python导入自然对数e

1. __name__

__name__属于Python中的内置类属性，代表对应程序名称。如果当前运行的程序是主程序，此时__name__的值就是__main__，反之，则是对应的模块名。以一个例子来说明：

创建first_module.py文件，文件内容及运行first_module.py文件的结果如下所示：

print("first_module's __name__:", __name__)

# 运行结果
# first_module's __name__: __main__

接着，创建second_module.py文件，在该文件中导入first_module.py文件，文件内容及运行second_module.py文件的结果如下所示:

import first_module

# 运行结果
# first_module's __name__: first_module

当运行first_module.py文件时，此时__name__的值为__main__，即代表主程序。而当运行second_module.py时，此时打印出的__name__为first_module，即对应module的name。

ⅰ. 使用场景

多用于模块自身的调试。比如，修改first_module.py文件，增加函数first_module_func，然后运行first_module.py文件，此时的运行结果如下，可以看到此时由于__name__的取值为__main__，所以会运行if语句中调用的函数的内容。

print("first_module's __name__:", __name__)

def first_module_func(a, b):
    print("a+b=", a+b)

if __name__ == '__main__':
    first_module_func(1, 2)

# 运行结果
# first_module's __name__: __main__
# a+b= 3

接着，运行second_module.py文件，文件内容和运行结果如下，即由于此时的first_module.py文件中__name__不等于__main__，所以不会执行first_module_func函数。

import first_module

# 运行结果
# first_module's __name__: first_module

因此，当我们在调试first_module.py文件中的一些函数时，可以通过这种方式来运行需要调试的函数，比如上面定义的first_module_func函数。此时调试通过之后也不需要删除调试的代码，其他模块引用时不会执行调试代码，从而输出一些无用信息。

2. 语法

标识符:

标识符的第一个字母必须是字母表中字母或下划线 '_'，标识符的其他部分由字母、数字和下划线组成

python保留字

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', '__peg_parser__', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

注释

#这是单行注释

"""
这是多行注释
这是多行注释
"""
'''
也可以用三个单引号来进行多行注释
'''

基本数据类型

Python3 的六个标准数据类型中：

不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；

可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

可变数据和不可变数据的“变”是相对于引用地址来说的，不是不能改变其数据，而是改变数据的时候会不会改变变量的引用地址。

切片

# 要取得一段子串的话，可以用到变量[头下标:尾下标]，就可以截取相应的字符串
str="qwertyuiop"
print(str[0:5])
包左不包右
#qwert

类型判断

python可以用type函数来检查一个变量的类型

type(name)

列表

列表list可以完成大多数集合类的数据结构实现，支持字符、数字、字符串甚至可以包含列表（也就是嵌套）

列表用 []标识。是Python最通用的复合数据类型

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']
 
print list # 输出完整列表
print list[0] # 输出列表的第一个元素
print list[1:3] # 输出第二个至第三个的元素 
print list[2:] # 输出从第三个开始至列表末尾的所有元素
print tinylist * 2 # 输出列表两次
print list + tinylist # 打印组合的列表

元组

元组Tuple是另一个数据类型，类似于List(列表)

元组用"()"标识。内部元素用逗号隔开。但是元素不能二次赋值，相当于只读列表

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2 )
tinytuple = (123, 'john')
 
print tuple # 输出完整元组
print tuple[0] # 输出元组的第一个元素
print tuple[1:3] # 输出第二个至第三个的元素 
print tuple[2:] # 输出从第三个开始至列表末尾的所有元素
print tinytuple * 2 # 输出元组两次
print tuple + tinytuple # 打印组合的元组

字典

字典是除列表以外Python 之中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。两者的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典用‘{}’标识。字典由索引key和它对应的值value组成

dict = {}
dict['one'] = "This is one"
dict[2] = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}
 
print dict['one'] # 输出键为'one' 的值
print dict[2] # 输出键为 2 的值
print tinydict # 输出完整的字典
print tinydict.keys() # 输出所有键
print tinydict.values() # 输出所有值

以字典（dict）为例，它包含多个函数供我们使用，例如使用 keys() 获取字典中所有的键，使用 values() 获取字典中所有的值，使用 item() 获取字典中所有的键值对。

数据类型转换

对数据内置的类型进行转换，只需要将数据类型作为函数名即可。

