5.13 内置函数
匿名函数: 函数名 = lambda 参数:返回值
1) 此函数不是没有名字，他是有名字的，他的名字就是你给其设置的变量，比如func.
2）lambda 是定义匿名函数的关键字，相当于函数的def.
3）lambda 后面直接加形参，形参加多少都可以，只要用逗号隔开就行。
4）返回值在冒号之后设置，返回值和正常的函数一样,可以是任意数据类型。
5）匿名函数不管多复杂.只能写一行.且逻辑结束后直接返回数据
def func(a,b):
return a+b
print(func(1,2))
# 匿名函数 完成上面的需求
func = lambda a,b:a+b
print(func(1,2))
1. 写匿名函数：接收一个可切片的数据，返回索引为0与2的对应的元素（元组形式）。
l = [1,2,3,4,5]
func = lambda a,b:(l[a],l[b]) # 返回上面类型就用什么类型表示 例如返回元组 (a,b)
print(func(0,2))
2. 写匿名函数：接收两个int参数，将较大的数据返回。
func = lambda a,b:a if a>b else b
print(func(12,45))内置函数 -- 重点
# 重点 重点 重点
min() 求最小值 max() 相同
print(min([1,2,3])) # 返回此序列最小值
ret = min([1,2,-5,],key=abs) # 按照绝对值的大小，返回此序列最小值
print(ret)
# 加key是可以加函数名，min自动会获取传入函数中的参数的每个元素，然后通过你设定的返回值比较大小，返回最小的传入的那个参数。
l1 = [('a1', 73, 170), ('a2', 35, 159), ('a3', 18, 185)]
print(min(l1,key=lambda x:x[1])) # 遍历列表l1,x 相当于列表中的元素,X[i]是元素中的第i个元素
# 结果 ('a3', 18, 185)
# 练习：
dic = {'a':3,'b':2,'c':1}
# 将dic值最小的键返回。
print(min(dic,key=lambda x:dic[x])) # lambda 函数 只是提供一个判断依据
# 将dic值最小的值返回。
print(dic[min(dic,key=lambda x:dic[x])])
dic = {'a':['李业',67],'b':['怼哥', 95],'c':['方垚', 85]}
# 将成绩最低的从属于的那个列表返回。
print(dic[min(dic,key=lambda x:dic[x][1])])
# 将成绩最低的分数返回。
print(dic[min(dic,key=lambda x:dic[x][1])][1])
list = [
{'name': 'a1', 'age': 73},
{'name': 'a2r', 'age': 35},
{'name': 'a3', 'age': 25},
]
# 将年龄最小的字典返回。
print(min(list,key=lambda x:x['age']))
# 将年龄最小的名字返回。
print(min(list,key=lambda dic:dic['age'])['name'])
# 将年龄最小的年龄返回。
print(min(list,key=lambda dic:dic['age'])['age'])int():pass
str():pass
bool():pass
set(): pass
list() 将一个可迭代对象转换成列表
tuple() 将一个可迭代对象转换成元组
dict() 通过相应的方式创建字典。
'''
list
l1 = list('abcd')
print(l1) # ['a', 'b', 'c', 'd']
tu1 = tuple('abcd')
print(tu1) # ('a', 'b', 'c', 'd')
'''
abs() 返回绝对值
i = -5
print(abs(i)) # 5
sum() 求和
print(sum([1,2,3]))
print(sum((1,2,3),100))
reversed() 将一个序列翻转, 返回翻转序列的迭代器 reversed 示例:
l = reversed('你好') # l 获取到的是一个生成器
print(list(l)) # ['好', '你']
print(l) #<reversed object at 0x000001A54C83A128>
ret = reversed([1, 4, 3, 7, 9])
print(list(ret)) # [9, 7, 3, 4, 1]
bytes() 把字符串转换成bytes类型
s = '你好aaa'
bs = s.encode('utf-8')
print(bs)
结果:b'\xe4\xbd\xa0\xe5\xa5\xbd\xe6\xad\xa6\xe5\xa4\xa7'
s1 = bs.decode('utf-8')
print(s1)
结果: 你好aaa
s = '你好'
bs = bytes(s,encoding='utf-8')
print(bs)
# 将字符串转换成字节
bs1 = str(bs,encoding='utf-8')
print(bs1)
# 将字节转换成字符串
zip() 拉链方法,返回一个迭代器 # 如果用next取值,要将zip函数赋值给一个变量
l1 = [1, 2, 3, 4]
tu = ('a', 'b', 'c')
s = 'python23'
print(zip(l1,tu,s))
print(list(zip(l1,tu,s)))
# [(1, 'a', 'p'), (2, 'b', 'y'), (3, 'c', 't')]
sorted 排序 # 语法:sorted(iterable,key=None,reverse=False)
l = [2,6,4,1,3]
print(sorted(l)) # 形成一个新列表
print(l) # 原来的列表不变
# 加 key
list1 = [
{'name': 'a1', 'age': 73},
{'name': 'a2', 'age': 35},
{'name': 'a3', 'age': 25},
]
print(sorted(list1))
print(sorted(list1, key=lambda x:x['age']))
print(sorted(list1, key=lambda x:x['age'],reverse=True))
l1 = [('张一东', 80), ('张耳洞', 75), ('怼怼哥', 7), ('李业', 59)]
print(sorted(l1,key=lambda x:x[1]))
print(sorted(l1,key=lambda x:x[1],reverse=True))
filter 返回一个生成器 # 语法: filter(function,iterable) 生成器表达式的筛选模式
l1 = [56, 67, 12, 34, 78, 90,]
print(filter(lambda x:x>60,l1))
print(list(filter(lambda x:x>60,l1)))
map 返回一个迭代器,相当于生成器表达式循环模式# 语法: map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别取执行function
l1 = [56, 67, 12, 34, 78, 90,]
print([i**2 for i in l1])
print(map(lambda x:x**2,l1))
print(list(map(lambda x:x**2,l1)))
# reduce python3x 从内置函数剔除了。
from functools import reduce
'''
第一次：x,y 1,2 求和 3 记录到内存
第二次：x,y 3,3 求和 6 记录到内存
第三次：x,y 6，4 .........
'''
print(reduce(lambda x,y: x+y,[1,2,3,4,5]))
print(reduce(lambda x,y: 2*x+y, [1,2,3]))
print(reduce(lambda x,y: x+y, ['a1','s','b'])) # 可以用字符串拼接print() 屏幕输出
''' 源码分析
def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
"""
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
file: 默认是输出到屏幕，如果设置为文件句柄，输出到文件
sep: 打印多个值之间的分隔符，默认为空格
end: 每一次打印的结尾，默认为换行符
flush: 立即把内容输出到流文件，不作缓存
"""
'''
print(111,222,333,sep='*') # 111*222*333
print(111,end='')
print(222) #两行的结果 111222
f = open('log','w',encoding='utf-8')
print('写入文件',fle=f,flush=True)内置函数 -- 熟练掌握
| 函数名 | 作用 |
|---|---|
| eval() | 剥去字符串的外衣,返回里面的本质 |
| exce() | 执行字符串类型的代码。代码流，过程。 |
| hash() | 获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。 |
| help() | 函数用于查看函数或模块用途的详细说明。 |
| callable() ** | 函数用于检查一个对象是否是可调用的 |
| int() ** | 函数用于将一个字符串或数字转换为整型。 |
| float() | 函数用于将整数和字符串转换成浮点数。 |
| complex() | 函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。 |
| bin() ** | 将十进制转换成二进制并返回。 |
| oct() | 将十进制转化成八进制字符串并返回。 |
| hex() ** | 将十进制转化成十六进制字符串并返回。 |
| divmod() ** | 计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。 |
| round() | 保留浮点数的小数位数，默认保留整数。 |
| pow() | 求x**y次幂。（三个参数是结果对z取余） |
| bytes() | 用于不同编码之间的转化。 |
| ord() | 输入字符找该字符编码的位置 |
| chr() ** | 输入位置数字找出其对应的字符 |
| repr() ** | 返回一个对象的string形式（原形毕露）。 |
| all() | 可迭代对象中，全都是True才是True |
| any() ** | 可迭代对象中，有一个True 就是True |
# 各种内置函数的举例
eval：执行字符串类型的代码，并返回最终结果。 剥去字符串的外衣,返回里面的本质
eval('2 + 2') # 4
n=81
eval("n + 4") # 85
eval('print(666)') # 666
exec:执行字符串类型的代码。代码流，过程。
s = '''
for i in [1,2,3]:
print(i)
'''
exec(s) # 1 2 3
hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。
print(hash(12322)) # 12322
print(hash('arg')) # 5789562807315427740
print(hash(True)) # 1
print(hash(False)) # 0
print(hash((1,2,3)))# 2528502973977326415
help：函数用于查看函数或模块用途的详细说明。
print(help(list))
print(help(str.split))
callable：函数用于检查一个对象是否是可调用的 **
name = 'alex'
def func():
pass
print(callable(name)) # False
print(callable(func)) # True
int：函数用于将一个字符串或数字转换为整型。**
print(int('12')) # 12
print(int(3.6)) # 3
print(int('0100',base=2)) # 将2进制的 0100 转化成十进制。结果为 4
float：函数用于将整数和字符串转换成浮点数。
complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。
print(complex(1,2)) # (1+2j)
bin：将十进制转换成二进制并返回。**
oct：将十进制转化成八进制字符串并返回。
hex：将十进制转化成十六进制字符串并返回。**
print(bin(10),type(bin(10))) # 0b1010 <class 'str'>
print(oct(10),type(oct(10))) # 0o12 <class 'str'>
print(hex(10),type(hex(10))) # 0xa <class 'str'>
divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。**
round：保留浮点数的小数位数，默认保留整数。
pow：求x**y次幂。（三个参数为x**y的结果对z取余）
print(divmod(7,2)) # (3, 1)
print(round(7/3,2)) # 2.33
print(round(7/3)) # 2
print(round(3.32567,3)) # 3.326
print(pow(2,3)) # 两个参数为2**3次幂
print(pow(2,3,3)) # 三个参数为2**3次幂，对3取余。
bytes：用于不同编码之间的转化。
s = '你好'
bs = s.encode('utf-8')
print(bs)
s1 = bs.decode('utf-8')
print(s1)
bs = bytes(s,encoding='utf-8')
print(bs)
b = '你好'.encode('gbk')
b1 = b.decode('gbk')
print(b1.encode('utf-8'))
ord:输入字符找该字符编码的位置
chr:输入位置数字找出其对应的字符**
ord 输入字符找该字符在UNICODE编码的位置
print(ord('a'))
print(ord('中'))
chr 输入位置数字找出其对应的字符
print(chr(97))
print(chr(20013))
repr:返回一个对象的string形式（原形毕露）。**
# %r 原封不动的写出来
name = 'taibai'
print('我叫%r'%name)
print(repr('{"name":"alex"}'))
print('{"name":"alex"}'
all：可迭代对象中，全都是True才是True
any：可迭代对象中，有一个True 就是True**
print(all([1,2,True,0]))
print(any([1,'',0]))
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
