python学习笔记

今日内容概要

• 作业讲解

• 三元表达式

• 各种生成式

• 匿名函数

• 匿名集合内置函数使用

• 重要内置函数

今日内容详细

作业讲解

# 1.有参装饰器多种用户认证方式
data_list = ['jason|123', 'kevin|321', 'oscar|222']
def login_auth(condition):
    def outer(func_name):
        def inner(*args, **kwargs):
            username = input('username:').strip()
            password = input('password:').strip()
            if condition == 'absolute':
                if username == 'jason' and password == '123':
                    res = func_name(*args, **kwargs)
                    return res
                else:
                    print('不是本人 不允许执行')
            elif condition == 'list_type':
                for user_data in data_list:
                    real_name, real_pwd = user_data.split('|')
                    if real_name == username and real_pwd == password:
                        res = func_name(*args, **kwargs)
                        return rees
            elif condition == 'file_type':
                with open(r'userinfo.txt', 'r', encoding='utf8') as f:
                    for line in f:
                        real_name, real_pwd_n = line.split('|')
                        if real_name == username and password == real_pwd_n.strip('\n'):
                            res = func_name(*args, **kwargs)
                            return res
        return inner
    return outer

@login_auth('absolute')
def func1():
    print('from func1')
    return 1
@login_auth('list_type')
def func2():
    print('from func2')
    return 2
@login_auth('file_type')
def func3():
    print('from func3')
    return 3

func1()
func2()
func3()

# 2.递推回溯求某个人的年龄
def get_age(n):
    if n == 1:
        return 18
    return get_age(n-1) + 2
res = get_age(5)
print(res)

三元表达式

三元表达式是python为我们提供的一种简化代码的解决方案

语法结构：

值1 if 条件 else 值2

如果if后面的条件成立，则使用if前面的值

如果if后面的条件不成立，则使用else后面的值

"""三元表达式:仅限于二选一的情况并且不建议嵌套使用"""
# 编写一个函数，比较两个数的大小，返回较大的那个
def my_max(a, b):
   # if a > b:
   #     return a
   # else:
   #     return b
    return a if a > b else b  # 相当于上面的注释内容
res = my_max(1, 10)
print(res)

res = 123 if 10 > 5 else (222 if 0 else (666 if 1 == 2 else 666))
ps:在python中代码不是精简的越少越好，在精简的过程中还要保证代码的可读性

各种生成式

列表生成式

name_list = ['jason', 'kevin', 'oscar', 'jerry', 'tony']
    # 给上述列表中所有的数据值加上_NB的后缀
    # 1.定义一个新的列表
     new_list = []
    # 2.循环原列表中所有的数据值
     for name in name_list:
    # 3.拼接_NB后缀
     new_name = name + '_NB'
    # 4.追加到新列表中
     new_list.append(new_name)
     print(new_list)
    """一行代码解决:  列表生成式"""
     new_list = [name + '_NB' for name in name_list]  # 先执行for循环 然后将一个个的数据值交给for循环前面处理
     print(new_list)
    # 还支持if判断   先执行for循环 然后将一个个的数据值交给if判断 结果为True则最后交给for循环前面处理
     new_list = [name + '_NB' for name in name_list if name != 'jason']
     print(new_list)
    # 列表生成式中只能出现for和if

字典生成式

new_dict = {i: 'jason' for i in range(10) if i == 6}
print(new_dict)  # {6: 'jason'}

先执行for循环，然后将一个个数据交给if 条件进行判断，最后的结果返回给for的前面进行处理

集合生成式

new_set = {i for i in range(10) if i == 6}
print(new_set) # {6}

先执行for循环，然后将一个个数据交给if 条件进行判断，最后的结果返回给for的前面进行处理

针对元组没有所谓的生成式一说 它是后面重点讲解的迭代器知识(生成器)

new_tuple = (i for i in range(10))
print(new_tuple)  # <generator object <genexpr> at 0x000001E62B8ED740>

匿名函数

匿名函数就是没有函数名的函数

语法结构
	lambda 形参: 返回值
调用方法具体案例
   (lambda x: x + 1)(123)   # 直接调用
   res = lambda x: x + 1  # 命名调用
   print(res(123))
应用场景
	匿名函数通常都需要配合其他函数一起使用 用于减少代码

匿名集合内置函数使用

max() 方法返回给定参数的最大值，参数可以为序列。

如果值是字符串，则按字母顺序进行比较。

max()  # 求最大值
l1 = [223, 3423, 123, 24, 34, 35, 435, 3, 24, 3534, 53, 24, 234, 132, 4234, 456, 456, 5345, 4, 234, 345, 23, 2123432]
res = max(l1)
print(res)  # 2123432

dic = {
    'jason': 100,
    'aj': 123,
    'Bason': 9999999,
    'zero': 888
    }

def index(k):
    return dic.get(k)
# res = max(dic, key=lambda k: dic.get(k)) # for循环的是k值，比对的是返回的值
res = max(dic, key=index)
print(res)  # Bason


# print('A' > 'a')
"""
A-Z   65-90
a-z   97-122
"""

重要内置函数

min(): 函数返回给定参数的最小值，参数可以为序列。

如果值是字符串，则按字母顺序进行比较。

map()把一组数据经过处理变成了另一组数据，并且数据之间一一对应

l1 = [11, 22, 33, 44, 55, 66]
# 需求:将列表中所有的数据值自增20
# 方式1:for循环
# 方式2:列表生成式
# 方式3:map函数
res = map(lambda x: x + 20, l1) # 用了匿名函数
print(res)  # <map object at 0x000001954B581100>
print(list(res)) # [31, 42, 53, 64, 75, 86]
def index(a):  # 用的是自定义函数
    return a + 20
