python--map、reduce、filter、sorted

• map
• reduce
• filter
• sorted

map

map()函數是 Python 內置的高階函數，它接收一個函數 f 和一個list(或多個 list,但list個數與f函數的參數個數必須相等)，並通過把函數 f 依次作用在 list 的每個元素上，得到一個新的 list 並返回。
簡而言之，map（）函數可以把一個list，轉換爲另一個新的list，它並不改變原來的list。

1.簡單使用

# 1.map(function, iterable, ...)
# 根據提供的函數對指定序列做映射
# function需要幾個參數，後面就需要跟幾個可迭代變量iterable
# 返回值是一個迭代器
map(lambda x: x ** 2, [1, 2, 3, 4, 5])

# 多參數時，以短的爲準
list(map(lambda x, y: x + y, ['a', 'b'], ['c', 'd', 'e'])) =》['ac', 'be']

2.特殊用法：做類型轉換

l = map(int,'1234')
for i in l:
    print(type(i))
    print(i)
a=(1,2,3,4,5)
b=[1,2,3,4,5]
c="zhangkang"

la=map(str,a)
lb=map(str,b)
lc=map(str,c)

reduce

格式：reduce( func, seq[, init] )=>list
注意：
（1）python3需要這樣導入：from functools import reduce
（2）對比與map返回迭代器，這裏由於結果是一個值，所以返回的不是迭代器，是基本數據類型

reduce函數即爲化簡，它是這樣一個過程：每次迭代，將上一次的迭代結果（第一次時爲init的元素，如沒有init則爲seq的第一個元素）與下一個元素一同執行一個二元的func函數。在reduce函數中，init是可選的，如果使用，則作爲第一次迭代的第一個元素使用。

簡單來說，可以用這樣一個形象化的式子來說明
reduce( func, [1, 2,3,4] ) = func(func( func(1, 2), 3),4)

舉個例子來說，階乘是一個常見的數學方法，Python中並沒有給出一個階乘的內建函數，我們可以使用reduce實現一個階乘的代碼。

# reduce實現累加--無初始值init
>>> from functools import reduce
>>> reduce(lambda x,y:x+y, range(0,101))
5050
# reduce實現累加--有初始值init
>>> reduce(lambda x,y:x+y, range(0,101), 100)
5150

# reduce實現階乘
>>> reduce(lambda x,y:x*y, range(1,5))
24

filter

filter() 函數用於過濾序列，過濾掉不符合條件的元素，返回一個迭代器對象，如果要轉換爲列表，可以使用 list() 來轉換。

該接收兩個參數，第一個爲函數，第二個爲序列，序列的每個元素作爲參數傳遞給函數進行判，然後返回 True 或 False，最後將返回 True 的元素放到新列表中。

格式：filter(function, iterable)

把iterable中的每個值傳入function函數，保留return值爲True的值放入結果列表中，是一個迭代器

#過濾出列表中的所有奇數：
def is_odd(n):
    return n % 2 == 1
 
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist) ==》[1, 3, 5, 7, 9]

# 過濾掉後綴爲sb的人名--去掉sb
name = ['alex', 'nihao_sb', 'haha', 'haha_sb']
list(filter(lambda x:not x.endswith('sb'), name))
# 過濾出後綴爲sb的人名--保留sb
name = ['alex', 'nihao_sb', 'haha', 'haha_sb']
list(filter(lambda x: x.endswith('sb'), name))

# 過濾出age大於1001的
name = [
    {"name": 'alex', 'age': 1000},
    {"name": 'wupeiqi', 'age': 10000},
    {"name": 'yaunhao', 'age': 9000},
    {"name": 'linhaifeng', 'age': 18}
]
print(list(filter(lambda x: x['age'] >= 1001, name)))
# 或者也可以用列表解析式
l = [i for i in name if i.get('age') >= 1001]

sorted

sort 與 sorted 區別：
sort 是應用在 list 上的方法，sorted 可以對所有可迭代的對象進行排序操作。
list 的 sort 方法返回的是對已經存在的列表進行操作，而內建函數 sorted 方法返回的是一個新的 list，而不是在原來的基礎上進行的操作。

格式：sorted(iterable, key=None, reverse=False)

iterable – 可迭代對象。
key --主要是用來進行比較的元素，只有一個參數，具體的函數的參數就是取自於可迭代對象中，指定可迭代對象中的一個元素來進行排序。
reverse – 排序規則，reverse = True 降序 ， reverse = False 升序（默認）。
res=>返回重新排序的列表(一個新列表，不會影響原列表)。

