文章目錄

• 高階函數
• • 回調函數
  • 閉包函數
  • • 特點：
  • 匿名函數 lambda 表達式
  • 迭代器
  • • iter()
    • next()
    • 迭代器的取值方案
    • 檢測迭代器和可迭代對象的方法
• 內置函數
• • range() 函數
  • • range函數的使用方式
    • 獲取range函數返回的數字序列的方法
  • zip() 函數
  • 其它內置函數
  • • 數據類型轉換相關內置函數
    • 變量相關函數
    • 數學相關函數
    • 進制相關函數
• 高階函數
• • sorted(iterable[reverse,key])排序
  • map(func, *iterables) 新迭代器
  • reduce(func,iterable)
  • filter(func,iterable)過濾數據

高階函數

##遞歸函數

遞歸函數就是定義了一個函數，然后在函數內，自己調用了自己這個函數

遞歸函數內必須要有結束，不然就會一只調用下去，直到調用的層數越來越多，棧溢出

遞歸函數是一層一層的進入，再一層一層的返回

普通戰甲套反浩克戰甲，套娃，

# 初步認識 遞歸函數 3 2 1 0 def digui(num):print(num) # 3 2 1 0# 檢測當前的值是否到了零if num > 0:# 調用函數本身digui(num-1)print(num) # 0 1 2 3digui(3)''' 解析當前遞歸函數的執行過程： digui(3) ==> 3 digui(3-1) ==> 2digui(2-1) ==> 1digui(1-1) ==> 0digui(0) ==> 0digui(1) ==> 1gidui(2) ==>2 digui(3) ==> 3 '''

回調函數

函數中的參數可以是任意類型的，那參數能不能是一個函數呢？

如果在一個函數中要求傳遞的參數是一個函數作為參數，并且在函數中使用了傳遞進來的函數，那么這個函數我們就可以稱為是一個回調函數

# 定義一個函數,函數中的一個參數要求是另一個函數 # 帶有回調函數參數的函數 # def func(f):# print(f,type(f))# 并且在函數中調用了傳遞進來的行參函數# f()# 回調函數 # def love(): # print('123') # # func(love)

閉包函數

既然可以把函數作為一個行參進行傳遞，作為回調函數，那么如果在一個函數中，返回了一個函數呢？

在一個函數內返回了一個內函數， 并且這個返回的內函數還使用了外函數中局部變量，這就是閉包函數

特點：

在外函數中定義了局部變量，并且在內部函數中使用了這個局部變量

在外函數中返回了內函數，返回的內函數就是閉包函數

?主要在于保護了外函數中的局部變量，既可以被使用，又不會被破壞

檢測一個函數是否為閉包函數，可以使用 函數名.__closure__如果是閉包函數返回 cell

# 定義一個函數 def person():money = 0 # 函數中定義了一個局部變量# 工作 定義的內函數def work():nonlocal money # 在內函數中使用了外函數的臨時變量money += 100print(money)# 在外函數中返回了內函數，這個內函數就是閉包函數return workres = person() # return work res = work res() # res() == work() res() res() res() # 此時 就不能夠在全局中對money這個局部變量進行任何操作了， # 閉包的作用：保護了函數中的變量不受外部的影響，但是又能夠不影響使用

匿名函數 lambda 表達式

匿名函數的意思就是說可以不使用def定義，并且這個函數也有沒有名字

在python中可以使用lambda表達式來定義匿名函數

注意：lambda表達式僅僅是一個表達式，不是一個代碼塊，所以lambda又稱為一行代碼的函數

lambda表達式也有行參，并且不能訪問除了自己的行參之外的任何數據包括全局變量

''' 語法： lambda [參數列表]:返回值 '''# 封裝一個函數做加法運算 # 普通函數 def jia(x,y):return x+y# print(jia(2,3))# 改成lambda表達式來封裝 res = lambda x,y:x+y # print(res(4,4))# 帶有分支結構的lambda 表達式 # lambda 參數列表: 真區間 if 表達式判斷 else 假區間 res = lambda sex:"很man" if sex=='男' else "很nice" print(res('女'))

迭代器

迭代器是python中最具特色的功能之一，是訪問集合元素的一種方式

迭代器是一個可以記住訪問遍歷的位置的對象

集合的第一個元素開始訪問，直到集合中的所有元素被訪問完畢

迭代器只能從前往后一個一個的便利，不能后退

能被next()函數調用，并不斷返回下一個值的對象稱為迭代器（Iterator 迭代器對象）

iter()

功能：把可迭代的對象，轉為一個迭代器對象

參數：可迭代的對象 （str，list，tuple，dict)

返回值： 迭代器對象

注意：迭代器一定是一個可以迭代的對象，但是可迭代對象不一定是迭代器

next()

next()函數可以去調用迭代器，并返回迭代器中的下一個數據

