建站
咨詢
售后
建站咨詢
新聞中心
python所有內置函數(shù)的定義詳解
1、定義函數(shù)
創(chuàng)新互聯(lián)專業(yè)為企業(yè)提供沙坡頭網站建設、沙坡頭做網站、沙坡頭網站設計、沙坡頭網站制作等企業(yè)網站建設、網頁設計與制作、沙坡頭企業(yè)網站模板建站服務，10年沙坡頭做網站經驗，不只是建網站，更提供有價值的思路和整體網絡服務。
函數(shù)是可重用的程序。本書中已經使用了許多內建函數(shù)，如len()函數(shù)和range()函數(shù)，但是還沒自定義過函數(shù)。定義函數(shù)的語法格式如下：
def 函數(shù)名(參數(shù)):
函數(shù)體
定義函數(shù)的規(guī)則如下：
①關鍵字def用來定義一個函數(shù)，它是define的縮寫。
②函數(shù)名是函數(shù)的唯一標識，函數(shù)名的命名規(guī)則遵循標識符的命名規(guī)則。
③函數(shù)名后面一定要緊跟著一個括號，括號內的參數(shù)是可選的，括號后面要有冒號。
④函數(shù)體(statement)為一個或一組Python語句，注意要有縮進。
⑤函數(shù)體的第一行可以有文檔字符串，用于描述函數(shù)的功能，用三引號括起來。
按照定義規(guī)則，可以定義第一個函數(shù)了：
def?hello_world():
...?????print('Hello,world!')???#?注意函數(shù)體要有縮進
...
hello_world()
Hello,world!
這個函數(shù)不帶任何參數(shù)，它的功能是打印出“Hello,world!”。最后一行代碼hello_world()是調用函數(shù)，即讓Python執(zhí)行函數(shù)的代碼。
2、全局變量和局部變量
全局變量是定義在所有函數(shù)外的變量。例如，定義一個全局變量a，分別在函數(shù)test1()和test2()使用變量a：
a?=?100???#?全局變量
def?test1():
...?????print(a)
...
def?test2():
...?????print(a)
...
test1()
100
test2()
100
定義了全局變量a之后，在函數(shù)test1()和test2()內都可以使用變量a，由此可知，全局變量的作用范圍是全局。
局部變量是在函數(shù)內定義的變量，除了用關鍵字global修飾的變量以外。例如，在函數(shù)test1()內定義一個局部變量a，分別在函數(shù)外和另一個函數(shù)test2()內使用變量a：
def?test1():
...?????a?=?100???#?局部變量
...?????print(a)
...
def?test2():
...?????print(a)
...
test1()
100
print(a)
Traceback?(most?recent?call?last):
File?"stdin",?line?1,?in?module
NameError:?name?'a'?is?not?defined
test2()
Traceback?(most?recent?call?last):
File?"stdin",?line?1,?in?module
File?"stdin",?line?2,?in?test2
NameError:?name?'a'?is?not?defined
Python解釋器提示出錯了。由于局部變量a定義在函數(shù)test1()內，因此，在函數(shù)test1()內可以使用變量a，但是在函數(shù)外或者另一個函數(shù)test2()內使用變量a，都會報錯，由此可見，局部變量的作用范圍是定義它的函數(shù)內部。
一般情況下，在函數(shù)內聲明的變量都是局部變量，但是采用關鍵字global修飾的變量卻是全局變量：
def?test1():
...?????global?a???#?全局變量
...?????a?=?100
...?????print(a)
...
def?test2():
...?????print(a)
...
test1()
100
print(a)
100
test2()
100
這個程序與上個程序相比，只是在函數(shù)test1()中多了一行代碼“global a”，程序便可以正確運行了。在函數(shù)test1()中，采用關鍵字global修飾了變量a之后，變量a就變成了全局變量，不僅可以在該函數(shù)內使用，還可以在函數(shù)外或者其他函數(shù)內使用。
如果在某個函數(shù)內局部變量與全局變量同名，那么在該函數(shù)中局部變量會覆蓋全局變量：
a?=?100???#?全局變量
def?test1():
...?????a?=?200???#?同名局部變量
...?????print(a)
...
def?test2():
...?????print(a)
...
test1()
200
test2()
100
由于在函數(shù)test1()中定義了一個與全局變量同名的局部變量a，因此，在函數(shù)test1()中全局變量a的值被局部變量覆蓋了，但是在函數(shù)test2()中全局變量a的值沒有被覆蓋。
綜上所述，在Python中，全局變量保存的數(shù)據供整個腳本文件使用;而局部變量只用于臨時保存數(shù)據，變量僅供局部代碼塊使用。
python中函數(shù)的作用
Python 函數(shù)定義以及參數(shù)傳遞
1.函數(shù)定義
#形如def func(args...):
doSomething123
以關鍵字def 開頭，后面是函數(shù)名和參數(shù)下面是函數(shù)處理過程。
舉例：
def add( a, b ):
return a+b12
參數(shù)可以設定默認值，如：
def add( a, b=10 ): #注意：默認值參數(shù)只會運算一次
return a+b12
默認值參數(shù)只會運算一次是什么意思？
def func( a, b=[] ): #b的默認值指向一個空的列表，每次不帶默認值都會指向這塊內存
b.append(a) return b
print(func(1))#向默認的空列表里加入元素1 ，默認列表里已經是[1]print(func(2))#向默認的列表里加入元素2,默認列表里已經是[1,2]print(func(3,[]))#向b指向的空列表里加入元素1 ，默認列表里還是[1,2]print(func(4))#向默認的列表里加入元素4,默認列表里已經是[1,2,4]'''
結果：
[1]
[1, 2]
[3]
[1, 2, 4]
'''12345678910111213141516
這下明白為什么默認參數(shù)只計算一次了吧，函數(shù)參數(shù)不傳遞時默認值總是指向固定的內存空間，就是第一次計算的空間。
2.參數(shù)傳遞
def func(a, b):
print('a=%d, b=%d' % (a,b) )12
在使用函數(shù)時可以如下方式,結果都是相同的
func(10,20) #不使用參數(shù)名，需要按參數(shù)順序傳遞func(a=10,b=20) #使用參數(shù)名可以不按順序傳遞func(b=20,a=10)#結果：a=10, b=20a=10, b=20a=10, b=201234567
如果函數(shù)定義形式如下方式：
def func(*args): #這種定義會把傳遞的參數(shù)包成元組
print(args,type(args))
func(10,20)#結果：#(10, 20) class 'tuple'1234567
舉一個和上述過程相反的例子：
def func(a,b):
print('a=%d, b=%d' % (a,b) )
a = (10, 20)
func(*a) #在調用函數(shù)使用`*`則會把元組解包成單個變量按順序傳入函數(shù)#結果：a=10, b=20123456
總結：*號在定義函數(shù)參數(shù)時，傳入函數(shù)的參數(shù)會轉換成元組，如果 *號在調用時則會把元組解包成單個元素。
另一種定義：
def func(**kw):#使用**定義參數(shù)會把傳入參數(shù)包裝成字典dict
print(kw, type(kw) )
func(a=10,b=20)#這種函數(shù)在使用時必須指定參數(shù)值，使用key=value這種形式#結果：{'b': 20, 'a': 10} class 'dict'12345
相反的例子：
def func(a,b):
print('a=%d, b=%d' % (a,b) )
d = {'a':10, 'b':20 }
func(**d) #在調用時使用**會把字典解包成變量傳入函數(shù)。12345
def func(*args, **kw):#這種形式的定義代表可以接受任意類型的參數(shù)
print(args,kw )12
總結：**號在定義函數(shù)參數(shù)時，傳入函數(shù)的參數(shù)會轉換成字典，如果 **號在調用時則會把字典解包成單個元素。
lambda表達式
lambda表達式就是一種簡單的函數(shù)
形如 f = lambda 參數(shù)1，參數(shù)2： 返回的計算值
例如：
add = lambda x,y: x+y
print(add(1,2))'''
結果：3
'''12345
怎樣理解python中的函數(shù),用戶自定義函數(shù)有什么意義?
函數(shù)是什么？
定義：函數(shù)是組織好的，可重復使用的，用來實現(xiàn)單一，或相關聯(lián)功能的代碼段。
作用：函數(shù)能提高應用的模塊性和代碼的重復利用率。你已經知道Python提供了許多內建函數(shù)，比如print()。但你也可以自己創(chuàng)建函數(shù)，這被叫做用戶自定義函數(shù)。
函數(shù)是 python 的一等公民，函數(shù)也是對象。
使用函數(shù)有兩個步驟：
1、定義函數(shù)?def 函數(shù)名(): 函數(shù)體
2、調用函數(shù)?函數(shù)名()
Python的函數(shù)都有哪些？
Python 函數(shù)
函數(shù)是組織好的，可重復使用的，用來實現(xiàn)單一，或相關聯(lián)功能的代碼段。
函數(shù)能提高應用的模塊性，和代碼的重復利用率。你已經知道Python提供了許多內建函數(shù)，比如print()。但你也可以自己創(chuàng)建函數(shù)，這被叫做用戶自定義函數(shù)。
定義一個函數(shù)
你可以定義一個由自己想要功能的函數(shù)，以下是簡單的規(guī)則：
函數(shù)代碼塊以?def?關鍵詞開頭，后接函數(shù)標識符名稱和圓括號()。
任何傳入參數(shù)和自變量必須放在圓括號中間。圓括號之間可以用于定義參數(shù)。
函數(shù)的第一行語句可以選擇性地使用文檔字符串—用于存放函數(shù)說明。
函數(shù)內容以冒號起始，并且縮進。
return [表達式]?結束函數(shù)，選擇性地返回一個值給調用方。不帶表達式的return相當于返回 None。
語法
def functionname( parameters ): ? "函數(shù)_文檔字符串"
function_suite
return [expression]
默認情況下，參數(shù)值和參數(shù)名稱是按函數(shù)聲明中定義的順序匹配起來的。
實例
以下為一個簡單的Python函數(shù)，它將一個字符串作為傳入參數(shù)，再打印到標準顯示設備上。
實例(Python 2.0+)
def printme( str ): ? "打印傳入的字符串到標準顯示設備上"
print str
return
函數(shù)調用
定義一個函數(shù)只給了函數(shù)一個名稱，指定了函數(shù)里包含的參數(shù)，和代碼塊結構。
這個函數(shù)的基本結構完成以后，你可以通過另一個函數(shù)調用執(zhí)行，也可以直接從Python提示符執(zhí)行。
如下實例調用了printme（）函數(shù)：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 定義函數(shù)def printme( str ): ? "打印任何傳入的字符串"
print str
return
# 調用函數(shù)printme("我要調用用戶自定義函數(shù)!")printme("再次調用同一函數(shù)")
以上實例輸出結果：
我要調用用戶自定義函數(shù)!再次調用同一函數(shù)
參數(shù)傳遞
在 python 中，類型屬于對象，變量是沒有類型的：
a=[1,2,3]
a="Runoob"
以上代碼中，[1,2,3]?是 List 類型，"Runoob"?是 String 類型，而變量 a 是沒有類型，她僅僅是一個對象的引用（一個指針），可以是 List 類型對象，也可以指向 String 類型對象。
可更改(mutable)與不可更改(immutable)對象
在 python 中，strings, tuples, 和 numbers 是不可更改的對象，而 list,dict 等則是可以修改的對象。
不可變類型：變量賦值?a=5?后再賦值?a=10，這里實際是新生成一個 int 值對象 10，再讓 a 指向它，而 5 被丟棄，不是改變a的值，相當于新生成了a。
可變類型：變量賦值?la=[1,2,3,4]?后再賦值?la[2]=5?則是將 list la 的第三個元素值更改，本身la沒有動，只是其內部的一部分值被修改了。
python 函數(shù)的參數(shù)傳遞：
不可變類型：類似 c++ 的值傳遞，如 整數(shù)、字符串、元組。如fun（a），傳遞的只是a的值，沒有影響a對象本身。比如在 fun（a）內部修改 a 的值，只是修改另一個復制的對象，不會影響 a 本身。
可變類型：類似 c++ 的引用傳遞，如 列表，字典。如 fun（la），則是將 la 真正的傳過去，修改后fun外部的la也會受影響
python 中一切都是對象，嚴格意義我們不能說值傳遞還是引用傳遞，我們應該說傳不可變對象和傳可變對象。
python 傳不可變對象實例
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
def ChangeInt( a ): ? ?a = 10
b = 2ChangeInt(b)print b # 結果是 2
實例中有 int 對象 2，指向它的變量是 b，在傳遞給 ChangeInt 函數(shù)時，按傳值的方式復制了變量 b，a 和 b 都指向了同一個 Int 對象，在 a=10 時，則新生成一個 int 值對象 10，并讓 a 指向它。
傳可變對象實例
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可寫函數(shù)說明def changeme( mylist ): ? "修改傳入的列表"
mylist.append([1,2,3,4])
print "函數(shù)內取值: ", mylist
return
# 調用changeme函數(shù)mylist = [10,20,30]changeme( mylist )print "函數(shù)外取值: ", mylist
實例中傳入函數(shù)的和在末尾添加新內容的對象用的是同一個引用，故輸出結果如下：
函數(shù)內取值: ?[10, 20, 30, [1, 2, 3, 4]]函數(shù)外取值: ?[10, 20, 30, [1, 2, 3, 4]]
參數(shù)
以下是調用函數(shù)時可使用的正式參數(shù)類型：
必備參數(shù)
關鍵字參數(shù)
默認參數(shù)
不定長參數(shù)
必備參數(shù)
必備參數(shù)須以正確的順序傳入函數(shù)。調用時的數(shù)量必須和聲明時的一樣。
調用printme()函數(shù)，你必須傳入一個參數(shù)，不然會出現(xiàn)語法錯誤：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可寫函數(shù)說明def printme( str ): ? "打印任何傳入的字符串"
print str
return
#調用printme函數(shù)printme()
以上實例輸出結果：
Traceback (most recent call last):
File "test.py", line 11, in module
printme()TypeError: printme() takes exactly 1 argument (0 given)
關鍵字參數(shù)
關鍵字參數(shù)和函數(shù)調用關系緊密，函數(shù)調用使用關鍵字參數(shù)來確定傳入的參數(shù)值。
使用關鍵字參數(shù)允許函數(shù)調用時參數(shù)的順序與聲明時不一致，因為 Python 解釋器能夠用參數(shù)名匹配參數(shù)值。
以下實例在函數(shù) printme() 調用時使用參數(shù)名：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可寫函數(shù)說明def printme( str ): ? "打印任何傳入的字符串"
print str
return
#調用printme函數(shù)printme( str = "My string")
以上實例輸出結果：
My string
下例能將關鍵字參數(shù)順序不重要展示得更清楚：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可寫函數(shù)說明def printinfo( name, age ): ? "打印任何傳入的字符串"
print "Name: ", name
print "Age ", age
return
#調用printinfo函數(shù)printinfo( age=50, name="miki" )
以上實例輸出結果：
Name: ?mikiAge ?50
默認參數(shù)
調用函數(shù)時，默認參數(shù)的值如果沒有傳入，則被認為是默認值。下例會打印默認的age，如果age沒有被傳入：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可寫函數(shù)說明def printinfo( name, age = 35 ): ? "打印任何傳入的字符串"
print "Name: ", name
print "Age ", age
return
#調用printinfo函數(shù)printinfo( age=50, name="miki" )printinfo( name="miki" )
以上實例輸出結果：
Name: ?mikiAge ?50Name: ?mikiAge ?35
不定長參數(shù)
你可能需要一個函數(shù)能處理比當初聲明時更多的參數(shù)。這些參數(shù)叫做不定長參數(shù)，和上述2種參數(shù)不同，聲明時不會命名。基本語法如下：
def functionname([formal_args,] *var_args_tuple ): ? "函數(shù)_文檔字符串"
function_suite
return [expression]
加了星號（*）的變量名會存放所有未命名的變量參數(shù)。不定長參數(shù)實例如下：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可寫函數(shù)說明def printinfo( arg1, *vartuple ): ? "打印任何傳入的參數(shù)"
print "輸出: "
print arg1
for var in vartuple: ? ? ?print var
return
# 調用printinfo 函數(shù)printinfo( 10 )printinfo( 70, 60, 50 )
以上實例輸出結果：
輸出:10輸出:706050
匿名函數(shù)
python 使用 lambda 來創(chuàng)建匿名函數(shù)。
lambda只是一個表達式，函數(shù)體比def簡單很多。
lambda的主體是一個表達式，而不是一個代碼塊。僅僅能在lambda表達式中封裝有限的邏輯進去。
lambda函數(shù)擁有自己的命名空間，且不能訪問自有參數(shù)列表之外或全局命名空間里的參數(shù)。
雖然lambda函數(shù)看起來只能寫一行，卻不等同于C或C++的內聯(lián)函數(shù)，后者的目的是調用小函數(shù)時不占用棧內存從而增加運行效率。
語法
lambda函數(shù)的語法只包含一個語句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
如下實例：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可寫函數(shù)說明sum = lambda arg1, arg2: arg1 + arg2
# 調用sum函數(shù)print "相加后的值為 : ", sum( 10, 20 )print "相加后的值為 : ", sum( 20, 20 )
以上實例輸出結果：
相加后的值為 : ?30相加后的值為 : ?40
return 語句
return語句[表達式]退出函數(shù)，選擇性地向調用方返回一個表達式。不帶參數(shù)值的return語句返回None。之前的例子都沒有示范如何返回數(shù)值，下例便告訴你怎么做：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可寫函數(shù)說明def sum( arg1, arg2 ): ? # 返回2個參數(shù)的和."
total = arg1 + arg2
print "函數(shù)內 : ", total
return total
# 調用sum函數(shù)total = sum( 10, 20 )
以上實例輸出結果：
函數(shù)內 : ?30
變量作用域
一個程序的所有的變量并不是在哪個位置都可以訪問的。訪問權限決定于這個變量是在哪里賦值的。
變量的作用域決定了在哪一部分程序你可以訪問哪個特定的變量名稱。兩種最基本的變量作用域如下：
全局變量
局部變量
全局變量和局部變量
定義在函數(shù)內部的變量擁有一個局部作用域，定義在函數(shù)外的擁有全局作用域。
局部變量只能在其被聲明的函數(shù)內部訪問，而全局變量可以在整個程序范圍內訪問。調用函數(shù)時，所有在函數(shù)內聲明的變量名稱都將被加入到作用域中。如下實例：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
total = 0 # 這是一個全局變量# 可寫函數(shù)說明def sum( arg1, arg2 ): ? #返回2個參數(shù)的和."
total = arg1 + arg2 # total在這里是局部變量.
print "函數(shù)內是局部變量 : ", total
return total
#調用sum函數(shù)sum( 10, 20 )print "函數(shù)外是全局變量 : ", total
以上實例輸出結果：
函數(shù)內是局部變量 : ?30函數(shù)外是全局變量 : ?0
python常用函數(shù)
1、complex()
返回一個形如?a+bj?的復數(shù)，傳入參數(shù)分為三種情況：
參數(shù)為空時，返回0j；參數(shù)為字符串時，將字符串表達式解釋為復數(shù)形式并返回；參數(shù)為兩個整數(shù)(a,b)時，返回?a+bj；參數(shù)只有一個整數(shù) a 時，虛部 b 默認為0，函數(shù)返回?a+0j。
2、dir()
不提供參數(shù)時，返回當前本地范圍內的名稱列表；提供一個參數(shù)時，返回該對象包含的全部屬性。
3、divmod(a,b)
a -- 代表被除數(shù)，整數(shù)或浮點數(shù)；b -- 代表除數(shù)，整數(shù)或浮點數(shù)；根據 除法運算 計算 a,b 之間的商和余數(shù)，函數(shù)返回一個元組(p,q)?，p 代表商?a//b?，q 代表余數(shù)?a%b。
4、enumerate(iterable,start=0)
iterable -- 一個可迭代對象，列表、元組序列等；start -- 計數(shù)索引值，默認初始為0‘該函數(shù)返回枚舉對象是個迭代器，利用 next() 方法依次返回元素值，每個元素以元組形式存在，包含一個計數(shù)元素(起始為 start )和 iterable 中對應的元素值。
網站名稱：python各函數(shù)意義,python函數(shù)有什么作用
當前網址：http://fisionsoft.com.cn/article/dsscoci.html
