python第四课

冷不防 2022-06-01 08:45 163阅读 0赞

\# 装饰器：本质是函数（装饰其他函数）就是为其他函数添加附加功能  
\# 不能修改被装饰的函数的功能；不能修改被装饰的函数的调用方式  
'''  
def logger():  
    print("logging")  
  
def test1():  
    pass  
    logger()  
  
def test2():  
    pass  
    logger()  
  
test1()  
test2()  
'''  
import time  
def timmer(func):  
    def warpper(\*args, \*\*kwargs):  
        start\_time=time.time()  
        func()  
        stop\_time=time.time()  
        print('the func run time is %s' %(stop\_time-start\_time))  
    return warpper  
@timmer  
def test1():  
    time.sleep(3)  
    print('in the test1')  
test1()  
\# 实现装饰器知识储备：1.函数即“变量”；2.高阶函数；3.嵌套函数  
\# 高阶函数+嵌套函数=装饰器  
  
def foo():  
    print('in the foo')  
    bar()  
foo()  
  
def bar():  
    print('in the bar')  
def foo():  
    print('in the foo')  
    bar()  
foo()  
\# 匿名函数  
calc = lambda x:x\*3  
print(calc(3))  
  
def bar():  
    print('in the bar')  
def test1(func):  
    print(func)  
    func()  
test1(bar)  
  
def bar():  
    time.sleep(3)  
    print('in the bar')  
def test1(func):  
    start\_time=time.time()  
    func()  
    stop\_time=time.time()  
    print('the func run time is %s' %(stop\_time-start\_time))  
  
test1(bar)  
  
def test2(func):  
    print(func)  
    return func  
bar = test2(bar)  
bar()  
  
\# 嵌套函数  
def foo():  
    print('in the foo')  
    def bar():  
        print('in the bar')  
    bar()  
foo()  
\# 局部作用域和全局作用域的访问顺序  
x=0  
def grandpa():  
    \# x=1  
    def dad():  
        x=2  
        def son():  
            x=3  
            print(x)  
        son()  
    dad()  
grandpa()  
  
\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#\#  
import time  
def timer(func): \# timer(test1) func=test1  
    def deco(\*args,\*\*kwargs):  
        start\_time=time.time()  
        func(\*args,\*\*kwargs) \# run test1()  
        stop\_time=time.time()  
        print('the func run time is %s' %(stop\_time-start\_time))  
    return deco  
@timer  \# 相当于test1=timer(test1)  
def test1():  
    time.sleep(3)  
    print('in the test1')  
@timer  
def test2(name):  
    time.sleep(3)  
    print('in the test2')  
  
test1()  \# -->deco  
test2('alex',22)

user,passwd='alex','abc123'  
def auth(auth\_type):  
    print('auth func:', auth\_type)  
    def outer\_wrapper(func):  
        def wrapper(\*args,\*\*kwargs):  
            username=input('Username:').strip()  
            password=input('Password:').strip()  
            if user == username and passwd == password:  
                print("\\033\[32;1mUser has passed authentication\\033\[0m")  
                res = func(\*args,\*\*kwargs)  
                print("-------after authentication")  
                return res  
            else:  
                print("\\033\[32;1mInvalid username or password\\033\[0m")  
        return wrapper  
    return outer\_wrapper  
def index():  
    print('welcome to index page')  
@auth(auth\_type='local')  
def home():  
    print('welcome to home page')  
    return 'from home'  
@auth(auth\_type='ldap')  
def bbs():  
    print('welcome to bbs page')  
index()  
print(home())  
bbs()

\# 列表生成式  
a = \[1,2,3\]  
\[i\*2 for i in range(10)\]

\# 生成器  
\# 通过列表生成式，我们可以直接受到内存限制，列表容量肯定是有限的。而且创建一个包含100万个元素的列表，不仅占用很大的内存空间，  
\# 如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。  
\# 所以，如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的list，从而节省  
\# 大量的空间。在python中，这种一边循环一边计算的机制，称为生成器：generator  
\# 要创建一个generator,有很多种方法。第一种方法很简单，只要把一个列表生成式的\[\]改成（），就创建了一个generator:  
L = \[x\*x for x in range(10)\]  
g = (x\*x for x in range(10))  \# 这就是列表生成器  
\# 生成器只记录当前的位置，只有一个\_\_next\_\_()方法，取下一个的含义  
def fib(max):  
    n, a, b = 0, 0, 1  
    while n < max:  
        print(b)  
        a, b = b, a + b  \# a=b b=a+b  
        n = n + 1  
    return 'done'  
fib(10)  
  
def fib(max):  
    n, a, b = 0, 0, 1  
    while n < max:  
        yield b  \# 将上面程序改成了生成器  
        a, b = b, a + b  \# a=b b=a+b  
        n = n + 1  
    return '----done----' \# 异常时打印的消息  
f = fib(10)  
  
print(f.\_\_next\_\_())  
print(f.\_\_next\_\_())  
print(f.\_\_next\_\_())  
print("====start loop====")  
for i in f:  
    print(i)  
  
