常用模块

Python中只有函数，类，模块能够建立自己的名称空间
for循环和条件语句还有其他的都没有自己的作用域

一、time模块

　　在Python中，通常有这三种方式来表示时间：时间戳、元组(struct_time)、格式化的时间字符串：
　　(1)时间戳(timestamp) ：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。

　　(2)格式化的时间字符串(Format String)： ‘1988-03-16’

　　(3)元组(struct_time) ：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一周中第几天，一年中第几天等）

import time
# print(time.time())#时间戳，给电脑用的
# print(time.localtime())#元组，给程序调用的
# print(time.strftime("%Y-%m-%d %X"))#格式化输出字符串，给人看的
# print(time.strftime("%x %X"))#格式化输出字符串，给人看的

　　有个特别傻逼的人问了我一个特别傻逼的问题说怎么输出2017-11-01  - 2017-12-01中间的日期，代码如下

import time
start_time = time.mktime(time.strptime("2017-11-01","%Y-%m-%d"))
end_time = time.mktime(time.strptime("2017-12-01","%Y-%m-%d"))
while start_time <= end_time:
    print(time.strftime("%Y-%m-%d",time.localtime(start_time)))
    start_time += 86400.0

　　后来这个傻逼又问我能不能输出星期几

import time
start_time = time.mktime(time.strptime("2017-12-01","%Y-%m-%d"))
end_time = time.mktime(time.strptime("2018-1-17","%Y-%m-%d"))
w_dic = {"0":"星期日","1":"星期一","2":"星期二","3":"星期三","4":"星期四","5":"星期五","6":"星期六"}
while start_time <= end_time:
    date_num_mode = time.strftime("%Y-%m-%d %w",time.localtime(start_time))
    date_ymd,date_w = date_num_mode.split(" ")
    print(date_ymd,w_dic[date_w])
    start_time += 86400.0

　　

# <1> 时间戳

>>> import time
>>> time.time()      #--------------返回当前时间的时间戳

1493136727.099066

# <2> 时间元组

>>> time.localtime()
time.struct_time(tm_year=2017, tm_mon=4, tm_mday=26,
                 tm_hour=0, tm_min=32, tm_sec=42, tm_wday=2,
                 tm_yday=116, tm_isdst=0)


# <3> 时间字符串

>>> time.strftime("%Y-%m-%d %X")
'2017-04-26 00:32:18'

　　小结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的

　几种形式之间的转化

　　(1)

                                   

#时间戳-->结构化时间-->字符串时间
#字符串时间-->结构化时间-->时间戳
#时间戳不能直接转换成字符串时间，字符串时间也不能直接转换成时间戳，他们必须经过中间人结构化时间

#时间戳==>结构化时间 localtime/gmtime(seconds=None)
# print(time.localtime(3600*24))#默认传当前时间，东八区时间
# print(time.gmtime(3600*24))#默认传当前时间，标准时区时间

#结构化时间的使用实例time.struct_time就是一个元组
# t=time.localtime()#这一步就是类实例化出一个对象，是struct_time的对象
# help(t)#可以通过help查询struct_time对象的属性
# print(t.tm_hour)#只是其中一个属性，这个是.不出来的pycharm不支持

#结构化时间==>时间戳 mktime(p_tuple)
# print(time.mktime(time.localtime()))#默认传当前时间

#结构化时间==>字符串时间 strftime(format, p_tuple=None) -> string
# print(time.strftime("%Y-%m-%d %X",time.localtime()))#time.localtime()结果就是一个元组

#字符串时间==>结构化时间 strptime(string, format) -> struct_time
# print(time.strptime("2017-04-26 16:26:04","%Y-%m-%d %X"))#两个参数必须一一对应

　　(2)

                                    

#结构化时间==>字符串时间 asctime([tuple]) -> string
# print(time.asctime(time.localtime(3123425546)))#Sun Dec 23 02:12:26 2068，固定格式
#时间戳==>字符串时间  ctime(seconds) -> string
# print(time.ctime(3123425546))#Sun Dec 23 02:12:26 2068，固定格式

#---------其他方法---------
#time.sleep(seconds)
#线程推迟指定的时间运行，单位为秒

　　

二、random模块

>>> import random
>>> random.random()      # 大于0且小于1之间的小数
0.7664338663654585

>>> random.randint(1,5)  # 大于等于1且小于等于5之间的整数
2

