2021年3月15日 星期一

Python 學習筆記 : 基本語法 (三) : 函式

本篇繼續複習整理 Python 的函數與類別, 本系列之前的測試筆記如下 :


更多 Python 筆記參考 :


參考書籍 :
  1. 人工智慧 Python 基礎課 (碁峰, 陳會安)
  2. 精通 Python (碁峰, 賴屹民譯)
  3. Python 程式設計入門與運算思維 (新陸, 曹祥雲)
  4. 一步到位! Python 程式設計 (旗標, 陳惠貞)
  5. Python 程式設計入門指南 (碁峰, 蔡明志譯)


九. 函式 :

函式是一個可重複使用的獨立程式片段, 開發較大的程式時通常會將特定功能或會重複使用之程式碼區塊寫成函式, 透過共用程式碼以簡化程式架構並提高可讀性. 對於呼叫者而言, 函式就像一個黑盒子, 不需要知道其內部之實作方式, 只要了解其輸出入介面 (即傳入參數與傳回值), 知道如何呼叫它即可. 

Python 的函式在程式語言中屬於第一級函式 (first-class functions), 其特性如下 : 
  1. 可以被當作引數 (argument) 傳入另一個函式的參數中.
  2. 可以在另一個函式中做為傳回值.
  3. 可以被指派給一個變數.
  4. 可以儲存於資料結構例如雜湊表 (hash table) 或串列中.
簡言之, Python 的函式可以被當成一般物件那樣地使用

參考 :

What is first class function in Python

Python 的函式分為自訂函式與內建函式兩種, 小程式只需要使用內建函式與運算式即可完成, 較大的程式為了開發與維護之便利通常需要自訂函式.  


1. 自訂函式 :     

使用函式必須先定義 (實作函式內容), 然後再呼叫它, Python 的函數可以傳入任意數量與型態之參數, 也可以傳回任意數量與型態之運算結果. Python 自訂函式有具名的 def 與匿名的 lambda 兩種寫法, 後者雖然匿名, 但因為第一級函式特性, 可以指定給變數故也能重複使用. 

函式的定義由關鍵字 def 為首的標頭與內縮的內容構成, 語法如下 : 

def functionName([para1, para2, .... paran=defaultValue]):
    statements
    [return ret1, ret2, ... retm]

摘要說明如下 :
  • 函式名稱命名方式與變數相同, 即只能使用英數字或底線 (但不可用數字開頭), 且不能與關鍵字相同 (會出現錯誤無法執行), 也最好不要與內建函數同名 (那將取代內建函數). 習慣上函式名稱通常使用小寫, 多詞串接可使用駝峰字例如 functionName, 或利用底線例如 function_name.
  • 函式名稱後面的小括號 () 內可傳入零或多個參數, 每個參數以逗號隔開, 即使沒有傳入參數也必須有個空的小括號. 參數可以有預設值, 但全部有預設值的參數必須放在參數列的最後面. 小括號跟著一個冒號, 跳行後即是內縮的函式內容. 參數可以是任何類型的資料, 也可以是另一個函式 (因為 Python 的函式是 first-class function).
  • 函式定義中的參數稱為形式參數 (formal parameter), 而呼叫者傳入的參數稱為實際參數 (actual paramenter) 或引數 (argument). 注意, Python 預設採用位置引數 (positional argument), 亦即呼叫者傳入引數時必須對應形式參數之順序 (亦即要記得參數之先後順序). 為防止對應錯誤, 呼叫時可以使用關鍵字引數 (keyword argument), 全部引數使用關鍵字時, 引數的位置可隨便排; 但若部分使用位置引數, 部分使用關鍵字引數時, 位置引數必須放在前面. 例如呼叫函式 def f(p1, p2,p3) 時可以用 f(1, 2, p3=3), 但 f(1, p2=2, 3) 則是錯誤的. 
  • 傳入之引數為不可變之資料類型 (數值, 字串, 元組) 時為傳值呼叫, 傳入函式的是變數的副本, 因此不會改變函式外這些變數之值; 若傳入函式之引數為可改變之資料類型 (串列, 字典, 集合) 時為傳址呼叫, 亦即傳入函式的是這些資料變數的位址, 函式內的運算可能會改變函式外這些變數的內容. 
  • statements 為函式內容的主體, 用來執行特定之運算. 
  • 函式最後可用關鍵字 return 向呼叫者 (caller) 送出零或多個傳回值, 傳回值是以 tuple 的型態回傳給呼叫者, 之間以逗號隔開, 可用 return r1, r2, r3, ...., rn 或加小括弧 return (return r1, r2, r3, ...., rn) 亦可.
  • 函式不需要傳回值時可只寫 return 會省略不寫, 沒有 return 的函式其實還是會傳回 None 給呼叫者. 有 return 的函式執行完 return 後即離開函式, 控制權轉回呼叫者, 因此 return 後面的敘述不會被執行. 

