Python函數(shù)的參數(shù)類型

Python函數(shù)的參數(shù)類型主要包括必選參數(shù)、可選參數(shù)、可變參數(shù)、位置參數(shù)和關鍵字參數(shù)，本文介紹一下他們的定義以及可變數(shù)據(jù)類型參數(shù)傳遞需要注意的地方。

創(chuàng)新互聯(lián)公司主營北鎮(zhèn)網(wǎng)站建設的網(wǎng)絡公司,主營網(wǎng)站建設方案,重慶APP開發(fā)公司,北鎮(zhèn)h5微信平臺小程序開發(fā)搭建,北鎮(zhèn)網(wǎng)站營銷推廣歡迎北鎮(zhèn)等地區(qū)企業(yè)咨詢

必選參數(shù)（Required arguments）是必須輸入的參數(shù)，比如下面的代碼，必須輸入2個參數(shù)，否則就會報錯：

其實上面例子中的參數(shù) num1和num2也屬于關鍵字參數(shù)，比如可以通過如下方式調(diào)用：

執(zhí)行結(jié)果：

可選參數(shù)（Optional arguments）可以不用傳入函數(shù)，有一個默認值，如果沒有傳入會使用默認值，不會報錯。

位置參數(shù)（positional arguments）根據(jù)其在函數(shù)定義中的位置調(diào)用，下面是pow()函數(shù)的幫助信息:

x，y，z三個參數(shù)的的順序是固定的，并且不能使用關鍵字：

輸出：

在上面的pow()函數(shù)幫助信息中可以看到位置參數(shù)后面加了一個反斜杠 / ，這是python內(nèi)置函數(shù)的語法定義，Python開發(fā)人員不能在python3.8版本之前的代碼中使用此語法。但python3.0到3.7版本可以使用如下方式定義位置參數(shù)：

星號前面的參數(shù)為位置參數(shù)或者關鍵字參數(shù)，星號后面是強制關鍵字參數(shù)，具體介紹見強制關鍵字參數(shù)。

python3.8版本引入了強制位置參數(shù)（Positional-Only Parameters），也就是我們可以使用反斜杠 / 語法來定義位置參數(shù)了，可以寫成如下形式：

來看下面的例子：

python3.8運行：

不能使用關鍵字參數(shù)形式賦值了。

可變參數(shù) (varargs argument) 就是傳入的參數(shù)個數(shù)是可變的，可以是0-n個，使用星號（ * ）將輸入?yún)?shù)自動組裝為一個元組（tuple）：

執(zhí)行結(jié)果：

關鍵字參數(shù)（keyword argument）允許將任意個含參數(shù)名的參數(shù)導入到python函數(shù)中，使用雙星號（ ** ），在函數(shù)內(nèi)部自動組裝為一個字典。

執(zhí)行結(jié)果：

上面介紹的參數(shù)可以混合使用：

結(jié)果：

注意：由于傳入的參數(shù)個數(shù)不定，所以當與普通參數(shù)一同使用時，必須把帶星號的參數(shù)放在最后。

強制關鍵字參數(shù)（Keyword-Only Arguments）是python3引入的特性，可參考：。 使用一個星號隔開：

在位置參數(shù)一節(jié)介紹過星號前面的參數(shù)可以是位置參數(shù)和關鍵字參數(shù)。星號后面的參數(shù)都是強制關鍵字參數(shù)，必須以指定參數(shù)名的方式傳參，如果強制關鍵字參數(shù)沒有設置默認參數(shù)，調(diào)用函數(shù)時必須傳參。

執(zhí)行結(jié)果：

也可以在可變參數(shù)后面命名關鍵字參數(shù)，這樣就不需要星號分隔符了：

執(zhí)行結(jié)果：

在Python對象及內(nèi)存管理機制中介紹了python中的參數(shù)傳遞屬于對象的 引用傳遞 （pass by object reference），在編寫函數(shù)的時候需要特別注意。

先來看個例子：

執(zhí)行結(jié)果：

l1 和 l2指向相同的地址，由于列表可變，l1改變時，l2也跟著變了。

接著看下面的例子：

