一、变量

1、局部变量

1）函数内部定义的变量

2）不同函数内的局部变量可以定义相同的名字，互不影响

3）作用范围：函数体内有效，其他函数不能直接使用

  1. def set_name():
  2.     name = "zhangsan"
  3.     return name
  4. def get_name(name):
  5.     name = "lisi"
  6.     print(name)
  7. nm = set_name()
  8. get_name(nm)

运行结果：

  1. lisi

2、全局变量

1）函数外部定义的变量

2）全局变量命名建议以g_开头，如：g_name

3）作用范围：可以在不同函数中使用

  1. name = "zhangsan"
  2. def get_name():
  3.     print(name)
  4. def get_name2():
  5.     print(name)
  6. get_name()
  7. get_name2()
  8. print(name)

运行结果：

  1. zhangsan
  2. zhangsan
  3. zhangsan

4）在函数体内修改全局变量：
先用global声明全局变量，再作修改。否则只会修改函数体内的参数值，在函数体外不变。

  1. age = 20
  2. weight = 60
  4. def change_age_weight():
  5.     weight = 70 #重新定义了一个局部变量weight
  6.     global age
  7.     age = 25
  8.     print("函数体内age=%d"%age)
  9.     print("函数体内weight=%d"%weight)
  11. change_age_weight()
  12. print("函数体外age=%d"%age)
  13. print("函数体外weight=%d"%weight)

运行结果：

  1. 函数体内age=25
  2. 函数体内weight=70
  3. 函数体外age=25
  4. 函数体外weight=60

如果全局变量与局部变量同名，则函数体内使用的是局部变量

5）全局变量定义的位置：

  1. g_num1 = 100
  2. def print_global_num():
  3.     print("g_num1:%d"%g_num1)
  4.     print("g_num2:%d"%g_num2)
  5.     print("g_num3:%d"%g_num3)
  7. g_num2 = 200
  8. print_global_num()
  9. g_num3 = 300

运行后，g_num1显示100，g_num2显示200，g_num3会报错

全局变量定义的位置要在函数调用之前或函数定义之前

6）字典、列表作为全局变量，在函数体内修改这种类型的全局变量中的元素不需要用global声明

  1. g_num_list = [1,2,3]
  2. g_info_dict = {"name":"zhangsan","age":20}
  4. def update_info():
  5.     g_num_list.append(4)
  6.     g_info_dict["gender"] = "male"
  8. update_info()
  9. print(g_num_list)
  10. print(g_info_dict)

运行结果：

  1. [1, 2, 3, 4]
  2. {'name': 'zhangsan', 'age': 20, 'gender': 'male'}

二、函数参数

1、缺省参数

1）函数定义带有初始值的形参

  1. def x_y_sum(x,y=20):
  2.     print("x=%d"%x)
  3.     print("y=%d"%y)
  4.     return  x + y
  5. print(x_y_sum(15))

运行结果：

  1. x=15
  2. y=20
  3. 35

2）函数调用时，缺省参数可传，也可不传

  1. def x_y_sum(x,y=20):
  2.     return  x + y
  3. rs = x_y_sum(10)
  4. print(rs)
  5. rs = x_y_sum(10,30)
  6. print(rs)

运行结果：

  1. 30
  2. 40

3）缺省参数一定要位于参数列表的最后

  1. #错误的使用方法
  2. def x_y_sum2(y=10,x):
  3.     return x + y

4）缺省参数数量没有限制

2、命名参数

1）调用带有参数的函数时，通过指定参数名称传入参数的值

2）可以不按函数定义的参数顺序传入

  1. def x_y_sum(x=10,y=20):
  2.     return  x + y 
  3. #注意：形参的顺序可以不同，但是名称要相同。
  4. rs1 = x_y_sum(y=30,x=15)
  5. rs2 = x_y_sum(x=15)
  6. rs3 = x_y_sum()
  7. print("rs1=%d"%rs1)
  8. print("rs2=%d"%rs2)
  9. print("rs3=%d"%rs3)

运行结果：

  1. rs1=45
  2. rs2=35
  3. rs3=30

3、不定长参数

函数可以接收不定个数的参数传入

def fuction([formal_args,]*args)函数调用时，传入的不定参数会被封装成元组

  1. def any_num_sum(x,y=10,*args):
  2.     print("args={}".format(args))
  3.     rs = x + y
  4.     if len(args) > 0:
  5.         for arg in args:
  6.             rs += arg
  7.     return rs
  8. rs1 = any_num_sum(10,20,30,40,50)
  9. print(rs1)

运行结果：

  1. args=(30, 40, 50)
  2. 150

