python 函數

函數是組織好的，可重復使用的，用來實現單一，或相關聯功能的代碼段。

函數能提高應用的模塊性，和代碼的重復利用率。你已經知道Python提供了許多內建函數，比如print()。但你也可以自己創建函數，這被叫做用戶自定義函數。

定義一個函數

在Python中，定義一個函數要使用def語句，依次寫出函數名、括號、括號中的參數和冒號:，然后，在縮進塊中編寫函數體，函數的返回值用return語句返回。

函數式編程和面向過程編程的區別：

函數式：將某功能代碼封裝到函數中，日后便無需重復編寫，僅調用函數即可

面向對象：對函數進行分類和封裝，讓開發“更快更好更強...”

你可以定義一個由自己想要功能的函數，以下是簡單的規則：

函數代碼塊以 def 關鍵詞開頭，后接函數標識符名稱和圓括號()。

任何傳入參數和自變量必須放在圓括號中間。圓括號之間可以用于定義參數。

函數的第一行語句可以選擇性地使用文檔字符串—用于存放函數說明。

函數內容以冒號起始，并且縮進。

return [表達式] 結束函數，選擇性地返回一個值給調用方。不帶表達式的return相當于返回 None。

語法

def functionname( parameters ):

"函數_文檔字符串"

function_suite

return [expression]

默認情況下，參數值和參數名稱是按函數聲明中定義的的順序匹配起來的。

請注意，函數體內部的語句在執行時，一旦執行到return時，函數就執行完畢，并將結果返回。因此，函數內部通過條件判斷和循環可以實現非常復雜的邏輯。

如果沒有return語句，函數執行完畢后也會返回結果，只是結果為None。

return None可以簡寫為return。

定義和使用

def 函數名(參數):

...

函數體

...

返回值

函數的定義主要有如下要點：

def：表示函數的關鍵字

函數名：函數的名稱，日后根據函數名調用函數

函數體：函數中進行一系列的邏輯計算，如：發送郵件、計算出 [11,22,38,888,2]中的最大數等...

參數：為函數體提供數據

返回值：當函數執行完畢后，可以給調用者返回數據。

返回值

函數是一個功能塊，該功能到底執行成功與否，需要通過返回值來告知調用者。

實例

以下為一個簡單的Python函數，它將一個字符串作為傳入參數，再打印到標準顯示設備上。

def printme( str ):

"打印傳入的字符串到標準顯示設備上"

print str

return

空函數

如果想定義一個什么事也不做的空函數，可以用pass語句：

def nop():

pass

pass語句什么都不做，那有什么用？實際上pass可以用來作為占位符，比如現在還沒想好怎么寫函數的代碼，就可以先放一個pass，讓代碼能運行起來。

小結

定義函數時，需要確定函數名和參數個數；

如果有必要，可以先對參數的數據類型做檢查；

函數體內部可以用return隨時返回函數結果；

函數執行完畢也沒有return語句時，自動return None。

函數可以同時返回多個值，但其實就是一個tuple。

函數調用

定義一個函數只給了函數一個名稱，指定了函數里包含的參數，和代碼塊結構。

這個函數的基本結構完成以后，你可以通過另一個函數調用執行，也可以直接從Python提示符執行。

如下實例調用了printme()函數：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

# 定義函數

def printme( str ):

"打印任何傳入的字符串"

print str;

return;

# 調用函數

printme("我要調用用戶自定義函數!");

printme("再次調用同一函數");

以上實例輸出結果：

我要調用用戶自定義函數!

再次調用同一函數

函數的有三中不同的參數：

普通參數

默認參數

動態參數

普通參數：

# ######### 定義函數 #########

# name 叫做函數func的形式參數，簡稱：形參

def func(name):

print name

# ######### 執行函數 #########

# ‘wupeiqi‘ 叫做函數func的實際參數，簡稱：實參

func(‘wupeiqi‘)

普通參數

默認參數：

def func(name, age = 18):

print "%s:%s" %(name,age)

# 指定參數

func(‘wupeiqi‘, 19)

# 使用默認參數

func(‘alex‘)

注：默認參數需要放在參數列表最后

默認參數

動態參數：

def func(*args):

print args

# 執行方式一

func(11,33,4,4454,5)

# 執行方式二

li = [11,2,2,3,3,4,54]

func(*li)

動態參數

def func(*args):

print args

# 執行方式一

func(11,33,4,4454,5)

# 執行方式二

li = [11,2,2,3,3,4,54]

func(*li)

動態參數

