Python函式用法和底層分析

ThankCAT 發表於 2022-12-25
Python

Python函式用法和底層分析

函式是可重用的程式程式碼塊。函式的作用,不僅可以實現程式碼的複用,更能實現程式碼的一致性。一致性指的是,只要修改函式的程式碼,則所有呼叫該函式的地方都能得到體現。

在編寫函式時,函式體中的程式碼寫法和我們前面講述的基本一致,只是對程式碼實現了封裝,並增加了函式呼叫、傳遞引數、返回計算結果等內容。

為了讓大家更容易理解,掌握的更深刻。我們也要深入記憶體底層進行分析。絕大多數語言記憶體底層都是高度相似的,這樣大家掌握了這些內容也便於以後學習其他語言

函式的基本概念

  1. 一個程式由一個個任務組成;函式就是代表一個任務或者一個功能。
  2. 函式是程式碼複用的通用機制。

Python 函式的分類

Python 中函式分為如下幾類:

  1. 內建函式

我們前面使用的 str()、list()、len()等這些都是內建函式,我們可以拿來直接使用。

  1. 標準庫函式

我們可以透過 import 語句匯入庫,然後使用其中定義的函式

  1. 第三方庫函式

Python 社群也提供了很多高質量的庫。下載安裝這些庫後,也是透過 import 語句匯入,然後可以使用這些第三方庫的函式

  1. 使用者自定義函式

使用者自己定義的函式,顯然也是開發中適應使用者自身需求定義的函式。

核心要點

Python 中,定義函式的語法如下:

def 函式名 ([引數列表]) : 
    '''文件字串''' 
    函式體/若干語

要點:

  1. 我們使用 def 來定義函式,然後就是一個空格和函式名稱;

(1) Python 執行 def 時,會建立一個函式物件,並繫結到函式名變數上。

  1. 引數列表

(1) 圓括號內是形式引數列表,有多個引數則使用逗號隔開'

(2) 形式引數不需要宣告型別,也不需要指定函式返回值型別

(3) 無引數,也必須保留空的圓括號

(4) 實參列表必須與形參列表一一對應

  1. return 返回值

(1) 如果函式體中包含 return 語句,則結束函式執行並返回值;

(2) 如果函式體中不包含 return 語句,則返回 None 值。

  1. 呼叫函式之前,必須要先定義函式,即先呼叫 def 建立函式物件

(1) 內建函式物件會自動建立

(2) 標準庫和第三方庫函式,透過 import 匯入模組時,會執行模組中的 def 語

形參和實參

【操作】定義一個函式,實現兩個數的比較,並返回較大的值

def print_max(a,b):
    '''實現兩個數的比較,並返回較大的值'''
    if a > b:
        print(a,'MAX')
    else:
        print(b,'MAX')

print_max(10, 20)
print_max(99, -99)

#result
#20 MAX
#99 MAX

上面的 printMax 函式中,在定義時寫的 print_max(a,b)。a 和 b 稱為“形式引數”,
簡稱“形參”。也就是說,形式引數是在定義函式時使用的。 形式引數的命名只要符合“識別符號”命名規則即可。

在呼叫函式時,傳遞的引數稱為“實際引數”,簡稱“實參”。上面程式碼中,
printMax(10,20),10 和 20 就是實際引數。

文件字串(函式的註釋)

程式的可讀性最重要,一般建議在函式體開始的部分附上函式定義說明,這就是“文件字串”,也有人成為“函式的註釋”。我們透過三個單引號或者三個雙引號來實現,中間可以加入多行文字進行說明

【操作】測試文件字串的使用

def print_max(a,b):
    '''實現兩個數的比較,並返回較大的值'''
    if a > b:
        print(a,'MAX')
    else:
        print(b,'MAX')

print(help(print_max.__doc__))

#result
#No Python documentation found for '實現兩個數的比較,並返回較大的值'.
#Use help() to get the interactive help utility.
#Use help(str) for help on the str class.
#None

返回值

return 返回值要點:

  1. 如果函式體中包含 return 語句,則結束函式執行並返回值;
  2. 如果函式體中不包含 return 語句,則返回 None 值。
  3. 要返回多個返回值,使用列表、元組、字典、集合將多個值“存起來”即可

操作】計算a + b 不設定返回值

def print_star(a,b):
    a + b

c = print_star(4,10)
print(c)

#result
#None

操作】計算a + b 設定返回值

