形參與實參

# 參數介紹：

# 函數為什么要有參數：因為內部的函數體需要外部的數據

# 怎么定義函數的參數：在定義函數階段，函數名后面()中來定義函數的參數

# 怎么使用函數的參數：在函數體中用定義的參數名直接使用

# 實參：有實際意義的參數

# -- 在函數調用的時候，()中傳入的參數

# 形參：參數本身沒有意義，有實參賦予形參值后，該形參就具備了意義

# 補充：有默認值的形參，在沒有被實參賦值，具備的是自身意義，但一旦被實參賦值，意義同實參 - def add(n1, n2=2):

# -- 在定義函數的時候，()中出現的參數

# 形參范疇

def add(n1, n2): #形參n1，n2在沒有被實參賦值時，沒有實際意義，被什么意義的實參賦值，就被賦予了什么意義

return n1 + n2

# 實參范疇

print(add('a', 'b')) #實際的字符串

print(add(10, 20)) #實際的數字

a = 200b= 300

print(add(a, b)) #存放實際數字的變量

形參是對實參的值拷貝

# 形參與實參可以重名，但是代表的是兩個不同的變量

# 不可變類型，形參發生重指向，實參不變

deffn(num):print('1>>>:', num) #10

num = 20

print('2>>>:', num) #20

num= 10fn(num)print('3>>>:', num) #10

# 可變類型，形參發生值的內部變化，實參變，兩個指向的是同一個地址

deffunc(ls):print('1>>>:', ls) #[10]

ls.append(20)print('2>>>:', ls) #[10, 20]

ls= [10]

func(ls)print('3>>>:', ls) #[10, 20]

實參的分類

# 實參分為：1.位置實參 2.關鍵字實參

deffn(a, b):print(a, b)

# 1)拿實際值進行傳參

fn(10, 20) #10 => a | 20 => b

# 2)拿位置實參進行傳參：形參與實參進行位置一一對應，eg:一號為的實參一定傳給一號位的形參

a = 100b= 200fn(a, b)#a:100 => a | b:200 => b

fn(b, a) #b:200 => a | a:100 => b

# 3)拿關鍵字實參進行傳參：指名道姓進行傳參 - 傳參的過程過指名道姓形參

# 明確：形參名目前為a和b

fn(a=1000, b=2000) #a:1000 => a | b:2000 => b

fn(b=2000, a=1000) #b:2000 => b | a:1000 => a

a = 666b= 888

# 前面的是形參名，后面的是傳遞的實參名

fn(a=a, b=b) #a:666 => a | b:888 => b

# 位置實參：一定按照位置，且個數要一一對應進行傳參

# 關鍵字實參：指名道姓進行傳參，個數一致位置可以改變進行傳參

# 實參組合傳參規則：必須先傳位置實參，再傳關鍵字實參

形參的分類

# 六大分類：

# 1.無值位置形參(位置形參)：可以被位置與關鍵字實參進行傳參，必須傳值

# 2.有值位置形參(默認形參)：可以被位置與關鍵字實參進行傳參，可以不用傳參采用默認值

# 3.可變長位置形參：可以接受前兩個沒有接收完位置實參，接收的個數可以為0~n個，0個是就是空元組

# 4.無值關鍵字形參：只能由關鍵字實參進行傳參，必須傳值

# 5.有值關鍵字形參：只能由關鍵字實參進行傳參，可以不用傳參采用默認值

# 6.可變長關鍵字形參：接收4，5沒有接收完的關鍵字實參，接收的個數可以為0~n個，0個是就是空字典

# 聲明順序：

# 位置形參:a -> 默認形參:b -> 可變長位置形參:args -> 有無默認值關鍵字形參:cde -> 可變長關鍵字形參:kwargs

def fn(a, b=10, *args, c, d=20, e, **kwargs):pass

# 注意點：

# 1.可變長位置形參只能接受位置實參，要想被附上值，前面的有值位置形參的默認值沒有多大意義

# 2.args與kwargs是可變長形參的變量名，所以可以自定義，但約定俗成就用它倆

# 常出現的組合

def f1(*args, **kwargs):

pass

def f2(a, b=10, **kwargs):

pass

def f3(a, *args, **kwargs):

pass

def f4(a, *, x, **kwargs):

pass

def f5(a, *args, x, **kwargs):

pass

# 使用法則：

# 1.所有位置形參全部采用位置實參進行傳值

# 2.所有關鍵字形參全部采用關鍵字實參進行傳值

# 3.不管位置還是關鍵字形參，全部按照順序進行傳參

可變參數的整體使用

# 1、可變位置形參以元組方式接收值

# 如：接收10，20，30三個數

def fn1(*args):print(args) #(10, 20, 30)

# 第一種傳參

fn1(10, 20, 30)

# 第二種傳參

t = (10, 20, 30) #單列集合及字符串類型都可以

fn1(*t)

# 2、可變位置實參以字典方式接收值

def fn2(**kwargs):print(kwargs) #{'name': 'Owen', 'age': 18}

# 第一種傳參

fn2(name='Owen', age=18)

# 第二種傳參

d = {'name': 'Owen', 'age': 18} #單列集合及字符串類型都可以

fn2(**d)

函數對象

# 函數名就是存放了函數的內存地址，存放了內存地址的變量都是對象，即 函數名 就是 函數對象

打散機制

def fn(*args, **kwargs):print(args)print(kwargs)

t= (1, 2, 3)

dic= {'a': 100, 'b': 200, 'c': 300}

# *單列容器 會打散單列容器

# **雙列容器 會打散雙列容器

fn(1, 2, 3, a=100, b=200, c=300) #(1, 2, 3) {'a': 100, 'b': 200, 'c': 300}

fn(*t, **dic) #(1, 2, 3) {'a': 100, 'b': 200, 'c': 300}

fn(*(1, 2, 3), **{'a': 100, 'b': 200, 'c': 300}) #(1, 2, 3) {'a': 100, 'b': 200, 'c': 300}

# 字符串也可以被打散

fn(*'abc') #('a', 'b', 'c') {}

print(*'abc') #a b c

# 測試：

def xingxing_test(*args, **kwargs):print(args)print(kwargs)print('-------------------------------------------------------------------')print(*args)print(*kwargs)#print(**args) # 報錯

#print(**kwargs) # 報錯

xingxing_test(str_1, list_2, tuple_2, dic_3, set_4)

輸出：

('abcd', [3, 4, 5], (1, 2, 3), {'a': 1, 'b': {'c': 1}}, {'g', 'f', 'e', 'h'})

{}-------------------------------------------------------------------abcd [3, 4, 5] (1, 2, 3) {'a': 1, 'b': {'c': 1}} {'g', 'f', 'e', 'h'}

xingxing_test(*str_1, *list_2, *tuple_2, **dic_3)

輸出：

('a', 'b', 'c', 'd', 3, 4, 5, 1, 2, 3)

{'a': 1, 'b': {'c': 1}}-------------------------------------------------------------------a b c d3 4 5 1 2 3a b

總結

以上是生活随笔為你收集整理的python中argument函数_PythonStudy——函数的参数 Function argument的全部內容，希望文章能夠幫你解決所遇到的問題。

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