转载请注明预见才能遇见的博客：http://my.csdn.net/
原文地址：https://blog.csdn.net/pcaxb/article/details/94449127
人工智能系列-Python系列（九）常用模块和包
目录
3.结构化时间，localtime当地时间，gmtime UTC 标准时间、将时间戳转化成格式化时间
4.字符串时间 mktime 、strftime、strptime
1.random 0-1的随机数 和 uniform 0-x的随机数
3. randrange() 方法返回指定递增基数集合中的一个随机数，基数缺省值为1。包括开始，不包括结束
1.chdir 获取当前工作目录，即当前python脚本工作的目录路径
2.chdir 改变当前脚本工作目录；相当于shell下cd
3,makedirs removedirs 创建和删除文件夹
3.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
3.json.dump() 和 json.load() 用于文件处理
3.hmac 模块，它内部对我们创建 key 和 内容 再进行处理然后再加密:
一.模块和包
1.定义和特性
# 模块
# 模块定义: 一个.py文件就称之为一个模块（Module）
# 模块一共三种：python标准库、第三方模块、应用程序自定义模块from A import B # from对应 A\B.py# import 做的事情
# import 找到文件、当前环境执行文件
# 1）执行对应文件
# 2）引入变量一般会把程序的入口定义成bin.py# 包：
# 包组成模块
# 包和包之间是可以重复文件名的2.模块调用路径
# from web.web1.web3.cal import add
# from web.web1.web3 import cal
from web.web1.web3.cal import *
# from web.web1 import web3 #执行web3的__init__文件,python3也是支持调用的
# print(1111111111111,web3.cal.add())3.__name__
# 系统变量 如果右键运行，__name__的值就是__main__print(__name__) # __main__# 不想bin文件被调用
if __name__ == '__main__': # 如果这里是执行文件
print('===', add())4.临时修改sys
# import sys
# print(sys.path)
# sys.path.append("D:\\dev\\day21\\test")
# print(sys.path)
# ['D:\\dev\\day21', 'D:\\dev', 'C:\\Program Files\\JetBrains\\PyCharm 2019.1.2\\helpers\\pycharm_display', ... ]
5.bin文件
# coding=utf-8
# from web.web1.web3.cal import *
import sys, os
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)
from web.web1.web3.cal import *
# 不想bin文件被调用
if __name__ == '__main__': # 如果这里是执行文件
print('===', add())
二、time模块
1.sleep 线程等待的时间，单位为秒
time.sleep(10) # 等待10s2.time 时间戳 计算
print(time.time()) # 1560842186.534062秒 1970年开始的秒数3.结构化时间，localtime当地时间，gmtime UTC 标准时间、将时间戳转化成格式化时间
# t = time.localtime()
# time.struct_time(tm_year=2019, tm_mon=6, tm_mday=18, tm_hour=15, tm_min=19, tm_sec=35, tm_wday=1, tm_yday=169, tm_isdst=0)
# print(t.tm_year) # 2019
# print(time.localtime(1460842186))
# time.struct_time(tm_year=2016, tm_mon=4, tm_mday=17, tm_hour=5, tm_min=29, tm_sec=46, tm_wday=6, tm_yday=108, tm_isdst=0)
# UTC 标准时间
print(time.gmtime())
# time.struct_time(tm_year=2019, tm_mon=6, tm_mday=18, tm_hour=7, tm_min=23, tm_sec=45, tm_wday=1, tm_yday=169, tm_isdst=0)
print(time.gmtime(1460842186))
# time.struct_time(tm_year=2016, tm_mon=4, tm_mday=16, tm_hour=21, tm_min=29, tm_sec=46, tm_wday=5, tm_yday=107, tm_isdst=0)
4.字符串时间 mktime 、strftime、strptime
# 将结构化时间转换成时间戳
print(time.mktime(time.localtime())) # 1560843153.0
# 将结构化时间转成字符串时间strftime
# %X 代表时分秒
print(time.strftime('%Y-%m-%d %X', time.localtime()))
# 将字符串时间转成结构化时间strptime
print(time.strptime('2019:01:01:12:56:21', '%Y:%m:%d:%X'))
# time.struct_time(tm_year=2019, tm_mon=1, tm_mday=1, tm_hour=12, tm_min=56, tm_sec=21, tm_wday=1, tm_yday=1, tm_isdst=-1)
5. asctime、ctime
print(time.asctime()) # Tue Jun 18 15:46:08 2019
print(time.ctime()) # Tue Jun 18 15:46:08 2019
6.datetime
import datetime
print(datetime.datetime.now()) # 2019-06-18 15:50:33.425216
三、random模块
1.random 0-1的随机数 和 uniform 0-x的随机数
print(random.random()) # 0-1的随机数
print(random.uniform(1, 4)) # 0-4的随机数2.randint 参数范围的整数
print(random.randint(1, 5)) # 4 整数3. randrange() 方法返回指定递增基数集合中的一个随机数，基数缺省值为1。包括开始，不包括结束
print(random.randrange(1, 3)) # 1
print(random.randrange(1, 10, 3)) # 1 4 74.choice随机列表中一个元素
print(random.choice([1, 2, 4, 5, 88]))5.sample随机列表中多个元素
print(random.sample([1, 2, 4, 5, 88], 3)) # [2,5,4]6.shuffle打乱数组
res = [1, 2, 3, 4, 5, 6]
random.shuffle(res)
print(res)7.验证码案例
print(chr(97)) # a
print(chr(122)) # z
def code_ver(n):
end = ""
for i in range(n):
num = random.randint(0, 9)
letter = chr(random.randint(97,122))
res = str(random.choice([num, letter]))
end += res
return end
print(code_ver(6))四、os模块
1.chdir 获取当前工作目录，即当前python脚本工作的目录路径
print(os.getcwd()) # D:\dev\day21
2.chdir 改变当前脚本工作目录；相当于shell下cd
os.chdir("web")
print(os.getcwd()) # D:\dev\day21\web
os.chdir("..")
print(os.getcwd()) # D:\dev\day213,makedirs removedirs 创建和删除文件夹
# os.makedirs('a/b')
# os.removedirs('a/b')4. remove 删除文件
os.remove('test01/yy.py')5.获取文件的信息 大小，访问时间、修改时间等
print(os.stat('random_.py'))6.system 运行shell命令，直接显示
print(os.system('dir')) #例如 dir命令7.split、dirname、basename
# 将path分割成目录和文件名二元组返回
print(os.path.split(os.getcwd())) # ('D:\\dev', 'day21')
# 返回path的目录。其实就是os.path.split(path)的第一个元素
print(os.path.dirname(os.getcwd())) # D:\dev
# 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
print(os.path.basename(os.getcwd())) # day21
8.join 路径拼接 不能直接拼接，要考虑不能环境
a1="D:\dev\day21\web"
b1="web1\web3\cal.py"
print(os.path.join(a1,b1))# 路径拼接 D:\dev\day21\web\web1\web3\cal.py
9.案例代码
bin文件
# coding=utf-8
# from web.web1.web3.cal import *
import sys, os
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)
from web.web1.web3.cal import *
# 不想bin文件被调用
if __name__ == '__main__': # 如果这里是执行文件
print('===', add())cal文件
# 如果cal只是同级调用没有问题，如果cal需要被上级调用不能这么写，所以看需求咯
# from cal1 import addc
# 导入所有
# from cal1 import *
# 不能cal同级调用、 只能web对应的同级调用
from web.web1.web3.cal1 import addc
def add():
res = addc(1, 2)
print(res)
return res
print(__name__)# web.web1.web3.cal 执行文件调用就是__mian__ ,不是执行文件就是路径
if __name__ == '__main__': # 用于被调用文件测试
add()cal1文件
# coding=utf-8
def addc(x, y):
return x + y
五、sys模块
1.version 获取python版本
print(sys.version)2.exit退出程序，正常退出时exit(0)
sys.exit(0)3.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
print(sys.path)4.其他 argv maxint platform
# sys.argv 命令行参数List，第一个元素是程序本身路径
# sys.exit(n) 退出程序，正常退出时exit(0)
# sys.version 获取Python解释程序的版本信息
# sys.maxint 最大的Int值
# sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
# sys.platform 返回操作系统平台名称5.进度条 案例
import time
for i in range(5):
sys.stdout.write("#")
time.sleep(0.5)
# sys.stdout.flush() # python2需要加，python3不要加六、json & pickle json非常重要
# 什么是序列化？
# 1）我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，
# 在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。
# 2）序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。
# 3）反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。# json模块1.dumps 对象--json格式的字符串
names = {'name': 'pca', 'age': 12, 'height': '1.3m'}
names_json = json.dumps(names)2.loads json格式字符串--对象
name2 = json.loads(names_json)
#
print(name2['name']) # pca
# print(json.dumps((1,2,4,))) # [1, 2, 4]3.json.dump() 和 json.load() 用于文件处理
# f = open('test.txt','w')
# json.dump(names,f)
# with open('test.txt','r') as f:
# names_obj = json.load(f)
# print(1,names_json)pickle模块
# pickle模块 pickle和json的使用一模一样
# Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，
# 因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。
# pickle保存的数据不可读，json保存的数据可读
import pickle
names1 = {'name': 'pca', 'age': 12, 'height': '1.3m'}4.dumps 对象--json格式的字符串
names1_pickle = pickle.dumps(names1)
print(names1_pickle)5.loads json格式字符串--对象
names4 = pickle.loads(names1_pickle)
print(names4) # {'name': 'pca', 'age': 12, 'height': '1.3m'}
七、shelve模块
import shelve
f = shelve.open(r'shelve1') # 目的：将一个字典放入文本 f={}
# f['stu1_info']={'name':'alex','age':'18'}
# f['stu2_info']={'name':'alvin','age':'20'}
# f['school_info']={'website':'oldboyedu.com','city':'beijing'}
# f.close()
print(f.get('stu1_info')['age']) # 18八、xml模块 （不常用）
<data>
<country name="Liechtenstein">
<rank name="111" updated="yes">8</rank>
<year updated="yes">2010</year>
<gdppc>141100</gdppc>
<neighbor direction="E" name="Austria" />
<neighbor direction="W" name="Switzerland" />
</country>
<country name="Singapore">
<rank name="111" updated="yes">11</rank>
<year updated="yes">2013</year>
<gdppc>59900</gdppc>
<neighbor direction="N" name="Malaysia" />
</country>
<country name="Panama">
<rank name="111" updated="yes">75</rank>
<year updated="yes">2013</year>
<gdppc>13600</gdppc>
<neighbor direction="W" name="Costa Rica" />
<neighbor direction="E" name="Colombia" />
</country>
</data># coding=utf-8
import xml.etree.cElementTree as ET
tree = ET.parse('xml_lesson')
root = tree.getroot() # 获取根节点
print(root.tag) # tag 标签名字
for item in root:
# print(item) # 节点
for i in item:
print(i.tag) # 标签名字
print(i.attrib) # 标签的属性
print(i.text) # 标签中间的值
# 只获取rank
for item1 in root:
for item2 in item1:
if item2.tag == 'rank':
print(item2.text)
for item1 in root.iter('rank'):
print(item1.tag, item1.text)
# 修改
for item1 in root.iter('rank'):
# print(item1.tag,item1.text)
item1.text = str(int(item1.text) + 1) # 一定要转成字符串类型
item1.set('name', '111')
tree.write('xml_lesson')
# 删除
# for country in root.findall("country"):
# rank_text = country.find('rank').text
# # print(rank_text)
# if int(rank_text) == 9:
# root.remove(country)
# tree.write('xml_lesson')
# 新建
# 新建根节点
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("xml_new.xml", encoding="utf-8", xml_declaration=True)
ET.dump(new_xml) # 打印生成的格式
九、configparser模块
# configparser 配置信息
# 配置文件不区分大小写测试数据
[DEFAULT]
serveraliveinterval = 45
compression = yes
compressionlevel = 9
forwardx11 = yes
[bitbucket.org]
user = hg
[topsecret.server.com]
host port = 50022
forwardx11 = no
[toskin.cn]
name = pca111
age = 15
[test]公共代码
import configparser
# 获取配置对象
config = configparser.ConfigParser()
1.新增一个配置文件
# config["DEFAULT"] = {'ServerAliveInterval': '45',
# 'Compression': 'yes',
# 'CompressionLevel': '9'}
#
# config['DEFAULT']['ForwardX11'] = 'yes'
#
# 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
#
# with open('configparser.ini', 'w') as configfile:
# config.write(configfile)2.查询
print(config.sections()) # []
# 读取文件到config
config.read('configparser.ini')
print(config.sections()) # ['bitbucket.org', 'topsecret.server.com']
print('bitbucket.org' in config) # True
print('bitbucket.org' in config.sections()) # True
print(config['topsecret.server.com']['host port']) # 50022
print(config['DEFAULT']['Compression']) # yes
# 不区分大小写，其他配置和默认配置重复，覆盖
# 相当于默认配置是公共的，其他配置是默认配置的子配置
print(config['topsecret.server.com']['ForwardX11']) # no
print(config['topsecret.server.com']['forwardx11']) # no
for item in config['topsecret.server.com']:
print(item)
# host port
# forwardx11
# serveraliveinterval
# compression
# compressionlevel
# 获取块下所有字段key
# ['host port', 'forwardx11', 'serveraliveinterval', 'compression', 'compressionlevel']
print(config.options('topsecret.server.com'))
# 获取块下所有字段key和value
# [('serveraliveinterval', '45'), ('compression', 'yes'), ('compressionlevel', '9'), ('forwardx11', 'no'), ('host port', '50022')]
print(config.items('topsecret.server.com'))
# 获取块下某个字段key和value
print(config.get('topsecret.server.com', 'compressionlevel')) # 9
3.添加块和添加和修改属性
#添加块
# config.add_section('toskin.cn')
#一定要记的写
# config.write(open('configparser.ini', 'w'))
#修改和添加属性
config.set('toskin.cn','name','pca111')
config.set('toskin.cn','age','12')
#修改
config['toskin.cn']['age'] = '15'
#修改块没有，可以先删除，然后新增
4.删除块和属性
#删除块
# config.remove_section('test')
# config.write(open('configparser.ini', 'w'))
#删除属性
# config.remove_option('test','name')
config.write(open('configparser.ini', 'w'))十、hashlib模块
# 用于加密相关的操作，3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法
1.md5加密
import hashlib
# md5 = hashlib.md5() # <md5 HASH object @ 0x000001C6F0761350>
md5 = hashlib.md5("key秘钥".encode('utf-8')) # 这里是增加一个秘钥
# 参数是字节
md5.update('pca'.encode('utf-8'))
# 打印加密之后的字符串
print(md5.hexdigest()) # 0b6af46c81c297aafb1d71e7d49ffda8
# 以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。
2.hsa256加密
hash = hashlib.sha256('key秘钥'.encode('utf8'))
hash.update('pca'.encode('utf-8'))
print(hash.hexdigest()) # d518092d465e88af88692249e13d62be067b8b0580cd12e0636b97d348a64840
3.hmac 模块，它内部对我们创建 key 和 内容 再进行处理然后再加密:
import hmac
h = hmac.new('key秘钥'.encode('utf-8'))
h.update('pca'.encode('utf-8'))
print(h.hexdigest()) # aba8ee27709796d12ec31c1cba7b64f3
十一、logging模块
1.灵活配置日志级别，日志格式，输出位置
# logging.basicConfig(
# # 默认是warning所以只显示warning以上级别的,打印三条
# level=logging.DEBUG, # 设置级别DEBUG,打印五条
# filename='logger.log', # 把日志打印到文件中去 ，否则就是显示在控制台
# filemode='w', # 默认是追加的模式，这里可以设置
# format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s', #日志打印的格式
# )# filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。
# filemode：文件打开方式，在指定了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用户输出的消息
# logging.debug('debug meg')
# logging.info('info msg')
# logging.warning('warning')
# logging.error('error')
# logging.critical('critical')
2.logging对象
logging.basicConfig(
# # 默认是warning所以只显示warning以上级别的,打印三条
level=logging.DEBUG, # 设置级别DEBUG,打印五条
# filename='logger.log', # 把日志打印到文件中去 ，否则就是显示在控制台
# filemode='w', # 默认是追加的模式，这里可以设置
format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s', # 日志打印的格式
)
#logging 对象的情况下，也可以使用basicConfig设置
# 创建logging对象
logger_ = logging.getLogger()
# 设置级别
# logger_.setLevel(logging.DEBUG)
# 日志打印格式
# fm = logging.Formatter('%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s')
# 创建一个handler，用于写入日志文件
fn = logging.FileHandler('logger2.log')
# 再创建一个handler，用于输出到控制台
ch = logging.StreamHandler()
# 设置日志打印格式
# fn.setFormatter(fm)
# ch.setFormatter(fm)
# logger对象可以添加多个fh和ch对象
logger_.addHandler(fn)
logger_.addHandler(ch)
logging.debug('debug meg')
logging.info('info msg')
logging.warning('warning')
logging.error('error')
logging.critical('critical')
3.兄弟之间的覆盖 后面的名字相同
# logger1 = logging.getLogger('mylogger')
# logger1.setLevel(logging.DEBUG)
#
# logger2 = logging.getLogger('mylogger')
# logger2.setLevel(logging.INFO)
# logger2 会覆盖 logger1十二、re模块
# re 正则表达式
# 定义：正则表达式（regular expression）就是用一个“字符串”来描述一个特征，然后去验证另一个“字符串”是否符合这个特征。
# 正则表达式（或 RE）是一种小型的、高度专业化的编程语言，（在Python中）它内嵌在Python中，并通过 re 模块实现。
# 正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。
import re
# 1.
re1 = re.findall('\d+', 'hafhah12hfahfh34hfahfh56fhafh78hfahf90')
print(re1)
# 2.
print(re.findall('(abc)+', 'abcabcabc')) # ['abc']
print(re.findall('(?:abc)+', 'abcabcabc')) # ['abcabcabc']
print(re.findall('abc+', 'abcabcabc')) # ['abc', 'abc', 'abc']
参考资料：https://www.cnblogs.com/yuanchenqi/articles/5732581.html
人工智能系列-Python系列（九）常用模块和包
博客地址：https://blog.csdn.net/pcaxb/article/details/94449127
970
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
