函式

概念:功能 (包裹一部分代碼 實作某一個功能 達成某一個目的)
特點:可以反復呼叫,提高代碼的復用性,提高開發效率,便于維護管理

 

1.函式基本格式

# 定義一個函式
def 函式名():
code1
code 

# 呼叫函式
函式名()
"""

# 定義函式
def func():
print("我是一個函式 ... ")

# 呼叫函式
func()

 

 

2.函式的命名

字母數字下劃線,首字符不能為數字
嚴格區分大小寫,且不能使用關鍵字
函式命名有意義,且不能使用中文哦

駝峰命名法:
(1) 大駝峰命名法: 每個單詞的首字符要大寫 (類的命名)
mycar => MyCar
(2) 小駝峰命名法: 除了第一個單詞首字符小寫外,剩下單詞首字符大寫 (函式或者變數)
mycar => myCar
(3)_命名法:可以將不同的單詞用_拼接在一起
mycar => my_car
symmetric_differencesymmetricDifference SymmetricDifference

# 函式定義
def cfb_99():
for i in range(1,10):
for j in range(1,i+1):
print("{:d}*{:d}={:2d} ".format(i,j,i*j) ,end="")
print()
# 呼叫函式
for i in range(5):
cfb_99()

 

函式的引數

引數: 函式運算時需要的值

引數種類:
(1)形參: 形式引數,在函式的定義處
(2)實參: 實際引數,在函式的呼叫處

形參的種類:
1.普通形參(位置形參) 2.默認形參 3普通收集形參 4.命名關鍵字形參 5.關鍵字收集形參
實參的種類:
1.普通實參 2.關鍵字實參

原則:
形參和實參要一一的對應

 

1.普通形參(位置形參)

# 定義函式
"""hang,lie普通形參,在函式定義處"""
def small_star(hang,lie):
i = 0
while i < hang:
j = 0
while j < lie:
print("*",end="")
j +=1
print()
i += 1
# 呼叫函式
"""10,10普通實參,在函式的呼叫處"""
small_star(10,10)
small_star(2,3)

 

2.默認形參

"""hang,lie默認形參,在函式定義處"""
"""
如果給予實參,那么使用實參
如果沒有給予實參,那么使用引數身上的默認值
"""
def small_star(hang=10,lie=10):
i = 0
while i < hang:
j = 0
while j < lie:
print("*",end="")
j +=1
print()
i += 1

small_star(4,8)
small_star(8)
small_star()

 

3.普通形參 + 默認形參

"""普通形參必須寫在默認形參的前面不能調換位置"""
def small_star(hang,lie=10):
i = 0
while i < hang:
j = 0
while j < lie:
print("*",end="")
j +=1
print()
i += 1
small_star(5,7)
# small_star(5)
# small_star() error

 

4.關鍵字實參

1.如果都是關鍵字實參,可以任意調整實參的順序
2.普通實參必須寫在關鍵字實參的前面

def small_star(hang,a,b,c,lie=10):
i = 0
while i < hang:
j = 0
while j < lie:
print("*",end="")
j +=1
print()
i += 1

# hang a ... lie 具體指定引數的值叫做關鍵字實參,在函式的呼叫處;
# small_star(hang=3,a=4,b=5,c=6,lie=7)
# small_star(b=5,c=6,lie=7,a=4,hang=3)
small_star(3,4,b=5,c=6,lie=7)
small_star(3,4,b=5,lie=7,c=6)
# small_star(b=5,c=6,lie=7,3,4) error

 

 

 

 

 

 

 收集引數

 

(1) 普通收集形參

專門用來收集那些多余的沒人要的普通實參 收集之后,會把多余實參打包成一個元組 引數頭上1個星星

def func(*args):
　　pass
args => arguments

def func(a,b,c,*args):
    print(a,b,c) # 1 2 3
    print(args)  # (4,5,6)

func(1,2,3,4,5,6)


# 任意個數值得累加和
def mysum(*args):
    total = 0
    for i in args:
        total += i
    print(total)
mysum(1,2,3,4,4,45,10,100)

 

 

(2) 關鍵字收集形參

專門用來收集那些多余的沒人要的關鍵字實參收集之后,會把多余關鍵字實參打包成一個字典,引數頭上有2個星星

def func(**kwargs):

　　pass
kwargs => keyword arguments

 

def func(a,b,c,**kwargs):
    print(a,b,c)
    print(kwargs) # {'f': 100, 'e': 200, 'z': 12}
func(c=1,a=3,b=10,f=100,e=200,z=12)

 

 

拼接任意個數值變成字串

"""
班長: 趙萬里
班花: 馬春陪
劃水群眾: 趙沈陽,李虎凌,劉子濤
"""
def func(**kwargs):
   strvar1 = ""
   strvar2 = ""
   # 定義職位資訊
   dic = {"monitor":"班長","classflower":"班花"}
   print(kwargs)
   # 共5次回圈
   for k,v in kwargs.items():
      if k in dic:
         # 將2次回圈的結果通過+= 拼接在一起
         strvar1 += dic[k] + ":" + v + "\n"       
      else:
         # 將3次回圈的結果通過+= 拼接在一起
         strvar2 += v + " , "
   print(strvar1.strip())
   print("劃水群眾:",strvar2.strip(" , "))
      
   """
   # print(k,v)
   k       v
   monitor 趙萬里
   classflower 馬春陪
   water1 趙沈陽
   water2 李虎凌
   water3 劉子濤
   {'monitor': '趙萬里', 'classflower': '馬春陪', 'water1': '趙沈陽', 'water2': '李虎凌', 'water3': '劉子濤'}
   """

func(monitor="趙萬里",classflower="馬春陪",water1="趙沈陽",water2="李虎凌",water3="劉子濤")

 

 

 

 

 

命名關鍵字引數

(1) def func(a,b,*,c,d) 跟在*號后面的c和d是命名關鍵字引數
(2) def func(*args,e,**kwargs) 加在*args和**kwargs之間的引數都是命名關鍵字引數

命名關鍵字引數 : 在呼叫函式時,必須使用關鍵字實參的形式來進行呼叫;

定義方法一

def func(a,b,*,c,d):
    print(a,b)
    print(c,d)
    
# 必須指定關鍵字實參,才能對命名關鍵字形參進行賦值
func(1,2,c=3,d=4)

 

定義方法二

def func(*args,e,**kwargs):
    print(args)   # (1, 2, 3, 4)
    print(e)      # 3
    print(kwargs) # {'a': 1, 'b': 2}
func(1,2,3,4,a=1,b=2,e=3)

 

星號的使用

* 和 ** 如果在函式的定義處使用:* 把多余的普通實參打包成元組,** 把多余的關鍵字實參打包成字典

* 和 ** 如果在函式的呼叫處使用:* 把元組或者串列進行解包,** 把字典進行解包

def func(a,b,*,c,d):
    print(a,b)
    print(c,d)

tup = (1,2)
# 函式的呼叫處 *號用法
func(*tup,c=3,d=4) # func(1,2,c=3,d=4)

# 函式的呼叫處 **號用法
dic={"c":3,"d":4}
func(1,2,**dic)    # func(1,2,c=3,d=4)

# 綜合寫法
# 函式的呼叫處
tup = (1,2)
dic={"c":3,"d":4}
func(*tup,**dic)

# 定義成如下形式,可以收集所有的實參
def func(*args,**kwargs):
    pass

 

總結:

當所有的形參都放在一起的時候,順序原則:普通形參 -> 默認形參 -> 普通收集形參 -> 命名關鍵字形參 -> 關鍵字收集形參

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)


# 以上兩個函式 列印結果
#(一)
f1(1, 2) # a =1 b=2 c=0 args=() kw={}
f1(1, 2, c=3) # a=1,b=2,c=3,args=() kw={}
f1(1, 2, 3, 'a', 'b') #a=1 b=2 c=3 args=(a,b) kw={}
f1(1, 2, 3, 'a', 'b', x=99) # a=1 b=2 c=3 args=(a,b) kw={x:99}
f2(1, 2, d=99, ext=None)#a=1 b=2 c=0 d=99 kw={ext:None}

#(二)
args = (1, 2, 3, 4)
kw = {'d': 99, 'x': '#'}
# f1(1,2,3,4,d=99,x=#)
f1(*args, **kw) # a=1 b=2 c=3 args=(4,) kw={d:99,x:#}


#(三)
myargs = (1, 2, 3)
mykw = {'d': 88, 'x': '#'}
# f2(1,2,3,d=88,x=#)
f2(*myargs, **mykw) # a=1,b=2,c=3 d=88 kw={x:#}

#(四)
def f1(a, b, c=0, *args,d,**kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
    print(d)

f1(1,2,3, 'a', 'b',d=67, x=99,y=77) # a=1 b=2 c=3 args=(a,b)  kw={x:99,y:77}
                                    # d=67

 

 

 

 

 

return 自定義函式的回傳值

 

概念:return 把函式內部的資料回傳到函式的外面,回傳到函式的呼叫處
1.return + 六大標準資料型別 , 除此之外還可以回傳函式 或者 是類物件
2.return 在執行時,意味著終止函式,后面的代碼不執行.
3.如果不定義return回傳值,默認回傳None

(1) return + 六大標準資料型別

def func():
    # return 111
    # return 6.89
    # return "你好帥啊,我愛死你樂"
    # return [1,2,3]
    # return {"a":1,"b":2}
    return 1,2,3 # 回傳元組
res = func()
print(res)

 

(2) return 在執行時,意味著終止函式,后面的代碼不執行.

def func():
    print(1)
    print(2)
    return 3
    print(4)
res = func()
print(res)

def func():
    for i in range(5):
        if i == 3:
            return 4
        print(i)
res = func()
print(res)

 

(3) 如果不定義return回傳值,默認回傳None

def func():
    pass
    
res = func()
print(res) # None
    
# 注意點 列印的資料和回傳的資料不是等價的,回傳的資料是可以自定義的;
res = print(1234)
print(res)  # None

 

模擬+-*/計算器

 

"""
功能:   完成計算
引數:   2個數字和運算子
回傳值: 計算后的結果
"""
def calc(num1,num2,sign):
    if sign == "+":
        return num1 + num2
    elif sign == "-":
        return num1 - num2
    elif sign == "*":
        return num1 * num2
    elif sign == "/":
        if num2 == 0:
            return "除數不能為零"
        return num1 / num2
    else:
        return "抱歉,超出了我的運算范圍."
    
res = calc(3,5,"+")
res = calc(3,5,"-")
res = calc(3,5,"*")
res = calc(3,0,"/")
res = calc(3,0,"&")
print(res)

 

全域變數和區域變數

1.概念
區域變數:在函式內部定義的變數就是區域變數
全域變數:在函式外部定義的變數或者在函式內部使用global關鍵字宣告是全域變數

2.作用域:
區域變數的作用范圍僅僅在函式的內部
全域變數的作用范圍橫跨整個檔案

3.生命周期:該變數的作用時長
內置命名空間 -> 全域命名空間 -> 區域命名空間 (開辟空間順序)
內置屬性 > 全域屬性 > 區域屬性 (作用時長:長->短)

 

 

 

1 區域變數

def func():
# 定義一個區域變數
a = 1
# 獲取當前的區域變數
print(a)
# 修改一個區域變數
a = 2
print(a)

func()
# print(a) error

 

2.全域變數

# 定義一個全域變數
b = 10
# 獲取當前的全域變數
print(b)
# 修改一個全域變數
b = 20
print(b)

def func():
    print(b)
func()

 

3.函式內部定義全域變數

def func():
    global c
    c =30
func()
print(c)

 

4.函式內部修改全域變數

d = 50
def func():
    global d
    d = 51
func()
print(d)

 

總結：

global的使用如果當前不存在全域變數,可以在函式內部通過global關鍵字來定義全域變數,如果當前存在全域變數,可以在函式內部通過global關鍵字來修改全域變數

 

函式名的使用

python中的函式可以像變數一樣,動態創建,銷毀,當引數傳遞,作為值回傳,叫第一類物件.其他語言功能有限

def func():
　　print( "我是func函式")

 

(1)動態創建

a = 1
print(a)
a = func
a()

 

(2)動態銷毀

del a
# a()
# func()

 

(3)當引數傳遞

def func2():
    return "我是func2函式"

def func1(f):
    return f() # "我是func2函式"

res = func1(func2)
print(res)

 

(4)作為值回傳

def func3():
    print( "我是func3函式" )
    
def func4(f):
    return f
res = func4(func3)    
print(res)
res()

 

 

 

(5)函式名可以作為容器型別資料的元素

lst = [func,func3]
for i in lst:
    i()

 

__doc__ 或者help查看檔案

def big_chang_cishen(something):
    """
    功能: 教你怎么吃大腸
    引數: 吃的內容
    回傳值: 是否滿意
    """
    print("把{}洗一洗".format(something))
    print("直接找腸子頭,放嘴里,吸一下")
    print("擦擦嘴,滿意的放下腸子頭")
    return "吃完了,真好吃~"
    
big_chang_cishen("生腸子")
# 方法一
res = big_chang_cishen.__doc__
print(res)
# 方法二
help(big_chang_cishen)

 

函式的嵌套

互相嵌套的兩個函式:包裹在外層的叫做外函式,內層的就是內函式

def outer():
    # inner()
    def inner():
        print("我是inner函式")

# (1)內部函式可以直接在函式外部呼叫么 不行
# inner()
# (2)呼叫外部函式后,內部函式可以在函式外部呼叫嗎 不行
# outer()
# inner()
# (3)內部函式可以在函式內部呼叫嗎 可以
outer()
# (4)內部函式在函式內部呼叫時,是否有先后順序 有的
# 先定義在呼叫
# 在其他語言中有預加載的機制,提前把函式駐留到記憶體中,然后再去編譯腳本內容
# python沒有預加載函式的機制,只能先定義在呼叫;

外函式是outer  中間函式是inner  最里層是smaller ,呼叫smaller函式

def outer():
    def inner():
        def smaller():
            print("我是smaller函式")
        smaller()
    inner()
outer()

 

LEGB 原則

def outer():    
    
    def inner():
        
        def smaller():    
            
            print(a)
        smaller()
    inner()
outer()

LEGB原則(就近找變數原則)
找尋變數的呼叫順序采用LEGB原則(即就近原則)
B —— Builtin(Python)；Python內置模塊的命名空間 (內建作用域)
G —— Global(module)； 函式外部所在的命名空間 (全域作用域)
E —— Enclosing function locals；外部嵌套函式的作用域(嵌套作用域)
L —— Local(function)；當前函式內的作用域 (區域作用域)
依據就近原則,從下往上 從里向外 依次尋找

 

nonlocal的使用 (用來修改區域變數)

nonlocal遵循LEGB原則
(1) 它會找當前空間上一層的變數進行修改
(2) 如果上一層空間沒有,繼續向上尋找
(3) 如果最后找不到,直接報錯

 

(1)它會找當前空間上一層的變數進行修改

def outer():
    a = 10
    def inner():
        nonlocal a
        a = 20
        print(a)
    inner()
    print(a)
outer()

 

(2)如果上一層空間沒有,繼續向上尋找

def outer():
    a = 20
    def inner():
        a = 15
        def smaller():
            nonlocal a
            a = 30
            print(a)
        smaller()
        print(a)
    inner()
    print(a)
outer()

 

(3)如果最后找不到,直接報錯

'''nonlocal 只能修改區域變數'''

a = 20
def outer():    
    def inner():
        def smaller():
            nonlocal a
            a = 30
            print(a)
        smaller()
        print(a)
    inner()
    print(a)
outer()
error

 

(4) 不通過nonlocal 是否可以修改區域變數呢?ok

def outer():
    lst = [1,2,3]
    def inner():
        lst[-1] = 3000
    inner()
    print(lst)
outer()

 

閉包函式

互相嵌套的兩個函式,如果內函式使用了外函式的區域變數，并且外函式把內函式回傳出來的程序叫做閉包，

里面的內函式叫做閉包函式

是不是閉包?
1.內函式用了外函式的那個區域變數
2.外函式回傳內函式

 

1.基本語法形式

def zhaoshenyang_family():
    father = "馬云"
    def hobby():
        print("我對錢沒有一絲絲的興趣,我不看重錢,這是我爸爸{}說的".format(father))
    return hobby

func = zhaoshenyang_family()
func()

 

 

2.閉包的復雜形式

def zhaowanli_family():
    gege = "王思聰"
    didi = "鞋王,高振寧"
    money = 1000
    
    def gege_hobby():
        nonlocal money
        money -= 500
        print("我交朋友不在乎他有沒有錢,反正都沒有我有錢.我就喜歡交女朋友... 錢物還剩下{}".format(money))
        
    def didi_hobby():
        nonlocal money
        money -= 400
        print("家里有鞋柜,各式各樣的奢侈鞋,一雙大概20~30萬,錢物還剩下{}".format(money))
    
    def big_master():
        return [gege_hobby,didi_hobby]
    
    return big_master
    
func = zhaowanli_family()
print(func)
lst = func()
print(lst)

# 獲取哥哥函式
gege = lst[0]
gege()
# 獲取弟弟函式
didi = lst[1]
didi()

 

 

 

3.使用 __closure__ , cell_contents 判定閉包

"""如果回傳的元組中有資料說明是閉包,誰的生命周期被延長就列印誰"""
tup = func.__closure__
print(tup)

# 先獲取第一個單元格  cell_contents獲取物件中的內容
func1 = tup[0].cell_contents
print("<11111>")
"""列印閉包函式didi_hobby中,生命周期被延長的屬性"""
print(func1.__closure__[0].cell_contents)
func1()
    
# 在獲取第二個單元格  cell_contents獲取物件中的內容
func2 = tup[1].cell_contents
print("<22222>")
"""列印閉包函式gege_hobby中,生命周期被延長的屬性"""
print(func2.__closure__[0].cell_contents)
func2()

 

 

閉包特點

特點:在閉包函式中,內函式使用了外函式的區域變數,該變數會與內函式發生系結,延長該變數的生命周期,持續到腳本執行結束.(生命周期和全域變數一樣長，但不是全域變數)

def outer(val):
    def inner(num):
        return val + num
    return inner
    
func = outer(10)
res = func(15)
print(res)

 

 

 

 

 

閉包的意義

全域變數的作用域大,容易被篡改

num = 0
def click_num():
    global num
    num += 1 # num = num + 1
    print(num)
click_num()
click_num()
click_num()
num = 100
click_num()
click_num()

 

改造,用閉包來實作

閉包的意義:閉包可以優先使用外函式中的變數,并對閉包中的值起到了封裝保護的作用.

def outer():
    x = 0
    def click_num():
        nonlocal x
        x += 1
        print(x)
    return click_num

click_num = outer()
click_num()
click_num()
click_num()
x = 100
click_num()
click_num()

 

匿名函式 lambda運算式

用一句話來表達只有回傳值的函式

語法:   lambda  引數：回傳值

特點： 簡介，高效

 

(1)無參的lambda運算式

def func():
    return "文哥是個帥哥"

改造

func = lambda : "文哥是個帥哥"
print(  func()  )

(2)有參的lambda運算式

def func(n):
    return id(n)

改造

func = lambda n : id(n)
print( func(100) )

 

(3)帶有判斷條件的lambda運算式

def func(n):
    if n % 2 == 0:
        return "偶數"
    else:
        return "奇數"

改造

func = lambda n : "偶數" if n % 2 == 0 else "奇數"
print( func(44) )

三元運算子

只能表達雙向分支 只有if else 比較固定 不靈活的語法 

語法: 真值 if 條件運算式 else 假值
如果條件運算式成立為True , 回傳if前面的真值,反之,回傳else后面的假值

n = 13
res = "偶數" if n % 2 == 0 else "奇數"
print(res)

 

小練習 : 比較兩者之間的最大值進行回傳

def func(x,y):
    if x > y:
        return x
    else:
        return y

改造

func = lambda x,y : x if x>y else y
print(  func(40,30)  )

 

locals 與 globals 使用 (了解)

 

一.locals 獲取當前作用域所有的變數

 

1.全域空間

locals 在函式外 , 獲取的是列印之前所有的全域變數
locals 在函式內 , 獲取的是呼叫之前所有的區域變數

def func():
    a1 = 1
    b2 = 2

a = 1
b = 2
res = locals()
c = 3
print(res)
d = 4

 

2.區域空間

a = 1
b = 2
def func():
    a1 = 1
    b2 = 2
    res = locals()
    c3 = 3
    print(res)
    d4 = 4
c = 3
func()
d = 4

 

二.globals 只獲取全域空間的全域變數

globals 在函式外 , 獲取的是列印之前所有的全域變數
globals 在函式內 , 獲取的是呼叫之前所有的全域變數

 

1. 全域空間

def func():
    a1 = 1
    b2 = 2

a = 1
b = 2
res = globals()
c = 3
print(res)
d = 4

 

2.區域空間

a = 1
b = 2
def func():
    a1 = 1
    b2 = 2
    res = globals()
    c3 = 3
    print(res)
    d4 = 4
c = 3 
func() #globals()
d = 4

 

globals  回傳的是內置系統的全域字典

通過字串可以創建出變數 一般應用在框架中

def func():
    dic = globals()
    for i in range(1,5):
        # 批量在dic當中添加鍵值對,以創建全域變數
        dic[ "a%d" % (i) ] = i 
        """
        dic["a1"] = 1
        dic["a2"] = 2
        dic["a3"] = 3
        dic["a4"] = 4
        """
func()
print(a1,a2,a3,a4)

 

迭代器

迭代器:
能被next()函式呼叫并不斷回傳下一個值的物件稱為迭代器(Iterator 迭代器是物件)
概念:
迭代器指的是迭代取值的工具，迭代是一個重復的程序，每次重復都是基于上一次的結果而繼續的，
單純的重復并不是迭代
特征:
并不依賴索引,而通過next指標(記憶體地址尋址)迭代所有資料,一次只取一個值,

而不是一股腦的把所有資料放進記憶體.大大節省空間,

一.可迭代物件

如果"__iter__" 在串列里就是可迭代物件 （ __iter__  in  一個串列 ）

setvar = {"王同培","馬春配","趙萬里","趙沈陽"}
# 獲取當前物件的內置成員
lst = dir(setvar)
print(lst)
# 判斷是否是可迭代物件
res = "__iter__" in lst
print(res)
# for i in setvar:
    # print(i)

 

二.迭代器

for回圈之所以可以遍歷所有的資料,是因為底層使用了迭代器,通過地址尋址的方式,一個一個的找資料;
可迭代物件 -> 迭代器 實際上就是從不能夠被next直接呼叫 -> 可以被next指標直接呼叫的程序

如果是可迭代物件 -> 不一定是迭代器
如果是迭代器 -> 一定是可迭代物件

 

1.如何創建一個迭代器

setvar = {"王同培","馬春配","趙萬里","趙沈陽"}
it = iter(setvar)
print(it)

 

2.如何判斷一個迭代器

不僅要有_ _iter_ _  還要有  _ _next_ _  在這個it里面

print(dir(it))
res = "__iter__" in dir(it)  and "__next__" in dir(it)
print(res)

 

3.如何呼叫一個迭代器

next是單向不可逆的程序,一條路走到黑

res = next(it)
print(res)
res = next(it)
print(res)
res = next(it)
print(res)
res = next(it)
print(res)
# res = next(it)
# print(res)     # error 因為單向不可逆 一條路走到黑

 

4.重置迭代器

it = iter(setvar)
print(  it.__next__()  )
print(  it.__next__()  )
print(  it.__next__()  )
print(  it.__next__()  )

 

 5.呼叫迭代器的其他方法

1.for

it = iter(setvar)
for i  in  it:
    print(i)

2.for + next

it = iter(setvar)
for i in range(2):
    print( next(it) )

print( next(it) )
print( next(it) )
# print( next(it) ) error  超出了尋址范圍

 

6.判斷迭代器/可迭代物件的其他方法

# 從...模塊 引入...內容
from collections import Iterator, Iterable
"""Iterator 迭代器 Iterable 可迭代的物件"""
res = isinstance(it,Iterator)
print(res)
res = isinstance(it,Iterable)
print(res)

 

7.range是迭代器么?

print(isinstance(range(10),Iterator)) # False
print(isinstance(range(10),Iterable)) # True

 

變成迭代器

it = range(10).__iter__()
print(isinstance(it,Iterator)) # True
print(isinstance(it,Iterable)) # True

呼叫it  (next)

res = next(it)
print(res)
res = next(it)
print(res)

for + next

for i in range(3):
    print(next(it))  # 2 3 4

for

for i in it:
    print(i)

 

 

高階函式 : 能夠把函式當成引數傳遞的就是高階函式 (map ,filter ,reduce , sorted)

 

map

map(func,iterable)
功能: 處理資料
　　把iterable中的資料一個一個拿出來,扔到func做處理,通過呼叫迭代器來獲取回傳值
引數:
　　func : 函式(內置函式,自定義函式)
　　iterable : 可迭代性物件 (容器型別資料,range物件,迭代器)
回傳值:
　　迭代器

 

(1) 把串列中的元素都變成整型

lst = ["1","2","3","4"]
lst_new = []
for i in lst:
    lst_new.append(int(i))
print(lst_new)

用map改寫

from collections import Iterator,Iterable
it = map(int,lst)
print(isinstance(it,Iterator))

"""
代碼決議:
第一次呼叫迭代器
先把串列中的第一個元素"1"拿出來扔到int中做強轉,變成整型1回傳出來
第二次呼叫迭代器
先把串列中的第一個元素"2"拿出來扔到int中做強轉,變成整型2回傳出來
第三次呼叫迭代器
先把串列中的第一個元素"3"拿出來扔到int中做強轉,變成整型3回傳出來
第四次呼叫迭代器
先把串列中的第一個元素"4"拿出來扔到int中做強轉,變成整型4回傳出來
"""

 

1.呼叫迭代器 next

print(next(it))
print(next(it))
print(next(it))
print(next(it))
# print(next(it)) error

 

2.呼叫迭代器 for

it = map(int,lst)
for i in it:
    print(i)

 

3.呼叫迭代器 for + next

it = map(int,lst)
for i in range(3):
    print(next(it))

 

4.強轉迭代器 => 串列

it = map(int,lst)
print(list(it)

 

 

(2) [1,2,3,4] => [2,8,24,64]

 

# print(1 * 2 ** 1)
# print(2 * 2 ** 2)
# print(3 * 2 ** 3)
# print(4 * 2 ** 4)

# 1 << 1
# 2 << 2
# 3 << 3
# 4 << 4

lst = [1,2,3,4]
lst_new = []
for i in lst:
    lst_new.append(i << i)
print(lst_new)

map改寫

def func(n):
    print(1111)
    return n << n
    
it = map(func,lst)
print(list(it))

"""
只有在呼叫迭代器的時候,才會真正觸發map函式中的所有內容;不呼叫不觸發;
強轉迭代器時,把可以呼叫的所有資料都放到串列中
第一次呼叫時:
把1拿出來,扔func當中做處理,回傳2,
第二次呼叫時:
把2拿出來,扔func當中做處理,回傳8,
第三次呼叫時:
把3拿出來,扔func當中做處理,回傳24,
第四次呼叫時:
把4拿出來,扔func當中做處理,回傳64,
到此串列[2,8,24,64]

