Python编程学习-基础笔记04

六、函数

6.1 函数基础

6.1.1 函数定义

''''
函数：复用
格式：
def 函数名([参数]，...)
    代码

sample：
def get_name():
    pass
def search():
    pass

代码：
    封装重复内容
函数调用：函数名()
'''
import random
def gernerate_code():
    # 定义一个空字符串
    ver_code = ''
    # 准备一个字符串，包含字母和数字
    source = 'QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm1234567890'
    for i in range(4):
        # 可以直接随机取一个字符
        r = random.choice(source)
        # 将每次获取到的值拼接为4为的字符串
        ver_code += r
    print(ver_code)

print(gernerate_code) #<function gernerate_code at 0x0000020BCFE3C2F0>
'''
定义一个login函数
用户名：admin，密码：123456
验证用户名和密码是否正确
'''
def login():
    while True:
        #输入用户名或手机号
        login_name = input("请输入用户名/手机号：")
        passwd = input("请输入密码：")
        if login_name == 'admin' and passwd == '123456':
            break
            print('登录成功')
        else:
            print('用户名或密码有误，请重新输入')

#验证函数是否可用？调用函数
gernerate_code()
login()

6.1.2 带参数的函数

'''
参数：
    1，无参数
    2，有参数
无参数：
def 函数名()
    代码
有参数：
def 函数名(参数1，参数2，...)
    代码
参数就是在调用函数时，往函数体内传值
默认值参数：在定义函数的时候，有一个或多个参数已经赋值好
    def 函数名(参数1，参数2，参数3=值，参数4=值):
        pass
    调用特点：
        函数名(值1，值2，值3)
    注意：
        定义函数时，普通参数要位于默认值参数前面
        调用时，默认参数顺序时定义时的顺序，可以指定关键字参数赋值，改变顺序
'''
#login 带参数，n表示允许输入的错误此次数
def login(n):
    m =0
    while m < n:
        m += 1
        #输入用户名或手机号
        login_name = input("请输入用户名/手机号：")
        passwd = input("请输入密码：")
        if login_name == 'admin' and passwd == '123456':
            break
            print('登录成功')
        else:
            print('用户名或密码有误，请重新输入')
#数字累加函数1 - n
def accumulation(n):
    sum = 0
    m = 0
    while m <= n:
        sum += m
        m += 1
    print(sum)

#带默认值的函数，number和school带默认值，不传入参数时，使用默认值
def borrow_book(bookname,username,number=1,school='天大'):
    print(f'欢迎进入{school}借书系统>>>>>>')
    print(f'{username}借阅了{bookname},共{number}本')
#函数调用
# login(3)
accumulation(10)
borrow_book('Forrest','红楼梦') #红楼梦借阅了Forrest,共1本
borrow_book(username='Forrest',bookname='红楼梦') #Forrest借阅了红楼梦,共1本
borrow_book('Forrest','红楼梦',2) #红楼梦借阅了Forrest,共2本
#普通参数也带上关键字后，默认参数不能直接给值
borrow_book(username='Forrest',bookname='红楼梦',number=2,school='北大') #SyntaxError: positional argument follows keyword argument

可变参数：参数类型为列表，元组和集合

'''
参数类型：
1，列表
2，可变参数:
    *args
    **kwargs
3，装包和拆包 --> 对应可变参数
    装包:函数装包的过程，定义函数是，参数加星*
    def 函数(*args): --> 此时函数会出现装包
        pass
    拆包：函数拆包的过程，调用函数时，参数加星*, 拆列表，元组和集合
    调用函数时：
        函数(*list) | 函数(*tuple) |函数(*set)
'''
#验证示例讲解
#参数和变量个数相等
a,b,c = 1,2,3
print(a)
print(b)
print(c)
#参数和变量个数不等，带星号的表示一个容器，多余的参数都给带星的
a,*b,c = 1,2,3,4,5,
print(a)
print(b) #[2, 3, 4]
print(c)
#参数和变量个数不等，带星号的表示一个容器，多余的参数都给带星的
*a,b,c = (1,2,3,4,5)
print(a) #[1, 2, 3]
print(b)
print(c)
#参数类型为列表
list1 = [1,5,66,34,22,7,77,89,100,25,50]
#从列表中删除小于50的数，list_1-->形参，可以随便定义
def del_from_list(list_1):
    n = 0
    while n < len(list_1):
        if list_1[n] < 50:
            list_1.remove(list_1[n])
        else:
            n += 1
    print(list_1)