結(jié)果：

l1沒有變化！為什么不是[1, 2, 3, 4]呢？

l = l + [4]表示創(chuàng)建一個“末尾加入元素 4“的新列表，并讓 l 指向這個新的對象，l1沒有進行任何操作，因此 l1 的值不變。如果要改變l1的值，需要加一個返回值：

結(jié)果：

下面的代碼執(zhí)行結(jié)果又是什么呢？

執(zhí)行結(jié)果：

和第一個例子一樣，l1 和 l2指向相同的地址，所以會一起改變。這個問題怎么解決呢？

可以使用下面的方式：

也可以使用淺拷貝或者深度拷貝，具體使用方法可參考Python對象及內(nèi)存管理機制。這個問題在Python編程時需要特別注意。

本文主要介紹了python函數(shù)的幾種參數(shù)類型：必選參數(shù)、可選參數(shù)、可變參數(shù)、位置參數(shù)、強制位置參數(shù)、關鍵字參數(shù)、強制關鍵字參數(shù)，注意他們不是完全獨立的，比如必選參數(shù)、可選參數(shù)也可以是關鍵字參數(shù)，位置參數(shù)可以是必選參數(shù)或者可選參數(shù)。

另外，python中的參數(shù)傳遞屬于對象的 引用傳遞 ，在對可變數(shù)據(jù)類型進行參數(shù)傳遞時需要特別注意，如有必要，使用python的拷貝方法。

參考文檔：

--THE END--

python 函數(shù)參數(shù)的類型

1. 不同類型的參數(shù)簡述

#這里先說明python函數(shù)調(diào)用得語法為：

復制代碼

代碼如下:

func(positional_args,

keyword_args,

*tuple_grp_nonkw_args,

**dict_grp_kw_args)

#為了方便說明,之后用以下函數(shù)進行舉例

def test(a,b,c,d,e):

print a,b,c,d,e

舉個例子來說明這4種調(diào)用方式得區(qū)別：

復制代碼

代碼如下:

#

#positional_args方式

test(1,2,3,4,5)

1 2 3 4 5

#這種調(diào)用方式的函數(shù)處理等價于

a,b,c,d,e = 1,2,3,4,5

print a,b,c,d,e

#

#keyword_args方式

test(a=1,b=3,c=4,d=2,e=1)

1 3 4 2 1

#這種處理方式得函數(shù)處理等價于

a=1

b=3

c=4

d=2

e=1

print a,b,c,d,e

#

#*tuple_grp_nonkw_args方式

x = 1,2,3,4,5

test(*x)

1 2 3 4

5

#這種方式函數(shù)處理等價于

復制代碼

代碼如下:

a,b,c,d,e = x

print

a,b,c,d,e

#特別說明:x也可以為dict類型,x為dick類型時將鍵傳遞給函數(shù)

y

{'a': 1,

'c': 6, 'b': 2, 'e': 1, 'd': 1}

test(*y)

a c b e d

#

#**dict_grp_kw_args方式

y

{'a': 1, 'c': 6, 'b': 2, 'e': 1, 'd': 1}

test(**y)

1 2 6

1 1

#這種函數(shù)處理方式等價于

a = y['a']

b = y['b']

... #c,d,e不再贅述

print

a,b,c,d,e

2.

不同類型參數(shù)混用需要注意的一些細節(jié)

接下來說明不同參數(shù)類型混用的情況,要理解不同參數(shù)混用得語法需要理解以下幾方面內(nèi)容.

首先要明白,函數(shù)調(diào)用使用參數(shù)類型必須嚴格按照順序,不能隨意調(diào)換順序,否則會報錯. 如 (a=1,2,3,4,5)會引發(fā)錯誤,;

(*x,2,3)也會被當成非法.

其次,函數(shù)對不同方式處理的順序也是按照上述的類型順序.因為#keyword_args方式和**dict_grp_kw_args方式對參數(shù)一一指定,所以無所謂順序.所以只需要考慮順序賦值(positional_args)和列表賦值(*tuple_grp_nonkw_args)的順序.因此,可以簡單理解為只有#positional_args方式,#*tuple_grp_nonkw_args方式有邏輯先后順序的.

