parameter 是函數定義的參數形式
創(chuàng)新互聯公司是一家專注于成都做網站、成都網站設計與策劃設計,果洛州網站建設哪家好?創(chuàng)新互聯公司做網站,專注于網站建設十載,網設計領域的專業(yè)建站公司;建站業(yè)務涵蓋:果洛州等地區(qū)。果洛州做網站價格咨詢:18982081108
argument 是函數調用時傳入的參數實體。
對于函數調用的傳參模式，一般有兩種：
此外，
也是關鍵字傳參
python的函數參數定義一般來說有五種: 位置和關鍵字參數混合 ， 僅位置參數 ， 僅關鍵字參數 ， 可變位置參數 ， 可變關鍵字參數 。其中僅位置參數的方式僅僅是一個概念，python語法中暫時沒有這樣的設計。
通常我們見到的函數是位置和關鍵字混合的方式。
既可以用關鍵字又可以用位置調用
或
這種方式的定義只能使用關鍵字傳參的模式
f(*some_list) 與 f(arg1, arg2, ...) （其中some_list = [arg1, arg2, ...]）是等價的
網絡模塊request的request方法的設計
多數的可選參數被設計成可變關鍵字參數
有多種方法能夠為函數定義輸出：
非?；逎?/p>
如果使用可變對象作為函數的默認參數，會導致默認參數在所有的函數調用中被共享。
例子1：
addItem方法的data設計了一個默認參數，使用不當會造成默認參數被共享。
python里面，函數的默認參數被存在__default__屬性中，這是一個元組類型
例子2：
在例子1中，默認參數是一個列表，它是mutable的數據類型，當它寫進 __defauts__屬性中時，函數addItem的操作并不會改變它的id，相當于 __defauts__只是保存了data的引用，對于它的內存數據并不關心，每次調用addItem，都可以修改 addItem.__defauts__中的數據，它是一個共享數據。
如果默認參數是一個imutable類型，情況將會不一樣,你無法改變默認參數第一次存入的值。
例子1中，連續(xù)調用addItem('world') 的結果會是
而不是期望的
Python函數的參數類型主要包括必選參數、可選參數、可變參數、位置參數和關鍵字參數，本文介紹一下他們的定義以及可變數據類型參數傳遞需要注意的地方。
必選參數（Required arguments）是必須輸入的參數，比如下面的代碼，必須輸入2個參數，否則就會報錯：
其實上面例子中的參數 num1和num2也屬于關鍵字參數，比如可以通過如下方式調用：
執(zhí)行結果：
可選參數（Optional arguments）可以不用傳入函數，有一個默認值，如果沒有傳入會使用默認值，不會報錯。
位置參數（positional arguments）根據其在函數定義中的位置調用，下面是pow()函數的幫助信息:
x，y，z三個參數的的順序是固定的，并且不能使用關鍵字：
輸出：
在上面的pow()函數幫助信息中可以看到位置參數后面加了一個反斜杠 / ，這是python內置函數的語法定義，Python開發(fā)人員不能在python3.8版本之前的代碼中使用此語法。但python3.0到3.7版本可以使用如下方式定義位置參數：
星號前面的參數為位置參數或者關鍵字參數，星號后面是強制關鍵字參數，具體介紹見強制關鍵字參數。
python3.8版本引入了強制位置參數（Positional-Only Parameters），也就是我們可以使用反斜杠 / 語法來定義位置參數了，可以寫成如下形式：
來看下面的例子：
python3.8運行：
不能使用關鍵字參數形式賦值了。
可變參數 (varargs argument) 就是傳入的參數個數是可變的，可以是0-n個，使用星號（ * ）將輸入參數自動組裝為一個元組（tuple）：
執(zhí)行結果：
關鍵字參數（keyword argument）允許將任意個含參數名的參數導入到python函數中，使用雙星號（ ** ），在函數內部自動組裝為一個字典。
執(zhí)行結果：
上面介紹的參數可以混合使用：
結果：
注意：由于傳入的參數個數不定，所以當與普通參數一同使用時，必須把帶星號的參數放在最后。
強制關鍵字參數（Keyword-Only Arguments）是python3引入的特性，可參考：。 使用一個星號隔開：
在位置參數一節(jié)介紹過星號前面的參數可以是位置參數和關鍵字參數。星號后面的參數都是強制關鍵字參數，必須以指定參數名的方式傳參，如果強制關鍵字參數沒有設置默認參數，調用函數時必須傳參。
執(zhí)行結果：
也可以在可變參數后面命名關鍵字參數，這樣就不需要星號分隔符了：
執(zhí)行結果：
在Python對象及內存管理機制中介紹了python中的參數傳遞屬于對象的 引用傳遞 （pass by object reference），在編寫函數的時候需要特別注意。
先來看個例子：
執(zhí)行結果：
l1 和 l2指向相同的地址，由于列表可變，l1改變時，l2也跟著變了。
接著看下面的例子：
結果：
l1沒有變化！為什么不是[1, 2, 3, 4]呢？
l = l + [4]表示創(chuàng)建一個“末尾加入元素 4“的新列表，并讓 l 指向這個新的對象，l1沒有進行任何操作，因此 l1 的值不變。如果要改變l1的值，需要加一個返回值：
結果：
下面的代碼執(zhí)行結果又是什么呢？
執(zhí)行結果：
和第一個例子一樣，l1 和 l2指向相同的地址，所以會一起改變。這個問題怎么解決呢？
可以使用下面的方式：
也可以使用淺拷貝或者深度拷貝，具體使用方法可參考Python對象及內存管理機制。這個問題在Python編程時需要特別注意。
本文主要介紹了python函數的幾種參數類型：必選參數、可選參數、可變參數、位置參數、強制位置參數、關鍵字參數、強制關鍵字參數，注意他們不是完全獨立的，比如必選參數、可選參數也可以是關鍵字參數，位置參數可以是必選參數或者可選參數。
另外，python中的參數傳遞屬于對象的 引用傳遞 ，在對可變數據類型進行參數傳遞時需要特別注意，如有必要，使用python的拷貝方法。
參考文檔：
--THE END--
import math
a = abs
print(a(-1))
n1 = 255
print(str(hex(n1)))
def my_abs(x):
# 增加了參數的檢查
if not isinstance(x, (int, float)):
raise TypeError('bad operand type')
if x = 0:
return x
else:
return -x
print(my_abs(-3))
def nop():
pass
if n1 = 255:
pass
def move(x, y, step, angle=0):
nx = x + step * math.cos(angle)
ny = y - step * math.sin(angle)
return nx, ny
x, y = move(100, 100, 60, math.pi / 6)
print(x, y)
tup = move(100, 100, 60, math.pi / 6)
print(tup)
print(isinstance(tup, tuple))
def quadratic(a, b, c):
k = b * b - 4 * a * c
# print(k)
# print(math.sqrt(k))
if k 0:
print('This is no result!')
return None
elif k == 0:
x1 = -(b / 2 * a)
x2 = x1
return x1, x2
else:
x1 = (-b + math.sqrt(k)) / (2 * a)
x2 = (-b - math.sqrt(k)) / (2 * a)
return x1, x2
print(quadratic(2, 3, 1))
def power(x, n=2):
s = 1
while n 0:
n = n - 1
s = s * x
return s
print(power(2))
print(power(2, 3))
def enroll(name, gender, age=8, city='BeiJing'):
print('name:', name)
print('gender:', gender)
print('age:', age)
print('city:', city)
enroll('elder', 'F')
enroll('android', 'B', 9)
enroll('pythone', '6', city='AnShan')
def add_end(L=[]):
L.append('end')
return L
print(add_end())
print(add_end())
print(add_end())
def add_end_none(L=None):
if L is None:
L = []
L.append('END')
return L
print(add_end_none())
print(add_end_none())
print(add_end_none())
def calc(*nums):
sum = 0
for n in nums:
sum = sum + n * n
return sum
print(calc(1, 2, 3))
print(calc())
l = [1, 2, 3, 4]
print(calc(*l))
def foo(x, y):
print('x is %s' % x)
print('y is %s' % y)
foo(1, 2)
foo(y=1, x=2)
def person(name, age, **kv):
print('name:', name, 'age:', age, 'other:', kv)
person('Elder', '8')
person('Android', '9', city='BeiJing', Edu='人民大學')
extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, **extra)
def person2(name, age, *, city, job):
print(name, age, city, job)
person2('Pthon', 8, city='BeiJing', job='Android Engineer')
def person3(name, age, *other, city='BeiJing', job='Android Engineer'):
print(name, age, other, city, job)
person3('Php', 18, 'test', 1, 2, 3)
person3('Php2', 28, 'test', 1, 2, 3, city='ShangHai', job='Pyhton Engineer')
def test2(a, b, c=0, *args, key=None, **kw):
print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'key=', key, 'kw =', kw)
test2(1, 2, 3, 'a', 'b', 'c', key='key', other='extra')
args = (1, 2, 3, 4)
kw = {'d': 99, 'x': '#'}
test2(*args, **kw)
Python 函數定義以及參數傳遞
1.函數定義
#形如def func(args...):
doSomething123
以關鍵字def 開頭，后面是函數名和參數下面是函數處理過程。
舉例：
def add( a, b ):
return a+b12
參數可以設定默認值，如：
def add( a, b=10 ): #注意：默認值參數只會運算一次
return a+b12
默認值參數只會運算一次是什么意思？
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
這下明白為什么默認參數只計算一次了吧，函數參數不傳遞時默認值總是指向固定的內存空間，就是第一次計算的空間。
2.參數傳遞
def func(a, b):
print('a=%d, b=%d' % (a,b) )12
在使用函數時可以如下方式,結果都是相同的
func(10,20) #不使用參數名，需要按參數順序傳遞func(a=10,b=20) #使用參數名可以不按順序傳遞func(b=20,a=10)#結果：a=10, b=20a=10, b=20a=10, b=201234567
如果函數定義形式如下方式：
def func(*args): #這種定義會把傳遞的參數包成元組
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) #在調用函數使用`*`則會把元組解包成單個變量按順序傳入函數#結果：a=10, b=20123456
總結：*號在定義函數參數時，傳入函數的參數會轉換成元組，如果 *號在調用時則會把元組解包成單個元素。
另一種定義：
def func(**kw):#使用**定義參數會把傳入參數包裝成字典dict
print(kw, type(kw) )
func(a=10,b=20)#這種函數在使用時必須指定參數值，使用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) #在調用時使用**會把字典解包成變量傳入函數。12345
def func(*args, **kw):#這種形式的定義代表可以接受任意類型的參數
print(args,kw )12
總結：**號在定義函數參數時，傳入函數的參數會轉換成字典，如果 **號在調用時則會把字典解包成單個元素。
lambda表達式
lambda表達式就是一種簡單的函數
形如 f = lambda 參數1，參數2： 返回的計算值
例如：
add = lambda x,y: x+y
print(add(1,2))'''
結果：3
'''12345
python 的函數參數類型分為4種：
1.位置參數：調用函數時根據函數定義的參數位置來傳遞參數，位置參數也可以叫做必要參數，函數調用時必須要傳的參數。
當參數滿足函數必要參數傳參的條件，函數能夠正常執(zhí)行：
add(1,2) #兩個參數的順序必須一一對應，且少一個參數都不可以
當我們運行上面的程序,輸出:
當函數需要兩個必要參數，但是調用函數只給了一個參數時，程序會拋出異常
add(1)
當我們運行上面的程序,輸出：
當函數需要兩個必要參數，但是調用函數只給了三個參數時，程序會拋出異常
add(1,2,3)
當我們運行上面的程序,輸出
2.關鍵字參數：用于函數調用，通過“鍵-值”形式加以指定?？梢宰尯瘮蹈忧逦?、容易使用，同時也清除了參數的順序需求。
add(1,2) # 這種方式傳參，必須按順序傳參：x對應1，y對應:2
add(y=2,x=1) #以關健字方式傳入參數（可以不按順序）
正確的調用方式
add(x=1, y=2)
add(y=2, x=1)
add(1, y=2)
以上調用方式都是允許的，能夠正常執(zhí)行
錯誤的調用方式
add(x=1, 2)
add(y=2, 1)
以上調用都會拋出SyntaxError 異常
上面例子可以看出：有位置參數時，位置參數必須在關鍵字參數的前面，但關鍵字參數之間不存在先后順序的
3.默認參數：用于定義函數，為參數提供默認值，調用函數時可傳可不傳該默認參數的值，所有位置參數必須出現在默認參數前，包括函數定義和調用，有多個默認參數時，調用的時候，既可以按順序提供默認參數，也可以不按順序提供部分默認參數。當不按順序提供部分默認參數時，需要把參數名寫上
默認參數的函數定義
上面示例第一個是正確的定義位置參數的方式，第二個是錯誤的，因為位置參數在前，默認參數在后
def add1(x=1,y) 的定義會拋出如下異常
默認參數的函數調用
注意：定義默認參數默認參數最好不要定義為可變對象，容易掉坑
不可變對象：該對象所指向的內存中的值不能被改變，int,string,float,tuple
可變對象，該對象所指向的內存中的值可以被改變，dict,list
這里只要理解一下這個概念就行或者自行百度，后續(xù)會寫相關的專題文章講解
舉一個簡單示例
4.可變參數區(qū)別:定義函數時，有時候我們不確定調用的時候會多少個參數,j就可以使用可變參數
可變參數主要有兩類：
*args: (positional argument) 允許任意數量的可選位置參數(參數),將被分配給一個元組, 參數名前帶*，args只是約定俗成的變量名，可以替換其他名稱
**kwargs：(keyword argument) 允許任意數量的可選關鍵字參數，,將被分配給一個字典，參數名前帶**，kwargs只是約定俗成的變量名，可以替換其他名稱
*args 的用法
args 是用來傳遞一個非鍵值對的可變數量的參數列表給函數
語法是使用 符號的數量可變的參數; 按照慣例,通常是使用arg這個單詞，args相當于一個變量名，可以自己定義的
在上面的程序中,我們使用* args作為一個可變長度參數列表傳遞給add()函數。 在函數中,我們有一個循環(huán)實現傳遞的參數計算和輸出結果。
還可以直接傳遞列表或者數組的方式傳遞參數,以數組或者列表方式傳遞參數名前面加（*） 號
理解* * kwargs
**kwargs 允許你將不定長度的鍵值對, 作為參數傳遞給函數，這些關鍵字參數在函數內部自動組裝為一個dict
下篇詳細講解 *args, **kwargs 的參數傳遞和使用敬請關注
重慶分公司
重慶分公司
