跟着柯南一起探索“函数”

1、函数的定义

函数的作用：提高代码的复用；减少代码的编写

函数名的命名规则跟变量的一样

def wakeup():#函数的定义（声明）   wakeup是函数名，不能使用关键字

        （该部分写程序即想要达成的目的）

wakeup()#函数的调用

def wake_up():  # 函数的定义（声明） def 函数名 （）：pass
    """
    这是函数的注释，打印hhhhhh,aaaaaaaa

    """
    print("hhhhhhhh")
    print("aaaaaaaa")
wake_up()  # 函数的调用 ：函数名（）

结果

hhhhhhhh
aaaaaaaa

函数的形参和实参：

形参写在函数定义（声明）里 ，形参没有固定的值，在函数调用时才有 def 函数名 （形参）：
实参写在函数调用里

def wakeup (形参):
               ........
wakeup(实参)

def wakeup(name):
    print(f"起床了，{name}")
wakeup("小乔")
wakeup("周瑜")

结果

起床了，小乔
起床了，周瑜

2、函数的调试

函数的调试：

步入：编写两个封装函数，如果一个函数调用了另一个函数的方法，那么在调试这个函数时，要进行步入，进入到被调用函数里，在被调用函数执行完成后或者想结束这个函数的调试，点击步出。

def f(a,b):
    """
    这是一个比较大小的函数
    :param a: 输入的值
    :param b: 输入的值
    :return: 返回最大的值
    """
    value = max(a,b)
    return value
print(f(5,10))#最大值10

def f1(a,b):
    """
    这是一个比较大小的函数，调用了上一个封装函数的方法
    :param a: 输入比较的数
    :param b: 输入比较的数
    :return: 返回最大的数
    """
    c = f(a,b)#调用了f()的方法，在调试时，要步入到f()函数中，执行完步出或者继续执行此函数
    return c
print(f1(6,9))#最大值9

函数的变量作用域：函数内部定义的变量，外部不能使用

def f(m):#在def前的变量可以使用
    i =10#函数内部定义的局部变量（i,m)，外部不能使用
    print(i,m)

f(20)#  f() 已经结束是函数外部
#如果在函数外打印 i,m 会报错
print(i,m) #报错，函数内部定义的变量函数外部不能使用

情况一：变量（a）是外部变量，可以直接获取

a = 10# a在函数外部，既可以在函数内使用，也可以在函数外打印
def f():
    print(a)

f()
print(a)#可打印a变量

情况二：变量(a)在函数内，且在print之后被赋值，会报错，因为在print打印时，a没有被赋值

def f():
    print(a)#此时a并没有被赋值定义，打印无效，报错
    a = 10

f()
print(a)

情况三：如果函数外部和函数内部都有变量但值不同，那么函数内部变量（a）相当于被重新赋值了20.不是修改外部变量，而是在函数内部有一个新的a赋值，函数结束，该赋值的变量消失

a = 10
def f():
    a= 20 # a被重新赋值为20
    print(a)

f()#到此函数结束
print(a)#在函数外部，所以函数内部的赋值，在函数结束后没有了，打印的还是a=10

情况四：使用关键字global声明修改外部变量a，也就是不管在函数内部还是函数外部，a都已经被修改不是原来的数

a = 10
def f():
    global a
    a = 20
    print(a)
f()
print(a)  #当第三种情况时，a是在函数内部重新赋值，与函数外部无关，此时的a还是10
           #当第四种情况，已经修改了外部变量，所以在函数之外的a也被修改了，此时打印的a是修 
             改后的，即 20

结果都是 20

3、函数的参数

位置参数：按照顺序，将参数依次赋予

#按顺序，将10,20,30依次赋值给a,b,c
def f(a,b,c):
    print(a,b,c)
    
f(10,20,30)

结果 
10 20 30

默认参数：在形参中有固定的值，不需要在实参中再赋值

#10,20会按照顺序，给a,b 由于C在形参中有固定的值，如果不赋给新的值，就打印形参中的，如果有#在实参中有新值，新值替换形参的值
def f(a,b,c=40):
    print(a,b,c)

f(10,20)

结果

10 20 40


def f(a,b,c=40):
    print(a,b,c)

f(10,20，50)

结果

10 20 50

可变（元组）参数：一个参数：*args （在形参中，尽量写在最后，如果写在前面或者中间部分，而后面的数没有默认参数或者实参中没有关键字参数，会导致后面的数无法赋值）

def f(a,b,*args):
    print(a,b,args)
#a和b按顺序赋值，剩下的合成元组给args
f(10,20,30,40,50,60,)    #10 20 (30, 40, 50, 60)


#如果默认参数跟可变参数换位置
def f(a,*args,b=100):
    print(a,args,b)

f(10,20,30,40,50)#10 (20, 30, 40, 50) 100
# 当默认参数在可变参数后，如果想要改变默认参数的值，在调用函数中使用关键字参数
f(10,20,30,40,50,b=400)#10 (20, 30, 40, 50) 400