#可变参数，重写求和函数,*星号是关键，装包，之后的变量名可以任意，但通常用args
def get_sum(*args):
    s = 0
    for i in args:
        s += i
    print(s)
#函数调用,list1 实参
del_from_list(list1)
get_sum(1,2) #参与会以元组的形式赋值给变量
get_sum(1,2,3,4,5)
#调用是加*，星号表示拆包
get_sum(*list1) #382

可变参数：带2颗星的情况, 同时有1颗星 和2颗星的情况

'''
可变参数：**kwargs， 关键字参数
在函数调用时必须传递关键字参数，才可以转换为key:value,装载到字典中
'''
#key word
def show_book(**kwargs):
    print(kwargs)

#同时带了*args 和 **kwargs
def show_story(*args,**kwargs):
    print(args) #()
    print(kwargs) #{}
#调用函数
show_book() #{}
# show_book('红楼梦') #TypeError: show_book() takes 0 positional arguments but 1 was given
#可以加多个关键参数
show_book(bookname='红楼梦',author='曹雪芹') #{'bookname': '红楼梦', 'author': '曹雪芹'}
#拆包,必须加2颗星
book = {'bookname': '红楼梦', 'author': '曹雪芹'}
show_book(**book) #{'bookname': '红楼梦', 'author': '曹雪芹'}

#带* ** 的情况
show_story('小红','小花') #('小红', '小花')
show_story('小红','小花', story='星际联邦')
'''
('小红', '小花')
{'story': '星际联邦'}
'''
#字符拼接,'-' 以此为分隔符
result = ''.join(['a','b','c'])
print(result) #abc
result = '-'.join(['a','b','c'])
print(result) #abc

6.2 函数应用

6.2.1 函数注释

'''
在函数体内加上注释，给使用函数的人以提示信息
'''

6.2.2 函数返回值

return 会结束函数调用，并返回值。return不仅会结束循环，还会结束函数

'''
参数：外界向函数内传值
返回值：函数里面的内容值向往传递
def function():
    ...
    return xx
当函数调用时，通过return向往返回值
注意: 只有函数有返回值，外部需要有变量来接收
     return 后可跟一个或多个值，逗号分隔
     如果时多个值，返回的是一个元组，多个值被封装在元组中
        示例： retur a,b,c
            结果 (a,b,c)
'''
#将计算结果作为返回值，返回一个值
def get_sum(*args):
    s = 0
    for i in args:
        s += i
    #返回计算结果
    return s

#返回多个值
def get_max_min(numbers):
    #先排序：冒泡排序
    for i in range(len(numbers)-1):
        for j in range(0,len(numbers)-1-i):
            if numbers[j]>numbers[j+1]:
                numbers[j],numbers[j+1] = numbers[j+1],numbers[j]
    #获取头和尾
    min = numbers[0]
    max = numbers[-1]
    #返回
    return min,max
#在外部定义一个变量total来接收函数的返回值
total = get_sum(1,2,3,5)
x = 100
x = x + total
print(x) #111

list1 = [3,8,6,11,25,43,66,89,36,77,99,66]
#return返回2个值(min,max)，使用2个变量来接收
min,max = get_max_min(list1)
print(min,max)

6.3 函数高级

6.3.1 全局变量和局部变量

全局变量：声明在函数外部的变量
局部变量：声明在函数内部的变量，使用范围仅限于函数内部

'''
全局和局部变量：
    全局变量：声明在函数外部的变量
    局部变量：声明在函数内部的变量，使用范围仅限于函数内部
    注意：
        函数内部可以直接使用全局变量，但是不能直接修改全局变量
        如果想修改全局变量，则必须使用关键字 global
    global 关键字的添加：
'''
a = 100
def test1():
    #局部变量，函数优先使用
    a = 0
    b = 8
    print('a = ',a)
    print('b = ',b)
def test2():
    #局部变量，函数优先使用，如果函数体内定义的同名的变量
    b = 8
    #这里取到的a就是全局变量a
    print('a = ',a)
    print('b = ',b)