>>> random.randrange(1,3) # 大于等于1且小于3之间的整数
1

>>> random.choice([1,'23',[4,5]])  # #1或者23或者[4,5]
1

>>> random.sample([1,'23',[4,5]],2) # #列表元素任意2个组合
[[4, 5], '23']

>>> random.uniform(1,3) #大于1小于3的小数
1.6270147180533838

>>> item=[1,3,5,7,9]
>>> random.shuffle(item) # 打乱次序
>>> item
[5, 1, 3, 7, 9]
>>> random.shuffle(item)
>>> item
[5, 9, 7, 1, 3]

　　练习：生成验证码

# import random
# def v_code():
#     code="" #先定一个空字符串，用来装验证码
#     for i in range(5): #确定验证码的位数为5位，循环五次
#         num=random.randint(0,9) #随机取一个整数
#         alf=chr(random.randint(65,90)) #通过ascii码表取出65-90，即a-z中的任意一个
#         add=random.choice([num,alf]) #在数字和字母中随机取一个,注意choice的参数用[]包起来
#         code="".join([code,str(add)]) #完成字符串的拼接，并赋值给code，初始的code为空为了保证正常拼接
#     return code  #返回拼接好的5位字符串
# print(v_code())

　　

三、hashlib模块

　算法介绍

　　Python的hashlib提供了常见的摘要算法，如MD5，SHA1等等。　

　　什么是摘要算法呢？摘要算法又称哈希算法、散列算法。它通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用16进制的字符串表示）。

　　摘要算法就是通过摘要函数f()对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被人篡改过。

　　摘要算法之所以能指出数据是否被篡改过，就是因为摘要函数是一个单向函数，计算f(data)很容易，但通过digest反推data却非常困难。而且，对原始数据做一个bit的修改，都会导致计算出的摘要完全不同。

　　我们以常见的摘要算法MD5为例，计算出一个字符串的MD5值：

import hashlib
# md5 = hashlib.md5() #模块里的类实例化出一个对象
# print(md5) #<md5 HASH object @ 0x0000000000A1FCD8>
# help(md5)
# md5.update("how to use md5 in python hashlib?".encode("utf8"))
# #在Python3中，Unicode-objects must be encoded before hashing
# #在Python2中，不需要解码，因为一运行就是字节
# print(md5.hexdigest())

　　如果数据量很大，可以分块多次调用update()，最后计算的结果是一样的：

# md5 = hashlib.md5()
# md5.update("how to use md5".encode("utf-8"))
# md5.update("in python hashlib?".encode("utf-8"))
# print(md5.hexdigest())

　　MD5是最常见的摘要算法，速度很快，生成结果是固定的128 bit字节，通常用一个32位的16进制字符串表示。另一种常见的摘要算法是SHA1，调用SHA1和调用MD5完全类似：

# sha1 = hashlib.sha1()
# sha1.update("how to use md5".encode("utf-8"))
# sha1.update("in python hashlib?".encode("utf-8"))
# print(sha1.hexdigest())

　　SHA1的结果是160 bit字节，通常用一个40位的16进制字符串表示。比SHA1更安全的算法是SHA256和SHA512，不过越安全的算法越慢，而且摘要长度更长。

　摘要算法应用

　　任何允许用户登录的网站都会存储用户登录的用户名和口令。如何存储用户名和口令呢？方法是存到数据库表中：

name    | password
--------+----------
michael | 123456
bob     | abc999
alice   | alice2008

　　如果以明文保存用户口令，如果数据库泄露，所有用户的口令就落入黑客的手里。此外，网站运维人员是可以访问数据库的，也就是能获取到所有用户的口令。正确的保存口令的方式是不存储用户的明文口令，而是存储用户口令的摘要，比如MD5：

username | password
---------+---------------------------------
michael  | e10adc3949ba59abbe56e057f20f883e
bob      | 878ef96e86145580c38c87f0410ad153
alice    | 99b1c2188db85afee403b1536010c2c9

　　考虑这么个情况，很多用户喜欢用123456，888888，password这些简单的口令，于是，黑客可以事先计算出这些常用口令的MD5值，得到一个反推表：

'e10adc3949ba59abbe56e057f20f883e': '123456'
'21218cca77804d2ba1922c33e0151105': '888888'
'5f4dcc3b5aa765d61d8327deb882cf99': 'password'

　　这样，无需破解，只需要对比数据库的MD5，黑客就获得了使用常用口令的用户账号。

