小白学习笔记之跟着B站大佬的笔记内容

虽然文心一言用着不能帮忙写代码，但是他的思路啥的很好看，而且错因翻译的也很好，讲的很清楚，还是很好用的

最近主攻python学习，其实此外也学了Java和c，也开始看了点web前端，但还是以python为主，等把大佬的教学视频看完了我再认真开始钻研其他的

# def func():
#     def inner():
#         print(123)
#     print(inner)
#     return inner  #返回的是一个函数，并且不是inner（），如果是带括号则被执行返回none
# b1 = func()  #b1是func的内部inner
# print(b1) #把函数当成一个变量返回
# b1()
#
# def an():
#     print(123)
# an()
# bn = an
# bn()#把函数当成一个变量即可
#
#
# #代理函数
# def func2(an):#此时an收到的是一个函数
#     an() #执行这个函数
# def target():
#     print("我是target")
# c = 456
# func2(target) #实参可以是函数
# """
#  综上*****函数可以作为返回值返回
#  函数可以作为参数互相传递
#  函数实际上就是一个变量名，都表示一个内存地址
#  """
#
# """
# global :在局部，引入全局变量
# nonlocal :在局部，引入外层的局部变量 def中的def
#  向外找一层，看看有没有该变量，如果有就引入，如果没有继续向外一层，直到全局但是不包括全局
# """
# a = 10
# def func():
#     global a #把全局变量引入到局部
#     a = 20   #仅有这句的话创建一个局部变量，并没有去改变全局变量中的a
# func()
# print(a)
#
# """
# 闭包：本质，内层函数对外层函数的局部变量的使用，此时内层函数被称为闭包函数
#   1、可以让一个变量常驻于内存
#   2、可以避免全局变量被修改
# """
# def func():
#     a = 10
#     def inner():#则有inner为闭包函数
#         print(a)#a常驻于内存
#         return a
#     return inner
# ret = func()   #inner=>ret=>什么时候执行
#
# def func():
#     a = 0
#     def add():
#         nonlocal a
#         a += 1
#         return a
#     return add
# print(func()())#在全局操控了局部变量
# print(func()())
#
# ret = func()
# r1 = ret()
# print(r1)
# r2 = ret()
# print(r2)
#
# """
# 函数可以作为参数进行传递
# 函数可以作为返回值进行返回
# 函数名称可以被当成变量一样被赋值操作
#
# 装饰器：->记住最后的结论
#     本质上是一个闭包
#     在不改变原有函数调用的情况下，给函数增加心得功能
#     可以在函数前后添加新功能但是不改变代码
#
# 在用户登录的地方，日志
#
# 通用装饰器的写法：
#     def wrapper(fn):#fn是目标函数，wrapper：装饰器
#         def inner(*args,**kwargs):
#         #在目标函数执行之前
#         fn(*args,**kwargs)
#         #在目标函数执行之后
#         return ret
#     return inner #加括号是把内存函数执行的结果返回，不加括号是把内存函数返回
#     一个函数可以被多个装饰器装饰
# """
# def func():
#     print('我是函数')
# def ggg(fn):#fn要求是个函数
#     fn()
# ggg(func)
#
# def func():
#     def inner():
#         print('123')
#     return inner()
# ret = func()
#
# def func1():
#     print('我是函数1')
# def func2():
#     print('我是函数2')
# func1 = func2
# func1()
#
# def guanjia(game):#参数即局部变量
#     def inner():
#         print('开外挂')
#         game()
#         print("关闭外挂")
#     return inner
# @guanjia       #相当于play_lol = guanjia(play_lol)
# def play_lol():
#     print("德玛西亚！")
# play_lol()
#
#
#
# def guanjia(game):
#     # *，**表示接受所有参数，打包成元组和字典
#     def inner(*args,**kwgargs):#inner添加了参数，args一定是一个元组，kwargs一定是字典
#         print("打开外挂")
#         # *,**表示args元组和kwargs字典打散成位置参数以及关键字参数传递进去
#         game(*args,**kwargs)
#         print('关闭外挂')
#     return inner
# @guanjia
# def play_lol(username,password,hero):
#     print("开始玩",username,password,hero)
#     print('比尔吉沃特你的国王回来了')
#
# """
# 通用装饰器的写法：
#     def wrapper(fn):#fn是目标函数，wrapper：装饰器
#         def inner(*args,**kwargs):
#         #在目标函数执行之前
#         ret = fn(*args,**kwargs) #执行目标函数
#         #在目标函数执行之后
#         return ret
#     return inner #加括号是把内存函数执行的结果返回，不加括号是把内存函数返回
#     @wrapper
#     def target():
#         pass
# """
# def wrapper1(fn):  # fn:target
#     def inner(*args, **kwargs):
#         print('这里是wrapper1，进入')
#         ret = fn(*args,**kwargs)
#         print('这里是wrapper1，出去')
#         return ret
#     return inner
# def wrapper2(fn):
#     def inner(*args,**kwargs):
#         print('这里是wrapper2，进入')
#         ret = fn(*args,**kwargs)
#         print('这里是wrapper2，出去')
#         return ret
#     return inner
#
# @wrapper1#                                                    后
# @wrapper2#target = wrapper2(target) =>target:wrapper2.inner   先
# def target():
#     print("我是目标")

