**

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)]

#参数可以有多个，用逗号隔开

#匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值

#返回值和正常的函数一样可以是任意数据类型