day14——內置函數

**

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

#參數能夠有多個，用逗號隔開

#匿名函數無論邏輯多複雜，只能寫一行，且邏輯執行結束後的內容就是返回值

#返回值和正常的函數同樣能夠是任意數據類型