示例：

>>>sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]  

你也可以使用 list 的 list.sort() 方法。這個方法會修改原始的
list（返回值爲None）。通常這個方法不如sorted()方便-如果你不需要原始的
list，list.sort()方法效率會稍微高一些；另一個區別在於list.sort() 方法只爲 list 定義。而 sorted()
函數可以接收任何的 iterable。

>>>a=[5,2,3,1,4]
>>> a.sort()
>>> a
[1,2,3,4,5]

sort和sorted的區別
雖然python3中sort()和sorted()都可以用來排序，但二者有以下兩個最主要的區別：
sort只能應用在列表list上，而sorted可以對所有可迭代的對象進行排序的操作
sort方法會在原list上直接進行排序，不會創建新的list。而sorted方法不會對原來的數據做任何改動，排序後的結果是新生成的。如果我們不需要原來的數據而且數據是list類型，可以用sort方法，能夠節省空間。否則要用sorted方法。

sort 在python2中，sort方法可以有3個參數：key、cmp和reverse。但在python3中取消了cmp這個參數，只有key和reverse兩個可選參數。參數reverse指定排序是正序還是倒序，默認是正序FALSE，不在多說。參數key指定了只含一個參數的方法，這個方法用來從列表的每個元素中提取比較鍵。可以看看下面幾個例子：

1.通過元素長度排序
> strlist = ["bbb","ccc","bac","ab","ba"]
strlist.sort(key=len)
print(strlist)==》['ab', 'ba', 'bbb', 'ccc', 'bac']

2.通過元素的字符順序
strlist = ["bbb","BBB","bAc","ab","bac"]
strlist.sort()
print(strlist)==》['BBB', 'ab', 'bAc', 'bac', 'bbb']
strlist.sort(key=str.lower)
print(strlist)==》['ab', 'bAc', 'bac', 'BBB', 'bbb']

3.list裏的元素是一個字典，通過字典的某個屬性值排序。下面是通過學生的年齡排序
student = [{"name": "a", "age": 12, "score": 90},
           {"name": "b", "age": 13, "score": 84},
           {"name": "c", "age": 14, "score": 85},
           {"name": "d", "age": 15, "score": 89},
           {"name": "e", "age": 15, "score": 92},
           {"name": "f", "age": 16, "score": 89},
           {"name": "g", "age": 16, "score":70},
           {"name": "h", "age": 16, "score":90},
           {"name": "i", "age": 12, "score": 88}]
student.sort(key=lambda a: a["age"])
4.存在二級排序:
(1)先按照age、再按照score
student.sort(key=lambda a: (a["age"],a["score"]))
(2)先按照score、再按照age
student.sort(key=lambda a: (a["score"],a["age"]))

sorted
所有可以迭代的對象都可以用sorted來進行排序，排序不會改變原來的對象。sorted接收3個參數：
sorted(iterable, *, key=None, reverse=False)
其中key，reverse和sort函數相同

student_tuples = [('john', 'A', 15),('jane', 'B', 12),('dave', 'B', 10)]
new_tuples = sorted(student_tuples, key=lambda student: student[2])
print(student_tuples)==>[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
print(new_tuples)==>[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]

由於這種含有key參數的方法很普遍，所以python中提供了一些方法使得訪問器函數更加方便。比如operator模塊中的itemgetter(), attrgetter()方法。

from operator import itemgetter
data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]
# 對第2個元素排序
print(sorted(data, key=itemgetter(0))) ==>[('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]
# 對第1個元素排序
print(sorted(data, key=itemgetter(1))) ==>[('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]
# 先對元組的第2個元素進行排序，然後對第一個元素進行排序，形成多級排序
print(sorted(data, key=itemgetter(1, 0))) ==>[('blue', 1), ('red', 1), ('blue', 2), ('red', 2)]

student = [{"name": "a", "age": 12, "score": 90},
           {"name": "b", "age": 13, "score": 84},
           {"name": "c", "age": 14, "score": 85},
           {"name": "d", "age": 15, "score": 89},
           {"name": "e", "age": 15, "score": 92},
           {"name": "f", "age": 16, "score": 89},
           {"name": "g", "age": 16, "score":70},
           {"name": "h", "age": 16, "score":90},
           {"name": "i", "age": 12, "score": 88}]
sorted(student, key=itemgetter('score', 'age')))