(1). 無 return 的函式 :

函式中沒有用 return 顯性傳回值的函式事實上仍會傳回 None, 下面這個攝氏溫度轉成華氏溫度的函式因為直接在函式內輸出結果, 因此不需要傳回值, 但呼叫者仍會得到 None 傳回值 :

def c2f(c):
    f=c*1.8 + 32
    print("攝氏", c, "度等於華氏", f, "度")

例如 : 

>>> def c2f(c):     //定義函式, 無 return
    f=c*1.8 + 32
    print("攝氏", c, "度等於華氏", f, "度")
    
>>> c2f(28)          //直接呼叫函式, 由函式本身直接輸出結果
攝氏 28 度等於華氏 82.4 度
>>> f=c2f(28)      //將函式傳回值設給 f 變數
攝氏 28 度等於華氏 82.4 度
>>> print(f)          //無 return 之函式一律會傳回 None
None


(2). 有 return 的函式 : 

上面的攝氏轉華氏函式可改寫為如下有 return 的版本 :

def c2f(c):
    f=c*1.8 + 32
    return f

此函式將運算結果 (華式溫度 f) 傳回給呼叫者自行輸出 :

>>> def c2f(c):
    f=c*1.8 + 32
    return f

>>> f=c2f(28)
>>> print(f)
82.4


(3). 多個傳回值 : 

下面這個排序函式會比較兩個參數的大小, 然後以 tuple 形式將排序後結果以前大後小的順序傳回, 看似有多個傳回值, 其實是以 tuple 形式傳回 :

def sort(a, b):
    if a > b:
        return a, b      # 從大到小排列
    else:
        return b, a

例如 : 

>>> def sort(a, b):   // 定義函式
    if a > b:
        return a, b
    else:
        return b, a

>>> c=sort1, 2)      //傳回值設給 c
>>> c
(2, 1)
>>> type(c)
<class 'tuple'>

下面是四則運算的範例, 傳入兩個數後函式會傳會其加減乘除結果, 此例傳回值放在小括弧內傳回 (tuple 的元素只要用逗號隔開即可, Python 會自動加上小括號) :

def arithmatic(a, b):
    return (a+b, a-b, a*b, a/b)

例如 : 

>>> def arithmatic(a, b):
    return (a+b, a-b, a*b, a/b)      # 以 tuple 傳回多個值

>>> arithmatic(3, 7)
(10, -4, 21, 0.42857142857142855)


(4). 位置引數與關鍵字引數 : 

位置引數必須全部放在關鍵字引數之前, 例如下面傳回立方體體積的函式 volume() :

def volume(l, w, h):
    return l*w*h

此函式有長 (l), 寬 (w), 與高 (h) 三個位置參數, 呼叫時引數數目必須與參數數目相同 (即每個參數都必須傳入引數), 並且位置需與參數對應,  例如 :

>>> def volume(l, w, h):
    return l*w*h