def print_star(a,b):
    c = a + b
    return c

c = print_star(4,10)
print(c)
#result
#14

函式也是物件,記憶體底層分析

Python 中,“一切都是物件”。實際上,執行 def 定義函式後,系統就建立了相應的函式物件。我們執行如下程式,然後進行解釋:

def print_star(n):
    print("*"*n)
print(print_star)
print(id(print_star))
c = print_star
c(3)

#result
#<function print_star at 0x0000000002BB8620>
#45844000
#***

上面程式碼執行 def 時,系統中會建立函式物件,並透過 print_star 這個變數進行引用:

Python函式用法和底層分析

我們執行“c=print_star”後,顯然將 print_star 變數的值賦給了變數 c,記憶體圖變成了:

Python函式用法和底層分析

顯然,我們可以看出變數 c 和 print_star 都是指向了同一個函式物件。因此,執行 c(3)和執行 print_star(3)的效果是完全一致的。 Python 中,圓括號意味著呼叫函式。在沒有圓括號的情況下,Python 會把函式當做普通物件。

變數的作用域(全域性變數和區域性變數)

變數起作用的範圍稱為變數的作用域,不同作用域內同名變數之間互不影響。變數分為:全域性變數、區域性變數。

全域性變數:

  1. 在函式和類定義之外宣告的變數。作用域為定義的模組,從定義位置開始直到模組結束。
  2. 全域性變數降低了函式的通用性和可讀性。應儘量避免全域性變數的使用。
  3. 全域性變數一般做常量使用。
  4. 函式內要改變全域性變數的值,使用 global 宣告一下

區域性變數:

  1. 在函式體中(包含形式引數)宣告的變數。
  2. 區域性變數的引用比全域性變數快,優先考慮使用。
  3. 如果區域性變數和全域性變數同名,則在函式內隱藏全域性變數,只使用同名的區域性變數

【操作】全域性變數的作用域測試

def f1():
    global a #如果要在函式內改變全域性變數的值,增加 global 關鍵字宣告
    print(a) #列印全域性變數 a 的值
    a = 300
f1()
print(a)

#result
#100
#300

【操作】全域性變數和區域性變數同名測試

a=100
def f1():
    a = 3 #同名的區域性變數
    print(a)
f1()
print(a) #a 仍然是 100,沒有變

#result
#3
#100

【操作】 輸出區域性變數和全域性變

a = 100
def f1(a, b, c):
    print(a, b, c)
    print(locals())
    print('*' * 20)
    print(globals())

f1(1, 2, 3)

#result
#1 2 3 
#{'a': 1, 'b': 2, 'c': 3} 返回一個字典
#********************
#{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000023F0086CA10>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'c:\\Users\\chenh\\OneDrive\\Data Learn\\Python 基礎\\課堂筆記\\05\\Book_code.py', '__cached__': None, 'a': 100, 'f1': <function f1 at 0x0000023F00810680>}

部變數和全域性變數效率測試

區域性變數的查詢和訪問速度比全域性變數快,優先考慮使用,尤其是在迴圈的時候。在特別強調效率的地方或者迴圈次數較多的地方,可以透過將全域性變數轉為區域性變數提高執行速度

【操作】測試區域性變數和全域性變數效率

#測試區域性變數、全域性變數的效率
import time
import math
def test01():
    start = time.time()
    for i  in range(100000000):
        math.sqrt(30)
    end = time.time()
    print('耗時{0}'.format(end - start))

def test02():
    b = math.sqrt
    start = time.time()
    for i  in range(100000000):
        b(30)
    end = time.time()
    print('耗時{0}'.format(end - start))

test01()
test02() 

#result
#耗時7.24362325668335
#耗時6.6801464557647705

引數的傳遞

函式的引數傳遞本質上就是:從實參到形參的賦值操作。 Python 中“一切皆物件”,所有的賦值操作都是“引用的賦值”。所以,Python 中引數的傳遞都是“引用傳遞”,不是“值傳遞”。具體操作時分為兩類:

  1. 對“可變物件”進行“寫操作”,直接作用於原物件本身。
  2. 對“不可變物件”進行“寫操作”,會產生一個新的“物件空間”,並用新的值填充這塊空間。(起到其他語言的“值傳遞”效果,但不是“值傳遞”)
    可變物件有:

字典、列表、集合、自定義的物件等
不可變物件有:
數字、字串、元組、function