　　对于用户来讲，当然不要使用过于简单的口令。但是，我们能否在程序设计上对简单口令加强保护呢？

　　由于常用口令的MD5值很容易被计算出来，所以，要确保存储的用户口令不是那些已经被计算出来的常用口令的MD5，这一方法通过对原始口令加一个复杂字符串来实现，俗称“加盐”：

hashlib.md5("salt".encode("utf8"))

　　经过Salt处理的MD5口令，只要Salt不被黑客知道，即使用户输入简单口令，也很难通过MD5反推明文口令。

　　但是如果有两个用户都使用了相同的简单口令比如123456，在数据库中，将存储两条相同的MD5值，这说明这两个用户的口令是一样的。有没有办法让使用相同口令的用户存储不同的MD5呢？

　　如果假定用户无法修改登录名，就可以通过把登录名作为Salt的一部分来计算MD5，从而实现相同口令的用户也存储不同的MD5。

　　摘要算法在很多地方都有广泛的应用。要注意摘要算法不是加密算法，不能用于加密（因为无法通过摘要反推明文），只能用于防篡改，但是它的单向计算特性决定了可以在不存储明文口令的情况下验证用户口令。

 

四、os模块

　　Python的os模块封装了操作系统的目录和文件操作，要注意这些函数有的在os模块中，有的在os.path模块中。

　　如果我们要操作文件、目录，可以在命令行下面输入操作系统提供的各种命令来完成。比如dir、cp等命令。

　　如果要在Python程序中执行这些目录和文件的操作怎么办？其实操作系统提供的命令只是简单地调用了操作系统提供的接口函数，Python内置的os模块也可以直接调用操作系统提供的接口函数。

　　os模块是与操作系统交互的一个接口

'''
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的大小
'''

　　

五、sys模块

　　该模块对某些使用或维护的对象提供访问解释器和与翻译器交互界面的功能。

　　sys模块包含了与Python解释器和它的环境有关的函数。

　　Python简明教程中说的很详细

sys.argv           命令行参数List，第一个元素是程序本身路径,是把.py文件作为一个脚本去执行的时候直接从命令行界面传参数
sys.exit(n)        退出程序，正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

　　进度条：

import sys,time
for i in range(10):
    sys.stdout.write('#')
    time.sleep(1)
    sys.stdout.flush()

　　

六、logging模块

　一、简单应用

import logging  
logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message')  

　　输出：

　　WARNING:root:warning message
　　ERROR:root:error message
　　CRITICAL:root:critical message

　　可见，默认情况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别等级CRITICAL>ERROR>WARNING>INFO>DEBUG>NOTSET）,默认的日志格式为日志级别：Logger名称：用户输出消息。

　二、灵活配置日志界别，日志格式，输出位置

# config，默认root用户，只能让文件流向一个地方要么是屏幕要么是文件，输出接口是logging
import logging  
logging.basicConfig(level=logging.DEBUG,  
                    format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',  
                    datefmt='%a, %d %b %Y %H:%M:%S',  
                    filename='/tmp/test.log',  
                    filemode='w')  #一般是用a，不用w也会自己建文件
  
logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message')

　　查看输出：
　　cat /tmp/test.log 
　　Mon, 05 May 2014 16:29:53 test_logging.py[line:9] DEBUG debug message
　　Mon, 05 May 2014 16:29:53 test_logging.py[line:10] INFO info message
　　Mon, 05 May 2014 16:29:53 test_logging.py[line:11] WARNING warning message
　　Mon, 05 May 2014 16:29:53 test_logging.py[line:12] ERROR error message
　　Mon, 05 May 2014 16:29:53 test_logging.py[line:13] CRITICAL critical message

　　可见在logging.basicConfig()函数中可通过具体参数来改logging模块的默认行为，可用参数有filename:用指定的文件名创建FileHandler(后边会具体讲handler的概念)，这样日志会被存储在指定的文件中。

　　filmode：文件打开方式，在指定了filename时使用这个参数，默认值为"a"还可以指定为"w"。

　　format：指定handler使用的日志显示格式。

　　datefmt：指定日期时间格式

　　level：设置rootlogger的日志级别

　　stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件

　　(f=open("test.log","w")),默认为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用户输出的消息

　三、logger对象

