python之常用模块篇5

一、日志模块,logging模块

1）logging模块简单使用，屏幕输出。默认级别30

import logging

logging.debug('debug...')   #
logging.info('info....')    #
logging.warning('可能着火...') #
logging.error('着火啦快跑') #
logging.critical('火越烧越大') #

2）控制日志输出到文件，但屏幕显示信息会消失。注意，存入文件时是以gbk，所以打开时，也要指定gbk格式

import logging

# 控制日志输出
logging.basicConfig(
filename='access.log',   # 记录在当前目录，生成文件
format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
        # 时间       日志的名,如debug，error    级别     模块          # 接收的信息
datefmt='%Y-%m-%d %H:%M:%S %p', # 时间
level=,
)
logging.debug('debug...')   #
logging.info('info....')    #
logging.warning('可能着火...') #
logging.error('着火啦快跑') #
logging.critical('火越烧越大') #

3）日志模块调用原理

import logging

#logger对象：用来产生日志
logger1=logging.getLogger('银行业务相关') # 日志名是用告诉我们所记录的日志到底是属于哪一类业务相关的信息

#filter对象：过滤日志

#handler对象：控制日志的去向： 文件 或 终端
fh1=logging.FileHandler('a1.log',encoding='utf-8')
fh2=logging.FileHandler('a2.log',encoding='utf-8')
ch=logging.StreamHandler() #代表的就是终端

# 建立logger对象与handler对象的绑定关系
logger1.addHandler(fh1)
logger1.addHandler(fh2)
logger1.addHandler(ch)

#formmatter对象：定制日志的格式
formatter1=logging.Formatter(
    fmt='%(asctime)s - %(name)s - %(levelname)s - %(module)s:  %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p'
)

formatter2=logging.Formatter(
    fmt='%(asctime)s ===> %(message)s',
)

# 为handler对象绑定日志格式
fh1.setFormatter(formatter1)
fh2.setFormatter(formatter2)
ch.setFormatter(formatter2)

#设置日志级别：两层关卡，第一次是logger，第二层是handler，只有两层都放行，最终日志才会打印
# logger1.setLevel()
# fh1.setLevel()
# fh2.setLevel()
# ch.setLevel()

logger1.setLevel()
fh1.setLevel()
fh2.setLevel()
ch.setLevel()

# 调用logger对象产生日志
logger1.debug('这是一条debug日志')

4）引用字典加载日志模块配置

日志配置文件，setting_log.py

import logging

# 定义日志文件的保存路径
logfile_path=r'D:\oldboyedu\manth-02\day-02\a1.log'

# 定义日志格式
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'

# log配置字典
LOGGING_DIC = {
    'version': ,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
    },
    'filters': {},
    'handlers': {
        #打印到终端的日志
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到终端
            'formatter': 'simple'
        },
        #打印到文件的日志,
        'default': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',  # 保存到文件  # logging.handlers.RotatingFileHandler
            'formatter': 'standard',
            'filename': logfile_path,  # 日志文件
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },

    },
    'loggers': {
        #logging.getLogger(__name__)拿到的logger配置
        'logger1': {
            'handlers': ['default', 'console'],
            'level': 'DEBUG',
            'propagate': False,
        },
    },
}

setting_log

升级修改的配置文件，增加日志轮转的功能

        'default': {
            'level': 'DEBUG',
           # 'class': 'logging.FileHandler',  # 保存到文件  # logging.handlers.RotatingFileHandler
            'class': 'logging.handlers.RotatingFileHandler',
            'formatter': 'standard',
            'filename': logfile_path,  # 日志文件
            'maxBytes': **,     # 日志文件大小 5M
            'backupCount': ,
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },

功能调用日志模块配置文件

import logging.config
from setting_log import LOGGING_DIC     # 导入日志的配置文件

logging.config.dictConfig(LOGGING_DIC)
logging1 = logging.getLogger('logger1')
logging1.debug('调试日志')

5）升级版，新增配置日志文件，如boss的日志

import logging

# 定义日志文件的保存路径
logfile_path=r'D:\oldboyedu\manth-02\day-02\a1.log'
boss_logfile_path=r'D:\oldboyedu\manth-02\day-02\a2.log'

# 定义日志格式
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 = '[%(asctime)s] %(message)s'  # 给boss的日志，简单明了的日志