def func(*args, **kwargs):

print args

print kwargs

按值傳遞參數和按引用傳遞參數

定義函數的時候，我們把參數的名字和位置確定下來，函數的接口定義就完成了。對于函數的調用者來說，只需要知道如何傳遞正確的參數，以及函數將返回什么樣的值就夠了，函數內部的復雜邏輯被封裝起來，調用者無需了解。

Python的函數定義非常簡單，但靈活度卻非常大。除了正常定義的必選參數外，還可以使用默認參數、可變參數和關鍵字參數，使得函數定義出來的接口，不但能處理復雜的參數，還可以簡化調用者的代碼。

所有參數(自變量)在Python里都是按引用傳遞。如果你在函數里修改了參數，那么在調用這個函數的函數里，原始的參數也被改變了。例如：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

# 可寫函數說明

def changeme( mylist ):

"修改傳入的列表"

mylist.append([1,2,3,4]);

print "函數內取值: ", mylist

return

# 調用changeme函數

mylist = [10,20,30];

changeme( mylist );

print "函數外取值: ", mylist

傳入函數的和在末尾添加新內容的對象用的是同一個引用。故輸出結果如下：

函數內取值: [10, 20, 30, [1, 2, 3, 4]]

函數外取值: [10, 20, 30, [1, 2, 3, 4]]

參數

以下是調用函數時可使用的正式參數類型：

必備參數

關鍵字參數

默認參數

不定長參數

設置默認參數時，有幾點要注意：

一是必選參數在前，默認參數在后，否則Python的解釋器會報錯(思考一下為什么默認參數不能放在必選參數前面)；

二是如何設置默認參數。

當函數有多個參數時，把變化大的參數放前面，變化小的參數放后面。變化小的參數就可以作為默認參數。

使用默認參數有什么好處？最大的好處是能降低調用函數的難度

必備參數

必備參數須以正確的順序傳入函數。調用時的數量必須和聲明時的一樣。

調用printme()函數，你必須傳入一個參數，不然會出現語法錯誤：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

#可寫函數說明

def printme( str ):

"打印任何傳入的字符串"

print str;

return;

#調用printme函數

printme();

以上實例輸出結果：

Traceback (most recent call last):

File "test.py", line 11, in

printme();

TypeError: printme() takes exactly 1 argument (0 given)

關鍵字參數

可變參數允許你傳入0個或任意個參數，這些可變參數在函數調用時自動組裝為一個tuple。而關鍵字參數允許你傳入0個或任意個含參數名的參數，這些關鍵字參數在函數內部自動組裝為一個dict。

關鍵字參數和函數調用關系緊密，函數調用使用關鍵字參數來確定傳入的參數值。

使用關鍵字參數允許函數調用時參數的順序與聲明時不一致，因為 Python 解釋器能夠用參數名匹配參數值。

以下實例在函數 printme() 調用時使用參數名：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

#可寫函數說明

def printme( str ):

"打印任何傳入的字符串"

print str;

return;

#調用printme函數

printme( str = "My string");

以上實例輸出結果：

My string

下例能將關鍵字參數順序不重要展示得更清楚：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

#可寫函數說明

def printinfo( name, age ):

"打印任何傳入的字符串"

print "Name: ", name;

print "Age ", age;

return;

#調用printinfo函數

printinfo( age=50, name="miki" );

以上實例輸出結果：

Name: miki

Age 50

對于關鍵字參數，函數的調用者可以傳入任意不受限制的關鍵字參數。

使用命名關鍵字參數時，要特別注意，如果沒有可變參數，就必須加一個*作為特殊分隔符。如果缺少*，Python解釋器將無法識別位置參數和命名關鍵字參數

缺省參數

調用函數時，缺省參數的值如果沒有傳入，則被認為是默認值。下例會打印默認的age，如果age沒有被傳入：

1 #!/usr/bin/python

2 #-*- coding: UTF-8 -*-

3

4 #可寫函數說明

5 def printinfo( name, age = 35):6 "打印任何傳入的字符串"

7 print "Name:", name;8 print "Age", age;9 return;10

11 #調用printinfo函數

12 printinfo( age=50, name="miki");13 printinfo( name="miki" );

以上實例輸出結果：

Name: miki

Age 50

Name: miki

Age 35

不定長參數

你可能需要一個函數能處理比當初聲明時更多的參數。這些參數叫做不定長參數，和上述2種參數不同，聲明時不會命名。基本語法如下：

1 def functionname([formal_args,] *var_args_tuple ):2 "函數_文檔字符串"