操作】引數傳遞:傳遞可變物件的引用

b = [10,20]
def f2(m):
    print("m:",id(m)) #b 和 m 是同一個物件
    m.append(30) #由於 m 是可變物件,不建立物件複製,直接修改這個物件
f2(b)
print("b:",id(b))
print(b)

#result
#m: 1619876826368
#b: 1619876826368
#[10, 20, 30]

傳遞不可變物件的引用

傳遞引數是不可變物件(例如:int、float、字串、元組、布林值),實際傳遞的還是物件的引用。在”賦值操作”時,由於不可變物件無法修改,系統會新建立一個物件。

【操作】引數傳遞:傳遞不可變物件的引用

a = 100
def f1(n):
    print("n:",id(n)) #傳遞進來的是 a 物件的地址
    n = n + 200 #由於 a 是不可變物件,因此建立新的物件 n
    print("n:",id(n)) #n 已經變成了新的物件
    print(n)
f1(a)
print("a:",id(a)) #a的記憶體地址並沒有發生改變

#result
#n: 140717568683912
#n: 2640908885520
#300
#a: 140717568683912

顯然,透過 id 值我們可以看到 n 和 a 一開始是同一個物件。給 n 賦值後,n 是新的物件。

淺複製和深複製

為了更深入的瞭解引數傳遞的底層原理,我們需要講解一下“淺複製和深複製”。我們可以使用內建函式:copy(淺複製)、deepcopy(深複製)。

淺複製:不複製子物件的內容,只是複製子物件的引用。
深複製:會連子物件的記憶體也全部複製一份,對子物件的修改不會影響源物件

【操作】測試淺複製和深複製

#測試淺複製和深複製
import copy
def testCopy():
    '''測試淺複製'''
    a = [10, 20, [5, 6]]
    b = copy.copy(a)
    print("a", a)
    print("b", b)
    b.append(30)
    b[2].append(7)
    print("淺複製......")
    print("a", a)
    print("b", b)

def testDeepCopy():
    '''測試深複製'''
    a = [10, 20, [5, 6]]
    b = copy.deepcopy(a)
    print("a", a)
    print("b", b)
    b.append(30)
    b[2].append(7)
    print("深複製......")
    print("a", a)
    print("b", b)

testCopy()
print("*************")
testDeepCopy()

#result
'''
a [10, 20, [5, 6]]
b [10, 20, [5, 6]]
淺複製......
a [10, 20, [5, 6, 7]]
b [10, 20, [5, 6, 7], 30]
*************
a [10, 20, [5, 6]]
b [10, 20, [5, 6]]
深複製......
a [10, 20, [5, 6]]
b [10, 20, [5, 6, 7], 30]
'''

傳遞不可變物件包含的子物件是可變的情況

傳遞不可變物件時。不可變物件裡面包含的子物件是可變的。則方法內修改了這個可變物件,源物件也發生了變化

a = (10,20,[5,6])
print("a:",id(a))

def test01(m):
    print("m:",id(m))
    m[2][0] = 888
    print(m)
    print("m:",id(m))

test01(a)
print(a)

#result
'''
a: 3006159512640
m: 3006159512640
(10, 20, [888, 6])
m: 3006159512640
(10, 20, [888, 6])
'''

引數的幾種型別

位置引數

函式呼叫時,實參預設按位置順序傳遞,需要個數和形參匹配。按位置傳遞的引數,稱為:“位置引數”。

【操作】測試位置引數

def f1(a,b,c):
    print(a,b,c)
f1(2,3,4)
f1(2,3) #報錯,位置引數不匹配

#result
'''
2 3 4
Traceback (most recent call last):
  File "c:\Users\chenh\OneDrive\Data Learn\Python 基礎\課堂筆記\05\Book_code.py", line 4, in <module>
    f1(2,3) #報錯,位置引數不匹配
    ^^^^^^^
TypeError: f1() missing 1 required positional argument: 'c'
'''

預設值引數

我們可以為某些引數設定預設值,這樣這些引數在傳遞時就是可選的。稱為“預設值引數”。預設值引數放到位置引數後面。

【操作】測試預設值引數

def f1(a, b, c=10, d=20): #預設值引數必須位於普通位置引數後面
    print(a, b, c, d)

f1(9, 8)
f1(8, 9, 19)
f1(8, 9, 19, 29)

#result
'''
9 8 10 20
8 9 19 20
8 9 19 29
'''

命名引數

