无情摆烂我竟是cv怪物第四周周末总结

1.*args
    星号代表接收未被位置形参接收的额外的位置实参，无论有多少位置实参*args都可以将它全部接受
def func(*args):
     pass
func(1, 2, 3, 4, 5, 6, 7, a, b, c, d)
2.**kwargs
    双星号代表可以接收未被接收的关键字实参，同样也是无论有多少额外的关键字实参他都可以全盘接纳
def func（**kwargs）：
    pass
func(a=1, b=2, c=3, d=4)
3.*args和**kwargs一起使用
    可以将所有形式的实参统统接收但是必须位置形参在前关键字实参在后
def func（*args， **kwargs）:
    pass
func(7, 8, 9, a=1, b=2, c=3)


1.内置名称空间
    内置名称空间其实就是我们经常使用的一些无需我们定义的函数所被存储的空间叫做内置名称空间例如：
    int（）    float()     print()     input()等
2.全局名称空间
    全局名称空间其实就是我们经常用来存储我们自己定义的一些的变量名，函数名的空间叫做全局名称空间例如：
    name    age     func（）  outer（）等
3.局部名称空间
    局部名称空间其实就是我们在函数内部存储变量名或者函数名的内存空间叫做局部内存空间，局部内存空间可以
    无限嵌套，但是不建议这样做可能会将你的内存卡崩


1.在全局名称空间中寻找名字
    全局名称空间      >>>:        内置名称空间
2.在局部名称空间中寻找名字
    局部名称空间      >>>:        全局名称空间      >>>:        内置名称空间
3.在名称空间中寻找名字只能按照上方的顺序去寻找名称，如果没有的话就证明那个空间中没有该名称，这个寻找过程
不可逆


1.global修改全局名称空间中的变量
flower = 99
def branch():
    global flower
    flower = 520
    print(flower)