3 function_suite4 return [expression]

加了星號(*)的變量名會存放所有未命名的變量參數。選擇不多傳參數也可。如下實例：

#!/usr/bin/python

# -*- coding: UTF-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

遞歸函數

在函數內部，可以調用其他函數。如果一個函數在內部調用自身本身，這個函數就是遞歸函數。

舉個例子，我們來計算階乘n! = 1 x 2 x 3 x ... x n，用函數fact(n)表示，可以看出：

fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n

所以，fact(n)可以表示為n x fact(n-1)，只有n=1時需要特殊處理。

于是，fact(n)用遞歸的方式寫出來就是：

def fact(n):

if n==1:

return 1

return n * fact(n - 1)

上面就是一個遞歸函數。可以試試：

>>> fact(1)

1

>>> fact(5)

120

>>> fact(100)

93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

如果我們計算fact(5)，可以根據函數定義看到計算過程如下：

===> fact(5)

===> 5 * fact(4)

===> 5 * (4 * fact(3))

===> 5 * (4 * (3 * fact(2)))

===> 5 * (4 * (3 * (2 * fact(1))))

===> 5 * (4 * (3 * (2 * 1)))

===> 5 * (4 * (3 * 2))

===> 5 * (4 * 6)

===> 5 * 24

===> 120

遞歸函數的優點是定義簡單，邏輯清晰。理論上，所有的遞歸函數都可以寫成循環的方式，但循環的邏輯不如遞歸清晰。

使用遞歸函數需要注意防止棧溢出。在計算機中，函數調用是通過棧(stack)這種數據結構實現的，每當進入一個函數調用，棧就會加一層棧幀，每當函數返回，棧就會減一層棧幀。由于棧的大小不是無限的，所以，遞歸調用的次數過多，會導致棧溢出。

解決遞歸調用棧溢出的方法是通過尾遞歸優化，事實上尾遞歸和循環的效果是一樣的，所以，把循環看成是一種特殊的尾遞歸函數也是可以的。

尾遞歸是指，在函數返回的時候，調用自身本身，并且，return語句不能包含表達式。這樣，編譯器或者解釋器就可以把尾遞歸做優化，使遞歸本身無論調用多少次，都只占用一個棧幀，不會出現棧溢出的情況。

尾遞歸調用時，如果做了優化，棧不會增長，因此，無論多少次調用也不會導致棧溢出。

遺憾的是，大多數編程語言沒有針對尾遞歸做優化，Python解釋器也沒有做優化，所以，即使把上面的fact(n)函數改成尾遞歸方式，也會導致棧溢出。

小結

使用遞歸函數的優點是邏輯簡單清晰，缺點是過深的調用會導致棧溢出。

針對尾遞歸優化的語言可以通過尾遞歸防止棧溢出。尾遞歸事實上和循環是等價的，沒有循環語句的編程語言只能通過尾遞歸實現循環。

Python標準的解釋器沒有針對尾遞歸做優化，任何遞歸函數都存在棧溢出的問題。

匿名函數

python 使用 lambda 來創建匿名函數。

lambda只是一個表達式，函數體比def簡單很多。

lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。

lambda函數擁有自己的命名空間，且不能訪問自有參數列表之外或全局命名空間里的參數。

雖然lambda函數看起來只能寫一行，卻不等同于C或C++的內聯函數，后者的目的是調用小函數時不占用棧內存從而增加運行效率。

語法

lambda函數的語法只包含一個語句，如下：

lambda [arg1 [,arg2,.....argn]]:expression

如下實例：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

# 可寫函數說明

sum = lambda arg1, arg2: arg1 + arg2;

# 調用sum函數

print "相加后的值為 : ", sum( 10, 20 )

print "相加后的值為 : ", sum( 20, 20 )

以上實例輸出結果：

return 語句

return語句[表達式]退出函數，選擇性地向調用方返回一個表達式。不帶參數值的return語句返回None。之前的例子都沒有示范如何返回數值，下例便告訴你怎么做：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

# 可寫函數說明

def sum( arg1, arg2 ):

# 返回2個參數的和."

total = arg1 + arg2

print "函數內 : ", total

return total;

# 調用sum函數

total = sum( 10, 20 );

以上實例輸出結果：

函數內 : 30

小結

Python的函數具有非常靈活的參數形態，既可以實現簡單的調用，又可以傳入非常復雜的參數。

默認參數一定要用不可變對象，如果是可變對象，程序運行時會有邏輯錯誤！