　　上述几个例子中我们了解到了logging.debug(),logging.info(),logging.warning(),logging.error(),logging.critical()（分别用以记录不同级别的日志信息），logging.basicConfig()（用默认日志格式（Formatter）为日志系统建立一个默认的流处理器（StreamHandler），设置基础配置（如日志级别等）并加到root logger（根Logger）中）这几个logging模块级别的函数，另外还有一个模块级别的函数是logging.getLogger([name])（返回一个logger对象，如果没有指定名字将返回root logger）

　　

#logger 推荐使用，可以同时打印到屏幕和文件，吸心大法，输出接口是logger
#先产生logger对象，再产生格式对象，然后产生两个流对象并把格式对象作为参数传入，在把两个流对象作为参数传入logger对象，通过对象之间的交互完成输出
#反正就是4个对象最牛逼的是logger然后是文件流和屏幕流，最怂的是格式对象，4个对象搞来搞去
# import logging
# def get_logger():  #每次用都写这么多太麻烦，直接定义一个函数，要改需求在函数里面改就好了
#     logger = logging.getLogger() #实例化产生一个对象
#     fm=logging.Formatter("%(asctime)s-%(name)s-%(levelname)s-%(message)s") #创建一个格式对象
#     fh=logging.FileHandler("logger2") #创建一个文件流handler(处理程序)，用于写入日志
#     sh=logging.StreamHandler() #创建一个屏幕流，用于输出到控制台
#
#     fh.setFormatter(fm) #文件流吸入格式对象，对象之间的交互
#     sh.setFormatter(fm) #屏幕流吸入格式对象，对象之间的交互
#
#     logger.addHandler(fh) #添加文件流，默认就是追加写
#     logger.addHandler(sh) #添加屏幕流
#
#     logger.setLevel(logging.DEBUG) #设计等级只能对logger对象进行设置，fh和sh设计了不管用
#     return logger
# logger=get_logger()
# logger.debug("logger debug messgage")
# logger.info("logger info message")
# logger.warning("logger warning message")
# logger.error("logger error message")
# logger.critical("logger critical message")

　　

　　先看一个最简单的过程：

import logging

logger = logging.getLogger()
# 创建一个handler，用于写入日志文件
fh = logging.FileHandler('test.log')

# 再创建一个handler，用于输出到控制台
ch = logging.StreamHandler()

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

fh.setFormatter(formatter)
ch.setFormatter(formatter)

logger.addHandler(fh) #logger对象可以添加多个fh和ch对象
logger.addHandler(ch)

logger.debug('logger debug message')
logger.info('logger info message')
logger.warning('logger warning message')
logger.error('logger error message')
logger.critical('logger critical message')

　　先简单介绍一下，logging库提供了多个组件：Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口，Handler发送日志到适当的目的地，Filter提供了过滤日志信息的方法，Formatter指定日志显示格式。

 (1)Logger是一个树形层级结构，输出信息之前都要获得一个Logger（如果没有显示的获取则自动创建并使用root Logger，如第一个例子所示）。

　　logger = logging.getLogger()返回一个默认的Logger也即root Logger，并应用默认的日志级别、Handler和Formatter设置。

　　当然也可以通过Logger.setLevel(lel)指定最低的日志级别，可用的日志级别有logging.DEBUG、logging.INFO、logging.WARNING、logging.ERROR、logging.CRITICAL。

　　Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()输出不同级别的日志，只有日志等级大于或等于设置的日志级别的日志才会被输出。 

logger.debug('logger debug message')  
logger.info('logger info message')  
logger.warning('logger warning message')  
logger.error('logger error message')  
logger.critical('logger critical message')  

　　只输出了
　　2014-05-06 12:54:43,222 - root - WARNING - logger warning message
　　2014-05-06 12:54:43,223 - root - ERROR - logger error message
　　2014-05-06 12:54:43,224 - root - CRITICAL - logger critical message
     从这个输出可以看出logger = logging.getLogger()返回的Logger名为root。这里没有用logger.setLevel(logging.Debug)显示的为logger设置日志级别，所以使用默认的日志级别WARNIING，故结果只输出了大于等于WARNIING级别的信息。

 (2) 如果我们再创建两个logger对象： 

##################################################
logger1 = logging.getLogger('mylogger')
logger1.setLevel(logging.DEBUG)

logger2 = logging.getLogger('mylogger')
logger2.setLevel(logging.INFO) #logger2与logger1指向的对象是一样的，等与在这里我们有重置了等级

