python学习笔记(二)

Bertha 。 2022-05-14 10:28 308阅读 0赞

**18.函数**  
abs函数，接收一个参数，返回其绝对值  
max函数，可用接收任意多个参数，返回最大的  
数据转化函数:  
int,float,str,bool  
可用把函数名赋值给一个变量，相当于给这个函数取了个别名  
eg:  
a = abs \# 变量a指向abs函数  
a(-1) \# 所以也可以通过a调用abs函数,显示1  
**19.定义函数**  
使用def，依次写出函数名，括号，括号中的参数，冒号，在缩进块中写函数体，返回值用return语句返回  
eg:  
def my\_abs(x):  
if x >= 0:  
return x  
else:  
return -x  
若没有return，也会返回结果，会是None，相当于return None  
空函数:  
如果想定义一个什么事也不做的空函数，可以用pass语句:  
def nop():  
pass  
pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。  
pass还可以用在其他语句里，比如：  
if age >= 18:  
pass  
**20.关于函数**  
可用用户isinstance函数检查数据类型:  
def my\_abs(x):  
if not isinstance(x, (int, float)):  
raise TypeError('bad operand type')  
if x >= 0:  
return x  
else:  
return -x  
返回多个值:  
import math  
def move(x, y, step, angle=0):  
nx = x + step \* math.cos(angle)  
ny = y - step \* math.sin(angle)  
return nx, ny  
其实返回的是一个tuple  
设置默认参数时，注意：  
必选参数在前，默认参数在后，否则Python的解释器会报错  
函数中对参数的改变不会改变原变量  
注意:默认参数的变量也是一个变量，如果指向的是\[\]，如果改变\[\]的内容，默认内容就变了，通过将默认参数改为None可以解决  
**21.可变参数**  
参数的个数是可变的，由于参数个数不确定，首先讲参数作为一个list或tuple传进来  
eg:  
def calc(numbers):  
sum = 0  
for n in numbers:  
sum = sum + n \* n  
return sum  
调用时要组装成一个list后tuple:  
calc(\[1, 2, 3\])  
calc((1, 3, 5, 7))  
当一个list所有元素作为参数传入时，直接再名字前加\*  
nums = \[1, 2, 3\]  
calc(\*nums)  
**22.关键字参数**  
关键字参数允许传入0个或任意个含参数名的参数，会在函数内部自动组装为一个dict  
eg:  
def person(name, age, \*\*kw):  
print('name:', name, 'age:', age, 'other:', kw)  
在调用该函数时，kw作为可选参数  
输入:person('Michael', 30)  
输出:name: Michael age: 30 other: \{\}  
输入:person('Adam', 45, gender='M', job='Engineer')  
输出:name: Adam age: 45 other: \{'gender': 'M', 'job': 'Engineer'\}  
输入：extra = \{'city': 'Beijing', 'job': 'Engineer'\}  
person('Jack', 24, \*\*extra)  
输出:name: Jack age: 24 other: \{'city': 'Beijing', 'job': 'Engineer'\}  
**23.命名关键字参数**  
如果要限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下：  
def person(name, age, \*, city, job):  
print(name, age, city, job)  
和关键字参数\*\*kw不同，命名关键字参数需要一个特殊分隔符\*，\*后面的参数被视为命名关键字参数。  
调用方式:person('Jack', 24, city='Beijing', job='Engineer')  
**24.参数组合**  
在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。  
**25.切片**  
py提供切片来从一个list中截取一部分元素  
eg:  
L = \['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack'\]  
输入:L\[0:3\]  
显示:\['Michael', 'Sarah', 'Tracy'\]  
如果第一个数字是0可以省略:L\[:3\],也支持倒数切片L\[-2：-1\]  
前十个数，每两个去一个写法:  
L\[:10:2\]  
所有数，每5个取一个:  
L\[::5\]  
只写L\[:\]可用原样复制一个list  
元组也可用切片，切出的结果也为tuple  
(-,1,2,3,4,5)\[:3\]  
结果:(0,1,2)  
**26.迭代**  
for in循环:  
d = \{'a': 1, 'b': 2, 'c': 3\}  
for key in d:  
print(key)  
当遍历dict时候，用value来取其值  
for value in d.values()  
如果要同时迭代key和value，写法:  
for k, v in d.items()  
如果想循环下标值，py有内置的enumerate函数:  
for i, value in enumerate(\['A', 'B', 'C'\]):  
print(i, value)  
结果:  
0 A  
1 B  
2 C  
想再for循环中同时引用两个变量:  
for x, y in \[(1, 1), (2, 4), (3, 9)\]:  
print(x, y)  
**27.列表生成式**  
生成\[1\*1,2\*2,4\*3..\]写法:  
L = \[\]  
for x in range(1, 11):  
L.append(x \* x)  
也可写成:  
\[x \* x for x in range(1, 11)\]  
for循环后可以加上if判断来筛选出偶数的平方:  
\[x \* x for x in range(1, 11) if x % 2 == 0\]  
结果:\[4, 16, 36, 64, 100\]  
还可用两层循环生成全排列:  
\[m + n for m in 'ABC' for n in 'XYZ'\]  
结果:\['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ'\]  
eg:用两个变量来生成list  
d = \{'x': 'A', 'y': 'B', 'z': 'C' \}  
\[k + '=' + v for k, v in d.items()\]  
结果:\['y=B', 'x=A', 'z=C'\]  
**28.生成器**  
一个列表的大小是有限的，如果创建一个很大的列表，每次却只访问前几个元素，那么绝大  
多数的空间就被浪费了，generator就是为了解决这个问题，每次在循环的过程中不断推算出后续  
的元素，这样不比创建完整的list，可以节省大量空间，这种一边循环一边计算的机制称为生成器  
L = \[x \* x for x in range(10)\]  
g = (x \* x for x in range(10))  
创建L和g的区别仅在于最外层的\[\]和()，L是一个list，而g是一个generator  
如果需要打印出每一个元素，可以通过next(g)打印出来  
每次调用next(g)就会计算下一个元素的值，直到计算到最后一个元素，没有更多的元素时会抛出错误  
但是一般不会使用next进行变量，可以使用for循环:  
g = (x \* x for x in range(10))  
for n in g:  
print(n)  
如果推算的算法比较赋值，for循环无法实现时，可用用函数来实现:  
如，输出斐波拉契数列:  
def fib(max):  
n, a, b = 0, 0, 1  
while n < max:  
print(b)  
a, b = b, a + b  
n = n + 1  
return 'done'  
注意，赋值语句：  
a, b = b, a + b  
相当于：  
t = (b, a + b) \# t是一个tuple  
a = t\[0\]  
b = t\[1\]  
调用:fib(6)  
结果:  
1  
1  
2  
3  
5  
8  
'done'  
如果要将上述函数变成generator，只需要讲print(b)变成yield b就可以了：  
def fib(max):  
n, a, b = 0, 0, 1  
while n < max:  
yield b  
a, b = b, a + b  
n = n + 1  
return 'done'  
generator和函数的执行流程不一样。函数是顺序执行，遇到return  
语句或者最后一行函数语句就返回。而变成generator的函数，在每次  
调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的  
yield语句处继续执行。  
eg:  
def odd():  
print('step 1')  
yield 1  
print('step 2')  
yield(3)  
print('step 3')  
yield(5)  
o = odd()  
调用:next(o)  
输出:step 1  
1  
调用:next(o)  
输出:step 2  
3  
调用:next(o)  
输出:step 3  
5  
用for循环调用generator时，发现拿不到generator的return语句的返回值。  
如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在  
StopIteration的value中：  
g = fib(6)  
while True:  
try:  
x = next(g)  
print('g:', x)  
except StopIteration as e:  
print('Generator return value:', e.value)  
break  
g: 1  
g: 1  
g: 2  
g: 3  
g: 5  
g: 8  
Generator return value: done  
**29.迭代器**  
凡是可作用于for循环的对象都是Iterable类型；  
凡是可作用于next()函数的对象都是Iterator类型，它们表示一个惰性计算的序列；  
集合数据类型如list、dict、str等是Iterable但不是Iterator，不过可以通过iter()函数获得一个Iterator对象。  
Python的for循环本质上就是通过不断调用next()函数实现的  
可以使用isinstance()判断一个对象是否是Iterable对象：  
>>> from collections import Iterable  
>>> isinstance(\[\], Iterable)  
True  
>>> isinstance(\{\}, Iterable)  
True  
>>> isinstance('abc', Iterable)  
True  
>>> isinstance((x for x in range(10)), Iterable)  
True  
>>> isinstance(100, Iterable)  
False  
可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。  
可以使用isinstance()判断一个对象是否是Iterator对象：  
>>> from collections import Iterator  
>>> isinstance((x for x in range(10)), Iterator)  
True  
>>> isinstance(\[\], Iterator)  
False  
>>> isinstance(\{\}, Iterator)  
False  
>>> isinstance('abc', Iterator)  
False  
生成器都是Iterator对象，但list、dict、str虽然是Iterable，却不是Iterator。  
把list、dict、str等Iterable变成Iterator可以使用iter()函数：  
>>> isinstance(iter(\[\]), Iterator)  
True  
>>> isinstance(iter('abc'), Iterator)  
True