python函数-笔记5
- 匿名函数: 一句话函数
函数名 = lambda 形参:返回值
写一个函数，此函数接收两个int参数，返回和值
func = lambda x,y:x+y
print(func(2, 3))
结果：
5
练习题：
1.接收一个可切片的数据，返回索引为0与2的对应的元素（元组形式）
func = lambda x:(x[0],x[2])
print(func([1, 2, 3, 4]))
结果：
(1, 3)
2. 接收两个int参数，将较大的数据返回
func = lambda x,y:x if x>y else y
print(func(2, 3))
结果：
3
- 内置函数
2.1. eval():执行字符串类型的代码，并返回最终结果
s = '2+2'
print(eval(s))
结果：
4
2.2. exec()执行字符串类型的代码。(代码流)
s = '''
for i in [1, 2, 3]:
print(i)
'''
exec(s)
结果：
1
2
3
2.3. hash()获取一个对象的hash值，对象必须为可哈希数据类型
s = 'hello'
print(hash(s))
结果：
2326383250150967506
2.4. help()用于查看函数或者模块用途的详细说明
help(bin)
结果：
Help on built-in function bin in module builtins:
bin(number, /)
Return the binary representation of an integer.
>>> bin(2796202)
'0b1010101010101010101010'
2.5. callable()函数用于检查一个对象是否可以调用
s = 'hello'
def func():
pass
print(callable(s))
print(callable(func))
结果：
False
True
2.6. int()函数用于将一个字符串或数字转换为整型
s = '124'
print(int(s))
f = 3.1415926
print(int(f))
b = '0100'
print(int(b, base=2))
结果：
124
3
4
2.7. float()函数用于将整数和字符串转换成浮点数
i = 132
print(float(i))
s = '3.1415'
print(float(s))
结果：
132.0
3.1415
2.8. bin()将十进制转换成二进制,oct()将十进制转换为8进制，hex()将十进制转换成16进制，并返回结果
i = 10
print(bin(i))
print(oct(i))
print(hex(i))
结果：
0b1010
0o12
0xa
2.9. divmod()计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。
print(divmod(10, 3))
结果：
(3, 1)
2.10. round()保留浮点数的小数位数，默认保留整数。
i = 3.1415926
print(round(i))
print(round(i, 2))
print(round(i, 4))
结果：
3
3.14
3.1416
2.11. pow()求x**y次幂。（三个参数为x**y的结果对z取余）
print(pow(2, 3)) #2**3
print(pow(2, 3, 2)) #2**3对2取余数
结果：
8
0
2.12. bytes()用于不同编码之间的转化。(将字符串转换成bytes类型)
s = '太白'
print(bytes(s, encoding='utf-8'))
结果：
b'\xe5\xa4\xaa\xe7\x99\xbd'
2.13. ord()输入字符找该字符编码的位置,chr()输入位置数字找出其对应的字符
s = 'A'
print(ord(s))
print(chr(65))
结果：
65
A
2.14. repr()返回一个对象的string形式（原形毕露）
name = 'alex'
print(f'my name is {name}')
print(f'my name is {repr(name)}')
结果：
my name is alex
my name is 'alex'
2.15. all()可迭代对象中，全都是True才是True,any()可迭代对象中，有一个True 就是True
print(all([i for i in range(4)]))
print(all([i for i in range(1, 4)]))
print(any([i for i in range(1, 4)]))
结果：
False
True
True
- 比较重要的内置函数(一定要会的)
3.1. print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)屏幕输出
file: 默认是输出到屏幕，如果设置为文件句柄，输出到文件
sep: 打印多个值之间的分隔符，默认为空格
end: 每一次打印的结尾，默认为换行符
flush: 立即把内容输出到流文件，不作缓存
------------------------------------------------------------
print(111, 222, 333, sep='|')
print(111, end='')
print(222)
f = open('test', encoding='utf-8', mode='w')
print('写入文件', file=f, flush=True)
f.close()
结果：
111|222|333
111222
3.2. abs() 返回绝对值
i = -5
print(abs(i))
结果：
5
3.3. sum() 求和
l = [i for i in range(4)]
print(sum(l))
结果：
6
3.4. reversed() 将一个序列翻转, 返回翻转序列的迭代器
l = [1, 3, 5, 7, 9, 22]
ret = reversed(l)
print(l)
print(ret)
print(list(ret))
结果：
[1, 3, 5, 7, 9, 22]
<list_reverseiterator object at 0x104cd9ac8>
[22, 9, 7, 5, 3, 1]
3.5. zip() 拉链方法。函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回。
lst1 = [1, 2, 3]
lst2 = ['a', 'b', 'c', 'd']
lst3 = (11, 12, 13, 14, 15)
ret = zip(lst1, lst2, lst3)
print(ret)
for i in ret:
print(i)
结果：
<zip object at 0x10fb18248>
(1, 'a', 11)
(2, 'b', 12)
(3, 'c', 13)
*** 带有key的函数(重点中的重点) ***
3.6. min() 求最小值,max() 最大值与最小值用法相同
lst1 = [1, 2, 3, 34, -5, -66]
print(min(lst1))
print(min(lst1, key=abs)) #以列表中元素的绝对值取出最小的
print(min(-33, 44, 77, 10, key=lambda x:abs(x)))
dic = {'a': 3, 'b': 2, 'c': 1}
print(min(dic, key=lambda x:dic[x]))
结果：
-66
1
10
c
3.7. sorted()排序函数
语法:sorted(iterable,key=None,reverse=False)
iterable : 可迭代对象
key: 排序规则(排序函数),在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数.根据函数运算的结果进行排序
reverse :是否是倒叙,True 倒叙 False 正序
-----------------------------------------------------------------
lst1 = [1, 2, 3, 34, -5, -66]
ret = sorted(lst1)
ret1 = sorted(lst1, reverse=True)
print(lst1)
print(ret)
print(ret1)
dic = {1:'a',3:'c',2:'b'}
print(sorted(dic))
# 定义一个列表,然后根据一元素的长度排序
lst = ['天龙八部', '西游记', '红楼梦', '三国演义']
ret = sorted(lst, key=lambda x:len(x))
print(ret)
# 按照年龄对学生信息进行排序
lst = [{'id':1,'name':'alex','age':18},
{'id':2,'name':'wusir','age':17},
{'id':3,'name':'taibai','age':16},]
ret = sorted(lst, key=lambda x:x['age'])
print(ret)
结果：
[1, 2, 3, 34, -5, -66]
[-66, -5, 1, 2, 3, 34]
[34, 3, 2, 1, -5, -66]
[1, 2, 3]
['西游记', '红楼梦', '天龙八部', '三国演义']
[{'id': 3, 'name': 'taibai', 'age': 16}, {'id': 2, 'name': 'wusir', 'age': 17}, {'id': 1, 'name': 'alex', 'age': 18}]
3.8. filter筛选过滤
语法: filter(function,iterable)
function: 用来筛选的函数,在filter中会自动的把iterable中的元素传递给function,然后根据function返回的True或者False来判断是否保留此项数据
iterable:可迭代对象
------------------------------------------------------------------
lst = [{'id':1,'name':'alex','age':18},
{'id':1,'name':'wusir','age':17},
{'id':1,'name':'taibai','age':16},]
ret = filter(lambda x:x['age'] > 16,lst)
print(lst)
print(ret)
print(list(ret))
结果：
[{'id': 1, 'name': 'alex', 'age': 18}, {'id': 1, 'name': 'wusir', 'age': 17}, {'id': 1, 'name': 'taibai', 'age': 16}]
<filter object at 0x10f21ca90>
[{'id': 1, 'name': 'alex', 'age': 18}, {'id': 1, 'name': 'wusir', 'age': 17}]
3.9. map映射函数
语法: map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别取执行function
------------------------------------------------------------------
1. 计算列表中每个元素的平方,返回新列表
lst = [1,2,3,4,5]
ret = map(lambda x:x**2,lst)
print(ret)
print(list(ret))
结果：
<map object at 0x107079630>
[1, 4, 9, 16, 25]
2. 计算两个列表中相同位置的数据的和
lst1 = [1, 2, 3, 4, 5]
lst2 = [2, 4, 6, 8, 10]
ret = map(lambda x,y:x+y,lst1,lst2)
print(ret)
print(list(ret))
结果：
<map object at 0x10da946a0>
[3, 6, 9, 12, 15]
3.10. reduce
from functools import reduce
def func(x,y):
return x + y
# reduce 的使用方式:
# reduce(函数名,可迭代对象) # 这两个参数必须都要有,缺一个不行
ret = reduce(func,[3,4,5,6,7])
print(ret) # 结果 25
reduce的作用是先把列表中的前俩个元素取出计算出一个值然后临时保存着,
接下来用这个临时保存的值和列表中第三个元素进行计算,求出一个新的值将最开始
临时保存的值覆盖掉,然后在用这个新的临时值和列表中第四个元素计算.依次类推
注意:我们放进去的可迭代对象没有更改
以上这个例子我们使用sum就可以完全的实现了.我现在有[1,2,3,4]想让列表中的数变成1234,就要用到reduce了.
普通函数版
from functools import reduce
def func(x,y):
return x * 10 + y
# 第一次的时候 x是1 y是2 x乘以10就是10,然后加上y也就是2最终结果是12然后临时存储起来了
# 第二次的时候x是临时存储的值12 x乘以10就是 120 然后加上y也就是3最终结果是123临时存储起来了
# 第三次的时候x是临时存储的值123 x乘以10就是 1230 然后加上y也就是4最终结果是1234然后返回了
l = reduce(func,[1,2,3,4])
print(l)
匿名函数版
l = reduce(lambda x,y:x*10+y,[1,2,3,4])
print(l)
- 闭包：闭包简单来讲就是内层函数调用了外层函数的变量，闭包的产生一定是在嵌套的函数中。
# type1: 数据不安全，在全局可以修改l中数据
l = list()
def func(x):
l.append(x)
return sum(l)/len(l)
ret = func(100000)
ret = func(110000)
ret = func(120000)
print(ret)
#type2: 闭包
def func():
l = list()
def func1(x):
l.append(x)
print(locals())
return sum(l)/len(l)
return func1
ret = func()
print(ret(100000))
print(ret(110000))
print(ret(120000))
结果：
{'x': 100000, 'l': [100000]}
100000.0
{'x': 110000, 'l': [100000, 110000]}
105000.0
{'x': 120000, 'l': [100000, 110000, 120000]}
110000.0
上面被红色方框框起来的区域就是闭包，被蓝色圈起来的那个变量应该是make_averager()函数的局部变量，它应该是随着make_averager()函数的执行结束之后而消失。但是他没有，是因为此区域形成了闭包，series变量就变成了一个叫自由变量的东西，averager函数的作用域会延伸到包含自由变量series的绑定。也就是说，每次我调用avg对应的averager函数 时，都可以引用到这个自用变量series，这个就是闭包。
4.1 用代码判断一个函数是否存在闭包
def make_averager():
series = []
def averager(new_value):
series.append(new_value)
total = sum(series)
return total/len(series)
return averager
avg = make_averager()
print(avg.__code__.co_freevars)
结果：
('series',)
#如果包含自由变量，那一定存在闭包
4.2 闭包的作用
主要作用就是保证数据的安全性。