day13匿名函數_ZenDei技術網路在線

補充知識點： 1. 匿名函數（用lambda構建）：一語句函數，比較簡單的函數。形式：lambda 參數 : 返回值 + lambda 參數 : 返回值：lambda後直接加形參，形參加多少都可以，但一般只用位置參數，參數之間需要用”，“隔開。 2. 內置函數： + int()：將字元串類型轉換為i ...

補充知識點：

def func(*args):
    for i in args:
        for j in i:
            yield i
print(list(func('asdf',(1,2,3))))     #list可以將生成器中的所有元素添加到列表中。

#簡化上述函數：
def func(*args):
    for i in args:
        yield from i  #優化了內層迴圈，提高了運行效率。

匿名函數（用lambda構建）：一語句函數，比較簡單的函數。形式：lambda 參數 : 返回值

def func(a,b):
    return a+b

#構建匿名函數：
func1 = lambda a,b:a+b
print(func1(1,2))

lambda 參數 : 返回值：lambda後直接加形參，形參加多少都可以，但一般只用位置參數，參數之間需要用”，“隔開。

#例1：接受一個可切片的數據，以元祖形式返回索引位0與2的對應元素
func = lambda a:(a[0],a[2])

#例2：接收兩個int參數，將較大的數據返回。
func = lambda a,b:a if a>b else b

內置函數：

int()：將字元串類型轉換為int類型；取整（舍尾法）
float()：將int和str轉換為float。
list()：將一個可迭代對象轉換成列表
tuple()：將一個可迭代對象轉換成元組
dict()：通過相應的方式創建字典。
abs()：返回絕對值
sum()：求和
reversed()：將一個序列翻轉，返回翻轉序列的迭代器。與列表的方法l1 .reverse()區分.
complex：創建一個值為real+imag*j的複數；轉換一個str或int為複數，如果第一個參數為str則不需要傳遞第二個參數。(複數：complex)
```
print(complex('1'))    #(1+0j)
```
bin：將十進位轉換為二進位字元串並返回。
oct：將十進位轉換為八進位字元串並返回。
hex：將十進位轉換為十六進位字元串並返回。
divmod：計算除數與被除數的結果，返回一個包含商和餘數的元祖（a//b,a%b)
round：保留浮點數的位數，預設保留整數。
pow：求x**y的次冪，並可以對所求結果對第三個參數取餘
```
print(pow(2,2))      #2**2   4
print(pow(2,2,3))    #(2**2)%3    1  
```

bytes：用於不同編碼之間的轉換。

s1 = '你好'
bs1 = s1.encode('utf-8')
print(bs1)
#b'\xe4\xbd\xa0\xe5\xa5\xbd'

s2 = bs1.decode('utf-8')
print(s1)
#你好

s3 = '你好'
bs2 = bytes(s3,encoding='utf-8')
print(bs2)
#b'\xe4\xbd\xa0\xe5\xa5\xbd'

bs3 = str(bs2,encoding='utf-8')
print(bs3)
#你好

ord()：輸入字元找該字元編碼的位置。（如果在ASCII碼中就用ASCII碼，否則用Unicode）
chr()：輸入位置數字找出其對應的字元。（如果在ASCII碼中就用ASCII碼，否則用Unicode）
repr()：返回一個對象的string形式。（str帶有引號的形式），在格式化輸出時常用（%r）。
```
s1 = 'python'
print('i love %r'%(s1))   #i love 'python'
```
print()：源碼分析：print(self, *args, sep=' ', end='\n', file=None):
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
file: 預設是輸出到屏幕，如果設置為文件句柄，輸出到文件
sep: 列印多個值之間的分隔符，預設為空格
end: 每一次列印的結尾，預設為換行符
flush: 立即把內容輸出到流文件，不作緩存
```
print(1,2,3)   #1 2 3
print(1,2,3,sep='@')   # 1@2@3
print(1,2,3,end='')   #不換行
```
all()：可迭代對象中，全為True才是True。
any()：可迭代對象中，有一True即為True。
zip()：拉鏈方法；函數用於將可迭代的對象作為參數,將對象中對應的元素打包成一個個元組,然後返回由這些元祖組成的內容,如果各個迭代器的元素個數不一致,則按照長度最短的返回。
```
lst1 = [1,2,3]
lst2 = ['a','b','c','d']
lst3 = (11,12,13,14,15)
for i in zip(lst1,lst2,lst3):
    print(i)
#(1, 'a', 11)  (2, 'b', 12)  (3, 'c', 13)
```

min()：求最小值，可以與函數結合(key：自動將可迭代對象中的每個元素按照順序傳入key對應的函數中，然後以返回值比較大小,key=一定是函數名，不能加（)，。min/max預設會按照字典的鍵去比較大小，但可以自己規定。

#以絕對值的方式取最小值
l1 = [1,2,-1,-5,3]
def func(s):
    return abs(s)
print(min(l1,key=func))   #1
#也可以直接使用匿名函數：
print(min(l1,key=lambda s:abs(s)))    #1

dic = {'a':3,'b':2,'c':1}
min(dic)   #a     預設以鍵排序，返回鍵 

#以值比較：
print(min(dic,key=lambda s:dic[s]))   #c   以值排序，返回鍵（返回的是迴圈的元素，而不是經函數轉換後比較的值。

