def logger():
    print("log is here!")

def test1():
    pass
    logger()

def test2():
    pass
    logger()
test1()
test2()
‘‘‘
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()

‘‘‘decorator 装饰器  语法糖
    高级装饰器:
    网站--页面（一个网站一个函数）100个页面不需要登录
                现20个需要登录才能访问

‘‘‘
user,passwd = "alex","abc_123"
def auth1(func):
    def wrapper(*args,**kwargs):
        username = input("Username").strip()
        password = input("Password").strip()

        if user == username and passwd == password:
            print("welcome!")
            return func(*args,**kwargs)
    return wrapper

def index():   #不需要登录
    print("welcome to index page")
@auth1
def home():     #需要登录
    print("welcome to home page")

home()

‘‘‘列表生成器‘‘‘
a = [1,2,3,4]
#列表生成式
b = [i*2 for i in range(10)]
c = []
for i in range(10):
    c.append(i*2)

print(a,b,c)

‘‘‘生成器  generator    g = (i**2 for i in range(10))
    1、只有在调用时才会生成相应的数据 。
    2、只记住当前位置
    3、只有一个3.0 __next__()【2.7  next()】方法
如果全部展示
只能用for 循环全部调用

可以使用函数生成    主要是 yield 关键字 
    把什么返回到外面，就把yeild关键字放到那边
    yeild返回函数当前的值
‘‘‘

def fib(max):
    n,a,b =0,0,1
    while n<max:
        #print(b)
        yield b
        a,b =b,a+b
        n=n+1
    return("done")

f = fib(10)
# for j in fibg:
#     print(fibg.__next__())
while True:
    try:
        print(f.__next__())
    except StopIteration as e:
        print("Generator return value:" ,e.value)
        break

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# Auther:Xll
‘‘‘协程‘‘‘
import time

def consumer(name):
    print("%s 准备吃包子了！" %name)
    while True:
        baozi = yield

        print("包子【%s】个来了，被【%s】吃了！" %(baozi,name))

# c = consumer("Chenronghua")
# c.__next__()
# c.send("白菜大葱")

def producter(name):
    c = consumer("Alex")
    c1 = consumer("Wutengnan")
    c.__next__()
    c1.__next__()
    print("%s宣布：吃包子大赛开始！" %name)
    for i in range(10):
        time.sleep(i)
        print("做了%s个包子" %((i+1)*2))
        c.send(i+1)
        c1.send(i+1)

producter("Oldboy")

#! /usr/bin/env python
# -*- coding:utf-8 -*-
# Auther:Xll
‘‘‘内置方法‘‘‘
#all 内部元素所有为真，返回真
print(all([111,1,2,3,-1]))
#any 内部任意元素为真，返回真
print(any([0,1,False]))
#内部数据转为可打印的字符串形式，中文转为unicode格式
s=[1,2,3,45,6,7,8,90,67]
s.append(‘开外挂‘)
print(ascii(s))
#bin 整数 10进制转2进制
print(bin(64))
#bool()   判断真假 0 空列表，空字典为假，其他为真
print(bool(False))
#转换位bit格式
a = bytes("abcde",encoding="utf-8")
print(a.capitalize(),a)
#bytearray 变为可列表，可操作列表来实现改变,但数据类型是bytearray
b = bytearray("abcde",encoding="utf-8")
print(b[2]) #98
b[1]=80
print(b,type(b))
#callable  是否可调用， 函数、类是可调用的，即可以加()的
print(callable(s))
#char 用数字转换为ascii码的字符，ord 相反
print(chr(97))
print(ord("b"))
#classmethod 类方法
#print(chr(97))
#complie 变成可执行的代码 的过程
#divmod   A/B 返回 商 和 余数
print(divmod(100,33))
#eval   把一个字符串变字典。
#exce  把一个字符变为可执行程序
#匿名函数  lambda 只能写三元运算，不能做更多的判断
calc = lambda n:print(n)
calc1 = lambda n:3 if n<4 else n
calc(5)
print(calc1(1))
#filter 一组数据中过滤出你想要的,配合lambda使用
res = filter(lambda n:n>5,range(10))
for i in res:
    print(i)
#map 对传入的值按照函数的方式处理，然后返回
ret = map(lambda n:n**2,range(10))
for j in ret:
    print(j)