logger1.addHandler(fh)
logger1.addHandler(ch)

logger2.addHandler(fh)
logger2.addHandler(ch)

logger1.debug('logger1 debug message')
logger1.info('logger1 info message')
logger1.warning('logger1 warning message')
logger1.error('logger1 error message')
logger1.critical('logger1 critical message')
  
logger2.debug('logger2 debug message')
logger2.info('logger2 info message')
logger2.warning('logger2 warning message')
logger2.error('logger2 error message')
logger2.critical('logger2 critical message')

　　结果：

        

这里有两个个问题：

　　  <1>我们明明通过logger1.setLevel(logging.DEBUG)将logger1的日志级别设置为了DEBUG，为何显示的时候没有显示出DEBUG级别的日志信息，而是从INFO级别的日志开始显示呢？

 　　 原来logger1和logger2对应的是同一个Logger实例，只要logging.getLogger（name）中名称参数name相同则返回的Logger实例就是同一个，且仅有一个，也即name与Logger实例一一对应。在logger2实例中通过logger2.setLevel(logging.INFO)设置mylogger的日志级别为logging.INFO，所以最后logger1的输出遵从了后来设置的日志级别。

　　 <2>为什么logger1、logger2对应的每个输出分别显示两次?

　　 这是因为我们通过logger = logging.getLogger()显示的创建了root Logger，而logger1 = logging.getLogger('mylogger')创建了root Logger的孩子(root.)mylogger,logger2同样。而孩子,孙子，重孙……既会将消息分发给他的handler进行处理也会传递给所有的祖先Logger处理。

　　ok,那么现在我们把

　　　　# logger.addHandler(fh)

　　　　# logger.addHandler(ch)  注释掉，我们再来看效果：

　　　　

 　　因为我们注释了logger对象显示的位置，所以才用了默认方式，即标准输出方式。因为他的父级没有设定文件显示方式，所以这里只打印一次。

 　　孩子,孙子，重孙……可逐层继承来自祖先的日志级别、Handler、Filter设置，也可以通过Logger.setLevel(lel)、Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)、Logger.addFilter(filt)、Logger.removeFilter(filt)。设置自己特别的日志级别、Handler、Filter。若不设置则使用继承来的值。

　　<3>Filter 限制只有满足过滤规则的日志才会输出。

　　比如我们定义了filter = logging.Filter('a.b.c'),并将这个Filter添加到了一个Handler上，则使用该Handler的Logger中只有名字带          a.b.c前缀的Logger才能输出其日志。

　　

　　filter = logging.Filter('mylogger') 

　　logger.addFilter(filter)

　　这是只对logger这个对象进行筛选

　　如果想对所有的对象进行筛选，则：

　　filter = logging.Filter('mylogger') 

　　fh.addFilter(filter)

　　ch.addFilter(filter)

　　这样所有添加fh或者ch的logger对象都会进行筛选

import logging

logger = logging.getLogger()
# 创建一个handler，用于写入日志文件
fh = logging.FileHandler('test.log')

# 再创建一个handler，用于输出到控制台
ch = logging.StreamHandler()

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

fh.setFormatter(formatter)
ch.setFormatter(formatter)

# 定义一个filter
filter = logging.Filter('mylogger')
fh.addFilter(filter)
ch.addFilter(filter)

# logger.addFilter(filter)
logger.addHandler(fh)
logger.addHandler(ch)

logger.setLevel(logging.DEBUG)

logger.debug('logger debug message')
logger.info('logger info message')
logger.warning('logger warning message')
logger.error('logger error message')
logger.critical('logger critical message')

##################################################
logger1 = logging.getLogger('mylogger')
logger1.setLevel(logging.DEBUG)

logger2 = logging.getLogger('mylogger')
logger2.setLevel(logging.INFO)

logger1.addHandler(fh)
logger1.addHandler(ch)

logger2.addHandler(fh)
logger2.addHandler(ch)

logger1.debug('logger1 debug message')
logger1.info('logger1 info message')
logger1.warning('logger1 warning message')
logger1.error('logger1 error message')
logger1.critical('logger1 critical message')

logger2.debug('logger2 debug message')
logger2.info('logger2 info message')
logger2.warning('logger2 warning message')
logger2.error('logger2 error message')
logger2.critical('logger2 critical message')

　　

#coding:utf-8  
import logging  
  
# 创建一个logger    
logger = logging.getLogger()  
  