# target()

"""规则和规律 wrapper1 wrapper2 target wrapper2 wrapper1"""

# 再新增、刪除、添加前后必须进行登陆调研适合用装饰器

login_flag = False
def login_verify(fn):
    def inner(*args, **kwargs):
        global login_flag  # 拉进来
        if login_flag == False:
            # 这里完成登录校验
            print("还未完成用户登陆操作")
            while 1:
                username = input(">>>")
                password = input(">>>")
                if username == "R" and password == "123654":
                    print("登陆成功")
                    login_flag = True
                    break
                else:
                    print("登陆失败，用户名或密码错误")
        ret = fn(*args, **kwargs)  # 后续程序的执行
        return ret
    return inner

@login_verify
def add():
    print("添加员工信息")

@login_verify
def delete():
    print("删除员工信息")

@login_verify
def upd():
    print("修改员工信息")

@login_verify
def search():
    print("查询员工信息")
# add()  # 登陆状态未被保存
# delete()

"""
for 变量 in 可迭代：
    pass
    
iterable:可迭代的东西
iterator：迭代器
str list tuple dict set open()
stopiteration:迭代已被停止，不可再从迭代器中拿东西了

可迭代的数据类型都会提供一个叫迭代器的东西，这个迭代器可以帮我们把数据类型中的所有数据逐一拿到

获取迭代器的两种方案：
    1、iter（）内置函数可以拿到迭代器
    2、__iter__() 特殊方法

从迭代器中拿到数据：
    1、next（）内置函数
    2.__next__（） 特殊方法
"""

it = iter("我叫R")
print(it)
# <str_iterator object at 0x0000027685C9A110>
print(next(it))  # 我
print(next(it))  # 叫

it2 = "好像是".__iter__()
print(next(it2))
print(it2.__next__())

# 模拟for循环的工作原理
s = "我是数据"
it = iter(s)  #拿到迭代器

while 1:
    try:  # 尝试运行里面的代码
        data = it.__next__()
        print(data)  # for循环的循环体
    except StopIteration:  # 如果出的错是StopIteration则：
        break
"""
try:
    pass
except 出的问题:
    break
是固定搭配
"""

# for里面一定是要拿迭代器的，所有不可迭代的东西不能用for循环
# for循环里面一定有__next__出现


# 总结：迭代器统一了所有数据类型的遍历工作  让不同的数据类型有了相同的遍历方式
"""
迭代器本身也是可迭代的

迭代器本身的一些特性：
    1、只能向前不能反复
    2、特别省内存
    3、惰性机制：只要不访问其next，他就不会向前挪
"""
s = "你好啊大聪明"
it = s.__iter__()
for i in it:
    print(i)

"""
生成器：generator
    生成器的本质就是迭代器
    
    创建生成器的两种方案：
        1、生成器函数
        2、生成器表达式
        
    生成器函数
        生成器函数中有个关键字：yield  函数中return-->yield
        生成器函数执行时， 并不会执行函数， 得到的是生成器
        
        yield：只要函数中出现了，他就是一个生成器函数
            作用：
                1、可以返回数据
                2、可以分段执行函数中的内容，通过__next__()可以执行到下一个yield的位置
        优势：
            用好了，特别节省内存
"""
def func():
    print(156)
    yield 2477  # yield也有返回的意思，
ret = func()
print(ret)  # <generator object func at 0x0000020ADBB76200>
print(ret.__next__())  # yield只有在执行到next的时候才会返回数据
# print(ret.__next__())  # stopiteration

def func3():
    print(123)
    yield 666
    print(555)
    yield 789

ret = func3()
print(ret.__next__())
print(ret.__next__())

# # 去工厂定制一万件衣服
# def order():
#     lst = []
#     for i in range(10000):
#         lst.append(f"衣服{i}")
#     return lst
# lst = order()
# print(lst)  # 过大，占内存

def order():
    lst = []
    for i in range(10000):
        lst.append(f'衣服{i}')
        if len(lst) == 50:
            yield lst
            # 下次拿数据
            lst = []

gen = order()
print(gen)  # <generator object order at 0x000001F82589D380>
print(gen.__next__())
print(gen.__next__())