max()：求最大值，可以與函數結合,同min()。

sorted()：排序函數；語法: sorted(iterable,key=None,reverse=False)

iterable: 可迭代對象

key: 排序規則(排序函數)，返回列表。在sorted內部會將可迭代對象中的每一個元素傳遞給這個函數的參數.根據函數運算的結果進行排序

reverse: 是否是倒敘,True：倒敘；False：正序

lst = [1,3,2,5,4]
lst2 = sorted(lst)
print(lst)  # 原列表不會改變
print(lst2)  # 返回的新列表是經過排序的

lst3 = sorted(lst,reverse=True)
print(lst3)  # 倒敘

#字典使用sorted排序
dic = {1: 'a',3: 'c',2: 'b'}
print(sorted(dic))  #[1,2,3] 字典排序返回的就是排序後的key 


#和函數組合使用
# 定義一個列表,然後根據一元素的長度排序
lst = ['1','111','11','1111']
# 計算字元串的長度
def func(s):
    return len(s)
print(sorted(lst,key=func))  #['1','11','111','1111']

lst = [{'id': 1,'name': 'a','age': 18},
       {'id': 2,'name': 'b','age': 17},
       {'id': 3,'name': '3','age': 16},]
# 按照年齡對學生信息進行排序
print(sorted(lst,key=lambda e: e['age']))

#[{'id': 3,'name': 'taibai','age': 16},{'id': 2,'name': 'wusir','age': 17},{'id': 1,'name': 'alex','age': 18}]

filter()：篩選過濾，返回一個迭代器（可與列表推導式的篩選模式進行對比）；語法: filter(function,iterable)

function: 用來篩選的函數,在filter中會自動的把iterable中的元素傳遞給function,然後根據function返回的True或者False來判斷是否保留此項數據iterable:可迭代對象

lst = [{'id':1,'name':'a','age':18},
        {'id':2,'name':'b','age':17},
        {'id':3,'name':'c','age':16},]

ls = filter(lambda e:e['age'] > 16,lst)
print(list(ls))

#[{'id': 1, 'name': 'alex', 'age': 18},{'id': 1, 'name': 'wusir', 'age': 17}]

map()：映射函數，反悔一格迭代器（可與列表推導式的迴圈模式對比）；語法: map(function,iterable) 可以對可迭代對象中的每一個元素進映射,分別取執行function。

#例1;計算列表中每個元素的平方,返回新列表
lst = [1,2,3,4,5]
print(map(lambda s:s*s,lst))   #<map object at 0x000002B2A4F04B88>
print(list(map(lambda s:s*s,lst)))

#例2;計算兩個列表中相同位置的數據的和
lst1 = [1, 2, 3, 4, 5]
lst2 = [2, 4, 6, 8, 10]
print(list(map(lambda x, y: x+y, lst1, lst2)))

reduce()：reduce(函數名,可迭代對象) # 這兩個參數必須都要有,缺一個不行

from functools import reduce
def func(x,y):
    return x + y
ret = reduce(func,[1,2,3])
print(ret)  # 結果 6
#reduce的作用是先把列表中的前倆個元素取出計算出一個值然後臨時保存著,接下來用這個臨時保存的值和列表中第三個元素進行計算,求出一個新的值將最開始臨時保存的值覆蓋掉,然後在用這個新的臨時值和列表中第四個元素計算.依次類推。註意:我們放進去的可迭代對象沒有更改

#現在有[1,2,3,4]想讓列表中的數變成1234
from functools import reduce
def func(x,y):
	return x * 10 + y
l1 = reduce(func,[1,2,3,4])
print(l1)
# 第一次的時候 x是1 y是2  x乘以10就是10,然後加上y也就是2最終結果是12然後臨時存儲起來了
# 第二次的時候x是臨時存儲的值12 x乘以10就是 120 然後加上y也就是3最終結果是123臨時存儲起來了
# 第三次的時候x是臨時存儲的值123 x乘以10就是 1230 然後加上y也就是4最終結果是1234然後返回了


#進階：使用匿名函數版
l = reduce(lambda x,y:x*10+y,[1,2,3,4])
print(l)

在Python2.x版本中recude是直接 import就可以的, Python3.x版本中需要從functools這個包中導入。

閉包：全局變數，數據不安全。使用局部變數，保證數據的安全。當內層函數對外層函數非全局變數的引用（使用）時，就會形成閉包。被引用的非全局變數也稱作自由變數，這個自由變數會與內層函數產生一個綁定關係，令自由變數不會再記憶體中消失。閉包現象只能存在函數的嵌套中。

判斷一個函數有沒有自由變數：

def func1():
    l1= []
    def func2(num):
        l1.append(num)
        return l1
    return func2
a = func1()
# 函數名.__code__.co_freevars 查看函數的自由變數
print(a.__code__.co_freevars)  # ('l1',)

# 函數名.__code__.co_varnames 查看函數的局部變數
print(a.__code__.co_varnames)  # ('num',)

# 函數名.__closure__ 獲取具體的自由變數對象，也就是cell對象。
print(a.__closure__)
#(<cell at 0x000001EE151AC738: list object at 0x000001EE135851C8>,)

# cell_contents 自由變數具體的值
print(a.__closure__[0].cell_contents)  # []