六、Python函数

一.函数的特性

1.功能性

2.隐藏细节

3.避免编写重复的代码 

4.参数列表可以没有

5.可以使用return返回值，如果没有return，返回None   

代码段

a = 3.1415926

result = round(a,3)  # round为函数，result变量也可以是一个函数
print(result)

输出结果

3.142

二.创建一个函数，使用关键字def

代码段

def mun(x,y):
    result = x+y
    return result

def pint(code):
    print(code)
    
a = mun(8,100)
b = pint(1000)
print(a,b)

　　输出结果

1000
108 None

三.返回多个值 return

代码段

def damage(skill1,skill2):
    damage1 = skill1 * 3
    damage2 = skill2 * 2 + 10
    return damage1,damage2
# 序列解包
skill1_damage,skill2_damage = damage(3,6)
print(skill1_damage,skill2_damage)

　　输出结果

9 22

四.序列解包

代码段

# a = 1
# b = 2
# c = 3
a,b,c = 1,2,3    # 不需要像上面一个单个赋值，可以一起赋值
d = 1,2,3    # d 是一个元组类型

print(type(d))

e=f=g=8   # 三个变量赋予同一个值
print(e,f,g)

　　输出结果

<class 'tuple'>
8 8 8

五.函数参数

1.必须参数

实参，在调用函数时使用，例如mun(8,100)，8,100为实参

def mun(x,y):   # x,y为形参，也就是形式参数
    result = x+y
    return result

a = mun(8,100)   # 8,100为实参，也就是实际参数
print(a)

　　输出结果

108

2.关键字参数

调用函数时，用来明确赋值的参数，例如调用时add(y=3,x=2)，主要可以保障代码的可读性

def adda(ipone,ipad):  
    result = x+y
    return result

a = adda(ipad=4300,ipone=5000) # 关键字参数，不用考虑顺序;使用关键字参数，可以提高代码的可读性
print(a)

　　输出结果

9300

3.默认参数

默认参数定义方式，例如def print_student_files(name,gender='男',age = 28,college = '人民路小学'):

def print_student_files(name,age,gender='男',school='清华大学'):     # gender、school为默认参数
    print("姓名：",name)
    print("年龄：",age)
    print("性别：",gender)
    print("学校：",school)
print_student_files('Cheney',18)       
print("\n")
print_student_files('joy',18,'女','北京大学')    # 修改默认参数
print("\n")
print_student_files('hebe',23,school='哈佛大学')   # 修改指定的默认参数

　　输出结果

姓名： Cheney
年龄： 18
性别： 男
学校： 清华大学


姓名： joy
年龄： 18
性别： 女
学校： 北京大学


姓名： hebe
年龄： 23
性别： 男
学校： 哈佛大学

注意

1.定义函数时，非默认参数不能在默认参数后面，例如def print_student_files(name,gender='男',age = 28,college):，college就在默认参数后面，执行导致报错

2.调用函数时，位置参数不能关键字参数后面，例如print_student_files('尼玛',gender = '女',22,college = '光明小学')，22的实参在关键字参数后面，执行导致报错

六.可变参数

 可变参数定义函数

注意：

关注demo('a',1,2,3,'param')的打印结果，1,2,3,'param'传给了可变参数*param，而没有传给param2

# 可变参数定义函数
def demo(param1,*param,param2=2):
    print('这是一个必须参数：', param1)
    print('这是一个可变参数：',param)
    print('这是一个默认参数：',param2) 
# 未传param2关键字参数 
demo('a',1,2,3,'param')
print('~'*28)
# 传入param2关键字参数 
demo('a',1,2,3,param2 = 'param')
print('~'*28)

def demo2(*param_a):
    print(param_a)
a = 5,6,7,8
# 可变参数两种入参方式
demo2(1,2,3,4)
# 将多个变量传入
demo2(*a)

# 可变参数求平方
def squsum(*param):
    sum = 0 
    for i in param:
        sum += i*i
    print(sum)
print('~'*28)   
squsum(1,2,3)

 结果

这是一个必须参数： a
这是一个可变参数： (1, 2, 3, 'param')
这是一个默认参数： 2
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
这是一个必须参数： a
这是一个可变参数： (1, 2, 3)
这是一个默认参数： param
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
(1, 2, 3, 4)
(5, 6, 7, 8)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
14

七.关键字可变参数

定义函数时，在形参前面增加**，可定义关键字可变参数

# 关键字可变参数
# 形参前面加上**，可定义为关键字可变参数
def city_temp(**temp):
    print(temp)
    # 遍历一个字典，需要使用items方法
    for key,value in temp.items():
        print(f'{key}:{value}')
        
city_temp(bj='28c',xm='35c',sh='30c')
print('~'*28)
# 通过一个字典的方式，传入实参
a  = {'bj':'11c','xm':'28c'}
city_temp(**a)

结果

{'bj': '28c', 'xm': '35c', 'sh': '30c'}
bj:28c
xm:35c
sh:30c
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
{'bj': '11c', 'xm': '28c'}
bj:11c
xm:28c

八.作用域

同名的变量，函数以外的称为全局变量，函数以内的称为局部变量，调用函数会优先调用内部变量

c = 50   
def sum(x,y):
    c = x*y  
# 函数内部的c，变量为局部变量
    print(c) 
# 当调用函数时，能在内部找到c，调用函数使用局部变量c
sum(2,3)
print(c)

# a为全局变量，当函数内部没有找到a时，会取全局变量的a
a = 50
def demo():
    print(a)
demo()

结果

6
50
50

函数内部的for、while循环，if else都属于函数内部的变量，属于同一级别

# 函数内部的for、while循环，if else都属于函数内部的变量，属于同一级别
def scope():
    b = 50
    for i in range(0,9):
        e = 'a'
        b += 1
    print(b)
    print(e)
    
scope()

结果

59
a

作用域链

# 作用域链，优先去func2中的c，
# 如果func2中没有找到，就会去func1中寻找
# 当func1没有找到，就去模块中寻找c
c = 1
def func1():
    c = 2
    def func2():
        c = 3
        print(c)
    func2()
func1()

结果

3

使用global方法，使内置变量变为全局变量，同时，在其他模块也可以导入后调用此变量

def cos():
    global g
    g = 2
# 执行函数
cos()    
print(g)

结果

2