注意點:形參和回傳值必須寫;
"""

 

(3) 給你一個串列["a","b","c"] => [97,98,99]

字典的鍵值翻轉操作

dic = {97:"a",98:"b",99:"c"}
dic_new = {}
for k,v in dic.items():
    # print(k,v) # 97 a | 98 b | 99 c
    dic_new[v] = k # dic_new["a"] = 97
print(dic_new)

lst = ["a","b","c"]
lst_new = []
for i in lst:
    lst_new.append(dic_new[i])
print(lst_new)

map改寫

lst = ["a","b","c"]# func 實作字典的翻轉,通過給與a,b,c三個鍵,得到對應的ascii碼,通過list強轉得到串列
def func(n):
    print(n)
    dic = {97:"a",98:"b",99:"c"}
    dic_new = {}
    for k,v in dic.items():
        dic_new[v] = k 
    print(dic_new) # {'a': 97, 'b': 98, 'c': 99}
    return dic_new[n]

        
it = map(func,lst)
print(list(it))

 

reduce

reduce(func,iterable)
功能: 計算資料
　　把iterable中的前兩個資料扔到func函式中做計算,把計算的結果和iterable中第三個值在繼續扔到func中做計算，以此類推 ...   最后回傳計算的結果 

引數:
　　func: 自定義函式
　　iterable : 可迭代物件 (容器型別資料 range物件 迭代器)
回傳值:
　　計算的結果

 

(1) [7,7,5,8] => 7758

lst = [7,7,5,8]

# 方法一
strvar = ""
for i in lst:
    strvar += str(i)
res = int(strvar)
print(res , type(res))

# 方法二
"""
7 * 10 + 7 = 77
77 * 10 + 5 = 775
775 * 10 + 8 = 7758
"""
# 1.先變成迭代器
it = iter(lst)
# 2.取出兩個值
num1 = next(it)
num2 = next(it)
print(num1,num2)
# 做計算
total = num1 * 10 + num2
print(total) # 77
# 3.把計算的結果在和剩下的資料做計算
for num in it:
    total = total * 10 + num
# 4.回傳最后的結果
print(total , type(total))

reduce改寫

'''從...functools模塊, 引入 .. reduce方法'''
from functools import reduce
lst = [7,7,5,8]
def func(x,y):
    # print(x,y)
    return x * 10 + y
res = reduce(func,lst)
print(res)

# 使用lambda 進行改造
print(reduce(lambda x,y: x*10 + y,lst))

 

(2) "123" => 123 不使用int的情況下實作該操作;

strvar = "123"
def func(x,y):
    return x * 10 + y

# 把字串"123" 處理成數字的123
def func2(n):
    # dic = {"0":0,"1":1,"2":2,"3":3,"4":4,"5":5,"6":6,"7":7,"8":8,"9":9}
    dic = {}
    for i in range(10):
        dic[str(i)] = i    
    return dic[n]

it = map(func2,strvar)
# res = reduce(func,it)
# print(res,type(res))
# 簡寫
print(reduce(lambda x,y: x*10 + y,it))

 

filter

filter(func,iterable)
功能: 過濾資料
　　 在自定義的函式中,
　　 如果回傳True, 該資料保留
　　 如果回傳False,該資料舍棄
引數:
　　 func: 自定義函式
 　　iterable : 可迭代物件 (容器型別資料 range物件 迭代器)
回傳值:
　　　迭代器

 

1.只要串列中所有的偶數

lst = [1,2,34,5,65,6,56,7,56,756,7567,11]
lst_new = []
for i in lst:
    if i % 2 == 0 :
        lst_new.append(i)
print(lst_new)

filter改寫

def func(n):
    if n % 2 == 0:
        return True
    else:
        return False
it = filter(func,lst)
print(list(it))

使用lambda 改寫

it = filter(lambda n :True if n % 2 == 0 else False , lst)
print(list(it))
print(list(filter(lambda n :True if n % 2 == 0 else False , lst)))

 

sorted

sorted(iterable,key=函式,reverse=False)
功能:排序資料
引數:
　　iterable : 可迭代物件 (容器型別資料 range物件 迭代器)
　　key : 指定函式(自定義/內置)
　　reverse : 是否倒序
回傳值:
　　串列

 

tup = (-90,89,78,3)
# 1.從小到大
res = sorted(tup)
print(res,type(res))

# 2.從大到小
res = sorted(tup,reverse = True)
print(res,type(res))

# 3.按照絕對值進行排序
tup = (-90,-100,1,2)
res = sorted(tup,key=abs)
print(res)
"""
1 => abs(1) => 1
2 => abs(2) => 2
-90 => abs(-90) => 90
-100 => abs(-100) => 100
"""

# 4.按照自定義函式進行排序
tup = (19,23,42,87)
"""
42 % 10 2 => 42
23 % 10 3 => 23
87 % 10 7 => 87
19 % 10 9 => 19
"""
def func(n):
    print(n)
    return n % 10
lst = sorted(tup,key = func)
print(lst)

 

5.任意的容器型別資料都可以通過sorted排序

container = "abc"
container = [1,2,3]
container = (1,2,3)
container = {"你好","王文","你真帥"}
container = {"caixukun","xiaozhan","zhaoshenyang","wangyibo"}
container = {"ww":"英俊帥氣","zxy":"猥瑣摳腳","zwl":"斯文敗類"} # 排的是字典的鍵
print(sorted(container))

 

總結:
sorted (推薦使用sorted)
　　(1) 可以排序所有的容器型別資料
　　(2) 回傳一個新的串列
sort
　　(1) 只能排序串列
　　(2) 基于原來的串列進行排序

 

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/428473.html

標籤：Python

上一篇：通過案例實戰深入認識python影像處理庫Pillow

下一篇：ECharts回圈push資料到series，從而實作series的動態處理之(一)（先用給定資料，后期用后端回傳資料）