day11(函数参数,函数对象,打散机制

2023-01-31 00:01:27 函数 对象 打散

一,复习

# 什么是函数:具体特定功能的代码块 - 特定功能代码块作为一个整体,并给该整体命名,就是函数


# 函数的优点:
# 1.减少代码的冗余
# 2.结构清晰,可读性强
# 3.具有复用性,开发效率高,维护成本低


# 如何定义一个函数:用def关键词来声明函数
'''
def fn(参数列表):
    函数体
    return 函数的返回值
'''
#    -- 定义函数时,函数体不会被执行  |  函数必须先定义后使用


# 函数的四部分:
# 函数名:存放着函数的地址,是调用函数的依据
# 函数体:解决问题的代码块
# 参数列表:外界为内部提供数据的途径 - 内部需要外部的数据,就需要定义参数列表
# 返回值:将内部的结果返回给外部


# 函数的使用
# 1.通过函数名找到函数的地址
# 2.函数名() 来调用执行函数
# 3.得到函数执行的结果 - 返回值

def add(n1, n2): return n1 + n2 add(10, 20)    # 只执行的函数体 res = add(10, 20) # 执行的函数体,并拿到函数的执行结果 print(add(10, 20) + 100) # 执行的函数体,并拿到函数的执行结果,再使用 # 函数的分类 # 有无函数体:空函数 - pass填充 | 非空函数 - 有函数体 # 有无参数: #无参函数 - 内部不需要外部数据 #有参函数 - 内部需要外部数据 # 有无返回值: #不主动明确返回值的函数 - 系统主动在函数体末尾添加return #主动明确返回值的函数 - 按需求明确return # 函数的返回值 # 没有return关键字的函数:不关系函数的返回值,但函数的返回值为None # 有空return:不关系函数的返回值,但在特定条件下要主动结束函数,空return,函数的返回值为None # return一个值:外界就可以接收到返回的一个值 # return多个值:外界用一个值接收,接收到的是元组 | 外界用多个值接收,接收的个数与返回的个数一定要统一(本质采用解压赋值) # return的作用:1.结束函数 2.携带内部参数给外部

 

二,今日内容

# 函数的参数: ****
# 函数对象 - 函数名:*****
# 函数的嵌套调用:***

 

三,形参与实参

# 参数介绍:
# 函数为什么要有参数:因为内部的函数体需要外部的数据
# 怎么定义函数的参数:在定义函数阶段,函数名后面()中来定义函数的参数
# 怎么使用函数的参数:在函数体中用定义的参数名直接使用


# 实参:有实际意义的参数
#       -- 在函数调用的时候,()中传入的参数
# 形参:参数本身没有意义,有实参赋予形参值后,该形参就具备了意义
#       补充:有默认值的形参,在没有被实参赋值,具备的是自身意义,但一旦被实参赋值,意义同实参  -  def add(n1, n2=2):
#       -- 在定义函数的时候,()中出现的参数

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

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

 

四,形参是对实参的值拷贝

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

# 不可变类型,形参发生重指向,实参不变
def fn(num): print('1>>>:', num) # 10 num = 20 print('2>>>:', num) # 20 num = 10 fn(num) print('3>>>:', num) # 10 # 可变类型,形参发生值的内部变化,实参变,两个指向的是同一个地址
def func(ls): print('1>>>:', ls) # [10] ls.append(20) print('2>>>:', ls) # [10, 20] ls = [10] func(ls) print('3>>>:', ls) # [10, 20]

五,实参的分类

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

def fn(a, b):
    print(a, b)

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


# 2)拿位置实参进行传参:形参与实参进行位置一一对应,eg:1号位的实参一定传给1号位的形参
a = 100
b = 200
fn(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 = 666 b = 888
# 前面的是形参名,后面的是传递的实参名 fn(a=a, b=b) # a:666 => a | b:888 => b # 位置实参:一定按照位置,且个数要一一对应进行传参 # 关键字实参:指名道姓进行传参,个数一致位置可以改变进行传参 # 实参组合传参规则:必须先传位置实参,再传关键字实参

 

六, 形参的分类

# 六大分类:
# 1.无值位置形参(位置形参):可以被位置与关键字实参进行传参,必须传值

# 2.有值位置形参(默认形参):可以被位置与关键字实参进行传参,可以不用传参采用默认值

# 3.可变长位置形参(*args):可以接受前两个没有接收完位置实参,接收的个数可以为0~n个,0个是就是空元组

# 4.无值关键字形参(c):只能由关键字实参进行传参,必须传值

# 5.有值关键字形参(d = 10):只能由关键字实参进行传参,可以不用传参采用默认值

# 6.可变长关键字形参(**kwargs):接收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 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 a():
    b()
    
def b():
    pass

a()        # a的调用必须在b的声明之后,原因a中要使用b


# 注意:在提前声明的函数中可以嵌套调用之后声明的函数,
# 但是本函数的调用必须在嵌套被调用的函数声明之后


# 应用场景
# 求两个数的大者
    def max_two(a, b):
        if a > b:
            return a
        return b
    print(max_two(100, 20))

# 求三个数的大者
    # def max_three(a, b, c):
    # #     if b < a > c:
    # #         return a
    # #     if a < b > c:
    # #         return b
    # #     if a < c > b:
    # #         return c
    def max_three(a, b, c):
        max_num = max_two(a, b)
        return max_two(max_num, c)
    # print(max_three(20, 10, 5))

    # 求四个数的大者
    def max_four(a, b, c, d):
        max_num = max_three(a, b, c)
        return max_two(max_num, d)

 

相关文章