def addfunc():
    print("我是新曾的功能")
def funcout(func):
    def funcin(x,y,z):
        addfunc()#新加功能直接在上边加
        func(4,5,6) #注意这里必须给func添加参数
    return funcin
@funcout
#test=funcout(test)
#def test(a,b,c):
    #print("a={0},b={1}".format(a,b))
#test(1,2)
def test(a,b,c):
    print("a={0},b={1},c={2}".format(a,b,c))
test(1,2,3)

老师 这个三个参数的函数 为什么要重新弄一个闭包 不能在之前的闭包上进行修改

def funcout(func):
    print("闭包1开始装饰")
    def funcin():
        return "$"+"《"+func()+"》"+"$"
    return funcin

def funcyout2(func):
    print("闭包2开始装饰")
    def funcin():
        return "!"+func()+"!"
    return funcin
@funcyout2 #如果同时从在多个装饰器的话 最靠近函数的装饰器先开始执行
@funcout #装饰器就相当于给外函数赋值
def bookname():
    return "西游记"

#给bookname重新赋值
#bookname=funcout(bookname)

print(bookname())

老师  

return "$"+"《"+func()+"》"+"$"

我完全可以在一个闭包里进行两个装饰 为啥要用两个闭包来实现？

import time
def writelog(func):
    try:
        file=open("log.txt","a",encoding="utf-8") #a就是追加模式
        #写入相关数据信息（访问的函数名，访问的时间）
        file.write(func.__name__)
        file.write("\t") #添加一个制表符
        #写入访问时间
        file.write(time.asctime())
        file.write("\n")
    except Exception as e:
        print(e)
    finally:
        file.close()
def func1():
    writelog(func1)
    print("我是功能1")
def func2():
    writelog(func2)
    print("我是功能2")
func1()
func2()

老师 代码当中那个func.__name__ 和 time.asctime() 这两个是什么意思 可以解释一下吗

老师，我想知道这个代码是怎么运行的，我手动计算不出这个答案，好像我对循环理解方式有错误。

#贪婪模式
v = re.match(r"abc(\d+)","abc123")
print(v.group(1))

# 非贪婪模式
v = re.match(r"abc(\d+?)","abc123")
print(v.group(1))

老师，正则表达式里面group的索引是从哪开始的?为什么写group(0)全部都打印了？

#匹配单词边界\b
pattern = r'\d{3,}\ber'
s = '1234 erao'
v = re.match(pattern,s)
print(v)

老师，我这样写为啥是这个结果呀？

"""
filter()
    #过滤器
    # 有内容的列表被保留了下来，没有内容的列表被删除
    # True被保留，False被删除
    filter(function or None, iterable) --> filter object

    Return an iterator yielding those items of iterable for which function(item)
    is true. If function is None, return the items that are true.
"""
list1 = [1,2,3,4,0,10,35,0]
#遍历列表中不为零的数
for i in list1:
    if i != 0:
        print(i,end=" ")
print()
#it1 = filter(None,list1)
#for i in it1:
#    print(i,end=" ")
#it1 = filter(lambda x:x !=0,list1)
#for i in it1:
#   print(i,end=" ")
it1 = filter(lambda x:x>5,list1)
for i in it1:
    print(i,end=" ")

老师，我想问一下就是这块代码，没有在filter里面写参数，后面也没有加任何条件，是怎么判断列表里面的哪些数不为零并且打印呢?

'''
wraps函数的使用
from functool import wraps

作用：
    functools.wraps可以将原函数对象的指定属性
    复制给包装函数对象，默认有module，name，doc，或者通过参数选择
'''
from functools import wraps

def log(func):
    @wraps(func)
    def with_logging(*args,**kwargs):
        print("%s was calling"%func.__name__)
        return func(*args,**kwargs)
    return with_logging

@log
#test = log(test)
def test(x):
    '''求x*x的值'''
    return x*x

print(test.__name__)
print(test.__doc__)

老师，我想请问一下这里的@wrps(func)还是没有搞明白是什么意思，能麻烦您帮我解释一下嘛？

老师你好！请问我这是什么情况？一直显示报错。