>>> v=volume(10, 20, 30)
>>> v
6000
>>> volume(10, 20)       # 缺第三個參數 h 導致錯誤
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
TypeError: volume() missing 1 required positional argument: 'h'   

此處長寬高分別為 10, 20, 30, 雖然傳入順序不同答案還是會相同, 但若缺第三個參數時, 錯誤訊息即指名缺了參數 h. 如果使用關鍵字引數, 就不需要按照函式定義之參數順序, 也可以部分用位置引數, 部分用關鍵字引數, 但關鍵字引數必須集中放在最後面, 例如 :

>>> def volume(l, w, h):
    return l*w*h

>>> volume(h=30, l=10, w=20)       # 全部使用關鍵字引數 (順序可隨意)
6000
>>> volume(10, h=30, w=20)          # 部分使用關鍵字引數時必須集中放在最後面
6000
>> volume(h=30, 20, l=10)              # 關鍵字引數 h=30 不可放在前面
  File "<pyshell>", line 1
SyntaxError: positional argument follows keyword argument


(5) 參數的預設值 :   

函式的參數可以設定預設值, 當該參數沒有傳入引數時即以預設值代替, 而有傳入引數時則取代預設值. 定義函式時若有設定預設值須注意 :
  • 有設定預設值的參數必須集中放在參數列的後面.
  • 預設值應該只用不可變資料 (數值, 字串, 元組), 使用可變資料 (串列, 字典, 集合) 當預設基本上無效, 但也不會出現錯誤訊息 (不是語法錯誤), 這是因為可變資料使用傳址呼叫, 只有第一次呼叫時才有預設效果, 之後的呼叫因為會記住上一次內容而失去預設功能. 
例如 :

>>> def volume(l=1, w=1, h=1):     # 全部參數都有預設值
    return l*w*h

>>> volume()     # 使用 l=1, w=1, h=1 預設值
1
>>> volume(10, 20, 30)    # 傳入引數取代預設值
6000

下面範例測試有預設值的參數必須放在參數列的最後面, 否則會有語法錯誤 : 

>>> def volume(l=1, w, h):      # 有預設值的參數需放在最後面
    return l*w*h

  File "<pyshell>", line 1
SyntaxError: non-default argument follows default argument
>>> def volume(w, h, l=1):       # 有預設值的參數需放在最後面
    return l*w*h

>>> volume(20, 30, 10)
6000

下面範例測試參數預設值不應該使用可變資料, 因為那是傳址呼叫, 沒有預設效果, 此例希望每次呼叫函式時都能使用一個新的空串列來儲存所傳入之第一參數, 但如果在參數列用空串列當預設值會有問題 :

>>> def func(e, lst=[]):  # 定義函式 func 參數 lst 預設值為空串列
    lst.append(e)               # 將參數 e 加入串列中
    print(lst)                      # 印出串列內容
    
>>> func('hello')             # 第一次呼叫函式 lst 有預設效果
['hello']
>>> func('world')            # 第二次呼叫函式 lst 沒有預設效果 (記住了上一次呼叫的結果)
['hello', 'world']

可見 lst 參數由於是可變資料, 其位址在函式執行完後仍然存在且記住其內容. 如果要達到上述目的, 不應該把空串列當參數預設值, 而是要在函式內使用一個空串列之區域變數 :

>>> def func(e):
    lst=[]                    # 空串列區域變數
    lst.append(e)
    print(lst)
    
>>> func('hello')
['hello']
>>> func('world')
['world']


(6). 用 * 收集位置引數

當傳入函式之位置參數個數不固定 (可變) 時, 可以用一個 tuple 變數前面冠一個 * 運算符來收集位置引數, 傳入之引數會按照順序被函式內的 tuple 變數接收, 例如 : 

>>> def test_args(*args):              # 用元組 args 收集可變數量之位置引數
    print('args 類型 :', type(args))
    print('傳入之參數 tuple : ', args)
    
