函数

• 定义和作用
• • 函数的概念
  • 函数的定义
• 函数的返回值
• 函数参数
• • 实参形参
  • 参数的类型为[固定数据类型时](https://blog.csdn.net/qq_43728862/article/details/116309649)
  • 当参数类型为可变数据类型
  • 参数类型
  • • 位置参数
    • 默认参数
    • 关键字参数
    • 不定长参数
  • 函数的嵌套
  • • 递归函数
• 变量的作用域
• • 局部变量
  • 全局变量
• global和nonlocal关键字
• • global
  • nonlocal

定义和作用

函数的概念

函数是一段具有特定功能的，可以重复使用的代码段，她能够提高程序的模块化和代码的复用率

函数的定义

def 函数名([形参列表]):
    函数体
#def关键字来定义函数
#例如

def print_text():#定义了一个函数
    print("hello")
print_text()#调用

函数的返回值

# #以该程序为例,后面的数字是执行的步骤
# #以该程序为例,后面的数字是执行的步骤
 def max_print(a,b):#1
     if a > b:#5
         return a
     else:#6
         return b#7
 a = 4#2
 b = 5#3
 c = max_print(a,b)#4
 print(c)#8
# #当返回值是两个及以上,返回值以元组的形式存储
 def Add(a,b):
     a = a + 1;
     b = b + 1;
     return a,b
 a = 1
 b = 2
 c = Add(a,b)
 print(type(c))#以元组的形式存储

函数参数

实参形参

def sum(aa):#这里的aa为形式参数
    aa = aa + 1
    return aa
a = 4
c = sum(a)#这里的a是实际参数
print(c)

参数的类型为固定数据类型时

def Be(a):
    a = 5
a = 3
Be(a)
print(a)#程序运行结果:3
#因为 a是整形为固定数据类型,值如果改变，地址也会改变，但在print打印时的a指向的是存放数字3的内存空间

当参数类型为可变数据类型

在函数内部使用下标或其他方法为其增加,删除或修改元素值时，实参的值也会相应的被修改

def alter(b):
    b.append(5)
b = [1,2,3,4]
alter(b)
print(b)#结果[1, 2, 3, 4, 5]

参数类型

**在python中，有多种参数类型,包括位置参数,默认参数,关键字参数和不定长参数

位置参数

位置参数是比较常用的形式,调用函数时,实参和形参的顺序严格一致,并且实参和形参的数量必需相同

默认参数

在定义函数时,可以为函数的参数,设置默认值,这个参数被称为默认值参数.在调用带有默认值参数的函数时,可以不用为设置默认值的形参进行传值
此时函数将会直接使用默认值,也可以通过显式赋值来替代其默认值**

def show(b,a = 4):
    print('b = %d a = %d'%(b,a))
    return

print(show.__defaults__)#输出函数默认值参数,我们会发现默认值类型是元组,
show(5,5)
show(6)

多次调用函数并不为默认值参数传递值时,默认值参数只在定义是是进行一次解释和初始化,(因为元组是不可变的)

#当默认值为可变数据类型
def demo(new,old_list = []):
    old_list.append(new)
    return old_list
print(demo('5',[1,2,3,4]))
print(demo('a'))
print(demo('b'))

程序运行结果
[1, 2, 3, 4, ‘5’]
[‘a’]
[‘a’, ‘b’]
在使用列表作为默认值参数,连续多次调用该函数而不给该参数传值时，再次调用将保留上一次调用的结果,所以会输出[a,b],所以默认只会改变，所以避免可变类型作为默认值

关键字参数

#关键字参数是指调用函数是的参数传递方式,是一种按参数名字传递的方式
def print_infor(name,age):
    print(f'名字{name}\n年龄{age}')
print_infor(age = 23,name="root")#他会按照名字来传值的
#运行结果:名字root
#         年龄23

不定长参数

#从字面理解是长度不确定的参数
# 语法格式:
# def 函数名([形参列表,],*args,**kwargs):#*args和**kwargs都是不定长参数,*args是用来接收任意多个实参并将其放入一个元组中
#                                        **kwargs 是用来接收类似于关键字参数一样显式赋值并将结果放入到字典中
#     函数体
def sum(a,b,*args,**kwargs):
    print(a)
    print(b)
    print(args)
    print(kwargs)
sum(1,2,3,4,56,x = 9,y = 19)

函数的嵌套

def print_tu():
    print("11111111111111111111")
    def print_h():
        print("Hello")
    print_h()
print_tu()

例题计算1! + 2! + … + 10!的值:使用函数嵌套

def jen(k):
    num = 1
    for x in range(1,k + 1):
        num = num * x;
    return num;
def sum(i):
    sums = 0
    for j in range(1,i + 1):
        sums = sums + jen(j)
    return  sums;

print(sum(10))

递归函数

函数的递归是一种特殊的函数嵌套,自己嵌套自己
函数递归:要有推出条件
计算5!

def sun(n):
    if(n == 1):
        return 1
    else:
        return n * sun(n - 1)
print(sun(5))

变量的作用域

局部变量

所谓局部变量,指的是定义在函数内的定义的变量,只能在函数内部使用,他与函数为具有相同名称的其他变量没有任何关系

全局变量

全局变量:在函数之外定义的变量称为全局变量,全局变量在整个程序范围内有效

a = 6#a是全局变量
def sum(c,b):
    a = c + b#a是局部变量
    print(f'函数内a = {a}')
    return a
sum(1,2)#调用sum函数
print(f'函数外a={a}')
# 运行结果:
# 函数内a = 3
# 函数外a=6
#分析:函数内部的a只在函数内部有效，而全局变量a和函数内部的a比起来还有有点弱，内部的a就好比地头蛇而全局变量的a就是龙，在函数内部就是函数内a的地盘，俗话所说强龙压不过地头蛇，所以在内部是3
#而到了函数为就是全局变量a

global和nonlocal关键字

global

使用情况
1,一个变量已在函数外部定义,如果在函数内部需要使用该变量的值或修改该变量的值,并将修改的结果反映到函数外,可以在函数内部用关键字global明确声明该全局变量
2,再函数内部直接使用global关键字将一个局部变量声明为一个全局变量,如果在函数外没有定义该全局变量,再调用函数后,会创建新的全局变量
加了global

# 加了global
str = '县令'
def fun():
    global str
    str = '知府'
    print(f'通过了培训,我可以当{str}')
fun()
print(f'我官阶是{str}')
#不加global
str = '县令'
def fun():

    str = '知府'
    print(f'通过了培训,我可以当{str}')
fun()
print(f'我官阶是{str}')
#关于global关键字，我的理解是这就相当于古代权力机构承认的官员培训结构,只要通过培训就升级,而没有global是权力机构不承认的机构,不能升级

nonlocal

nonlocal关键字(只能用在函数嵌套中)

def guan():
    str = '我是县令'
    def pei():
        nonlocal str
        str = '我是知府'
        print(f'经过培训{str}')
    pei()
    print(f'官员统计{str}')
guan()
def guan():
    str = '我是县令'
    def pei():

        str = '我是知府'
        print(f'经过培训{str}')
    pei()
    print(f'官员统计{str}')
guan()
#和global关键字意义一样