python的函數(shù)最詳解
發(fā)布日期：2021-12-19 04:37 | 文章來源：CSDN
一、函數(shù)入門
1.概念
- 函數(shù)是可以重復執(zhí)行一定任務的代碼片段，具有獨立的固定的輸入輸出接口。
- 函數(shù)定義的本質，是給一段代碼取個名字，方便以后重復使用
- 為了方便以后調用這個函數(shù)，在定義它的時候，就需要明確它的輸入（參數(shù)）與輸出（返回值）
2.定義函數(shù)的語法格式
def 函數(shù)名(形參列表): #可執(zhí)行語句 return 返回值
函數(shù)名
- 只要是合法的標識符即可（同變量命名）
- 為了提高可讀性，建議函數(shù)名由一個或多個有意義的單詞組成，單詞之間用下劃線_分隔，字母全部小寫
形參列表
- 在函數(shù)名后面的括號內，多個形參用逗號分隔，可以沒有參數(shù)
- 參數(shù)可以有默認值，可以用等號=直接指定默認值，有默認值的參數(shù)必須排最后
- 沒有默認值的參數(shù)，在調用的時候必須指定
- 形參也可以沒有，但是括號不能省略
- 調用有默認值的參數(shù)要指定名字
返回值
- 返回值可以沒有，直接省略return這句話
- 返回值可以是一個或多個，用逗號分隔，組合成一個元組
- 返回值還可以是表達式
- 多個返回值，不需要的用下劃線頂替!
3.函數(shù)的文檔（注釋→help）
- 一段被注釋的文字對函數(shù)進行解釋。
- 可以用help()查看函數(shù)的文檔，只要把一段字符串緊接著放在函數(shù)的聲明行的后面，它就可以被help識別了。
4.舉例
# 函數(shù)定義 def myfunc(arg1, arg2, arg3=None): ''' This is a example for python documentation. 這是一個為python函數(shù)提供文檔的例子。 arg1: 第一個參數(shù)的說明 arg2: 第二個參數(shù)的說明 arg3: 第三個參數(shù)的說明（這個參數(shù)有默認值） v1, v2, v3: 返回值的說明 ''' v1 = arg1 + arg2 v2 = arg1 * arg2 if arg3 is None: v3 = arg1 + arg2 else: v3 = arg1 + arg2 + arg3 return v1, v2, v3 # 函數(shù)調用 v1, v2, v3 = myfunc(5, 3, arg3=4) print(v1, v2, v3) #8 15 12 # 使用arg3的默認值調用函數(shù) v1, v2, v3 = myfunc(5, 3) print(v1, v2, v3) #8 15 8 # 忽略一個返回值 v1, v2, _ = myfunc(5, 3) print(v1, v2, v3) #8 15 8 # 看看返回值是元組tuple，在返回的過程中被自動解包 print(type(myfunc(5,3))) #<class 'tuple'>
二、函數(shù)的參數(shù)
- 函數(shù)的參數(shù)是參數(shù)與外部可變的輸入之間交互的通道。
- 函數(shù)的參數(shù)名稱應該滿足標識符命名規(guī)范，應該有明確的含義，可通過參數(shù)名稱知道每個參數(shù)的含義。
- 在函數(shù)定義下面的注釋中逐個注明函數(shù)（和返回值）的含義，以便用戶即使不甚了解函數(shù)中的具體內容也能正確無誤的使用它。
- 實參：實際參數(shù)，從外面?zhèn)鬟f來的實際的參數(shù)
- 形參：形式參數(shù)，在函數(shù)內部它形式上的名字
- 調用函數(shù)時，實參按照順序位置與形參綁定，稱為位置參數(shù)（Positional Argument）
- 也可以在調用時，寫明實參與形參的對應關系，稱作傳遞關鍵字參數(shù)（Keyword Argument），這時候位置信息被忽略了
- 同時傳遞位置參數(shù)與關鍵字參數(shù)，應該先傳遞位置參數(shù)，再傳遞關鍵字參數(shù)!
- 函數(shù)定義的時候，可以指定默認值，但帶默認值的參數(shù)必須列在參數(shù)列表的最后
#舉一個小栗子，計算紙箱子的體積
def cube_volume(length, width, height = 0.25):
'''
計算紙箱子的體積(單位：m)
length: 長； width: 寬
height: 高（默認參數(shù)0.25）
v: 返回值，紙箱的體積，單位m**3
'''
if length <= 0:
print('length must larger than 0!')
return 0
if width <= 0:
print('width must larger than 0!')
return 0
if height <= 0:
print('height must larger than 0!')
return 0
v = length*width*height
print('length = %.2f; width = %.2f; height = %.2f; cube volume = %.2f' % \
(length, width, height, v))
return v
# 使用位置參數(shù)調用
v = cube_volume(1, 2, 3)
# 使用關鍵字參數(shù)調用
v = cube_volume(width = 1, height = 2, length = 3)
# 位置參數(shù)和關鍵字參數(shù)混用
v = cube_volume(1, height = 2, width = 3)
# 關鍵字參數(shù)在位置參數(shù)之前會報錯
# v = cube_volume(width = 1, 2, 3)
1.可變對象
- 如果參數(shù)是可變對象（如列表），函數(shù)內部對此對象的修改會在函數(shù)執(zhí)行后仍然有效
- 如果默認參數(shù)是可變對象，函數(shù)內部修改了此對象后，函數(shù)默認值也發(fā)生了改變!
- 實際函數(shù)傳遞進去的是地址，函數(shù)體不會將地址傳遞出來，但地址對應的值發(fā)生了變化。
# 對列表的乘方運算 def pow_list(x, p): ''' power of a list x: list p: power not return value ''' for i in range(len(x)): x[i] **= p #這樣會輸出乘方后的值，但不會改變x列表里的值 #因為在計算時將x中的值傳入了新的參數(shù)進行計算 #for i in x: # i **= p # print(i) #print(x) x = [1,2,3,5,7,9,10,12] pow_list(x,2) print(x) # 可見函數(shù)內部對列表x中元素的更改，當函數(shù)退出之后依然有效
利用可變對象的特點，可以制作一種隱藏的參數(shù)記錄器
# 隱藏的參數(shù)記錄器
def growing_list(x, y=[]):
y.append(x)
print(y)
# 重復執(zhí)行growing_list(‘a')會發(fā)生什么結果？
growing_list(2)#[2]
growing_list('張三') #[2, '張三']
growing_list(22333) #[2, '張三', 22333]
2.參數(shù)收集（不定個數(shù)的參數(shù)）
- 參數(shù)收集，指定是可以往函數(shù)內傳遞不定個數(shù)的參數(shù)，例如有時候傳遞3個，有時候傳遞5個，有時候傳遞10個，等等。
- 傳遞不定個數(shù)的參數(shù)，要在定義參數(shù)時，加上一個星號“*”（形參為空的tuple）。
- 帶星號的參數(shù)可以位于參數(shù)列表的任意位置（不一定是開頭也不一定是結尾），python要求一個函數(shù)只能有一個帶星參數(shù)。
# 不定個數(shù)的數(shù)字求和 def my_sum(*t): # 帶星號的輸入參數(shù)被當作元組處理 print(t, type(t)) sum = 0 for s in t: sum += s return sum # 事實上該函數(shù)接受了不定個數(shù)的輸入參數(shù) my_sum(1,2,3,4,2233)
如果帶星參數(shù)后面還有別的參數(shù)，則它們必須要用關鍵字參數(shù)的方式傳遞，否則python不知道它們到底是啥，都會給收集到帶星參數(shù)里。
# 不定個數(shù)的數(shù)字乘方后求和 def pow_sum(*t, p): # 帶星號的輸入參數(shù)被當作元組處理 print(t, type(t)) sum = 0 for s in t: sum += s**p return sum # 最后一個參數(shù)p，需要指定關鍵字傳遞 pow_sum(1,2,3,4,2233,p=2) # 如果不指定關鍵字傳遞呢？會報錯 # pow_sum(1,2,3,4,2233,2)
3.解決一個實際問題
# 不定個數(shù)的數(shù)字加權求和 # 權重隨著數(shù)字的個數(shù)而發(fā)生變化 def weighted_sum(x1,x2,*y): sum = 0 n = len(y) weight = 1/3/n for i in y: sum += weight*i return sum+1/3*x1+1/3*x2 weighted_sum(1,2,3) weighted_sum(1,2,3,22,44,55) weighted_sum(1,2,3,4,5,6)
4.參數(shù)收集（收集關鍵字參數(shù)）
- python除了帶一個型號的參數(shù)，還支持帶兩個星號的參數(shù)。它的功能是收集關鍵字參數(shù)。
- 一個函數(shù)，至多可以帶一個一星參數(shù)（收集位置參數(shù)），加上一個二星參數(shù)（收集關鍵字參數(shù)）。
- 二星參數(shù)在函數(shù)內部以字典的形式存在。
- 二星參數(shù)必須在參數(shù)列表的末尾，它后面不能再有別的關鍵字參數(shù)和位置參數(shù)了。
# 測試一星參數(shù)和兩星參數(shù)
def test_star(a, b, c, *onestar, **twostar):
print('a = %d; b = %d; c = %d' % (a, b, c))
print(onestar, type(onestar))
print(twostar, type(twostar))
test_star(1, 2, 3, 4, 5, 6, s1 = 7, s2 = 8, s3 = 9)
# 換個順序呢？
# test_star(1, 2, 3, 4, 5, 6, s1 = 7, s2 = 8, s3 = 9, a = 10, b = 11, c = 12)
# 報錯了，二星參數(shù)后面不能再傳遞關鍵字參數(shù)了（當然位置參數(shù)也不行）
“參數(shù)收集”功能，會讓帶星參數(shù)盡量少的收集，把更多參數(shù)留給正常的位置參數(shù)和關鍵字參數(shù)
# 如果有默認參數(shù)，要注意可能引起的bug
def test_star(a, b, c, p = 5, *onestar, **twostar):
print('a = %d; b = %d; c = %d; p = %d' % (a, b, c, p)) #a = 1; b = 2; c = 3; p = 4
print(onestar, type(onestar))#(5, 6) <class 'tuple'>
print(twostar, type(twostar))#{'s1': 7, 's2': 8, 's3': 9} <class 'dict'>
# 會傳遞一個p=4進去，而不是設想的，onestar=(4,5,6)
test_star(1, 2, 3, 4, 5, 6, s1 = 7, s2 = 8, s3 = 9)
5.逆向參數(shù)收集（炸開參數(shù)）
- 在參數(shù)外部定義好了的列表、元組、字典等，可以在傳參的時候被“炸開”，其中的內容被自動分配到參數(shù)列表中
- “炸”列表或者元組，需要在前面添加一個星號。
- “炸”字典，需要在前面添加兩個星號。
# 炸參數(shù)例子
def zha(a,b,c):
print(a,b,c)
# 炸元組
z = (1,2,3)#1 2 3
zha(*z)
# 炸列表
z = [4,5,6]#4 5 6
zha(*z)
# 炸字典
z = {'a':7,'b':8,'c':9} #7 8 9
zha(**z)
# 炸字典
z = {'c':7,'a':8,'b':9} #8 9 7
zha(**z)
# 如果炸開后參數(shù)個數(shù)或Key不匹配，會報錯
# z = {'c':7,'a':8}
# zha(**z)
6.參數(shù)的內存管理
- python的參數(shù)傳遞，傳遞的是參數(shù)值而非參數(shù)地址。參數(shù)值被復制后傳遞進函數(shù)。
- 對于數(shù)值類型的參數(shù)（整型、浮點、復數(shù)等），在函數(shù)內改變參數(shù)值，函數(shù)外面不受影響。
- 對于容器類型的參數(shù)（列表、字典、字符串等），在函數(shù)內改變了容器里的內容，在函數(shù)的外面也可以體現(xiàn)出來。
# 傳遞數(shù)值類型參數(shù)
# 在函數(shù)內修改，在函數(shù)外面不受影響
def mod_para1(a,b):
print('In mod_para1, before modification: a = %d; b = %d' % (a,b)) #a = 2; b = 8
a *= 2
b += 4
print('In mod_para1, after modification: a = %d; b = %d' % (a,b)) #a = 4; b = 12
a = 2
b = 8
print('Out of mod_para1, before modification: a = %d; b = %d' % (a,b)) #a = 2; b = 8
mod_para1(a,b)
print('Out of mod_para1, after modification: a = %d; b = %d' % (a,b)) #a = 2; b = 8
- 傳遞容器類型參數(shù)
- 在函數(shù)內修改，在函數(shù)外面也能體現(xiàn)，也可以用這種方法向外界傳遞信息
- 如果不希望容器類型中的內容被修改，請手動使用copy.copy() copy.deepcopy()方法
# 列表通過函數(shù)傳參時，被改動了數(shù)據
def mod_para2(x):
print('In mod_para2, before modification: x = ' + str(x))
for i in range(len(x)):
x[i] *= 2
print('In mod_para2, after modification: x = ' + str(x))
x = [i for i in range(10)]
print('Out of mod_para2, before modification: x = ' + str(x))
mod_para2(x)
print('Out of mod_para2, after modification: x = ' + str(x))
import copy
A = [1,2,3]; B = copy.copy(A)
mod_para2(B); print(A,B)
7.函數(shù)中變量的作用域
- 創(chuàng)建于函數(shù)外部，它是全局（Global）的，它在這個py文件內部的任何地方可見。
- 創(chuàng)建于函數(shù)內部，它是局部（Local）的，它只能在函數(shù)內部才能訪問，在函數(shù)外部不可見。
- 全局變量和局部變量重名，函數(shù)內會訪問到局部變量，函數(shù)外訪問到全局變量。
- 函數(shù)內部能訪問全局變量，但不能修改！
- 如果非要在函數(shù)內部修改全局變量，需要聲明（不推薦這么干！）
gv1 = 1
def test():
# gv1=2
print('在函數(shù)內部訪問全局變量：gv1 = %d' % gv1) #1
# gv1=2
test()
print('在函數(shù)外部訪問全局變量：gv1 = %d' % gv1) #1
- 上面的例子，會在gv1 = 2的前一行，報錯，看起來匪夷所思。
- 事實上，這屬于python對全局變量的“遮蔽”（hide）操作。在python的函數(shù)內部對不存在的變量賦值時，默認會重新定義局部變量。也就是說，在整個函數(shù)的內部，gv1都被重新定義了，這一操作會影響整個函數(shù)，因此會在它的上一行報錯。
- 為了訪問被遮蔽的全局變量，需要使用globals()函數(shù)，將全局變量以字典的形式輸出。（globals()['全局變量名']）——或者可以簡單認為出全局變量通過globals()中的字典存儲
- 目前得知python3.10以后是不會報錯了，但這種操作方法我們一般是不推薦的！
# 訪問被遮蔽的全局變量
gv1 = 1
def test():
# 用globals函數(shù)訪問被遮蔽的全局變量
print('在函數(shù)內部訪問全局變量：gv1 = %d' % globals()['gv1'])
gv1 = 2
print('在函數(shù)內部訪問修改后的全局變量：gv1 = %d' % gv1)
test()
print('在函數(shù)外部訪問全局變量：gv1 = %d' % gv1) # 函數(shù)內部修改的其實是同名局部變量，全局變量沒有被修改。
- 正常的做法是，只要有定義全局變量，函數(shù)內部的局部變量就不應該和它重名！
- 可以用global語句，在函數(shù)內部聲明全局變量，經過聲明的全局變量在函數(shù)內部可以訪問和修改。
# 測試全局變量
gv1 = 1
def test():
global gv1 #全局變量我來撐控
print('在函數(shù)內部訪問全局變量：gv1 = %d' % gv1) #1
gv1+=1
test()
print('在函數(shù)外部訪問全局變量：gv1 = %d' % gv1) #2
8.獲取指定范圍內的變量
- python提供了多個方法可以讓我們訪問到每個變量的“名字”和他們持有的“值”
- 變量在內存的某處保存著“名字”-“值”對兒
- globals(): 返回全局范圍內所有變量組成的字典, globals()[“名字”]
- locals(): 返回當前函數(shù)范圍內的所有變量組成的字典
- vars(object): 獲取指定對象范圍內的所有變量組成的字典（如果不傳入object參數(shù)，vars和locals的作用完全相同）
- 如果在全局范圍內（在函數(shù)外部）調用locals()，則它的行為和globals()一樣，也會列出全局范圍內所有變量
- 一般來說，上述函數(shù)所列出的變量字典，都不應該被修改！但事實上它們可以被修改！！不推薦使用這種方式修改變量。
三、局部函數(shù)（函數(shù)的嵌套）
- python可以在函數(shù)的內部定義函數(shù)，多個函數(shù)相互嵌套。在其它函數(shù)內部的函數(shù)稱為“局部函數(shù)”。
- 局部函數(shù)是對外隱藏的，只能封閉在定義它的那一個函數(shù)的內部使用。
- python的函數(shù)也可以作為返回值，如果把局部函數(shù)作為返回值，就可以在其它函數(shù)中使用了。
一個栗子（利用局部函數(shù)實現(xiàn)多種平均值的切換）
# 利用局部函數(shù)實現(xiàn)多種平均值的切換 def mymean(x, mtype = 'arithmetic'): '''計算列表x的平均值，用mtype定義計算哪種平均值，默認為算術平均值（arithmetic mean） ''' def arithmetic(x): ''' 算術平均值（arithmetic mean) ''' m = sum(x)/len(x); return m def geometric(x): '''幾何平均值（geometric mean） ''' p = 1.; n = len(x) for i in range(n):p *= x[i] m = p ** (1/n); return m def harmonic(x): ''' 調和平均值（harmonic mean) ''' s = 0.;n = len(x) for i in range(n): s += 1/x[i] m = 1/(s/n); return m if mtype == 'arithmetic': return arithmetic elif mtype == 'geometric': return geometric elif mtype == 'harmonic': return harmonic else: return arithmetic
- 類似于函數(shù)內局部變量遮蔽全局變量，局部函數(shù)內的變量也會遮蔽它所在函數(shù)的局部變量。
- 因此使用局部函數(shù)時，同樣要注意變量名的問題，不同層次的函數(shù)變量名應該不同。
- 如果要訪問上一層函數(shù)的局部變量，在局部函數(shù)中應該用nonlocal聲明（類比于用global聲明全局變量）。
# 局部函數(shù)內的變量與函數(shù)內的局部變量相沖突，這個程序會報錯
def test1():
fv = 1
def test2():
# print('局部函數(shù)內打印上層函數(shù)中的局部變量：%d' % fv) # 會在這里報錯
fv = 2
print('局部函數(shù)內打印上層函數(shù)中的局部變量（更改后）：%d' % fv) #2
test2()
print('上層函數(shù)內打印局部變量（更改后）：%d' % fv) #1
return fv
print('上層函數(shù)外打印局部變量（更改后）：%d' % test1()) #1
用nolocal聲明的方式可以使用/更改全局變量
# 局部函數(shù)內的變量與函數(shù)內的局部變量相沖突，應該改成這樣就不報錯了
def test1():
fv = 1
def test2():
nonlocal fv # 用nonlocal聲明，把fv聲明為上一層函數(shù)的變量
print('局部函數(shù)內打印上層函數(shù)中的局部變量：%d' % fv) #1
fv = 2
print('局部函數(shù)內打印上層函數(shù)中的局部變量（更改后）：%d' % fv) #2
test2()
print('上層函數(shù)內打印局部變量（更改后）：%d' % fv) #2
return fv
print('上層函數(shù)外打印局部變量（更改后）：%d' % test1()) #2
四、函數(shù)的高級內容
- python中萬物皆對象，函數(shù)也是對象。函數(shù)可以賦值給變量，可以作為函數(shù)的參數(shù)，也可以作為函數(shù)的返回值。
- python中以函數(shù)作為對象的用法，可以類比于c語言中的函數(shù)指針，但比函數(shù)指針靈活的多，也更不容易出錯。
# 以第三章栗子中mymean函數(shù)為例
# 將函數(shù)賦值給變量f
f = mymean2('arithmetic')
# 打印出來看看
print(f)
# 測試一下
x = list(range(1,10))
m = f(x)
print(m)
# 也可以像上面的例子一樣，連起來寫
print(mymean2('geometric')(x))
1.函數(shù)作為函數(shù)的形參
- 有時候需要定義一個函數(shù)，讓它內部的大致流程都固定下來，但其中某些部件可以替換：類似于汽車換發(fā)動機，電腦換顯卡。
- 這種“可替換式”的程序設計方式，在python中可以方便的通過將函數(shù)作為形參的方式來實現(xiàn)。
2.使用函數(shù)作為返回值
- 將一個函數(shù)對象（可以是局部函數(shù)，也可以是別的地方定義的函數(shù)）作為返回值，適合“部件替換式”程序設計中，判斷使用哪個部件。
- 具體實現(xiàn)方式參見第三章局部變量栗子中的代碼
# 以第三章栗子中mymean函數(shù)為例 # 編寫另一個程序，對列表中的數(shù)字進行變換，變成均值為1的另一個列表 # 均值，可以是算術平均值、幾何平均值、調和平均值 def mynormalize(x, mtype): f = mymean(mtype) m = f(x) return [i/m for i in x] x = list(range(1,10)) mtype = 'geometric' print(mymean(mtype)(x)) print(mynormalize(x, mtype))
3.遞歸
- 在一個函數(shù)里面調用它自己，稱為遞歸。
- 遞歸可以視作一種隱式的循環(huán)，不需要循環(huán)語句控制也可實現(xiàn)重復執(zhí)行某段代碼。
- 遞歸在大型復雜程序中非常有用，在數(shù)值和非數(shù)值算法中都能大顯身手！
- 使用遞歸的時候要注意，當一個函數(shù)不斷調用自己的時候，必須保證在某個時刻函數(shù)的返回值是確定的，即不再調用自己。
# 斐波那契數(shù)列（Fibonacci sequence）
# 在現(xiàn)代物理、準晶體結構、化學等領域，斐波納契數(shù)列都有直接的應用
def Fibonacci(n):
''' Fibonacci sequence
f(0)=1, f(1) = 1, f(n) = f(n-1)+f(n-2) '''
if n == 0 or n == 1: return 1
else:return Fibonacci(n-1) + Fibonacci(n-2)
# 測試一下，注意n不要設的太大，python的遞歸效率是比較低的，太大會死機
print(Fibonacci(5))
# 斐波那契數(shù)列，前20位
print('Fibonacci sequence:')
for i in range(20):
print('%d: %d' % (i,Fibonacci(i)))
五、局部函數(shù)與lambda
- lambda表達式是現(xiàn)代編程語言引入的一種函數(shù)實現(xiàn)方式，它可以在一定程度上代替局部函數(shù)。
- 對于局部函數(shù)，它的名字只在函數(shù)內部有意義，在函數(shù)外部看不到它的名字。即便使用返回值的形式傳出來了，它的名字并沒有被同時傳出來。
- 從命名的意義上講，局部函數(shù)都是“隱姓埋名”的，出了這個函數(shù)就沒人知道它的名字。
- lambda表達式就相當于匿名函數(shù)。
# 一行中的hello world
greeting = lambda: print('Hello lambda!')
greeting()
# lambda表達式可以放在數(shù)組里面，批量運行
L = [lambda x: x**2, lambda x: x**3, lambda x: x**4]
for p in L:
print(p(3))
1.用lambda表達式代替局部函數(shù)
# 用lambda表達式代替局部函數(shù)
def mymean2(mtype = 'arithmetic'):
''' 返回計算平均值所用的函數(shù)，用mtype定義計算哪種平均值，默認為算術平均值（arithmetic mean） '''
# 由于lambda表達式只能寫一行，這里用numpy和scipy的現(xiàn)成的函數(shù)來實現(xiàn)
import numpy as np
import scipy.stats as st
a = np.array(x)
if mtype == 'arithmetic': # 算術平均值（arithmetic mean）
return lambda a: np.mean(a)
elif mtype == 'geometric':# 幾何平均值（geometric mean）
return lambda a: st.gmean(a)
elif mtype == 'harmonic': # 調和平均值（harmonic mean）
return lambda a: st.hmean(a)
else: # 默認：算術平均值（arithmetic mean）
return lambda a: np.mean(a)
x = list(range(1,10))
print(x)
print(mymean2('arithmetic')(x))
print(mymean2('geometric')(x))
print(mymean2('harmonic')(x))
2.常見數(shù)學方法的內部函數(shù)
# 判斷所有元素是否為True，相當于多重的and help(all) print(all([3>2,6<9])) # 任意一個元素是否為True，相當于多重的or help(any) print(any([3>2,6<9])) # 最大值和最小值 help(max) help(min) print(max([1,2,5,3])) print(min([1,2,5,3])) # 四舍五入(到小數(shù)點后第n位) help(round) print(round(3.1415926,3)) # 所有元素相加 help(sum) print(sum([1,2,3])) print(sum([1,2,3],5)) # 乘冪 help(pow) print(pow(6,2)) print(pow(6,2,5)) # 帶余除法 help(divmod) print(divmod(6,2)) # 絕對值 help(abs) print(abs(-2.56))
總結
本篇文章就到這里了，希望能夠給你帶來幫助，也希望您能夠多多關注本站的更多內容！
版權聲明：本站文章來源標注為YINGSOO的內容版權均為本站所有，歡迎引用、轉載，請保持原文完整并注明來源及原文鏈接。禁止復制或仿造本網站，禁止在非maisonbaluchon.cn所屬的服務器上建立鏡像，否則將依法追究法律責任。本站部分內容來源于網友推薦、互聯(lián)網收集整理而來，僅供學習參考，不代表本站立場，如有內容涉嫌侵權，請聯(lián)系alex-e#qq.com處理。
相關文章
關注官方微信