# log配置字典
LOGGING_DIC = {
    'version': ,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
        'id_simple': {
            'format': id_simple_format
        }
    },
    'filters': {},
    'handlers': {
        #打印到终端的日志
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到终端
            'formatter': 'simple'
        },
        #打印到文件的日志,
        'default': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',  # 保存到文件  # logging.handlers.RotatingFileHandler
            'formatter': 'standard',
            'filename': logfile_path,  # 日志文件
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },
        # 打印给boss的日志
        'boss': {
            'level': 'ERROR',
            'class': 'logging.FileHandler',  # 保存到文件  # logging.handlers.RotatingFileHandler
            'formatter': 'id_simple',
            'filename': boss_logfile_path,  # 日志文件
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },
    },
    'loggers': {
        #logging.getLogger(__name__)拿到的logger配置
        'logger1': {
            'handlers': ['default', 'console','boss'],
            'level': 'DEBUG',
            'propagate': False,
        },
    },
}

setting_log2

6）函数调用配置文件输出日志

def get_logger(logger_name):
    # 获取输入日志的信息
    logging.config.dictConfig(settings.LOGGING_DIC)  # 导入上面定义的settings配置
    logger=logging.getLogger(logger_name)
    return logger

logger=get_logger('logger1')
def register():
    logger.info('用户%s注册成功' %user)

def info():
    logger.info('用户%s登录成功' %user)

7）可实现任意log对象的配置，字典的key为空即可

    'loggers': {
        #logging.getLogger(__name__)拿到的logger配置
        '': {
            'handlers': ['default', 'console'],
            'level': 'DEBUG',
            'propagate': False,
        },
    },

任意log对象配置

8）扩展，log的日志格式

可在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：字符串形式的当前时间。默认格式是 “-- ::,”。逗号后面的是毫秒

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

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

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

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

日志格式扩展

二、跨平台序列化存储数据。json和pickle

1）序列化的概念，意义

 什么是序列化
    序列化：把内存中的数据转成一种中间格式（json/pickle）,然后存放到硬盘中，永久保存
    反序列化：从文件中读出（json/pickle）格式，然后返解成python的数据类型

 为什么要序列化
    、数据结构持久化

    、跨平台数据交互

 如何进行序列化，反序列化
    json：
        缺点：
            只能支持部分python的数据类型
        优点：
            所有的语言都支持json格式

        应用：
            如果需要考虑跨平台性，则需要用json格式
    pickle
        缺点：
            只有python支持pickle格式
        优点：
            pickle能够支持所有的python数据类型

        应用：
            如果不需要考虑跨平台性，则可以用pickle格式

2）json支持转换python格式的类型

3）json序列化模块的使用

import json

# dic={'name':'egon','age':,'is_beautiful':True}

# #序列化
# res=json.dumps(dic) # 强调，json格式不识别单引号
# # print(res,type(res))
# with open('user.json','w',encoding='utf-8') as f:
#     f.write(res)

# 反序列化
# with open('user.json','r',encoding='utf-8') as f:
#     res=f.read()

# dic=json.loads(res)
# print(dic['name'])

# 强调，json格式不识别单引号
# with open('user1.json','r',encoding='utf-8') as f:
#     res=f.read()
#
# dic=json.loads(res)
# print(dic['x'])

# #序列化
# dic={'name':'egon','age':,'is_beautiful':True}
#
# with open('user2.json','w',encoding='utf-8') as f:
#     json.dump(dic,f)

# 反序列化
with open('user.json','r',encoding='utf-8') as f:
    dic=json.load(f)

    print(dic['name'])

json的使用

4）pickle用法和json一模一样

import json
import pickle

# 序列化
# pickle可以序列化任意python的数据类型
# print(json.dumps({,,}))
# print(pickle.dumps({,,}))

# dic={'name':'egon','age':,'is_beautiful':True}
#
# res=pickle.dumps(dic)
# with open('user3.pkl','wb') as f:
#     f.write(res)

# 反序列化
# with open('user3.pkl','rb') as f:
#     res=f.read()
#
# dic=pickle.loads(res)
# print(dic['name'])

#简单写法
# # 序列化
# dic={'name':'egon','age':,'is_beautiful':True}
# with open('user4.pkl','wb') as f:
#     pickle.dump(dic,f)