g = fib(6)  
while True:  
    try:  
        x = next(g)  
        print('g:', x)  
    except StopIteration as e:  
        print('Generator return value:', e.value)  
        break  
\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*  
import time  
def consumer(name):  
    print("%s 准备吃包子啦！" % name)  
    while True:  
        baozi = yield  
        print('包子\[%s\]来了，被\[%s\]吃了！' %(baozi, name))  
c = consumer('chenronghua')  
c.\_\_next\_\_()  
\# b1 = '韭菜馅'  
\# c.send(b1)  
\# c.\_\_next\_\_()  
def producer(name):  
    c = consumer('a')  
    c2 = consumer('b')  
    c.\_\_next\_\_()  
    c2.\_\_next\_\_()  
    print('开始做包子了！')  
    for i in range(10):  
        time.sleep(1)  
        print('做了一个包子，分两半！')  
        c.send(i)  
        c2.send(i)  
producer('alex')

\# 迭代器  
\# 可以直接作用于for循环的对象统称为可迭代对象：Iterable  
\# 可以使用isinstance()判断一个对象是否是Iterable对象  
\# 可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator  
\# 可以使用isinstance()判断一个对象是否是Iterator对象

\# 内置参数  
print(all(\[0, -5, 3\])) \# 所有数据为真返回True  
any(\[\])  \# 有一个数据为真返回True  
print(ascii(\[1, 2, "开外挂"\]))  \# 把对象变为一个字符串  
bin(1)  \# 把数字转二进制  
bool(0)  \# 判断bool值  
a = bytes('abc', encoding='utf-8')  
b = bytearray('abc', encoding='utf-8')  
print(b\[0\])  
print(a.capitalize(), a)  
def f():  
    callable(f)  \# 返回是否可添加括号  
chr(98)  
ord('b')  
  
code = 'for i in range(10):print(i)'  
c = compile(code, '', 'exec')  \# 字符串转成可执行程序  
exec(c)  
exec(code)  \# 也可以执行  
divmod(5, 3)  \# 相除 余数  
def sayhi(n):  
    print(n)  
sayhi(3)  
(lambda n: print(n))(5)  
calc = lambda n: print(n)  
calc(5)  
res = filter(lambda n: n > 5, range(10))  
for i in res:  
    print(i)  
res1 = map(lambda n: n\*2, range(10))  
for i in res1:  
    print(i)  
import functools  
res2 = functools.reduce(lambda x, y: x+y, range(10))  
print(res2)  
  
a = frozenset(\[1,2,3,4,5,6,4,2\])  \# 不可变列表  
print(globals())  \# 展现这个程序的变量值  
hash('alex')  
hex(11)  \# 把数据转成16进制  
def test():  
    local\_var = 333  
    print(locals())  
    print(globals())  
test()  
print(globals())  
print(globals().get('local\_var'))  
oct(10)  \# 把数据转成8进制  
pow(2, 8)  \# 返回多少次方  
round(1.3342, 2)  \# 保留2位小数  
slice(2, 5)  \# 切片  
a = \{6: 2, 8: 0, 1: 4, -5: 6, 99: 11, 4: 22\}  
print(sorted(a.items()))   \# 排序  
print(sorted(a.items(), key=lambda x: x\[1\]))   \# 按值排序  
a = \[1, 2, 3, 4\]  
b = \['a', 'b', 'c', 'd'\]  
for i in zip(a, b):       \# 两个列表打印  
    print(i)  
\_\_import\_\_('decorator')  \# 当不知道导入模块的时候，可以用名字导入  
  
  
\# 序列化  
info = \{  
    'name': 'alex',  
    'age': 22  
\}  
f = open('test.text', 'w')  
f.write(str(info))  
f.close()  
  
import  json  
info = \{  
    'name': 'alex',  
    'age': 22  
\}  
f = open('test.text', 'w')  
f.write(json.dumps(info))  
f.close()  
\# 反序列化  
f = open('test.text', 'r')  
data = eval(f.read())  
f.close()  
print(data\['age'\])  
  
import  json  
f = open('test.text', 'r')  
data = json.loads(f.read())  
f.close()  
print(data\['age'\])  
\# --------------------------------  
import  pickle  
def sayhi(name):  
    print('hello,', name)  
info = \{  
    'name': 'alex',  
    'age': 22,  
    'func': sayhi  
\}  
f = open('test.text', 'wb')  
f.write(pickle.dumps(info))  
f.close()  
  
import  pickle  
def sayhi(name):  
    print('hello,', name)  
f = open('test.text', 'wb')  
f.write(pickle.loads(info))  
f.close()  
print(data)  
\---------------------  
import os  
import sys  
BASE\_DIR = os.path.dirname(os.path.dirname(os.path.abspath(\_\_file\_\_)))  
\# 返回当前文件所在的文件夹的上一级文件夹  
sys.path.append(BASE\_DIR)  \# 进去目录  
from conf import settings  \# 调用目录下conf文件夹的settings文件  
from core import main      \# 调用目录下core文件夹的main文件