最后,參數(shù)是不允許多次賦值的.

舉個例子說明,順序賦值(positional_args)和列表賦值(*tuple_grp_nonkw_args)的邏輯先后關系:

復制代碼

代碼如下:

#只有在順序賦值,列表賦值在結(jié)果上存在羅輯先后關系

#正確的例子1

x =

{3,4,5}

test(1,2,*x)

1 2 3 4 5

#正確的例子2

test(1,e=2,*x)

1 3 4 5 2

#錯誤的例子

test(1,b=2,*x)

Traceback (most recent call

last):

File "stdin", line 1, in module

TypeError: test()

got multiple values for keyword argument 'b'

#正確的例子1,處理等價于

a,b = 1,2 #順序參數(shù)

c,d,e = x #列表參數(shù)

print a,b,c,d,e

#正確的例子2,處理等價于

a = 1 #順序參數(shù)

e = 2 #關鍵字參數(shù)

b,c,d = x #列表參數(shù)

#錯誤的例子,處理等價于

a = 1 #順序參數(shù)

b = 2 #關鍵字參數(shù)

b,c,d = x

#列表參數(shù)

#這里由于b多次賦值導致異常,可見只有順序參數(shù)和列表參數(shù)存在羅輯先后關系

函數(shù)聲明區(qū)別

理解了函數(shù)調(diào)用中不同類型參數(shù)得區(qū)別之后,再來理解函數(shù)聲明中不同參數(shù)得區(qū)別就簡單很多了.

1. 函數(shù)聲明中的參數(shù)類型說明

函數(shù)聲明只有3種類型, arg, *arg , **arg 他們得作用和函數(shù)調(diào)用剛好相反.

調(diào)用時*tuple_grp_nonkw_args將列表轉(zhuǎn)換為順序參數(shù),而聲明中的*arg的作用是將順序賦值(positional_args)轉(zhuǎn)換為列表.

調(diào)用時**dict_grp_kw_args將字典轉(zhuǎn)換為關鍵字參數(shù),而聲明中**arg則反過來將關鍵字參數(shù)(keyword_args)轉(zhuǎn)換為字典.

特別提醒：*arg

和 **arg可以為空值.

以下舉例說明上述規(guī)則:

復制代碼

代碼如下:

#arg, *arg和**arg作用舉例

def

test2(a,*b,**c):

print a,b,c

#

#*arg 和

**arg可以不傳遞參數(shù)

test2(1)

1 () {}

#arg必須傳遞參數(shù)

test2()

Traceback (most recent call last):

File "stdin", line 1,

in module

TypeError: test2() takes at least 1 argument (0 given)

#

#*arg將順positional_args轉(zhuǎn)換為列表

test2(1,2,[1,2],{'a':1,'b':2})

1 (2, [1, 2], {'a': 1, 'b': 2})

{}

#該處理等價于

a = 1 #arg參數(shù)處理

b = 2,[1,2],{'a':1,'b':2} #*arg參數(shù)處理

c =

dict() #**arg參數(shù)處理

print a,b,c

#

#**arg將keyword_args轉(zhuǎn)換為字典

test2(1,2,3,d={1:2,3:4}, c=12, b=1)

1 (2, 3) {'c': 12, 'b': 1, 'd': {1: 2, 3:

4}}

#該處理等價于

a = 1 #arg參數(shù)處理

b= 2,3 #*arg參數(shù)處理

#**arg參數(shù)處理

c =

dict()

c['d'] = {1:2, 3:4}

c['c'] = 12

c['b'] = 1

print

a,b,c

2. 處理順序問題

函數(shù)總是先處理arg類型參數(shù),再處理*arg和**arg類型的參數(shù).

因為*arg和**arg針對的調(diào)用參數(shù)類型不同,所以不需要考慮他們得順序.

復制代碼

代碼如下:

def test2(a,*b,**c):

print

a,b,c

test2(1, b=[1,2,3], c={1:2, 3:4},a=1)

Traceback (most

recent call last):

File "stdin", line 1, in

module

TypeError: test2() got multiple values for keyword argument