>>> test_args(1, 2, 3, True, 'hello world')
args 類型 : <class 'tuple'>                                        # 類型為 tuple
傳入之參數 tuple :  (1, 2, 3, True, 'hello world')     #順序與傳入引數之順序相同

注意, 元組變數使用 args 只是慣例, 可以改用任何合法識別字, 例如 : 

>>> def test_args(*var):
    print('var 類型 :', type(var))
    print('傳入之參數 tuple : ', var)

>>> test_args(1, 2, 3, True, 'hello world')
var 類型 : <class 'tuple'>
傳入之參數 tuple :  (1, 2, 3, True, 'hello world')

如果要保留部分必要之位置引數, 其餘用 *args 收集, 則 *args 必須放在參數的最後面, 例如 : 

>>> def test_args(a, b, c, *args):     # 保留三個必要的位置參數, 其餘交由 args 收集
    print('a :', a)
    print('b :', b)
    print('c :', c)
    print('其餘之位置引數 : ', args)
    
>>> test_args(1, 2, 3, True, 'hello world')  
a : 1
b : 2
c : 3
其餘之位置引數 :  (True, 'hello world')


(7). 用 ** 收集關鍵字引數 : 

與用 * 收集不確定數量位置引數類似, 關鍵字引數可以用 ** 運算符收集為字典變數 (慣例上常用 **kwargs, 也可以用其他名稱), 例如 :

>>> def test_kwargs(**kwargs):          # 以字典變數 kwargs 收集關鍵字引數
    print('kwargs 型態:', type(kwargs))
    print(kwargs)
    
>>> test_kwargs(name='tony', age=28, gender='male', married=True)
kwargs 型態: <class 'dict'>     # 收集結果為字典
{'name': 'tony', 'age': 28, 'gender': 'male', 'married': True}  

函式同時使用 *args 與 **kwargs 時, 參數列的前後關係如下 :  

(位置參數, *args, 關鍵字參數, **kwargs) 

亦即位置參數須在前, 關鍵字參數須在後, 例如 :  

>>> def test_mix(a, *args, x, y, **kwargs):   # 位置參數在前, 關鍵字參數在後
    print('a:', a)
    print('args:', args)
    print('x:', x)
    print('y:', y)
    print(kwargs)
    
>>> test_mix(1, 2, 3, x=4, y=5, z=6, w=7)
a: 1
args: (2, 3)
x: 4
y: 5
{'z': 6, 'w': 7}


(8). 全域變數與區域變數 : 

Python 變數依其作用範圍分為兩種 : 
  • 全域變數 :
    在 Python 程式最外層 (無縮排之主程式部分) 所指派的變數為全域變數, 其作用範圍為整個程式, 在函式內外均可存取全域變數 (但同名時在函式內會存取到區域變數). 
  • 區域變數 : 
    在函式內部指派的變數為區域變數, 其作用範圍僅限於函式內, 在函式外部無法存取函式內之區域變數, 當函式結束時區域變數就消失了. 當區域變數與全域變數同名時, 在函式內會優先存取到區域變數, 若要在函式內要存取外部同名之全域變數須在前面加 global 關鍵字
Python 程式裡會存在各種命名空間, 在每個命名空間中的變數名稱都是獨一無二, 且與其他命名空間中的同名變數無關. 例如主程式中的變數為全域變數, 各函式內的變數為區域變數, 即使它們名稱相同, 但所參考的物件是不同的, 而關鍵字 global 就是在函式內翻牆存取外部同名變數的工具. 

首先測試全域變數的作用範圍遍及程式的每一處, 例如 :

>>> a='hello'         # 全域變數
>>> id(a)               # 傳回物件之記憶體位置參考
2452239477480     
>>> def func():      # 定義函數
    print('a=', a, 'id=', id(a))        # 輸出全域變數之值與其
    
>>> func()
a= hello id= 2452239477480    