res = map(index, l1)
print(list(res)) # [31, 42, 53, 64, 75, 86]

filter()函数用于过滤序列，过滤掉不符合条件的元素，返回符合条件的元素组成新列表。

l1 = ['jason', 'kevin', 'oscar', 'tony']
# 需求:移除数据值里面的jason
# 方式1:for循环
# 方式2:列表生成式
# 方式3:filter()
res = filter(lambda a: a != 'jason', l1) # # 用了匿名函数
print(res)  # <filter object at 0x00000195F21E6C70>
print(list(res))  # ['kevin', 'oscar', 'tony']
def index(a):   # 用的是自定义函数
    return a != 'jason'
res = filter(index, l1)
print(list(res)) # ['kevin', 'oscar', 'tony']

reduce()是一个化整为零的过程，将很多单体变成一个整体

l2 = [1, 2, 3]
# 需求:求列表中所有数据值的和
# 方式1:for循环
# 方式2:sum()
res = sum(l2)
print(res) # 6
# 方式3:reduce()   将很多单体 变成一个整体
from functools import reduce
res = reduce(lambda x, y: x + y, l2, 100) # # 用了匿名函数
print(res) # 106

zip()函数来可以把 2 个或多个列表合并，并创建一个元组对的列表，元组对的数量以合并列表的最短长度为准。

n1 = [1, 2, 3]
n2 = ['jason', 'kevin', 'oscar']
res = zip(n1, n2)
print(res)  # <zip object at 0x000002A9E38C7F40>
print(list(res)) # [(1, 'jason'), (2, 'kevin'), (3, 'oscar')]

n1 = [1, 2, 3, 4]
n2 = [5, 6, 7, 8]
n3 = 'jack'
res = zip(n1, n2, n3)
print(list(res)) # [(1, 5, 'j'), (2, 6, 'a'), (3, 7, 'c'), (4, 8, 'k')]


n1 = [1, 2, 3, 4, 5, 6, 7]
n2 = [5, 6, 7, 8]
n3 = 'jason'
res = zip(n1, n2, n3)
print(list(res)) # [(1, 5, 'j'), (2, 6, 'a'), (3, 7, 's'), (4, 8, 'o')]

作业

def outter1(func1):
    print('加载了outter1')
    def wrapper1(*args, **kwargs):
        print('执行了wrapper1')
        res1 = func1(*args, **kwargs)
        return res1
    return wrapper1

def outter2(func2):
    print('加载了outter2')
    def wrapper2(*args, **kwargs):
        print('执行了wrapper2')
        res2 = func2(*args, **kwargs)
        return res2
    return wrapper2

def outter3(func3):
    print('加载了outter3')
    def wrapper3(*args, **kwargs):
        print('执行了wrapper3')
        res3 = func3(*args, **kwargs)
        return res3
    return wrapper3


@outter1
@outter2
@outter3
def index():
    print('from index')

1.先看紧挨@outter3语法糖的被装饰对象的函数名字，这里是index() 被当做形参传入了outter3，所以func3()=index(),然后运行打印加载了outter3得到返回值wrapper3

2.由于上面还有语法糖接着看@outter2语法糖，这里wrapper3被当做形参传入了outter2,所以func2()=wrapper3, 然后运行打印加载了outter2得到返回值wrapper2

3.由于上面还有语法糖接着看@outter1语法糖，这里wrapper2被当做形参传入了outter1,所以func1=wrapper2, 然后运行打印加载了outter1得到返回值wrapper1，由于到这里上面没有语法糖了，这里的wrapper1就等于真正的index()函数

4.接着调用index()函数=wrapper1运行打印执行了wrapper1，然后运行func1()，func1()=wrapper2

5.接着运行wrapper2打印执行了wrapper2，然后运行func2()，func2()=wrapper3

6.接着运行wrapper3打印执行了wrapper3，然后运行func3()，func3()是真正的index()函数

7.由于func3=index(), 所以打印from index

def outer(condition,type_user):
    def login_auth(func_name):  # 这里不能再填写其他形参
        def inner(*args, **kwargs):  # 这里不能再填写非被装饰对象所需的参数
            username = input('username>>>:').strip()
            password = input('password>>>:').strip()
            if type_user =='jason':print('VIP')
            if condition == '列表':
                print('使用列表作为数据来源 比对用户数据')
            elif condition == '字典':
                print('使用字典作为数据来源 比对用户数据')
            elif condition == '文件':
                print('使用文件作为数据来源 比对用户数据')
            else:
                print('去你妹的 我目前只有上面几种方式')
        return inner
    return login_auth
@outer('文件','jason')  # # 左侧是语法糖结构，右侧是函数名加括号结构，先执行函数调用'outer('文件','jason')',返回值是login_auth,再执行语法糖结构'@login_auth'
def index():
    print('from index')
index()

1.首先看outer函数，然后看@outer('文件')这个语法糖由于函数名加括号执行级别最高，先执行outer('文件')这部分，文件当做形参传入outer函数接着执行login_auth函数，得到返回值login_auth，再执行语法糖结构@login_auth

2.接着执行函数login_auth，将index传入login_auth函数，定义函数inner，得到返回值inner，将返回值赋值给index，接下来执行index函数相当于执行inner函数，获取用户名和密码，接收outer传来的参数进行判断接下来执行哪一步