1、昨日内容回顾
可迭代对象：内部含有__iter__方法的
迭代器：内部含有__iter__方法并且还含有__next__方法的
可迭代对象.__iter__()
判断可迭代对象，迭代器。
'__iter__' in dir(可迭代对象)
'__next__' in dir(可迭代对象)
isinstance(obj, Iterator)
isinstance(obj, Iterable)
迭代器：
节省内存。
惰性机制。
单向不可逆。
生成器：
生成器本质是迭代器，他是用python代码写的。
生成器函数。 yield
__next__ send()
生成器推导式。
[变量(加工后的变量) for 变量 in 可迭代对象] 遍历模式。
[变量(加工后的变量) for 变量 in 可迭代对象 if 条件] 筛选模式。
() 生成器推导式
2、内置函数
重点记忆
用域相关
**globals() 已字典的形式返回全局变量
**locals() 已字典的形式返回当前位置的局部变量
q = 666
def wrapper(argv):
a = 3
print(locals()) # 1 {a:3,argv:2}
def inner(argv1):
b = 4
c = 5
print(locals()) # 2 {b:4 c:5,argv1:6}
inner(6)
wrapper(2)
print(globals()) # 3
其他相关
1.2.1 字符串类型代码的执行 eval，exec，complie
***eval 去除字符串的引号，返回对应内部的值
s = '{"a":1,"b":3}'
dic = eval(s)
print(dic,type(dic))
print(eval('2 + 2'))
print(eval('print(666)'))
*** exec 执行字符串内部的代码
print(exec('1 + 1'))
ret = '''
name = input('请输入名字：').strip()
if name == 'alex':
print(666)
'''
exec(ret)
compile: pass
1.2.2 输入输出相关 input，print
name = input('请%s输入名字:' % 'alex')
print(name)
print(1, 2, 3,sep='*') # 设定打印元素的连接方式
print('alex', end='') # end控制的是换行
print('老男孩')
***f1 = open('log', encoding='utf-8', mode='w')
print('666', file=f1) # file 操作文件句柄，写入文件。
f1.close()
1.2.3内存相关 hash id
*hash 将不可变的数据通过hash算法转化成hash值
print(hash('name'))
print(hash('age'))
print(hash((1, 2, 3,)))
print(hash(1))
print(hash(100))
*print(id('name'))
1.2.3文件操作相关
open：函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
1.2.4模块相关__import__
__import__：函数用于动态加载类和函数 。
1.2.5帮助
*help：函数用于查看函数或模块用途的详细说明。
print(help(str))
1.2.6调用相关
*** callable：函数用于检查一个对象是否是可调用的。
如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
def func1():
print(666)
age = 16
print(callable('name'))
print(callable(age))
print(callable(func1))
1.2.7查看内置属性
** dir：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；
带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。
如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
print(dir(str))
1.3 迭代器生成器相关
*** range iter() next()
print(len(range(100)))
l = [1, 2, 3, 4, 5]
l_obj = l.__iter__()
l_obj = iter(l)
print(l_obj)
print(l_obj.__next__())
print(next(l_obj))
1.4.1数字相关（14）
数据类型（4）：
bool ：用于将给定参数转换为布尔类型，如果没有参数，返回 False。
int：函数用于将一个字符串或数字转换为整型。
print(int('123'))
print(int(1.234))
print(int(1.768))
float：函数用于将整数和字符串转换成浮点数。
complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。
如果第一个参数为字符串，则不需要指定第二个参数。。
i = 3.1415
print(i, type(i))
s = '1.234'
print(int(1.234))
print(float(s))
print(float(100))
bin：将十进制转换成二进制并返回。
print(bin(100))
oct：将十进制转化成八进制字符串并返回。
print(oct(10))
hex：将十进制转化成十六进制字符串并返回。
print(hex(13))
print(hex(18))
数学运算（7）：
**abs：函数返回数字的绝对值。
print(abs(-5))
***divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。
print(divmod(7, 3))
**round：保留浮点数的小数位数，默认保留整数。
print(round(1.234,2))
*pow：求x**y次幂。（三个参数为x**y的结果对z取余）
print(pow(2, 3)) # 2的三次幂
print(pow(2, 3, 3)) # 2的三次幂对3取余数
***sum：对可迭代对象进行求和计算（可设置初始值）。
print(sum([1, 2, 3, 4]))
print(sum([1, 2, 3, 4], 100))
*** min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。
print(min([1, 3, 5, 7, -4]))
print(min([1, 3, 5, 7, -4], key=abs))
*** max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。
print(max([1, 3, 5, 7, -4]))
print(max([1, 3, 5, 7, -9], key=abs))
1.4.2和数据结构相关（24）
列表和元祖（2）
list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。
tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。
tu = (1, 2, 3)
print(list(tu))
l1 = list((1, 2, 3))
l1 = list({'name':'alex','age':1000})
print(l1)
自己试
相关内置函数（2）
*** reversed：将一个序列翻转，并返回此翻转序列的迭代器。
l1 = [11, 22, 33, 44, 77, 66]
l_obj = reversed(l1)
# print(l_obj)
for i in l_obj:
print(i)
slice：构造一个切片对象，用于列表的切片。
l1 = [11, 22, 33, 44, 77, 66]
l2 = [111, 222, 333, 444, 777, 666]
# print(l1[1::2])
rule = slice(1, len(l2), 2)
print(l2[rule])
字符串相关（9）
str：将数据转化成字符串。
format:与具体数据相关，用于计算各种小数，精算等。
print(format('test', '<20')) # 左对齐
print(format('test', '>20')) # 右对齐
print(format('test', '^20')) # 居中
*** bytes：str---> bytes
s1 = 'alex'
# b1 = s1.encode('utf-8')
b2 = bytes(s1,encoding='utf-8')
# print(b1)
print(b2)
bytearray
ret = bytearray('alex', encoding='utf-8') # 类比：[97,103,....]
print(id(ret))
print(ret) # bytearray(b'alex')
print(ret[0])
ret[0] = 65
print(ret)
print(id(ret))
分字节去转换成str
b1 = bytes('你好',encoding='utf-8')
print(b1)
ret = memoryview(b1)
# print(len(ret))
# print(ret)
print(bytes(ret[:3]).decode('utf-8'))
print(bytes(ret[3:]).decode('utf-8'))
ord:输入字符找该字符编码的位置
print(ord('a'))
print(ord('中')) # unicode
chr:输入位置数字找出其对应的字符
print(chr(65))
print(chr(20013)) # unicode
ascii:是ascii码中的返回该值，不是就返回/u...
print(ascii('a'))
print(ascii(1))
print(ascii('中'))
*** repr:返回一个对象的string形式（原形毕露）。
msg = '小数%f' %(1.234)
print(msg)
msg = '姓名：%r' % ( 'alex')
print(msg)
print(repr('{"name":"alex"}'))
print('{"name":"alex"}')
数据集合（3）
dict：创建一个字典。
set：创建一个集合。
frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
dic = dict({'name': 'alex'})
print(dic)
set1 = set(('alex','wusir'))
print(set1)
相关内置函数（8）
*** len:返回一个对象中元素的个数。
*** sorted：对所有可迭代的对象进行排序操作。 返回的是列表
print(sorted([1, 2, 3, 4, 5, -6]))
print(sorted([1, 2, 3, 4, 5, -6], key=abs))
L = [('a', 1), ('c', 2), ('d', 4), ('b', 3), ]
print(sorted(L))
def func1(x):
return x[1]
L = [('a', 1), ('c', 2), ('d', 4),('b', 3), ]
print(sorted(L, key=func1))
*all：可迭代对象中，全都是True才是True
*any：可迭代对象中，有一个True 就是True
print(all([1, 'alex', True, (1,2,3)]))
print(all([0, 'alex', True, (1,2,3)]))
print(any([0, '', False, (1,2,3)]))
print(any([0, '', False, ()]))
***zip 拉链方法 返回的是一个迭代器
l1 = [1, 2, 3, 4]
tu1 = ('老男孩', 'alex', 'wusir')
l2 = ['*', '**', '***', "****"]
obj = zip(l1,tu1,l2)
for i in obj:
print(i)
***map: 循环模式
def func2(x):
return x**2
obj = map(func2, [1, 2, 3, 4])
for i in obj:
print(i)
print((i**2 for i in [1, 2, 3, 4]))
def func2(x, y):
return x + y
obj1 = map(func2, [1, 2, 3, 4, 6], (2, 3, 4, 5))
for i in obj1:
print(i)
***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)
print((i for i in [1, 2, 3, 4, 5, 6, 7] if i % 2 == 0))
***lambda 匿名函数 一句话函数
def func(x): return x % 2 == 0
def func1(x, y):
return x + y
ret = lambda x, y: x+y
print(ret(2,3))
def func1(x, y):
return x if x > y else y
ret = lambda x, y: x if x > y else y
print(ret(2,3))
def func(x):
return x % 2 == 0
ret = filter(lambda x:x % 2 == 0, [1, 2, 3, 4, 5, 6, 7])
print(ret)
for i in ret:
print(i)
[1, 2, 3, 4, 5, 6, 7] [1,4,9,16...] map lambda
ret2 = map(lambda x:x**2,[1, 2, 3, 4, 5, 6, 7])
for i in ret2:
print(i)
def func1(x):
return x[1]
L = [('a', 1), ('c', 2), ('d', 4),('b', 3), ]
print(sorted(L, key=func1))
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
l = sorted(students, key= lambda x: x[2],reverse=True)
print(l)
sorted max min map filter