python中有許多內置函式，不像print那么廣為人知，但它們卻例外的強大，用好了可以大大提高代碼效率，

Python3_函式：高價函式

一、編程的3種方法：

• 面向程序：將一個大問題分成若干個小問題進行逐一的處理
• 函式式編程：是將編程語言的函式和數學意義的函式相結合，如y=2*x+1相當于

def func(x):
    return 2 * x + 1

• 面向物件：將事物的本質通過建立一系列模型來體現出事物的本質和特征

二、高階函式：

1、高階函式的定義：

• 函式接收的引數可以是另一個函式的函式名
• 在函式的回傳值中包含于一個函式名

2、3個常用的內置高階函式：

2.1：map()函式：

• 將串列[1, 2, 3, 4]中的每個元素進行加10

方法1：

list01 = [1, 2, 3, 4]

def func(x):
    return x + 10

def add_num(function, array):
    res = []
    for i in array:
        res.append(function(i))
    return res

print(add_num(func, list01))

方法2：

list01 = [1, 2, 3, 4]

def add_num(function, array):
    res = []
    for i in array:
        res.append(function(i))
    return res

print(add_num(lambda x:x+10, list01))

使用map()函式：

list01 = [1, 2, 3, 4]

print(list(map(lambda x:x+10, list01)))

運行結果：

[11, 12, 13, 14]

map()函式的用法：
map(處理方法, 可迭代物件)

功能：
對可迭代物件中的每個元素按照指定的處理方法進行操作，最后以迭代型別輸出，可將其轉換為相應的資料型別進行輸出

2.2：filter()函式：

• 將串列[{“class”:101, “name”:“zhang”},{“class”:102, “name”:“li”},{“class”:201, “name”:“wang”},{“class”:202, “name”:“zhao”}]中的年級是一年級的洗掉

方法1：

def func(x):
    return x["class"][0]

def class_list(function, array):
    new_list = []
    for i in array:
        if function(i) != "1":
            new_list.append(i)
    return new_list

print(class_list(func, student_list))

方法2：

def class_list(function, array):
    new_list = []
    for i in array:
        if function(i) != "1":
            new_list.append(i)
    return new_list

print(class_list(lambda x:x["class"][0], student_list))

filter()方法：

print(list(filter(lambda x:x["class"][0] != "1", student_list)))

運行結果：

[{‘class’: ‘201’, ‘name’: ‘wang’}, {‘class’: ‘202’, ‘name’: ‘zhao’}]

filter()函式的用法：
filter(處理方法, 可迭代物件)

“處理方法”得到的結果必須是一個布林值

功能：
將可迭代物件中的元素按照指定的處理方法進行刪選后以迭代型別輸出，可將其轉換為相應的資料型別進行輸出

2.3：reduce()函式：

在Python2中可直接使用reduce()函式，在Python3中需要匯入functools模塊后才能使用，

• 將串列[2, 3, 4, 10]中的元素跟指定的初始值(可選)累乘后進行輸出

方法1：
情況1：沒有指定初始值

def func(x, y):
    return x * y

def times(function, array, init=None):
    if init == None:
        res = 1
    else:
        res = init
    for num in array:
        res = function(res, num)
        # res *= num
    return res

print(times(func, list01))

情況2：指定初始值

def func(x, y):
    return x * y

def times(function, array, init=None):
    if init == None:
        res = 1
    else:
        res = init
    for num in array:
        res = function(res, num)
        # res *= num
    return res

print(times(func, list01, 100))

方法2：
情況1：沒有指定初始值

def times(function, array, init=None):
    if init == None:
        res = 1
    else:
        res = init
    for num in array:
        res = function(res, num)
        # res *= num
    return res

print(times(lambda x,y:x*y, list01))

情況2：指定初始值

def times(function, array, init=None):
    if init == None:
        res = 1
    else:
        res = init
    for num in array:
        res = function(res, num)
        # res *= num
    return res

print(times(lambda x,y:x*y, list01, 100))

reduce()方法：
情況1：沒有指定初始值

from functools import reduce

print(reduce(lambda x,y:x*y, list01))

情況2：指定初始值

from functools import reduce

print(reduce(lambda x,y:x*y, list01, 100))

reduce()函式用法：
reduce(處理方法, 可迭代物件, 初始值)

功能：
將可迭代物件中的元素按照制定的處理方法進行運算后輸出

set()

當需要對一個串列進行去重操作的時候，set()函式就派上用場了，

obj = ['a','b','c','b','a']
print(set(obj))
# 輸出：{'b', 'c', 'a'}

set([iterable])用于創建一個集合，集合里的元素是無序且不重復的，

集合物件創建后，還能使用并集、交集、差集功能，

A = set('hello')
B = set('world')

A.union(B) # 并集，輸出：{'d', 'e', 'h', 'l', 'o', 'r', 'w'}
A.intersection(B) # 交集，輸出：{'l', 'o'}
A.difference(B) # 差集，輸出：{'d', 'r', 'w'}

eval()

之前有人問如何用python寫一個四則運算器，輸入字串公式，直接產生結果，

用eval()來做就很簡單：

eval(str_expression)作用是將字串轉換成運算式，并且執行，

a = eval('[1,2,3]')
print(type(a))
# 輸出：<class 'list'>

b = eval('max([2,4,5])')
print(b)
# 輸出： 5

sorted()

在處理資料程序中，我們經常會用到排序操作，比如將串列、字典、元組里面的元素正/倒排序，

這時候就需要用到sorted() ，它可以對任何可迭代物件進行排序，并回傳串列，

對串列升序操作：

a = sorted([2,4,3,7,1,9])
print(a)
# 輸出：[1, 2, 3, 4, 7, 9]

對元組倒序操作：

sorted((4,1,9,6),reverse=True)
print(a)
# 輸出：[9, 6, 4, 1]

使用引數：key，根據自定義規則，按字串長度來排序：

chars = ['apple','watermelon','pear','banana']
a = sorted(chars,key=lambda x:len(x))
print(a)
# 輸出：['pear', 'apple', 'banana', 'watermelon']

根據自定義規則，對元組構成的串列進行排序：

tuple_list = [('A', 1,5), ('B', 3,2), ('C', 2,6)]
# key=lambda x: x[1]中可以任意選定x中可選的位置進行排序
a = sorted(tuple_list, key=lambda x: x[1]) 
print(a)
# 輸出：[('A', 1, 5), ('C', 2, 6), ('B', 3, 2)]

reversed()

如果需要對序列的元素進行反轉操作，reversed()函式能幫到你，

reversed()接受一個序列，將序列里的元素反轉，并最侄訓傳迭代器，

a = reversed('abcde')
print(list(a))
# 輸出：['e', 'd', 'c', 'b', 'a']

b = reversed([2,3,4,5])
print(list(b))
# 輸出：[5, 4, 3, 2]

唐_sri：https://www.jianshu.com/p/e2596e812bd5

IT入門 感謝關注 | 練習地址：www.520mg.com/it