可变（字典）参数：参数：**kwargs，如果在调用函数中出现新的实参（使用关键字）而形参中没有，想要打印出，要赋给形参的**kwagrs，也就是可变字典参数

def f(a,b,*agrs,**kwargs):
    print(a,b,agrs,kwargs)

f(10,20,30,40,50,c=200,d=300)#10 20 (30, 40, 50) {'c': 200, 'd': 300}
#如果在调用函数中出现新的实参（使用关键字），想要打印出，要赋给形参的**kwagrs，也就是可变字典参数
#这里的关键字不能是形参，也就是形参中没有的

def f(a,*agrs,b=1,**kwargs):
    print(a,b,agrs,kwargs)

f(10,20,30,40,b=50,c=200,d=300)

结果

10 20 (30, 40, 50) {'c': 200, 'd': 300}
10 50 (20, 30, 40) {'c': 200, 'd': 300}

4、匿名函数

匿名函数：

不需要名字
lambda 冒号左边是形参，冒号右边是函数体，只支持简单的表达式，不重复赋值（例如：lambdax,y:x+y,x*y 这种表达是错误的）

f = lambda x:x+100
print(f(100)) # x=100
f = lambda x,y:x*y
print(f(10,40)) # x=10,y=40

f= lambda :print("醒醒")
f()

结果

200
400
醒醒

5、递归函数

递归函数：自己调用自己，递归要有出口；递归有深度限制

#1+2+3+......+100
# 100+f(99)
# 100+99+f(98)
# .....
# 3+f(2)
# 2+f(1)
# 2+1
def f(n):
    if n == 1:
        return 1
    else:
        return n+f(n-1)
a= f(100)
print(a)

结果

5050

import sys
sys.setrecursionlimit(2000)
print(sys.getrecursionlimit())

结果

2000

6、装饰器

闭包（将函数包装起来）三要素：

外部函数嵌套内部函数

外部函数返回内部函数的值

内部函数可以访问和保存外部函数的局部变量

def f1():
        i = 0
        rint("f1")
        def f2():
                nonlocal i#用nonlocal可以修改外部函数局部变量，golbal 是修改函数外部的变量
                i+=1
                print("f2",i)#访问外部局部变量
        return f2
a = f1()#return 返回的是f2 所以结果是f2 f1正常打印
a()

结果

f1
f2 1

装饰器有五大步骤：

1、定义基本函数

def index():

        print("欢迎来到首页")

index()

2、编写闭包函数

def login_requiered(f):

        def f1():

                pass

        return f1

a = login_requiered()

a()

3、使用闭包加工函数

def login_requiered(f):

        def f1():

                f()

        return f1

a = login_requiered(index)

a()

4、给闭包添加权限效验

def login_requiered(f):

        def f1():

                username = input("输入用户名")

                if username=="admin":

                        f()#这个调用的是开始写的基本函数

                else:

                        print("用户效验失败")

        return f1

a =login_requiered()

a()

5、函数调用

def login_requiered(f):

        def f1():

                username = input("输入用户名")

                if username=="admin":

                        f()#这个调用的是开始写的基本函数

                else:

                        print("用户效验失败")

        return f1

@login_requiered

def index():

        print("欢迎来到首页")

index()

def login_requiered(f):
    def f1():
        username = input("输入用户名")
        if username =="admin":

            f()#这个调用的是开始写的基本函数

        else:
            print("用户效验失败")
    return f1
@login_requiered
def index():
    print("欢迎来到首页")
index()

7、内置函数

#计算长度
l = [1,2,3,4]
print(len(l))
#取绝对值
print(abs(-5))
#all有一个是假，结果就是假，括号内容是可迭代的
print(all([10,2,False]))
#any 有一个是真结果就是真，两个都是假结果才是假
print(any([0,1]))
#bin 十进制转二进制
print(bin(10))
#chr是ASCII码转换
print(chr(97))
#Return the tuple (x//y, x%y)
print(divmod(100,3))

4
5
False
True
0b1010
a
(33, 1)

#取最大值
print(max([10,20,100]))
print(max([{"age":20},{"age":10}],key=lambda x:x["age"]))
print(min([{"age":20,"age":10}],key=lambda x:x["age"]))

100
{'age': 20}
{'age': 10}

import math
# #求次方2的3次方
print(math.pow(2,3))
#向上取整
print(math.ceil(3.4))
#向下取整
print(math.floor(3.4))
#四舍五入
print(round(3.6))
#排序，升序
print(sorted("gshdf"))
#求和
print(sum(i for i in range(10)))

8.0
4
3
4
['d', 'f', 'g', 'h', 's']
45

总结

函数是计算机程序中的一个重要概念，它是一段可重复使用的代码块，用于执行特定的任务或完成特定的操作。函数可以接受输入参数，经过处理后产生输出结果，将代码模块化、简化和重复利用。