python第十一天

今日内容

1. 函数的参数

2. 函数对象 -- 函数名  * * * *重点！

3. 函数 的嵌套调用

1. 形参与实参：

函数介绍：

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

1.2  怎么定义函数的参数，在定义函数阶段，函数名后面（）中来定义函数的参数

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

1.4 实参:  有实际意义的参数

　　　　　　　　-----在函数调用的时候，从 （） 中传入的参数

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

　　　　　　　　-----补充：有默认值的形参，在没有被实参赋值，具备的就是自身的意义，返回的是默认值，但是一旦被实参赋值，它的意义就等同与实参

1.6 形参范围：def add (n1, n2):# 形参n1 ，n2 在没有被实参赋值时，没有实际意义，被实参所赋值，就被赋予了实参的意义

　　　　　　　　return n1 + n2

1.7  实参范围：

　　　　　　print(add('a','b'))  # 实际的字符串
　　　　　　print(add(10,20))    # 实际的数字
　　　　　　a = 100
　　　　　　b = 200
　　　　　　print(add(a,b))      # 存放实际数字的变量

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

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

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

def fn(num):
    print('数字1>>>:',num)  # 此处为 10
    num = 20
    print('数字2>>>:',num)  # 此处为20
num = 10
fn(num)
print('数字3>>>:',num)      #  此处为10

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

def func(ls):
    print('信息：',ls)   # 此处为 [10]
    ls.append(20)
    print('信息：',ls)   # 此处为[10,20] 因为添加了一个元素到列表
ls = [10]
func(ls)
print('信息3：',ls)      # [10,20] 此处ls就成了[10，20]

3. 实参的分类

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

def fn(a,b):
    print(a,b)
# 拿实际值进行传参
fn(10,20)  # 10 ==> a  |  20 ===> b

拿位置 实参 进行传参：需要知道的是，形参 与 实参 的位置一一对应。比如第一号位的 实参，一定是传给一号位的 形参 的

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

拿关键字实参进行传参：指名道姓进行传参 -------实参 指名道姓 形参

例如：明确的：形参名目前位 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 = 666
b = 888
# 前面是形参名，后面是传递的实参名
fn(a=a,b=b) # a:666 ==> a |  b:888==> b

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

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

　　　3. 实参组合传参规则：必须先传位置实参，再传关键字实参

4 .形参的分类

六大分类：

4.1 无值位置形参 (位置形参) ：可以被位置与关键字来进行传参，它必须传值，不传值会报错

4. 2 有值位置形参 (默认形参) ：可以被位置与关键字实参来进行传参，可以不用传参，来采用它的默认值

4. 3  可变长位置形参：可以接收前两个没有接收完的位置参数，可以接受的个数为 0 ~ n 个，如果不传入参数会返回一个空元祖 （它会用一个元祖来包裹返回的值）

4. 4 无值关键字形参：只能由关键字实参来进行传参，必须传值，不传值会报错

4 .5 有值关键字形参：只能由关键字实参来进行传参，也可以不传参，来采用它的默认值

4. 6  可变长关键字形参：接收 第 4 和第 5 点没有接收完的关键字实参，接受的个数可以为 0 ~ n 个，如果不传入，返回的是一个空字典 ( 它会用一个元祖来包裹返回的值)

声明顺序：

4. 7 位置形参： a --> 默认形参：b ---> 可变长位置形参：args --->有无默认值关键字形参：c,d,e --->可边长关键字形参：kwargs

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

需要注意的地方：

4. 8 可变长位置形参只能接收位置实参，想要被附上值，前面的有值位置形参的默认值就变的没有意义了

4. 9 args与kwargs是可变长形参的变量名，所以可以自定义，但是一般都会约定使用这两个来表示

4. 10 常出现的组合：

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

4. 11 使用法则：

　　1. 所有位置形参全部采用位置实参进行传值

　　2. 所有关键字形参全部采用关键字实参进行传值

　　3. 不管位置还是关键字形参，全部按照顺序进行传参

打散机制

```python
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