int(x)	转成整数
long(x)	将x转成一个长整数
float(x)	将x转成一个浮点数
str(x)	将对象x转换成字符串
repr(x)	将对象x转换为表达式字符串

输入输出流

input函数作为输出流，print函数作为输入流

name=input()
print(name)

变量

变量是存储在内存中的值。就是指针无关数据类型，解释器会分配指定大小的内存。

# 等号（=）用来给变量赋值
counter = 100 # 赋值整型变量
miles = 1000.0 # 浮点型
name = "John" # 字符串

# 多个对象指定多个变量
a, b, c = 1, 2, "john"

文本换行

使用+ \起到多行连接的作用：

data="this  " + \
    "is  " + \
    "Tuesday"
print(data)
#this  is  Tuesday

# 空格也会被视为字符

字符串运行算回切片获取

自定义函数

def 函数名(参数列表):
    //实现特定功能的多行代码
    [return [返回值]]

匿名函数

对于定义一个简单的函数，Python 还提供了另外一种方法，lambda 表达式，又称匿名函数，常用来表示内部仅包含 1 行表达式的函数。如果一个函数的函数体仅有 1 行表达式，则该函数就可以用 lambda 表达式来代替。

name = lambda [list] : 表达式

def name(list):
    return 表达式
name(list)

类

class 类名：

多个（≥0）类属性...

多个（≥0）类方法...

构造方法

在创建类时，我们可以手动添加一个__init__() 方法，该方法是一个特殊的类实例方法，称为构造方法（或构造函数）

def __init__(self,...):
    代码块

类的构造方法最少也要有一个 self 参数。self 所表示的都是实际调用该方法的对象。无论是类中的构造函数还是普通的类方法，实际调用它们的谁，则第一个参数 self 就代表谁。相当于Java的this。

类的实例化
创建类对象的过程，又称为类的实例化。类名(参数)。

定义的类只有进行实例化后，才能得到利用。实例化后的类对象可以执行以下操作：

class Dog:
    def __init__(self, name, breed, age):
        self.name = name
        self.breed = breed
        self.age = age

my_dog = Dog('Buddy', 'Golden Retriever', 6)

公有属性：指没有加前缀双下划线__的属性，可以在类内外被访问，也可以被继承和重写。

私有属性：指加了前缀双下划线__的属性，只能在类内被访问和修改，而在类外部无法访问或修改。

实例属性：指定义在 __init__ 方法中，以 self.属性名 的形式定义的属性，每个实例都独立拥有一个自己的实例属性，它们随实例创建和销毁。

静态属性：指在类下直接定义的属性，可以使用类名直接访问，它们是类的属性，每个实例都共享一个静态属性。

class revealAccess:
    def __init__(self, initval = None, name = 'var'):
        self.val = initval
        self.name = name
    def __get__(self, obj, objtype):
        print("Retrieving",self.name)
        return self.val
    def __set__(self, obj, val):
        print("updating",self.name)
        self.val = val

IO处理

Python 提供了内置的文件对象，以及对文件、目录进行操作的内置模块，通过这些技术可以很方便地将数据保存到文件（如文本文件等）中。

在 Windows 上，路径书写使用反斜杠 “” 作为文件夹之间的分隔符，但在 OS X 和 Linux 上，使用正斜杠 “/” 作为它们的路径分隔符。需要两个第一个是转义字符。

对文件的系统级操作功能单一，比较容易实现，可以借助 Python 中的专用模块（os、sys 等），并调用模块中的指定函数来实现。

import os
os.remove("a.txt")

打开文件：使用 open() 函数，该函数会返回一个文件对象；

对已打开文件做读/写操作：读取文件内容可使用read()、readline() 以及 readlines()函数；向文件中写入内容，可以使用 write() 函数。

关闭文件：完成对文件的读/写操作之后，最后需要关闭文件，可以使用close()函数。

如果想要操作文件，首先需要创建或者打开指定的文件，并创建一个文件对象，而这些工作可以通过内置的 open()函数实现:

file = open(file_name [, mode='r' [ , buffering=-1 [ , encoding = None ]]])

3. OS

a. 绝对路径三种表达方式

单斜杠 /

双反斜杠 \\

在路路径前加上字母 r

b. os.getcwd()

获取当前文件所在的路径