'''
1.闭包：在不修改源码的基础上增加新的功能
2.装饰器
    与闭包关联紧密，很多时候，二者结合使用

'''
import time
def writelog(func):
    try:
        file = open('log.txt','a',encoding='utf-8')
        file.write(func.__name__)
        file.write('\t')
        file.write(time.asctime())
        file.write('\n')
    except Exception as e:
        print(e)
    finally:
        file.close()

def funcout(func):
    def funcin():
        #添加新的功能
        writelog(func)
        func()
    return funcin()
@funcout    #装饰器的名字就是闭包外部函数名，不能随意写函数名
def func1():
    print("我是功能1")
@funcout
def func2():
    print("我是功能2")

#func1 = funcout(func1)
#func2 = funcout(func2)

func1()
func2()

老师。d代码能运行，日志文件也能正常运行，但是每次运行就会报这个错，麻烦您帮忙看看

'''
闭包的特殊功能：
    1.可以在不修改现有源码的前提下，增加新的功能
    日志功能（统计访问时间，访问功能写道日志文件中），权限验证（下载之前，验证当前用户是否为会员）

开闭原则：
    开放：开放功能
    关闭：修改源码
'''
import time
#定义一个记录日志的函数：将访问时间以及访问的函数名写入到文件中(log.txt)
def writelog(func):
    try:
        file = open('log.txt','a',encoding='utf-8')
        #写入相关数据信息(访问的函数名，访问的时间)
        file.write(func.__name__)
        file.write("\t")#制表符
        #写入访问时间
        file.write(time.asctime())
        file.write("\n")#换行符
    except Exception as e:
        print(e.args)
    finally:
        #关闭文件
        file.close()

#闭包
def funcout(func):
    def funcin():
        #新增功能
        writelog(func)
        func()
    return funcin

def func1():
    print("我是功能1")
def func2():
   print("我是功能2")

#闭包的调用
func1 = funcout(func1)
func2 = funcout(func2)

func1()
func2()

老师，我想请问一下原来的def func1()这个函数它怎么就是下面的func1 = funcout(func1)这两个func1为啥是同一个呢？下面这个不是上面闭包函数里面的参数嘛？

import time
import sys#系统模块
time.perf_counter()
list = [x for x in range(2,10000000)]
costime = time.perf_counter()
print(f"创建时间:{costime}")
print(f"通过列表的内存开销{sys.getsizeof(list)}")
#生成器
time.perf_counter()
g1 = (x for x in range(2,10000000))
castime1 = time.perf_counter()
print(f'创建时间:{castime1}')
print(f"通过生成器的内存开销{sys.getsizeof(g1)}")

老师这种情况怎么列表的速度还快呢。用process_time进入进程时间的话大部分时间都是一样的

import time
import sys#系统模块
time.process_time()
list = [x for x in range(2,10000000)]
costime = time.process_time()
print(f"创建时间:{costime}")
print(f"通过列表的内存开销{sys.getsizeof(list)}")
#生成器
time.process_time()
g1 = (x for x in range(2,10000000))
castime1 = time.process_time()
print(f'创建时间:{castime1}')
print(f"通过生成器的内存开销{sys.getsizeof(g1)}")

老师，偏函数的参数设定是不是要根据所要修改的函数参数名来设定。例如视频里int3有个参数是base= 2，是不是在int原函数里第二个参数本来就是base，还是说这个参数名是随便取的

import re

def test(parameter):
    pattern = r'[a-zA-Z1-9.]{4,19}@[a-zA-Z0-9]{2,18}.[com$|net$]'
    v = re.match(pattern, parameter)

    if v:
        print("匹配成功",v)
        #print(v)

    else:
        print("请输入正确的邮箱")


if __name__ == '__main__':
    s = test(input("请输入邮箱地址："))

运行结果

请输入邮箱地址：stone.zhao@asteelfalsh.com
匹配成功 <re.Match object; span=(0, 24), match='stone.zhao@asteelfalsh.c'>

老师看看为什么不能全部输出

re

(parameter):pattern = v = re.match(patternparameter)

    v:
        (v)
        :
        ()

__name__ == :
    s = test(())

运行结果

请输入邮箱地址：stone.zhao@asteelflash.com
匹配成功 <re.Match object; span=(0, 24), match='stone.zhao@asteelflash.c'>