引數是函式的函式就是實參高階函式
def func4(f):
# f=func1
print(f(10, 20) * 2) # print(func1(10, 20)*2)
def func1(*nums):
return [1, 2]
func4(func1)
普通用法：max/min（序列） - 求序列中元素的最大/小值（序列中元素的型別必須一致，而且元素必須支援比較運算）
實參高階函式：
max/min（序列，key=函式） - 通過函式來定製求最大值的方式
序列 - 需要獲取某種最大值/最小值對應的序列
函式 - 又且只有乙個引數（指向/代表序列每乙個元素）；有乙個返回值(求最大值的時候的比較物件)
nums = [93, 45, 67, 122]
# 求最大的元素
print(max(nums))
# 求個位數最大的元素
result = max(nums, key=lambda item: item % 10)
print(result) # 67
# 求十位數最大的元素
result = max(nums, key=lambda item: item // 10 % 10)
print(result)
用法一：sorted（序列） - 將序列中的元素按照元素的大小從小到大排序
用法二:
sorted(序列，key=函式)
函式 - 有且只有乙個引數（指向/代表序列中的每個元素）；有乙個返回值(比較返回值的大小進行排序的；返回值就是排序標準）
nums = [115, 34, 62, 89, 102]
# a.按序列元素大小排序
result = sorted(nums, key=lambda item: item)
print(result) # [34, 62, 89, 102]
# b.按照序列元素的個位數的大小排序
result = sorted(nums, key=lambda item: item % 10)
print(result)
map（函式，序列） - 通過原序列中元素進行指定的變換後產生乙個新的序列(返回的是map物件，本質是序列)
函式 - 有且只有乙個引數(指向/代表後面的序列中的元素)；有乙個返回值(新序列中的元素)
用法二：
map（函式，序列1，序列2） - 產生乙個新的序列，序列中的元素是序列1和序列2中元素通過指定的變換產生的
函式 - 有且只有兩個引數(這個兩個引數分別指向序列1中的元素和序列2中的元素)
有乙個返回值(新序列中的元素)
# 產生乙個新的列表，列表中是nums中元素的平方
nums = [1, 2, 3, 4]
result = list(map(lambda item: item**2, nums))
print(result) # [1, 4, 9, 16]
# 產生乙個新的列表，列表中的元素是seq1中加上seq2中的元素
seq1 = (1, 2, 3, 4)
seq2 = [5, 6, 7, 8]
result = list(map(lambda item1, item2: item1+item2, seq1, seq2))
print(result) # [6, 8, 10, 12]
eval(序列字串) - 將滿足規範格式的序列的字串轉換成序列
dict1 =
dict1_str = str(dict1) # ""
dict2 = eval(dict1_str)
print(dict2, type(dict2)) # list_str = "[1, 2, 3, 4]"
list1 = eval(list_str)
print(list1, type(list1)) # [1, 2, 3, 4]
用法一：
reduce（函式，序列） - 將序列中的元素通過指定的規則合併成乙個資料
函式 - 有且只有兩個引數, 第乙個引數第一次呼叫的時候指向序列中的第乙個元素，從第二次開始都是指向上一次運算的結果;
返回值是每一次合併的結果（用來定製合併規則的）
用法二：
reduce（函式，序列，初始值）
函式：第乙個引數：第一次指向初始值；從第二次開始引數指向上次合併的結果
第二個引數：指向序列中所有的元素
返回值：每一次合併的結果（用來定製合併規則的）
# **********====用法一(了解)***************==
nums = [10, 11, 12, 13, 14]
def func1(x, y):
print(f'x:, y:')
return x+y
"""第一次： x=10; y=11； x=x+y,
第二次： x=21; y=12; x=x+y
第三次: x=33; y=13; x=x+y
第四次: x=46; y=14; x=x+y
..."""
result = reduce(func1, nums)
print(result)
# **********====用法二(掌握)***************==
nums = [10, 11, 12, 13, 14]
def func2(x, y):
print(f'x:, y:')
return x+y
result = reduce(func2, nums, 0)
print(result)
方式一：直接在需要新增功能的函式中新增新功能對應的**（缺點：同樣的功能的**可能需要寫多遍）
def func1():
start = time.time()
print('hello world!')
end = time.time()
def func2(x, y):
start = time.time()
z = x+y
print('和:', z)
end = time.time()
func1()
func2(10, 20)
def count_time(func, *args, **kwargs):
start = time.time()
# 執行原函式的功能
func(*args, **kwargs)
end = time.time()
def add_time(func):
def test(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
end = time.time()
print('action time:', end-start)
return result
return test
@add_time
def func3():
print('你好嗎')
@add_time
def func4(num):
print(num*2)
套路：
def 函式名1(引數1):
def 函式名2(*args, **kwarg):
result = 引數1(*args, **kwarg)
實現新增功能的**段
return result
return 函式名2
函式名1 - 裝飾器的名字（按照當前裝飾器新增的功能來命名）
引數1 - 這個引數是用來接受被新增功能的函式（指向原函式），一般直接命名成: func
函式名2 - 表示的是在原函式的基礎上新增完功能的新函式， 一般直接命名成乙個固定的名字：test、new_func
使用裝飾器：在需要新增功能的函式的定義前加：@裝飾器名
def end(func):
def new_func(*args, **kwargs):
result = func(*args, **kwargs)
print('*****=函式結束*****==')
return result
return new_func
@end
def func5(x, y):
print(x+y)
day11 高階函式和裝飾器
什麼是實參高階函式 引數是函式的函式就是實參高階函式 系統實參高階函式的應用 max min，sorted，map，reduce 1 max min a.普通用法 max 序列 求序列中元素的最大值 序列中元素的型別必須一致，而且元素本身必須支援比較運算 b.實參高階函式 max 序列,key 函式...
day11 函式高階
根據變數作用域 能使用的範圍 的不同將變數分為 全域性變數和區域性變數 1.全域性變數 沒有定義在函式裡面或者類裡面的變數都是全域性變數 全域性變數的作用域是從定義開始到程式結束 全域性變數可以在函式裡直接用 2.區域性變數 定義在函式裡面的變數就是區域性變數。區域性變數的作用域是從定義開始到函式結...
day11 閉包函式和裝飾器
目錄 閉包函式 裝飾器什麼是閉包函式？閉，封閉，把乙個函式封閉在另乙個函式裡面起來，就是定義在函式內部的函式 包，將它整體打包，同時引用外部函式作用域的名字，方便接下裡使用 x 56 defouter y 78 definner print x,y return inner 只要是呼叫了外部函式y的...