Python(四)

函数

1. 函数相关的链接：函数

定义：函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。
可以理解为对实现某一功能的封装。

函数的语法格式：

def 函数名称（参数）：
    函数体代码
    return 返回值

函数定义以及函数调用（函数名（参数））

实例1：

#函数的定义
def print_user_info():
    print("name:zhangsan")
    print("age:20")
    print("gender:male")

print_user_info()

结果：

name:zhangsan
age:20
gender:male

函数参数

1. 形参：定义函数时设置的参数
2. 调用函数时传入的参数

实例2：

#带参函数注意，1.调用函数时传入的参数个数与函数定义参数个数相同。2.参数顺序要相同
#有参无返回值函数
##形参：name，age，gender
##实参：悟空，20，male
def print_user_info2(name,age,gender):
    print("name:%s"%name)
    print("age:%d"%age)
    print("gender:%s"%gender)

print_user_info2("悟空",20,"male")
print_user_info2("八戒",18,"male")
print_user_info()

函数类型

1. 无参无返回值函数
2. 无参有返回值函数
3. 有参无返回值函数
4. 有参有返回值函数

实例3：

#有返回值函数
def x_y_sum_return(x,y):
    res = x + y
    return res

z = x_y_sum_return(2,3)
print(z)

结果：

5

变量

局部变量

• 函数内部定义函数
• 不同函数内的局部变量可以定义相同的名字，互不影响
• 作用范围：函数体内有效，其他函数不能直接使用

链接：局部和全局变量

此链接推荐阅读，讲的很详细，下面会摘取一些例子

实例4：

#局部变量
def set_name():
    name = "zhangsan"
    return name

def get_name(name):
    #name = "lisi"
    print(name)

nm = set_name()
get_name(nm)

结果：

lisi

#从结果可以看出，打印的并非zhangsan，而是lisi，因为调用的是get_name函数里面的局部变量name

全局变量

• 函数外部定义的变量
• 作用范围：可以再不同函数中使用
• 在函数内使用global关键字实现修改全局变量的值
• 全局变量命名建议以g_开头，如g_game

实例5：

