Python基础语法（七）

1. 函数

1. 函数的作用

1. 实现代码重用

2. 使用步骤

1. 定义函数

   def 函数名(参数):
       处理
   

2. 调用函数

   函数名(参数)
   

3. 注意：参数可有可无，必须先定义函数，再调用。

3. 函数的参数的作用

1. 让函数变得更灵活
2. 示例

   def fn_Sum(iNum1, iNum2):
       return iNum1 + iNum2
   
   
   print(fn_Sum(1, 2))
   
   # 输出结果
   3
   

4. 函数的返回值作用

1. 作用
   1. 返回函数结果
   2. 退出函数
2. 示例

   def fn_Sum(iNum1, iNum2):
       return iNum1 + iNum2
   
   
   print(fn_Sum(1, 2))
   
   # 输出结果
   3
   

5. 函数的说明文档

1. 语法

   def 函数名(参数):
       """ 函数的说明文档 """
       处理
   
   
   # 查看函数的说明文档
   help(函数名)
   

2. 示例

   def fn_Sum(iNum1, iNum2):
       """ Get Sum(iNum1, iNum2) """
       return iNum1 + iNum2
   
   
   help(fn_Sum)
   
   # 输出结果
   Help on function fn_Sum in module __main__:
   
   fn_Sum(iNum1, iNum2)
       Get Sum(iNum1, iNum2)
   

3. 函数文档的高级使用

   def fn_Sum(iNum1, iNum2):
       """
       Get Sum(iNum1, iNum2)
       :param iNum1: 
       :param iNum2: 
       :return: 
       """
       return iNum1 + iNum2
   
   
   help(fn_Sum)
   
   # 输出结果
   Help on function fn_Sum in module __main__:
   
   fn_Sum(iNum1, iNum2)
       Get Sum(iNum1, iNum2)
       :param iNum1:
       :param iNum2:
       :return:
   

6. 变量作用域

1. 局部变量：定义在函数体内部的变量，只在该函数体内部生效。在函数体内部临时保存变量，函数结束，变量销毁。

   def fn_test():
       iNum = 10
       print(iNum)
   
   
   fn_test()
   
   # 输出结果
   10
   

2. 全局变量：函数体内外都生效的变量，

   iNum = 10
   
   def fn_test1():
       print(iNum)
   
   
   def fn_test2():
       print(iNum)
   
   
   fn_test1()
   fn_test2()
   
   # 输出结果
   10
   10
   

3. 修改全局变量

   iNum = 10
   
   def fn_test1():
       print(iNum)
   
   
   def fn_test2():
       global iNum
       iNum = 20
       print(iNum)
   
   
   fn_test1()
   fn_test2()
   print(iNum)
   
   # 输出结果
   10
   20
   20
   
   

4. 函数多返回值

   # 多返回值时，默认返回的是元组，return后面可以连接元组，列表或字典、以返回多个值。
   def fn_test1():
       return 10, 20
   
   
   print(fn_test1())
   
   # 输出结果
   (10, 20)
   

7. 函数的参数

1. 位置参数：调用函数时，根据函数参数的定义位置来传递参数。传递和定义参数的位置和个数必须一致。

   def fn_test1(iNum1, iNum2):
       print(f"{iNum1}, {iNum2}")
   
   
   fn_test1(11, 22)
   
   # 输出结果
   11, 22
   

2. 关键字参数：通过“键=值”的方式指定，若参数中有位置参数，必须放在关键字参数前面，关键字参数没有顺序。

   def fn_userinfo(name, age, gender):
       print(f"{name}, {age}, {gender}")
   
   
   fn_userinfo("ccblogs", gender=0, age=18)
   
   # 输出结果
   ccblogs, 18, 0
   

3. 缺省参数：为参数设置默认值，调用函数时，为该参数传值则使用传递的值，未传值则使用默认值。位置参数必须在缺省参数前。

   def fn_userinfo(name, age, gender="0"):
       print(f"{name}, {age}, {gender}")
   
   
   fn_userinfo("ccblogs", 18)
   fn_userinfo("ccblogs", 18, 1)
   # 输出结果
   ccblogs, 18, 0
   ccblogs, 18, 1
   

4. 不定长参数：也叫可变参数。用于不确定调用的时候。可用包裹位置参数，或者包裹关键字参数，以进行参数传递。

   # 包裹位置传递（元组的方式）
   def fn_userinfo(*args):
       print(args)
   
   
   fn_userinfo("ccblogs", 18)
   fn_userinfo("ccblogs", 18, 1)
   
   # 输出结果
   ('ccblogs', 18)
   ('ccblogs', 18, 1)
   
   # 包裹关键字传递（字典的方式）
   def fn_userinfo(**kwargs):
       print(kwargs)
   
   
   fn_userinfo(name="ccblogs", age=18)
   fn_userinfo()
   
   # 输出结果
   {'name': 'ccblogs', 'age': 18}
   {}
   

8. 拆包和交换变量值

1. 拆包

   # 元组拆包
   def fn_test1():
       return 1, 3
   
   
   iNum1, iNum2 = fn_test1()
   print(f"{iNum1}, {iNum2}")
   
   # 输出结果
   1, 3
   
   # 字典拆包
   dicNb = {"name":"ccblogs", "age":18}
   
   
   key1, key2 = dicNb
   print(key1, key2)
   print(dicNb[key1], dicNb[key2])
   
   # 输出结果
   name age
   ccblogs 18
   

2. 交换变量值

   iNum1 = 10
   iNum2 = 20
   print(iNum1, iNum2)
   
   iNum1, iNum2 = iNum2, iNum1
   print(iNum1, iNum2)
   
   # 输出结果
   10 20
   20 10
   

9. 引用

1. 用id()来判断两个变量是否为同一个值的引用。
2. 在python中，值是靠引用来传递的。
3. 可变数据类型与不可变数据类型比较示例

   # 不可变数据类型
   iA = 1
   iB = iA
   print(iA, iB, id(iA), id(iB))
   
   iA = 2
   print(iA, iB, id(iA), id(iB))
   
   # 输出结果
   1 1 11677888 11677888
   2 1 11677920 11677888
   
   # 可变数据类型
   lstA = [1, 2]
   lstB = lstA
   print(lstA, lstB, id(lstA), id(lstB))
   
   lstA.append(3)
   print(lstA, lstB, id(lstA), id(lstB))
   
   # 输出结果
   [1, 2] [1, 2] 140141770266048 140141770266048
   [1, 2, 3] [1, 2, 3] 140141770266048 140141770266048
   

4. 引用当作实参

   def fn_test(iNum):
       print(iNum)
       print(id(iNum))
   
       iNum += iNum
       print(iNum)
       print(id(iNum))
   
   
   iA = 10
   fn_test(iA)
   print(iA)
   
   lstA = [10, 20]
   fn_test(lstA)
   print(lstA)
   
   # 输出结果
   10
   11678176
   20
   11678496
   10
   [10, 20]
   139882176710080
   [10, 20, 10, 20]
   139882176710080
   [10, 20, 10, 20]
   

10. 可变与不可变类型

1. 数据能直接进行修改就是可变，否则是不可变。
2. 可变类型
   • 列表
   • 字典
   • 集合
3. 不可变类型
   • 整型
   • 浮点型
   • 字符型
   • 元组