迭代器的取值方案

next() 調用一次獲取一次，直到數據被取完

list() 使用list函數直接取出迭代器中的所有數據

for 使用for循環遍歷迭代器的數據

迭代器取值的特點，取出一個少一個，直到都取完，最后再獲取就會報錯

檢測迭代器和可迭代對象的方法

from collections.abc import Iterator,Iterable varstr = '123456' res = iter(varstr) # type() 函數返回當前數據的類型， # isinstance() 檢測一個數據是不是一個指定的類型 r1 = isinstance(varstr,Iterable) # True 可迭代對象 r2 = isinstance(varstr,Iterator) # False 不是一個迭代器 r3 = isinstance(res,Iterable) # True 可迭代對象 r4 = isinstance(res,Iterator) # True 是一個迭代器 print(r1,r2) print(r3,r4) # 迭代器一定是一個可迭代的對象，可迭代對象不一定是迭代器

內置函數

內置函數就是在系統安裝完python解釋器時，由python解釋器給提供好的函數

range() 函數

如果你確實需要遍歷一個數字序列，內置函數 range() 會派上用場。它生成算術級數

range函數的使用方式

# 只寫一個參數，就是從零開始到10之前，9 # res = range(11)# 兩個參數時，第一個參數是開始的值，第二個參數是結束的值（在結束值之前） # res = range(5,10)# 三個參數， 參數1是開始值，參數2是結束值，參數三是步進值 # res = range(1,10,3)# 獲取一個倒敘的數字序列 # res = range(10,0,-1) # res = range(10,0,-2)res = range(-10,-20,-1) res = range(-20,-10) res = range(-10,10) print(list(res))

獲取range函數返回的數字序列的方法

res = range(10) # 1。轉為list列表數據 # print(list(res))# 2。通過 for循環 進行遍歷 # for i in res: # print(i)# 3。轉為迭代器，使用next函數調用 # res = iter(res) # print(next(res)) # print(next(res))

zip() 函數

功能：zip 函數是可以接受多個可迭代的對象，然后把每個可迭代對象中的第i個元素組合在一起，形成一個新的迭代器
參數：*iterables，任意個的 可迭代對象
返回值： 返回一個元組的迭代器

var1 = '1234' var2 = ['a','b','c'] var3 = ('A','B','C','D') # 調用zip函數，組成新的元組迭代器 res = zip(var1,var2,var3) # print(res,type(res))for i in res:print(i) ''' ('1', 'a', 'A') ('2', 'b', 'B') ('3', 'c', 'C') ('4', 'd', 'D') ''' # zip() 與 * 運算符相結合可以用來拆解一個列表: x = [1, 2, 3] y = [4, 5, 6] zipped = zip(x, y) print(list(zipped))print(zip(x, y)) # 迭代器對象， print(*zip(x, y))# 組合好的多個元組數據

其它內置函數

數據類型轉換相關內置函數

• int() 將其它類型數據轉為整型
• float() 轉為浮點類型
• bool() 轉為布爾類型
• complex() 轉為復數
• str() 轉為字符串類型
• list 轉為列表類型
• tuple 轉為元組類型
• dict 轉為字典類型
• set 轉為集合類型

變量相關函數

• id() 獲取當前數據的ID標識
• type() 獲取當前數據的類型字符串
• print() 數據的打印
• input() 獲取輸入的數據
• isinstance() 檢測是否為指定的數據類型

數學相關函數

# 獲取一個數的絕對值 # print(abs(-99.99))# 求和 從 start 開始自左向右對 iterable 中的項求和并返回總計值 # print(sum([1,2,3]))# 獲取最大值 # print(max([1,2,3])) # print(max(99,12,45))# 獲取最小值 # print(min([2,1,6,-9])) # print(min(6,7,1,0,-2))# 冪運算 返回 x 的 y 次冪 # print(pow(2,3))# 四舍五入 # r = round(3.1415926) # r = round(3.1415926,2) # 小數點保留幾位# r = round(4.5) # 奇進偶退 1.5 = 2 2.5=2,3.5=4,4.5=4 # print(r)

進制相關函數

# bin() 將數值類型轉為二進制 # print(bin(123)) # 0b1111011# int() 將二進制轉為整型 # print(int(0b1111011)) #1 23# oct() 轉為八進制數 01234567 # print(oct(123)) # 0o173# hex() 轉為十六進制數 0123456789abcdef # print(hex(123)) # 0x7b

高階函數

sorted(iterable[reverse,key])排序

sorted()
運行原理：
把可迭代數據里面的元素，一個一個的取出來，放到key這個函數中進行處理，
并按照函數中return的結果進行排序，返回一個新的列表
功能： 排序
參數：
iterable 可迭代的數據 （容器類型數據，range數據序列，迭代器）
reverse 可選，是否反轉，默認為False，不反轉， True反轉
key 可選， 函數，可以是自定義函數，也可以是內置函數
返回值： 排序后的結果