要注意定義可變參數和關鍵字參數的語法：

*args是可變參數，args接收的是一個tuple；

**kw是關鍵字參數，kw接收的是一個dict。

以及調用函數時如何傳入可變參數和關鍵字參數的語法：

可變參數既可以直接傳入：func(1, 2, 3)，又可以先組裝list或tuple，再通過*args傳入：func(*(1, 2, 3))；

關鍵字參數既可以直接傳入：func(a=1, b=2)，又可以先組裝dict，再通過**kw傳入：func(**{‘a‘: 1, ‘b‘: 2})。

使用*args和**kw是Python的習慣寫法，當然也可以用其他參數名，但最好使用習慣用法。

命名的關鍵字參數是為了限制調用者可以傳入的參數名，同時可以提供默認值。

定義命名的關鍵字參數在沒有可變參數的情況下不要忘了寫分隔符*，否則定義的將是位置參數。

變量作用域

一個程序的所有的變量并不是在哪個位置都可以訪問的。訪問權限決定于這個變量是在哪里賦值的。

變量的作用域決定了在哪一部分程序你可以訪問哪個特定的變量名稱。兩種最基本的變量作用域如下：

全局變量

局部變量

全局變量和局部變量

定義在函數內部的變量擁有一個局部作用域，定義在函數外的擁有全局作用域。

局部變量只能在其被聲明的函數內部訪問，而全局變量可以在整個程序范圍內訪問。調用函數時，所有在函數內聲明的變量名稱都將被加入到作用域中。如下實例：

#!/usr/bin/python

# -*- coding: UTF-8 -*-

total = 0; # 這是一個全局變量

# 可寫函數說明

def sum( arg1, arg2 ):

#返回2個參數的和."

total = arg1 + arg2; # total在這里是局部變量.

print "函數內是局部變量 : ", total

return total;

#調用sum函數

sum( 10, 20 );

print "函數外是全局變量 : ", total

以上實例輸出結果：

函數內是局部變量 : 30

函數外是全局變量 : 0

內置函數

Python3版本所有的內置函數：

The Python interpreter has a number of functions and types built into it that are always available. They are listed here in alphabetical order.

注: 查看3.0版本詳細猛擊這里查看2.0版本詳細猛擊這里

1. abs()　　獲取絕對值

2. all()　　接受一個迭代器，如果迭代器的所有元素都為真，那么返回True，否則返回False

3. any()　　接受一個迭代器，如果迭代器里有一個元素為真，那么返回True,否則返回False

4. ascii()　　調用對象的__repr__()方法，獲得該方法的返回值.

5. bin(),　6. oct(), ?7. hex() ?　　三個函數功能為：將十進制數分別轉換為2/8/16進制。

8. bool()　　測試一個對象是True還是False.

9. bytes()　　將一個字符串轉換成字節類型

10. str()　　將字符類型/數值類型等轉換為字符串類型

11. challable()　　判斷對象是否可以被調用，能被調用的對象就是一個callables對象，比如函數和帶有__call__()的實例。

12. char()，13. ord()　　查看十進制數對應的ASCII字符/查看某個ASCII對應的十進制數。

14. classmethod()　　用來指定一個方法為類的方法，由類直接調用執行，只有一個cls參數,執行雷的方法時，自動將調用該方法的類賦值給cls.沒有此參數指定的類的方法為實例方法。

15. complie()　　將字符串編譯成python能識別或可以執行的代碼，也可以將文字讀成字符串再編譯。

16. complex()

17. delattr()　　刪除對象的屬性

具體查看：python面向對象類的成員中屬性的詳細介紹

18. dict()　　創建數據字典

19. dir()　　不帶參數時返回當前范圍內的變量，方法和定義的類型列表，帶參數時返回參數的屬性，方法列表。

20. divmod()　　分別取商和余數

21. enumerate()　　返回一個可以枚舉的對象，該對象的next()方法將返回一個元組。

22. eval()　　將字符串str當成有效的表達式來求值并返回計算結果

23. exec()　　執行字符串或complie方法編譯過的字符串，沒有返回值

24. filter()　　過濾器，構造一個序列，等價于[ item for item in iterables if function(item)]，在函數中設定過濾條件，逐一循環迭代器中的元素，將返回值為True時的元素留下，形成一個filter類型數據。

25. float()　　講一個字符串或整數轉換為浮點數。

26. format()　　格式化輸出字符串，format(value, format_spec)實質上是調用了value的__format__(format_spec)方法。

