常用模块_新

re模块

logging模块

日志级别

CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0
重要知识点

#logging最简单的用法  打印对应级别的日志
#默认打印到终端，默认级别为 warn
#这种形式基本没什么用
logging.debug('调试debug')
logging.info('消息info')
logging.warning('警告warn')
logging.error('错误error')
logging.critical('严重critical')
'''
打印结果
WARNING:root:警告warn
ERROR:root:错误error
CRITICAL:root:严重critical
'''

#======介绍
可在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的配置

import logging
#需求   不同的格式 打印到不同的文件
'''
前三个需要记住：
Formater  定义日志格式
handler 指定日志输出到的文件
logger

filter
'''

# logging.Formatter()  定义格式
#这里定义了一种格式了  名字为formatter1 还可以定义多个格式
formatter1=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S %p',)

# handler 指定日志输出到的文件  有两种 一种是文件  一种是终端
# 1> logging.FileHandler() 和文件有关  定义打印日志的文件路径 handler也可以设置级别
ch.setFormatter(20)
fh1=logging.FileHandler('test1.log') #将日志打印到test1.log文件里
fh2=logging.FileHandler('test2.log') #将日志打印到test2.log文件里
fh3=logging.FileHandler('test3.log') #将日志打印到test3.log文件里
ch=logging.StreamHandler() #将日志打印到终端

# logging.getLogger() 拿到一个日志对象 默认为root
logger1=logging.getLogger('egon')
logger1.setLevel(10) #设置handler的级别 如果logger和handler都设置了级别  那么都满足才会打印出来
#联系上边的三个
'''
Formater 定义日志格式
handler  负责接收日志
logger 负责产生日志  交给handler  handler会按照日志格式输出到指定文件
'''
#logger如何把日志交给handler 方法如下
logger1.addHandler(fh1)
logger1.addHandler(fh2)
logger1.addHandler(fh3)
logger1.addHandler(ch)

#把日志交个handler后  会输出到文件 但是现在还没有和日志格式连接起来  下面连接起来
fh1.setFormatter(formatter1)
fh2.setFormatter(formatter1)
fh3.setFormatter(formatter1)
ch.setFormatter(formatter1)


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

图片链接：https://pan.baidu.com/s/1skWyTT7

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)


log1=logging.getLogger('root')
log2=logging.getLogger('root.child1')
log3=logging.getLogger('root.child1.child2')


log1.setLevel(10)
log2.setLevel(10)
log3.setLevel(10)
log1.addHandler(ch)
log2.addHandler(ch)
log3.addHandler(ch)