import os
print(os.getcwd())

c. os.chdir(path)

更改当前路径，更改后，默认路径为更改后的路径

os.chdir(r'D:\临时\python试验\pandas')
os.getcwd()

d. os.path.split(path) 将path分割成目录和文件名二元组返回

以路径最后一个'/'为分隔，分隔路径与文件名。若路径中无文件名，则输出路径与空文件名。

import os 
path = '/home/User/Desktop/file.txt'
head_tail = os.path.split(path) 
print("Head of '% s:'" % path, head_tail[0]) 
print("Tail of '% s:'" % path, head_tail[1], "\n") 
  
path = '/home/User/Desktop/'
head_tail = os.path.split(path) 
print("Head of '% s:'" % path, head_tail[0]) 
print("Tail of '% s:'" % path, head_tail[1], "\n") 

path = 'file.txt'
head_tail = os.path.split(path) 
print("Head of '% s:'" % path, head_tail[0]) 
print("Tail of '% s:'" % path, head_tail[1])

e. os.path.basename(p)

获取路径中的最后一个文件夹名字

print(os.path.basename(r'D:\临时\python试验\pandas'))
#pandas

注意，若传入的路径为文件，如 r'D:\临时\python试验\pandas\test.txt'，返回的结果是文件名 test.txt。

返回path的文件名，等同于os.path.split(path)[1]

f. os.path.dirname(p)

返回path的目录,相当于os.path.split(path)[0]

g. os.path.splitext(path)将路径的文件名{只是名称}和后缀名分开

import os
file_path = "D:/test/data_expand/192.168.1.70_01_20210901163745710_250_150_4...jpg"
filename,extension = os.path.splitext(file_path)
print("filename:",filename)   # D:/test/data_expand/192.168.1.70_01_20210901163745710_250_150_4..
print("extension:",extension) # .jpg

file_path ="D:/test/data_expand/"
filename,extension = os.path.splitext(file_path)
print("filename:",filename)         # D:/test/data_expand/
print("extension:",extension)       # 空文件后缀

h. os.path.join(path,*path)

拼接路径

p1 = r'D:\临时\python试验\pandas'
p2 = r'merge\test.txt'
print(os.path.join(p1,p2))

i. os.path.exists(path)

判断路径是否存在

print(os.path.exists(r'D:\临时\python试验\pandas'))
print(os.path.exists(r'D:\临时\python试验\pandas\3D图.csv'))
#true true

j. os.path.isdir(path, /) 、os.path.isfile(path)

前者判断是否为文件夹内 后者判断是否为文件

r1 = r'D:\临时\python试验\pandas'
r2 = r'D:\临时\python试验\pandas\merge\test.txt'
 
print(os.path.isdir(r1))
print(os.path.isfile(r2))

k. os.listdir(path)

输出path路径下所有的文件及文件夹 不遍历下层

l. os.walk(top, topdown=True, οnerrοr=None, followlinks=False)

循环遍历top路径下所有文件 该路径下层的文件及文件夹

top：路径，顶层路径

topdown：可以理解为加快速度，不用管，默认为True

onerror：当有错误时，可以用定义的函数去输出错误

followlinks：默认为False，意义不大

该函数必须传入路径，返回3个变量值。第一个为文件夹绝对路径，第二个为子文件夹的列表，第三个为根目录下所有文件的列表。先看第一个 (i)：

for (i,j,k) in os.walk(r'D:\临时\python试验\pandas'):
    print(i)

i 得到的是该路径下所有文件夹的绝对路径

j 得到的是对应 i 路径下含有的文件夹，每个 i 的路径输出一个列表。['merge']的由来是因为 D:\临时\python试验\pandas下有个merge文件；[]的由来是因为 D:\临时\python试验\pandas\merge下没有文件夹了。

k 得到的是对应 i 路径下含有的文件，每个 i 的路径输出一个列表。这里输出的两个列表的由来，和 j 一样，就不一一解释了。

m. os.scandir(path = none)

加快迭代速度，把需要迭代的内容放在一个迭代对象里，而不是像os.listdir()一样把结果存在列表中（放在列表占用大量内存）

可见返回的是一个可迭代对象，作用是减少内存占用，加快运行速度。除此之外，它还可以访问文件的各种属性。如获取文件/文件夹名，文件/文件夹绝对路径，是否为文件夹，是否为文件，以及属性。