改变不定长参数的位置

  1. def any_num_sum2(x,*args,y=10):
  2.     print("args={}".format(args))
  3.     print("x={}".format(x))
  4.     print("y={}".format(y))
  5.     rs = x + y
  6.     if len(args) > 0:
  7.         for arg in args:
  8.             rs += arg
  9.     return rs
  10. rs1 = any_num_sum2(20)
  11. rs2 = any_num_sum2(20,30,y=100)
  12. rs3 = any_num_sum2(20,30,40,50,60,y=100)
  13. print(rs1)
  14. print(rs2)
  15. print(rs3)

运行结果：

  1. args=()
  2. x=20
  3. y=10
  4. args=(30,)
  5. x=20
  6. y=100
  7. args=(30, 40, 50, 60)
  8. x=20
  9. y=100
  10. 30
  11. 150
  12. 300

若不定长参数在中间，后面需要用命名参数传入，否则后面的都会传入不定长参数

def fuction([formal_args,]**args)函数调用时，如果传入key=value形式的不定长参数，会被封装成字典

  1. def social_insurance_comp(basic_money,**proportion):
  2.     print(proportion)
  3.     e_money = basic_money * proportion["e"]
  4.     m_money = basic_money * proportion["m"]
  5.     a_money = basic_money * proportion["a"]
  6.     total_money = e_money + m_money + a_money
  7.     return e_money,m_money,a_money,total_money
  9. e,m,a,t = social_insurance_comp(8000,e=0.2,m=0.1,a=0.12)
  10. print("养老：{},医疗：{}，公积金：{}，缴费总额：{}".format(e,m,a,t))

运行结果：

  1. {'e': 0.2, 'm': 0.1, 'a': 0.12}
  2. 养老：1600.0,医疗：800.0，公积金：960.0，缴费总额：3360.0

拆包

对于定义了不定长参数的函数，在函数调用时需要把已定义好的元组或者列表传入到函数中，需要使用拆包方法

  1. def salary_comp(basic_money,*other_money,**proportion):
  2.     print("缴费基数:{}".format(basic_money))
  3.     print("其他工资:{}".format(other_money))
  4.     print("比例:{}".format(proportion))
  6. other_money = (500,200,100,1000)
  7. proportion_dict = {"e":0.2,"m":0.1,"a":0.12}
  8. #未使用拆包
  9. print("未使用拆包")
  10. salary_comp(8000,other_money,proportion_dict)
  11. print("--------------------------")
  12. print("使用拆包")
  13. salary_comp(8000,*other_money,**proportion_dict)

运行结果：

  1. 未使用拆包
  2. 缴费基数:8000
  3. 其他工资:((500, 200, 100, 1000), {'e': 0.2, 'm': 0.1, 'a': 0.12})
  4. 比例:{}
  5. --------------------------
  6. 使用拆包
  7. 缴费基数:8000
  8. 其他工资:(500, 200, 100, 1000)
  9. 比例:{'e': 0.2, 'm': 0.1, 'a': 0.12}

三、递归函数

函数调用自身。
如：阶乘

  1. def recursive(num):
  2.     if num > 1:
  3.         return num * recursive(num -1)
  4.     else:
  5.         return num
  6. print(recursive(3))

运行结果：

  1. 6

注意：递归过程中要有用于结束递归的判断

四、匿名函数

用lambda关键字创建匿名函数

匿名函数定义：

  1. lambda [参数列表]:表达式

匿名函数可以作为参数被传入其他函数

  1. sum = lambda x,y:x+y
  2. print(sum(10,20))
  3. #等价函数
  4. def sum(x,y):
  5.     return x + y

（1）匿名函数作为参数传入到自定义函数中

  1. def x_y_comp(x,y,func):
  2.     rs = func(x,y)
  3.     print(rs)
  5. x_y_comp(3,5,lambda x,y:x+y)
  6. print("----------------")
  7. x_y_comp(4,7,lambda x,y:x*y)

运行结果：

  1. 8
  2. ----------------
  3. 28

（2）匿名函数作为python内置函数的参数使用

  1. #按age大小排序
  2. user_infos = [{"name":"zhangsan","age":20},{"name":"lisi","age":30},{"name":"wangwu","age":18}]
  3. print(user_infos)
  4. user_infos.sort(key=lambda info:info["age"],reverse=True)
  5. print(user_infos)

运行结果：

  1. [{'name': 'zhangsan', 'age': 20}, {'name': 'lisi', 'age': 30}, {'name': 'wangwu', 'age': 18}]
  2. [{'name': 'wangwu', 'age': 18}, {'name': 'zhangsan', 'age': 20}, {'name': 'lisi', 'age': 30}]