此例先定義了一個字串物件 a, 然後在函式 func() 中印出變數 a 之值, 由於搜尋函式區域命名空間中沒有找到一個名為 a 之區域變數, 會往上搜尋外層命名空間, 故會參考到外部之全域變數, 透過呼叫內建函數 id() 取得物件之記憶體參考位址可知, 函式內存取到的確實是全域變數. 

但是如果函式內有與全域變數同名之區域變數時, 會優先指涉區域變數 (先搜尋區域命名空間), 例如重新定義函式 func() 使其有一個區域變數 a :

>>> def func():        # 重新定義函式 
    a='world'              # 指定一個區域變數 a
    print('a=', a, 'id=', id(a))    # 輸出區域變數

>>> func()
a= world id= 2452239476696      # 存取區域變數
>>> a
'hello'                                            # 全域變數不受影響
>>> id(a)
2452239477480   

可見函式內被指定內容的是與外部 a 變數全然無關的區域 a 變數, 從 id() 傳回之記憶體參考位址可知這兩個同名變數乃是兩個不同的物件. 

總之, 只要函式內存在一個與全域變數同名之區域變數, 當此函式被放進記憶體時, 解譯器便將該變數視為區域變數, 未經賦值直接存取它就會出現變數尚未定義之錯誤, 若將上面的 func() 修改為 :

>>> a='hello'         # 全域變數
>>> def func():
    print('a=', a, 'id=', id(a))    # 存取區域變數 (下一行有同名變數, 全域變數無法被參考)
    a='world'                           # 定義區域變數
    print('a=', a, 'id=', id(a))

>>> func()
Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
  File "<pyshell>", line 2, in func
UnboundLocalError: local variable 'a' referenced before assignment    

函式 func() 內第一行試圖去存取外部區域變數結果造成變數 a 未定義錯誤, 此乃源自一個錯誤認知, 以為在尚未定義區域變數 a='world' 之前將存取到全域變數, 事實上當函式定義完畢存入記憶體時, 第一行的 a 就不會參考外部變數了, 因為它發現函式內有個同名變數, 所以才會出現未賦值就存取錯誤. 

在函式內要存取全域變數必須先用關鍵字 global 宣告, 然後再進行存取, 例如 :

>>> def func():
    global a        # 宣告 a 變數為外部之全域變數
    a='world'      # 重新賦值 (建立新物件)
    print('a=', a, 'id=', id(a))
    
>>> func()
a= world id= 2452239476696       # a 變數內容已變, 其實是建立新物件 (字串不可變)
>>> a 
'world'                     # 內容已變更
>>> id(a)
2452239476696      # 新物件

此例重新定義 func() 函式, 首先宣告變數 a 為 global (全域變數), 然後以 a='world' 對 a 變數重新賦值, 這個 a 會參考到外部的全域變數 a, 故呼叫 func() 時顯示其內容已變更為 'world', 但卻顯示與最初的 id  不同 (由 2452239477480 變為 2452239476696), 此乃字串為不可變資料型態之故, 對字串變數重新賦值其實是建立一個新字串物件, 然後將 a 參考此新物件. 

注意, global 必須單獨宣告, 不可宣告同時賦值, 否則會出現語法錯誤, 例如 : 

>>> def func():
    global a='world'               # 不可以宣告同時賦值 (語法錯誤)
    print('a=', a, 'id=', id(a))
    
  File "<pyshell>", line 2
    global a='world'
            ^
SyntaxError: invalid syntax   

下面範例以簡單的增量函式測式 global 的用法 : 

>>> def increment():    # 會將全域變數 a 增量 1 的函式
    global a                     # 宣告參考全域變數 a
    a += 1                        # 增量 1 
    print('insid function : a=', a)
    