logger1 = logging.getLogger('mylogger')  
logger1.setLevel(logging.DEBUG)  
  
logger2 = logging.getLogger('mylogger')  
logger2.setLevel(logging.INFO)  
  
logger3 = logging.getLogger('mylogger.child1')  
logger3.setLevel(logging.WARNING)  
  
logger4 = logging.getLogger('mylogger.child1.child2')  
logger4.setLevel(logging.DEBUG)  
  
logger5 = logging.getLogger('mylogger.child1.child2.child3')  
logger5.setLevel(logging.DEBUG)  
  
# 创建一个handler，用于写入日志文件    
fh = logging.FileHandler('/tmp/test.log')  
  
# 再创建一个handler，用于输出到控制台    
ch = logging.StreamHandler()  
  
# 定义handler的输出格式formatter    
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')  
fh.setFormatter(formatter)  
ch.setFormatter(formatter)  
  
#定义一个filter  
#filter = logging.Filter('mylogger.child1.child2')  
#fh.addFilter(filter)    
  
# 给logger添加handler    
#logger.addFilter(filter)  
logger.addHandler(fh)  
logger.addHandler(ch)  
  
#logger1.addFilter(filter)  
logger1.addHandler(fh)  
logger1.addHandler(ch)  
  
logger2.addHandler(fh)  
logger2.addHandler(ch)  
  
#logger3.addFilter(filter)  
logger3.addHandler(fh)  
logger3.addHandler(ch)  
  
#logger4.addFilter(filter)  
logger4.addHandler(fh)  
logger4.addHandler(ch)  
  
logger5.addHandler(fh)  
logger5.addHandler(ch)  
  
# 记录一条日志    
logger.debug('logger debug message')  
logger.info('logger info message')  
logger.warning('logger warning message')  
logger.error('logger error message')  
logger.critical('logger critical message')  
  
logger1.debug('logger1 debug message')  
logger1.info('logger1 info message')  
logger1.warning('logger1 warning message')  
logger1.error('logger1 error message')  
logger1.critical('logger1 critical message')  
  
logger2.debug('logger2 debug message')  
logger2.info('logger2 info message')  
logger2.warning('logger2 warning message')  
logger2.error('logger2 error message')  
logger2.critical('logger2 critical message')  
  
logger3.debug('logger3 debug message')  
logger3.info('logger3 info message')  
logger3.warning('logger3 warning message')  
logger3.error('logger3 error message')  
logger3.critical('logger3 critical message')  
  
logger4.debug('logger4 debug message')  
logger4.info('logger4 info message')  
logger4.warning('logger4 warning message')  
logger4.error('logger4 error message')  
logger4.critical('logger4 critical message')  
  
logger5.debug('logger5 debug message')  
logger5.info('logger5 info message')  
logger5.warning('logger5 warning message')  
logger5.error('logger5 error message')  
logger5.critical('logger5 critical message')  

　　应用：

import os
import time
import logging
from config import settings


def get_logger(card_num, struct_time):

    if struct_time.tm_mday < 23:
        file_name = "%s_%s_%d" %(struct_time.tm_year, struct_time.tm_mon, 22)
    else:
        file_name = "%s_%s_%d" %(struct_time.tm_year, struct_time.tm_mon+1, 22)

    file_handler = logging.FileHandler(
        os.path.join(settings.USER_DIR_FOLDER, card_num, 'record', file_name),
        encoding='utf-8'
    )
    fmt = logging.Formatter(fmt="%(asctime)s :  %(message)s")
    file_handler.setFormatter(fmt)

    logger1 = logging.Logger('user_logger', level=logging.INFO)
    logger1.addHandler(file_handler)
    return logger1

　　

七、json和pickle模块

　　之前我们学习过用eval内置方法可以将一个字符串转成Python对象,不过,eval方法是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就顾管用了，所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。

import json
x="[null,true,false,1]"
print(eval(x))
print(json.loads(x))

　　什么是序列化？

　　我们把对象（变量）从内存中变成可储存或传输的过程称之为序列化，在Python中叫pickling,在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。

　　序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上

　　反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling

　　json

　　如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

　　JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：

　　

