Python--day11（函数的参数）

今日主要内容

1.  函数的参数

2.  函数的嵌套调用

1.  形参与实参

1.  参数介绍：

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

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

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

2. 实参：有实际意义的参数

在函数调用的时候，（）内传入的参数

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

　　　　有默认值的新参，在没有被实参赋值，具有的是自身的意义，但一旦被实参赋值，意义同实参

# 形参范畴def add(n1,n2):  # 在形参n1,n2在没有被实参赋值时，没有实际意义，被什么意义的实参赋值，就被赋予了什么意义    return n1 + n2

# 实参范畴print(add('a','b'))  # 实际的字符串    abprint(add(10,20))    # 实际的数字      30a = 200b = 300print(add(a,b))      # 存放实际数字的变量    500

2.  形参是对实参的值拷贝

形参与实参可以重名，但是代表的是两个不同的变量

不可变类型，形参发生重指向，实参不变

def fun(num):    print('1>>>:',num)   # 10    num = 20    print('2>>>:',num)   # 20

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

可变类型，形参发生值的内部变化，实参也变化，两个指向同一个地址

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

ls = [10]fun(ls)print('3>>>',ls)          # [10, 20]

3.  实参的分类

实参分为 1.  位置实参   2.  关键字实参

位置实参：一定按照位置，且个数要一一对应进行传参

关键字实参：指名道姓进行传参，个数一致，位置可以改变进行传参

#  实参分类def fun(a,b):    print(a,b)

# 1)拿实际值进行传参fun(10,20)    # 10 => a    20 => b

# 2)拿位置实参进行传参，形参与实参进行位置一一对应a = 100b = 200fun(a,b)      # a:100 => a     b:200 => bfun(b,a)      # b:200 => a     a:100 => b

# 3)拿关键字实参进行传参，指名道姓进行进行传参

fun(a=100, b=200)    # a:100 => a     b:200 => bfun(b=200, a=100)    # b:200 => b     a:100 => a

a = 888b = 666fun(a = a, b = b)    # a:888 => a     b:666 => b

4.  形参的分类

六大分类

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.  不管位置还是关键字形参，全部按照顺序进行传参

def f(a,b=10,*args,x=11111,y=110,**kwargs):    print(a)              # 10    print(b)              # 20    print(args)           # (10,)    print(x)              # 10    print(y)              # 110    print(kwargs)         # {'z': 111}f(10,20,10,x=10,z=111)

5.  打散机制

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

t = (1,2,3)dic = {'a':1,'b':2,'c':3}

# *单列容器：会被打散单列容器# **双列容器：会打散双列容器

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

# 字符串也可以被打散fun('abc')    # ('a','b','c')   {}print(*'abc')  #   a b c