'a'

#這里會報錯得原因是,總是先處理arg類型得參數(shù)

#該函數(shù)調(diào)用等價于

#處理arg類型參數(shù):

a = 1

a = 1

#多次賦值,導致異常

#處理其他類型參數(shù)

...

print a,b,c

def foo(x,y):

... def bar():

... print

x,y

... return bar

...

#查看func_closure的引用信息

a =

[1,2]

b = foo(a,0)

b.func_closure[0].cell_contents

[1, 2]

b.func_closure[1].cell_contents

b()

[1, 2] 0

#可變對象仍然能被修改

a.append(3)

b.func_closure[0].cell_contents

[1, 2, 3]

b()

[1, 2, 3] 0

python 函數(shù)參數(shù)類型

python 的函數(shù)參數(shù)類型分為4種：

1.位置參數(shù)：調(diào)用函數(shù)時根據(jù)函數(shù)定義的參數(shù)位置來傳遞參數(shù)，位置參數(shù)也可以叫做必要參數(shù)，函數(shù)調(diào)用時必須要傳的參數(shù)。

當參數(shù)滿足函數(shù)必要參數(shù)傳參的條件，函數(shù)能夠正常執(zhí)行：

add(1,2) #兩個參數(shù)的順序必須一一對應，且少一個參數(shù)都不可以

當我們運行上面的程序,輸出:

當函數(shù)需要兩個必要參數(shù)，但是調(diào)用函數(shù)只給了一個參數(shù)時，程序會拋出異常

add(1)

當我們運行上面的程序,輸出：

當函數(shù)需要兩個必要參數(shù)，但是調(diào)用函數(shù)只給了三個參數(shù)時，程序會拋出異常

add(1,2,3)

當我們運行上面的程序,輸出

2.關鍵字參數(shù)：用于函數(shù)調(diào)用，通過“鍵-值”形式加以指定。可以讓函數(shù)更加清晰、容易使用，同時也清除了參數(shù)的順序需求。

add(1,2) # 這種方式傳參，必須按順序傳參：x對應1，y對應:2

add(y=2,x=1) #以關健字方式傳入?yún)?shù)（可以不按順序）

正確的調(diào)用方式

add(x=1, y=2)

add(y=2, x=1)

add(1, y=2)

以上調(diào)用方式都是允許的，能夠正常執(zhí)行

錯誤的調(diào)用方式

add(x=1, 2)

add(y=2, 1)

以上調(diào)用都會拋出SyntaxError 異常

上面例子可以看出：有位置參數(shù)時，位置參數(shù)必須在關鍵字參數(shù)的前面，但關鍵字參數(shù)之間不存在先后順序的

3.默認參數(shù)：用于定義函數(shù)，為參數(shù)提供默認值，調(diào)用函數(shù)時可傳可不傳該默認參數(shù)的值，所有位置參數(shù)必須出現(xiàn)在默認參數(shù)前，包括函數(shù)定義和調(diào)用，有多個默認參數(shù)時，調(diào)用的時候，既可以按順序提供默認參數(shù)，也可以不按順序提供部分默認參數(shù)。當不按順序提供部分默認參數(shù)時，需要把參數(shù)名寫上

默認參數(shù)的函數(shù)定義

上面示例第一個是正確的定義位置參數(shù)的方式，第二個是錯誤的，因為位置參數(shù)在前，默認參數(shù)在后

def add1(x=1,y) 的定義會拋出如下異常

默認參數(shù)的函數(shù)調(diào)用

注意：定義默認參數(shù)默認參數(shù)最好不要定義為可變對象，容易掉坑

不可變對象：該對象所指向的內(nèi)存中的值不能被改變，int,string,float,tuple

可變對象，該對象所指向的內(nèi)存中的值可以被改變，dict,list

這里只要理解一下這個概念就行或者自行百度，后續(xù)會寫相關的專題文章講解

舉一個簡單示例

4.可變參數(shù)區(qū)別:定義函數(shù)時，有時候我們不確定調(diào)用的時候會多少個參數(shù),j就可以使用可變參數(shù)

可變參數(shù)主要有兩類：