def test3():
    #声明a为全局变量
    global a
    #如果部声明a为全局变量，函数内部无权操作a
    a -= 10
    #这里取到的a就是全局变量a
    print('a = ',a)
#函数调用
test3()
test1()
test2()

6.3.2 可变和不可变类型

'''
全局和局部变量：
global 关键字的添加：
    只有不可变的类型，才需要添加关键字global
    可变类型，不需要添加关键字global
可变和不可变类型：
    不可变：当改变变量值时，地址发生了改变
        类型：int， str，float,bool, tuple
    可变：内容发生改变，但是地址没有发生改变
        类型：list, dict, set
'''
#可变变量
library = ['红楼梦','水浒传','西游记','三国演义']
print(id(library)) #2425797567112
library.append('窦娥冤')
print(id(library)) #2425797567112
#不可变变量
a = 100
print(id(a)) #140712806182832
a = 80
print(id(a)) #140712806182192
s = 'abc'
print(id(s)) #1698608322912
s = 'def'
print(id(s)) #1698608946848
t1 = (1,2,3)
print(id(t1)) #1908556126968
t1 = (1,2,3,4)
print(id(t1)) #1908556105112
#添加图书
def add_book(bookname):
    if bookname not in library:
        library.append(bookname)
        print(f'{bookname}添加成功')
    else:
        print('此书已经存在')
#展示全部图书
def show_books(books):
    for book in books:
        print(book)
#函数调用
add_book('西厢记')
show_books(library)

6.3.3 引用及参数值传递

'''
引用：
1，不是在函数中使用，可以通过sys.getrefcount(a)查看引用个数
    del 变量名 --> 表示删除了一个引用
2，函数的引用：
    必须要分清传递的值是可变还是不可变类型
    如果可变，里面发生改变，外层可以看到改变后的内容
    如果是不可变，里面发生改变，不会影响外部的变量值
'''
import sys

list1 = [1,2,3,4,5]
list2 = list1 #list1 将其引用地址给list2赋值
list3 = list1
#获取变量被引用的次数,这里查的是地址
print(sys.getrefcount(list1)) #4
del list2
print(sys.getrefcount(list1)) #3

def test(n1):
    #n1是局部变量
    for i in range(n1):
        print('--->',i)
    n1 += 1  # 这里改变的只是局部变量的值

n = 9
#调用test
test(n)
print(n) #9

def test1(l):
    #判断传入的是列表
    if isinstance(l,list):
        for i in l:
            print(i)
        #在第0个位置插入新的值
        l.insert(0,8) #可变参数，改变的是全局参数值
    else:
        print('不是列表类型')

#调用test1
test1(list1)
print(list1) #[8, 1, 2, 3, 4, 5]

6.3.4 练习：停车计费系统

'''
停车计费数据结果：
[{'车牌'：[进入时间，0]},{'车牌'：[进入时间，出场时间]}]
15分钟 1元
1小时 4 元

停车场变量--> 全局变量
'''
import  random
#初始化停车场数据
car_park = []
#记录车辆入场停车，车牌和时间
def veh_enter():
    print('欢迎进入AAA停车场')
    plate = input('请输入车牌号：').strip()
    #构建结构{'车牌'：[0，5]}
    car = {}
    car[plate] = [0]
    #添加到car_park
    car_park.append(car)
    print(f'欢迎{plate}入场停车！')
#记录车辆出场，车牌和时间
def veh_exit():
    #出场扫描
    plate = input('请输入车牌号：').strip()
    #判断此车是否有入场记录
    for car in car_park:
        if plate in car:
            #记录出场时间
            time = random.randint(0,24)
            time_record = car.get(plate)
            time_record.append(time)
            #计算费用,退出循环
            total = time * 4
            print(f'{plate}停车{time}小时，应缴费：{total}元')
            break
    else:
        print(f'{plate}没有入场记录！')
#调用
veh_enter()
veh_exit()

6.4 闭包

函数只是一段可执行代码，编译后就固化了，每个函数在内存中只有一份实例，得到函数入口点便可执行。函数还可以嵌套函数，即函数内部可以定义另一个函数，这就会产生闭包的问题。