我們也可以按照形參的名稱傳遞引數,稱為“命名引數”,也稱“關鍵字引數”。

【操作】測試命名引數

def f1(a,b,c):
    print(a,b,c)

f1(8, 9, 19)            #位置引數
f1(c=10, a=20, b=30)    #命名引數、

#result
'''
8 9 19
20 30 10
'''

可變引數

可變引數指的是“可變數量的引數”。分兩種情況:

  1. *param(一個星號),將多個引數收集到一個“元組”物件中。
  2. **param(兩個星號),將多個引數收集到一個“字典”物件中。

【操作】測試可變引數處理(元組、字典兩種方式

def f1(a,b,*c):
    print(a,b,c)

f1(8, 9, 19, 20)

def f2(a,b,**c):
    print(a,b,c)

f2(8, 9, name = 'gaoqi', age = 18)

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

f3(8, 9, 20, 30, name = 'gaoqi',age = 18)\

#result
'''
8 9 (19, 20)    #將*c引數放在元組中
8 9 {'name': 'gaoqi', 'age': 18}    #將**c引數放在字典中
8 9 (20, 30) {'name': 'gaoqi', 'age': 18}
'''

強制命名引數

在帶星號的“可變引數”後面增加新的引數,必須在呼叫的時候“強制命名引數”。

操作】強制命名引數的使用

def f1(*a,b,c):
    print(a,b,c)
#f1(2,3,4) #會報錯。由於 a 是可變引數,將 2,3,4 全部收集。造成 b 和 c 沒有賦值。
f1(2,b=3,c=4) 
f1(2, 3, 4, b=10, c=100)
'''
result:
(2,) 3 4
(2, 3, 4) 10 100
'''

lambda 表示式和匿名函式

lambda 表示式可以用來宣告匿名函式。lambda 函式是一種簡單的、在同一行中定義函式的方法。lambda 函式實際生成了一個函式物件。

lambda 表示式只允許包含一個表示式,不能包含複雜語句,該表示式的計算結果就是函式的返回值。

ambda 表示式的基本語法如下:

lambda arg1,arg2,arg3... : <表示式>

arg1/arg2/arg3 為函式的引數。<表示式>相當於函式體。運算結果是:表示式的運算結果。

【操作】lambda 表示式使

f = lambda a, b, c : a + b + c

print(f)
print(f(2, 3, 4))

'''
result:
<function <lambda> at 0x0000024E1DBA0680>
9
'''

g = [lambda a : a*2, lambda b : b*3, lambda c : c*4]

print(g)
print(g[0](6),g[1](7),g[2](8))

'''
result:
[<function <lambda> at 0x0000019D11368E00>, <function <lambda> at 0x0000019D11368F40>, <function <lambda> at 0x0000019D11368FE0>]
12 21 32
'''

eval()函式

功能:將字串 str 當成有效的表示式來求值並返回計算結果。

語法引數:

eval(source[, globals[, locals]]) -> value

source:一個 Python 表示式或函式 compile()返回的程式碼物件
globals:可選。必須是 dictionary
locals:可選。任意對映物件
s = "print('abcde')"
eval(s)

a = 10
b = 20
c = eval("a + b")
print(c)

dict1 = dict(a = 100, b = 200)

d = eval("a+b",dict1)
print(d)

'''
result:
abcde
30
300
'''

eval 函式會將字串當做語句來執行,因此會被注入安全隱患。比如:字串中含有刪除檔案的語句。那就麻煩大了。因此,使用時候,要慎重!!!

遞迴函式

遞迴函式指的是:自己呼叫自己的函式,在函式體內部直接或間接的自己呼叫自己。遞迴類似於大家中學數學學習過的“數學歸納法”。 每個遞迴函式必須包含兩個部分:

  1. 終止條件

表示遞迴什麼時候結束。一般用於返回值,不再呼叫自己。

  1. 遞迴步驟

把第 n 步的值和第 n-1 步相關聯。

遞迴函式由於會建立大量的函式物件、過量的消耗記憶體和運算能力。在處理大量資料時,謹慎使用。

操作】 使用遞迴函式計算階乘(factorial


def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)

for i in range(1,11):
    print(i,'!=',factorial(i))

'''
result:
1 != 1
2 != 2
3 != 6
4 != 24
5 != 120
6 != 720
7 != 5040
8 != 40320
9 != 362880
10 != 3628800
'''

Python函式用法和底層分析