# 反序列化
with open('user4.pkl','rb') as f:
    dic=pickle.load(f)
    print(dic['name'])

pkickle的使用

三、hash加密模块

1）hash加密算法的用途

、只要校验的文本内容一样，那么得到的hash值是相同===>校验文件的完整性
、只要使用hash算法固定，无论校验的内容有多大，得到的hash值长度都是固定的（与上一条合到一起用）
、hash不可以逆，即无法通过hash值反解出明文====》将明文转成密文进行传输

2）hash的各种用法

import hashlib

# m=hashlib.md5() # 建造了一个hash工厂

# m.update(b'hello') # update接收的数据类型都必须是bytes类型
# m.update(b'world') # update接收的数据类型都必须是bytes类型
# m.update(b'egon') # update接收的数据类型都必须是bytes类型
# #b'helloworldegon'
# print(m.hexdigest()) 

# m1=hashlib.md5() # 建造了一个hash工厂

# m1.update(b'hellowo') # update接收的数据类型都必须是bytes类型
# m1.update(b'rldegon') # update接收的数据类型都必须是bytes类型
# #b'helloworldegon'
# print(m1.hexdigest()) 

# m2=hashlib.md5() # 建造了一个hash工厂

# m2.update(b'hellowo') # update接收的数据类型都必须是bytes类型
# m2.update(b'rldegon') # update接收的数据类型都必须是bytes类型
# m2.update(b'rldegon') # update接收的数据类型都必须是bytes类型
# print(m2.hexdigest()) 

#用途，验证文件
# import hashlib
# m=hashlib.md5()
# with open('1.flv','rb') as f:
#     # for line in f:
#     #     m.update(line)
#     m.update(f.read())
#     print(m.hexdigest()) 

# 升级加密，密码写在中间
# import hashlib
# password='alex3714'

# m=hashlib.md5()
# m.update('天王盖地虎'.encode('utf-8'))
# m.update(password.encode('utf-8'))
# m.update('小鸡炖蘑菇'.encode('utf-8'))
# pwd_md5=m.hexdigest()
# print(pwd_md5)

# 查看hash的各个加密方法的难易度
# import hashlib
# m0=hashlib.md5()
# m0.update('hello'.encode('utf-8'))
# print(m0.hexdigest())
#
# m1=hashlib.sha256()
# m1.update('hello'.encode('utf-8'))
# print(m1.hexdigest())
#
# m2=hashlib.sha512()
# m2.update('hello'.encode('utf-8'))
# print(m2.hexdigest())

# 了解
import hmac
m=hmac.new('天王盖地虎'.encode('utf-8'))
m.update(b'hello')
m.update(b'world')
print(m.hexdigest())

3）模拟撞库

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

四、re正则模块

1）基本正则练习

# =================================匹配模式=================================
#一对一的匹配
# 'hello'.replace(old,new)
# 'hello'.find('pattern')

#正则匹配
import re
#\w与\W
print(re.findall('\w','hello egon 123')) #['h', 'e', 'l', 'l', 'o', 'e', 'g', 'o', 'n', '', '', '']
print(re.findall('\W','hello egon 123')) #[' ', ' ']

#\s与\S
print(re.findall('\s','hello  egon  123')) #[' ', ' ', ' ', ' ']
print(re.findall('\S','hello  egon  123')) #['h', 'e', 'l', 'l', 'o', 'e', 'g', 'o', 'n', '', '', '']

#\n \t都是空,都可以被\s匹配
print(re.findall('\s','hello \n egon \t 123')) #[' ', '\n', ' ', ' ', '\t', ' ']

#\n与\t
print(re.findall(r'\n','hello egon \n123')) #['\n']
print(re.findall(r'\t','hello egon\t123')) #['\n']

#\d与\D
print(re.findall('\d','hello egon 123')) #['', '', '']
print(re.findall('\D','hello egon 123')) #['h', 'e', 'l', 'l', 'o', ' ', 'e', 'g', 'o', 'n', ' ']

#\A与\Z
print(re.findall('\Ahe','hello egon 123')) #['he'],\A==>^
print(re.findall('123\Z','hello egon 123')) #['he'],\Z==>$

#^与$
print(re.findall('^h','hello egon 123')) #['h']
print(re.findall('3$','hello egon 123')) #['']