#frozenset 不可变集合
aa = frozenset([11,22,33,44,33,22,11,55,66])
print(aa)
#globals 返回当前文件中所有变量的k v 格式
print(globals())
#hash
print(hash(aa))
#hex 数字转16进制 oct 数字转8进制
a = {0: 10000, 6: 2, 1: 4, -5: 6, 99: 11, 1111: 32}
print(sorted(a.items())) #按照key排序
print(sorted(a.items(),key = lambda x:x[1])) #按照value排序
#zip 拉链函数 ，以最短的聚合
a=[1,2,3,4]
b=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘]
for i in zip(a,b):
    print(i)

(1, ‘a‘)
(2, ‘b‘)
(3, ‘c‘)
(4, ‘d‘)
__import__(‘decorator‘)

info ={‘name‘:‘alex‘,‘age‘:22}
# with open(‘test.txt‘,"w") as f:
#     f.write(str(info))
# with open(‘test.txt‘,"r") as f:
#     data=http://www.mamicode.com/eval(f.read())"w") as f:
#     f.write(json.dumps(info))
# with open(‘test.txt‘,"r") as f:
#     data = http://www.mamicode.com/json.loads(f.read())"Hello",name)
info[‘func‘] = sayhi
# print(info)
# print(pickle.dumps(info))
# with open(‘test.txt‘,"wb") as f:
#     f.write(pickle.dumps(info))
with open(‘test.txt‘,"rb") as f:
    data = http://www.mamicode.com/pickle.loads(f.read())"func"](‘alex‘))

‘‘
包：本质就是一个文件夹，区别是必须带有__init__.py文件
    导入包的本质是解释包下面的__init__.py文件
模块：
    1、定义：模块用来从逻辑上组织python代码(变量、函数、类，逻辑：实现一个功能)
             本质上就是以.py结尾的python文件（文件名test.py对应的模块名：test）
    2、导入方法
            import module_1
            import module_1,module_2
            from module_1 import * (不使用,容易出现变量等冲突)
            from module_1 import m1,m2,m3
            from module_1 import logger as logger_m
    3、import本质（路径搜索和搜索路径）
        把文件解释一遍，import 文件名代表导入所有，from只解释from的那一段，
        import module_name ----->module_name.py---->必须找到文件的路径
        在sys.path 列出的路径下找
    4、导入优化
        多次调用 import module 中的test方法时，会造成效率低下，
         建议使用  from module import test  或者加上 as module_test_test
    5、模块的分类：
     a:标准库
     b:开源模块
     c:自定义模块
‘‘‘
#import module_1  =   module_1 = all code
#from module_1 import say_hi 把module_1中的say_hi 函数放到当前位置，并命名为 say_hi
import module_1
module_1.say_hi()
from module_1 import say_hi
name1 = "Wu Teng Nuan"
say_hi()
#导入包
import package_test

import os
print(os.getcwd())   #获取当前工作目录，即当前python脚本工作的目录路径
print(os.chdir("c:\\")) # 改变当前脚本工作目录；相当于shell下cd
os.curdir  #返回当前目录: (‘.‘)
os.pardir  #获取当前目录的父目录字符串名：(‘..‘)
os.makedirs(‘dirname1/dirname2‘)   # 可生成多层递归目录
os.removedirs(‘dirname1‘)   # 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir(‘dirname‘)   # 生成单级目录；相当于shell中mkdir dirname
os.rmdir(‘dirname‘)   # 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir(‘dirname‘) #   列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
os.remove() # 删除一个文件
os.rename("oldname","newname")  #重命名文件/目录
os.stat(‘path/filename‘) # 获取文件/目录信息
os.sep   # 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep  #  输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep   # 输出用于分割文件路径的字符串
os.name   # 输出字符串指示当前使用平台。win->‘nt‘; Linux->‘posix‘
os.system("bash command") # 运行shell命令，直接显示
os.environ  #获取系统环境变量
os.path.abspath(path) # 返回path规范化的绝对路径
os.path.split(path) # 将path分割成目录和文件名二元组返回
os.path.dirname(path) # 返回path的目录。其实就是os.path.split(path)的第一个元素
os.path.basename(path) # 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
os.path.exists(path)  #如果path存在，返回True；如果path不存在，返回False
os.path.isabs(path)  #如果path是绝对路径，返回True
os.path.isfile(path) # 如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  #如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]]) # 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path) # 返回path所指向的文件或者目录的最后存取时间
os.path.getmtime(path)  #返回path所指向的文件或者目录的最后修改时间