log1.debug('log1 debug')
log2.debug('log2 debug')
log3.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
'''

part4:logger继承

logging实际应用

套用老师给的模板即可

"""
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()

logging配置文件

"""
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()

使用

另外一个django的配置，瞄一眼就可以，跟上面的一样

#! /usr/bin/env python
# -*- coding: utf-8 -*-
# __author__ = "Q1mi"
# Date: 2017/7/28



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") #领导说,需要为领导们单独定制领导们看的日志

 time模块

在Python中，通常有这几种方式来表示时间：

• 时间戳(timestamp)：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。
• 格式化的时间字符串(Format String)
• 结构化的时间(struct_time)：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

import time
# 时间戳
print(time.time()) #1502329946.682236
#格式化字符串时间
print(time.strftime('%Y-%m-%d %X'))
'''
2017-08-10 09:53:14
'''
#结构化时间
print(time.localtime()) #本地时区
print(time.gmtime()) #utc 时间  相差8个小时
'''
time.struct_time(tm_year=2017, tm_mon=8, tm_mday=10, tm_hour=9, tm_min=53, tm_sec=14, tm_wday=3, tm_yday=222, tm_isdst=0)
time.struct_time(tm_year=2017, tm_mon=8, tm_mday=10, tm_hour=1, tm_min=53, tm_sec=14, tm_wday=3, tm_yday=222, tm_isdst=0)
'''

三种时间之间的转换

import time
#结构化时间 struct_time <=====> 格式化字符串时间 format string

#1> struct_time =====>
print(time.strftime('%Y-%m-%d %X', time.localtime()))
print(time.strftime('%Y-%m-%d %X', time.gmtime()))

#2>format string =====> struct_time
print(time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X'))


#结构化时间 struct_time <=====> 时间戳 timestamp

#1> timestamp ====> localtime
    #timestamp ====> gmtime
print(time.time())
print(time.localtime(1502330480.143894))
print(time.gmtime(1502330480.143894))

#2>  gmtime/localtime ======> timestamp
print(time.mktime(time.localtime()))
print(time.mktime(time.gmtime()))

和linux有关的时间

#--------------------------按图2转换时间
# asctime([t]) : 把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 23:21:05 1993'。
# 如果没有参数，将会将time.localtime()作为参数传入。
print(time.asctime())#Sun Sep 11 00:43:43 2016

# ctime([secs]) : 把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为
# None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。
print(time.ctime())  # Sun Sep 11 00:46:38 2016
print(time.ctime(time.time()))  # Sun Sep 11 00:46:38 2016

random模块

import random

#潜规则 （）不包括边界的数  []包括边界的数 

print(random.random())  # (0,1)----float    固定的 大于0且小于1之间的小数

print(random.uniform(1, 3))  # 大于1小于3的小数，如1.927109612082716

print(random.randint(1, 3))  # [1,3]    大于等于1且小于等于3之间的整数

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

print(random.choice([1, '23', [4, 5]]))  # 列表里随机一个元素

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

item = [1, 3, 5, 7, 9]
random.shuffle(item)  # 打乱item的顺序,相当于"洗牌"
print(item)

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

print(make_code(9))

生成随机验证码

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下为"	
",Linux下为"
"
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的大小

normcase normpath重点掌握一下

在Linux和Mac平台上，该函数会原样返回path，在windows平台上会将路径中所有字符转换为小写，并将所有斜杠转换为饭斜杠。
>>> os.path.normcase('c:/windows\system32\')   
'c:\windows\system32\'   
   

规范化路径，如..和/
>>> os.path.normpath('c://windows\System32\../Temp/')   
'c:\windows\Temp'   

>>> a='/Users/jieli/test1/\a1/\\aa.py/../..'
>>> print(os.path.normpath(a))
/Users/jieli/test1

os路径处理
#方式一：推荐使用
import os
#具体应用
import os,sys
possible_topdir = os.path.normpath(os.path.join(
    os.path.abspath(__file__),
    os.pardir, #上一级
    os.pardir,
    os.pardir
))
sys.path.insert(0,possible_topdir)


#方式二：不推荐使用
os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

sys模块

sys.argv 单独补充用法

########需要重点掌握和记住的两个######
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.argv           命令行参数List，第一个元素是程序本身路径
#其他：
sys.exit(n)        退出程序，正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值

sys.platform       返回操作系统平台名称

实例展示 进度条  没事常练习一下

import sys
import time
for i in range(100):
    sys.stdout.write('
%s' %('#'*i))
    sys.stdout.flush()
    time.sleep(0.5)

import sys
import time
for i in range(100):
    time.sleep(0.5)
    print('
%s' %('#'*i),end='',file=sys.stdout,flush=True)

#=========知识储备==========
#指定宽度
print('<%-10.3f>' %3.22) #总宽度为10,保留3位小数点
#打印结果
#<3.220     >

#打印%号,用%%
width=10
print('<%%-%ds>' %width)
#打印结果
# <%-10s>

#嵌套的%
width=10
print(('<%%-%ds>' %width) %('hello'))
#打印结果
# <hello     >

#=========实现打印进度条函数==========
import sys
import time
def progress(percent,width=50):
    if percent >= 100:
        percent=100

    show_str=('[%%-%ds]' %width) %(int(width * percent / 100) * "#") #字符串拼接的嵌套使用
    print("
%s %d%%" %(show_str, percent),end='',file=sys.stdout,flush=True)


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

    recv_per=int(100*(recv_size/data_size)) #接收的比例
    progress(recv_per,width=30) #进度条的宽度30

进度条应用

json&pickle模块

json 序列化

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

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

#json 保存和读出数据有两套用法
json.dumps()  json.loads()
json.dump()   json.load()

import json
dic={
    'name':'egon',
    'age':18,
    'sex':'boy'
}
#保存数据
json.dump(dic,open('b.json','w'))
#读出数据
print(json.load(open('b.json','r'))['name'])

import  json
dic={
    'name':'egon',
    'age':18,
    'sex':'boy'
}
#保存数据
with open('c.json','w') as f:
    f.write(json.dumps(dic))

#读出数据
with open('c.json','r') as f:
    data=f.read()
    dic=json.loads(data)
    print(dic['name'])

pickle 序列化

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

pickle 读入读出bytes格式 wb rb

#pickle 保存和读出数据有两套用法
pickle.dumps()  pickle.loads()
pickle.dump()   pickle.load()

import pickle
dic={
    'name':'egon',
    'age':18,
    'sex':'boy'
}
#保存数据
pickle.dump(dic,open('aa.json','wb')) #注意是 wb
#读出数据
print(pickle.load(open('aa.json','rb'))['name']) # 注意是rb
'''
egon
'''

import pickle
dic={
    'name':'egon',
    'age':18,
    'sex':'boy'
}
#保存数据
with open('bb.json','wb') as f: #wb
    f.write(pickle.dumps(dic))

# #读出数据
with open('bb.json','rb') as f: #rb
    data=f.read()
    dic=pickle.loads(data)
    print(dic['name'])

 xml模块

实现不同语言之间的数据交换，在没有json的 时候，用的就是xml,使用<>来定义数据结构，

如下格式

<?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>

xml数据