# 重复匹配：| . | * | ? | .* | .*? | + | {n,m} |
#.
print(re.findall('a.b','a1b')) #['a1b']
print(re.findall('a.b','a1b a*b a b aaab')) #['a1b', 'a*b', 'a b', 'aab']
print(re.findall('a.b','a\nb')) #[]
print(re.findall('a.b','a\nb',re.S)) #['a\nb']
print(re.findall('a.b','a\nb',re.DOTALL)) #['a\nb']同上一条意思一样

#*
print(re.findall('ab*','bbbbbbb')) #[]
print(re.findall('ab*','a')) #['a']
print(re.findall('ab*','abbbb')) #['abbbb']

#?
print(re.findall('ab?','a')) #['a']
print(re.findall('ab?','abbb')) #['ab']
#匹配所有包含小数在内的数字
print(re.findall('\d+\.?\d*',"asdfasdf123as1.13dfa12adsf1asdf3")) #['', '1.13', '', '', '']

#.*默认为贪婪匹配
print(re.findall('a.*b','a1b22222222b')) #['a1b22222222b']

#.*?为非贪婪匹配：推荐使用
print(re.findall('a.*?b','a1b22222222b')) #['a1b']

#+
print(re.findall('ab+','a')) #[]
print(re.findall('ab+','abbb')) #['abbb']

#{n,m}
print(re.findall('ab{2}','abbb')) #['abb']
print(re.findall('ab{2,4}','abbb')) #['abb']
print(re.findall('ab{1,}','abbb')) #'ab{1,}' ===> 'ab+'
print(re.findall('ab{0,}','abbb')) #'ab{0,}' ===> 'ab*'

#[]
print(re.findall('a[1*-]b','a1b a*b a-b')) #[]内的都为普通字符了，且如果-没有被转意的话，应该放到[]的开头或结尾
print(re.findall('a[^1*-]b','a1b a*b a-b a=b')) #[]内的^代表的意思是取反，所以结果为['a=b']
print(re.findall('a[0-9]b','a1b a*b a-b a=b')) #[]内的^代表的意思是取反，所以结果为['a=b']
print(re.findall('a[a-z]b','a1b a*b a-b a=b aeb')) #[]内的^代表的意思是取反，所以结果为['a=b']
print(re.findall('a[a-zA-Z]b','a1b a*b a-b a=b aeb aEb')) #[]内的^代表的意思是取反，所以结果为['a=b']

#\# print(re.findall('a\\c','a\c')) #对于正则来说a\\c确实可以匹配到a\c,但是在python解释器读取a\\c时，会发生转义，然后交给re去执行，所以抛出异常
print(re.findall(r'a\\c','a\c')) #r代表告诉解释器使用rawstring，即原生字符串，把我们正则内的所有符号都当普通字符处理，不要转义
print(re.findall('a\\\\c','a\c')) #同上面的意思一样，和上面的结果一样都是['a\\c']

#():分组
print(re.findall('ab+','ababab123')) #['ab', 'ab', 'ab']
print(re.findall('(ab)+123','ababab123')) #['ab']，匹配到末尾的ab123中的ab
print(re.findall('(?:ab)+123','ababab123')) #findall的结果不是匹配的全部内容，而是组内的内容,?:可以让结果为匹配的全部内容
print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击</a>'))#['http://www.baidu.com']
print(re.findall('href="(?:.*?)"','<a href="http://www.baidu.com">点击</a>'))#['href="http://www.baidu.com"']

#|
print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company'))

2）re提供的方法

# ===========================re模块提供的方法介绍===========================
import re
#
print(re.findall('e','alex make love') )   #['e', 'e', 'e'],返回所有满足匹配条件的结果,放在列表里
#
print(re.search('e','alex make love').group()) #e,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。

#
print(re.match('e','alex make love'))    #None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match

#
print(re.split('[ab]','abcd'))     #['', '', 'cd']，先按'a'分割得到''和'bcd',再对''和'bcd'分别按'b'分割

#
print('===>',re.sub('a','A','alex make love')) #===> Alex mAke love，不指定n，默认替换所有
print('===>',re.sub('a','A','alex make love',)) #===> Alex make love
print('===>',re.sub('a','A','alex make love',)) #===> Alex mAke love
print('===>',re.sub('^(\w+)(.*?\s)(\w+)(.*?\s)(\w+)(.*?)$',r'\5\2\3\4\1','alex make love')) #===> love make alex