*args: (positional argument) 允許任意數(shù)量的可選位置參數(shù)(參數(shù)),將被分配給一個元組, 參數(shù)名前帶*，args只是約定俗成的變量名，可以替換其他名稱

**kwargs：(keyword argument) 允許任意數(shù)量的可選關鍵字參數(shù)，,將被分配給一個字典，參數(shù)名前帶**，kwargs只是約定俗成的變量名，可以替換其他名稱

*args 的用法

args 是用來傳遞一個非鍵值對的可變數(shù)量的參數(shù)列表給函數(shù)

語法是使用 符號的數(shù)量可變的參數(shù); 按照慣例,通常是使用arg這個單詞，args相當于一個變量名，可以自己定義的

在上面的程序中,我們使用* args作為一個可變長度參數(shù)列表傳遞給add()函數(shù)。 在函數(shù)中,我們有一個循環(huán)實現(xiàn)傳遞的參數(shù)計算和輸出結(jié)果。

還可以直接傳遞列表或者數(shù)組的方式傳遞參數(shù),以數(shù)組或者列表方式傳遞參數(shù)名前面加（*） 號

理解* * kwargs

**kwargs 允許你將不定長度的鍵值對, 作為參數(shù)傳遞給函數(shù)，這些關鍵字參數(shù)在函數(shù)內(nèi)部自動組裝為一個dict

下篇詳細講解 *args, **kwargs 的參數(shù)傳遞和使用敬請關注

Python的函數(shù)都有哪些？

Python 函數(shù)

函數(shù)是組織好的，可重復使用的，用來實現(xiàn)單一，或相關聯(lián)功能的代碼段。

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

定義一個函數(shù)

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

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

任何傳入?yún)?shù)和自變量必須放在圓括號中間。圓括號之間可以用于定義參數(shù)。

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

函數(shù)內(nèi)容以冒號起始，并且縮進。

return [表達式]?結(jié)束函數(shù)，選擇性地返回一個值給調(diào)用方。不帶表達式的return相當于返回 None。

語法

def functionname( parameters ): ? "函數(shù)_文檔字符串"

function_suite

return [expression]

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

實例

以下為一個簡單的Python函數(shù)，它將一個字符串作為傳入?yún)?shù)，再打印到標準顯示設備上。

實例(Python 2.0+)

def printme( str ): ? "打印傳入的字符串到標準顯示設備上"

print str

return

函數(shù)調(diào)用

定義一個函數(shù)只給了函數(shù)一個名稱，指定了函數(shù)里包含的參數(shù)，和代碼塊結(jié)構(gòu)。

這個函數(shù)的基本結(jié)構(gòu)完成以后，你可以通過另一個函數(shù)調(diào)用執(zhí)行，也可以直接從Python提示符執(zhí)行。

如下實例調(diào)用了printme（）函數(shù)：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

# 定義函數(shù)def printme( str ): ? "打印任何傳入的字符串"

print str

return

# 調(diào)用函數(shù)printme("我要調(diào)用用戶自定義函數(shù)!")printme("再次調(diào)用同一函數(shù)")

以上實例輸出結(jié)果：

