文章目錄

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

高階函數(shù)

##遞歸函數(shù)

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

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

遞歸函數(shù)是一層一層的進入，再一層一層的返回

普通戰(zhàn)甲套反浩克戰(zhàn)甲，套娃，

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

回調函數(shù)

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

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

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

閉包函數(shù)

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

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

特點：

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

在外函數(shù)中返回了內函數(shù)，返回的內函數(shù)就是閉包函數(shù)

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

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

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

匿名函數(shù) lambda 表達式

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

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

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

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

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

迭代器

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

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

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

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

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

iter()

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

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

返回值： 迭代器對象

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

next()

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

迭代器的取值方案

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

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

for 使用for循環(huán)遍歷迭代器的數(shù)據(jù)

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

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

from collections.abc import Iterator,Iterable varstr = '123456' res = iter(varstr) # type() 函數(shù)返回當前數(shù)據(jù)的類型， # isinstance() 檢測一個數(shù)據(jù)是不是一個指定的類型 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) # 迭代器一定是一個可迭代的對象，可迭代對象不一定是迭代器

內置函數(shù)

內置函數(shù)就是在系統(tǒng)安裝完python解釋器時，由python解釋器給提供好的函數(shù)

range() 函數(shù)

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

range函數(shù)的使用方式

# 只寫一個參數(shù)，就是從零開始到10之前，9 # res = range(11)# 兩個參數(shù)時，第一個參數(shù)是開始的值，第二個參數(shù)是結束的值（在結束值之前） # res = range(5,10)# 三個參數(shù)， 參數(shù)1是開始值，參數(shù)2是結束值，參數(shù)三是步進值 # res = range(1,10,3)# 獲取一個倒敘的數(shù)字序列 # 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函數(shù)返回的數(shù)字序列的方法

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

zip() 函數(shù)

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

var1 = '1234' var2 = ['a','b','c'] var3 = ('A','B','C','D') # 調用zip函數(shù)，組成新的元組迭代器 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))# 組合好的多個元組數(shù)據(jù)

其它內置函數(shù)

數(shù)據(jù)類型轉換相關內置函數(shù)

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

變量相關函數(shù)

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

數(shù)學相關函數(shù)

# 獲取一個數(shù)的絕對值 # 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) # 小數(shù)點保留幾位# r = round(4.5) # 奇進偶退 1.5 = 2 2.5=2,3.5=4,4.5=4 # print(r)

進制相關函數(shù)

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

高階函數(shù)

sorted(iterable[reverse,key])排序

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

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這個函數(shù)(求絕對值）作為sorted的key關鍵字參數(shù)使用 res = sorted(arr,key=abs) # print(res)# 使用自定義函數(shù) # def func(num): # print(num,num % 2) # return num % 2 # # arr = [3,2,4,6,5,7,9] # # # 在sorted函數(shù)中使用自定義函數(shù)對數(shù)據(jù)進行處理 # res = sorted(arr,key=func) # print(res)## 優(yōu)化版 arr = [3,2,4,6,5,7,9] res = sorted(arr,key=lambda x:x%2) print(res)

map(func, *iterables) 新迭代器

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

(1）把一個字符串數(shù)字的列表轉為 整型的數(shù)字列表 ['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函數(shù)進行處理 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函數(shù)處理這個數(shù)據(jù) varlist = [1,2,3,4] def myfunc(x):return x ** 2 res = map(myfunc,varlist) print(res,list(res))優(yōu)化版 res = map(lambda x:x**2,varlist)# print(res,list(res))練習作業(yè) (3) ['a','b','c','d'] ==> [65,66,67,68]

reduce(func,iterable)

reduce(func,iterable)
功能：
每一次從 iterable 拿出兩個元素，放入到func函數(shù)中進行處理，得出一個計算結果，
然后把這個計算結果和iterable中的第三個元素，放入到func函數(shù)中繼續(xù)運算，
得出的結果和之后的第四個元素，加入到func函數(shù)中進行處理，以此類推，直到最后的元素都參與了運算
參數(shù)：
func： 內置函數(shù)或自定義函數(shù)
iterable： 可迭代的數(shù)據(jù)
返回值：最終的運算處理結果
注意： 使用 reduce函數(shù)時，需要導入 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] # # 調用函數(shù) # res = reduce(myfunc,varlist) # print(res,type(res))（2） 把字符串的 '456' ==> 456 # 要求不能使用int方法進行類型的轉換時，如何解決上面的問題# 定義函數(shù)，給定一個字符串的數(shù)字，返回一個整型的數(shù)字 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函數(shù)，把數(shù)字字符串，轉為整型的數(shù)字 iter1 = map(myfunc,'456')# 2. 把數(shù)字列表中的值，使用lambda進行二次處理 iter2 = reduce(lambda x,y:x*10+y,iter1) print(iter2)

filter(func,iterable)過濾數(shù)據(jù)

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

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

總結

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

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