根据属性，还可以提取文件的大小(单位为kb，文件夹大小为0kb)、最近访问时间、最近修改时间、window系统下的创建时间、linux系统下的创建时间等。这里以文件大小 .st_size为例

文件大小 .st_size

最近访问时间 .st_atime

最近修改时间 .st_mtime

window系统下的创建时间 .st_ctime

linux系统下的创建时间 .st_birthtime

for i in os.scandir(r'D:\临时\python试验\pandas'):

print(i.name,i.stat().st_size,'kb')

使用os.scandir()方法，它可以列出指定目录下的所有文件夹和文件

n. os.stat(path, *, dir_fd=None, follow_symlinks=True)

获得文件的属性。能获得的属性与上面一样，不再重复。

o. os.mkdir(path, mode=511, *, dir_fd=None)

创建路径，只能创建一层

p. os.makedirs(name, mode=511, exist_ok=False)

创建路径，可以创建多层

q. os.rename(src, dst, *, src_dir_fd=None, dst_dir_fd=None)

重命名 移动文件或文件夹

src:原文件路径

dst:重命名/移动后的文件路径

r. os.remove(path, *, dir_fd=None)

删除文件

s. 获取桌面的路径

os.path.expanduser("~") 获取电脑用户名及路径

user = os.path.expanduser("~")
desktop = os.path.join(user,'Desktop')
print(user)
print(desktop)

4. 字符串处理

切片: s[start: end: step]每step个字符切取一个字符拼接为字符串

字符串的重复s * n 或n * s

a. strip

它的作用是去除字符串两端的空白字符(例如空格、制表符、换行符)。

line = "  hello world!  "
line = line.strip()
print(line)  # 输出 "hello world!"

b. capitalize 首字母大写

s = 'alexWUsir'
s4_1 = s.capitalize()  #首字母大写
print(s4_1)   #Alexwusir

c. upper全部大写

s = 'alexWUsir'
s4_2 = s.upper() #全部大写
print(s4_2)   #ALEXWUSIR

d. lower全部小写

s = 'alexWUsir'
s4_3 = s.lower() #全部小写
print(s4_3)   #alexwusir

e. swapcase()大小写互换

s = 'alexWUsir'
s4_4 = s.swapcase() #大小写互换
print(s4_4)   #ALEXwuSIR

f. center居中（用空白/其他字符填充）

#center(self, width, fillchar=None)s = 'alexWUsir'
s5_1 = s.center(20,'%')  #用%填充
s5_2 = s.center(15,'*')  #用*填充
s5_3 = s.center(20)      #空白填充
print(s5_1)     #%%%%%alexWUsir%%%%%%
print(s5_2) 
  #***alexWUsir***
print(s5_3)   #     alexWUsir

g. find查找

s.find通过元素找索引，找到返回索引，找不到返回-1

s.index通过元素找索引，找到返回索引，找不到返回error

s = 'alexWUsir'
s8_11 = s.find('W')
s8_12 = s.index('W')
s8_21 = s.find('WU')
s8_22 = s.index('WU')
s8_31 = s.find('A')
s8_32 = s.index('A')
print(s8_11,type(s8_12))     
 #4 <class 'int'>

print(s8_21 ,type(s8_22))    
 #4 <class 'int'>

print(s8_31 ,type(s8_32))     
#报错：ValueError: substring not found----未找到子字符串

h. count计算字符串中某字符/字符串的个数

s = 'alexaa wusirl'
s10 = s.count('a')
print('此字符串中有' + s10 + '个a')   
#报错：TypeError: must be str, not int

print('此字符串中有' + str(s10) + '个a')    
#此字符串中有3个a

i. split 分割：用空格（默认）/固定字符分割字符串（相当于str—>list）

s = 'hello baby'
s1 = 'bb:aaa:g:ggg'
s11_1 = s.split()
print(s11_1)    #['hello', 'baby']
s11_2 = s1.split(':')
print(s11_2)   #['bb', 'aaa', 'g', 'ggg']

j. format 格式化输出

格式化字符串 用大括号{}标明被替换的字符串

1.按照{}的顺序依次匹配括号中的值

s = "{} is a {}".format('Tom', 'Boy')
print(s) # Tom is a Boy