#只要符合json规则的字符串就是json字符串，不一定非要json.dumps后才是json字符串
#json处理的是json字符串，如果字符串是json里面有的可以直接拿来处理，如果没有需要先dumps一下转为json字符串，在loads出来操作
#json.dumps和json.loads是结合起来用的，而json.dump(d,f)完成了两步:dumps和f.write()
#json.dumps 转储成json字符串,也叫序列化
#json.loads 装载json字符串,也叫反序列化
#json.dump 往文件中倾倒json字符串
import json
#当json碰见中文
#d={'河北': ['廊坊', '保定']}
#s=json.dumps(d)
# print(s)#结果是一堆Unicode字节，要看明文需要打印一下这个Unicode数据
#print(json.loads(s))
# print({"\u6cb3\u5317": ["\u5eca\u574a", "\u4fdd\u5b9a"]})

# d1={"name":"egon"}
# s1=json.dumps(d1)
# print(type(s1))#<class 'str'>,其实是json字符串因为python中也有str所以直接就是str了
# f=open("new","w")
# f.write(s1)
# f=open("new")
# d2=json.loads(f.read())
# print(d2["name"])

# f=open("new1","w")
# json.dump(d1,f)  #完成两步，第一步把d1转成json字符串，第二步把json字符串进行f.write操作
# f.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

　　pickle

# 序列化
import pickle
 
dic={'name':'alvin','age':23,'sex':'male'}
 
print(type(dic))#<class 'dict'>
 
j=pickle.dumps(dic)
print(type(j))#<class 'bytes'>
 
 
f=open('序列化对象_pickle','wb')  # 注意是w是写入str,wb是写入bytes,j是'bytes'
f.write(j)  # 等价于pickle.dump(dic,f)
 
f.close()
# 反序列化
import pickle
f=open('序列化对象_pickle','rb')
 
data=pickle.loads(f.read())  # 等价于data=pickle.load(f)
 
print(data['age'])    

　　pickle 追加读写

import pickle

with open('info', 'wb') as f:
    pickle.dump({'a1': 'b1', 'c1': 'd1'}, f)

with open('info', 'ab') as f:
    pickle.dump({'a2': 'b2', 'c2': 'd2'}, f)

with open('info', 'rb') as f:
    while True:
        try:
            dic = pickle.load(f)
            print(dic)
        except EOFError:
            break

Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。

 

八、re模块

　　就其本质而言，正则表达式（或RE）是一种小型的、高度专业化的编程语言，（在Python中）它内嵌在Python中，并通过re模块实现。正则表达式模式被编译成一系列的字节码，然后用C编写的匹配引擎执行。

　　字符匹配（普通字符，元字符）：

 　　1 普通字符：大多数字符和字母都会和自身匹配
              >>> re.findall('alvin','yuanaleSxalexwupeiqi')
                      ['alvin'] 

　　2 元字符：. ^ $ * + ? { } [ ] | ( ) \

　　元字符之. ^ $ * + ? { }

import re
 
ret=re.findall('a..in','helloalvin')
print(ret)#['alvin']
 
 
ret=re.findall('^a...n','alvinhelloawwwn')
print(ret)#['alvin']
 
 
ret=re.findall('a...n$','alvinhelloawwwn')
print(ret)#['awwwn']
 
 
ret=re.findall('a...n$','alvinhelloawwwn')
print(ret)#['awwwn']
 
 
ret=re.findall('abc*','abcccc')#贪婪匹配[0,+oo]  
print(ret)#['abcccc']
 
ret=re.findall('abc+','abccc')#[1,+oo]
print(ret)#['abccc']
 
ret=re.findall('abc?','abccc')#[0,1]
print(ret)#['abc']
 
 
ret=re.findall('abc{1,4}','abccc')
print(ret)#['abccc'] 贪婪匹配

　　注意：前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配

ret=re.findall('abc*?','abcccccc')
print(ret)#['ab'] #也就是说后面的？号是去前面*范围的最小值，也就是0

　　元字符之字符集［］：

#--------------------------------------------字符集[]
ret=re.findall('a[bc]d','acd')
print(ret)#['acd']
 
ret=re.findall('[a-z]','acd')
print(ret)#['a', 'c', 'd']
 
ret=re.findall('[.*+]','a.cd+')
print(ret)#['.', '+']
 
#在字符集里有功能的符号: - ^ \
 
ret=re.findall('[1-9]','45dha3')
print(ret)#['4', '5', '3']
 
ret=re.findall('[^ab]','45bdha3')
print(ret)#['4', '5', 'd', 'h', '3']
 