'''
函数嵌套：
变量查找顺序：内层函数 --> 外层函数 --> 全局 --> 系统 builtins
闭包：
1，是嵌套函数
2，内部函数引用了外部函数变量
3，返回值是内部函数
'''
#嵌套
def outer():
    a = 100
    def inner():
        b = 200
        # b += a  #内部函数可以使用外部函数的变量，但是不能改变外部变量
        #如果想修改外部变量，需要在内部函数中加上： nonlocal
        nonlocal a
        a += b #内部函数不能改变外部变量
        print('这是内部函数',b)
    result = locals() #locals()表示查看函数中的局部变量,以字典形式返回
    print(result) #{'a': 100, 'inner': <function outer.<locals>.inner at 0x000001E39698E730>}
    #调用inner
    inner() #这是内部函数 300
#函数调用
outer()

#闭包 = 函数块 + 引用环境
def outer1(n):
    a = 10
    def inner():
        b = a + n
        print('内部函数：',b)
    return inner

r = outer1(5)
print(r) #<function outer1.<locals>.inner at 0x0000020177D0E7B8>
r() #内部函数： 15

6.5 装饰器

6.5.1 装饰器基础

'''
装饰器：
遵循开放封闭原则,在不改变原函数的情况下，扩展了函数功能
定义：
def xxx(func):
    def xxx():
        ...
        func()
        ...
        return xxx
    return yyy
装饰：
@装饰器名  #原函数 = 装饰器名(原函数)
def 原函数():
    pass
功能：
1，引入日志
2，函数执行时间统计
3，执行函数前的预备处理
4，执行函数后的清理功能
5，权限校验等场景
6，缓存
'''
#定义一个装饰器
def decorator(func):
    print('------------->1')
    def wraper():
        func() # 先执行外部函数 house
        print('刷漆')
        print('铺地板')
        print('软装')
        print('精装房')
    print('------------->2')
    return  wraper

@decorator #开始调用decorator,house = decorator(house) 先执行打印 ------------->1 ------------->2
def house(): #将house作为变量传入，类似 func = house
    print('毛坯房')
#调用函数
house()
'''
执行结果：
------------->1
------------->2
毛坯房
刷漆
铺地板
软装
精装房
'''

6.5.2 带参数的装饰器

'''
带参数的装饰器：
如果原函数有参数，装饰器内部也要有参数
'''
#定义一个装饰器,*args,**kwargs 可以接任意变量
def decorator(func):
    def wraper(*args,**kwargs): #address = ’北京‘,*args是一个元组
        func(*args,**kwargs) # func 就是 house
        print('刷漆')
        print('铺地板')
        print('软装')
        print('精装房')
    return  wraper

@decorator #开始调用decorator
def house(address): #将house作为变量传入，类似 func = house
    print(f'位于{address}的毛坯房')

@decorator #开始调用decorator
def workplace(address,area):
    print(f'位于{address}的毛坯房,面积{area}平米')

@decorator #开始调用decorator
def hotel(name,address,area=40):
    print(f'{name}酒店，位于{address}的毛坯房,单间面积{area}平米')
#调用函数
house('北京') # house 就是 wraper

workplace("北京通州",1000)

hotel('全季',address='北京') #如果没有**kwargs 运行会报错

6.5.2 带返回值的装饰器

'''
装饰器修饰有返回值的函数：
原函数有返回值，装饰器内部函数也需要返回值
'''
#定义一个装饰器,*args,**kwargs 可以接任意变量
def decorator(func):
    def wraper(*args,**kwargs): #address = ’北京‘,*args是一个元组
        r = func(*args,**kwargs) # func 就是 house
        print(f'预计费用是：{r}元')
        print('刷漆')
        print('铺地板')
        print('软装')
        print('精装房')
        return 60000 # 原函数有返回值，wrapper也需要返回值
    return  wraper
@decorator #开始调用decorator
def house(address): #将house作为变量传入，类似 func = house
    print(f'位于{address}的毛坯房')
    return 50000
#调用函数
house('北京') # house 就是 wraper

6.6 递归函数

如果一个函数在内部不调用其他任何函数，而是自己本身的话，这个函数就是递归函数。

'''
如果一个函数在内部不调用其他任何函数，而是自己本身的话，这个函数就是递归函数
遵循：
1，必须要有出口
2，每次递归，要向出口靠近

'''
#
def test():
    print('----------test-----------')
    # 调用a()
    a()

