定义形式

函数是将一段具有独立功能的代码块整合到一个整体并命名，在需要的位置调用即可。
函数在开发过程中，可以更高效的实现代码重用。

  1. # 定义形式
  2. def 函数名(形参):
  3.     return
  5. # 调用方法
  6. 函数名(实参)

return的作用

  • 函数返回值；

  • 退出当前函数。

    return返回多个值

    1. def return_num()
    2.   return 1,2
    3. result = return_num()
    4. print(result)    # (1, 2)

  • rerturn a, b返回多个数据的时候，默认是元组类型；

  • return后面可以连接列表、元组或字典，以返回多个值。

    函数说明文档

    ```python

    定义形式

    def 函数名(形参): “”” 说明文档 “”” 代码 ……

调用方法

help(函数名)

  1. <a name="mbb3u"></a>
  2. # 在函数体内修改全局变量
  3. ```python
  4. a = 100  # 声明全局变量
  5. print(a)  # 100
  8. def testA():
  9.     global a  # 声明a是全局变量
  10.     a = 299  # 修改全局变量
  11.     print(a)  # 299
  14. def testB():
  15.     print(a)
  18. def testC():
  19.     a = 200  # 局部变量
  20.     print(a)
  23. testB()  # 100
  24. testC()  # 200
  25. testA()  # 299
  26. print(a)  # 299

函数的参数

位置参数

调用函数时，根据函数定义的参数位置来传递参数。

  • 传递和定义参数的顺序即个数必须一致。 ```python def user_info(name, age, gender) print(f”您的名字是{name}，年龄是{age}，性别是{gender}”)

user_info(“TOM”, 20, “男”)

  1. <a name="d4fb7"></a>
  2. ## 关键字参数
  3. 函数调用时，通过"`**键=值**`"形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。
  5. - 函数调用时，**如果有位置参数，位置参数必须在关键字参数的前面**，但**关键字参数之间不存在先后顺序**。
  6. ```python
  7. def    user_info(name, age, gender)
  8.     print(f"您的名字是{name}，年龄是{age}，性别是{gender}")
  10. user_info("TOM", age=20, gender="男")
  11. user_info("小明", gender="男", age=21)

缺省参数

缺省参数也叫默认参数，用于定义函数，为参数提供默认值，调用函数时可不传该默认参数的值。

  • 所有位置参数必须出现在默认参数前。 ```python def user_info(name, age, gender=”男”): print(f”名字是{name}，年龄是{age}，性别是{gender}”)

user_info(“Tom”, 20) # user_info(“Tom”, 20) user_info(“Rose”, 22, “女”) # 名字是Rose，年龄是22，性别是女

  1. <a name="V5vBA"></a>
  2. ## 不定长参数（可变参数）
  3. 不定长参数也叫**可变参数**。**用于不确定调用的时有多少个参数的场景**。<br />此时，可以用**包裹(**`**packing**`**)位置参数**，或者**包裹关键字参数**来进行参数传递。
  4. <a name="D4mLj"></a>
  5. ### 包裹位置参数
  6. **传进的所有参数都会被**`**args**`**变量收集，它会根据传进参数的位置合并成一个元组**。
  8. - **返回的是元组类型**。
  9. ```python
  10. def user_info(*args):
  11.     print(args)
  14. user_info()  # ()空元组
  15. user_info("Tom")  # ('Tom',)
  16. user_info("Rose", 18)  # ('Rose', 18)

包裹关键字参数

无论是包裹位置传递还是包裹关键字传递，都是一个组包的过程。

  • 返回的是字典类型。 ```python def user_info(**kwargs): print(kwargs)

user_info() # {} user_info(name=”Tom”, age=19, id=110) # {‘name’: ‘Tom’, ‘age’: 19, ‘id’: 110}

  1. <a name="sqtRw"></a>
  2. # 拆包和交换变量的值
  3. <a name="bYZjU"></a>
  4. ## 拆包
  5. <a name="lz1Uz"></a>
  6. ### 元组拆包
  7. ```python
  8. def return_num():
  9.     return 1, 2
  12. num1, num2 = return_num()    # 元组拆包
  13. print(num1)  # 1
  14. print(num2)  # 2

字典拆包

对字典进行拆包，取出来的是字典的**key**值，再通过key查找对应的**value**。

  1. dict1 = {"name": "Tom", "age": 20}
  2. a, b = dict1    # 取出key值
  4. print(a)  # name
  5. print(b)  # age
  7. print(dict1[a])  # Tom
  8. print(dict1[b])  # 20

交换变量的值

方法一（借助临时变量）

  1. a = 1
  2. b = 2
  3. print(f"a={a}")  # a=1
  4. print(f"a={b}")  # b=2
  5. c = a
  6. a = b
  7. b = c
  8. print(f"a={a}")  # a=2
  9. print(f"a={b}")  # b=1

方法二（简化，推荐使用）

  1. a, b = 1, 2
  2. print(f"a={a}，b={b}")  # a=1，b=2
  3. a, b = b, a
  4. print(f"a={a}，b={b}")  # a=2，b=1

引用（类似于指针）

在Python中，值是靠引用来传递的。
可以通过**id()**来判断两个变量是否为同一个值的引用。
**id**值是数据所在内存的地址标识（类似于指针）。

不可变类型—声明时内存空间已确定

  1. # int类型（不可变类型）
  2. a = 1
  3. b = a
  5. print(b)  # 1
  6. print(id(a))  # 打印数值1所在的内存地址----a指向1的地址
  7. print(id(b))  # 打印数值1所在的内存地址----b指向1的地址
  9. a = 2
  10. print(id(a))  # 打印数值2所在的内存地址
  11. print(id(b))  # 打印数值1所在的内存地址

可变类型—存储方式类似于链表，呈动态存储

  1. # 列表（可变类型）
  2. a = [10, 20]
  3. b = a
  5. print(b)  # [10, 20]
  6. print(id(a))  # 列表[10, 20]所在内存地址
  7. print(id(b))  # 列表[10, 20]所在内存地址
  9. a.append(30)
  10. print(b)  # [10, 20, 30]
  11. print(id(a))  # 列表[10, 20]所在内存地址----没有变化
  12. print(id(b))  # 列表[10, 20]所在内存地址

可变与不可变类型

所谓可变与不可变类型，指的是数据是否能够直接被修改，如果能，则是可变的，否则就是不可变的。

可变类型

  • 列表；
  • 字典；

  • 集合。

    不可变类型

  • 整型；

  • 浮点型；
  • 字符串；
  • 元组。