Python之函数

￡神魔★判官ぃ 2022-05-20 05:58 172阅读 0赞

定义一个事件或者功能，等到需要的时候直接去调用就好了，那么这里定义的一段代码块，就是一个函数。

**函数的定义**

def 函数名(参数列表):

函数体（代码块）

函数名的命名规则详见本博客《[Python中的命名规范][Python]》。

下面我们通过代码来来定义一个函数：

def funcMax(a, b):
        if a > b:
            return a
        return b

我们可以这样调用函数：

print(funcMax(1, 2))

运行结果：

Process finished with exit code 0

在上面的代码中，funcMax就是函数的名字，后面括号是函数的形式参数，在调用时需人为的给定。下面部分为函数体，可编写不同的代码实现不同的功能。其中return表示返回函数的值，缺省返回None，函数执行到return时，结束函数体。

**函数参数**

在上述的实例中，函数名后括号内的值为函数的形式参数，可缺省，亦可包括多值。

函数参数分为两种：

形参：在函数调用的时候给函数传递的值，叫实参。实际执行的时候给函数传递的信息，表示给函数xxx。

传参：给函数传递信息的时候将实际参数交给形式参数的过程被称为传参。

下面我们将在参数位置进行一些操作，方便大家更能认识函数参数的作用。

def yue(chat):  # chat 形参
        print("拿出⼿机")
        print("打开" + chat)
        print("找个漂亮的妹⼦")
        print("约不约")
    
    
    yue("陌陌")  # 实参
    len("字符串")  # "字符串"在这⾥就是实参
    print("麻花藤")  # "麻花藤"就是实参

运行结果：

拿出手机  
打开陌陌  
找个漂亮的妹子  
约不约  
麻花藤  
  
Process finished with exit code 0

**位置参数**

**       ** 定义多个参数时，在传递参数时应按参数位置进行，系统会默认按照位置把实参赋值到形参。

def yue(chat, address, age):  # 形参
        print("拿出⼿机")
        print("打开" + chat)
        print("找个" + address + "附近漂亮的" + str(age) + "岁妹⼦")
        print("约不约")
    
    
    yue("微信", "北京", 18)  # 实参

**    **    运行结果：

拿出手机  
打开微信  
找个北京附近漂亮的18岁妹子  
约不约  
  
Process finished with exit code 0

**        关键字参数**

位置参数好不好呢? 如果是少量的参数还算OK，没有问题。但是如果函数在定义的时候参数非常多怎么办? 程序员必须记住，我有哪些参数，而且还有记住每个参数的位置，否则函数就不能正常调用了。那则么办呢? python提出了一种叫做关键字参数，我们不需要记住每个参数的位置，只要记住每个参数的名字就可以了。

def yue(chat, address, age):
        print("拿出⼿机")
        print("打开" + chat)
        print("找个" + address + "附近漂亮的" + str(age) + "岁妹⼦")
        print("约不约")
    
    
    yue(chat="微信", age=18, address="北京")

运行结果：

拿出手机  
打开微信  
找个北京附近漂亮的18岁妹子  
约不约

Process finished with exit code 0

这样，在参数较多或者调用多次时我们就不需要反复记住繁琐的参数位置了。

**混合参数**

**       ** 可以把上面两种参数混合着使用，也就是说在调用函数的时候即可以给出位置参数，也可以指定关键字参数。

# 正确.第⼀个位置赋值给chat, 后⾯的参数开始指定关键字.
    yue("微信", age=18, address="上海")
    
    #   错误, 最开始使⽤了关键字参数, 那么后⾯的微信的位置就串了, 容易出现混乱
    yue(age="18", "微信", address="⼴州")

注意：在使用混合参数的时候，关键字参数必须在位置参数后面。否则会如下报错。

SyntaxError: positional argument follows keyword argument（位置参数跟随关键字参数）

综上：

在实参的角度来看，分为三种：

1. 位置参数

2. 关键字参数

3. 混合参数，位置参数必须在关键字参数前面

**        默认值参数**

在函数声明的时候，就可以给出函数参数的默认值。在调用的时候可以给出具体的值，也可以不给值。

使用默认值，比如，我们录入咱们班学生的基本信息，通过调查发现，我们班大部分学生都是男生，这个时候就可以给出一个sex='男'的默认值。如：

def stu_info(name, age, sex='男'):
        print("录⼊学⽣信息")
        print(name, age, sex)
        print("录⼊完毕")
    
    
    stu_info("张强强", 18)

运行结果：

录入学生信息  
张强强 18 男  
录入完毕  
  
Process finished with exit code 0

注意：必须先声明位置参数，才能声明默认值参数。

综上: 在形参的角度来看

1. 位置参数