>>> a=1             # 定義全域變數 a=1
>>> print('before increment : a=', a)    # 呼叫前
before increment : a= 1
>>> increment()                    # 呼叫增量函式
insid function : a= 2              # 增量為 2 
>>> print('after increment : a=', a)        # 呼叫後
after increment : a= 2
>>> increment()
insid function : a= 3              # 第二次呼叫函式
>>> a
3

Python 提供內建函式 locals() 與 globals() 分別用來檢視目前命名空間中所存在之物件, 都會傳回一個字典物件以 key:value 形式呈現物件之名稱與其值, 故可以用 in 運算子檢查指定之物件名稱是否存在. 

剛進入 Python 執行環境時呼叫 globals() 檢視已經存在如下物件 : 

>>> globals()       # 檢視初始之全域命名空間
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001B988D84320>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}

然後建立一個全域變數 somebody 並定義一個函式 hello(), 在此函式內建立一個區域變數 msg 並呼叫 locals() 檢視此函式命名空間內之物件 :

>>> somebody='tony'
>>> def hello(name):
    msg='hello ' + name
    print('locals()=', locals())       # 呼叫 locals() 檢視區域命名空間之物件
    print('msg in locals()', 'msg' in locals())
    print('msg=', msg)

呼叫 hello() 函式可見包括傳入參數 name 與區域變數 msg 都在 locals() 傳回的字典中, 用 in 檢查 msg 是否在字典中結果為 True : 
    
>>> hello(somebody)
locals()= {'name': 'tony', 'msg': 'hello tony'}    # 顯示區域變數 (包含參數 name)
msg in locals() True                                          # msg 是區域變數
msg= hello tony

再次呼叫 globals() 發現全域命名空間多了 somebody (全域變數) 與 hello (函式) 這兩個物件.:

>>> globals()   
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001B988D84320>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'somebody': 'tony', 'hello': <function hello at 0x000001B98AFDF510>}

用 in 運算子檢查可知, 區域變數 msg 不在 globals() 傳回的字典內, 而全域變數 somebody 與函式 hello 則在其中 : 

>>> print('msg in globals()', 'msg' in globals())        # 區域變數 msg 不存在於 globals() 中
msg in globals() False                                               
>>> print('somebody in globals()', 'somebody' in globals())    # 全域變數 somebody 在 globals() 中
somebody in globals() True   
>>> print('hello in globals()', 'hello' in globals())    # 函式 hello 有在 globals() 中
hello in globals() True


(9). 匿名函式 Lambda :

Python 的匿名函式是用關鍵字 lambda 定義的一行運算式函式, 不需要用 def 定義函式名稱, 適合用來實作單一回傳值的小函式, 其語法如下 :

func=lambda 參數列: 運算式   

其中參數列可傳入多個參數, 每個參數以逗號隔開, 運算式必須為單行, 且可直接存取外部 (全域) 變數 (def 函式不行, 必須透過 global 關鍵字翻牆), 其運算結果必須指派給一個變數儲存, 否則無法重複呼叫 (因為匿名). 

例如下面的平方函式 : 

>>> square=lambda x: x**2       # 定義一個平方匿名函式
>>> type(square)    
<class 'function'>                         # lambda 型態為 function
>>> square
<function <lambda> at 0x0000023AF4E241E0>
>>> square(4)                              # 傳回運算結果 (型態為數值)
16
>>> x=square(5)
>>> x
25

下面為多個參數與存取外部全域變數範例 :

>>> w=1
>>> sum=lambda a, b, c: a + b + c + w        # 存取外部變數 w
>>> sum(1, 2, 3)
7
>>> func=lambda a, b, c: max(a, b, c) + w     # 運算式呼叫內建函式 max() 
>>> func(1, 2, 3)
4


(10). 以函式為參數 : 

由於 Python 的函式為第一級函式, 亦即函式如同一般物件可以當成參數傳給另一個函式, 例如 : 

>>> def add(a, b):
    print('a + b=', a + b)

>>> def dosomething(a, b, func):         # 第三參數為一個函式
    return func(a, b)

