**
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))----------{'a': 1, 'b': 3} <class 'dict'>
print(eval('2 + 2'))-----------4
print(eval('print(666)'))--------666 \n None
***
exec 执行字符串内部的代码
print(exec('1 + 1'))--------------- None
ret = '''
name = input('请输入名字：').strip()
if name == 'alex':
print(666)
'''
exec(ret)--------会走这里面的程序
***
f1 = open('log', encoding='utf-8', mode='w')
print('666', file=f1) # file 操作文件句柄，写入文件。
f1.close()
1.2.6调用相关
***
callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
def func1():
print(666)
age = 16
print(callable('name'))-----------False
print(callable(age))-----------False
print(callable(func1))-----------True
1.2.7查看内置属性
**
dir：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。
如果参数包含方法__dir__()，该方法将被调用。如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
print(dir(str))
----------['__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']
1.3 迭代器生成器相关
***
range iter() next()
print(len(range(100)))---------------100
l = [1, 2, 3, 4, 5]
l_obj = l.__iter__()
l_obj = iter(l)
print(l_obj)----------------------<list_iterator object at 0x0000019742CD3828>
print(l_obj.__next__())-----------1
print(next(l_obj))-----------------2
数学运算（7）：
**
abs： 函数返回数字的绝对值。
print(abs(-5))---------5
***
divmod： 计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。
print(divmod(7, 3))--------------(2, 1)
**
round： 保留浮点数的小数位数，默认保留整数。
print(round(1.234,2))--------1.23【后面的2代表保留几位小数】
***
sum： 对可迭代对象进行求和计算（可设置初始值）。
print(sum([1, 2, 3, 4]))----------------10
print(sum([1, 2, 3, 4], 100))----------------110【后面的100代表从100开始】
***
min： 返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。
print(min([1, 3, 5, 7, -4])) ------------------- -4
print(min([1, 3, 5, 7, -4], key=abs))--------------- 1 【key=abs代表按照绝对值取值】
***
max： 返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。
print(max([1, 3, 5, 7, -4]))-------------------------7
print(max([1, 3, 5, 7, -9], key=abs))-------------- -9 【key=abs代表按照绝对值取值】
1.4.2和数据结构相关（24）
相关内置函数（2）
***
reversed： 将一个序列翻转，并返回此翻转序列的迭代器。
l1 = [11, 22, 33, 44, 77, 66]
l_obj = reversed(l1)
for i in l_obj:
print(i)-----------答案翻转，遍历
***
bytes：str---> bytes
s1 = 'alex'
①
b1 = s1.encode('utf-8')
print(b1)--------------b'alex'
②
b2 = bytes(s1,encoding='utf-8')
print(b2)--------------b'alex'
***
repr: 返回一个对象的string形式（原形毕露）。
msg = '小数%f' %(1.234)
print(msg)----------------------小数1.234000
msg = '姓名：%r' % ( 'alex')
print(msg)----------------------姓名：'alex'
print(repr('{"name":"alex"}'))------------------'{"name":"alex"}'
print('{"name":"alex"}')------------------------{"name":"alex"}
相关内置函数（8）
***
len: 返回一个对象中元素的个数。
***
sorted： 对所有可迭代的对象进行排序操作。 返回的是列表 , key
print(sorted([1, 2, 3, 4, 5, -6]))------------[-6, 1, 2, 3, 4, 5]
print(sorted([1, 2, 3, 4, 5, -6],key=abs))------------[1, 2, 3, 4, 5, -6]
L = [('a', 1), ('c', 2), ('d', 4), ('b', 3), ]
print(sorted(L))-----------------[('a', 1), ('b', 3), ('c', 2), ('d', 4)]
def func1(x):
return x[1]
L = [('a', 1), ('c', 2), ('d', 4),('b', 3), ]
print(sorted(L, key=func1))-------------按照元组后面的元素排序[('a', 1), ('c', 2), ('b', 3), ('d', 4)]
***
zip 拉链方法 返回的是一个迭代器
l1 = [1, 2, 3, 4]
tu1 = ('老男孩', 'alex', 'wusir')
l2 = ['*', '**', '***', "****"]
obj = zip(l1,tu1,l2)
for i in obj:
print(i)
------------------- (1, '老男孩', '*')
(2, 'alex', '**')
(3, 'wusir', '***')
***
map: 循环模式 key
①
def func2(x):
return x**2
obj = map(func2, [1, 2, 3, 4])
for i in obj:
print(i)#------------------1 \n 4 \n 9 \n 16
②
print([i**2 for i in [1, 2, 3, 4]])-------------------[1, 4, 9, 16]
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) ------------------3 \n 5 \n 7 \n 9
***
filte 过滤 通过你的函数，过滤一个可迭代对象，返回迭代器 key
筛选模式
def func(x):
return x % 2 == 0
ret = filter(func,[1, 2, 3, 4, 5, 6, 7])
print(ret)---------------<filter object at 0x0000020FE9CEFF60>
for i in ret:
print(i)-------------2 \n 4 \n 6
print([i for i in [1, 2, 3, 4, 5, 6, 7] if i % 2 == 0])-------------------[2, 4, 6]
***
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))#-----------------5
①：普通三元运算
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))#----------------3
①：普通筛选
def func(x):
return x % 2 == 0
②：lambda 方法筛选
ret = filter(lambda x:x % 2 == 0, [1, 2, 3, 4, 5, 6, 7])
for i in ret:
print(i)#--------------------2 \n 4 \n 6
[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)-----------------------1 \n 4 \n 9 \n 16 \n 25 \n 36 \n 49
def func1(x):
return x[1]
L = [('a', 1), ('c', 2), ('d', 4),('b', 3), ]
print(sorted(L, key=func1))---------------------[('a', 1), ('c', 2), ('b', 3), ('d', 4)]
①按照元组内最后一位元素正序
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
l = sorted(students, key= lambda x: x[2])
print(l)----------------[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
②按照元组内最后一位元素倒序
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
l = sorted(students, key= lambda x: x[2],reverse=True)
print(l)----------------[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
#参数可以有多个，用逗号隔开
#匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
#返回值和正常的函数一样可以是任意数据类型