print('===>',re.subn('a','A','alex make love')) #===> ('Alex mAke love', ),结果带有总共替换的个数

#
obj=re.compile('\d{2}')

print(obj.search('abc123eeee').group()) #
print(obj.findall('abc123eeee')) #[''],重用了obj

3）补充练习

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

4）findall和search的区别

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

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

search与findall

5）计算器会用到的技术点，例,1+(2+(3+4)*2

# # 计算第一步，判断是否有括号
# inpp = '1+2+(3+4)*2'
# b = re.search('\(',inpp)
# print(b)    # 打印结果，判断是字符串是否有（）

# # 计算第二步，拿到最里面括号的内容
# inpp = '1+(2+(3+4*2))*2+(2+3)'
# b = re.search('\([^()]+\)',inpp).group()
# print(b)    # 拿到最里面括号的结果,结果靠前

# ## 计算第三步，拿到括号内的结果，先匹配乘除运算,并得到运算结果
# # # 匹配字符串中的'(3+42.2*2)'，42.2*  ，也可匹配，*, *
# innp = '(3+2.2*2.3)'
# # a = re.search('\d+\.?\d*\*\d+',innp).group()    # 2.2*，不能匹配2.*2.3
# a = re.search('\d+\.?\d*[*/]\d+\.?\d*',innp).group()    # 可匹配到 2.2*2.3 或 2.2/1.1
# print(a)    # 2.2*
# x ,y = re.split('[*/]',a)
# print(type(x),x,y)
# z = float(x) * float(y)
# z = str(z)
# s = innp.replace(a,z)
# print(s)    # 结果就由 innp = '(3+2.2*2.3)' 变成了 (+5.06)

6）过滤文件内的所有ip地址

import  re

with open('hosts','r') as f:
    for line in f.readlines():
        result2 = re.findall('[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}', line)
        if not result2  == []:
            print result2[]
            result = result2[] + '\n'
            with open('hosts_ip', 'a+') as w:
                w.write(result)

五、时间模块time

1）三种时间格式

print(time.time())      # 时间戳
print(time.strftime('%Y-%m-%d %H:%M:%S'))   # 格式化字符串时间，标准时间格式
print(time.strftime('%Y-%m-%d %X'))         # 上面的简写
print(time.localtime()) # 结构化时间，东八区时间，把时间拆分成一小块
print(time.gmtime())    # 结构化时间，世界标准时间，把时间拆分成一小块

2）格式化时间的参数

%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 [,].
%H    Hour (-hour clock) as a decimal number [,].
%I    Hour (-hour clock) as a decimal number [,].
%j    Day of the year as a decimal number [,].
%m    Month as a decimal number [,].
%M    Minute as a decimal number [,].
%p    Locale’s equivalent of either AM or PM.    ()
%S    Second as a decimal number [,].    ()
%U    Week number of the year (Sunday as the first day of the week) as a decimal number [,]. All days in a new year preceding the first Sunday are considered to be in week .    ()
%w    Weekday as a decimal number [(Sunday),].
%W    Week number of the year (Monday as the first day of the week) as a decimal number [,]. All days in a new year preceding the first Monday are considered to be in week .    ()
%x    Locale’s appropriate date representation.
%X    Locale’s appropriate time representation.
%y    Year without century as a decimal number [,].
%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 [-:, +:].
%Z    Time zone name (no characters if no time zone exists).
%%    A literal '%' character.

3）三种时间的转换

# 结构化时间转换成时间戳
print(time.localtime())
print(time.mktime(time.localtime()))
# 时间戳转换成结构化时间
print(time.gmtime())

# 结构化时间转换成字符串标准时间
print(time.strftime('%Y-----%m',time.localtime()))

# 标准时间格式转换成结构化时间
print(time.strptime('2017-03-01','%Y-%m-%d'))

4）结构化时间，时间戳，与英文显示时间的转换

# 转换成 Sun May  ::  这种类型
print(time.asctime(time.localtime()))
print(time.ctime())

六、datatime模块

1）获取当前时间，时间戳转换成标准时间

import datetime
print(datetime.datetime.now())                   # 获取当前时间
print(datetime.datetime.fromtimestamp())  # 时间戳直接转换成格式化标准时间

2）运算时间

import datetime
print(datetime.datetime.now() + datetime.timedelta(days=))
print(datetime.datetime.now() + datetime.timedelta(weeks=))
print(datetime.datetime.now() + datetime.timedelta(hours=-))
print(datetime.datetime.now() - datetime.timedelta(hours=))

3）替换部分时间内容

print(datetime.datetime.now().replace(year=,hour=))

4）时间运算

import datetime
event_start_time = '2019-12-01T17:00:00.000Z'

event_start_time = datetime.datetime.strptime(event_start_time, "%Y-%m-%dT%H:%M:%S.%fZ") + datetime.timedelta(
            hours=)
print(event_start_time)  # -- ::

七、random随机数模块

1）random模块基本操作

import random
print(random.random())#(,)----float    大于0且小于1之间的小数
print(random.randint(,))  #[,]    大于等于1且小于等于3之间的整数
print(random.randrange(,)) #[,)    大于等于1且小于3之间的整数
print(random.uniform(,))              #大于1小于3的小数，如1.

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

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

2）随机生成验证码，用了ASCII表的

import random
# 思路，先个随机生成一个数字和字母，然后再随机选择其中一个
def make_code(n):
    res=''
    for i in range(n):
        s1=str(random.randint(,))
        s2=chr(random.randint(,))
        res+=random.choice([s1,s2])
    return res
print(make_code())

八、os 模块，与操作系统交互的模块

1）os的基本参数，也基本功能

os.cpu_count()  获取计算器的cpu核数
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的大小

2）os的基本练习

import os
print(os.listdir(r'.'))               # 显示当前目录下的所有文件，用列表的方式显示
print(os.stat('tatata.py'))          # 显示该文件的详细信息
print(os.stat('tatata.py').st_size)  # 获取文件大小，字节单位
print(os.path.getsize(r'tatata.py')) # 获取文件大小，字节单位

# tasklist 是Windows下的命令，显示当前所有的进程数
res=os.system('tasklist')
print('res---->',res) # res只是命令的执行成功与否的标志

os.environ['login']='yes'   # 添加系统环境变量
print(os.environ['login'])

print(os.path.split('/a/b/c/d.txt'))    # 把完整文件拆分成路径，和文件名，拆分结果返回元组的形式
print(os.path.split('/a/b/c/d.txt')[])
print(os.path.split('/a/b/c/d.txt')[])
# 更方便的方式获取到文件路径和文件名
print(os.path.dirname('/a/b/c/d.txt'))
print(os.path.basename('/a/b/c/d.txt'))

# join 拼接路径，注意点
print(os.path.join('a','b','D:\\','c','d.txt'))     # D:\c\d.txt
print(os.path.join('a','b','d','c','/','d.txt'))    # /d.txt

print(os.path.normcase('C:/windOws\\system32\\') )  # 只在Windows系统有用，c:\windows\system32\  ，大写换小写，左斜杠换右斜杠
print(os.path.normpath('c:\\windOws/a/b/../system32\\') ) #c:\\windOws/a/system32\\         # 规范路径，去掉 .. 或者.

# 获取上一级的上一级的目录的2种方式，类似也项目目录
os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
print(os.path.normpath(
    os.path.join(
        os.path.abspath(__file__),
        '..',
        '..'
    )
))

os.system("test.exe")       # 调用操作系统应用程序

九、 subprocess模块，调用操作系统命令，可将命令的结果存放起来

import subprocess
obj=subprocess.Popen('ipconfig /all',
                 shell=True,
                 stdout=subprocess.PIPE,    # 正确结果
                 stderr=subprocess.PIPE     # 错误结果
                 )
print(obj.stdout.read().decode('gbk'))

十、sys模块

1）常用操作

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

2）打印进度条

思路，方法

# import time
# # 打印进度条件
# print('\r[#                         ]',end='')
# time.sleep(0.5)
# print('\r[###                       ]',end='')
# time.sleep(0.5)
#
# print('\r[########                  ]',end='')
# time.sleep(0.5)
#
# print('\r[#########                 ]',end='')

# print('[%-50s]'  %'#')
# print('[%-50s]'  %'##')
# print('[%-50s]'  %'###')
# print('[%-50s]'  %'####')
# print('[%-50s]'  % (int(0.3*) * '#'))
# print('[%-50s]'  % (int(*) * '#'))

# print('%d%%' %)

模拟打印进度条

import time
def progress(percent,width=):
    if percent > :
        percent =
    show_str=('[%%-%ds]' %width) %(int(percent*width) * '#')
    print('\r%s %d%%' %(show_str,int( * percent)),end='')

total_size=
recv_size=
while recv_size < total_size:
    # 接收数据
    time.sleep(0.1)
    recv_size+=
    percent=recv_size / total_size
    progress(percent)

3）获取到执行脚本的传入参数

import sys
print(sys.argv)

python cpu_test.py run

['cpu_test.py', 'run']  已获取到该参数

十一、shutil模块。高级的 文件、文件夹、压缩包 处理模块

1）将文件内容拷贝到另一个文件中

import shutil
shutil.copyfileobj(open('a.xml','r'), open('new.xml', 'w'))

2）拷贝文件

shutil.copyfile('f1.log', 'f2.log')

3）仅拷贝权限。内容、组、用户均不变

shutil.copymode('f1.log', 'f2.log')

4）仅拷贝状态的信息，包括：mode bits, atime, mtime, flags

shutil.copystat('f1.log', 'f2.log') 

5）拷贝文件和权限

shutil.copy('f1.log', 'f2.log')

6）拷贝文件和状态信息

shutil.copy2('f1.log', 'f2.log')

7）递归的拷贝文件夹

shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))