##高级的 文件、文件夹、压缩包 处理模块

import shutil

#shutil.copyfileobj(‘os-mk.py‘, ‘os-1‘,100)
#将文件内容拷贝到另一个文件中，可以部分内容

shutil.copyfile("os-mk.py","os-mk")
#拷贝文件

shutil.copymode("os-mk.py","os-mk")
#仅拷贝权限。内容、组、用户均不变              !!!  linux 比较适用，windows下看不出来太大区别
shutil.copystat("os-mk.py","os-mk")
#拷贝状态的信息，包括：mode bits, atime, mtime, flags

shutil.copy("os-mk.py", "os-mk1")
#拷贝文件和权限

shutil.copy2("os-mk1","os-m1")
#拷贝文件和状态信息

#shutil.ignore_patterns(*patterns)
#shutil.copytree(src, dst, symlinks=False, ignore=None)
#递归的去拷贝文件,文件夹
#shutil.copytree(‘py06‘, ‘py05‘, ignore=shutil.ignore_patterns(‘*.pyc‘, ‘tmp*‘))

#shutil.rmtree(‘py05‘)
#递归的去删除文件
#shutil.move(‘py06‘, ‘py04‘)
#递归的去移动文件
‘‘‘
shutil.make_archive(base_name, format,...)

创建压缩包并返回文件路径，例如：zip、tar

base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
如：www                        =>保存至当前路径
如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/
format：	压缩包种类，“zip”, “tar”, “bztar”，“gztar”
root_dir：	要压缩的文件夹路径（默认当前目录）
owner：	用户，默认当前用户
group：	组，默认当前组
logger：	用于记录日志，通常是logging.Logger对象
‘‘‘
shutil.make_archive(‘aaaa.tar‘, ‘tar‘)

import shelve

d = shelve.open(‘shelve--test‘)  # 打开一个文件
# d["name"] = ["alex", "WutN", "test"]
# d["age"] = 22  # 持久化类
# d[‘info‘] = {"name":"alex","age":21,"school":"Oldboy"}
# d.close()
print(dir(d))
print(d.get("name"))
print(d.get("info"))

import re
#re.match 匹配是否以字符开始 没有匹配上返回None，此时不具有group属性，会报错。
#re.serch 全文搜索
#re.findall 搜索所有的
#re.split 以匹配到的进行分割
#re.sub() 以第二个来替换匹配到的信息   re.sub(search,repl,string,count=)
a = re.match("\w*",‘inter 192.168.0.161‘)
print(a,a.group())
# group 和groups的却别， groups 打印出分组()中匹配到的数据
b = re.match(‘(\d{2})(\d{2})(\d{2})(\d{4})‘,‘212312200212172233 name:alex‘)
print(b.group())
print(b.groups())

print(re.search(‘^\d.*\d\Z‘,‘213123124xyz1432432‘).group())
# ?P<内容>  搭配groupdict()，转为字典格式，装逼ing
cc = re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<year>[0-9]{4})","212312200212172233")
print(cc.groups())
print(cc.group())
print(cc.groupdict())

print(re.findall(‘\w‘,‘a!!!!c@@ww$$$$‘))

print(re.split(‘\d+‘,‘ads1ljkk132kjh43h234jhj24k3hj234jkh66‘))
print(re.sub(‘\d+‘,‘||‘,‘ads1ljkk132kjh43h234jhj24k3hj234jkh66‘))
# 自然语言，不对字符串进行转移 logs‘string‘
print(re.split(‘\\\\‘,logs‘c:\\user\pwd\new\python33‘))
print(re.split(logs‘\\‘,logs‘c:\\user\pwd\new\python33‘))
#flags re.I 忽略大小写 re.M 多行模式  re.
print(re.search(‘a‘,‘ABC‘,flags=re.I))
print(re.search(‘^A.*\w$‘,‘ABCabcdsfs4\n213789sdff‘, flags=re.M).group())