形参与实参

# 参数介绍：

# 函数为什么要有参数：因为内部的函数体需要外部的数据

# 怎么定义函数的参数：在定义函数阶段，函数名后面()中来定义函数的参数

# 怎么使用函数的参数：在函数体中用定义的参数名直接使用

# 实参：有实际意义的参数

# -- 在函数调用的时候，()中传入的参数

# 形参：参数本身没有意义，有实参赋予形参值后，该形参就具备了意义

# 补充：有默认值的形参，在没有被实参赋值，具备的是自身意义，但一旦被实参赋值，意义同实参 - 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