#15 函数二 与 匿名函数
1.dir() # 查看内置属性,将对象所有方法名放在另一个列表中.
dic={"水果":"香蕉",'蔬菜':"土豆"}
print(dir(dic))
2.迭代器相关 range() next() iter()
# range() # 一般用于for 循环中
# next 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
try:
# 获得下一个值:
x = next(it)
print(x)
except StopIteration:
# 遇到StopIteration就退出循环
break
# iter() 判断对象是迭代器
from collections import Iterable
from collections import Iterator
l = [1,2,3]
print(isinstance(l,Iterable)) # True
print(isinstance(l,Iterator)) # False
l1 = iter(l)
print(isinstance(l1,Iterable)) # True
print(isinstance(l1,Iterator)) # True
3.基础数据类型相关 bool int complex (real + imag *j)
bool() # 用于将给定参数转换为布尔类型，如果没有参数，返回 False.
int()# 三种用法:
#(1).直接转化.
s="1234"
print(int(s)) #1234
#(2).小数取整 浮点型转换成整数
print((int(12.23))) # 结果 12
#补充 :float;将字符转成浮点数
# (3). 将二进制转成十进制
print(int("0100",base=2))
complex 复数 (real + imag *j)
print(complex(1,2)) # 结果 (1+2j)
4.进制转换 bin()十转二进制 oct()十转八进制 hex()十转十六进制
print(bin(3)) #0b11 十转二进制
print(oct(8)) # 0o11 十转八进制
print(hex(20)) #0x14 十转十六进制
5.数学运算abs() 绝对值 divmod() round() pow() sum() min() max()
#abs()
li=[-5,-6,-7,55,66]
print(abs(li[1])) # 6 求元素的绝对值
#divmod() 计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)
print(divmod(7,3)) # (2, 1)
#round(小数,位数) 保留浮点数的小数位数，默认保留整数
print(round(3.1415926,4)) #3.1416
# pow() 求x**y次幂。（三个参数为x**y的结果对z取余）
print(pow(2,3)) #8 2的三次幂
print(pow(3,3,5)) #三个参数 先算3的3次幂 ,结果对第三个参数5 取余 # 结果 2
# sum() 两种用法
#1.求和
li=[1,2,3,4,5]
print(sum(li)) # 15 返回列表元素的和
print(sum(li,100)) #115 后面的参数是它的初始值
# 2.设置初始值
print(sum(li,100)) #115 后面的参数是它的初始值
print(sum(li,sum(li))) #初始值也可以是sum函数 结果30
# min()求最小值 可以加函数名
li2=[-3,-4,-5,55,77]
print(min(li2,key=abs)) # 结果 -3
# max()求最大值 也可以加函数名
dic={'a':3,"b":2,"c":1}
print(max(dic)) #结果 c
def func(x):
return dic[x]
print(max(dic,key=func)) # a
print(dic[max(dic,key=func)]) # 结果3
# 用匿名函数
print(max(dic,key=lambda x:dic[x])) # a
print(dic[max(dic,key=lambda x:dic[x])]) # 3
6.list() tuple() reversed() slice() str() format() bytes() bytearry() memoryview()
# list() 创建列表 也可以转化
l = list((1,2,3))
print(l) # [1, 2, 3]
l = list({'k1':1,'k2':2})
print(l) #['k1', 'k2'] 将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）
# tuple()
tu = tuple((1,2,3))
print(tu) #(1, 2, 3)
tu = tuple({'k1':1,'k2':2})
print(tu) #('k1', 'k2') 将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素
# reversed() 将一个序列翻转，并返回此翻转序列的迭代器
li=[22,33,44,55,66]
print(reversed(li)) # <list_reverseiterator object at 0x000002522EC0CCC0> 返回一个地址
for i in reversed(li):
print(i) # 得到它里面的每一个元素
# slice() 构造一个切片对象，用于列表的切片
li=[1,2,3,4,5,6,7]
li2=[2,-3,4,-5,6,-7]
print(li[1:4]) # [2, 3, 4]
print(li2[1:4]) #[[-3, 4, -5]
rule=slice(1,4,2) #第三个参数为步长
print(li[rule]) # [2, 3, 4]
print(li2[rule]) # [-3, 4, -5]
# str() 将数据转化成字符串
# 与具体数据相关，用于计算各种小数，精算等
# 字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐
print(format('1234', '<20')) #左对齐
print(format('test', '>20')) #右对奇
print(format('abcd', '^20')) #居中对齐
# bytes() 把unicode 转换成 bytes
s = '你好'
bs = s.encode('utf-8')
print(bs) # b'xe4xbdxa0xe5xa5xbd'
bs = bytes(s, encoding='utf-8')
print(bs) # b'xe4xbdxa0xe5xa5xbd'
# bytearry()
ret = bytearray('alex',encoding='utf-8')
print(id(ret)) # 2249729581216 内存地址
print(ret) #bytearray(b'alex')
print(ret[0]) # 97 utf-8编码的第一位 a 序号97
ret[0] = 65
print(ret) #bytearray(b'Alex')
print(id(ret)) # 32249729581216
# memoryview()
ret = memoryview(bytes('你好',encoding='utf-8'))
print(len(ret)) # 字节的长度
print(ret) #<memory at 0x000001E263235F48> 地址
print(bytes(ret[:3]).decode('utf-8')) # 解码字节,范围是[0:3] 你
print(bytes(ret[3:]).decode('utf-8')) #解码字节 范围是[3:] 好
7.ord() chr() ascii()
# ord:输入字符找该字符编码的位置
print(ord('我')) # 25105
# chr:输入位置数字找出其对应的字符
print(chr(100)) #d
# ascii:是ascii码中的返回该值，不是就返回/u..
print(ascii('a')) #'a'
print(ascii('中')) #'u4e2d'
# 8.repr() dict() set() frozenset() len() sorted()
# repr() 返回一个对象的string形式（原形毕露）
name = 'taibai'
print('我叫%r'%name) # 我叫'taibai'
print(repr('{"name":"alex"}')) #'{"name":"alex"}' 有引号
print('{"name":"alex"}') #{"name":"alex"} 无引号
# set() 创建一个集合
# dict() 创建一个字典
# frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素
# len() 返回一个对象中元素的个数
sorted()
l = [('a', 1), ('c', 3), ('d', 4),('b', 2) ]
print(sorted(l,key=lambda x:x[1])) # [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
print(sorted(students,key=lambda x:x[2])) #[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
print(sorted(students,key=lambda x:x[2],reverse=True )) #[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
9.all() any() zip() filter() map()
# all() 可迭代对象中，全都是True才是True
print(all([1, 2, True, 0])) # False 最后一项是0
# any() 可迭代对象中，有一个True 就是True
print(any([1, '', 0])) #True
# zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
# 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同
li1=["1","2","3",]
li2=["a","b","c","d"]
li3=["*","**",(1,2,3),"2","4"]
print(zip(li,li2,li3)) #<zip object at 0x0000019722FE32C8>
for i in zip(li,li2,li3):
print(i) #(1, 'a', '*')
# filter() 过滤
def func(x):return x%2 == 0
ret = filter(func, [1, 2, 3, 4, 5, 6, 7])
print(ret)
for i in ret:
print(i) #2,4,6
# map() 会根据提供的函数对指定序列做映射
li=[1,2,3,4,5]
def func1(x):return x*x
ret=map(func1,li) #<map object at 0x0000026608732470>
print(ret)
for i in ret:
print(i)
print(map(lambda x:x**2,[1,2,3,4,5]))
for i in map(lambda x:x**2,[1,2,3,4,5]):
print(i)
10.匿名函数 一句话函数 变量=lambda 参数,参数冒号 返回值.
calc = lambda n:n**n
print(calc(10))
# 匿名函数 格式说明
#参数可以有多个，用逗号隔开
#匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
#返回值和正常的函数一样可以是任意数据类型
res = map(lambda x:x**2,[1,5,7,4,8])
for i in res:
print(i)
res = filter(lambda x: x > 10, [5, 8, 11, 9, 15])
for i in res:
print(i)