s1 = "{} is a {}".format('Tom')
# 抛出异常， Replacement index 1 out of range for positional args tuple
print(s1)

2.通过索引的方式去匹配参数

s = "{0} is a {1}".format('Tom', 'Boy')
print(s) # Tom is a Boy

s1 = "{1} is a {2}".format('Tom', 'Lily', 'Girl')
print(s1) # Lily is a Girl

3.通过参数名来匹配参数

s = "{name} is a {sex}".format(name='Tom', sex='Boy')
print(s) # Tom is a Boy

4.如果参数已经确定，可以直接利用{}进行格式化引用。

name = 'Tom'
sex = 'Girl'
# 以f开头表示在字符串中支持大括号内的python表达式   此用法3.6之后支持
s = f"{name} is a {sex}"
print(s) # Tom is a Boy

k. replace 字符串的替换

s13_1 = '小明，哈喽你好，我是小明'
s13_2 = s13_1.replace('小明','张三')
s13_3 = s13_1.replace('小明','张三',1)

l. is系列

s14 = ''print(s14.isdigit())   #是否由数字组成
print(s14.isalpha())   #是否由字母组成
print(s14.isalnum())   #是否由字母或数字组成
s14_1 = 'zxcs'
s14_2 = '123546'
s14_3 = 'c1d21c4'
print('----------s14_1----------')
print(s14_1.isdigit())   #False
print(s14_1.isalpha())   #True
print(s14_1.isalnum())   #True
print('----------s14_2----------')
print(s14_2.isdigit())  #True
print(s14_2.isalpha())   #False
print(s14_2.isalnum())   #True
print('----------s14_3----------')
print(s14_3.isdigit())   #False
print(s14_3.isalpha())   #False
print(s14_3.isalnum())   #True

判断字符串是否全部是空格
s14_4 = ' n  '
s14_5 = ''
s14_6 = '   '
print(s14_4.isspace())  #False：有除空格外的其他字符
print(s14_5.isspace())  #False：空
print(s14_6.isspace())  #True：全是空格

m. for

s = 'xiaomingnihao'
for i in s:
    print(i)

#举例：

s = 'ddddddeafsdfdsafsfff'
if 'sf' in s:
    print('非法')
print('------------------------')
if 'esffff' not in s:
    print('合法')

5. 操作文件

a. with open

用来打开本地文件，会在使用完毕后自动关闭文件

with open(file="你要打开的路径名(或保存内容的地址)",mode="r/w/a",encoding="utf-8") as f:
    data=f.read/write()
    print(data)

mode

'r' —— 只读模式，要求目标文件必须存在。

'w' —— 只写模式，如果目标文件已存在，将会截断目标文件并覆盖其内容；如果目标文件不存在，则新建之。

'a' —— 追加模式，只写打开目标文件，如果目标文件已存在，写入的内容追加到源文件的结尾；如果目标文件不存在，则创建之。

'r+' —— 读写模式，要求目标文件必须存在，此时写入，并不会截断源文件，而是替换源文件中相应位置的内容。

'w+' —— 读写模式，如果目标文件已存在，将会截断目标文件并覆盖其内容；如果目标文件不存在，则新建之。

'a+' —— 追加模式，读写打开目标文件，如果目标文件已存在，写入的内容追加到源文件的结尾；如果目标文件不存在，则创建之。

上面的6中文件打开模式，还可以与'b'，'t'相结合，组成类似'rb'、'wt'这样的形式，'b'代表二进制模式，'t'代表文本模式。默认情况下，Python以文本模式打开目标文件。

file对象的属性：

