OS 模块

os模块就是对操作系统进行操作，使用该模块必须先导入模块：

import os

getcwd() 获取当前工作目录(当前工作目录默认都是当前文件所在的文件夹)

result = os.getcwd()
print(result)

chdir()改变当前工作目录

os.chdir('/home/sy')
result = os.getcwd()
print(result)

操作时如果书写完整的路径则不需要考虑默认工作目录的问题,按照实际书写路径操作

open('/home/sy/下载/02.txt','w')

listdir() 获取指定文件夹中所有内容的名称列表

result = os.listdir('/home/sy')
print(result)

mkdir() 创建文件夹

os.mkdir('girls')
os.mkdir('boys',0o777)

makedirs() 递归创建文件夹

os.makedirs('/home/sy/a/b/c/d')

rmdir() 删除空目录

os.rmdir('girls')

removedirs 递归删除文件夹必须都是空目录

os.removedirs('/home/sy/a/b/c/d')

rename() 文件或文件夹重命名

os.rename('/home/sy/a','/home/sy/alibaba')
os.rename('02.txt','002.txt')

stat() 获取文件或者文件夹的信息

result = os.stat('/home/sy/PycharmProject/Python3/10.27/01.py)
print(result)

system() 执行系统命令(危险函数)

result = os.system('ls -al') #获取隐藏文件

环境变量

环境变量就是一些命令的集合
操作系统的环境变量就是操作系统在执行系统命令时搜索命令的目录的集合
getenv() 获取系统的环境变量
result = os.getenv('PATH')
print(result.split(':'))

pardir 表示上一层文件夹 ..表示上一层文件夹不可省略!

print(os.pardir)

导入os模块

import os

以下内容都是os.path子模块中的内容

abspath() 将相对路径转化为绝对路径

path = './boys'#相对
result = os.path.abspath(path)
print(result)

dirname() 获取完整路径当中的目录部分 & basename()获取完整路径当中的主体部分

path = '/home/sy/boys'
result = os.path.dirname(path)
print(result)
result = os.path.basename(path)
print(result)

split() 将一个完整的路径切割成目录部分和主体部分

path = '/home/sy/boys'
result = os.path.split(path)
print(result)

join() 将2个路径合并成一个

var1 = '/home/sy'
var2 = '000.py'
result = os.path.join(var1,var2)
print(result)

splitext() 将一个路径切割成文件后缀和其他两个部分,主要用于获取文件的后缀

path = '/home/sy/000.py'
result = os.path.splitext(path)
print(result)

getsize() 获取文件的大小

path = '/home/sy/000.py'
result = os.path.getsize(path)
print(result)

isfile() 检测是否是文件

path = '/home/sy/000.py'
result = os.path.isfile(path)
print(result)

isdir() 检测是否是文件夹

result = os.path.isdir(path)
print(result)

islink() 检测是否是链接

path = '/initrd.img.old'
result = os.path.islink(path)
print(result)

常用命令

os.walk() 生成目录树下的所有文件名
os.chdir('dirname') 改变目录
os.mkdir/makedirs('dirname')创建目录/多层目录
os.rmdir/removedirs('dirname') 删除目录/多层目录
os.listdir('dirname') 列出指定目录的文件
os.getcwd() 取得当前工作目录
os.chmod() 改变目录权限
os.path.basename(‘path/filename’) 去掉目录路径，返回文件名
os.path.dirname(‘path/filename’) 去掉文件名，返回目录路径
os.path.join(path1[,path2[,...]]) 将分离的各部分组合成一个路径名
os.path.split('path') 返回( dirname(), basename())元组
os.path.splitext() 返回 (filename, extension) 元组
os.path.getatime\ctime\mtime 分别返回最近访问、创建、修改时间
os.path.getsize() 返回文件大小
os.path.exists() 是否存在
os.path.isabs() 是否为绝对路径
os.path.isdir() 是否为目录
os.path.isfile() 是否为文件

sys 模块

sys.argv 命令行参数List，第一个元素是程序本身路径

time模块

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# __author__ = "TKQ"
import time
# 生成timestamp
time.time()
# 1477471508.05
#struct_time to timestamp
time.mktime(time.localtime())
#生成struct_time
# timestamp to struct_time 本地时间
time.localtime()
time.localtime(time.time())
# time.struct_time(tm_year=2016, tm_mon=10, tm_mday=26, tm_hour=16, tm_min=45, tm_sec=8, tm_wday=2, tm_yday=300, tm_isdst=0)
# timestamp to struct_time 格林威治时间
time.gmtime()
time.gmtime(time.time())
# time.struct_time(tm_year=2016, tm_mon=10, tm_mday=26, tm_hour=8, tm_min=45, tm_sec=8, tm_wday=2, tm_yday=300, tm_isdst=0)
#format_time to struct_time
time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X')
# time.struct_time(tm_year=2011, tm_mon=5, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=6, tm_wday=3, tm_yday=125, tm_isdst=-1)
#生成format_time
#struct_time to format_time
time.strftime("%Y-%m-%d %X")
time.strftime("%Y-%m-%d %X",time.localtime())
#生成固定格式的时间表示格式
time.asctime(time.localtime())
time.ctime(time.time())

randmon（获取随机数）

random.random random.random()用于生成一个0到1的随机符点数: 0 <= n < 1.0

random.uniform random.uniform(a, b)，用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限。如果a > b，则生成的随机数n: a <= n <= b。如果 a

代码如下:

print random.uniform(10, 20)
print random.uniform(20, 10)
18.7356606526
12.5798298022

random.randint random.randint(a, b)，用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b

代码如下:

print random.randint(12, 20)  # 生成的随机数 n: 12 <= n <= 20
print random.randint(20, 20)  # 结果永远是20     
# print random.randint(20, 10)  # 该语句是错误的。下限必须小于上限

random.randrange random.randrange([start], stop[, step])，从指定范围内，按指定基数递增的集合中获取一个随机数。如：random.randrange(10, 100, 2)，结果相当于从[10, 12, 14, 16, ... 96, 98]序列中获取一个随机数。random.randrange(10, 100, 2)在结果上与 random.choice(range(10, 100, 2) 等效

random.choice random.choice从序列中获取一个随机元素。其函数原型为：random.choice(sequence)。参数sequence表示一个有序类型。这里要说明一下：sequence在python不是一种特定的类型，而是泛指一系列的类型。list, tuple, 字符串都属于sequence。有关sequence可以查看python手册数据模型这一章。下面是使用choice的一些例子：

代码如下:

print random.choice("学习Python")
print random.choice(["JGood", "is", "a", "handsome", "boy"])
print random.choice(("Tuple", "List", "Dict"))

random.shuffle random.shuffle(x[, random])，用于将一个列表中的元素打乱。如:

代码如下:

p = ["Python", "is", "powerful", "simple", "and so on..."]
random.shuffle(p)
print p
# ['powerful', 'simple', 'is', 'Python', 'and so on...']

random.sample random.sample(sequence, k)，从指定序列中随机获取指定长度的片断。sample函数不会修改原有序列

代码如下:

list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
slice = random.sample(list, 5)  # 从list中随机获取5个元素，作为一个片断返回
print slice
print list  # 原有序列并没有改变

随机整数：

代码如下:

>>> import random
>>> random.randint(0,99)
# 21

随机选取0到100间的偶数：

代码如下:

>>> import random
>>> random.randrange(0, 101, 2)
# 42

随机浮点数：

代码如下:

>>> import random
>>> random.random()
0.85415370477785668
>>> random.uniform(1, 10)
# 5.4221167969800881

随机字符：

代码如下:

>>> import random
>>> random.choice('abcdefg&#%^*f')
# 'd'

多个字符中选取特定数量的字符：

代码如下:

>>> import random
random.sample('abcdefghij', 3)
# ['a', 'd', 'b']

多个字符中选取特定数量的字符组成新字符串：

代码如下:

>>> import random
>>> import string
>>> string.join( random.sample(['a','b','c','d','e','f','g','h','i','j'], 3) ).replace(" ","")
# 'fih'

随机选取字符串：

代码如下:

>>> import random
>>> random.choice ( ['apple', 'pear', 'peach', 'orange', 'lemon'] )
# 'lemon'

洗牌：

代码如下:

>>> import random
>>> items = [1, 2, 3, 4, 5, 6]
>>> random.shuffle(items)
>>> items
# [3, 2, 5, 6, 4, 1]

numpy模块

numpy元素的属性

numpy的所有值都有以下几个属性

A = np.arange(12).reshape(3, 4).astype(np.float32)

print(A.ndim)
print(A.shape)
print(A.size)
print(A.dtype)
print(A.itemsize)

# 输出结果为
# 2
# (3, 4)
# 12
# float32
# 4

A.ndim
数组轴的个数，在python的世界中，轴的个数被称作秩

A.shape
数组的维度。

A.size
数组元素的总个数。

A.dtype
元素的数据类型。

A.itemsize
数组中每个元素的字节大小。

生成数列

指定值的增量

data = np.arange(10, 30, 5)
print(data)  # [10 15 20 25]

指定值的个数

data = np.linspace(1, 10, 5)
print(data) # [  1\.     3.25   5.5    7.75  10\.  ]

生成矩阵

data = np.array([[2, 3, 4], [4, 5, 6]], dtype=np.float32)
print(data)
# [[ 2\.  3\.  4.]
#  [ 4\.  5\.  6.]]

生成全是0的矩阵

data = np.zeros((3, 4))
print(data)
# [[ 0\.  0\.  0\.  0.]
#  [ 0\.  0\.  0\.  0.]
#  [ 0\.  0\.  0\.  0.]]

生成全是1的矩阵

data = np.ones((3, 4))
print(data)
# [[ 1\.  1\.  1\.  1.]
#  [ 1\.  1\.  1\.  1.]
#  [ 1\.  1\.  1\.  1.]]

生成随机数据

随机生成0~1之间的数

data = np.random.random()
print(data) #0.01447623686510957

随机生成指定范围内的浮点数

data = np.random.uniform(10,20)
print(data)
# 14.646829941471552

随机整数

data = np.random.randint(10,20)
print(data)
# 17

随机生成一个矩阵

data = np.random.random((3,4))
print(data)
# [[ 0.77829489  0.63959774  0.83723733  0.95292845]
#  [ 0.78949057  0.38655045  0.79205805  0.06847395]
#  [ 0.5284635   0.95181041  0.39267602  0.23638718]]

多维矩阵

data = np.random.random((2,3,4))
print(data)
# [[[ 0.36605927  0.47719931  0.16654015  0.17585629]
#   [ 0.66085507  0.09883734  0.22603851  0.91388161]
#   [ 0.33416014  0.82187631  0.91063299  0.25781208]]
# 
#  [[ 0.56585862  0.09606677  0.84916434  0.26007262]
#   [ 0.16145394  0.61120144  0.75447741  0.40179179]
#   [ 0.55887648  0.45416114  0.17644248  0.43142769]]]

合并

A = np.array([1, 1, 1])
B = np.array([2, 2, 2])
#纵向合并
print(np.vstack((A, B)))
#横向合并
print(np.hstack((A, B)))
# [[1 1 1]
#  [2 2 2]]
#
# [1 1 1 2 2 2]

增加维度

添加一个横向的维度

A = np.array([1, 1, 1])
B = A[np.newaxis, :]
print(A.shape)
print(B.shape)
print(B)
# (3,)
# (1, 3)
# [[1 1 1]]

添加一个纵向的维度

A = np.array([1, 1, 1])
B = A[:,np.newaxis]
print(A.shape)
print(B.shape)
print(B)
# (3,)
# (3, 1)
# [[1]
#  [1]
#  [1]]

分割

A = np.arange(12).reshape(3, 4)
print(A)
#横向分割
print(np.vsplit(A, 3))
#纵向分割
print(np.hsplit(A, 2))
#可以在参数中指定分割哪个坐标
print(np.split(A, 3, axis=0))
print(np.split(A, 2, axis=1))
#不等量分割
print(np.array_split(A, 3, axis=1))

深层拷贝

在numpy中直接用"="号赋值,相当于赋予的是指针,赋值前后的"两个"变量是同"一个"变量.比如,下面的变量a,b,改变a,b也会跟着变化.

a = np.array([1, 2, 3])
b = a
a[0] = 666
print(a)
print(b)
#[666   2   3]
#[666   2   3]

如果想要两个变量不关联,需要这样拷贝

b = a.copy()

运算

numpy中矩阵的加法减法的运算和普通的加减运算相同,但是矩阵乘法的运算需要用dot函数,如下

A = np.array([[2, 3],
              [4, 7]])
B = np.array([[1, 2],
              [3, 4]])
print(A + B)
print(A - B)
print(np.dot(A, B))

# [[ 3  5]
#  [ 7 11]]
#
# [[1 1]
#  [1 3]]
#
# [[11 16]
#  [25 36]]

索引与切片

numpy中的索引与切片功能比python中的切片更加强大

索引多维数组

data = np.random.random((3,4,5))
print(data[0,2,3])

image

索引多维数组的时候也可以用切片

data = np.random.random((3,4,5))
print(data[1,:,3])
print(data[:2,:,3])

argparse模块

argparse是一个完整的参数处理库。参数可以根据add_argument()的action选项触发不同action。支持的action有存储参数（单个，或作为列表的一部分）;存储常量的值（对布尔开关true/false有特殊处理）。默认动作是存储参数值。支持type(指定存储类型)和dest(指定存储变量)等参数。

然后使用函数parse_args()进行参数解析，这个函数的输入默认是sys.argv[1:]，也可以使用其他字符串列表。选项使用GNU/POSIX语法处理，可以混合选项和参数值。parse_args的返回值是一个包含命令参数的Namespace。所有参数以属性的形式存在，比如args.myoption。

下面是一个简单的示例：argparse_short.py


import argparse

parser = argparse.ArgumentParser(description='Short sample app')

parser.add_argument('-a', action="store_true", default=False)
parser.add_argument('-b', action="store", dest="b")
parser.add_argument('-c', action="store", dest="c", type=int)

print(parser.parse_args(['-a', '-bval', '-c', '3']))

执行结果：


$ python3 argparse_short.py
Namespace(a=True, b='val', c=3)

长参数argparse_long.py


import argparse

parser = argparse.ArgumentParser(
    description='Example with long option names',
)

parser.add_argument('--noarg', action="store_true",
                    default=False)
parser.add_argument('--witharg', action="store",
                    dest="witharg")
parser.add_argument('--witharg2', action="store",
                    dest="witharg2", type=int)

print(
    parser.parse_args(
        ['--noarg', '--witharg', 'val', '--witharg2=3']
    )
)

执行结果


$ python3 argparse_long.py

Namespace(noarg=True, witharg='val', witharg2=3)

混合可选和必选参数：argparse_arguments.py


import argparse

parser = argparse.ArgumentParser(
    description='Example with nonoptional arguments',
)

parser.add_argument('count', action="store", type=int)
parser.add_argument('units', action="store")

print(parser.parse_args())

执行结果


$ python3 argparse_arguments.py 3 inches

Namespace(count=3, units='inches')

$ python3 argparse_arguments.py some inches

usage: argparse_arguments.py [-h] count units
argparse_arguments.py: error: argument count: invalid int value:
'some'

$ python3 argparse_arguments.py

usage: argparse_arguments.py [-h] count units
argparse_arguments.py: error: the following arguments are
required: count, units

参数action有：

store：默认action模式，存储值到指定变量。
store_const：存储值在参数的const部分指定，多用于实现非布尔的命令行flag。
store_true / store_false：布尔开关。可以2个参数对应一个变量。
append：存储值到列表，该参数可以重复使用。
append_const：存储值到列表，存储值在参数的const部分指定。
version 输出版本信息然后退出。

下面是各种action的示例：argparse_action.py


import argparse

parser = argparse.ArgumentParser()

parser.add_argument('-s', action='store',
                    dest='simple_value',
                    help='Store a simple value')

parser.add_argument('-c', action='store_const',
                    dest='constant_value',
                    const='value-to-store',
                    help='Store a constant value')

parser.add_argument('-t', action='store_true',
                    default=False,
                    dest='boolean_t',
                    help='Set a switch to true')
parser.add_argument('-f', action='store_false',
                    default=True,
                    dest='boolean_f',
                    help='Set a switch to false')

parser.add_argument('-a', action='append',
                    dest='collection',
                    default=[],
                    help='Add repeated values to a list')

parser.add_argument('-A', action='append_const',
                    dest='const_collection',
                    const='value-1-to-append',
                    default=[],
                    help='Add different values to list')
parser.add_argument('-B', action='append_const',
                    dest='const_collection',
                    const='value-2-to-append',
                    help='Add different values to list')

parser.add_argument('--version', action='version',
                    version='%(prog)s 1.0')

results = parser.parse_args()
print('simple_value     = {!r}'.format(results.simple_value))
print('constant_value   = {!r}'.format(results.constant_value))
print('boolean_t        = {!r}'.format(results.boolean_t))
print('boolean_f        = {!r}'.format(results.boolean_f))
print('collection       = {!r}'.format(results.collection))
print('const_collection = {!r}'.format(results.const_collection))

执行结果如下，注意'simple_value'等被自动化转化为大写


$ python3 argparse_action.py -h

usage: argparse_action.py [-h] [-s SIMPLE_VALUE] [-c] [-t] [-f]
                          [-a COLLECTION] [-A] [-B] [--version]

optional arguments:
  -h, --help       show this help message and exit
  -s SIMPLE_VALUE  Store a simple value
  -c               Store a constant value
  -t               Set a switch to true
  -f               Set a switch to false
  -a COLLECTION    Add repeated values to a list
  -A               Add different values to list
  -B               Add different values to list
  --version        show program's version number and exit

$ python3 argparse_action.py -s value

simple_value     = 'value'
constant_value   = None
boolean_t        = False
boolean_f        = True
collection       = []
const_collection = []

$ python3 argparse_action.py -c

simple_value     = None
constant_value   = 'value-to-store'
boolean_t        = False
boolean_f        = True
collection       = []
const_collection = []

$ python3 argparse_action.py -t

simple_value     = None
constant_value   = None
boolean_t        = True
boolean_f        = True
collection       = []
const_collection = []

$ python3 argparse_action.py -f

simple_value     = None
constant_value   = None
boolean_t        = False
boolean_f        = False
collection       = []
const_collection = []

$ python3 argparse_action.py -a one -a two -a three

simple_value     = None
constant_value   = None
boolean_t        = False
boolean_f        = True
collection       = ['one', 'two', 'three']
const_collection = []

$ python3 argparse_action.py -B -A

simple_value     = None
constant_value   = None
boolean_t        = False
boolean_f        = True
collection       = []
const_collection = ['value-2-to-append', 'value-1-to-append']

$ python3 argparse_action.py --version

argparse_action.py 1.0

可选前缀

ArgumentParser函数中的选项prefix_chars可以指定前缀。默认使用UNIX风格，命令行使用‘-’作为前缀。可以使用windows的’/’或者其他符号。

argparse_prefix_chars.py


import argparse

parser = argparse.ArgumentParser(
    description='Change the option prefix characters',
    prefix_chars='-+/',
)

parser.add_argument('-a', action="store_false",
                    default=None,
                    help='Turn A off',
                    )
parser.add_argument('+a', action="store_true",
                    default=None,
                    help='Turn A on',
                    )
parser.add_argument('//noarg', '++noarg',
                    action="store_true",
                    default=False)

print(parser.parse_args())

执行结果


$ python3 argparse_prefix_chars.py -h

usage: argparse_prefix_chars.py [-h] [-a] [+a] [//noarg]

Change the option prefix characters

optional arguments:
  -h, --help        show this help message and exit
  -a                Turn A off
  +a                Turn A on
  //noarg, ++noarg

$ python3 argparse_prefix_chars.py +a

Namespace(a=True, noarg=False)

$ python3 argparse_prefix_chars.py -a

Namespace(a=False, noarg=False)

$ python3 argparse_prefix_chars.py //noarg

Namespace(a=None, noarg=True)

$ python3 argparse_prefix_chars.py ++noarg

Namespace(a=None, noarg=True)

$ python3 argparse_prefix_chars.py --noarg

usage: argparse_prefix_chars.py [-h] [-a] [+a] [//noarg]
argparse_prefix_chars.py: error: unrecognized arguments: --noarg

处理配置文件中的参数

argparse_with_shlex.py


import argparse
from configparser import ConfigParser
import shlex

parser = argparse.ArgumentParser(description='Short sample app')

parser.add_argument('-a', action="store_true", default=False)
parser.add_argument('-b', action="store", dest="b")
parser.add_argument('-c', action="store", dest="c", type=int)

config = ConfigParser()
config.read('argparse_with_shlex.ini')
config_value = config.get('cli', 'options')
print('Config  :', config_value)

argument_list = shlex.split(config_value)
print('Arg List:', argument_list)

print('Results :', parser.parse_args(argument_list))

其中argparse_with_shlex.ini文件的内容如下：


[cli]
options = -a -b 2

执行结果


$ python3 argparse_with_shlex.py

Config  : -a -b 2
Arg List: ['-a', '-b', '2']
Results : Namespace(a=True, b='2', c=None)

上面例子使用了ConfigParser来读取配置，再用shlex来切割参数。也可以通过fromfile_prefix_chars 告知argparse输入参数为文件。

argparse_fromfile_prefix_chars.py


import argparse
import shlex

parser = argparse.ArgumentParser(description='Short sample app',
                                 fromfile_prefix_chars='@',
                                 )

parser.add_argument('-a', action="store_true", default=False)
parser.add_argument('-b', action="store", dest="b")
parser.add_argument('-c', action="store", dest="c", type=int)

print(parser.parse_args(['@argparse_fromfile_prefix_chars.txt']))

argparse_fromfile_prefix_chars.txt


-a
-b
2

执行结果


$ python3 argparse_fromfile_prefix_chars.py

Namespace(a=True, b='2', c=None)

帮助

自动生成

Argparse会自动生成的帮助和版本信息。ArgumentParser的add_help参数控制帮助的生成，默认是开启。

argparse_with_help.py


import argparse

parser = argparse.ArgumentParser(add_help=True)

parser.add_argument('-a', action="store_true", default=False)
parser.add_argument('-b', action="store", dest="b")
parser.add_argument('-c', action="store", dest="c", type=int)

print(parser.parse_args())

下例就关闭帮助：

argparse_without_help.py


import argparse

parser = argparse.ArgumentParser(add_help=False)

parser.add_argument('-a', action="store_true", default=False)
parser.add_argument('-b', action="store", dest="b")
parser.add_argument('-c', action="store", dest="c", type=int)

print(parser.parse_args())

执行结果


$ python argparse_with_help.py -h
usage: argparse_with_help.py [-h] [-a] [-b B] [-c C]
optional arguments:
-h, --help show this help message and exit
-a
-b B
-c C
$ python argparse_without_help.py -h
usage: argparse_without_help.py [-a] [-b B] [-c C]
argparse_without_help.py: error: unrecognized arguments: -h

自定义帮助

argparse_custom_help.py


import argparse

parser = argparse.ArgumentParser(add_help=True)

parser.add_argument('-a', action="store_true", default=False)
parser.add_argument('-b', action="store", dest="b")
parser.add_argument('-c', action="store", dest="c", type=int)

print('print_usage output:')
parser.print_usage()
print()

print('print_help output:')
parser.print_help()

执行结果


$ python3 argparse_custom_help.py

print_usage output:
usage: argparse_custom_help.py [-h] [-a] [-b B] [-c C]

print_help output:
usage: argparse_custom_help.py [-h] [-a] [-b B] [-c C]

optional arguments:
  -h, --help  show this help message and exit
  -a
  -b B
  -c C

argparse_raw_description_help_formatter.py


import argparse

parser = argparse.ArgumentParser(
    add_help=True,
    formatter_class=argparse.RawDescriptionHelpFormatter,
    description="""
    description
        not
           wrapped""",
    epilog="""
    epilog
      not
         wrapped""",
)

parser.add_argument(
    '-a', action="store_true",
    help="""argument
    help is
    wrapped
    """,
)

parser.print_help()

执行结果


$ python3 argparse_raw_description_help_formatter.py

usage: argparse_raw_description_help_formatter.py [-h] [-a]

    description
        not
           wrapped

optional arguments:
  -h, --help  show this help message and exit
  -a          argument help is wrapped

    epilog
      not
         wrapped

argparse_raw_text_help_formatter.py


import argparse

parser = argparse.ArgumentParser(
    add_help=True,
    formatter_class=argparse.RawTextHelpFormatter,
    description="""
    description
        not
           wrapped""",
    epilog="""
    epilog
      not
         wrapped""",
)

parser.add_argument(
    '-a', action="store_true",
    help="""argument
    help is not
    wrapped
    """,
)

parser.print_help()

执行结果


$ python3 argparse_raw_text_help_formatter.py

usage: argparse_raw_text_help_formatter.py [-h] [-a]

    description
        not
           wrapped

optional arguments:
  -h, --help  show this help message and exit
  -a          argument
                  help is not
                  wrapped

    epilog
      not
         wrapped

argparse_metavar_type_help_formatter.py


import argparse

parser = argparse.ArgumentParser(
    add_help=True,
    formatter_class=argparse.MetavarTypeHelpFormatter,
)

parser.add_argument('-i', type=int, dest='notshown1')
parser.add_argument('-f', type=float, dest='notshown2')

parser.print_help()

执行结果


$ python3 argparse_metavar_type_help_formatter.py

usage: argparse_metavar_type_help_formatter.py [-h] [-i int] [-f
 float]

optional arguments:
  -h, --help  show this help message and exit
  -i int
  -f float

组织解析器

公共解析器:通过父子类来实现。

见argparse_parent_base.py：


import argparse

parser = argparse.ArgumentParser(add_help=False)

parser.add_argument('--user', action="store")
parser.add_argument('--password', action="store")

argparse_uses_parent.py


import argparse
import argparse_parent_base

parser = argparse.ArgumentParser(
    parents=[argparse_parent_base.parser],
)

parser.add_argument('--local-arg',
                    action="store_true",
                    default=False)

print(parser.parse_args())

注意：父类关闭了help。子类却默认开启了help。执行结果：


$ python3 argparse_uses_parent.py -h

usage: argparse_uses_parent.py [-h] [--user USER]
                               [--password PASSWORD]
                               [--local-arg]

optional arguments:
  -h, --help           show this help message and exit
  --user USER
  --password PASSWORD
  --local-arg

参数冲突

argparse_conflict_handler_resolve.py


import argparse

parser = argparse.ArgumentParser(conflict_handler='resolve')

parser.add_argument('-a', action="store")
parser.add_argument('-b', action="store", help='Short alone')
parser.add_argument('--long-b', '-b',
                    action="store",
                    help='Long and short together')

print(parser.parse_args(['-h']))

执行结果


$ python3 argparse_conflict_handler_resolve.py

usage: argparse_conflict_handler_resolve.py [-h] [-a A]
[--long-b LONG_B]

optional arguments:
  -h, --help            show this help message and exit
  -a A
  --long-b LONG_B, -b LONG_B
                        Long and short together

argparse_conflict_handler_resolve2.py、


import argparse

parser = argparse.ArgumentParser(conflict_handler='resolve')

parser.add_argument('-a', action="store")
parser.add_argument('--long-b', '-b',
                    action="store",
                    help='Long and short together')
parser.add_argument('-b', action="store", help='Short alone')

print(parser.parse_args(['-h']))

执行结果


$ python3 argparse_conflict_handler_resolve2.py

usage: argparse_conflict_handler_resolve2.py [-h] [-a A]
                                             [--long-b LONG_B]
                                             [-b B]

optional arguments:
  -h, --help       show this help message and exit
  -a A
  --long-b LONG_B  Long and short together
  -b B             Short alone

参数分组

默认有可选参数和必选参数组。

argparse_default_grouping.py


import argparse

parser = argparse.ArgumentParser(description='Short sample app')

parser.add_argument('--optional', action="store_true",
                    default=False)
parser.add_argument('positional', action="store")

print(parser.parse_args())

执行结果


$ python3 argparse_default_grouping.py -h

usage: argparse_default_grouping.py [-h] [--optional] positional

Short sample app

positional arguments:
  positional

optional arguments:
  -h, --help  show this help message and exit
  --optional

前面的用户名和密码就可以分组：

argparse_parent_with_group.py


import argparse

parser = argparse.ArgumentParser(add_help=False)

group = parser.add_argument_group('authentication')

group.add_argument('--user', action="store")
group.add_argument('--password', action="store")

argparse_uses_parent_with_group.py


import argparse
import argparse_parent_with_group

parser = argparse.ArgumentParser(
    parents=[argparse_parent_with_group.parser],
)

parser.add_argument('--local-arg',
                    action="store_true",
                    default=False)

print(parser.parse_args())

执行结果


$ python3 argparse_uses_parent_with_group.py -h

usage: argparse_uses_parent_with_group.py [-h] [--user USER]
                                          [--password PASSWORD]
                                          [--local-arg]

optional arguments:
  -h, --help           show this help message and exit
  --local-arg

authentication:
  --user USER
  --password PASSWORD

互斥选项

使用add_mutually_exclusive_group()可以添加互斥选项：

argparse_mutually_exclusive.py


import argparse

parser = argparse.ArgumentParser()

group = parser.add_mutually_exclusive_group()
group.add_argument('-a', action='store_true')
group.add_argument('-b', action='store_true')

print(parser.parse_args())

执行结果


$ python3 argparse_mutually_exclusive.py -h

usage: argparse_mutually_exclusive.py [-h] [-a | -b]

optional arguments:
  -h, --help  show this help message and exit
  -a
  -b

$ python3 argparse_mutually_exclusive.py -a

Namespace(a=True, b=False)

$ python3 argparse_mutually_exclusive.py -b

Namespace(a=False, b=True)

$ python3 argparse_mutually_exclusive.py -a -b

usage: argparse_mutually_exclusive.py [-h] [-a | -b]
argparse_mutually_exclusive.py: error: argument -b: not allowed
with argument -a

嵌套解析

argparse_subparsers.py


import argparse

parser = argparse.ArgumentParser()

subparsers = parser.add_subparsers(help='commands')

# A list command
list_parser = subparsers.add_parser(
    'list', help='List contents')
list_parser.add_argument(
    'dirname', action='store',
    help='Directory to list')

# A create command
create_parser = subparsers.add_parser(
    'create', help='Create a directory')
create_parser.add_argument(
    'dirname', action='store',
    help='New directory to create')
create_parser.add_argument(
    '--read-only', default=False, action='store_true',
    help='Set permissions to prevent writing to the directory',
)

# A delete command
delete_parser = subparsers.add_parser(
    'delete', help='Remove a directory')
delete_parser.add_argument(
    'dirname', action='store', help='The directory to remove')
delete_parser.add_argument(
    '--recursive', '-r', default=False, action='store_true',
    help='Remove the contents of the directory, too',
)

print(parser.parse_args())

执行结果


$ python3 argparse_subparsers.py -h

usage: argparse_subparsers.py [-h] {list,create,delete} ...

positional arguments:
  {list,create,delete}  commands
    list                List contents
    create              Create a directory
    delete              Remove a directory

optional arguments:
  -h, --help            show this help message and exit

$ python3 argparse_subparsers.py create -h

usage: argparse_subparsers.py create [-h] [--read-only] dirname

positional arguments:
  dirname      New directory to create

optional arguments:
  -h, --help   show this help message and exit
  --read-only  Set permissions to prevent writing to the directo
ry

$ python3 argparse_subparsers.py delete -r foo

Namespace(dirname='foo', recursive=True)

高级参数处理

可变参数：数字N代表N的参数，？0或者1个参数。*0或者多个参数。+1或者多个参数。

argparse_nargs.py


import argparse

parser = argparse.ArgumentParser()

parser.add_argument('--three', nargs=3)
parser.add_argument('--optional', nargs='?')
parser.add_argument('--all', nargs='*', dest='all')
parser.add_argument('--one-or-more', nargs='+')

print(parser.parse_args())

执行结果


$ python3 argparse_nargs.py -h

usage: argparse_nargs.py [-h] [--three THREE THREE THREE]
                [--optional [OPTIONAL]]
                [--all [ALL [ALL ...]]]
                [--one-or-more ONE_OR_MORE [ONE_OR_MORE ...]]

optional arguments:
  -h, --help            show this help message and exit
  --three THREE THREE THREE
  --optional [OPTIONAL]
  --all [ALL [ALL ...]]
  --one-or-more ONE_OR_MORE [ONE_OR_MORE ...]

$ python3 argparse_nargs.py

Namespace(all=None, one_or_more=None, optional=None, three=None)

$ python3 argparse_nargs.py --three

usage: argparse_nargs.py [-h] [--three THREE THREE THREE]
                [--optional [OPTIONAL]]
                [--all [ALL [ALL ...]]]
                [--one-or-more ONE_OR_MORE [ONE_OR_MORE ...]]
argparse_nargs.py: error: argument --three: expected 3
argument(s)

$ python3 argparse_nargs.py --three a b c

Namespace(all=None, one_or_more=None, optional=None,
three=['a', 'b', 'c'])

$ python3 argparse_nargs.py --optional

Namespace(all=None, one_or_more=None, optional=None, three=None)

$ python3 argparse_nargs.py --optional with_value

Namespace(all=None, one_or_more=None, optional='with_value',
three=None)

$ python3 argparse_nargs.py --all with multiple values

Namespace(all=['with', 'multiple', 'values'], one_or_more=None,
optional=None, three=None)

$ python3 argparse_nargs.py --one-or-more with_value

Namespace(all=None, one_or_more=['with_value'], optional=None,
three=None)

$ python3 argparse_nargs.py --one-or-more with multiple values

Namespace(all=None, one_or_more=['with', 'multiple', 'values'],
optional=None, three=None)

$ python3 argparse_nargs.py --one-or-more

usage: argparse_nargs.py [-h] [--three THREE THREE THREE]
                [--optional [OPTIONAL]]
                [--all [ALL [ALL ...]]]
                [--one-or-more ONE_OR_MORE [ONE_OR_MORE ...]]
argparse_nargs.py: error: argument --one-or-more: expected
at least one argument

参数类型

argparse_type.py


import argparse

parser = argparse.ArgumentParser()

parser.add_argument('-i', type=int)
parser.add_argument('-f', type=float)
parser.add_argument('--file', type=open)

try:
    print(parser.parse_args())

except IOError as msg:
    parser.error(str(msg))

执行结果


$ python3 argparse_type.py -i 1

Namespace(f=None, file=None, i=1)

$ python3 argparse_type.py -f 3.14

Namespace(f=3.14, file=None, i=None)

$ python3 argparse_type.py --file argparse_type.py

Namespace(f=None, file=<_io.TextIOWrapper
name='argparse_type.py' mode='r' encoding='UTF-8'>, i=None)

$ python3 argparse_type.py -i a

usage: argparse_type.py [-h] [-i I] [-f F] [--file FILE]
argparse_type.py: error: argument -i: invalid int value: 'a'

$ python3 argparse_type.py -f 3.14.15

usage: argparse_type.py [-h] [-i I] [-f F] [--file FILE]
argparse_type.py: error: argument -f: invalid float value:
'3.14.15'

$ python3 argparse_type.py --file does_not_exist.txt

usage: argparse_type.py [-h] [-i I] [-f F] [--file FILE]
argparse_type.py: error: [Errno 2] No such file or directory:
'does_not_exist.txt'

Choices可以指定参数的选项：

argparse_choices.py


import argparse

parser = argparse.ArgumentParser()

parser.add_argument(
    '--mode',
    choices=('read-only', 'read-write'),
)

print(parser.parse_args())

执行结果


$ python3 argparse_choices.py -h

usage: argparse_choices.py [-h] [--mode {read-only,read-write}]

optional arguments:
  -h, --help            show this help message and exit
  --mode {read-only,read-write}

$ python3 argparse_choices.py --mode read-only

Namespace(mode='read-only')

$ python3 argparse_choices.py --mode invalid

usage: argparse_choices.py [-h] [--mode {read-only,read-write}]
argparse_choices.py: error: argument --mode: invalid choice:
'invalid' (choose from 'read-only', 'read-write')

文件参数

argparse_FileType.py


import argparse

parser = argparse.ArgumentParser()

parser.add_argument('-i', metavar='in-file',
                    type=argparse.FileType('rt'))
parser.add_argument('-o', metavar='out-file',
                    type=argparse.FileType('wt'))

try:
    results = parser.parse_args()
    print('Input file:', results.i)
    print('Output file:', results.o)
except IOError as msg:
    parser.error(str(msg))

执行结果


$ python3 argparse_FileType.py -h

usage: argparse_FileType.py [-h] [-i in-file] [-o out-file]

optional arguments:
  -h, --help   show this help message and exit
  -i in-file
  -o out-file

$ python3 argparse_FileType.py -i argparse_FileType.py -o tmp_\
file.txt

Input file: <_io.TextIOWrapper name='argparse_FileType.py'
mode='rt' encoding='UTF-8'>
Output file: <_io.TextIOWrapper name='tmp_file.txt' mode='wt'
encoding='UTF-8'>

$ python3 argparse_FileType.py -i no_such_file.txt

usage: argparse_FileType.py [-h] [-i in-file] [-o out-file]
argparse_FileType.py: error: argument -i: can't open
'no_such_file.txt': [Errno 2] No such file or directory:
'no_such_file.txt'

自定义action

自定义action是argparse.Action的子类可以处理add_argument中的参数定义相关的参数，并返回一个可调用对象。构造函数会处理参数定义，仅仅需要处理call函数。call函数中parser代表解释器，namespace用于返回解释结果，value为要处理的参数，option_string用于触发action（对可选参数，永远是None。

argparse_custom_action.py


import argparse

class CustomAction(argparse.Action):
    def __init__(self,
                 option_strings,
                 dest,
                 nargs=None,
                 const=None,
                 default=None,
                 type=None,
                 choices=None,
                 required=False,
                 help=None,
                 metavar=None):
        argparse.Action.__init__(self,
                                 option_strings=option_strings,
                                 dest=dest,
                                 nargs=nargs,
                                 const=const,
                                 default=default,
                                 type=type,
                                 choices=choices,
                                 required=required,
                                 help=help,
                                 metavar=metavar,
                                 )
        print('Initializing CustomAction')
        for name, value in sorted(locals().items()):
            if name == 'self' or value is None:
                continue
            print('  {} = {!r}'.format(name, value))
        print()
        return

    def __call__(self, parser, namespace, values,
                 option_string=None):
        print('Processing CustomAction for {}'.format(self.dest))
        print('  parser = {}'.format(id(parser)))
        print('  values = {!r}'.format(values))
        print('  option_string = {!r}'.format(option_string))

        # Do some arbitrary processing of the input values
        if isinstance(values, list):
            values = [v.upper() for v in values]
        else:
            values = values.upper()
        # Save the results in the namespace using the destination
        # variable given to our constructor.
        setattr(namespace, self.dest, values)
        print()

parser = argparse.ArgumentParser()

parser.add_argument('-a', action=CustomAction)
parser.add_argument('-m', nargs='*', action=CustomAction)

results = parser.parse_args(['-a', 'value',
                             '-m', 'multivalue',
                             'second'])
print(results)

执行结果


$ python3 argparse_custom_action.py

Initializing CustomAction
  dest = 'a'
  option_strings = ['-a']
  required = False

Initializing CustomAction
  dest = 'm'
  nargs = '*'
  option_strings = ['-m']
  required = False

Processing CustomAction for a
  parser = 4315836992
  values = 'value'
  option_string = '-a'

Processing CustomAction for m
  parser = 4315836992
  values = ['multivalue', 'second']
  option_string = '-m'

Namespace(a='VALUE', m=['MULTIVALUE', 'SECOND'])

当然，还有其他的常用模块，比如numpy,pandas等，欢迎各位道友补充

python常用模块

OS 模块

os模块就是对操作系统进行操作，使用该模块必须先导入模块：

getcwd() 获取当前工作目录(当前工作目录默认都是当前文件所在的文件夹)

chdir()改变当前工作目录

操作时如果书写完整的路径则不需要考虑默认工作目录的问题,按照实际书写路径操作

listdir() 获取指定文件夹中所有内容的名称列表

mkdir() 创建文件夹

makedirs() 递归创建文件夹

rmdir() 删除空目录

removedirs 递归删除文件夹 必须都是空目录

rename() 文件或文件夹重命名

stat() 获取文件或者文件夹的信息

system() 执行系统命令(危险函数)

环境变量

pardir 表示上一层文件夹 ..表示上一层文件夹 不可省略!

导入os模块

以下内容都是os.path子模块中的内容

abspath() 将相对路径转化为绝对路径

dirname() 获取完整路径当中的目录部分 & basename()获取完整路径当中的主体部分

split() 将一个完整的路径切割成目录部分和主体部分

join() 将2个路径合并成一个

splitext() 将一个路径切割成文件后缀和其他两个部分,主要用于获取文件的后缀

getsize() 获取文件的大小

isfile() 检测是否是文件

isdir() 检测是否是文件夹

islink() 检测是否是链接

常用命令

sys 模块

sys.argv 命令行参数List，第一个元素是程序本身路径

time模块

randmon（获取随机数）

numpy模块

numpy元素的属性

生成数列

生成矩阵

生成随机数据

合并

增加维度

分割

深层拷贝

运算

索引与切片

argparse模块

可选前缀

处理配置文件中的参数

帮助

组织解析器

参数冲突

参数分组

互斥选项

嵌套解析

高级参数处理

参数类型

文件参数

自定义action

你可能感兴趣的:(python常用模块)

removedirs 递归删除文件夹必须都是空目录

pardir 表示上一层文件夹 ..表示上一层文件夹不可省略!