ret=re.findall('[\d]','45bdha3')
print(ret)#['4', '5', '3']

　　元字符之转义符\

　　反斜杠后边跟元字符去除特殊功能,比如\.
　　反斜杠后边跟普通字符实现特殊功能,比如\d

　　\d  匹配任何十进制数；它相当于类 [0-9]。
　　\D 匹配任何非数字字符；它相当于类 [^0-9]。
　　\s  匹配任何空白字符；它相当于类 [ \t\n\r\f\v]。
　　\S 匹配任何非空白字符；它相当于类 [^ \t\n\r\f\v]。
　　\w 匹配任何字母数字字符；它相当于类 [a-zA-Z0-9_]。
　　\W 匹配任何非字母数字字符；它相当于类 [^a-zA-Z0-9_]
　　\b  匹配一个特殊字符边界，比如空格 ，&，＃等

ret=re.findall('I\b','I am LIST')
print(ret)#[]
ret=re.findall(r'I\b','I am LIST')
print(ret)#['I']

　　下面我们聊一聊\,先看下面两个匹配：

#-----------------------------eg1:
import re
ret=re.findall('c\l','abc\le')
print(ret)#[]
ret=re.findall('c\\l','abc\le')
print(ret)#[]
ret=re.findall('c\\\\l','abc\le')
print(ret)#['c\\l']
ret=re.findall(r'c\\l','abc\le')
print(ret)#['c\\l']
 
#-----------------------------eg2:
#之所以选择\b是因为\b在ASCII表中是有意义的
m = re.findall('\bblow', 'blow')
print(m)
m = re.findall(r'\bblow', 'blow')
print(m)

　　

　　元字符值分组()

m = re.findall(r'(ad)+', 'add')
print(m)
 
ret=re.search('(?P<id>\d{2})/(?P<name>\w{3})','23/com')
print(ret.group())#23/com
print(ret.group('id'))#23

　　元字符之 |

ret=re.search('(ab)|\d','rabhdg8sd')
print(ret.group())#ab

　　re模块下的常用方法

import re
#1
re.findall('a','alvin yuan')    #返回所有满足匹配条件的结果,放在列表里
#2
re.search('a','alvin yuan').group()  #函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以
                                     # 通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。
 
#3
re.match('a','abc').group()     #同search,不过尽在字符串开始处进行匹配
 
#4
ret=re.split('[ab]','abcd')     #先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret)#['', '', 'cd']
 
#5
ret=re.sub('\d','abc','alvin5yuan6',1)
print(ret)#alvinabcyuan6
ret=re.subn('\d','abc','alvin5yuan6')
print(ret)#('alvinabcyuanabc', 2)
 
#6
obj=re.compile('\d{3}')
ret=obj.search('abc123eeee')
print(ret.group())#123

　　

import re
ret=re.finditer('\d','ds3sy4784a')
print(ret)        #<callable_iterator object at 0x10195f940>
 
print(next(ret).group())
print(next(ret).group())

　　注意：

import re
 
ret=re.findall('www.(baidu|oldboy).com','www.oldboy.com')
print(ret)#['oldboy']     这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可
 
ret=re.findall('www.(?:baidu|oldboy).com','www.oldboy.com')
print(ret)#['www.oldboy.com']

　　补充1：

import re

print(re.findall("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>"))
print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>"))
print(re.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>"))

　　补充2：

#匹配出所有的整数
import re

#ret=re.findall(r"\d+{0}]","1-2*(60+(-40.35/5)-(-4*3))")
ret=re.findall(r"-?\d+\.\d*|(-?\d+)","1-2*(60+(-40.35/5)-(-4*3))")
ret.remove("")

print(ret)

　　

九、datetime模块

　　将GMT(格林尼治标准时间)转换为当前时间

import requests

GMT_FORMAT = '%a, %d %b %Y %H:%M:%S GMT'

response = requests.get('http://www.baidu.com')
gmt_dt = datetime.datetime.strptime(response.headers['Date'], GMT_FORMAT)  # <class 'str'> --> <class 'datetime.datetime'>
gmt_dt_utc = gmt_dt.replace(tzinfo=datetime.timezone.utc)  # 强制修改时区
gmt_dt_utc_timestamp = gmt_dt_utc.timestamp()
gmt_local = datetime.datetime.fromtimestamp(gmt_dt_utc_timestamp)  # 将时间戳转换为本地时间
print(gmt_local)