%a    Locale’s abbreviated weekday name.     
%A    Locale’s full weekday name.     
%b    Locale’s abbreviated month name.     
%B    Locale’s full month name.     
%c    Locale’s appropriate date and time representation.     
%d    Day of the month as a decimal number [01,31].     
%H    Hour (24-hour clock) as a decimal number [00,23].     
%I    Hour (12-hour clock) as a decimal number [01,12].     
%j    Day of the year as a decimal number [001,366].     
%m    Month as a decimal number [01,12].     
%M    Minute as a decimal number [00,59].     
%p    Locale’s equivalent of either AM or PM.    (1)
%S    Second as a decimal number [00,61].    (2)
%U    Week number of the year (Sunday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Sunday are considered to be in week 0.    (3)
%w    Weekday as a decimal number [0(Sunday),6].     
%W    Week number of the year (Monday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Monday are considered to be in week 0.    (3)
%x    Locale’s appropriate date representation.     
%X    Locale’s appropriate time representation.     
%y    Year without century as a decimal number [00,99].     
%Y    Year with century as a decimal number.     
%z    Time zone offset indicating a positive or negative time difference from UTC/GMT of the form +HHMM or -HHMM, where H represents decimal hour digits and M represents decimal minute digits [-23:59, +23:59].     
%Z    Time zone name (no characters if no time zone exists).     
%%    A literal \'%\' character.

#时间加减
import datetime

# print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925
#print(datetime.date.fromtimestamp(time.time()) )  # 时间戳直接转成日期格式 2016-08-19
# print(datetime.datetime.now() )
# print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天
# print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天
# print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时
# print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分


#
# c_time  = datetime.datetime.now()
# print(c_time.replace(minute=3,hour=2)) #时间替换

import random
def make_code(n):
    res=\'\'
    for i in range(n):
        s1=chr(random.randint(65,90))
        s2=str(random.randint(0,9))
        res+=random.choice([s1,s2])
    return res

print(make_code(9))

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于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    输出用于分割文件路径的字符串 win下为;,Linux下为:
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所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小

#=========知识储备==========
#进度条的效果
[#             ]
[##            ]
[###           ]
[####          ]

#指定宽度
print(\'[%-15s]\' %\'#\')
print(\'[%-15s]\' %\'##\')
print(\'[%-15s]\' %\'###\')
print(\'[%-15s]\' %\'####\')

#打印%
print(\'%s%%\' %(100)) #第二个%号代表取消第一个%的特殊意义

#可传参来控制宽度
print(\'[%%-%ds]\' %50) #[%-50s]
print((\'[%%-%ds]\' %50) %\'#\')
print((\'[%%-%ds]\' %50) %\'##\')
print((\'[%%-%ds]\' %50) %\'###\')


#=========实现打印进度条函数==========
import sys
import time

def progress(percent,width=50):
    if percent >= 1:
        percent=1
    show_str=(\'[%%-%ds]\' %width) %(int(width*percent)*\'#\')
    print(\'\r%s %d%%\' %(show_str,int(100*percent)),file=sys.stdout,flush=True,end=\'\')


#=========应用==========
data_size=1025
recv_size=0
while recv_size < data_size:
    time.sleep(0.1) #模拟数据的传输延迟
    recv_size+=1024 #每次收1024

    percent=recv_size/data_size #接收的比例
    progress(percent,width=70) #进度条的宽度70

import shutil

shutil.copytree(\'f1\', \'f2\', symlinks=True, ignore=shutil.ignore_patterns(\'*.pyc\', \'tmp*\'))

\'\'\'
通常的拷贝都把软连接拷贝成硬链接，即对待软连接来说，创建新的文件
\'\'\'

import zipfile

# 压缩
z = zipfile.ZipFile(\'laxi.zip\', \'w\')
z.write(\'a.log\')
z.write(\'data.data\')
z.close()

# 解压
z = zipfile.ZipFile(\'laxi.zip\', \'r\')
z.extractall(path=\'.\')
z.close()

import tarfile

# 压缩
>>> t=tarfile.open(\'/tmp/egon.tar\',\'w\')
>>> t.add(\'/test1/a.py\',arcname=\'a.bak\')
>>> t.add(\'/test1/b.py\',arcname=\'b.bak\')
>>> t.close()


# 解压
>>> t=tarfile.open(\'/tmp/egon.tar\',\'r\')
>>> t.extractall(\'/egon\')
>>> t.close()

import json
#dct="{\'1\':111}"#json 不认单引号
#dct=str({"1":111})#报错,因为生成的数据还是单引号:{\'one\': 1}

dct=\'{"1":"111"}\'
print(json.loads(dct))

#conclusion:
#        无论数据是怎样创建的，只要满足json格式，就可以json.loads出来,不一定非要dumps的数据才能loads

# 在python解释器2.7与3.6之后都可以json.loads(bytes类型)，但唯独3.5不可以
>>> import json
>>> json.loads(b\'{"a":111}\')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/Users/linhaifeng/anaconda3/lib/python3.5/json/__init__.py", line 312, in loads
    s.__class__.__name__))
TypeError: the JSON object must be str, not \'bytes\'

# 一.什么是猴子补丁?
      属性在运行时的动态替换，叫做猴子补丁（Monkey Patch）。
      猴子补丁的核心就是用自己的代码替换所用模块的源代码，详细地如下
　　1，这个词原来为Guerrilla Patch，杂牌军、游击队，说明这部分不是原装的，在英文里guerilla发音和gorllia(猩猩)相似，再后来就写了monkey(猴子)。
　　2，还有一种解释是说由于这种方式将原来的代码弄乱了(messing with it)，在英文里叫monkeying about(顽皮的)，所以叫做Monkey Patch。


# 二. 猴子补丁的功能(一切皆对象)
　　1.拥有在模块运行时替换的功能, 例如: 一个函数对象赋值给另外一个函数对象(把函数原本的执行的功能给替换了)
class Monkey:
    def hello(self):
        print(\'hello\')

    def world(self):
        print(\'world\')


def other_func():
    print("from other_func")



monkey = Monkey()
monkey.hello = monkey.world
monkey.hello()
monkey.world = other_func
monkey.world()

# 三.monkey patch的应用场景
如果我们的程序中已经基于json模块编写了大量代码了，发现有一个模块ujson比它性能更高，
但用法一样，我们肯定不会想所有的代码都换成ujson.dumps或者ujson.loads,那我们可能
会想到这么做
import ujson as json，但是这么做的需要每个文件都重新导入一下，维护成本依然很高
此时我们就可以用到猴子补丁了
只需要在入口处加上
, 只需要在入口加上:

import json
import ujson

def monkey_patch_json():
    json.__name__ = \'ujson\'
    json.dumps = ujson.dumps
    json.loads = ujson.loads

monkey_patch_json() # 之所以在入口处加，是因为模块在导入一次后，后续的导入便直接引用第一次的成果

#其实这种场景也比较多, 比如我们引用团队通用库里的一个模块, 又想丰富模块的功能, 除了继承之外也可以考虑用Monkey
Patch.采用猴子补丁之后，如果发现ujson不符合预期，那也可以快速撤掉补丁。个人感觉Monkey
Patch带了便利的同时也有搞乱源代码的风险!
    

# coding:utf-8
import pickle

with open(\'a.pkl\',mode=\'wb\') as f:
    # 一：在python3中执行的序列化操作如何兼容python2
    # python2不支持protocol>2，默认python3中protocol=4
    # 所以在python3中dump操作应该指定protocol=2
    pickle.dump(\'你好啊\',f,protocol=2)

with open(\'a.pkl\', mode=\'rb\') as f:
    # 二：python2中反序列化才能正常使用
    res=pickle.load(f)
    print(res)

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
print(root.tag)
 
#遍历xml文档
for child in root:
    print(\'========>\',child.tag,child.attrib,child.attrib[\'name\'])
    for i in child:
        print(i.tag,i.attrib,i.text)
 
#只遍历year 节点
for node in root.iter(\'year\'):
    print(node.tag,node.text)
#---------------------------------------

import xml.etree.ElementTree as ET
 
tree = ET.parse("xmltest.xml")
root = tree.getroot()
 
#修改
for node in root.iter(\'year\'):
    new_year=int(node.text)+1
    node.text=str(new_year)
    node.set(\'updated\',\'yes\')
    node.set(\'version\',\'1.0\')
tree.write(\'test.xml\')
 
 
#删除node
for country in root.findall(\'country\'):
   rank = int(country.find(\'rank\').text)
   if rank > 50:
     root.remove(country)
 
tree.write(\'output.xml\')

import xml.etree.ElementTree as ET
 
 
new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = \'33\'
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = \'19\'
 
et = ET.ElementTree(new_xml) #生成文档对象
et.write("test.xml", encoding="utf-8",xml_declaration=True)
 
ET.dump(new_xml) #打印生成的格式

import configparser
  
config = configparser.ConfigParser()
config["DEFAULT"] = {\'ServerAliveInterval\': \'45\',
                      \'Compression\': \'yes\',
                     \'CompressionLevel\': \'9\'}
  
config[\'bitbucket.org\'] = {}
config[\'bitbucket.org\'][\'User\'] = \'hg\'
config[\'topsecret.server.com\'] = {}
topsecret = config[\'topsecret.server.com\']
topsecret[\'Host Port\'] = \'50022\'     # mutates the parser
topsecret[\'ForwardX11\'] = \'no\'  # same here
config[\'DEFAULT\'][\'ForwardX11\'] = \'yes\'
with open(\'example.ini\', \'w\') as configfile:
   config.write(configfile)

import hashlib
passwds=[
    \'alex3714\',
    \'alex1313\',
    \'alex94139413\',
    \'alex123456\',
    \'123456alex\',
    \'a123lex\',
    ]
def make_passwd_dic(passwds):
    dic={}
    for passwd in passwds:
        m=hashlib.md5()
        m.update(passwd.encode(\'utf-8\'))
        dic[passwd]=m.hexdigest()
    return dic

def break_code(cryptograph,passwd_dic):
    for k,v in passwd_dic.items():
        if v == cryptograph:
            print(\'密码是===>\033[46m%s\033[0m\' %k)

cryptograph=\'aee949757a2e698417463d47acac93df\'
break_code(cryptograph,make_passwd_dic(passwds))

#要想保证hmac最终结果一致，必须保证：
#1:hmac.new括号内指定的初始key一样
#2:无论update多少次，校验的内容累加到一起是一样的内容

# 操作一
import hmac
h1=hmac.new(\'hello\'.encode(\'utf-8\'),digestmod=\'md5\')
h1.update(\'world\'.encode(\'utf-8\'))

print(h1.hexdigest()) # 0e2564b7e100f034341ea477c23f283b

# 操作二
import hmac
h2=hmac.new(\'hello\'.encode(\'utf-8\'),digestmod=\'md5\')
h2.update(\'w\'.encode(\'utf-8\'))
h2.update(\'orld\'.encode(\'utf-8\'))

print(h1.hexdigest()) # 0e2564b7e100f034341ea477c23f283b

可在logging.basicConfig()函数中通过具体参数来更改logging模块默认行为，可用参数有
filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。 
datefmt：指定日期时间格式。 
level：设置rootlogger（后边会讲解具体概念）的日志级别 
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。



#格式
%(name)s：Logger的名字，并非用户名，详细查看

%(levelno)s：数字形式的日志级别

%(levelname)s：文本形式的日志级别

%(pathname)s：调用日志输出函数的模块的完整路径名，可能没有

%(filename)s：调用日志输出函数的模块的文件名

%(module)s：调用日志输出函数的模块名

%(funcName)s：调用日志输出函数的函数名

%(lineno)d：调用日志输出函数的语句所在的代码行

%(created)f：当前时间，用UNIX标准的表示时间的浮 点数表示

%(relativeCreated)d：输出日志信息时的，自Logger创建以 来的毫秒数

%(asctime)s：字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒

%(thread)d：线程ID。可能没有

%(threadName)s：线程名。可能没有

%(process)d：进程ID。可能没有

%(message)s：用户输出的消息

 

#======介绍
可在logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有
filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置rootlogger（后边会讲解具体概念）的日志级别
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。


format参数中可能用到的格式化串：
%(name)s Logger的名字
%(levelno)s 数字形式的日志级别
%(levelname)s 文本形式的日志级别
%(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
%(filename)s 调用日志输出函数的模块的文件名
%(module)s 调用日志输出函数的模块名
%(funcName)s 调用日志输出函数的函数名
%(lineno)d 调用日志输出函数的语句所在的代码行
%(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
%(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d 线程ID。可能没有
%(threadName)s 线程名。可能没有
%(process)d 进程ID。可能没有
%(message)s用户输出的消息




#========使用
import logging
logging.basicConfig(filename=\'access.log\',
                    format=\'%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s\',
                    datefmt=\'%Y-%m-%d %H:%M:%S %p\',
                    level=10)

logging.debug(\'调试debug\')
logging.info(\'消息info\')
logging.warning(\'警告warn\')
logging.error(\'错误error\')
logging.critical(\'严重critical\')





#========结果
access.log内容:
2017-07-28 20:32:17 PM - root - DEBUG -test:  调试debug
2017-07-28 20:32:17 PM - root - INFO -test:  消息info
2017-07-28 20:32:17 PM - root - WARNING -test:  警告warn
2017-07-28 20:32:17 PM - root - ERROR -test:  错误error
2017-07-28 20:32:17 PM - root - CRITICAL -test:  严重critical

part2: 可以为logging模块指定模块级的配置,即所有logger的配置

\'\'\'
critical=50
error =40
warning =30
info = 20
debug =10
\'\'\'


import logging

#1、logger对象：负责产生日志，然后交给Filter过滤，然后交给不同的Handler输出
logger=logging.getLogger(__file__)

#2、Filter对象：不常用，略

#3、Handler对象：接收logger传来的日志，然后控制输出
h1=logging.FileHandler(\'t1.log\') #打印到文件
h2=logging.FileHandler(\'t2.log\') #打印到文件
h3=logging.StreamHandler() #打印到终端

#4、Formatter对象：日志格式
formmater1=logging.Formatter(\'%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s\',
                    datefmt=\'%Y-%m-%d %H:%M:%S %p\',)

formmater2=logging.Formatter(\'%(asctime)s :  %(message)s\',
                    datefmt=\'%Y-%m-%d %H:%M:%S %p\',)

formmater3=logging.Formatter(\'%(name)s %(message)s\',)


#5、为Handler对象绑定格式
h1.setFormatter(formmater1)
h2.setFormatter(formmater2)
h3.setFormatter(formmater3)

#6、将Handler添加给logger并设置日志级别
logger.addHandler(h1)
logger.addHandler(h2)
logger.addHandler(h3)
logger.setLevel(10)

#7、测试
logger.debug(\'debug\')
logger.info(\'info\')
logger.warning(\'warning\')
logger.error(\'error\')
logger.critical(\'critical\')

Logger is also the first to filter the message based on a level — if you set the logger to INFO, and all handlers to DEBUG, you still won\'t receive DEBUG messages on handlers — they\'ll be rejected by the logger itself. If you set logger to DEBUG, but all handlers to INFO, you won\'t receive any DEBUG messages either — because while the logger says "ok, process this", the handlers reject it (DEBUG < INFO).



#验证
import logging


form=logging.Formatter(\'%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s\',
                    datefmt=\'%Y-%m-%d %H:%M:%S %p\',)

ch=logging.StreamHandler()

ch.setFormatter(form)
# ch.setLevel(10)
ch.setLevel(20)

l1=logging.getLogger(\'root\')
# l1.setLevel(20)
l1.setLevel(10)
l1.addHandler(ch)

l1.debug(\'l1 debug\')

import logging

formatter=logging.Formatter(\'%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s\',
                    datefmt=\'%Y-%m-%d %H:%M:%S %p\',)

ch=logging.StreamHandler()
ch.setFormatter(formatter)


logger1=logging.getLogger(\'root\')
logger2=logging.getLogger(\'root.child1\')
logger3=logging.getLogger(\'root.child1.child2\')


logger1.addHandler(ch)
logger2.addHandler(ch)
logger3.addHandler(ch)
logger1.setLevel(10)
logger2.setLevel(10)
logger3.setLevel(10)

logger1.debug(\'log1 debug\')
logger2.debug(\'log2 debug\')
logger3.debug(\'log3 debug\')
\'\'\'
2017-07-28 22:22:05 PM - root - DEBUG -test:  log1 debug
2017-07-28 22:22:05 PM - root.child1 - DEBUG -test:  log2 debug
2017-07-28 22:22:05 PM - root.child1 - DEBUG -test:  log2 debug
2017-07-28 22:22:05 PM - root.child1.child2 - DEBUG -test:  log3 debug
2017-07-28 22:22:05 PM - root.child1.child2 - DEBUG -test:  log3 debug
2017-07-28 22:22:05 PM - root.child1.child2 - DEBUG -test:  log3 debug
\'\'\'

"""
logging配置
"""

import os
import logging.config

# 定义三种日志输出格式 开始

standard_format = \'[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]\' \
                  \'[%(levelname)s][%(message)s]\' #其中name为getlogger指定的名字

simple_format = \'[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s\'

id_simple_format = \'[%(levelname)s][%(asctime)s] %(message)s\'

# 定义日志输出格式 结束

logfile_dir = os.path.dirname(os.path.abspath(__file__))  # log文件的目录

logfile_name = \'all2.log\'  # log文件名

# 如果不存在定义的日志目录就创建一个
if not os.path.isdir(logfile_dir):
    os.mkdir(logfile_dir)

# log文件的全路径
logfile_path = os.path.join(logfile_dir, logfile_name)

# log配置字典
LOGGING_DIC = {
    \'version\': 1,
    \'disable_existing_loggers\': False,
    \'formatters\': {
        \'standard\': {
            \'format\': standard_format
        },
        \'simple\': {
            \'format\': simple_format
        },
    },
    \'filters\': {},
    \'handlers\': {
        #打印到终端的日志
        \'console\': {
            \'level\': \'DEBUG\',
            \'class\': \'logging.StreamHandler\',  # 打印到屏幕
            \'formatter\': \'simple\'
        },
        #打印到文件的日志,收集info及以上的日志
        \'default\': {
            \'level\': \'DEBUG\',
            \'class\': \'logging.handlers.RotatingFileHandler\',  # 保存到文件
            \'formatter\': \'standard\',
            \'filename\': logfile_path,  # 日志文件
            \'maxBytes\': 1024*1024*5,  # 日志大小 5M
            \'backupCount\': 5,
            \'encoding\': \'utf-8\',  # 日志文件的编码，再也不用担心中文log乱码了
        },
    },
    \'loggers\': {
        #logging.getLogger(__name__)拿到的logger配置
        \'\': {
            \'handlers\': [\'default\', \'console\'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            \'level\': \'DEBUG\',
            \'propagate\': True,  # 向上（更高level的logger）传递
        },
    },
}


def load_my_logging_cfg():
    logging.config.dictConfig(LOGGING_DIC)  # 导入上面定义的logging配置
    logger = logging.getLogger(__name__)  # 生成一个log实例
    logger.info(\'It works!\')  # 记录该文件的运行状态

if __name__ == \'__main__\':
    load_my_logging_cfg()

"""
MyLogging Test
"""

import time
import logging
import my_logging  # 导入自定义的logging配置

logger = logging.getLogger(__name__)  # 生成logger实例


def demo():
    logger.debug("start range... time:{}".format(time.time()))
    logger.info("中文测试开始。。。")
    for i in range(10):
        logger.debug("i:{}".format(i))
        time.sleep(0.2)
    else:
        logger.debug("over range... time:{}".format(time.time()))
    logger.info("中文测试结束。。。")

if __name__ == "__main__":
    my_logging.load_my_logging_cfg()  # 在你程序文件的入口加载自定义logging配置
    demo()

注意注意注意：


#1、有了上述方式我们的好处是：所有与logging模块有关的配置都写到字典中就可以了，更加清晰，方便管理


#2、我们需要解决的问题是：
    1、从字典加载配置：logging.config.dictConfig(settings.LOGGING_DIC)

    2、拿到logger对象来产生日志
    logger对象都是配置到字典的loggers 键对应的子字典中的
    按照我们对logging模块的理解，要想获取某个东西都是通过名字，也就是key来获取的
    于是我们要获取不同的logger对象就是
    logger=logging.getLogger(\'loggers子字典的key名\')

    
    但问题是：如果我们想要不同logger名的logger对象都共用一段配置，那么肯定不能在loggers子字典中定义n个key   
 \'loggers\': {    
        \'l1\': {
            \'handlers\': [\'default\', \'console\'],  #
            \'level\': \'DEBUG\',
            \'propagate\': True,  # 向上（更高level的logger）传递
        },
        \'l2: {
            \'handlers\': [\'default\', \'console\' ], 
            \'level\': \'DEBUG\',
            \'propagate\': False,  # 向上（更高level的logger）传递
        },
        \'l3\': {
            \'handlers\': [\'default\', \'console\'],  #
            \'level\': \'DEBUG\',
            \'propagate\': True,  # 向上（更高level的logger）传递
        },

}

    
#我们的解决方式是，定义一个空的key
    \'loggers\': {
        \'\': {
            \'handlers\': [\'default\', \'console\'], 
            \'level\': \'DEBUG\',
            \'propagate\': True, 
        },

}

这样我们再取logger对象时
logging.getLogger(__name__)，不同的文件__name__不同，这保证了打印日志时标识信息不同，但是拿着该名字去loggers里找key名时却发现找不到，于是默认使用key=\'\'的配置

#logging_config.py
LOGGING = {
    \'version\': 1,
    \'disable_existing_loggers\': False,
    \'formatters\': {
        \'standard\': {
            \'format\': \'[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]\'
                      \'[%(levelname)s][%(message)s]\'
        },
        \'simple\': {
            \'format\': \'[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s\'
        },
        \'collect\': {
            \'format\': \'%(message)s\'
        }
    },
    \'filters\': {
        \'require_debug_true\': {
            \'()\': \'django.utils.log.RequireDebugTrue\',
        },
    },
    \'handlers\': {
        #打印到终端的日志
        \'console\': {
            \'level\': \'DEBUG\',
            \'filters\': [\'require_debug_true\'],
            \'class\': \'logging.StreamHandler\',
            \'formatter\': \'simple\'
        },
        #打印到文件的日志,收集info及以上的日志
        \'default\': {
            \'level\': \'INFO\',
            \'class\': \'logging.handlers.RotatingFileHandler\',  # 保存到文件，自动切
            \'filename\': os.path.join(BASE_LOG_DIR, "xxx_info.log"),  # 日志文件
            \'maxBytes\': 1024 * 1024 * 5,  # 日志大小 5M
            \'backupCount\': 3,
            \'formatter\': \'standard\',
            \'encoding\': \'utf-8\',
        },
        #打印到文件的日志:收集错误及以上的日志
        \'error\': {
            \'level\': \'ERROR\',
            \'class\': \'logging.handlers.RotatingFileHandler\',  # 保存到文件，自动切
            \'filename\': os.path.join(BASE_LOG_DIR, "xxx_err.log"),  # 日志文件
            \'maxBytes\': 1024 * 1024 * 5,  # 日志大小 5M
            \'backupCount\': 5,
            \'formatter\': \'standard\',
            \'encoding\': \'utf-8\',
        },
        #打印到文件的日志
        \'collect\': {
            \'level\': \'INFO\',
            \'class\': \'logging.handlers.RotatingFileHandler\',  # 保存到文件，自动切
            \'filename\': os.path.join(BASE_LOG_DIR, "xxx_collect.log"),
            \'maxBytes\': 1024 * 1024 * 5,  # 日志大小 5M
            \'backupCount\': 5,
            \'formatter\': \'collect\',
            \'encoding\': "utf-8"
        }
    },
    \'loggers\': {
        #logging.getLogger(__name__)拿到的logger配置
        \'\': {
            \'handlers\': [\'default\', \'console\', \'error\'],
            \'level\': \'DEBUG\',
            \'propagate\': True,
        },
        #logging.getLogger(\'collect\')拿到的logger配置
        \'collect\': {
            \'handlers\': [\'console\', \'collect\'],
            \'level\': \'INFO\',
        }
    },
}


# -----------
# 用法:拿到俩个logger

logger = logging.getLogger(__name__) #线上正常的日志
collect_logger = logging.getLogger("collect") #领导说,需要为领导们单独定制领导们看的日志

"""
logging配置
"""

import os

# 1、定义三种日志输出格式，日志中可能用到的格式化串如下
# %(name)s Logger的名字
# %(levelno)s 数字形式的日志级别
# %(levelname)s 文本形式的日志级别
# %(pathname)s 调用日志输出函数的模块的完整路径名，可能没有
# %(filename)s 调用日志输出函数的模块的文件名
# %(module)s 调用日志输出函数的模块名
# %(funcName)s 调用日志输出函数的函数名
# %(lineno)d 调用日志输出函数的语句所在的代码行
# %(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示
# %(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数
# %(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
# %(thread)d 线程ID。可能没有
# %(threadName)s 线程名。可能没有
# %(process)d 进程ID。可能没有
# %(message)s用户输出的消息

# 2、强调：其中的%(name)s为getlogger时指定的名字
standard_format = \'[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]\' \
                  \'[%(levelname)s][%(message)s]\'

simple_format = \'[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s\'

test_format = \'%(asctime)s] %(message)s\'

# 3、日志配置字典
LOGGING_DIC = {
    \'version\': 1,
    \'disable_existing_loggers\': False,
    \'formatters\': {
        \'standard\': {
            \'format\': standard_format
        },
        \'simple\': {
            \'format\': simple_format
        },
        \'test\': {
            \'format\': test_format
        },
    },
    \'filters\': {},
    \'handlers\': {
        #打印到终端的日志
        \'console\': {
            \'level\': \'DEBUG\',
            \'class\': \'logging.StreamHandler\',  # 打印到屏幕
            \'formatter\': \'simple\'
        },
        #打印到文件的日志,收集info及以上的日志
        \'default\': {
            \'level\': \'DEBUG\',
            \'class\': \'logging.handlers.RotatingFileHandler\',  # 保存到文件,日志轮转
            \'formatter\': \'standard\',
            # 可以定制日志文件路径
            # BASE_DIR = os.path.dirname(os.path.abspath(__file__))  # log文件的目录
            # LOG_PATH = os.path.join(BASE_DIR,\'a1.log\')
            \'filename\': \'a1.log\',  # 日志文件
            \'maxBytes\': 1024*1024*5,  # 日志大小 5M
            \'backupCount\': 5,
            \'encoding\': \'utf-8\',  # 日志文件的编码，再也不用担心中文log乱码了
        },
        \'other\': {
            \'level\': \'DEBUG\',
            \'class\': \'logging.FileHandler\',  # 保存到文件
            \'formatter\': \'test\',
            \'filename\': \'a2.log\',
            \'encoding\': \'utf-8\',
        },
    },
    \'loggers\': {
        #logging.getLogger(__name__)拿到的logger配置
        \'\': {
            \'handlers\': [\'default\', \'console\'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            \'level\': \'DEBUG\', # loggers(第一层日志级别关限制)--->handlers(第二层日志级别关卡限制)
            \'propagate\': False,  # 默认为True，向上（更高level的logger）传递，通常设置为False即可，否则会一份日志向上层层传递
        },
        \'专门的采集\': {
            \'handlers\': [\'other\',],
            \'level\': \'DEBUG\',
            \'propagate\': False,
        },
    },
}

import settings

# !!!强调!!!
# 1、logging是一个包，需要使用其下的config、getLogger，可以如下导入
# from logging import config
# from logging import getLogger

# 2、也可以使用如下导入
import logging.config # 这样连同logging.getLogger都一起导入了,然后使用前缀logging.config.

# 3、加载配置
logging.config.dictConfig(settings.LOGGING_DIC)

# 4、输出日志
logger1=logging.getLogger(\'用户交易\')
logger1.info(\'egon儿子alex转账3亿冥币\')

# logger2=logging.getLogger(\'专门的采集\') # 名字传入的必须是\'专门的采集\'，与LOGGING_DIC中的配置唯一对应
# logger2.debug(\'专门采集的日志\')

import re
print(re.findall("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")) #[\'h1\']
print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>").group()) #<h1>hello</h1>
print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>").groupdict()) #<h1>hello</h1>

print(re.search(r"<(\w+)>\w+</(\w+)>","<h1>hello</h1>").group())
print(re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>").group())

#为何同样的表达式search与findall却有不同结果:
print(re.search(\'\(([\+\-\*\/]*\d+\.?\d*)+\)\',"1-12*(60+(-40.35/5)-(-4*3))").group()) #(-40.35/5)
print(re.findall(\'\(([\+\-\*\/]*\d+\.?\d*)+\)\',"1-12*(60+(-40.35/5)-(-4*3))")) #[\'/5\', \'*3\']

#看这个例子:(\d)+相当于(\d)(\d)(\d)(\d)...,是一系列分组
print(re.search(\'(\d)+\',\'123\').group()) #group的作用是将所有组拼接到一起显示出来
print(re.findall(\'(\d)+\',\'123\')) #findall结果是组内的结果,且是最后一个组的结果

#_*_coding:utf-8_*_
__author__ = \'Linhaifeng\'
#在线调试工具:tool.oschina.net/regex/#
import re

s=\'\'\'
http://www.baidu.com
egon@oldboyedu.com
你好
010-3141
\'\'\'

#最常规匹配
# content=\'Hello 123 456 World_This is a Regex Demo\'
# res=re.match(\'Hello\s\d\d\d\s\d{3}\s\w{10}.*Demo\',content)
# print(res)
# print(res.group())
# print(res.span())

#泛匹配
# content=\'Hello 123 456 World_This is a Regex Demo\'
# res=re.match(\'^Hello.*Demo\',content)
# print(res.group())


#匹配目标,获得指定数据

# content=\'Hello 123 456 World_This is a Regex Demo\'
# res=re.match(\'^Hello\s(\d+)\s(\d+)\s.*Demo\',content)
# print(res.group()) #取所有匹配的内容
# print(res.group(1)) #取匹配的第一个括号内的内容
# print(res.group(2)) #去陪陪的第二个括号内的内容



#贪婪匹配:.*代表匹配尽可能多的字符
# import re
# content=\'Hello 123 456 World_This is a Regex Demo\'
#
# res=re.match(\'^He.*(\d+).*Demo$\',content)
# print(res.group(1)) #只打印6,因为.*会尽可能多的匹配,然后后面跟至少一个数字


#非贪婪匹配:?匹配尽可能少的字符
# import re
# content=\'Hello 123 456 World_This is a Regex Demo\'
#
# res=re.match(\'^He.*?(\d+).*Demo$\',content)
# print(res.group(1)) #只打印6,因为.*会尽可能多的匹配,然后后面跟至少一个数字


#匹配模式:.不能匹配换行符
content=\'\'\'Hello 123456 World_This
is a Regex Demo
\'\'\'
# res=re.match(\'He.*?(\d+).*?Demo$\',content)
# print(res) #输出None

# res=re.match(\'He.*?(\d+).*?Demo$\',content,re.S) #re.S让.可以匹配换行符
# print(res)
# print(res.group(1))


#转义:\

# content=\'price is $5.00\'
# res=re.match(\'price is $5.00\',content)
# print(res)
#
# res=re.match(\'price is \$5\.00\',content)
# print(res)


#总结:尽量精简,详细的如下
    # 尽量使用泛匹配模式.*
    # 尽量使用非贪婪模式:.*?
    # 使用括号得到匹配目标:用group(n)去取得结果
    # 有换行符就用re.S:修改模式















#re.search:会扫描整个字符串,不会从头开始,找到第一个匹配的结果就会返回

# import re
# content=\'Extra strings Hello 123 456 World_This is a Regex Demo Extra strings\'
#
# res=re.match(\'Hello.*?(\d+).*?Demo\',content)
# print(res) #输出结果为None

#
# import re
# content=\'Extra strings Hello 123 456 World_This is a Regex Demo Extra strings\'
#
# res=re.search(\'Hello.*?(\d+).*?Demo\',content) #
# print(res.group(1)) #输出结果为



#re.search:只要一个结果,匹配演练,
import re
content=\'\'\'
<tbody>
<tr id="4766303201494371851675" class="even "><td><div class="hd"><span class="num">1</span><div class="rk "><span class="u-icn u-icn-75"></span></div></div></td><td class="rank"><div class="f-cb"><div class="tt"><a href="/song?id=476630320"><img class="rpic" src="http://p1.music.126.net/Wl7T1LBRhZFg0O26nnR2iQ==/19217264230385030.jpg?param=50y50&amp;quality=100"></a><span data-res-id="476630320" "
# res=re.search(\'<a\shref=.*?<b\stitle="(.*?)".*?b>\',content)
# print(res.group(1))


#re.findall:找到符合条件的所有结果
# res=re.findall(\'<a\shref=.*?<b\stitle="(.*?)".*?b>\',content)
# for i in res:
#     print(i)



#re.sub:字符串替换
import re
content=\'Extra strings Hello 123 456 World_This is a Regex Demo Extra strings\'

# content=re.sub(\'\d+\',\'\',content)
# print(content)


#用\1取得第一个括号的内容
#用法:将123与456换位置
# import re
# content=\'Extra strings Hello 123 456 World_This is a Regex Demo Extra strings\'
#
# # content=re.sub(\'(Extra.*?)(\d+)(\s)(\d+)(.*?strings)\',r\'\1\4\3\2\5\',content)
# content=re.sub(\'(\d+)(\s)(\d+)\',r\'\3\2\1\',content)
# print(content)




# import re
# content=\'Extra strings Hello 123 456 World_This is a Regex Demo Extra strings\'
#
# res=re.search(\'Extra.*?(\d+).*strings\',content)
# print(res.group(1))


# import requests,re
# respone=requests.get(\'https://book.douban.com/\').text

# print(respone)
# print(\'======\'*1000)
# print(\'======\'*1000)
# print(\'======\'*1000)
# print(\'======\'*1000)
# res=re.findall(\'<li.*?cover.*?href="(.*?)".*?title="(.*?)">.*?more-meta.*?author">(.*?)</span.*?year">(.*?)</span.*?publisher">(.*?)</span.*?</li>\',respone,re.S)
# # res=re.findall(\'<li.*?cover.*?href="(.*?)".*?more-meta.*?author">(.*?)</span.*?year">(.*?)</span.*?publisher">(.*?)</span>.*?</li>\',respone,re.S)
#
#
# for i in res:
#     print(\'%s    %s    %s   %s\' %(i[0].strip(),i[1].strip(),i[2].strip(),i[3].strip()))

import re

# 1、匹配密码，密码必须是由6位数字与字母组成，并且不能是纯数字也不能是纯字母
# 1.1 知识点：# ?!pattern,表示在没有配到pattern的字符串的前提下，再进行后续的正则表达式匹配，后续匹配仍然从被匹配字符串的头开始

# 1.2 答案：
print(re.search("(?!^[0-9]+$)(?!^[a-zA-Z]+$)^[0-9A-Za-z]{6}$","123asf").group())  # 123asf

# 1.3 解释：
# 上述正则的意思为：在匹配(?!^[0-9]+$)以及(?!^[a-zA-Z]+$)过后，如果字符串成功后在从头去匹配(?!^[a-zA-Z]+$)，最终匹配完。


# 2、匹配密码，密码强度：强，必须包含大写，小写和数字,和特殊字符(!,@,#,%,&),且大于6位
# 2.1 知识点：# ?=pattern,表示在配到pattern的字符串的前提下，再进行后续的正则表达式匹配，后续匹配仍然从被匹配字符串的头开始

# 2.2 答案：
# while True:
#     pwd = input("please your password: ").strip()  # 比如输入：Aa3@adf123
#     pwd_pattern= re.compile("(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])(?=.*[!@#%&])^([a-zA-Z0-9!@#%&]){6,}$")
#     if pwd_pattern.search(pwd) is None:
#         print("密码强度不够")
#     else:
#         break

# 2.3 解释：
# 上述正则表达式的意思：
#（1）首先是(?=.*[A-Z])匹配，.*表示密码中可以包含多个字符，[A-Z]代表密码中需要包含至少一个大写字母，注意一定不要去掉.*写成(?=[A-Z]),那样表示密码只能由一个字符组成，该字符是大写字母
#（2）其次是(?=.*[a-z])匹配，同上，确保密码中必须至少有一个小写字母
#（3）然后是(?=.*[0-9])匹配，同上，确保密码中必须至少有一个数字
#（4）然后是(?=.*[!@#%&])匹配，同上，，确保密码中必须至少有一个特殊符号!@#%&

#（5）最后是^([a-zA-Z0-9!@#%&]){6,}$，确保密码是由[a-zA-Z0-9!@#%&]字符构成，至少有6位


# 3、匹配email
# print(re.findall("(?:[a-zA-Z0-9]+)@(?:[0-9a-zA-Z]+).com","18611323113@163.com xxx@qq.com"))

# 4、匹配身份证
# your_id=input(">>: ").strip()
# print(re.findall("^([0-9]){17}([0-9]|X)$",your_id)) # 17个数字组成，最后一个字符可以是数字或X

# 5、匹配用户名，包含字母或者数字,且8位
# print(re.findall("^[0-9a-zA-Z]{8}$","egonlinh"))

# 5.1、要求输入的内容只能是汉字
# name=input(\'>>: \').strip()
# print(re.search(r\'[\u4E00-\u9fa5]+\',name))

# 6、取出字符串里的数字
# print(re.findall(r\'\d+(?:\.\d+)?\', \'sww123kw11.333e2lkd\'))

# 7、取出所有负整数
# print(re.findall(r\'-\d+\', \'-12,3,54,-13.11,64，-9\'))  # 错误答案
# print(re.findall(r\'(?!-\d+\.\d+)-\d+\', \'-12,3,54,-13.11,64，-9\'))  # 正确答案

# 8、所有数字
# print(re.findall(r\'\-?\d+(?:\.\d+)?\', \'-12.9,3.92,54.11,64，89，-9，-45.2\'))

# 9、所有负数
# print(re.findall(r\'\-\d+(?:\.\d+)?\', \'-12.9,3.92,54.11,64，89，-9，-45.2\'))

# 10、所有的非负浮点数
print(re.findall(r\'\d+\.\d+\', \'-12.9,3.92,54.11,64，89，-9，-45.2\'))

# 11、
msg = """
中文名 贝拉克·侯赛因·奥巴马 
外文名 Barack Hussein Obama II 
别名 欧巴马 
性 别 男
国籍 美国 
民 族 德裔族 
出生地 美国夏威夷州檀香山 
出生日期 1961年8月4日 
职 业政治家、律师、总统 
毕业院校 哥伦比亚大学，哈佛大学 
信 仰新教 
主要成就 1996年伊利诺伊州参议员 
主要成就 美国第56届、57届总统 2009年诺贝尔和平奖获得者 时代周刊年度风云人物2008、2011 任期内清除本·拉登 
代表作品 《我相信变革》《我父亲的梦想》《无畏的希望》 
所属政党美国民主党 
血 型 AB型 
学 院西方学院 
妻 子 米歇尔·拉沃恩·奥巴马 

"""
#外文名
print(re.findall("外文名 (.*)",msg))

#出生日期
print(re.findall(\'出生日期 (\d{4})年(\d+)月(\d+)日\',msg))

#妻子姓名
print(re.findall(\'妻 子 (\S+)\',msg))