8）拷贝软连接

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

9）递归的删除文件

import shutil
shutil.rmtree('folder1')

10）递归的去移动文件，它类似mv命令，其实就是重命名。

shutil.move('folder1', 'folder3')

11）打包与解压

import shutil
#将 /data 下的文件打包放置当前程序目录
ret = shutil.make_archive("data_bak", 'gztar', root_dir='/data')

#将 /data下的文件打包放置 /tmp/目录
ret = shutil.make_archive("/tmp/data_bak", 'gztar', root_dir='/data')

打包和解压的原理，shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的

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

zipfile的压缩和解压

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

tarfile的压缩和解压

十二、xml模块

在json模块之前，大都使用xml模块来进行数据交换。xml数据如下

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes"></rank>
        <year></year>
        <gdppc></gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes"></rank>
        <year></year>
        <gdppc></gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes"></rank>
        <year></year>
        <gdppc></gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
    </country>
</data>

a.xml

xml协议在各个语言里的都 是支持的，在python中可以用以下模块操作xml：

import xml.etree.ElementTree as ET
tree = ET.parse("a.xml")
root=tree.getroot()

print(root.iter('year')) #全文搜索
print(root.find('country')) #在root的子节点找，只找一个
print(root.findall('country')) #在root的子节点找，找所有