#全局变量
#可以在不同的函数中使用
'''
name = "zhangsan"
def get_name():
    print(name)

def get_name2():
    print(name)

get_name()
get_name2()
print(name)

结果：

zhangsan
zhangsan
zhangsan

#打印name，所有函数全部调用了全部变量的name

实例6：

#修改全局变量的值
age = 20
def change_age():
    age = 25  #重新定义了一个局部变量age
    #global age
    #age = 25
    print("函数体内age=%d"%age)

change_age()
print("函数体外age=%d"%age)

print('================')

age = 20
def change_age():
    #age = 25  #重新定义了一个局部变量age
    global age
    age = 25
    print("函数体内age=%d"%age)

change_age()
print("函数体外age=%d"%age)

结果：

函数体内age=25
函数体外age=20

=======================
函数体内age=25
函数体外age=25

##可以看出，如果不对局部变量用关键词global进行申明，函数体外打印的值还是全局变量age = 20，如果对进行global申明，那函数体内的局部变量就会代替体外的全局变量成为新的全局变量，所以申明后的体外打印的age =25

实例7：

#全局变量定义的位置
g_num1 = 100
def print_global_num():
    print("g_num1:%d"%g_num1)
    print("g_num2:%d"%g_num2)
    print("g_num3:%d"%g_num3)

g_num2 = 200
print_global_num()
g_num3 = 300

结果：

g_num1:100
g_num2:200
g_num3:300

实例8：

#字典、列表作为全局变量，在函数内修改这种类型的全局变量中的元素

g_num_list = [1,2,3]
g_info_dict = {"name":"zhangsan","age":20}

def update_info():
    g_num_list.append(4)
    g_info_dict["gender"] = "male"

update_info()
print(g_num_list)
print(g_info_dict)

结果：

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

实例9：

num = 100
def func():
    num = 123
    print(num)

func()

结果：

123

##函数内部的变量名如果第一次出现，且出现在=前面，即被视为定义一个局部变量，不管全局域中有没有用到该变量名，函数中使用的将是局部变量

函数参数

链接：函数参数

可在此链接查看函数的参数，参数分四种（必须参数，关键字参数，默认参数，不定长参数等）

缺省参数

• 函数定义带有初始值的形参
• 函数调用时，缺省参数可传，也可不穿
• 缺省参数一定要位于参数列表的最后
• 缺省参数数量没有限制

实例10：

#缺省参数
def x_y_sum(x,y=20):
    print("x=%d"%x)
    print("y=%d"%y)
    return  x + y

print(x_y_sum(20))

结果：

x = 20
y = 20
40

实例11：

def x_y_sum2(y=10,x):
    return x + y
print(x_y_sum2(10))

结果：

 File "<ipython-input-31-cc4701538993>", line 1
    def x_y_sum2(y=10,x):
                ^
SyntaxError: non-default argument follows default argument

###从上面报错得知，缺省参数一定要位于参数列表的的最后

命名参数

• 调用带有参数的函数时，通过指定参数名称传入参数的值
• 可以不按函数定义的参数顺序传入

实例12：

def x_y_sum(x=10,y=20):
    return  x + y
#注意：函数调用的时候命名参数的名称与函数定义时的形参名称相同，但是顺序可以不同
rs1 = x_y_sum(y=30,x=15)
rs2 = x_y_sum(x=15)
rs3 = x_y_sum()

print("rs1=%d"%rs1)
print("rs2=%d"%rs2)
print("rs3=%d"%rs3)

结果：

rs1=45
rs2=35
rs3=30

##结果可以看出 rs1是通过命名参数的的输入，得出的结果
##rs2是y是缺省参数，x是命名参数，相加得到的结果
##rrs3是相加的两个数都是缺省参数相加

不定长参数

• 函数可以接受不定个数的参数传入
• def function([formal_args,]*args)函数调用时，传入的不定参数会被封装成元组
• def function([formal_args,]**args)函数调用时，如果传入key = value的形式的不定长参数，会被封装成字典

实例13：

#不定长参数
#第一种def fuction([formal_args,]*args)

def any_num_sum(x,y=10,*args):
    print("args={}".format(args))
    rs = x + y
    if len(args) > 0:
        for arg in args:
            rs += arg
    return rs
rs1 = any_num_sum(20,10,30,40,50,60)

结果：

args=(30, 40, 50, 60)
210

# x =  20 ， y = 10 然后再讲被封装成元组的不定长参数依次相加，得到结果210

实例14：

#改变不定长参数的位置
def any_num_sum2(x,*args,y=10):
    print("args={}".format(args))
    print("x={}".format(x))
    print("y={}".format(y))
    rs = x + y
    if len(args) > 0:
        for arg in args:
            rs += arg
    return rs
    
rs2 = any_num_sum2(20,30,40,50,60,y=100)

结果：

args=(30, 40, 50, 60)
x=20
y=100
300

实例15：

#第二种def fuction([formal_args,]**kvargs)

#养老 医疗 公积金

def social_insurance_comp(basic_money,**proportion):
    print(proportion)
    e_money = basic_money * proportion["e"]
    m_money = basic_money * proportion["m"]
    a_money = basic_money * proportion["a"]
    total_money = e_money + m_money + a_money
    return e_money,m_money,a_money,total_money

e,m,a,t = social_insurance_comp(8000,e=0.2,m=0.1,a=0.12)

print("养老：{},医疗：{}，公积金：{}，缴费总额：{}".format(e,m,a,t))

结果：

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

拆包

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

实例16：

#拆包
#工资计算器

def salary_comp(basic_money,*other_money,**proportion):
    print("缴费基数:{}".format(basic_money))
    print("其他工资:{}".format(other_money))
    print("比例:{}".format(proportion))

other_money = (500,200,100,1000)
proportion_dict = {"e":0.2,"m":0.1,"a":0.12}
print('未使用拆包的：')
salary_comp(8000,other_money,proportion_dict)#未使用拆包
print('=========')
salary_comp(8000,*other_money,**proportion_dict)

结果：

未使用拆包的：
缴费基数:8000
其他工资:((500, 200, 100, 1000), {'e': 0.2, 'm': 0.1, 'a': 0.12})
比例:{}
=========
缴费基数:8000
其他工资:(500, 200, 100, 1000)
比例:{'e': 0.2, 'm': 0.1, 'a': 0.12}
##如果不拆包的话，就会使other_money和proportion_dict被封装成元组变为实参，进入函数内执行。

递归函数和匿名函数

递归函数

• 函数调用自身
• 注意：递归过程中要有用于结束递归的判断

实例17：

#递归函数，自身调用自身
'''
1! = 1
2! = 2 * 1
3! = 3 * 2 * 1
...
n! = n * (n-1)!
'''
#for循环实现

def recursive_for(num):
    rs = num
    for i in range(1,num):# (1,4) = [1,2,3)
        rs *= i
    return rs
rs = recursive_for(4)
print(rs)

##递归函数实现
def recursive(num):
    if num > 1:
        return num * recursive(num -1) #这里就是函数的递归，调用自身
    else:
        return num
print(recursive(4))

结果：

24 
24

匿名函数

• 用lambda关键字创建匿名函数
• 定义：lambda[参数列表]：表达式
• 匿名函数可以作为参数被传入其他函数

实例18：

#匿名函数
sum = lambda x,y:x+y
print(sum(10,20))
#等价函数
def sum(x,y):
    return x + y

结果：

30

实例19：

#1.匿名函数作为参数传入到自定义函数中

def x_y_comp(x,y,func):
    rs = func(x,y)
    print(rs)

x_y_comp(3,5,lambda x,y:x+y)
print("----------------")
x_y_comp(4,7,lambda x,y:x*y)

实例20：

链接：sort的用法

#2.匿名函数作为python内置函数的参数使用

user_infos = [{"name":"zhangsan","age":20},{"name":"lisi","age":30},{"name":"wangwu","age":18}]

print(user_infos)
user_infos.sort(key=lambda info:info["age"])
print(user_infos)
user_infos.sort(key=lambda info:info["age"],reverse=True)
print(user_infos)

结果：

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