2. 默认值参数(大多数传进来的参数都是一样的，一般用默认参数）。

**动态传参**

之前我们说过了传参，如果我们需要给一个函数传参，而参数又是不确定的，或者我给一个个函数传很多参数，我的形参就要写很多，很麻烦，怎么办呢？我们可以考虑使用动态参数。

动态参数分成两种：

动态接收位置参数：

位置参数也就是按照位置来进行传参。

def chi(quality_food, junk_food):
        print("我要吃", quality_food, junk_food)
    
    
    # "⼤⽶饭"传递给quality_food "⼩⽶饭"传递给junk_food
    chi("⼤⽶饭", "⼩⽶饭")

运行结果：

我要吃 大米饭 小米饭  
  
Process finished with exit code 0

这是传统的传参方式，是不是感觉很麻烦，下面将演示动态传参与之对比。

def chi(*food):
        print("我要吃", food)
    
    
    chi("⼤⽶饭", "⼩⽶饭")

运行结果：

我要吃 ('大米饭', '小米饭')  
  
Process finished with exit code 0

细心的同学可能已经注意到，在使用动态传参时候返回的是一个tuple数据类型。

注意：在动态传参过程中，动态参数必须在位置参数后面，否则动态参数后面的位置参数无法被赋值。下面将逐一演示

错误做法：

def chi(*food, a, b):
        print("我要吃", food, a, b)
    
    
    chi("⼤⽶饭", "⼩⽶饭", "⻩⽠", "茄⼦")

运行结果：

Traceback (most recent call last):  
  File "D:/AiBentao/Python/DayTen/Basic.py", line 59, in <module>  
    chi("大米饭", "小米饭", "西瓜", "茄子")  
TypeError: chi() missing 2 required keyword-only arguments: 'a' and 'b'  
  
Process finished with exit code 1

正确做法：

def chi(a, b, *food):
        print("我要吃", a, b, food)
    
    
    chi("⼤⽶饭", "⼩⽶饭", "⻩⽠", "茄⼦")

运行结果：

我要吃 大米饭 小米饭 ('黄瓜', '茄子')

Process finished with exit code 0

下面我们来看看默认值参数加入会有啥反应：

def chi(a, b, c='馒头', *food):
        print(a, b, c, food)
    
    
    # ⾹蕉 菠萝 馒头 (). 默认值⽣效
    chi("⾹蕉", "菠萝")
    # ⾹蕉 菠萝 葫芦娃 () 默认值不⽣效
    chi("⾹蕉", "菠萝", "葫芦娃")
    # ⾹蕉 菠萝 葫芦娃 ('⼝罩',) 默认值不⽣效
    chi("⾹蕉", "菠萝", "葫芦娃", "⼝罩")

运行结果：

香蕉 菠萝 馒头 ()  
香蕉 菠萝 葫芦娃 ()  
香蕉 菠萝 葫芦娃 ('口罩',)  
  
Process finished with exit code 0

默认参数放在动态参数之前，参数个数没有达到默认参数时，默认参数返回默认值，动态参数返回空元组。

def chi(a, b, *food, c='馒头'):
        print(a, b, c, food)
    
    
    # ⾹蕉 菠萝 馒头 (). 默认值⽣效
    chi("⾹蕉", "菠萝")
    # ⾹蕉 菠萝 葫芦娃 () 默认值不⽣效
    chi("⾹蕉", "菠萝", "葫芦娃")
    # ⾹蕉 菠萝 葫芦娃 ('⼝罩',) 默认值不⽣效
    chi("⾹蕉", "菠萝", "葫芦娃", "⼝罩")

运行结果：

香蕉 菠萝 馒头 ()  
香蕉 菠萝 馒头 ('葫芦娃',)  
香蕉 菠萝 馒头 ('葫芦娃', '口罩')  
  
Process finished with exit code 0

我们不难发现，当动态参数放在默认参数前面时，除了位置参数a,b外的数全被动态参数给“吃了”，导致默认参数无法被赋值，在调用时将永远返回默认值。

**动态接收关键字参数**

在python中可以动态的位置参数，但是\*这种情况只能接收位置参数无法接收关键字参数，在python中使用\*\*来接收动态关键字参数。

def func(**kwargs):
        print(kwargs)
    
    
    func(a=1, b=2, c=3)
    func(a=1, b=2)

运行结果：

\{'c': 3, 'a': 1, 'b': 2\}  
\{'a': 1, 'b': 2\}  
  
Process finished with exit code 0

这时我们发现接收得到的是一个dict。

顺序的问题，在函数调用的时候，如果先给出关键字参数，则整个参数列表会报错。

def func(**kwargs, a, b, c):
        print(kwargs)
    
    
    func(a=1, b=2, c=3)
    func(a=1, b=2, c=3, d=4)

运行结果：

File "D:/AiBentao/Python/DayTen/Basic.py", line 55  
    def func(\*\*kwargs, a, b, c):  
                     ^  
SyntaxError: invalid syntax  
  
Process finished with exit code 1

结论：位置参数 > \*args > 默认值参数 > \*\*kwargs

此外，可用以下方式接收全部参数：

def func(*args, **kwargs):
        print(args, kwargs)
    
    
    func("麻花藤", "哈哈", wtf="胡辣汤")

运行结果：

('麻花藤', '哈哈') \{'wtf': '胡辣汤'\}  
  
Process finished with exit code 0

**动态参数的另一种传参方式**

lst = [1, 4, 7]
    fun(lst[0], lst[1], lst[2])
    fun(*lst)  # 可以使⽤*把⼀个列表按顺序打散
    s = "⾂妾做不到"
    fun(*s)  # 字符串也可以打散, (可迭代对象)

运行结果：

(1, 4, 7)  
(1, 4, 7)  
('臣', '妾', '做', '不', '到')

Process finished with exit code 0

在实参位置上给一个序列，列表，可迭代对象前面加个\*表示把这个序列按顺序打散。

在形参的位置上的\* 表示把接收到的参数组合成一个元组。

如果是一个字典，那么也可以打散，不过需要用两个\*。

def fun(**kwargs):
        print(kwargs)
    
    
    dic = {
      'a': 1, 'b': 2}
    fun(**dic)

运行结果：

\{'a': 1, 'b': 2\}  
  
Process finished with exit code 0

**函数的注释  **

def chi(food, drink):
        """ 函数的作用 :param food: 参数food的意思 :param drink: 参数drink的意思 :return: 返回值是什么 """ print(food, drink)
        return "very good"

**命名空间**

在python解释器开始执行之后，就会在内存中开辟一个空间，每当遇到一个变量的时候，就把变量名和值之间的关系记录下来，但是当遇到函数定义的时候，解释器只是把函数名读入内存，表示这个函数存在了，至于函数内部的变量和逻辑，解释器是不关心的。也就是说一开始的时候函数只是加载进来，仅此而已，只有当函数被调用和访问的时候，解释器才会根据函数内部声明的变量来进行开辟变量的内部空间。随着函数执行完毕，这些函数内部变量占用的空间也会随着函数执行完毕而被清空。

def fun():
        a = 10
        print(a)
    
    
    fun()
    print(a)  # a不存在了已经..

我们给存放名字和值的关系的空间起一个名字叫：命名空间。我们的变量在存储的时候就是存储在这片空间中的。

命名空间分类：

1. 全局命名空间--> 我们直接在py文件中, 函数外声明的变量都属于全局命名空间

2. 局部命名空间--> 在函数中声明的变量会放在局部命名空间。

3. 内置命名空间--> 存放python解释器为我们提供的名字, list, tuple, str, int这些都是内置命名空间。

加载顺序：

1. 内置命名空间

2. 全局命名空间

3. 局部命名空间（函数被执行的时候）

取值顺序：

1. 局部命名空间

2. 全局命名空间

3. 内置命名空间

a = 10
    
    
    def func():
        a = 20
        print(a)
    
    
    func()  # 20

运行结果：20

作用域：作用域就是作用范围，按照生效范围来看分为全局作用域和局部作用域。

全局作用域：包含内置命名空间和全局命名空间，在整个文件的任何位置都可以使用(遵循从上到下逐一执行)。

局部作用域: 在函数内部可以使用。

作用域命名空间：

1. 全局作用域：全局命名空间 + 内置命名空间。

2. 局部作用域：局部命名空间。

我们可以通过globals()函数来查看全局作用域中的内容，也可以通过locals()来查看局部用域中的变量和函数信息。

a = 10
    
    
    def func():
        a = 40
        b = 20
    
        def abc():
            print("哈哈")
            print(a, b)  # 这里使⽤的是局部作⽤域
            print(globals())  # 打印全局作⽤域中的内容
            print(locals())  # 打印局部作⽤域中的内容
    
    
    func()

**        函数的嵌套**

也就是函数内调用函数（Python解释器中最多只能嵌套数为998）。

**        关键字global和nonlocal**

首先我们写这样一个代码，首先在全局声明一个变量，然后再局部调用这个变量，并改变这个变量的值。

a = 100
    
    
    def func():
        global a  # 加了个global表示不再局部创建这个变量了. ⽽是直接使⽤全局的a
        a = 28
        print(a)
    
    
    func()
    print(a

运行结果：

28  
28

Process finished with exit code 0

global表示：不再使用局部作用域中的内容了，而改用全局作用域中的变量。

def func1():
        a = 20
    
        def func2():
    
            nonlocal a
        a = 30
        print(a)
        func2()
        print(a)
    
    
    func1()

运行结果：

30  
30  
  
Process finished with exit code 0

nonlocal表示在局部作用域中，调用父级命名空间中的变量。

请看下面的习题：

a = 1
    
    
    def fun_1():
        a = 2
    
        def fun_2():
    
            nonlocal a
        a = 3
    
        def fun_3():
    
            a = 4
        print(a)
        print(a)
        fun_3()
        print(a)
        print(a)
        fun_2()
        print(a)
    
    
    print(a)
    fun_1()
    print(a)

运行结果：

1  
3  
3  
3  
3  
3  
1  
  
Process finished with exit code 0

如果你能分析上面的程序，那作用域这一关你是问题不大了。

[Python]: https://blog.csdn.net/qq_33567641/article/details/80889248