branch()
print(flower）
"""
520
520
"""
2.nonlocal修改局部名称空间的上层函数中的变量
def all():
    num = 99
    l1 = [1, 2, 3, 4]
    def nest():
        num = 520
        l1.append(666)
        def only():
            nonlocal num
            num = 521
            l1.append(999)
            print(num)
            print(l1)
        only()
        print(num)
        print(l1)
    nest()
    print(num)
    print(l1)
all()
"""
521
[1, 2, 3, 4, 666, 999]
521
[1, 2, 3, 4, 666, 999]
99
[1, 2, 3, 4, 666, 999]


1.闭包函数就是函数中嵌套一个函数内部函数使用必须要使用外部函数中的函数名或变量名的函数叫做闭包函数
def func(name):  # 首先创造一个函数并建一个参数
    # name = 'joseph'
    def index():  # 在函数中嵌套一个我们真正需要调用的额函数
        print(name)  # 我们想要在内函数中调用外函数的参数
    return index  # 返回值打印内函数

res = func('joseph')  # 返回的结果就是内函数
print(res)  # 打印一下func（）现在对应的是什么
res(）  # 调用上方函数
"""
<function func.<locals>.index at 0x000001F27B70A4C0>
joseph
"""


1.装饰器其实就是为了在不改变其原本调用方式和代码结构的情况下帮他添加新功能
2.最初计算机操作系统是32位，⽽时间也是⽤32位表⽰。
System.out.println(Integer.MAX_VALUE);
2147483647
Integer在JAVA内⽤32位表⽰，因此32位能表⽰的最⼤值是2147483647。
另外1年365天的总秒数是31536000，
2147483647/31536000 = 68.1
也就是说32位能表⽰的最长时间是68年，⽽实际上到2038年01⽉19⽇03时14分07秒，便会到达最⼤时间，过了这个时间点，所有32位操作
系统时间便会变为
10000000 00000000 00000000 00000000
也就是1901年12⽉13⽇20时45分52秒，这样便会出现时间回归的现象，很多软件便会运⾏异常了。
到这⾥，我想问题的答案已经出来了:
因为⽤32位来表⽰时间的最⼤间隔是68年，⽽最早出现的UNIX操作系统考虑到计算机产⽣的年代和应⽤的时限综合取了1970年1⽉1⽇作为
UNIX TIME的纪元时间(开始时间)，⽽java⾃然也遵循了这⼀约束。
⾄于时间回归的现象相信随着64为操作系统的产⽣逐渐得到解决，因为⽤64位操作系统可以表⽰到292,277,026,596年12⽉4⽇15时30分08
秒，相信我们的N代⼦孙，哪怕地球毁灭那天都不⽤愁不够⽤了，因为这个时间已经是千亿年以后了。


1.
import time  # 首先调用时间模块
def outer():  # 创造一个函数
    time.sleep(2)  # 睡眠时间为2秒
    print('joseph')  # 睡眠时间结束后打印joseph
start_time = time.time()  # 开始一个计数
outer()  # 调用outer开始运行，因为上方设置会停两秒所以两秒之后才会开始运行这个程序
end_time = time.time()  # 计算停止时间
print(end_time - start_time)  # 计算这程序从开始到运行结束一共花了多久
"""
joseph
2.011749267578125
当我们遇到多个类似条件时那么就会显得臃肿每个还是都需要写额外的
"""
2.
import time  # 首先调用时间模块
def again_outer():  # 创造一个函数
    time.sleep(5)  # 睡眠时间为5秒
    print('Joseph')  # 打印约瑟夫富歇
    start_time = time.time()  # 开始一个计数
    again_outer()  # 调用outer开始运行，因为上方设置会停两秒所以两秒之后才会开始运行这个程序
    end_time = time.time()  # 计算停止时间
    print(end_time - start_time)  # 计算这程序从开始到运行结束一共花了多久
"""
Joseph
5.009907007217407
"""
3.
import time  # 首先调用时间模块
def outer():  # 创造一个函数
    time.sleep(2)  # 睡眠时间为2秒
    print('joseph')  # 睡眠时间结束后打印joseph
def home():  # 创建一个新的函数
    time.sleep(4)  # 设定睡眠时间为4秒
    print('lili')  # 睡眠结束后打印莉莉
def get_time(x, *args,**kwargs):
    start_time = time.time()
    x(*args,**kwargs)
    end_time = time.time()
    print(end_time - start_time)
get_time(outer)
get_time(home)
"""
lili
4.0153868198394775
"""


1.终极版本装饰器模板，无脑套用
from functools import wraps
def outer(func_name):
    @wraps(func_name)  # 仅仅是为了让装饰器不容易被别人发现 做到真正的以假乱真
    def inner(*args, **kwargs):
        print('执行被装饰对象之前可以做的额外操作')
        res = func_name(*args, **kwargs)
        print('执行被装饰对象之后可以做的额外操作')
        return res
    return inner

import time

def home():
    time.sleep(1)
    print('from home')
    return 'home返回值'

home = outer(home)
res = home()
print(res)

"""

执行被装饰对象之后可以做的额外操作
home返回值
"""


@outer  #  home = outer(真正的函数名home)
def home():
    '''我是home函数'''
    time.sleep(1)
    print('from home')
    return 'home返回值'

help(home)
print(home)
home()

"""
home()
    我是home函数 我要热死了!!!

<function home at 0x000001D9F0F27820>
执行被装饰对象之前可以做的额外操作
from home
执行被装饰对象之后可以做的额外操作
"""


def outter1(func1):
    print('执行到outter1')
    def inner1(*args,**kwargs):
        print('被装饰对像result1执行前所打印的对象')
        result1 = func1(*args,**kwargs)
        print('被装饰对象result1执行后所打印的对象')
        return result1
    return inner1

def outter2(func2):
    print('执行到outter2')
    def inner2(*args,**kwargs):
        print('被装饰对像result2执行前所打印的对象')
        result2 = func2(*args,**kwargs)
        print('被装饰对象result2执行后所打印的对象')
        return result2
    return inner2

def outter3(func3):
    print('执行到outter3')
    def inner3(*args,**kwargs):
        print('被装饰对像result3执行前所打印的对象')
        result3 = func3(*args,**kwargs)
        print('被装饰对象result3执行后所打印的对象')
        return result3
    return inner3

@outter1  #  index = outter1（outter2）
@outter2  #  outter2 = outter2（outter3）
@outter3  #   outter3 = outter3(index)
def index():
    print('执行到index')

index()

"""
首先我们在一个三重装饰器三重语法糖中，调用最下层的函数index然后看到上方有语法糖那么就是
outer3 = outter3（index）因为这是个多重语法糖所以不能先执行这个函数，先到上方outer3的地方开始执行，
（执行到outer3）返回下方语法糖运行到第二层语法糖 outer2 = outer2（outer3）执行到outer2所以我们要去上
方函数outer处执行（执行到outer2）返回下方第三重语法糖index = outer1（outer2）所以我们又需要取上方第一
个函数寻找outer1执行（执行到outer1）执行完outer1终于到index开始执行inner1，return返回 inner1所打印的
结果执行前的值 执行到inner2返回值return inner2 打印inner2结果执行前的值，接下来走到inner3的函数，
inner3返回值return inner3 打印inner3结果执行前的值，正式执行到我们的函数index的步骤到上方找到result3
执行并得到返回结果打印执行后的对象，转向result2执行并得到返回结果打印执行后的结果，最后走到result1执行
并打印返回值。
"""


def outter(stdcall):
    def func(user_name):
        def inner(*args,**kwargs):
            name = input('请输入您的用户名>>>:').strip()
            pwd = input('请输入您的密码>>>:').strip()
            if stdcall == 'list':
                print('调用列表中的数据值进行判断')
                result = user_name(*args,**kwargs)
                return inner
            elif stdcall == 'dict':
                print('调用字典中的数据值进行判断')
                result = user_name(*args,**kwargs)
                return inner
            elif stdcall == 'a.txt':
                print('调用文件中的数据值进行判断')
                result = user_name(*args,**kwargs)
                return inner
            else:
                print('暂无该调用方式')
        return inner
    return func

@outter('list')
def index():
    print('通过index打印的值')
index()
"""
首先我们在下方调用index函数，到上方找到index开始执行，看到上方有装饰器语法糖@outer并且语法糖内部有实参
那么我们就需要先拿着这个实参去上方找到对应的函数位置并将内部实参传入内部与实参对应的形参stdcall并继续往
下执行到func函数得到func的返回值func函数自己本身开始执行func内部的代码，函数inner由inner接受两个实参
并继续往下执行，获取用户名的输入，获取用户密码的输入并且获取用户选择的数据存储地址进行对接验证，如果选择
列表那么我们从列表中获取数据那么我们就从列表调取数据并使用for循环进行比对，如果成功通过那么打印成功并收
到返回值inner的返回值，失败的话呢就给用户提示您输入的用户名或密码错误，如果使用字典进行判断的话那么我们
也是从字典取值进行比对如果成功则打印成功并收到inner的返回值失败还是打印用户名或密码错误，如果选择的是文
件的话就需要从文件中调取数据with open（r'a.txt''r'encoding=utf8）as f:调取值进行比对成功得到返回值失
败用户名或密码错误。
"""


1.1.在某些需要在相同类型中的复杂数据需要不断向内部取值直到取到某个值，我们就需要递归函数来取值
2.自己调用自己
def func():
    print('调用了func')
    func()
func()
"""
在递归函数调用时因为是自己调用自己可能会无限调用自己那么就会产生出无限个局部函数名套用局部函数，那么我们如
果没有中止的话可能就会将内存卡崩，所以我们的python就帮我们做了优化一旦我们的递归函数跑过1000左右的次数后
就会自动帮我们报错（数值会有偏差python对数字不太敏感但是后期有模块帮我们优化数字系统）
"""
3.两个函数互相调用
def func():
    print('调用了func')
    index()

def index():
    print('调用了index')
    func()
func()
"""
在我们将两个函数互相调用的情况下，首先是调用了func函数而在func函数中又调用index函数因为两个函数的名称都
是在全局名称空间中所以可以相互调用，还是只能跑100左右的次数就会自动停止
"""
4.定义互相调用次数
count = 1  # 首先做一个简单的计数器
def func():  # 定义一个函数
    print('调用func函数')  # 设置输出值
    global count  # 改变全局变量中的数值
    count += 1  # 简单计数
    print(count)  # 打印次数
    func()  # 自己调用自己
func()  # 运行本函数
"""
调用func函数
997  # 简陋计数
"""
5.使用模块计数与修改递归次数
count = 1
def func():
    print('调用func函数')
    global count
    count += 1
    print(count)
    func()
func()
import sys  # 调用sys模块
print(sys.getrecursionlimit())  # 使用sys模块获取最大递归次数
sys.setrecursionlimit(1314)  # 使用sys模块设置最大递归次数
print(sys.getrecursionlimit())  # 将递归次数打印出来
print(sys.setrecursionlimit())  # 获取设置递归次数后的数值


l2 = [1, 3, 4, 6, 7, 8, 9, 11, 15, 17, 19, 21, 22, 25, 29,
         33, 38, 69, 99, 107, 222, 333, 444, 555, 666, 777, 888, 999]
def get_num(l2,result_num):  # 传参给数值
    if len(l2) == 0:  # 如果找不到就是0那么直接打印找不到
        print('您所寻找到值不存在于本列表中')
        return
    middle_index = len(l2) // 2  # 将整个分为两截
    middle_value = l2[middle_index]
    if result_num > middle_value:  # 判断是否数值在右边
        right_l2 = l2[middle_index + 1:]  # 顾头不顾尾所以需要加上最后一个进行判断
        print(right_l2  # 打印
        get_num(right_l2,result_num)
    elif result_num < middle_value:  # 判断是否在左边
        left_l2 = l2[:middle_index]  # 不需要价值判断
        print(left_l2)
        get_num(left_l2, result_num)
    else:
        print('您寻找的值在本列表中存在', result_num)
get_num(l2,999)
"""
[33, 38, 69, 99, 107, 222, 333, 444, 555, 666, 777, 888, 999]
[444, 555, 666, 777, 888, 999]
[888, 999]
您寻找的值在本列表中存在 999
"""


# 1.获取用户输入并且对比是否符合姓名否则判断失败
name = input('请输入您的用户名>>>:').strip()
if name == 'joseph':
    print('欢迎光临')
else:
    print('登陆失败')
"""
请输入您的用户名>>>:joseph
欢迎光临
"""
# 当我们使用三元表达式的时候就可以将上方的四行代码缩成一行节省我们的行数，并且一眼就可以看出我们想要写出
的是什么意思
print('欢迎光临' if name == 'joseph' else '登陆失败')
"""
欢迎光临
"""
2.比较两个数值之间的大小a == 18，b==20
a = 18
b = 20
if a > b :
    print(a)
else:
    print(b)
"""
20
"""
# 我们以前进行判断时需要进行判断就需要四步才可以写完整个程序使用三元表达式那么也可以节省使用行数
def max(a, b):
    return a if a > b else b
result = max(18, 20)
print(result)
# 我们使用三元表达式可以在一行完成整个式子，在if前方填写如果这个条件判断成功那么使用if前方的结果如果不成
功那么就使用后面的结果


1.列表生成式
    1.1在列表中给数值后面加66
   l1 = ['joseph', 'jason', 'kevin', 'tom', 'trump']# 首先建立一个列表给她传值
    l2 = []  # 建立一个新列表接受改变后的值
    for i in l1:  # 将列表1后面的数值一次循环出来
        l2 = i + '66'  # 给数值加字符并传入l2
        print(l2)  # 打印l2列表
   """
   joseph66
    jason66
    kevin66
    tom66
    trump66
   """
    1.2利用列表生成式传值
   l1 = ['joseph', 'jason', 'kevin', 'tom', 'trump']  # 建造一个列表
    l2 = [i + '66' for i in l1]  # 创建一个新列表并直接给她赋值，在括号中我们应该先看for再看左
    边，利用for将l1中的数值一次循环出来，我们再看左边需要给数值增加字符那么我们就在这个循环中一次给这些
    数值全部增加66
   print(l2)  # 打印l2列表
    """
    ['joseph66', 'jason66', 'kevin66', 'tom66', 'trump66']
    """
   1.3利用列表生成式但是排除给kevin66
    l1 = ['joseph', 'jason', 'kevin', 'tom', 'trump']  # 建造一个列表
    l2 = [i + '66' for i in l1 if i != 'kevin']  # 在之前列表的基础上给他加个判断，如果不等于
    kevin才会执行前面的增值行为等于那么直接跳过
   print(l2)  # 打印l2
    """
    ['joseph66', 'jason66', 'tom66', 'trump66']
    """
2.字典生成式
    2.1使用字典生成式循环0-5顾头不顾尾将他赋值给dic1列表
    dic1 = {i:'joseph' for i in range(5)}  # 利用字典生成式达式循环出来直接赋值
    print(dic1)  # 打印dic1
   """
   {0: 'joseph', 1: 'joseph', 2: 'joseph', 3: 'joseph', 4: 'joseph'}
   """
    2.2将我们不想让3增为字典时，那么就需要加一个条件
   dic1 = {i:'joseph' for i in range(5) if i != 3}  # 利用字典生成式直接赋值，并判断是否等于3，
   如果不等于3都继续执行如果等于3下一个
    print(dic1)  # 打印dic1
   """
   {0: 'joseph', 1: 'joseph', 2: 'joseph', 4: 'joseph'}
   """
3.集合生成式
    3.1
   set1 = {i for i in range(5)} # 生成一个集合生成式
    print(set1)  # 打印set1
    """
    {0, 1, 2, 3, 4}
    """
   3.2
    set1 = {i for i in range(5) if i != 3}  # 生成一个集合生成式并判断是否等于3
    print(set1)  # 打印set1
   """
   {0, 1, 2, 4}
   """


1.匿名函数的本质
    匿名函数本质上就是没有名字的函数，匿名函数一般搭配其他函数一起使用，用来节省代码行数，匿名函数一
    般都只有一行，里面不能有return，可以没有参数也可以有一个或多个参数
2.匿名函数的结构
    lambda '参数': '返回值'
    result = lambda x: x + 1  # 首先使用匿名函数定义一个参数加上冒号接受返回值再赋值给result结果
    print(result)  #打印出结果但是返回的是一堆我们看不懂的东西所以我们需要给她加上一个数据形式来识
    别和接受这个结果
3.匿名函数的使用
    在程序之执行一遍的时候，为了方便我们就不需要再来定义一个函数，就是用匿名函数来代替，节省变量定义
    空间，也为了让程序变得更加简洁


1.max的使用取列表中的最大值
l1 = [1, 51, 5, 1, 561, 56, 51, 531, 561, 86, 41, 8, 4, 651, 9, 784561, 89746513, 65,
89748615, 4978, 46, 155, 98748,615535, 49, 7461]  # 创造一个列表纯瞎打的
result = max(l1)  # 使用max内置方法取得这个列表中的最大值并赋值给result结果
print(result)  # 接受结果并打印出来
"""
89748615
"""
2.min的使用,正好与max相反取最小值
l1 = [1, 51, 5, 1, 561, 56, 51, 531, 561, 86, 41, 8, 4, 651, 9, 784561, 89746513, 65,
89748615, 4978, 46, 155, 98748,615535, 49, 7461]   # 上面那个列表
result = min(l1)  # 使用min内置方法取得这个列表中的最小值并赋值给result结果
print(result)  # 接受结果并打印出来
"""
1
"""
3.reduce（相加）参数为一个可迭代对象的每一个元素，是对每一个元素执行迭代操作（通过函数实现具体的操作），
返回一个具体的值而不是对象，需要先将reduce调用出来（底层拥有循环）
from functools import reduce   # 在py3中需要先将reduce调用出来
def func(x,y):  # 设置两个形参
    return x + y  # 返回值为形参相加
result = reduce(func,range(1,11))   # 使用reduce相加范围中的所有值,并赋值给结果
print(result)  # 打印结果
"""
55
"""
4.filter（过滤）通常用于过滤的功能，需要加入过滤的条件，过滤的对象为一个可迭代对象的每一个元素，返
回一个filter 对象，通过强转换才可以显示内容
l1 = ['a','b','c','d']  # 创造一个列表

def func(s):   # 添加一个形参
         if s != 'a':   # filter 只能过滤，有过滤条件形参如果不等于a那么继续运行
             return s  # 返回值为s

result = filter(func,l1)
print(result)
print(list(result))
"""
<filter object at 0x0000026181A55BB0>
['b', 'c', 'd']
"""
5.map（映射）参数为一个可迭代对象的每一个元素，是对每一个元素执行相同的操作（通过函数实现具体的操作），返
回一个map 对象，同样可以用强制转换来显示内容
l1 = ['a','b','c','d']
for i in l1:
    res = map(lambda joseph:'joseph' + i,i)
    print(res)
    print(list(res))
"""
<filter object at 0x0000024D2DA45BB0>
['b', 'c', 'd']
<map object at 0x0000024D2DA0F2E0>
['josepha']
<map object at 0x0000024D2DA0F130>
['josephb']
<map object at 0x0000024D2DA0F190>
['josephc']
<map object at 0x0000024D2DA0F1F0>
['josephd']
"""
6.zip（拉链，缝合）可以接收多个可迭代对象，然后把每个可迭代对象中的第i个元素组合在一起
a = [1, 2, 3 ]
b = [4, 5, 6]
c = zip(a, b)
print(list(c))
"""
[(1, 4), (2, 5), (3, 6)]
"""
a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
b = ['a', 'b', 'c', 'd', 'e', 'f']
c = 'joseph'
result = zip(a, b, c)
print(result)
print(list(result))
"""
<zip object at 0x000001E9C2B1F5C0>
[(1, 'a', 'j'), (2, 'b', 'o'), (3, 'c', 's'), (4, 'd', 'e'), (5, 'e', 'p'), (6, 'f', 'h')]
"""