>>> dosomething(5, 7, add)                  # 第三引數為函式名稱
a + b= 12

此例先定義了 add() 函式, 然後於定義 dosomething() 函式時以 add() 函式做為第三參數, 此函式會呼叫傳入之 add() 函式並傳回其執行結果. 


2. 內建函式 :

Python 提供了豐富的內建函式, 不需匯入即可直接呼叫使用, 參考 :

https://docs.python.org/3.3/library/functions.html

常用內建函式整理如下 :


(1). 系統函式 : 


 系統函數 說明
 dir() 查詢傳入參數 (物件) 之屬性與方法
 type() 查詢傳入參數之資料型別
 help() 查詢傳入參數之說明
 id() 查詢傳入參數 (物件) 之 id 編號 (記憶體位址參考)
 callable() 查詢傳入參數 (物件) 是否可呼叫 (方法)
 isinstance() 查詢傳入參數是否為一物件實體


(2). 輸出入函式 : 


 輸出入函數 說明
 input() 從標準輸入 (鍵盤) 讀取輸入 (傳回字串)
 print() 將變數以 %[f]w.ps 格式輸出至螢幕


函數 print() 的輸出格式為 %[f]w.ps :


 格式 說明
 f 旗標 (可有可無), "0" 表示空格補 0, "-" 表靠左對齊, "+" 表加正負號
 w 欄位寬度
 p 小數位數
 s 資料格式 : d (整數), f (浮點數), s (字串)



(3). 資料型態轉換函式 :


 型別轉換函數 說明
 bin(d) 將整數 d 轉成 2 進位整數表示
 hex(d) 將整數 d 轉成 16 進位整數表示
 oct(d) 將整數 d 轉成 8 進位整數表示
 chr(i) 傳回 Uincode 編碼 i 的 ASCII 字元
 ord(c) 傳回字元 c 的 Unicode 編碼 
 float(x) 將傳入參數 x 轉成浮點數 (float) 型別
 int(x) 將傳入參數 x 轉成整數 (int) 型別
 str(x) 將傳入參數 x 轉成字串 (str) 型別
 bool(x) 將傳入參數 x 轉成布林 (bool) 型別
 complex(x, y) 傳回實部 x 與虛部 y 組成之複數 x+yj



(4). 數值計算函數 : 


 數值計算函數 說明
 abs(x)  傳回變數 x 之絕對值 (複數則傳回大小)
 divmod(x, y) 計算 x 除以 y 並傳回 (商, 餘數) 元組
 max(x) 傳回可迭代型別變數 (如串列) x 元素中的最大值
 max(x1, x2, ...) 傳回列舉數值 x1, x2,... 中的最大值 
 min(x) 傳回可迭代型別變數 (如串列) x 元素中的最大值
 min(x1, x2, ...) 傳回最小值 (列舉數值或可迭代型別如串列)
 pow(x, y) 傳回 x 的 y 次方
 round(x [, d]) 傳回變數 x 之值至小數後第 d 位之最近偶數
 sum(x) 傳回數值串列 (或元組) x 之全部元素加總


以上函數要注意的是 :
  • round() 並非數學中的四捨五入, 而是取值到小數後指定位數之最接近偶數, 所以 round(1.25, 1) 傳回 1.2 而非 1.3, 而 round(1.35, 1) 則傳回 1.4. 預設取值到整數位. 
  • sorted() 可對任何可迭代資料 (串列, 字串, 字典等) 進行排序, 預設是遞增排序, 若要遞減排序, 可傳入第二參數 reverse=True. 


(5). 容器函數 :


 容器函數 說明
 list(x) 將可迭代物件 x 轉成串列傳回
 tuple(x) 將可迭代物件 x 轉成元組傳回
 set(x) 將可迭代物件 x 轉成集合傳回
 dict(x) 將可迭代物件 x 轉成字典傳回


沒有留言 :