有名函式 下面這種函式定義方式，有函式名的嘛，func就是函式的名字，指向函式代碼在記憶體中的地址，加上括號就可以運行
def func(x,y):
return x+y
print(func) # <function func at 0x005A9540> func就是函式的名字，指向函式代碼在記憶體中的地址
匿名函式 lambda 不要問為什么，匿名函式就叫lambda 記住就可以，中文的釋義 就是沒有名字的函式，哈哈，英文我也沒找到出處，
lambda x,y: x+y # 它代表一個記憶體地址 <function <lambda> at 0x00270858>
(lambda x,y: x+y)(1,2) # 3， 記憶體地址加括號，傳引數后運行函式，但是一般不這樣用的
用lambda 去定義一個過渡的函式，是不是簡單很多了，這個通常用在 將函式做成一個‘橋’ 就是短暫的用一下下的時候，通常跟其他函式聯合使用，\
匿名函式，由于沒有名字，只是一串記憶體地址，所以它會被Python解釋器識別成 垃圾， 運行完了 就會被回收，
一、匿名函式的應用
dic = {'jack':5000,'joe':2000,'sue':6000} # 找出工資最高和最低的人
p1 = max(dic,key = lambda k: dic[k]) # max函式有兩個引數，一個可迭代物件，一個key = 函式的記憶體地址，key的意思是 對于可迭代物件按照key排序后取出最大值
p2 = min(dic,key = lambda k : dic[k])
dic_new = sorted(dic, key = lambda k : dic[k]) # 也是一樣，按照key去排序，默認升序）
1.map 函式
l = ['jack','joe','sue']
g= map(lambda name:name+'_l',l) # map 函式有兩個引數，前面是函式的記憶體地址（它決定這如何處理可迭代物件中的每個值），后面是可迭代物件，
print(g) # <map object at 0x005B8BD0> map()回傳的是一個可迭代物件，
l = [i.upper() for i in l] # 用串列生成式也是可以做的
2.filter 函式
l = ['jack','joe','sue','bob'] # 留下已e結尾的名字
g = filter(lambda name: name.endswith('e') , l) # filter 函式有兩個引數，前面是函式的記憶體地址（它接收可迭代物件傳進來的值，經過運算后，得到True或者False. filter會過濾掉結果為False的可迭代物件的值），后面是可迭代物件
print(g) # <filter object at 0x005B8BD0>
print(list(g)) # ['joe', 'sue']
g = [i for i in l if i.endswith('e')] # 用串列生成式也可以的
3.reduce 函式
reduce 是一個累加操作，不要問為什么reduce 是合并累加的意思，他就是這個意思，在Python 3中，reduce不是內置函式，需要從functools中匯入，
from functools import reduce
reduce(lambda x,y: x+y, [1,2,3],10) # 16 其實是從串列中取出一個值，跟初始值合并成一個....，重復操作，最后合并成一個值，初始值可以省略
除了數字的合并，reduce也可以用來做字串的合并
reduce(lambda x,y: x+y, [‘a','b','c'],'hello') # ‘helloabc’
3.zip 函式
zip()---> print(list(zip(("a", "b","C"), (1,2,3)))) # [('a', 1), ('b', 2), ('C', 3)]
p = {"name":"alex","age":18}
print(list(zip(p.keys(),p.values()))) # [('name', 'alex'), ('age', 18)]
salaries = {
'tom': 3000,
'jack': 122121221,
'rose': 100,
}
k_and_v = zip(salaries.values(), salaries.keys())
print(k_and_v) # <zip object at 0x0000000000C07BC8>
print(max(k_and_v)) # (122121221, 'jack')
#k_and_v是迭代器，因而只能訪問一次
# print(min(k_and_v)) #報錯了
k_and_v2 = zip(salaries.values(), salaries.keys())
# print(list(k_and_v2)) # [(3000, 'tom'), (122121221, 'jack'), (100, 'rose')]
# print(list(zip(k_and_v2))) #[((3000, 'tom'),), ((122121221, 'jack'),), ((100, 'rose'),)]
# print(list(zip(*k_and_v2))) #[(3000, 122121221, 100), ('tom', 'jack', 'rose')]
print(list(map(list, zip(*k_and_v2)))) #[[3000, 122121221, 100], ['tom', 'jack', 'rose']]
class zip(object)
| zip(iter1 [,iter2 [...]]) --> zip object
|
Return a zip object whose .__next__() method returns a tuple
where the i-th element comes from the i-th iterable argument.
The .__next__() method continues until the shortest iterable in the argument sequence is exhausted and then it raises StopIteration.
回傳一個zip物件，其剩余的next__()方法回傳一個元組
第i個元素來自第i個可迭代引數，
剩余的next__()方法一直持續到引數序列中最短的可迭代被耗盡，然后它拋出StopIteration，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/71720.html
標籤：Python
上一篇：python練習006
下一篇：模塊與包