一、匿名函数
1.定义：
匿名函数顾名思义就是指：是指一类无需定义标识符（函数名）的函数或子程序。
2.语法格式：lambda 参数:表达式
lambda语句中，开头先写关键字lambda，冒号前是参数，可以有多个，用逗号隔开；冒号右边的为表达式，需要注意的是只能有一个表达式。由于lambda返回的是函数对象（构建的是一个函数对象），所以需要定义一个变量去接收。
3.注意点：lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值。lambda 函数不能包含命令，包含的表达式不能超过一个。
4.匿名函数优点：
- 使用Python写一些脚本时，使用lambda可以省去定义函数的过程，让代码更加精简。
- 对于一些抽象的，不会被别的地方再重复使用的函数，有时候函数起个名字也是个难题，使用lambda不需要考虑命名的问题
- 使用lambda在某些时候然后代码更容易理解
5.应用：在内置函数 max() 求最大值,min()求最小值, map() 映射, reduce 合并, filter() 过滤 中会用到！
简单代码举例：
1 salaries={
2 ‘egon‘:3000,
3 ‘alex‘:100000000,
4 ‘wupeiqi‘:10000,
5 ‘yuanhao‘:2000
6 }
7 f = lambda k: salaries[k]
8 print(f)
9 print(f(‘egon‘))
执行结果：
<function <lambda> at 0x0000000000413E18> 3000
二、内置函数
内置参数详解 https://docs.python.org/3/library/functions.html?highlight=built#ascii
1.abs() 取绝对值 数据类型 必须是 整型！
1 print(abs(1)) 2 print(abs(-1)) 3 print(abs(‘a‘))
执行结果：
1
1
Traceback (most recent call last):
File "F:/py_fullstack_s4/day25/内置函数.py", line 3, in <module>
print(abs(‘a‘))
TypeError: bad operand type for abs(): ‘str‘
2.all(可迭代对象) 返回布尔值 只要任何一个值不为真，返回Flase，可迭代对象为空时，返回True
1 print(all(‘‘)) 2 print(all((1,‘‘,None,0))) 3 print(all(i for i in range(1,10))) #从1开始取值，排除0
执行结果：
True False True
3.any(可迭代对象) 返回布尔值 只要任何一个值为真，返回True，可迭代对象为空时，返回Flase
1 print(any(‘‘)) 2 print(any([None,1,2,‘‘]))
执行结果：
False True
4.将十进制转换成 ：bin() 二进制 hex() 十六进制 oct()八进制
1 print(bin(12)) #二进制 2 print(hex(12)) #十六进制 3 print(oct(12)) #八进制
执行结果：
1 0b1100 2 0xc 3 0o14
5.数据类型：int() 整型；str() 字符串；list()列表；tuple()元组；dict()字典；set() 集合；frozenset() 不可变集合
is 判断身份，身份运算，根据id去判断身份
1 num =1
2 s = "adxz"
3 l = [1,2.3,4]
4 d = {1:1,"z":2}
5 print(type(d))
6 print(type(l))
7 print(type(s))
8 print(num is 1)
9
10 d = dict(x=1,y=2,z="3") #生成字典的另一种方式
11 print(d)
12 s = {1,2,3,4,4,3,2,5} #集合
13 print(s)
14 s.add((6,7))
15 print(s)
16 f = frozenset(s) #不可变集合
17 print(f)
18 print(type(f))
执行结果：
1 <class ‘dict‘>
2 <class ‘list‘>
3 <class ‘str‘>
4 True
5 {‘x‘: 1, ‘y‘: 2, ‘z‘: ‘3‘}
6 {1, 2, 3, 4, 5}
7 {1, 2, 3, 4, 5, (6, 7)}
8 frozenset({1, 2, 3, 4, 5, (6, 7)})
9 <class ‘frozenset‘>
6.bool() 判断布尔值
1 print(bool(2>1)) 2 print(bool(2<1))
执行结果：
1 True 2 False
7.bytes() bytes 字节 指定编码格式否则报错 type() 查看变量 是 哪种数据类型
1 s = ‘abcdefg‘ 2 print(s) #查看字符串s 3 print(type(s)) #查看字符串类型 4 s1 = bytes(s,encoding=‘utf-8‘) #查看字符串类型 5 print(s1)
执行结果：
1 abcdefg 2 <class ‘str‘> 3 b‘abcdefg‘
8.ASCII码转换 ：chr() ASCII转换 数字转换成字符；ord() ASCII转换 字符转换成数字
1 print(chr(81)) #根据位置找值 2 print(ord(‘A‘)) #根据值找位置
执行结果：
1 Q 2 65
9.callable() 判断是否为函数，括号内传入函数名 complex() 定义复数
1 x = complex(1-2j) #定义一个复数 2 print(type(x)) #查看函数类型 3 print(x.real) #打印x 的实部 4 print(x.imag) #打印x 的虚部 5 print(callable(x)) #查看是否是函数 6 7 def test(): #定义函数 8 pass 9 print(callable(test)) #查看是否是函数
执行结果：
1 <class ‘complex‘> 2 1.0 3 -2.0 4 False 5 True
10.帮助 dir(对象) 查看对象都能调用什么方法；help()直接查看 函数 具体的帮助信息
1 a = ‘hnaxhoqihcqew0‘ 2 print(dir(a)) #查看调用方法 help()直接查看具体的帮助信息
执行结果：
[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__getnewargs__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__init_subclass__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mod__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__rmod__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘, ‘capitalize‘, ‘casefold‘, ‘center‘, ‘count‘, ‘encode‘, ‘endswith‘, ‘expandtabs‘, ‘find‘, ‘format‘, ‘format_map‘, ‘index‘, ‘isalnum‘, ‘isalpha‘, ‘isdecimal‘, ‘isdigit‘, ‘isidentifier‘, ‘islower‘, ‘isnumeric‘, ‘isprintable‘, ‘isspace‘, ‘istitle‘, ‘isupper‘, ‘join‘, ‘ljust‘, ‘lower‘, ‘lstrip‘, ‘maketrans‘, ‘partition‘, ‘replace‘, ‘rfind‘, ‘rindex‘, ‘rjust‘, ‘rpartition‘, ‘rsplit‘, ‘rstrip‘, ‘split‘, ‘splitlines‘, ‘startswith‘, ‘strip‘, ‘swapcase‘, ‘title‘, ‘translate‘, ‘upper‘, ‘zfill‘]
11.divmod(int1,int2) 两个数做除法 int1/int2；返回值是得到一个元组（整除的值，取余的值）；主要应用于网页的分页
1 print(divmod(10,2)) 2 print(divmod(10,3))
执行结果：
(5, 0) (3, 1)
12.enumerate()
enumerate函数说明：
- 函数原型：enumerate(sequence, [start=0])
- 功能：将可循环序列sequence以start开始分别列出序列数据和数据下标（可自定义起始值）
- 即对一个可遍历的数据对象(如列表、元组或字符串)，enumerate会将该数据对象组合为一个索引序列，同时列出数据和数据下标，以元组的形式输出结果
1 list = [‘ni‘,‘hao‘,‘ma‘,‘hello‘,‘world‘] 2 for i in enumerate(list,1): 3 print(i)
执行结果：
(1, ‘ni‘) (2, ‘hao‘) (3, ‘ma‘) (4, ‘hello‘) (5, ‘world‘)
13.hash() hash() 哈希算法，应用：进行数据校验
特性：
1、字符串改变，得到的数值必将改变
2、只要算法一致，得到的值永远不会变，长度也不会改变。
3、hash值不能逆推
1 #字符串类型 2 x = "hello" 3 y = ‘hello‘ #x和y 两个值相等 4 print(hash(x)) 5 print(hash(y)) 6 y = ‘hellobuxaoixax‘ #改变y 7 print(hash(x)) 8 print(hash(y))
执行结果：
4282436752230277468 4282436752230277468 4282436752230277468 -397579801337672607
14.eval() 将字符串 转换成 表达式 形式 进行运算
15.id() id() 查看唯一标识身份信息 字符串一样，数字超过一定长度就不同
1 >>> x =10 2 >>> y =10 3 >>> print(id(x)) 4 1393927552 5 >>> print(id(y)) 6 1393927552 7 >>> x = 100000000000000000000000 8 >>> y = 100000000000000000000000 9 >>> print(id(x)) 10 42716256 11 >>> print(id(y)) 12 42716296 13 >>>
16.#拉链 zip()
zip()，放入两个迭代器，一一对应重新取值，以元组的形式输出。不管是某一方的个数多，都不会输出。
l1 = [1,2,3,4,5,6]
s = ‘hello‘
z = zip(l1,s)
for i in z:
print(i)
执行结果：
(1, ‘h‘) (2, ‘e‘) (3, ‘l‘) (4, ‘l‘) (5, ‘o‘)
17.sorted() 排序 可迭代对象 得到一个新的返回值。返回值是列表，默认是升序； reverse = True 反转。降序； reversed() 取反，本末倒置
对字典排序，默认是按照字典的key去排序的
1 salaries={
2 ‘egon‘:3000,
3 ‘alex‘:100000000,
4 ‘wupeiqi‘:10000,
5 ‘yuanhao‘:2000
6 }
7 print(sorted(salaries)) #按照keys排序，依次比较字母的大小 从小到大
8 print(sorted(salaries,reverse = True)) #按照keys排序，依次比较字母的大小 从大到小
9 print(sorted(salaries,key = lambda x:salaries[x])) #按照values的值排keys的序，从小到大
10 l = [1,2,3,4
执行结果：
[‘alex‘, ‘egon‘, ‘wupeiqi‘, ‘yuanhao‘] [‘yuanhao‘, ‘wupeiqi‘, ‘egon‘, ‘alex‘] [‘yuanhao‘, ‘egon‘, ‘wupeiqi‘, ‘alex‘]
#reversed()应用 l = [1,2,3,45,7] #定义初始列表 l1= reversed(l) #转换 会得到一个返回值 print(list(l1)) #list（）一个一个的取值，生成一个列表
执行结果：
[7, 45, 3, 2, 1]
18.max() and min() 求最大值和最小值
max(*args,key=func) key可有可无。当需要用函数判断的时候，添加key. min与max的使用方法一致。
1 #max和min
2 print(max(1,2,3,4,10,3)) #直接比较
3 print(min(1,2,3,4,10,3))
4 print(max((1,‘a‘),(1,‘b‘)))
5 salaries={
6 ‘egon‘:3000,
7 ‘alex‘:100000000,
8 ‘wupeiqi‘:10000,
9 ‘yuanhao‘:2500
10 }
11 def get_value(k):
12 return salaries[k]
13 print(max(salaries)) #比较keys
14 print(max(salaries,key=get_value)) #原始的定义一个函数
15 print(max(salaries,key=lambda k:salaries[k])) #使用lambda函数
16 print(min(salaries,key=lambda k:salaries[k]))
执行结果：
10 1 (1, ‘b‘) yuanhao alex alex yuanhao
19.map 映射
map(func,list)
map()是 Python 内置的高阶函数，它接收一个函数 func 和一个list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。
1 #map 映射 将原有的可迭代对象中的元素逐一拿出来处理后，返回一个新的可迭代对象 2 l = [1,2,3,45,7] 3 m = map(lambda item:item*2,l) 4 print(m) 5 print(list(m))
执行结果：
<map object at 0x00000000026E96A0> [2, 4, 6, 90, 14]
20.reduce 合并规则 求多个参数的运算！ （加减乘除）
reduce(fun,list,初始值)
reduce依次把list中的数字赋值给fun进行计算
注意fun必须是两个数字间的运算，list必须是整型数字，初始值可定义，也可以不定义。
reduce()传入的函数func 必须接收两个参数，reduce() 对list的每个元素反复调用函数func，并返回最终结果值。
from functools import reduce l = range(100) print(reduce(lambda x,y:x+y,l)) print(reduce(lambda x,y:x+y,l,100))
执行结果：
4950 5050
21.filter() 过滤器 会有一个判断，输出的结果是布尔值，会将布尔值为True的过滤出来。
filter（函数func，可迭代对象list）
filter()函数接收一个函数 func 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。
1 #filter 过滤
2 name_l =[
3 {"name":‘egon‘,‘age‘:120},
4 {"name":"fsw","age":1000},
5 {‘name‘:‘wang‘,‘age‘:2000},
6 {‘name‘:‘jie‘,‘age‘:18}
7 ]
8 f = filter(lambda d:d[‘age‘]>100,name_l)
9 for i in f:
10 print(i)
执行结果：
{‘name‘: ‘egon‘, ‘age‘: 120}
{‘name‘: ‘fsw‘, ‘age‘: 1000}
{‘name‘: ‘wang‘, ‘age‘: 2000}
23.其他
pow() 两个值求方，三个值是前两个求方然后值和第三个数再取余数
round() 带小数点的值，四舍六入五留双。。。
slice() 定义切片对象
vars() #局部变量
_import_(‘字符串‘) 将导入的字符串转成模块
1 #其他 2 3 #pow() 4 print(pow(3,2)) 5 print(pow(3,2,2)) 6 7 #round() 五舍六入 8 print(round(10.3)) 9 print(round(10.5)) 10 print(round(10.6)) 11 print(round(10.9)) 12 13 # slice 切片 14 l=[1,2,3,4,5,6,7,9] 15 print(l[2:5:2]) 16 s=slice(2,5,2) 17 print(l[s]) 18 19 #vars() 等同于局部变量 20 print(vars() is locals()) 21 22 #_import_() 自定义模块 23 import time 24 # time.sleep(3) 25 print(time) 26 27 m=__import__(‘time‘) 28 print(m) 29 m.sleep(3)
执行结果：
9 1 10 10 11 11 [3, 5] [3, 5] True <module ‘time‘ (built-in)> <module ‘time‘ (built-in)>
# #在面向对象里讲# classmethod# staticmethod# property## delattr# hasattr# getattr# setattr## issubclass## super