arr = [3,7,1,-9,20,10] # 默認按照從小到大的方式進行排序 # res = sorted(arr) # [-9, 1, 3, 7, 10, 20]# 可以按照從大到小的方式進行排序 # res = sorted(arr,reverse=True) # [20, 10, 7, 3, 1, -9]# 使用abs這個函數(求絕對值）作為sorted的key關鍵字參數使用 res = sorted(arr,key=abs) # print(res)# 使用自定義函數 # def func(num): # print(num,num % 2) # return num % 2 # # arr = [3,2,4,6,5,7,9] # # # 在sorted函數中使用自定義函數對數據進行處理 # res = sorted(arr,key=func) # print(res)## 優化版 arr = [3,2,4,6,5,7,9] res = sorted(arr,key=lambda x:x%2) print(res)

map(func, *iterables) 新迭代器

map(func, *iterables)
功能： 對傳入的可迭代數據中的每個元素放入到函數中進行處理，返回一個新的迭代器
參數：
func 函數 自定義函數|內置函數
iterables：可迭代的數據
返回值：迭代器

(1）把一個字符串數字的列表轉為 整型的數字列表 ['1','2','3','4'] # ==> [1,2,3,4] 普通的處理方法 varlist = ['1','2','3','4'] # ==> [1,2,3,4]# newlist = [] for i in varlist:newlist.append(int(i)) print(newlist)使用map函數進行處理 varlist = ['1','2','3','4'] res = map(int,varlist) # <map object at 0x104ea8890> print(list(res))(2) [1,2,3,4] ==> [1,4,9,16] 普通方法 varlist = [1,2,3,4] newlist = [] for i in varlist:res = i ** 2newlist.append(res) print(newlist)使用map函數處理這個數據 varlist = [1,2,3,4] def myfunc(x):return x ** 2 res = map(myfunc,varlist) print(res,list(res))優化版 res = map(lambda x:x**2,varlist)# print(res,list(res))練習作業 (3) ['a','b','c','d'] ==> [65,66,67,68]

reduce(func,iterable)

reduce(func,iterable)
功能：
每一次從 iterable 拿出兩個元素，放入到func函數中進行處理，得出一個計算結果，
然后把這個計算結果和iterable中的第三個元素，放入到func函數中繼續運算，
得出的結果和之后的第四個元素，加入到func函數中進行處理，以此類推，直到最后的元素都參與了運算
參數：
func： 內置函數或自定義函數
iterable： 可迭代的數據
返回值：最終的運算處理結果
注意： 使用 reduce函數時，需要導入 from functools import reduce

from functools import reduce(1) [5,2,1,1] ==> 5211# 普通方法 # varlist = [5,2,1,1] # res = '' # for i in varlist: # res += str(i) # res = int(res) # print(res,type(res)) ''' 5 2 1 1 5 * 10 + 2 == 52 52 * 10 + 1 == 521 521 * 10 + 1 == 5211 '''# 使用 reduce完成 # def myfunc(x,y): # return x*10+y # varlist = [5,2,1,1] # # 調用函數 # res = reduce(myfunc,varlist) # print(res,type(res))（2） 把字符串的 '456' ==> 456 # 要求不能使用int方法進行類型的轉換時，如何解決上面的問題# 定義函數，給定一個字符串的數字，返回一個整型的數字 def myfunc(s):vardict = {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}return vardict[s]# 1.先使用 map函數，把數字字符串，轉為整型的數字 iter1 = map(myfunc,'456')# 2. 把數字列表中的值，使用lambda進行二次處理 iter2 = reduce(lambda x,y:x*10+y,iter1) print(iter2)

filter(func,iterable)過濾數據

filter(func,iterable)
功能： 過濾數據，把 iterable 中的每個元素拿到 func 函數中進行處理，
如果函數返回True則保留這個數據，返回False則丟棄這個數據
參數：
func 自定義函數
itereble： 可迭代的數據
返回值：保留下來的數據組成的 迭代器

# 要求 保留所有的偶數，丟棄所有的奇數 varlist = [1,2,3,4,5,6,7,8,9](1)普通方法實現 newlist = [] for i in varlist:if i % 2 == 0:newlist.append(i)print(newlist)(2)使用 filter 進行處理 # 定義一個函數，判斷當前這個函數是否為偶數，偶數返回True，奇數返回False def myfunc(n):if n % 2 == 0:return Trueelse:return False(3) 調用 過濾器 函數進行處理 it = filter(myfunc,varlist) print(it,list(it))優化版 it = filter(lambda n:True if n % 2 == 0 else False,varlist) print(it,list(it))

總結

以上是生活随笔為你收集整理的python一入深似海-模块化编程-钢铁侠战甲（二）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。