def a():
    print('----------aaaa-----------')
    #调用a()
    a()


# 调用a()
# a()

#打印数字1-10，递归函数实现
def num(i):
    if i == 10:
        print(i)
    else:
        print(i)
        i += 1
        num(i)

#调用num(),从1开始
# num(1)

#数字1-10的累加和，递归函数实现
total = 0
def sum(i):
    global total
    if i == 11:
        print('over',total)
    else:
        total += i
        i += 1
        sum(i)
#使用返回值求累加
def sum1(i):
    if i == 10:
        return 10
    else:
        return i + sum1(i+1)  # 逐层向下递归，但是到最后i=10之后才有返回，然后再逐层返回值进行计算
#调用sum(),从1开始
# sum(1)

r = sum1(1)
print(r)

6.7 匿名函数

6.7.1 匿名函数定义

'''
用lamda关键词可以创建小型匿名函数，省略了def声明函数的标准步骤
匿名函数定义格式：
lamda 参数列表：返回值表达式
'''
#定义标准函数
def test(a):
    return a+1
#使用变量来接收函数返回值
result = test(5)
print(result)

#定义匿名函数，由于没有函数名，使用r来接收
r = lambda a:a+1
result = r(6)
print(result)

#定义匿名函数，多个参数
r = lambda x,y: x+y
result = r(6,7)
print(result)

6.7.2 匿名函数的使用场合

'''
匿名函数的使用场合：
匿名函数作为参数来使用
'''
#定义标准函数
def test():
    print('------test------')
def func(a,f):
    print('--------->',a)
    f()
#使用变量来接收函数返回值
func(5,test)

def func1(a,f): #lambda x:x**2
    print('>>>>>>>>>>',a)
    r = f(a)
    print('=====>',r)

#调用func1，因为f带返回值，这里用匿名函数来赋值，多数情况，匿名函数放在参数位置
func1(8,lambda x:x**2)

6.8 高阶函数

函数可以作为变量来使用。既然变量可以指向函数， 函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数。同样，可以把一个函数作为另一个函数的返回值。这种函数的使用方式，称之为高阶函数。

'''
高阶函数：
    一个函数的参数是另一个函数
系统高阶函数：
    max,min,sorted, filter,map,reduce
'''
#普通查找最大值
from functools import reduce

m = max(5,6)
print(m)

#列表内查找最大值
m = max([2,5,8,3,11,56,39,22])
print(m)

#匿名函数，找最大年龄
list1 = [('Lily',25),('Tony',19),('Jessy',21),('Tomas',28),('Lucy',26),('Rose',29)]
m = max(list1,key= lambda x:x[1])
print(m)

#找最小年龄
m = min(list1,key= lambda x:x[1])
print(m)

#按年龄排序
m = sorted(list1,key= lambda x:x[1])
print(m) #[('Tony', 19), ('Jessy', 21), ('Lily', 25), ('Lucy', 26), ('Tomas', 28), ('Rose', 29)]

#按年龄排序,倒序
m = sorted(list1,key= lambda x:x[1],reverse=True)
print(m) #[('Rose', 29), ('Tomas', 28), ('Lucy', 26), ('Lily', 25), ('Jessy', 21), ('Tony', 19)]

#过滤 大于20岁的，lambda 返回值是真或假，返回值必须是bool类型，结果为True才符合过滤条件
m = filter(lambda x:x[1]>20,list1)
print(m) #<filter object at 0x0000020A2EDED748>, 返回的是可迭代对象
#将m强转为list
print(list(m)) #[('Lily', 25), ('Jessy', 21), ('Tomas', 28), ('Lucy', 26), ('Rose', 29)]

#映射map,通过匿名函数指明提取内容，并对内容进行加工
ma = map(lambda x:x[1]+1,list1)
print(ma) #<map object at 0x000001FF6FCEE710>
print(list(ma)) #[26, 20, 22, 29, 27, 30]

ma = map(lambda x:x[0].title(),list1)
print(ma) #<map object at 0x0000013E7233E860>
print(list(ma)) #['Lily', 'Tony', 'Jessy', 'Tomas', 'Lucy', 'Rose']

#reduce,对一个序列进行压缩运算，最后得到一个值
r = reduce(lambda x,y:x+y,[1,2,3,4,5])
print(r) #15