1）输入一个标签的各个部分的内容

import xml.etree.ElementTree as ET
tree = ET.parse("a.xml")
root=tree.getroot()

print(root.tag)     # 跟，标签名
print(root.attrib)  # 属性
print(root.text)    # 文本内容

2）各种查找方式

import xml.etree.ElementTree as ET
tree = ET.parse("a.xml")
root=tree.getroot()

res=root.iter('year') # 从整个树形结构中寻找
# print(list(res))
for item in res:
    print(item.tag,item.attrib,item.text)

res=root.find('country').find('year') # 从当前节点的儿子中查找,找到第一个
print(res,res.text)

res=root.findall('country') # 从当前节点的儿子中查找,找到所有
print(res)

3）遍历整个文件

# 遍历
for country in root:    # root.iter('country)
    print('==============>',country.tag,country.attrib)
    for item in country:
        print(item.tag,item.attrib,item.text)

4）修改文件内容

# 修改文件内容
for year in root.iter('year'):
    print(year.text)
    year.text=str(int(year.text) + )
    print(year.text)
    year.attrib={'updated':'yes'}   # 增加属性
tree.write('a.xml')

5）之上，删除year的属性

# 删除选中的属性
for year in root.iter('year'):
    year.attrib.pop('updated')
tree.write('a.xml')

6）删除节点

# 删除节点
for country in root:
    rank=country.find('rank')
    v=int(rank.text)
    if v > :
        # print(rank.text)
        root.remove(country)
tree.write('a.xml')