27. frozenset()　　創建一個不可修改的集合。

28. getattr()　　獲取對象的屬性

29. globals()　　返回一個描述當前全局變量的字典

30. hasattr()

31. hash()　　哈希值

32. help()　　返回對象的幫助文檔

33. id()　　返回對象的內存地址

34. input()　　獲取用戶輸入內容

35. int()　　將一個字符串或數值轉換為一個普通整數

36. isinstance()　　檢查對象是否是類的對象，返回True或False

37. issubclass()　　檢查一個類是否是另一個類的子類。返回True或False

38. iter()

39. len()　　返回對象長度，參數可以是序列類型(字符串，元組或列表)或映射類型(如字典)

40. list()　　列表構造函數。

41. locals()　　打印當前可用的局部變量的字典

42. map()

43. max()　　返回給定元素里最大值

44. meoryview()

45. min()　　返回給定元素里最小值

46. next()　　返回一個可迭代數據結構(如列表)中的下一項

47. object()

48. open()　　打開文件

49. pow()　　冪函數

50. print()　　輸出函數

51. property()

52. range()　　根據需要生成一個指定范圍的數字，可以提供你需要的控制來迭代指定的次數

53. repr()　　將任意值轉換為字符串，供計時器讀取的形式

54. reversed()　　　反轉，逆序對象

55. round()　　四舍五入

56. set()

57. setattr()　　與getattr()相對應

58. slice()　　切片功能

59. sorted()　　排序

60. staticmethod()

61. str()　　字符串構造函數

62. sum()　　求和

63. super()　　調用父類的方法

64. tuple()　　元組構造函數

65. type()　　顯示對象所屬的類型

66. vars()

67. zip()　　將對象逐一配對

68. __import__()

分類

一、數學運算類

abs(x)

求絕對值

1、參數可以是整型，也可以是復數

2、若參數是復數，則返回復數的模

complex([real[, imag]])

創建一個復數

divmod(a, b)

分別取商和余數

注意：整型、浮點型都可以

float([x])

將一個字符串或數轉換為浮點數。如果無參數將返回0.0

int([x[, base]])

將一個字符轉換為int類型，base表示進制

long([x[, base]])

將一個字符轉換為long類型

pow(x, y[, z])

返回x的y次冪

range([start], stop[, step])

產生一個序列，默認從0開始

round(x[, n])

四舍五入

sum(iterable[, start])

對集合求和

oct(x)

將一個數字轉化為8進制

hex(x)

將整數x轉換為16進制字符串

chr(i)

返回整數i對應的ASCII字符

bin(x)

將整數x轉換為二進制字符串

bool([x])

將x轉換為Boolean類型

二、集合類操作

basestring()

str和unicode的超類

不能直接調用，可以用作isinstance判斷

format(value [, format_spec])

格式化輸出字符串

格式化的參數順序從0開始，如“I am {0},I like {1}”

unichr(i)

返回給定int類型的unicode

enumerate(sequence [, start = 0])

返回一個可枚舉的對象,該對象的next()方法將返回一個tuple

iter(o[, sentinel])

生成一個對象的迭代器，第二個參數表示分隔符

max(iterable[, args...][key])

返回集合中的最大值

min(iterable[, args...][key])

返回集合中的最小值

dict([arg])

創建數據字典

list([iterable])

將一個集合類轉換為另外一個集合類

set()

set對象實例化

frozenset([iterable])

產生一個不可變的set

str([object])

轉換為string類型

sorted(iterable[, cmp[, key[, reverse]]])

隊集合排序

tuple([iterable])

生成一個tuple類型

xrange([start], stop[, step])

xrange()函數與range()類似，但xrnage()并不創建列表，而是返回一個xrange對象，它的行為與列表相似，但是只在需要時才計算列表值，當列表很大時，這個特性能為我們節省內存

三、邏輯判斷

all(iterable)

1、集合中的元素都為真的時候為真

2、特別的，若為空串返回為True

any(iterable)

1、集合中的元素有一個為真的時候為真

2、特別的，若為空串返回為False

cmp(x, y)

如果x < y ,返回負數；x == y, 返回0；x > y,返回正數

四、反射

callable(object)

檢查對象object是否可調用

1、類是可以被調用的

2、實例是不可以被調用的，除非類中聲明了__call__方法

classmethod()

1、注解，用來說明這個方式是個類方法

2、類方法即可被類調用，也可以被實例調用

3、類方法類似于Java中的static方法

4、類方法中不需要有self參數

compile(source, filename, mode[, flags[, dont_inherit]])