file.readline()	读文件中一行内容 调用一次读一行
file.readlines()	返回一个列表，文件中的每一行都是列表中的一个数据
f.closed	只读属性，判断f.close()是否已经调用过。
f.encoding	只读属性，文件的encoding格式
f.mode	只读属性，显示调用open()打开文件时指定的mode
f.name	只读属性，显示调用open()文件时的指定名称
f.softspace	只读的布尔属性，供print语句记录自己的状态，file对象自身并不修改或使用该属性。
f.close()	关闭已经打开的file对象，所有的file对象，完成读写操作后，都应该关闭
f.read(size = -1)	读取文件内容，以字符串的形式返回。 size < 0 —— 一直读到文件结尾； size > 0 —— 读取 size 字节的内容直到文件结尾，如果到了文件末尾仍未满 size 字节，则返回全文。 size = 0 —— size = 0 或读取时当前文件的位置在文末，都会返回一个空字符串。 省略时表示一次性读完整个文件
f.readline(size = -1)	读取1行，直到遇见'\n'或读满size字节，以字符串的形式返回。 size >= 0，读取的内容不超过size字节，如果没有读够 size 字节就到本行结尾，则停止读取，返回本行。 size < 0，读取当前一行的全部内容，直到遇到 '\n' 或文件结尾。 省略时表示读取当前一行的全部内容
f.readlines()	读取多行，返回一个list，每一行作为 list 中的一个字符串。最后一个字符串可能不以 “ \n ”结尾。
f.next()	file对象是可迭代的，每次迭代返回文件中的一行。
f.seek(pos, how = 0)	将当前文件的位置设置到距离参考点pos字节的位置，参数 how 决定参照点的位置： how = 0，参照点是文件开头，这是默认情形，对应于 os.SEEK_SET how = 1，参考点是当前位置，对应于os.SEEK_CUR how = 2，参考点是文末，对应于os.SEEK_END
f.write(s)	将字符串 s 写入到文件中
f.writelines(lst)	参数lst是一个可迭代对象，将其中的字符串内容全部写到 f 中，该函数不会自动添加 '\n' ！

b. 遍历指定类型文件

可以指定文件夹包含某个字符，可以使用 find 方法或者 __contains__ 方法：

# 包含 返回 True/False
    path.__contains__("xxx")
    # 查找 如果包含子字符串返回开始的索引值，否则返回-1
    path.find("xxx") >= 0

如果只需要遍历相关的文件夹只需要在遍历 fileList 时对 path 进行限制，例如只遍历 shell，python，java文件可以这样设置：

path.endswith('.sh') or path.endswith('.py') or path.endswith('.java')

c. 替换文件内容

def replaceFileByTarget(path, target, new):
    with open(path, 'r') as f:
        text = f.read().replace(target, new)
        open(path, 'w').write(text)
    print("修改成功: {}".format(path))
 
fileList = getFile(rootDir)
for i in fileList:
    replaceFileByTarget(i, "hello", "HELLO")

d. 将数据写入excel

1.需要安装openpyxl

import openpyxl

# 创建一个新的Excel工作簿
workbook = openpyxl.Workbook()

# 获取默认的工作表
sheet = workbook.active

# 写入数据
sheet['A1'] = '姓名'
sheet['B1'] = '年龄'

# 添加一行数据
sheet.append(['Alice', 25])

# 保存工作簿
workbook.save('example.xlsx')

6. argparse 命令行

argparse是一个Python模块

用途是：命令行选项、参数和子命令解释

add_argument的参数

ArgumentParser.add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])

6.1 name or flags

#1.导入包
import argparse

#2.创建解释器
parse = argparse.ArgumentParser(description="描述")
# python argparseTest.py -h 执行-h 时将会出现描述信息

#3.调用add_argument 添加需要的参数
#ArgumentParser.add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])

#3.1 name or flags 命名：前面没有--或者-  flags：前面有-- 或 -
parse.add_argument('-ob','--openbook')
parse.add_argument('animal')
#参数解释
# -ob 代表短选项，在命令行输入 -ob 和 --openbook 的效果是一样的，作用是简化参数输入 ob只是简写，需要通过解析后的参数拿到值的话必须使用--
# --openbook 代表完整的参数名称，注意: 如果想通过解析后的参数取出该值，必须使用带--的名称 --命令后跟的参数会放到解析参数的openbook中
# animal 代表name 自动获得命令行输入的不是跟在-- - 命令之后的值 使用name参数必须在命令行输入值 不输入值会报错
#4.参数解析
args = parse.parse_args()
print('---name or flags--', args.openbook)
print('---name or flags--', args.animal)
# 结果
'''
python argparseTest.py -ob a h
---name or flags-- a
---name or flags-- h

python argparseTest.py -ob a 
usage: argparseTest.py [-h] [-ob OPENBOOK] animal
argparseTest.py: error: the following arguments are required: animal
'''

6.2 action

#1.导入包
import argparse

#2.创建解释器
parse = argparse.ArgumentParser(description="描述")
# python argparseTest.py -h 执行-h时将会出现描述信息