7）增加一个标签

# 增加一个标签
for country in root:
    tag=ET.Element('egon')
    tag.attrib={'age':"",'sex':'male'}
    tag.text='tearcher'
    country.append(tag)
tree.write('a.xml')

十三、shelve模块，作用类似于pickle模块，同样只支持python类型，操作更简单

import shelve
# userinfo={
#     'egon':{'age':,'sex':'male'},
#     'alex':{'age':,'sex':'female'},
# }
f=shelve.open(r'sheve.txt',writeback=True)
f['egon']={'age':,'sex':'male'}
f['alex']={'age':,'sex':'female'}
f['egon']['age']=    # 修改
print(f['egon']['age'])
f.close()

十四、configparser 解析配置文件的模块，如 my.ini。类似也mysql的配置文件

[egon]
pwd=
age=
salary=3.1
is_beautiful=True

[alex]
pwd=
age=
salary=3.2

my.ini

1）查看配置文件的内容

import configparser
config=configparser.ConfigParser()
config.read('my.ini')
print(config.sections())       # 查看所有的标题
print(config.options('egon')) # 取出该标题下的所有key

v1=config.get('egon','age')     # 取出key的值
print(v1,type(v1))

v2=config.getint('egon','age')  # 直接被转换成整形
print(v2,type(v2))

v3=config.getfloat('egon','salary')
print(v3,type(v3))

v4=config.getboolean('egon','is_beautiful')
print(v4,type(v4))

2）修改配置文件的内容

import configparser

config=configparser.ConfigParser()
config.read('a.cfg',encoding='utf-8')

#删除整个标题section2
config.remove_section('section2')

#删除标题section1下的某个k1和k2
config.remove_option('section1','k1')
config.remove_option('section1','k2')

#判断是否存在某个标题
print(config.has_section('section1'))

#判断标题section1下是否有user
print(config.has_option('section1',''))

#添加一个标题
config.add_section('egon')

#在标题egon下添加name=egon,age=18的配置
config.set('egon','name','egon')
config.set('egon','age',) #报错,必须是字符串

#最后将修改的内容写入文件,完成最终的修改
config.write(open('a.cfg','w'))

3）基于修改的内容的方法，自动创建 ini 文档

import configparser

config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '',
                      'Compression': 'yes',
                     'CompressionLevel': ''}

config['bitbucket.org'] = {}
config['bitbucket.org']['User'] = 'hg'
config['topsecret.server.com'] = {}
topsecret = config['topsecret.server.com']
topsecret['Host Port'] = ''     # mutates the parser
topsecret['ForwardX11'] = 'no'  # same here
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini', 'w') as configfile:
   config.write(configfile)

十五、psutil模块使用，监控服务器cpu内存模块

import psutil
def cpu ():
    cpu_count = psutil.cpu_count(False)
    cpu_per = int(psutil.cpu_percent())
    print(cpu_per)
    print(cpu_count)
    return cpu_per

https://www.cnblogs.com/saneri/p/7528283.html

十六、python模块总篇

常用重要模块
    time    时间模块
    datatime 模块
    socket    网络套接字
    logging    日志模块
    hash    加密算法
    re        正则模块
    random    随机数模块
    shutil    文件、文件夹、压缩包 处理模块

与服务器相关运行模块，运维脚本开发
    os        与操作系统交互的模块，添加环境变量
    psutil    查看服务器的cpu，内存的模块
    sys        常用查看系统路径，系统变量
    paramiko    与服务器连接的模块
    subprocess 调用操作系统命令
    pymysql        服务库连接

配置文件解析模块
    xml        解析Java配置文件
    configparser    解析配置文件

数据封装传输模块
    json    封装数据传输
    pickle    封装数据传输
    shelve模块，作用类似于pickle模块，同样只支持python类型，操作更简单

web框架类
    django
    tornado
    flask
    bottle

爬虫类
    scrapy        爬虫框架
    requests    爬虫，模拟请求
    beautisoup    正则分析前端字符串

并发编程相关
    Process        进程
    Thread        线程

图形化模块
    Seaborn        图形可视化库
    matplotlib    图形可视化
    numpy        科学计算库，类似于操作三维列表
    tkinter        GUI编程模块

原文出处：http://www.cnblogs.com/linhaifeng/articles/6384466.html#_label4