將source編譯為代碼或者AST對象。代碼對象能夠通過exec語句來執行或者eval()進行求值。

1、參數source：字符串或者AST(Abstract Syntax Trees)對象。

2、參數 filename：代碼文件名稱，如果不是從文件讀取代碼則傳遞一些可辨認的值。

3、參數model：指定編譯代碼的種類。可以指定為 ‘exec’,’eval’,’single’。

4、參數flag和dont_inherit：這兩個參數暫不介紹

dir([object])

1、不帶參數時，返回當前范圍內的變量、方法和定義的類型列表；

2、帶參數時，返回參數的屬性、方法列表。

3、如果參數包含方法__dir__()，該方法將被調用。當參數為實例時。

4、如果參數不包含__dir__()，該方法將最大限度地收集參數信息

delattr(object, name)

刪除object對象名為name的屬性

eval(expression [, globals [, locals]])

計算表達式expression的值

execfile(filename [, globals [, locals]])

用法類似exec()，不同的是execfile的參數filename為文件名，而exec的參數為字符串。

filter(function, iterable)

構造一個序列，等價于[ item for item in iterable if function(item)]

1、參數function：返回值為True或False的函數，可以為None

2、參數iterable：序列或可迭代對象

getattr(object, name [, defalut])

獲取一個類的屬性

globals()

返回一個描述當前全局符號表的字典

hasattr(object, name)

判斷對象object是否包含名為name的特性

hash(object)

如果對象object為哈希表類型，返回對象object的哈希值

id(object)

返回對象的唯一標識

isinstance(object, classinfo)

判斷object是否是class的實例

issubclass(class, classinfo)

判斷是否是子類

len(s)

返回集合長度

locals()

返回當前的變量列表

map(function, iterable, ...)

遍歷每個元素，執行function操作

memoryview(obj)

返回一個內存鏡像類型的對象

next(iterator[, default])

類似于iterator.next()

object()

基類

property([fget[, fset[, fdel[, doc]]]])

屬性訪問的包裝類，設置后可以通過c.x=value等來訪問setter和getter

reduce(function, iterable[, initializer])

合并操作，從第一個開始是前兩個參數，然后是前兩個的結果與第三個合并進行處理，以此類推

reload(module)

重新加載模塊

setattr(object, name, value)

設置屬性值

repr(object)

將一個對象變幻為可打印的格式

slice()

staticmethod

聲明靜態方法，是個注解

super(type[, object-or-type])

引用父類

type(object)

返回該object的類型

vars([object])

返回對象的變量，若無參數與dict()方法類似

bytearray([source [, encoding [, errors]]])

返回一個byte數組

1、如果source為整數，則返回一個長度為source的初始化數組；

2、如果source為字符串，則按照指定的encoding將字符串轉換為字節序列；

3、如果source為可迭代類型，則元素必須為[0 ,255]中的整數；

4、如果source為與buffer接口一致的對象，則此對象也可以被用于初始化bytearray.

zip([iterable, ...])

實在是沒有看懂，只是看到了矩陣的變幻方面

五、IO操作

file(filename [, mode [, bufsize]])

file類型的構造函數，作用為打開一個文件，如果文件不存在且mode為寫或追加時，文件將被創建。添加‘b’到mode參數中，將對文件以二進制形式操作。添加‘+’到mode參數中，將允許對文件同時進行讀寫操作

1、參數filename：文件名稱。

2、參數mode：‘r‘(讀)、‘w‘(寫)、‘a‘(追加)。

3、參數bufsize：如果為0表示不進行緩沖，如果為1表示進行行緩沖，如果是一個大于1的數表示緩沖區的大小 。

input([prompt])

獲取用戶輸入

推薦使用raw_input，因為該函數將不會捕獲用戶的錯誤輸入

open(name[, mode[, buffering]])

打開文件

與file有什么不同？推薦使用open

print

打印函數

raw_input([prompt])

設置輸入，輸入都是作為字符串處理

其他

help()--幫助信息

后記

內置函數，一般都是因為使用頻率比較頻繁或是是元操作，所以通過內置函數的形式提供出來，通過對python的內置函數分類分析可以看出來：基本的數據操作基本都是一些數學運算(當然除了加減乘除)、邏輯操作、集合操作、基本IO操作，然后就是對于語言自身的反射操作，還有就是字符串操作，也是比較常用的，尤其需要注意的是反射操作。

總結

以上是生活随笔為你收集整理的python123自定义幂函数_python基础之函数的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。