Python函數詳解
Python函數詳解
一、函數概念function
- 函數是對實現某一功能的代碼的封裝
- 函數可以實現代碼的復用，從而減少代碼的重復編寫
- 函數可以接受任何類型的輸入作為其參數
- 函數可以通過關鍵字 return 可以返回任何類型的結果
沒有使用函數式編程之前帶來的問題:
- 代碼的組織結構不清晰，可讀性差
- 實現重復的功能時，只能重復編寫實現功能的代碼，導致代碼冗余，白白耗費精力
- 假如某一部分功能需要擴展或更新時，需要找出所有實現此功能的地方，一一修改，無法統(tǒng)一管理，加大維護難度
函數分類
內建函數
? builtins function
? Python提供內建函數，無需事先定義，如len()、sum()、max()、print()
>> sum([1,1,1],20) #求和，只能接收列表和元組 >> 23
? 自定義函數
? 用戶自己創(chuàng)建的函數，被叫做用戶自定義函數
二、函數定義和調用
規(guī)則
1. 函數代碼塊以 def 關鍵詞開頭，后接函數標識符名稱和圓括號(),函數內容以冒號起始，并且縮進。
圓括號中可以用于定義參數，任何傳入參數和自變量必須放在圓括號中。
2. 函數的第一行語句可以選擇性地使用文檔字符串—用于存放函數說明。
return [表達式] 結束函數，選擇性地返回一個值給調用方。不帶表達式的return相當于返回 None。
語法
def functionname( parameters ): "函數_文檔字符串" function_suite return [expression]
例
#!/usr/bin/python3.8
def printme(str): # 定義函數
"打印任何傳入的字符串" # 文檔字符串
print(str)
return
printme("hello world") # 調用函數，函數名加小括號函數的調用
- 先找到名字
- 根據名字調用代碼
函數在定義階段的動作
只檢測語法，不執(zhí)行代碼，語法錯誤在函數定義階段就會檢測出來，而代碼的邏輯錯誤只有在調用執(zhí)行時才會知道
例
In [8]: def get_result(): # 函數定義階段，沒有報錯，因為語法沒有錯誤 ...: print(r - 1) ...: In [9]: get_result() # 運行函數報錯 NameError: name 'r' is not defined
定義函數的三種形式
無參
應用場景僅僅只是執(zhí)行一些操作，比如與用戶交互，打印
def myfunc():
print("www.fklinux.com") 有參
需要根據外部傳進來的參數，才能執(zhí)行相應的邏輯，比如統(tǒng)計時長，數學運算
def get_reslut(x, o , y):
print(x)
print(o)
print(y)空函數
設計代碼結構
def auth_user(user,password):
'''
auth function
:param user: 用戶名
:param password: 密碼
:return: 認證結果
'''
pass
def get(filename):
'''
:param filename:
:return:
'''
pass
def put(filename):
'''
:param filename:
:return:
''' 函數使用的原則
必須得先定義，才可調用
在使用函數時,一定要明確區(qū)分定義階段和調用階段
在函數里面的任何代碼都只是定義而已，即使函數體里面有其他函數也不會現在調用，只是定義要使用其他函數而已，只有在調用此函數時，這個函數內的代碼才會執(zhí)行。
# 定義階段
def foo():
print('from foo') # 函數體里的東西在定義階段實際上只是一堆字符串存到內存而已
func()
def func():
print('from bar')
# 調用階段
foo()有參函數和無參函數的調用對比
定義階段
In [7]: def tell_tag(tag,n): # 有參數
...: print(tag*n)
...:
...: def tell_msg(): # 無參數
...: print(' hello world')
...:
調用階段
...: tell_tag('*',15)
...: tell_msg()
...: tell_tag('*',15)
...:
***************
hello world
***************1、定義時無參，意味著調用時也無需傳入參數
2、定義時有參，意味著調用時則"必須"傳入參數,默認參數雖然不用必須手動傳參，但是也是傳入了默認參數
函數調用的方式
語句形式
foo()
表達式形式
3 * len('hello') # len() 是 python 的內置函數做為另外一個函數的參數
range(len('hello')) range(5)不帶括號調用函數
In [1]: def hello(a,b): ...: print(a + b) In [2]: hello(1,2) # 函數調用，帶括號表示告訴編譯器"執(zhí)行這個函數" In [6]: c=hello # 不帶括號表示把函數賦給另一個函數對象 In [8]: c(3,4) 7
三、文檔字符串
定義
在函數體的第一行，可以使用一對三引號（‘’'）或者（“”"）來定義文檔字符串，文檔字符串通常第一行以大寫字母開頭，以句號 （.）結束，第二行是空行，第三行開始是詳細描述。強烈建議為你重要的函數寫文檔字符串都遵循此慣例。
作用
文檔字符串是使用Python過程中一個很重要的工具，他對程序文檔很有幫助，使程序很容易理解。甚至當程序運行的時候，可以從一個函數中返回文檔字符串。把函數當做一個對象來看，這更有助于我們的理解，就相當于獲取一個對象的屬性（doc）.
函數文檔字符串舉例
# cat nester.py 這是一個模塊文件
#!/usr/bin/env python3.8
'''這是模塊文檔字符串'''
def print_list(name):
'''這是函數文檔字符串'''
for each_item in name:
if isinstance(each_item,list):
print_list(each_item)
else:
print(each_item)
#python3.8
>>> import nester
>>> print(nester.print_list.__doc__)
這是函數文檔字符串
>>> help(nester)
Help on module nester:
NAME
nester - 這是模塊文檔字符串
FILE
/python/nester.py
FUNCTIONS
print_list(name)
這是函數文檔字符串
(END) 四、參數解析
1、形參和實參
形參
形式參數簡稱形參，是指在定義函數時，定義的一個變量名；
下面的代碼中，arg1、arg2、arg3就是形參
def foo(arg1,arg2,arg3)
print('The first argument is ',arg1)
print('The second argument is ',arg2)
print('The third argument is ',arg3)實參
實際參數簡稱實參，是指在調用函數時傳入的實際的數據，是給形參賦值的，可以理解為變量的值；函數調用時，將值綁定到變量名上，函數調用結束，解除綁定。
下面的 1、2、3 就是實參。
foo(1,2,3)
2、參數類型
? 必備參數
? 關鍵字參數
? 默認參數
? 不定長參數
必備參數
對于函數來講也叫位置參數，有位置上的要求，要一一對應
必備參數須以正確的順序傳入函數。調用時的數量必須和聲明時的一樣。
比如調用printme()函數，你必須傳入一個參數，不然會出現語法錯誤
#!/usr/bin/python3.8 def printme( str ): print (str); return ;
關鍵字參數
在傳入實參時以鍵值對的形式傳入參數
允許函數調用時參數的順序與聲明時不一致，因為 Python 解釋器能夠用參數名匹配參數值。
以下實例在函數 printme() 調用時使用參數名：
#!/usr/bin/python3.8 def printme( str ): print(str); return;
# 調用printme函數 printme( str = "My string"); 輸出結果： My string
下例能將關鍵字參數順序不重要展示得更清楚：
#!/usr/bin/python3.8
def printinfo( name, age ):
print ("Name: ", name);
print ("Age ", age);
return;# 調用printinfo函數 printinfo( age=50, name="miki" ) 輸出結果： Name: miki Age 50
缺省參數
調用函數時，缺省參數的值如果沒有傳入，則被認為是默認值。
下例會打印默認的age，如果age沒有被傳入：
#!/usr/bin/python3.8
def printinfo( name, age = 35 ):
print ("Name: ", name);
print ("Age ", age);
return;# 調用printinfo函數 printinfo( age=50, name="miki" ); printinfo( name="miki" ) 輸出結果： Name: miki Age 50 Name: miki Age 35
注：在函數定義時，默認參數必須放在位置(必備)參數的后面,比如：
In [49]: def printinfo( age=35,name ):
...: print("Name: ", name);
...: print("Age ", age);
...: return;
...:
...:
File "<ipython-input-49-ad599e8b1050>", line 1
def printinfo( age=35,name ):
^
SyntaxError: non-default argument follows default argument不定長參數
如果需要一個函數能處理比當初聲明時更多的參數。這些參數叫做不定長參數,也叫動態(tài)參數、萬能參數，和上述2種參數不同，聲明時不會命名。
語法：
def functionname([formal_args,] *var_args_tuple ): function_suite return [expression] # 加了星號（*）的變量名會存放所有未命名的變量參數。
例1：
#!/usr/bin/python3.8
def printinfo( arg1, *vartuple ):
print("輸出: ")
print(arg1)
for var in vartuple:
print(var)
return
# 調用printinfo 函數
printinfo( 10 )
printinfo( 70, 60, 50 )
輸出結果：
輸出:
10
輸出:
70
60
50例2
#vim multi.py
def multiarg(*args):
for i in args:
print(i)
return
def multiargs(*args):
print(args[2])
return
print("第一個調用:")
multiarg('hello','lili','tom','wing')
print("第2個調用:")
multiargs('hello','lili','tom','wing')
執(zhí)行結果：
第一個調用:
hello
lili
tom
wing
第2個調用:
tom*args和**kwargs
[wing@macserver ~]$ cat b.py
#!/usr/bin/env python3.8
def foo(*args,**kwargs):
print ('args = ',args)
print ('kwargs = ',kwargs)
print ('-'*20)
if __name__ == '__main__':
foo(1,2,3,4)
foo(a=1,b=2,c=3)
foo(1,2,3,4,a=1,b=2,c=3) # 同時使用*args和**kwargs，必須*args參數列在前
foo('a',1,None,a=1,b='2',c=3)
# *args是一個tuple,**kwargs表示關鍵字參數，是一個dict
執(zhí)行結果：
[wing@macserver ~]$ python b.py
args = (1, 2, 3, 4)
kwargs = {}
--------------------
args = ()
kwargs = {'a': 1, 'c': 3, 'b': 2}
--------------------
args = (1, 2, 3, 4)
kwargs = {'a': 1, 'c': 3, 'b': 2}
--------------------
args = ('a', 1, None)
kwargs = {'a': 1, 'c': 3, 'b': '2'}
-------------------- 一些特殊的傳參用法
In [91]: def print_args(*args):
...: print('傳入的位置參數會包含在一個元組里:',args)
...:情景 1 普通傳參
In [92]: print_args(22,'192.168.1.10','wing') 傳入的位置參數會包含在一個元組里: (22, '192.168.1.10', 'wing')
情景 2 傳入列表
In [93]: li = [22,'192.168.1.10','wing']
In [94]: print_args(li)
傳入的位置參數會包含在一個元組里: ([22, '192.168.1.10', 'wing'],)
# 上面的這種方式是，每個實參對象作為元組的一個元素
In [4]: print_args(*li)
傳入的位置參數會包含在一個元組里: (22, '192.168.1.10', 'wing')
In [5]: print_args(*'abc')
傳入的位置參數會包含在一個元組里: ('a', 'b', 'c')
# 這也就是傳說中元組解包的原理
# 把一個可迭代對象中的每個元素作為元組的每一個元素 情景3 **kwargs也有同樣的用法
In [6]: def print_kwargs(**kwargs):
...: print("接收的關鍵字參數，會是一個字典:", kwargs)
...:
In [7]: print_kwargs(name='wing')
接收的關鍵字參數，會是一個字典: {'name': 'wing'}
In [8]: print_kwargs(ip='192.168.1.10', port=22)
接收的關鍵字參數，會是一個字典: {'ip': '192.168.1.10', 'port': 22}
In [9]: dic = {'ip': '192.168.1.10', 'port': 22}
In [10]: print_kwargs(**dic)
接收的關鍵字參數，會是一個字典: {'ip': '192.168.1.10', 'port': 22}
[root@workstation ~]# cat a.py
li={1:"abc",1:"def"} # 在這里字典定義的時候key不能用數字，不然報錯如下
def foo(**arg01):
print(arg01)
foo(**li)
[root@workstation ~]# python3.8 a.py
Traceback (most recent call last):
File "a.py", line 5, in <module>
foo(**li)
TypeError: foo() keywords must be strings三種形參在定義函數時的順序如下
In [108]: def position_arg(arg1, arg2, *args, k1='v1', **kwargs):
...: pass
...: 單星占位
表示星后面的參數必須以關鍵字形式傳參，默認關鍵字參數依然可用
星本身的位置不用傳參
def hello(a,b,,*,c):
print(a,b,c)
hello(1,2,c=5) #此位置的5不能直接傳參
-----------------------------------------
def hello(a,b,*,c=5):
print(a,b,c)
hello(1,2) #此位置c參數還是可以直接使用默認參數五、詳解return
定義在函數體結尾，用來退出函數，選擇性地向調用方返回一個表達式
語法
? return [表達式]
1、 在函數執(zhí)行過程中，當在函數體內遇到 return關鍵字，函數就會立刻停止執(zhí)行，并返回其返回值
def func():
x = 100
return # 函數到這里碰到return就結束了
print('Ok')
func() # 結果不會打印‘Ok‘2、return語句可以返回多個值，每個值用逗號隔開，即元組形式。
3、return語句未寫入 或 寫入不帶參數值的return語句 時則返回None
例：
# 想獲取函數的return結果可以使用print()打印 In [21]: print(fun()) hello world None # 用print打印函數執(zhí)行結果會包含返回值None
例
#!/usr/bin/python3.8
def sum( arg1, arg2 ):
total = arg1 + arg2
return total
# 調用sum函數
print(sum( 10, 20 ))
# 輸出結果
304、接收函數的返回值
函數的返回值必須執(zhí)行函數，此函數的返回值才會被創(chuàng)建并返回
注意：引用函數 返回的結果應該是返回值，而不是函數體打印的東西
ret = foo()
# 使用一個變量來接收一個函數的返回值
print("foo 函數的返回值是：", ret)5、當返回值為多個的時候，必須使用多個變量接收，實際上就是元組解包
def func():
x = 100
return x,1,3
a,b,c=func()
print(a,b,c)六、變量作用域
一個程序所有的變量并不是在任何位置都可以訪問的。訪問權限取決于這個變量是在哪里賦值的。
變量的作用域決定了在哪一部分程序你可以訪問哪個特定的變量名稱。
調用函數時，所有在函數內聲明的變量名稱都將被加入到作用域中
1、全局變量和局部變量
定義在函數內部的變量擁有一個局部作用域
定義在函數外的變量擁有全局作用域
局部變量只能在其被聲明的函數內部訪問
全局變量可以在整個程序范圍內訪問
例
#!/usr/bin/env python3.8
total = 0 # 這是一個全局變量
def sum( arg1, arg2 ):
global total = arg1 + arg2 # total在這里是局部變量.
print("函數內是局部變量 : ", total)
return total;
sum( 10, 20 );
print("函數外是全局變量 : ", total)
# 調用sum函數
sum( 10, 20 );
print "函數外是全局變量 : "，total
輸出結果：
函數內是局部變量 : 30
函數外是全局變量 : 0 命名空間和作用域
命名空間:namespace
是一個包含了變量名稱（鍵）和它們各自相應的對象（值）的字典。
- 一個Python表達式可以訪問局部命名空間和全局命名空間里的變量。
- 如果一個局部變量和一個全局變量重名，則局部變量會覆蓋全局變量。
- 每個函數都有自己的命名空間。類的方法的作用域規(guī)則和通常函數的一樣。
- Python認為任何在函數內賦值的變量都是局部的。因此，如果要給全局變量在一個函數里賦值，必須使用global語句。
global關鍵字
? global VarName表達式會告訴Python， VarName是一個全局變量，這樣Python就不會在局部命名空間里尋找這個變量了。
? 例如，在全局命名空間里定義一個變量Money，再在函數內給變量Money賦值，然后Python會假定Money是一個局部變量。然而，并沒有在訪問前聲明一個局部變量Money，結果就是會出現一個UnboundLocalError的錯誤。需要使用global語句生命使用全局變量Money。
#!/usr/bin/python3.8
Money = 2000
def AddMoney():
# global Money
Money = Money + 1
return Money
print(AddMoney())globals()和locals()函數
根據調用地方的不同，globals()和locals()函數可被用來返回全局和局部命名空間里的名字。
在函數內部調用locals()：
返回的是所有能在該函數里訪問的命名。
在函數內部調用globals()：
返回的是所有在該函數里能訪問的全局名字。
兩個函數的返回類型都是字典。所以名字們能用keys()函數摘取。
七、lambda表達式
Python 使用 lambda 來創(chuàng)建匿名函數。
? • 匿名是因為不需要以標準的方式來聲明,比如說, 使用 def 語句。
? • 一個完整的 lambda"語句"代表了一個表達式,這個表達式的定義體必須和聲明放在同一行。
? • lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
? • lambda函數擁有自己的命名空間，且不能訪問自有參數列表之外或全局命名空間里的參數。
語法
lambda [arg1 [,arg2,…argn]]:expression
參數是可選的,如果使用參數,參數通常也是表達式的一部分。
例：
#!/usr/bin/python3.8
sum = lambda arg1, arg2: arg1 + arg2
# 調用sum函數
print("相加后的值為 : ", sum( 10, 20 ))
print("相加后的值為 : ", sum( 20, 20 ))
輸出結果：
相加后的值為 : 30
相加后的值為 : 40單行語句
def true():
return True上面的函數沒有帶任何的參數并且總是返回 True。python 中單行函數可以和標題寫在同一行
重寫true()函數:
def true(): return True使用 lambda 的等價表達式(沒有參數,返回一個 True)為:
lambda :True
In [4]: a = lambda x, y=2: x + y In [5]: a(5) 7 In [6]: a(3,5) 8
In [2]: a=lambda *z:z In [3]: a(1,2,3,4) (1, 2, 3, 4)
八、內建函數
Python按照對象是否可變，將類型分類為：
不可變類型：
對象的內容不能夠改變(not mutable)，這些類型中主要有數值類型(整數，浮點數，復數),字符
串類型，元組等
可變類型:
對象的內容能夠改變(mutable),主要有列表，字典
Python針對眾多的類型，提供了眾多內建函數來處理
內建函數的查看
>>> dir(__builtins__) ['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BufferError', 'BytesWarning', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError', 'RuntimeWarning', 'StandardError', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'ZeroDivisionError', '_', '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs', 'all', 'any', 'apply', 'basestring', 'bin', 'bool', 'buffer', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'cmp', 'coerce', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'execfile', 'exit', 'file', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'intern', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'long', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip']
>>> import __builtin__ >>> dir(__builtin__)
獲取內建函數幫助：
help()
獲取幫助信息
其完整的一般使用形式為:
help(module.class.function)
例子：
In [3]: import sys
In [4]: help(sys.getsizeof)
函數使用例子
需要對List、Dict進行排序，Python提供了兩個方法對給定的List L進行排序:
? 方法1.用List的成員函數sort進行排序，在本地進行排序，不返回副本
? 方法2.用built-in函數sorted進行排序（從2.4開始），返回副本，原始輸入不變
--------------------------------sorted---------------------------------------
>>> help(sorted)
Help on built-in function sorted in module builtin:
sorted(…)
sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list
---------------------------------sort----------------------------------------
>>> help(list.sort)
Help on method_descriptor:
sort(…)
L.sort(cmp=None, key=None, reverse=False) – stable sort IN PLACE;
cmp(x, y) -> -1, 0, 1
-----------------------------------------------------------------------------
參數說明：
iterable：
是可迭代類型;cmp參數
? cmp接受一個用于比較的函數，比較什么由key決定，拿整形舉例，形式為:
? def f(a,b):
? return a-b
? 如果排序的元素是其他類型的，如果a邏輯小于b，函數返回負數；a邏輯等于b，函數返回0；a邏輯大于
b，函數返回正數就行了
key參數
key用列表元素的某個屬性和函數作為關鍵字,也是接受一個函數，不同的是，這個函數只接受一個元素,
形式如下
def f(a):
return len(a)
key接受的函數返回值，表示此元素的權值，sort將按照權值大小進行排序reverse參數
接受False 或者True 表示是否逆序
返回值：是一個經過排序的可迭代類型，與iterable一樣。
注:一般來說，cmp和key可以使用lambda表達式。
例子：
(1)按照元素長度排序
使用sorted排序：
#!/usr/bin/env python
L = [{1:5,3:4},{1:3,6:3},{1:1,2:4,5:6},{1:9}]
def f(x):
return len(x)
M=sorted(L,key=f)
print M
輸出:
[{1: 9}, {1: 5, 3: 4}, {1: 3, 6: 3}, {1: 1, 2: 4, 5: 6}]
使用sort排序：
#!/usr/bin/env python
L = [{1:5,3:4},{1:3,6:3},{1:1,2:4,5:6},{1:9}]
def f(x):
return len(x)
L.sort(key=f)
print L
(2)按照每個字典元素里面key為1的元素的值排序
L = [{1:5,3:4},{1:3,6:3},{1:1,2:4,5:6},{1:9}]
def f2(a,b):
return a[1]-b[1]
L.sort(cmp=f2)
print L
對由tuple組成的List排序
由tuple組成的List:
>>> students = [(‘john’, ‘A’, 15), (‘jane’, ‘B’, 12), (‘dave’, ‘B’, 10),]
用key函數排序：返回由tuple組成的list
>>> sorted(students, key=lambda student : student[2]) # sort by age
[(‘dave’, ‘B’, 10), (‘jane’, ‘B’, 12), (‘john’, ‘A’, 15)]
用cmp函數排序 ：
>>> sorted(students, cmp=lambda x,y : cmp(x[2], y[2])) # sort by age
[(‘dave’, ‘B’, 10), (‘jane’, ‘B’, 12), (‘john’, ‘A’, 15)]
用 operator 函數來加快速度：
>>> from operator import itemgetter, attrgetter
>>> sorted(students, key=itemgetter(2))
用 operator 函數進行多級排序
Python代碼
>>> sorted(students, key=itemgetter(1,2)) # sort by grade then by age
[(‘john’, ‘A’, 15), (‘dave’, ‘B’, 10), (‘jane’, ‘B’, 12)]
對字典排序 ，返回由tuple組成的List,不再是字典。
Python代碼
>>> d = {‘data1’:3, ‘data2’:1, ‘data3’:2, ‘data4’:4}
>>> sorted(d.iteritems(), key=itemgetter(1), reverse=True)
[(‘data4’, 4), (‘data1’, 3), (‘data3’, 2), (‘data2’, 1)]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Sorting basic:
>>> print sorted([5, 2, 3, 1, 4])
[1, 2, 3, 4, 5]
>>> L = [5, 2, 3, 1, 4]
>>> L.sort()
>>> print L
[1, 2, 3, 4, 5]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Sorting cmp:
>>>L = [(‘b’,2),(‘a’,1),(‘c’,3),(‘d’,4)]
>>>print sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))
[(‘a’, 1), (‘b’, 2), (‘c’, 3), (‘d’, 4)]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Sorting keys:
>>>L = [(‘b’,2),(‘a’,1),(‘c’,3),(‘d’,4)]
>>>print sorted(L, key=lambda x:x[1]))
[(‘a’, 1), (‘b’, 2), (‘c’, 3), (‘d’, 4)]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Sorting reverse:
>>> print sorted([5, 2, 3, 1, 4], reverse=True)
[5, 4, 3, 2, 1]
>>> print sorted([5, 2, 3, 1, 4], reverse=False)
[1, 2, 3, 4, 5]
注：效率key>cmp(key比cmp快)
在Sorting Keys中：我們看到，此時排序過的L是僅僅按照第二個關鍵字來排的，如果我們想用第二個關鍵
字排過序后再用第一個關鍵字進行排序呢?
>>> L = [(‘d’,2),(‘a’,4),(‘b’,3),(‘c’,2)]
>>> print sorted(L, key=lambda x:(x[1],x[0]))
>>>[(‘c’, 2), (‘d’, 2), (‘b’, 3), (‘a’, 4)]
擴展：內置函數列表
abs()
獲取一個數字的絕對值
all()
接受一個序列，如果序列內的所有元素都為真，那么返回True，否則返回False
any()
接受一個序列，如果序列內的元素任何一個為真，則返回 True。
bin() 、oct()、 hex()
將十進制數分別轉換為2/8/16進制。
bytes()
將一個字符串轉換成字節(jié)類型
In [63]: bytes('千鋒', encoding='utf=8') Out[63]: b'\xe5\x8d\x83\xe5\xb3\xb0'str()
將字符類型等轉換為字符串類型, 就是調用一個對象的 str 方法
In [64]: str(b'\xe5\x8d\x83\xe5\xb3\xb0',encoding='utf-8') Out[64]: '千鋒'
callable()
判斷對象是否可以被調用，能被調用的對象就是一個callables對象
dir()
不帶參數時返回當前范圍內的變量，方法和定義的類型列表，帶參數時返回參數的方法列表
divmod()
分別取商和余數
In [66]: divmod(10,3) Out[66]: (3, 1) In [67]: divmod(10,2) Out[67]: (5, 0)
enumerate()
返回一個可以枚舉的對象，該對象的next()方法將返回一個元組。
eval()
把字符串轉換成python代碼去執(zhí)行（有返回值）,不支持復雜表達式In [44]: eval("3+5") Out[44]: 8 In [45]: res = eval("3+5") In [46]: res Out[46]: 8frozenset()
創(chuàng)建一個不可修改的集合。
In [71]: s = frozenset([1,2,3]) In [72]: s1 = set([1,2,3])
round()
精確度，保留幾位小數
# round(x [, n]) # 對參數x的第n+1位小數進行四舍五入，返回一個小數位數為n的浮點數。 # 參數n的默認值是0 In [74]: round(3.1415926,3) Out[74]: 3.142
print()
打印函數，打印內容到標準輸出
print(self, *args, sep=’ ‘, end=’\n’)
import time
for i in range(0, 101, 2):
time.sleep(0.1)
char_num = i//2
# print("{}%".format(char_num)) # 打印多少個#
per_str = '\r{}%: {}\n'.format(i, '#' * char_num) if i == 100 else '\r{}%: {}'.format(i, '#' * char_num)
print(per_str, end='')
print('end')
# \r 換行符，光標在行首
# \n 回車符，光標在行尾enumerate()
返回一個可以枚舉的對象，該對象的next()方法將返回一個元組。
eval()
把字符串轉換成python代碼去執(zhí)行（有返回值）,不支持復雜表達式In [44]: eval("3+5") Out[44]: 8 In [45]: res = eval("3+5") In [46]: res Out[46]: 8frozenset()
創(chuàng)建一個不可修改的集合。
In [71]: s = frozenset([1,2,3]) In [72]: s1 = set([1,2,3])
round()
精確度，保留幾位小數
# round(x [, n]) # 對參數x的第n+1位小數進行四舍五入，返回一個小數位數為n的浮點數。 # 參數n的默認值是0 In [74]: round(3.1415926,3) Out[74]: 3.142
print()
打印函數，打印內容到標準輸出
print(self, *args, sep=’ ‘, end=’\n’)
import time
for i in range(0, 101, 2):
time.sleep(0.1)
char_num = i//2
# print("{}%".format(char_num)) # 打印多少個#
per_str = '\r{}%: {}\n'.format(i, '#' * char_num) if i == 100 else '\r{}%: {}'.format(i, '#' * char_num)
print(per_str, end='')
print('end')
# \r 換行符，光標在行首
# \n 回車符，光標在行尾到此這篇關于09-Python函數詳解的文章就介紹到這了,更多相關Python函數內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要介紹了Python3.5多進程原理與用法,結合實例形式分析了多進程的原理、單進程、多進程、進程類及進程隊列等相關定義與使用技巧,需要的朋友可以參考下2019-04-04
Python使用read_csv讀數據遇到分隔符問題的2種解決方式
read.csv()可以從帶分隔符的文本文件中導入數據,下面這篇文章主要給大家介紹了關于Python使用read_csv讀數據遇到分隔符問題的2種解決方式,文中通過實例代碼介紹的非常詳細,需要的朋友可以參考下2022-07-07
Python處理電子表格的Pandas、OpenPyXL、xlrd和xlwt庫
在Python中處理表格數據,有幾個非常流行且功能強大的庫,Pandas在數據分析方面提供了廣泛的功能,而OpenPyXL、xlrd和xlwt則在處理Excel文件方面各有所長,以下是一些最常用的庫及其示例代碼2024-01-01
這篇文章主要為大家介紹了python密碼學換位密碼及換位解密轉置加密教程，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-05-05
Python讀取txt文件數據的方法(用于接口自動化參數化數據)
這篇文章主要介紹了Python讀取txt文件數據的方法(用于接口自動化參數化數據),需要的朋友可以參考下2018-06-06
這篇文章主要介紹了python操作gitlab API過程解析,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下2019-12-12
這篇文章主要介紹了python?數據挖掘算法,首先給大家介紹了數據挖掘的過程，基于sklearn主要的算法模型講解，給大家介紹的非常詳細，對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2022-02-02
Python中的NumPy實用函數整理之percentile詳解
這篇文章主要介紹了Python中的NumPy實用函數整理之percentile詳解,NumPy函數percentile()用于計算指定維度上數組元素的第?n?個百分位數,返回值為標量或者數組,需要的朋友可以參考下2023-09-09
這篇文章主要為大家介紹了Django admin顯示json字段方法詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2023-06-06
在本篇文章里小編給大家整理的是一篇關于python析構函數用法及注意事項，有需要的朋友們可以學習參考下。2021-06-06