1，函数的参数
1.1，查看函数的参数类型
def run(a, *args, b, **kwargs):
return a + b
可以通过如下方式查看参数类型：
import inspect
k = inspect.signature(run)
for i, j in k.parameters.items():
print('{:7}:'.format(i) , j.kind)
输出结果为：
a : POSITIONAL_OR_KEYWORD
args : VAR_POSITIONAL
b : KEYWORD_ONLY
kwargs : VAR_KEYWORD
含义如下：
POSITIONAL_OR_KEYWORD：位置参数或者关键字参数，可以用位置参数或者关键字参数方式传参
VAR_POSITIONAL：可变位置参数，*args
KEYWORD_ONLY：仅限关键字参数，*args或者*后面的，只能用关键字参数方式传参
VAR_KEYWORD：可变关键字参数，**kwargs
POSITIONAL_ONLY：目前不支持
备注：
*args是最后一个位置参数，即*args后面的都是“仅限关键字参数”
**kwargs是最后一个参数，即**kwargs后面不允许再跟参数
1.2，传参方法
位置参数必须在关键字参数前面！
def test(x, y，z)
.......
传参：
位置参数：test(a, b, c)
关键字接收：test(y=a, x=b, z=c) # 关键字参数，可颠倒次序
混合：test(1, z=2, y=6) # 位置参数必须在关键字参数前面，后面2个可以颠倒
1.3，*args，数量可变位置参数
args：序列
*args: 序列中的值
def test(x, *args):
print(x, *args) # 1,2,3
print(x, args) # 1,(2,3)
test(1,2,3) # 或test(*[1,2,3])
1.4，**kwargs，数量可变的关键字参数
kwargs：字典
*kwargs： 字典的key
**kwargs：字典的键值对
def test(**kwargs):
print(kwargs) # {'name': 'guxh', 'age': 18}
print(*kwargs) # name age
print(kwargs['name']) # 'guxh'
test(name='guxh', age=18) # 或test(**{'name':'guxh', 'age':18})
1.5，只接受仅限关键字参数
*后面的是仅限关键字参数：
def test(x, *, y):
print(x, y) test('a', 'b') # TypeError
test('a', y='b') # OK
*args后面的是仅限关键字参数：
def test(*args, y):
print(*args, y) test('a', 'b') # TypeError
test('a', y='b') # OK
1.6，特殊传参
组合传参，如果name用关键字参数传参，则age必须用关键字参数传参，因为位置参数必须在关键字参数前面。
def test(name, age=18, *args, **kwargs):
print(name) # 位置参数或关键字参数，'guxh'
print(age) # 位置参数或关键字参数，34
print(args) # 可变位置参数，()
print(kwargs) # 可变关键字参数，{'sex': 'f', 'hobby': 'python'}
test('guxh', 34, sex='f',hobby='python')
test(name='guxh', age=34, sex='f',hobby='python')
序列传参，字典传参：
def test(x, y)：test(*序列)，或test(**字典)
def test(*args) ： test(*序列)
def test(**kwargs) ：test(**字典)
2，防御可变参数
python的传参是按引用传参，但是函数对传入的参数进行修改以后：
可变参数：例如列表/字典，会就地修改，实际相当于传统的"按引用传参"
不可变参数：例如数值/字符串/远组，会重新开辟内存，结果相当于传统的"按值传参"
2.1，不可变参数传参
函数或类，在改变x之前，x的id与实参a的id完全一样，但是改变后就不一样了，也就是x发生改变时不会影响到实参a，效果相当于传统的按值传参。
函数传参：
def run(x):
print(id(x)) # 1591569856
x += 1
print(id(x)) # 1591569888 a = 0
run(a)
print(a, id(a)) # 0, 1591569856
类的实例化传参：
class Foo:
def __init__(self, x):
self.x = x
print(id(self.x)) # 1591569856
self.x = self.x + 1
print(id(self.x)) # 1591569888
a = 0
print(id(a)) # 1591569856
f = Foo(a)
2.2，可变参数
函数或类，对x的改变会影响到实参a，效果相当于传统的按引用传参。
函数传参：
def run(x):
x.append(1) a = []
run(a)
print(a) # [1]
类的实例化传参：
class Foo:
def __init__(self, x):
self.x = x
self.x.append(1)
a = []
f = Foo(a)
print(a) # [1]
因此如果不想改变原来的a，可以用浅拷贝或深拷贝：
class Foo:
def __init__(self, x):
self.x = list(x)
2.3，可变参数作为默认值的问题
如果想实现对一个输入列表添加一个1，当没有输入列表时，创建一个空列表并添加1，会发生如下问题：
函数：
def run(x=[]):
x.append(1)
return x a = [1, 2, 3]
print(run(a)) # [1, 2, 3, 1]，有参数时表现正常
print(run()) # [1]，第一次run也正常
print(run()) # [1, 1]，第二次run出错了，返回的是有2个1的列表
类的实例化传参：
class Foo:
def __init__(self, x=[]):
self.x = x
self.x.append(1)
根据不同打印顺序，结果不一样：
f1 = Foo()
f2 = Foo()
print(f1.x) # [1, 1]
print(f2.x) # [1, 1]
f1 = Foo()
print(f1.x) # [1]
f2 = Foo()
print(f2.x) # [1, 1]
实际上f1和f2实例共享了同一个列表，所以都完成实例化后打印的值完全一样。
解决方法是函数或类有可变参数作为默认值时用None：
def run(x=None, y=None):
x = [] if x is None else x
y = {} if y is None else y # requests框架使用了这2句
x.append(1)
y.update({'a': 1})
return x, y
3，高阶函数
3.1，高阶函数
满足下面两个条件之一的就叫高阶函数：
1）一个函数当作参数传给另外一个函数（参数有函数）
2）函数的返回值中包含函数（返回有函数）
3.2，回调函数
回调本质上就是高阶函数的第一个定义场景。
函数A作为参数传给另外一个函数B，涉及三个角色：中间函数A，回调函数B，中间函数A的调用者（一般是主程序）。
如果回调函数想保存额外状态，可以用基于类、闭包、协程、functools.partial、lambda等方式实现。
简单的回调函数：
def add(x, y): # 回调函数
print(x + y) def fun(x, y, callback): # 中间函数
return callback(x, y) if __name__ == '__main__': # 中间函数调用者
fun(1, 2, callback=add)
保存额外状态的回调 — 基于类：
class Foo:
def __init__(self):
self.s = 0 # 额外状态s
def add(self, x, y):
self.s += 1
print('第{}次相加结果：{}'.format(self.s, x + y)) def fun(x, y, callback):
return callback(x, y) if __name__ == '__main__': # 中间函数调用者
f = Foo()
fun(1, 2, callback=f.add) # 第1次相加结果：3
fun(3, 4, callback=f.add) # 第2次相加结果：7
保存额外状态的回调 — 基于类 + functools.partial / lambda：
class Seq: # 保存额外状态的类
def __init__(self):
self.seq = 0 def fun(x, y, callback):
return callback(x, y) def add(x, y, s):
s.seq += 1
print('第{}次相加结果：{}'.format(s.seq, x + y)) if __name__ == '__main__':
s = Seq()
fun(1, 2, callback=partial(add, s=s))
fun(3, 4, callback=partial(add, s=s))
# 用lambda替代functools.partial
# fun(1, 2, callback=lambda x, y: add(x, y, s))
# fun(3, 4, callback=lambda x, y: add(x, y, s))
保存额外状态的回调 — 基于闭包：
def make_add():
s = 0
def add(x, y):
nonlocal s
s += 1
print('第{}次相加结果：{}'.format(s, x + y))
return add def fun(x, y, callback):
return callback(x, y) if __name__ == '__main__':
add = make_add()
fun(1, 2, callback=add)
fun(3, 4, callback=add)
保存额外状态的回调 — 基于协程：
def make_add():
s = 0
while True:
x, y = yield # 不产出值，只接收值（接收值在yield左边，产出值在yield右边）
s += 1
print('第{}次相加结果：{}'.format(s, x + y)) def fun(x, y, callback):
return callback((x, y)) # 协程只能接受一个参数，因此改为发送元组 if __name__ == '__main__':
add = make_add()
next(add)
fun(1, 2, callback=add.send) # 往协程发送数据是send
fun(3, 4, callback=add.send)
4，常用内置函数
4.1，匿名函数lambda
调用方法：
>>> fn = lambda x:x*3
>>> fn(3)
9
>>> (lambda x:x*3)(3)
9
lambda y: x + y，其中输入参数y可变，x在运行时才绑定，注意以下代码的区别：
funs1 = [lambda x: x + n for n in range(5)]
for f in funs1:
print(f(0), end=' ') # 4 4 4 4 4
funs2 = [lambda x, n=n: x + n for n in range(5)]
for f in funs2:
print(f(0), end=' ') # 0 1 2 3 4
4.2，计算
1）sum：求和，归约函数，归约函数可以直接结合生成器表达式，避免创建临时列表
nums = [1, 2, 3, 4, 5]
s = sum(x*x for x in nums) # 55，如果nums很大，用列表推导会有很大开销
2）max：最大值，归约函数
3）min：最小值，归约函数
4）round：保留小数位数
5）divmond：相除，返回商和余
6）eval
7）exec
8）hash：哈希
9）id：获取ID
10）int / float / hex / oct / bytes / char / bin / chr / ord ： 类型转换
11）pow：次方
4.3，检测
1）all：全部为真返回True，否则返回False，归约函数
2）any：任意为真返回Ture，否则返回False，归约函数
3）bool：判断True or False
4）callable：判断是否可调用
5）isinstance：判断类
6）issubclass：判断子类
7）type
class Human:
pass class Male(Human):
pass m = Male()
print(isinstance(m, Human)) # True
print(isinstance(m, Male)) # True
print(issubclass(Male, Human)) # True
print(type(m)) # <class '__main__.Male'>，如果是import，__main__显示module名
4.4，面向对象
1）super：继承父类
2）vars：返回所有属性名，相当于self.__dict__？
3）setattr / delattr：设置属性 / 删除属性
4）dir：看object部分方法
4.5，迭代
1）iter：获取iterator，iter()可以加哨符值取代while
2）zip：两个序列合起来
3）enumerate：获取index和value
4）map：返回iterator
m = map(lambda x: x * 2, [1, 2, 3])
print(list(m))
print(dir(m)) # 含有'__iter__', '__new__'
print(type(m)) # <class 'map'>
print(type(iter(m))) # <class 'map'>，iterator的__iter__是return self
5）filter：返回iterator
print(list(filter(lambda x: x > 1, [1, 2, 3]))) # [2, 3]
print(list(filter(None, ['', None, 1, 'a']))) # [1, 'a']
6）range：返回iterable
r = range(10)
print(dir(r)) # 含__iter__，但不含__next__
print(type(r)) # <class 'range'>
print(type(iter(r))) # <class 'range_iterator'>，iterable的__iter__是return iterator
4.6，数据类型
1）tupple，list，dict，set，frozenset：转换为元组/列表/字典/集合/不可变集合
2）slice：切片
3）sort / sorted：排序
4）reversed：反向
4.7，文本
1）str
2）repr
3）replace：替换
4）strip：去除空格
5）format
name = 'guxh'
age = 20
print("my name is " + name + ", age is " + str(age))
print("my name is %s, age is %s" % (name, age))
print("my name is {}, age is {}".format(name, age))
print("my name is {0}, age is {1}".format(name, age))
print("my name is {name}, age is {age}".format(name=name, age=age))
print("my name is {name}, age is {age}".format(**{'name': name, 'age': age}))
格式化参数：
^, <, > 分别是居中、左对齐、右对齐，后面带宽度，分别等效于center, ljust, rjust。
: 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。
+ 表示在正数前显示 +，负数前显示 -； （空格）表示在正数前加空格
b、d、o、x 分别是二进制、十进制、八进制、十六进制
eg：>右对齐，@缺失部分用@填充，18固定宽度，','千分位，'.2'浮点精度2，f浮点数声明
'{:@>18,.2f}'.format(70305084.0) # 输出@@@@@70,305,084.00
6）文本对齐
>>>text = 'hello world'
>>>text.center(20, '*') # 等效format(text, '*^20s'), '{:*^20s}'.format(text)
'****hello world*****'
>>>text.ljust(20, '*') # 等效format(text, '*>20s'), '{:*>20s}'.format(text)
'hello world*********'
>>>text.rjust(20, '*') # 等效format(text, '*<20s'), '{:*<20s}'.format(text)
'*********hello world'
4.8，显示交互
1）print：打印，end指定结束换行符
>>> for i in range(5):
... print(i, end=' ')
0 1 2 3 4
读取文件时有默认的换行符号，加上print自动产生的换行符，就会产生空行，可以用end去除空行：
with open('text.txt') as f:
for line in f:
print(line, end='')
sep指定间隔，join()只能合并同类型，print+sep可以合并不同类型
>>>print(*list('abcd'), sep='#')
a#b#c#d
2）保存内容到f文件
print('hello world', file=f)
4.9，文件IO
打开文件：
open()函数返回的是个iterator
>>>from collections import abc
>>>f = open('text.txt')
>>>isinstance(f, abc.Iterator)
True
参数说明：
- t：文本，默认
- r ：读，默认
- w：写，有同名文件覆盖，无同名文件新建
- a ：追加，有同名文件追加，无同名文件新建
- r+ : 读写（读模式 +写模式/追加模式），写入时和指针指向第几行没有关系，python3总是追加到最后面
- w+ ：没什么用！写读（先创建文件再往里面写），文件不存在会创建，存在就覆盖，和w一样比较危险
- a+: 比较常用，追加模式 + 读模式，即附加了读的a追加模式(相当于r+a)，可以读，也可以追加到最后
- rb，wb，ab ：二进制的基本操作，python3里以rb打开以后无需encode到bytes类型
- rb+, wb+, ab+ ： 二进制的读写操作
- x：文件不存在时才写入，可以省略os.path.exists判断
- encoding：编码
- newline：python会自动将系统换行符（unix是\n，windows是\r\n）转换成\n，设置newline=‘’可以取消自动转换
常用方法：
f：是iteraotr，可以逐行打印，但无法获取下标
for i in f：
print(i)
f.read() ：一次性全部读取所有内容，注意只能读一次，读第二次会为空
f.readline() ：逐行读取，读5行可以：
for i in range(5):
print(f.readline())
f.readlines() ：逐行读取所有内容，可以打印所有，f.readlines()和list(f)结果是一样的
for i in f.readlines() :
print(i)
f.tell()：返回文件句柄当前指针指向的位置，指针位置是根据字符串确定的，不是根据行数确定的。
f.seek()：返回到指针位置，例如f.seek(0)，回到指针0的位置，f.seek()一般配合f.tell()使用，f.tell()确定指针位置，f.seek()回到指针位置。
f.encoding：获取文件编码
f.name()：获取文件名
f.buffer
f.fileno():打印文件句柄在内存中的位置
f.isatty()：判断是否是一个终端设备
f.seekable()：判断文件是否可以移回去
f.writeable()：判断文件是否可写
f.flush()：刷新，写一句语句后不一定马上写到硬盘上，实际是等积满一定内容后再写到硬盘上，flush可以实时刷到硬盘上
# CMD写文件刷新
f = open('test.txt', 'w')
f.write('hello world 1 \n') #此时去打开文件发现还没有写入
f.flush() # 此时去打开发现已写入
f.close()
# 打印进度条：
import(sys)
import(time)
for i in range(50):
sys.stdout.write('#')
sys.stdout.flush()
time.sleep(0.1)
f.truncate()：不写参数就清空
f.truncate(10) # 从开头截断至10
f.seek(10); # 从第10个字符开始，往后截断至10
f.truncate(10)
f.writelines(s)：s是个iterable，相当于：
for i in s:
f.write(i)
f.readinto(buff)：将二进制数读取到可变缓冲区中
修改文件内容
- 方法一，读到内存里修改
- 方法二，修改内容，写到新文件中
读写压缩文件
- gzip.open：gz
- bz2.open：bz2
4.10，其他函数
1）globals：返回所有key，value
5，其他
5.1，函数注释
可以对函数的参数类型，返回类型，做注释：
def fun(x: int, y: int) -> int:
return x + y
5.2，exec和eval
exec：执行复杂的python代码，无返回结果（相当于JavaScript中的eval）
eval：计算单个表达式的值，有返回结果