#3.调用add_argument 添加需要的参数
#ArgumentParser.add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])

#3.2 action 当参数在命令行中出现时使用的动作基本类型
#action = 'store' 默认值 存储参数
parse.add_argument('--a', action='store')
#action = 'store_const'  存储const命名参数指定的值 需要指定一个const值一个default值
parse.add_argument('--b', action='store_const', const=7,default=0)
#action = 'store_true' 和 'store_false' 分别代表const为true和false的情况，可省略const不写
parse.add_argument('--c', action='store_true', default=False)
parse.add_argument('--d', action='store_false', default=True)
#action = ‘append’ 存储列表 将每个参数的值都追加到列表中
parse.add_argument('--e', action='append')
#action = 'append_const' 将const指定的值加到列表
parse.add_argument('--f', action='append_const', const=[1,5,7])
#action = ‘count’ 计算
parse.add_argument('-g','--g',action='count')
#action = ‘help’
parse.add_argument('-he',action='help')

#4.参数解析
args = parse.parse_args()
print('---action--', args.a)
print('---action--', args.b)
# 结果
'''
--b调用时 b值为const的值
$ python argparseTest.py --a 5 --b
---action-- 5
---action-- 7

--b不调用时，b默认为default的值
$ python argparseTest.py --a 5
---action-- 5
---action-- 0
'''

print('---action--', args.c)
print('---action--', args.d)
'''
--c 和 --d调用时 action为store_true的值为true 
                 action为store_false的值为false
$ python argparseTest.py --c --d
---action-- True
---action-- False

不调用时 为default的值
$ python argparseTest.py
---action-- False
---action-- True
'''

print('---action--', args.e)
'''
$ python argparseTest.py --e 4 --e 5 --e 7 --e dd
---action-- ['4', '5', '7', 'dd']
'''

print('---action--', args.f)
'''
$ python argparseTest.py --f 
---action-- [[1, 5, 7]]
'''

print('---action--', args.g)
'''
$ python argparseTest.py -ggggg
---action-- 5
$ python argparseTest.py -ggg
---action-- 3
$ python argparseTest.py -g
---action-- 1
'''
print('---action--', args.he)
'''
$ python argparseTest.py -he
usage: argparseTest.py [-h] [--a A] [--b] [--c] [--d] [--e E] [--f] [-g] [-he]

描述

options:
  -h, --help  show this help message and exit
  --a A
  --b
  --c
  --d
  --e E
  --f
  -g, --g
  -he
'''

6.3 choices 参数只能从 choices 给定的值中选择。

#1.导入包
import argparse

#2.创建解释器
parse = argparse.ArgumentParser(description="描述")
# python argparseTest.py -h 执行-h时将会出现描述信息

#3.调用add_argument 添加需要的参数
#ArgumentParser.add_argument(name or flags...[, action][, nargs][, const][, default][, type][, choices][, required][, help][, metavar][, dest])

#3.3 choices 参数只能从 choices 给定的值中选择。
parse.add_argument('--fruit', choices=['apple','pear'])

#4.参数解析
args = parse.parse_args()
print('---choices--', args.fruit)
# 结果
'''
$ python argparseTest.py --fruit
usage: argparseTest.py [-h] [--fruit {apple,pear}]
argparseTest.py: error: argument --fruit: expected one argument

$ python argparseTest.py --fruit apple
---choices-- apple

$ python argparseTest.py --fruit wa
usage: argparseTest.py [-h] [--fruit {apple,pear}]
argparseTest.py: error: argument --fruit: invalid choice: 'wa' (choose from 'apple', 'pear')
'''

6.4 required

--f -f这样的flags 默认是可选的 如果指定它们为必选 设置required = true即可

parse_args()解析命令行的参数

args = parser.parse_args()

7. UT

Unittest 是Python自带的一种单元测试框架

使用Unittest 必须导包 import unittest

测试类必须继承 unittest.TestCase

测试方法必须以test_开头

7.1 TestCase测试用例

是一个代码文件 在代码文件中书写真正的用例代码 里面的print均是模拟测试用例

说明：def定义的test_是测试用例，只有执行 if __name__ == '___mian___' 的时候会执行测试用例，其他普通函数则不执行，通过self来调用执行