我要調(diào)用用戶自定義函數(shù)!再次調(diào)用同一函數(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沒有動，只是其內(nèi)部的一部分值被修改了。

python 函數(shù)的參數(shù)傳遞：

不可變類型：類似 c++ 的值傳遞，如 整數(shù)、字符串、元組。如fun（a），傳遞的只是a的值，沒有影響a對象本身。比如在 fun（a）內(nèi)部修改 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 # 結(jié)果是 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ù)內(nèi)取值: ", mylist

return

# 調(diào)用changeme函數(shù)mylist = [10,20,30]changeme( mylist )print "函數(shù)外取值: ", mylist

實例中傳入函數(shù)的和在末尾添加新內(nèi)容的對象用的是同一個引用，故輸出結(jié)果如下：

函數(shù)內(nèi)取值: ?[10, 20, 30, [1, 2, 3, 4]]函數(shù)外取值: ?[10, 20, 30, [1, 2, 3, 4]]

參數(shù)

以下是調(diào)用函數(shù)時可使用的正式參數(shù)類型：

必備參數(shù)

關鍵字參數(shù)

默認參數(shù)

不定長參數(shù)

必備參數(shù)

必備參數(shù)須以正確的順序傳入函數(shù)。調(diào)用時的數(shù)量必須和聲明時的一樣。

調(diào)用printme()函數(shù)，你必須傳入一個參數(shù)，不然會出現(xiàn)語法錯誤：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

#可寫函數(shù)說明def printme( str ): ? "打印任何傳入的字符串"

print str

return

#調(diào)用printme函數(shù)printme()

以上實例輸出結(jié)果：

Traceback (most recent call last):

File "test.py", line 11, in module

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

關鍵字參數(shù)

關鍵字參數(shù)和函數(shù)調(diào)用關系緊密，函數(shù)調(diào)用使用關鍵字參數(shù)來確定傳入的參數(shù)值。

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

以下實例在函數(shù) printme() 調(diào)用時使用參數(shù)名：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

#可寫函數(shù)說明def printme( str ): ? "打印任何傳入的字符串"

print str

return

#調(diào)用printme函數(shù)printme( str = "My string")

以上實例輸出結(jié)果：

My string

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

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

#可寫函數(shù)說明def printinfo( name, age ): ? "打印任何傳入的字符串"

print "Name: ", name

print "Age ", age

return

#調(diào)用printinfo函數(shù)printinfo( age=50, name="miki" )

以上實例輸出結(jié)果：

Name: ?mikiAge ?50

默認參數(shù)

調(diào)用函數(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

#調(diào)用printinfo函數(shù)printinfo( age=50, name="miki" )printinfo( name="miki" )

以上實例輸出結(jié)果：

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

# 調(diào)用printinfo 函數(shù)printinfo( 10 )printinfo( 70, 60, 50 )

以上實例輸出結(jié)果：

輸出:10輸出:706050

匿名函數(shù)

python 使用 lambda 來創(chuàng)建匿名函數(shù)。

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

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

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

雖然lambda函數(shù)看起來只能寫一行，卻不等同于C或C++的內(nèi)聯(lián)函數(shù)，后者的目的是調(diào)用小函數(shù)時不占用棧內(nèi)存從而增加運行效率。

語法

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

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

如下實例：

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

# 可寫函數(shù)說明sum = lambda arg1, arg2: arg1 + arg2

# 調(diào)用sum函數(shù)print "相加后的值為 : ", sum( 10, 20 )print "相加后的值為 : ", sum( 20, 20 )

以上實例輸出結(jié)果：

相加后的值為 : ?30相加后的值為 : ?40

return 語句

return語句[表達式]退出函數(shù)，選擇性地向調(diào)用方返回一個表達式。不帶參數(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ù)內(nèi) : ", total

return total

# 調(diào)用sum函數(shù)total = sum( 10, 20 )

以上實例輸出結(jié)果：

函數(shù)內(nèi) : ?30

變量作用域

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

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

全局變量

局部變量

全局變量和局部變量

定義在函數(shù)內(nèi)部的變量擁有一個局部作用域，定義在函數(shù)外的擁有全局作用域。

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

實例(Python 2.0+)

#!/usr/bin/python# -*- coding: UTF-8 -*-

total = 0 # 這是一個全局變量# 可寫函數(shù)說明def sum( arg1, arg2 ): ? #返回2個參數(shù)的和."

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

print "函數(shù)內(nèi)是局部變量 : ", total

return total

#調(diào)用sum函數(shù)sum( 10, 20 )print "函數(shù)外是全局變量 : ", total

以上實例輸出結(jié)果：

函數(shù)內(nèi)是局部變量 : ?30函數(shù)外是全局變量 : ?0

python中的函數(shù)和類的區(qū)別

類，class，用來描述具有相同的屬性和方法的對象的集合。它定義了該集合中每個對象所共有的屬性和方法。對象是類的實例。

函數(shù)，是組織好的，可重復使用的，用來實現(xiàn)單一，或相關聯(lián)功能的代碼段。

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

python語言中類和函數(shù)的區(qū)別是什么?

1、規(guī)則不同

類是一種引用數(shù)據(jù)類型，類似于byte、short、int(char)、long、float、double等基本數(shù)據(jù)類型;

函數(shù)必須聲明后才可以被調(diào)用，調(diào)用格式為：函數(shù)名(實參)調(diào)用時函數(shù)名后的小括號中的實參必須和聲明函數(shù)時的函數(shù)括號中的形參個數(shù)相同。

2、主體不同

類是面向?qū)ο蟪绦蛟O計實現(xiàn)信息封裝的基礎;

函數(shù)是指一段在一起的、可以做某一件事的子程序。

3、特點不同

類是一種用戶定義的引用數(shù)據(jù)類型，也稱類類型，每個類包含數(shù)據(jù)說明和一組操作數(shù)據(jù)或者傳遞消息的函數(shù)，類的實例稱為對象;

函數(shù)分為全局函數(shù)、全局靜態(tài)函數(shù)，在類中還可以定義構(gòu)造函數(shù)、析構(gòu)函數(shù)、拷貝構(gòu)造函數(shù)、成員函數(shù)、友元函數(shù)、運算符重載函數(shù)、內(nèi)聯(lián)函數(shù)等。

python函數(shù)和方法區(qū)別

python中函數(shù)和方法的區(qū)別：

首先，從分類的角度來分析。

（1）函數(shù)的分類：

內(nèi)置函數(shù)：python內(nèi)嵌的一些函數(shù)。

匿名函數(shù)：一行代碼實現(xiàn)一個函數(shù)功能。

遞歸函數(shù)

自定義函數(shù)：根據(jù)自己的需求，來進行定義函數(shù)。

（2）方法的分類：

普通方法：直接用self調(diào)用的方法。

私有方法：__函數(shù)名，只能在類中被調(diào)用的方法。

屬性方法：@property，將方法偽裝成為屬性，讓代碼看起來更合理。

特殊方法(雙下劃線方法)：以__init__為例，是用來封裝實例化對象的屬性，只要是實例化對象就一定會執(zhí)行__init方法，如果對象子類中沒有則會尋找父類（超類），如果父類（超類）也沒有，則直接繼承object（python 3.x）類，執(zhí)行類中的__init__方法。

類方法：通過類名的調(diào)用去操作公共模板中的屬性和方法。

靜態(tài)方法：不用傳入類空間、對象的方法， 作用是保證代碼的一致性，規(guī)范性，可以完全獨立類外的一個方法，但是為了代碼的一致性統(tǒng)一的放到某個模塊（py文件）中。

其次，從作用域的角度來分析：

（1）函數(shù)作用域：從函數(shù)調(diào)用開始至函數(shù)執(zhí)行完成，返回給調(diào)用者后，在執(zhí)行過程中開辟的空間會自動釋放，也就是說函數(shù)執(zhí)行完成后，函數(shù)體內(nèi)部通過賦值等方式修改變量的值不會保留，會隨著返回給調(diào)用者后，開辟的空間會自動釋放。

（2）方法作用域：通過實例化的對象進行方法的調(diào)用，調(diào)用后開辟的空間不會釋放，也就是說調(diào)用方法中對變量的修改值會一直保留。

最后，調(diào)用的方式不同。

（1）函數(shù)：通過“函數(shù)名（）”的方式進行調(diào)用。

（2）方法：通過“對象.方法名”的方式進行調(diào)用。

class Foo(object): ? ?def func(self): ? ? ? ?pass#實例化obj = Foo()# 執(zhí)行方式一:調(diào)用的func是方法obj.func() #func 方法# 執(zhí)行方式二：調(diào)用的func是函數(shù)Foo.func(123) # 函數(shù)

當前標題：python中函數(shù)的種類 python中函數(shù)的分類
網(wǎng)站URL：http://www.chinadenli.net/article6/dodccog.html

成都網(wǎng)站建設公司_創(chuàng)新互聯(lián)，為您提供云服務器、企業(yè)網(wǎng)站制作、面包屑導航、網(wǎng)站改版、、靜態(tài)網(wǎng)站

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)