创世网站建设公司,wordpress 仿微博,石家庄公司网站设计,域名申请时间需要多久1. 模块和包
**容器#xff1a;**列表、元组、字符串、字典等#xff0c;对数据的封装**函数#xff1a;**对语句的封装**类#xff1a;**对方法和属性的封装#xff0c;即对函数和数据的封装
而模块#xff08;module#xff09;就是个程序#xff0c;一个.py 文件**列表、元组、字符串、字典等对数据的封装**函数**对语句的封装**类**对方法和属性的封装即对函数和数据的封装
而模块module就是个程序一个.py 文件模块分为三类
**Python 标准库**如 time、random 等**第三方模块**如 requests、beautiful 等**应用程序自定义模块**用户自定义模块
随机程序代码越写越多每个文件里面的代码越来越长越来越不容易维护。使用模块的好处
模块化代码 将不同功能的代码归类提高代码的可维护性**避免重复造轮子**编写代码可以不必从零开始可以引用别人已经写好的模块Python 有很多优秀的第三方模块**命名空间**每个模块单独维护一个命名空间不同模块相同函数名、变量名不会有冲突 **Tips**自定义模块的时候不要与内置的模块名有冲突不然会影响内置模块 1.1 包
为了避免不同的人编写的模块名相同Python 引入了按目录来组织模块的方法 —— 包Package
不同包下的模块名字相同不会有冲突只要顶层的包名不冲突就行。
如何创建一个包
创建一个文件夹里面存放相应模块文件文件夹名字即为包名在文件夹中创建一个 __init__.py 文件可以为空
1.2 导入模块
导入模块的几种常用方法 import 模块1, 模块2... # sys.path搜索路径 from 模块名 import 函数名 from 模块名 import * # 导入模块中所有函数不推荐导致命名空间优势荡然无存from one.two import main import 模块名 as newname # 当模块名比较长时我们可以给它去个新名字使用起来更方面导入模块后就需要使用模块中的函数我们可以使用 模块名.函数名 或直接调用函数即可
# calc.py
def add(x, y):return x yimport calc # 导入模块使用 模块名.函数名 的方法调用函数
calc.add(4, 6)from calc import add # 直接把函数名也导入可以直接调用函数
add(4, 6)不同包中的模块导入方法 three.py 是个模块two 是个包两者同级。要想在 three.py 中导入 calc.py
from one.two import calc1.3 __name__ __main__
有时我们在阅读别人的源代码时经常看到代码中有 if __name__ __main__它有什么作用呢
**在被调用文件上**用于被调用文件的测试在执行文件上 不想这个文件成为被调用文件
# calc.py
pi 3.14def main():print(pi:, pi)
main()现在我们想在bin.py 中调用 cacl.py 中的 add()函数计算两个数的和
# bin.py
from calc import pidef calc_round_area(radius):return pi * (radius ** 2)def main():print(round area:, calc_round_area(2))main()pi: 3.14
round area: 12.56bin.py 把 main()函数也执行了而不是我们想要的只执行calc_round_area() 函数。在有些时候我们只想 被调用模块的部分程序函数被调用而不是全部程序。我们可以在 被调用模块中添加 if __name__ __main__将不想被调用的函数放入里面即可能被调用的不放入其中开发相应的接口即可。
# calc.py
pi 3.14def main():print(pi:, pi)if __name__ __main__:main()from calc import pidef calc_round_area(radius):return pi * (radius ** 2)def main():print(round area:, calc_round_area(2))main()我们再执行 bin.py 发现只执行
round area: 12.56函数也是对象每个对象都有一个__name__ 属性在程序中我们查看__name__ 属性为 __main__因此为 True
# calc.py
....
print(__name__)__main__一旦我们引入到其他模块中__name__ 属性就变成了 被引入模块的路径而不再是 __main__因此为 False即不能执行被调用模块 if __name__ __main__ 的程序。
# bin.py
...
print(calc.__name__)calc另一个作用是不想这个模块文件称为被调用文件我们将所有的调用方式都放入__name____main__下没有开发接口别人就不能调用模块中的任何函数了。
1.4 搜索路径
模块是一个 .py 文件那么必然有个路径。每次导入模块时首先在内置在解释器中找是否有这个模块如sys、time 模块再搜索安装目录。下载安装的模块一般都是在 Python 安装路径下的 Lib 目录下也可以使用 sys.path 查看
import sys
sys.path[, C:\\Users\\HJ\\Anaconda3\\python36.zip, C:\\Users\\HJ\\Anaconda3\\DLLs, C:\\Users\\HJ\\Anaconda3\\lib, C:\\Users\\HJ\\Anaconda3, C:\\Users\\HJ\\Anaconda3\\lib\\site-packages, C:\\Users\\HJ\\Anaconda3\\lib\\site-packages\\win32, C:\\Users\\HJ\\Anaconda3\\lib\\site-packages\\win32\\lib, C:\\Users\\HJ\\Anaconda3\\lib\\site-packages\\Pythonwin]对于自定义的模块可以使用 sys 模块将其路径添加到 sys.path 中需要注意的是这是临时修改永久修改需要修改系统环境变量。
sys.path.append(C:\\Python36\\test\\)BASE_DIR
每次这样将绝对路径添加到 sys.path 中一旦将程序拷贝别人使用就会出现没有这个模块的问题我们可以借用 BASE_DIR 来将文件本身的路径添加到 sys.path 中。
# __file__ 拿到文件名在 Pycharm 中之所以看到的是绝对路径是 Pycharm 给我们自动添加的
# os.path.abspath(__file__) 可以拿到文件的绝对路径
import sys, osBASE_DIR os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR)2. 模块
2.1 time 模块
Python 中三种时间表示法
**时间戳timestamp**时间戳是从 1970年1月1日 000000 开始按秒计算的偏移量返回的是浮点型**结构化时间struct_time**共有9个元素共九个元素:(年月日时分秒一年中第几周一年中第几天夏令时)**格式化的时间字符串**格式化后的时间如 1970-1-1 00:00:00
import time
# 1. time返回当前时间的时间戳time.time()
1542195047.3042223# 2. localtime[secs]将一个时间戳转换为当前时区的结构化时间未指定时间戳则以当前时间为准time.localtime() # 查看当前时间的结构化时间
time.struct_time(tm_year2018, tm_mon11, tm_mday14, tm_hour19, tm_min32, tm_sec51, tm_wday2, tm_yday318, tm_isdst0)time.localtime(1432195047.3042223) # 传入时间戳查看某个时间的结构化时间
time.struct_time(tm_year2015, tm_mon5, tm_mday21, tm_hour15, tm_min57, tm_sec27, tm_wday3, tm_yday141, tm_isdst0)# 3. gmtime[secs]与 localtime类似将一个时间戳转换为UTC时区0时区的struct_time。时间标准时间
# UTC英国格林威治全球每 15 度为一个时区总共 24 个时区格林威治为时间标准时间中国为东八区也就是说中国要比时间标准时间早八个小时time.gmtime() # 比中国晚早 8 小时
time.struct_time(tm_year2018, tm_mon11, tm_mday14, tm_hour11, tm_min34, tm_sec50, tm_wday2, tm_yday318, tm_isdst0)# 4. mktimep_tuple将结构化时间转换为时间戳参数为结构化的时间time.mktime(time.localtime()) # 将当前时间的结构化时间转换为时间戳
1542195406.0# 5. strftimeformat[, t]将结构化时间转换为字符串时间第一个参数为格式化成的时间格式第二个为结构化时间 %X 表示时分秒中间的分隔符随意time.strftime(%Y-%m-%d %X, time.localtime()) # 将当前时间的结构化时间转换为字符串时间
2018-11-14 19:39:22# 6. strptimestringformat将一个格式化时间字符串转换为结构化时间与 strftime是逆操作time.strptime(2018:11:14:19:42:56, %Y:%m:%d:%X)
time.struct_time(tm_year2018, tm_mon11, tm_mday14, tm_hour19, tm_min42, tm_sec56, tm_wday2, tm_yday318, tm_isdst-1)# 7. asctime[t]将结构化时间转换为一个固定形式的字符串时间默认为 time.localtime()time.asctime()
Wed Nov 14 19:45:57 2018# 8. ctime[secs]将时间戳转换为一个固定形式的字符串时间默认为 time.timetime.ctime()
Wed Nov 14 19:46:07 2018time.ctime(1542195047.3042223)
Wed Nov 14 19:30:47 2018# 9. sleepsecs线程推迟指定的时间运行单位为秒time.sleep(3)# 10. clock不同系统上含义不同UNIX 系统上返回的是 “进程时间”。Windows 系统上第一次调用为进程运行实际时间第二次调用为第一次调用到现在的运行时间即两次调用的时间差。time.clock()datetime 模块
datetime 模块也是一个时间模块只需记得一些一个方法即可
import datetimeprint(datetime.datetime.now()) # 查看当前时间的结构化时间
2018-11-14 16:56:12.0657092.2 random 模块
随机模块产生一个随机数
import random# 1. random随机产生一个 0 ~ 1 的浮点数random.random()
0.42091646162129426# 2. randintstart, stop产生一个 start ~ stop 的随机整数包含左右 [start, stop]random.randint(1, 3)
2# 3. randrangestartstop[,step] 产生一个指定递增基础集合中的一个随机整数基数缺省为 1 [start, stop)random.randrange(10, 20, 2) # 返回 [10, 20) 间的偶数
18random.randrange(10, 20, 3) # 返回 [10, 20) 间的其他数
13random.randrange(10, 20) # 返回 [10, 20) 间的任意一个数
17# 4. choiceseq在一个序列中随机获取一个元素random.choice([1, 2, 3])
2random.choice(hello)
l# 5. sampleseq, k从指定序列中随机获取指定长度 的片段不会修改原有序列random.sample([1, 2, 3, 4], 2) # 获取两个元素
[2, 3]# 6. uniformstartstop随机产生一个 start ~ stop 范围的浮点数random.uniform(1, 3)
2.4704091068940937# 7. shuffleseq打乱列表中元素顺序n [1, 2, 3]random.shuffle(n)n
[1, 3, 2]随机验证码生成
import randomdef v_code():产生一个四个字符组成的随机验证码:return: 验证码res for i in range(4):num random.randint(0, 9) # 产生一个 0~9 的随机整数alf chr(random.randint(65, 90)) # 产生一个 65~90 的随机整数再用 chr转换为大写字母ret random.choice([num, alf]) # 从 num、alf 中随机选取一个res str(ret)return resres v_code()
print(res)S3H62.3 os 模块
os 模块与操作系统的交互的接口
import os
# getcwd获取当前工作目录os.getcwd()
E:\\电脑软件\\cmder# chdirpath改变当前工作目录支持绝对路径和相对路径os.chdir(..) # 返回上一层目录os.chidr(E:\\)os.getcwd()
E:\\# listdirpath.列出指定目录下所有文件和目录os.listdir()
[.ipynb_checkpoints, bin, Cmder.exe, config, icons, LICENSE, README.md, SUMMARY.md, Untitled.ipynb, vendor, Version 1.3.6.678]os.listdir(E:\\)# mkdirpath创建文件夹若该文件夹存在抛出 FileExistsError 异常os.mkdir(test)# makedirspath创建多层目录os.makedirs(dir1/dir2) # 适用 Linux 和 winos.makedirs(rE:\a\b\c) # 仅适用 win# removepath删除指定文件不能删除目录os.remove(rE:\a\b\c\a.txt)# rmdirdir删除单个目录若目录为空则无法删除os.rmdir(rE:\a\b\c)# removedirspath若目录为空则删除。并递归到上一级目录如若也为空则删除依次类推os.removedirs(rE:\a\b)# renameoldnew重命名文件或文件夹os.chdir(rE:\\)os.getcwd()
E:\\os.mkdir(a)os.rename(a, b)# system(bash command) 运行shell命令直接显示os.system(calc) # 调用系统内置计算器# statpath/filename查看文件/目录信息如创建时间、修改时间、字节等
# st_size7文件多少个字节、st_atime用户上一次的访问时间、st_mtime上一次修改的时间、st_ctime创建时间os.stat(rE:\b\a.txt)
os.stat_result(st_mode33206, st_ino1125899906882595, st_dev646140012, st_nlink1, st_uid0, st_gid0, st_size7, st_atime1542207918, st_mtime1542207963, st_ctime1542207918)# sep输出当前操作系统特定的路径分隔符win 下为 \\Linux 为 /os.sep
\\# linesep输出当前平台使用的行终止符win下为 \r\nLinux 下为 \nos.linesep
\r\n# pathsep 输出用于分割文件路径的字符串 win下为;,Linux下为os.pathsep
;# name 输出字符串指示当前使用平台。win-nt; Linux-posixos.name
nt# environ 获取系统环境变量os.envirom# curdir返回当前目录.os.curdir
.# pardir获取当前目录的父目录字符串名..os.pardir
..# walkpath返回指定路径下所有子目录结果是一个三元组路径[包含目录][包含文件]for i in os.walk(rE:\b):
... print(i)
...
(E:\\b, [], [a.txt])os.path 模块
import os
# abspathpath返回文件或目录规范化的绝对路径os.path.abspath(a.txt)
E:\\b\\a.txt# splitpath将 path 分割成目录和文件名二元组返回os.path.split(rE:\b\a.txt)
(E:\\b, a.txt)os.path.split(os.path.abspath(a.txt))
(E:\\b, a.txt)# splitextpath分割文件拓展名os.path.splitext(os.path.abspath(a.txt))
(E:\\b\\a, .txt)# dirnamepath去掉文件名返回目录即返回 os.path.split[0]os.path.dirname(rE:\b\a.txt)
E:\\b# basenamepath去掉目录返回文件名即返回 os.path.split[1]os.path.basename(rE:\b\a.txt)
a.txt# existspath如果 path 存在返回 true否则为 falseos.path.exists(rE:\b)
True# isabspath如果 path 是绝对路径返回 true否则为 falseos.path.isabs(rE:\b)
True# isfilepath判断指定路径是否存在且是一个文件os.path.isfile(rE:\b)
False# isdirpath判断指定路径是否存在且是一个目录os.path.isdir(rE:\b)
True# joinpath1[, path2[,...]]拼接多个路径第一个绝对路径之前的参数将被忽略a rE:\a\b b rc\a.txt # 相对路径os.path.join(a, b)
E:\\a\\b\\c\\a.txt a rE:\a\b b rF:\c\a.txt # 第一个绝对路径之前的参数将被忽略os.path.join(a, b)
F:\\c\\a.txt a rE:\a\b b rE:\d\a.txt # 第一个绝对路径之前的参数将被忽略os.path.join(a, b)
E:\\d\\a.txt# getatimepath返回 path 所指向的文件或目录的最后存取时间os.path.getatime(rE:\b\a.txt)
1542207918.4124079# getmtimepath返回 path 所指向的文件或目录的最后修改时间os.path.getmtime(rE:\b\a.txt)
1542207963.2649732# getctimepath返回 path 所指向的文件或目录的创建时间os.path.getctime(rE:\b\a.txt)
1542207918.4124079# getsizepath返回 path 所指向的文件或目录的大小字节os.path.getsize(rE:\b\a.txt)
7图片爬取全代码
# 图片爬取全代码
import requests
import osurl https://ss3.bdstatic.com/70cFv8Sh_Q1YnxGkpoWK1HF6hhy/it/u2079998410,926856509fm26gp0.jpg
root rE:\\pics\\
path root url.split(/)[-1]try:if not os.path.exists(root): # 目录不存在则新建os.mkdir(root)if not os.path.exists(path): # path 不存在就爬取存在就打印 文件已经存在r requests.get(url)with open(path, wb) as f:f.write(r.content)f.close()print(保存文件成功)else:print(文件已经存在)
except:print(爬取失败)2.4 sys 模块
import sys
# exitn退出程序正常退出是 exit0exit(0)attempt to call a nil value
# version获取 Python 解释器程序的版本信息sys.version
3.6.5 |Anaconda, Inc.| (default, Mar 29 2018, 13:32:41) [MSC v.1900 64 bit (AMD64)]# path返回模块的搜索路径初始化时使用 PythonPath 环境变量的值sys.path# platform返回操作系统平台名称sys.platform
win32argv 变量
argv 命令行参数 List第一个元素是程序本身路径如允许 python hello.py 获得的 sys.argv 就是 [hello.py]允许 python hello.py poost 获得的 sys.argv 就是 [hello.py, post]。
# hello.py
#!/usr/bin/env python3 # 任何平台都能使用
# -*- coding: utf-8 -*- # 编码格式
一个测试 avgv 变量的模块
__author__ Hubery_Junimport sysdef test():args sys.argvif len(args) 1:print(Hello, world)elif len(args) 2:print(Hello, %s % args[1])else:print(Too many arguments)if __name__ __main__:test()在命令行运行 hello.py
$ E:\PycharmProjects\university_test\day21\one\fourpython shenzhen_work.py
Hello, world$ E:\PycharmProjects\university_test\day21\one\fourpython shenzhen_work.py rose
Hello, rosePython shell 交互环境中 import hellohello.test()
Hello worldFTP 上传下载功能简单实现
# ftp.py
import sysdef test():command sys.argv[1]path sys.argv[2]# 上传if command post:print(post 请求方式)# 下载elif command get:print(get 请求方式)print(下载路径为 %s % path)if __name__ __main__:test()命令行中运行 ftp.py
$ python ftp.py get E:/download/
get 请求方式
下载路径为 E:/download/进度条实现
import time
import sysfor i in range(20):sys.stdout.write(#)time.sleep(0.1)sys.stdout.flush()2.5 json 模块
之前我们学过 eval 方法可以将一个字符串处理成 Python 对象对于普通的数据类型eval 可以处理但是对于特殊的数据了新eval 就不管用了。json 适用于任何语言的数据交互写入文件的必须是字符串类型。
序列化
把对象变量从内存中变成可存储或传输的过程称为 序列化也叫 pickling其他语言中称之为 serializationmarshallingflattening等。反过来把变量内容从序列化的对象重新读取到内存中称之为 反序列化即 unpickling。
json
为了在不同编程语言之间能够互相传输就必须把对象序列化为标准格式如XML但最好的是 JSON。因为 json 表示出来的就是一个字符串可以被任何语言读取也方便存储到磁盘或通过网络传输而且比 XML 更快更可以在 Web 页面上读取非常方便。
json 表示的对象就是标准的 JavaScript 语言的对象json 和 Python 内置的数据类型对应关系如下
json 类型Python 类型json 类型Python 类型{}dict[]list‘string’str1234.56int 或 floattrue/falsetrue/falsenullNone
# 序列化
import jsondic {name: rose, age: 18} # type(dic) 为 class dictdic_sec json.dumps(dic) # 将 Python 的数据类型转换为 json 字符串数据类型typedic_sec 为 class strf open(test.json, w)
f.write(dic_sec) # 将 json 数据写入一个文件中
f.close()# dic_sec json.dumps(dic)
# f.write(dic_sec)
# 等价于 json.dump(dic, f)# 反序列化
import json
f open(test.json, r)
data json.loads(f.read()) # 等价于 data json.load(f)
f.close()
type(data) # class dictTipsjson 字符串是双引号不认单引号。无论数据是怎样创建的只要满足 json 格式即双引号就可以json.loads出来,不一定非要 dumps的数据才能 loads 2.6 pickle 模块
pickle 模块与 json 模块类似用法一致去区别在于 pickle 模块将数据序列化为 字节型而 json 序列化为 字符串型。
pickle 只能用于 Python而且版本不同也有可能不同因此只能用来保存不那么重要的数据。支持函数、类。
# 序列化
import pickledic {name: rose, age: 18}
dic_str pickle.dumps(dic) class bytes
f open(text.pkl, wb)
f.write(dic_str) # pickle.dump(dic, f)
f.close()# 反序列化
import picklef open(text.pkl, rb)
data pickle.loads(f.read()) # data pickle.load(f)
print(data)
f.close()2.7 shelve 模块
与 json、pickle 类似也是用于数据传输。只有一个open函数返回类似字典的对象可读可写 key 必须为字符串而值可以是 python 所支持的数据类型。
import shelvef shelve.open(rshelve.txt)# 存储会产生三个文件xxx.bak、xxx.dat、xxx.dir
# f[info] {name: rose, age: 18} # f 相当于一个空字典写操作相当于给字典赋值
# f.close()print(f.get(info)[name]) # 读取操作类似于字典取值----------------------------------------------------------
rose2.8 XML 模块
xml 是实现不同语言或程序之间进行数据交换的协议跟 json 差不多但 json 使用起来更简单。xml 比 json 出现更早早前不同语言之间数据交换都是 xml现在仍然有很多公司、语言在用但 json 是未来趋势。
import xml.etree.ElementTree as et
tree et.parse(test.xml) # 解析 text.xml
root tree.getroot() # 获取根节点
# node.tag获取标签名
# node.attrib获取属性名
# node.text获取文本内容
# root.findall(node_name) 查看根节点下所有叫 node_name 的标签
# node.find(node_name) 查看某个标签下某个子标签子节点
# root.iter(node_name) 查看根节点下所有叫 node_name 的标签
# node.set(属性名, 属性值) 修改某个节点的属性
# root.remove(node_name) 删除某个节点
# tree.write(text.xml) 不管是删除还是修改都要将修改后的文件写入原文件中findall查找的是所有某个节点find查找某个节点当有多个时只返回第一个
country root.find(country)
print(country.tag, country.attrib)rank country.find(rank)
print(rank.tag, rank.attrib, rank.text)country {name: Liechtenstein}
rank {updated: yes} 2XML 文档操作
?xml version1.0?
datacountry nameLiechtensteinrank updatedyes2/rankyear2008/yeargdppc141100/gdppcneighbor nameAustria directionE/neighbor nameSwitzerland directionW//countrycountry nameSingaporerank updatedyes5/rankyear2011/yeargdppc59900/gdppcneighbor nameMalaysia directionN//countrycountry namePanamarank updatedyes69/rankyear2011/yeargdppc13600/gdppcneighbor nameCosta Rica directionW/neighbor nameColombia directionE//country
/dataimport xml.etree.ElementTree as ettree et.parse(test) # 解析读取root tree.getroot() # 获取根节点# print(root.tag) # 打印根节点名称# 遍历 xml 文档
# for country in root:
# # print(country.tag, country.attrib)
# for i in country:
# print(i.tag, i.text)# # 只遍历所有 year 节点
# for year in root.iter(year):
# print(year.tag, year.text)# # 修改
# for year in root.iter(year):
# new_year int(year.text) 3
# year_text str(new_year)
# year.set(updated, yes)
# tree.write(test)# # 删除
# for country in root.findall(country):
# rank int(country.find(rank).text)
# if rank 50:
# root.remove(country)
# tree.write(test)生成 xml 文档
使用 Python 也可以手动生成 xml 文档。
import xml.etree.ElementTree as et
new_xml et.Element(root_node) # 创建一个名为 root_node 的根节点
node et.SubElemnt(father_node, node, attrib{key: value}) # 创建一个名为 node 的结点父节点为 father_node
node.text value # 设置某个节点的文本内容
ts et.ElementTree(new_xml) # 生成文档树对象
ts.write(test.xml, encodinguft-8, xml_declarationTrue)et.dump(new_xml) # 打印生成的格式import xml.etree.ElementTree as etnew_xml et.Element(data) # 生成一个名叫 data 的根节点
name et.SubElement(new_xml, name, attrib{enrolled: yes}) # 创建一个 name 节点父节点为 new_xml 即 data
age et.SubElement(name, age, attrib{checked: no}) # 创建一个 age 节点父节点为 name
sex et.SubElement(name, sex)
sex.text 33ts et.ElementTree(new_xml) # 生成文档树对象
ts.write(test.xml, encodinguft-8, xml_declarationTrue)et.dump(new_xml) # 打印生成的格式生成的 xml 文档
!--test.xml--
?xml version1.0 encodingutf-8?
dataname enrolledyesage checkedno /sex33/sex/name
/data2.9 logging 模块
logging 模块将日志打印到标准输出中且只显示大于等于 WARNING 级别的日志默认日志级别为 WARING日志级别等级CRITICAL ERROR WARNING INFO DEBUG NOTSET默认的日志格式为日志级别Logger名称用户输出消息。
logging 模块有两种输出日志的方法第一是利用 basicConfig 函数进行相应的配置第二是 logger 对象输出。
2.9.1 basicConfig 函数
basicConfig() 函数有很多参数通过更改其中参数可来设定日志输出形式以及格式等具体参数如下
filename用指定的文件名创建 FileHandle 这样日志会被存储到指定的文件中。filemode文件打开方式在指定了 filename 后默认为 ‘a’追加可以指定为 ‘w’覆盖format指定 handle 使用的日志显示格式datefmt指定日期时间格式level设置 rootlogger 的日志级别stream用指定的 stream 创建 StreamHandle。可以指定输出到 sys.stderr,sys,stdout输出到屏幕或文件fopen(test.log, w)输出到文件中默认为输出到屏幕。若同时列出了 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 logginglogging.basicConfig(levellogging.DEBUG,# 当前时间模块名行号等级名输出信息format%(asctime)s %(filename)s [line:%(lineno)d] %(levelname)s %(message)s,#datefmt%a, %d %b %Y %H:%M:%S,#filenametest.log)
logging.debug(debug message)
logging.info(info message)
logging.warning(waring message)
logging.error(error message)
logging.critical(critical message)输出
2018-11-19 17:04:06,070 logging_test.py [line:10] DEBUG debug message
2018-11-19 17:04:06,071 logging_test.py [line:11] INFO info message
2018-11-19 17:04:06,071 logging_test.py [line:12] WARNING waring message
2018-11-19 17:04:06,071 logging_test.py [line:13] ERROR error message
2018-11-19 17:04:06,071 logging_test.py [line:14] CRITICAL critical messagebasicConfig() 函数配置日志不够灵活而且不能同时输出在屏幕的同时保存到文件而 logger 对象恰好可以解决。
2.9.2 logger 对象
logging.basicConfig() 用默认日志格式Format为日志系统建立一个默认的流处理器StreamHandler设置基础配置如日志级别等并加到 root logger根 Logger中这几个 logging 模块级别的函数。另一个模块级别的函数 logging.getLogger([name]) 返回一个 logger 对象如果没有指定名字将返回 root logger。
一个 logger 对象
import logginglogger logging.getLogger() # 创建一个 logger 对象
#logger.setLevel(DEBUG) 设定日志等级fh logging.FileHandler(log.log) # 创建一个 handle用于写入日志文件ch logging.StreamHandler() # 创建一个 handle用于输出到屏幕# 指定日志显示格式
fomatter logging.Formatter(%(asctime)s %(filename)s [line:%(lineno)d] %(levelname)s %(message)s)# logger 对象添加多个 fh、ch 对象既输出到文件中也输出到屏幕上
logger.addHandler(fh)
logger.addHandler(ch)# 各等级日志输出信息
logger.debug(debug message)
logger.info(info message)
logger.warning(waring message)
logger.error(error message)
logger.critical(critical message)waring message
error message
critical message默认只输出三个级别可以通过 logger.setLevel(DEBUG) 设定日志级别。可用的日志级别有logging.DEBUG、logging.INFO、logging.WARNING、logging.ERROR、logging.CRITICAL。
logging 库提供了多个组件
**Logger**Logger 对象**Handler**发送日志到文件中或屏幕上**Filter**过滤日志信息**Format**指定日志显示格式
Logger 对象提供了应用程序可直接使用的接口Logger 是一个树形层级结构输出信息之前要获得一个 Looger 对象如果没有指定名字那么就是 root Looger 根。
两个 logger 对象
logger1 logging.getLogger(mylogger)
logger2 logging.getLogger(mylogger)logger1.setLevel(logging.DEBUG)
logger2.setLevel(logging.INFO)fh logging.FileHandler(new_log.log)
ch logging.StreamHandler()logger1.addHandler(fh)
logger1.addHandler(ch)logger2.addHandler(fh)
logger2.addHandler(ch)logger1.debug(debug message)
logger1.info(info message)
logger1.warning(waring message)
logger1.error(error message)
logger1.critical(critical message)logger2.debug(debug message)
logger2.info(info message)
logger2.warning(waring message)
logger2.error(error message)
logger2.critical(critical message)info message
waring message
error message
critical message
info message
waring message
error message
critical message可以看出输出了两次从 INFO 级别开始的日志导致出现这种情况出现的原因有两个
logger1 和 logger2 两个所创建的对象对应的是同一个 Logger 实例只要 logging.getLogger(name) 中的 name 相同则就是同一个实例有且仅有一个。在 logger2 实例中将 mylogger 的日志级别设置为 logging.INFO所有遵从了后来设置的日志级别。
对于上述情况我们只需设置不同的 name 即可。
一个 logger 和 一个 logger1 对象
# 一个 logger 和 一个 logger1 对象
logger logging.getLogger()
logger.setLevel(logging.INFO)logger1 logging.getLogger(mylogger)
logger1.setLevel(logging.DEBUG)ch logging.StreamHandler()logger.addHandler(ch)
logger1.addHandler(ch)logger.debug(debug message)
logger.info(info message)
logger.warning(waring message)
logger.error(error message)
logger.critical(critical message)logger1.debug(debug message)
logger1.info(info message)
logger1.warning(waring message)
logger1.error(error message)
logger1.critical(critical message)info message
waring message
error message
critical message
debug message
debug message
info message
info message
waring message
waring message
error message
error message
critical message
critical message之所以会出现两次是因为我们通过 logger logging.getLogger()显示的创建了root Logger而logger1 logging.getLogger(mylogger)创建了root Logger的孩子(root.)mylogger,logger2。而子孙既会将消息发布给给它的 Handler 处理也会传递给它的祖先 Logger 处理。
只要将 logger 输出注释掉就行 # logger.addHandler(ch)。
Filter
import logginglogger logging.getLogger()
logger1 logging.getLogger(mylogger)# 输出到屏幕控制台
ch logging.StreamHandler()# 定义一个 filter
f logging.Filter(mylogger)
ch.addFilter(f)logger.addHandler(ch)
logger1.addHandler(ch)# # 设置等级
# logger.setLevel(logging.DEBUG)
# logger1.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.debug(1)
logger1.info(2)
logger1.warning(3)
logger1.error(4)
logger1.critical(5)3
3
4
4
5
52.10 configparser 模块
可以用来生成某种固定格式的配置文件并具有增删改查操作。
import configparserconfig configparser.ConfigParser() # 相当于一个空字典 {}
config[DEFAULT] {ServerAliveInterval: 45,Compression: yes,CompressionLevel: 9}config[bitbucket.org] {}config[bitbucket.org][User] hgconfig[topsecret.server.com] {}topsecret config[topsecret.server.com]topsecret[Host Port] 50022topsecret[ForwardX11] noconfig[DEFAULT][ForwardX11] yeswith open(config.ini, w) as f:config.write(f)# config.ini
[DEFAULT]
serveraliveinterval 45
compression yes
compressionlevel 9
forwardx11 yes[bitbucket.org]
user hg[topsecret.server.com]
host port 50022
forwardx11 no增删改查操作
import configparser
config configparser.ConfigParser()#-------------------------查---------------------------config.read(config.ini) # 读取文件# 打印所有块名除默认 DEFAULT 以外
print(config.sections()) #[bitbucket.org, topsecret.server.com]# 判断某行是否在里面
print(bytebong.com in config) # False# 查询某个块下某个值
print(config[bitbucket.org][user]) # hg# 查询默认块下某个值
print(config[DEFAULT][compression]) # yes# 遍历某个块的所有键信息 遍历时会打印 default 的信息
for key in config[bitbucket.org]:print(key)
# user
# serveraliveinterval
# compression
# compressionlevel
# forwardx11# 查询某个块的所有键信息以列表形式显示
print(config.options(bitbucket.org)) # [user, serveraliveinterval, compression, compressionlevel, forwardx11]# 查询某个块的所有键信息以列表二元组形式显示
print(config.items(bitbucket.org))# [(serveraliveinterval, 45), (compression, yes), (compressionlevel, 9), (forwardx11, yes), (user, hg)]#---------------增-----------------------
# 增加块
config.add_section(yuan)# 增加块下键值信息
config.set(yuan, k1, 1111)#-----------删-----------------
# 删除块
config.remove_section(topsecret.server.com)# 删除块下键值
config.remove_option(bitbucket.org, user)config.write(open(new_config.ini, w))**Tips**DEFAULT 用来存储必要的信息以便每次遍历时能打印。增删改操作必须重新写入文件可以是同文件名 2.11 hashlib 模块
在加密操作中Python 3.x 用 hashlib 模块替代了 md5 和 sha 模块主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 MD5 算法。
MD5 算法
import hashlibm hashlib.md5() # 创建一个对象m.update(hello.encode(utf8)) # 对 hello 进行加密
print(m.hexdigest()) # 5d41402abc4b2a76b9719d911017c592m.update(admin.encode(utf8)) # 对 admin 进行加密
print(m.hexdigest()) # dbba06b11d94596b7169d83fed72e61bm2 hashlib.md5()
m2.update(helloadmin.encode(utf8))
print(m2.hexdigest()) # dbba06b11d94596b7169d83fed72e61bm 对象加密字符串 hello再加密 admin 得到的结果和 m2 对象之间加密 helloadmin 的结果一样。
以上加密算法虽然比较厉害但还是可以通过撞库反解所有可以在加密算法中添加自定义 key 再加密。
import hashlib
m hashlib.md5(dfkey.encode(utf8)) # 添加自定义 key随意
m.update(hello.encode(utf8))
print(m.hexdigest()) # a674e0a8aa1a489ce67538a28c60abbfsha256 算法
与 md5 算法用法一致
m hashlib.sha256()
m.update(hello.encode(utf8))
print(m.hexdigest())2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824还有一个 hmac 模块它内部对我们创建 key 和内容再处理然后加密
import hmach hmac.new(rose.encode(utf8))
h.update(hello.encode(utf8))
print(h.hexdigest()) # a3b661e7d63a4eb65acb8223f96e22412.12 hamc 模块
实现标准的 Hmac 算法
方法
# 产生一个新的哈希对象并返回
# 随机 keymsg哈希算法默认 md5
h hmac.new(key, msgNone, digestmodNone)# 获取哈希对象的散列值
h.digest()# 和 digest() 一样但返回的是一串十六进制数字
h.hexdigest()# 用新的字符串 msg2 去更新哈希对象
h.update(msg2)示例
import hmackey bI love python
msg bpythonh hmac.new(msg, key, digestmodmd5)
digest h.digest()
hexdigest h.hexdigest()
print(digest)
print(hexdigest)msg2 bpycharm
h.update(msg2)
print(h.hexdigest())b\xda\xf3\x0c\xa5\x175Cka\x9e\xa9\r\x1d\x0c{
daf30ca51735436b619ea90d1d0c7b3c
c976aa6fb6689c16a804eac9bf18d311Tips msg 和 key 必须是 bytes 类型 2.13 struct 模块
在网络通信中大多数数据以二进制形式binary data传输。当传递的是字符串时没有必要担心太多问题。但是若传递的数 int、float 等类型时就需要将它们打包成二进制形成再进行网络传输。而 struct 模块就提供了这样的机制。
2.13.1 pack 和 unpack
struct 提供用 format specifier 方式对数据进行打包和解包packing and unpacking import structpack_data struct.pack(hhl, 1, 2, 3) # h 两个 2 进制位l 4个总共 8个pack_data
b\x01\x00\x02\x00\x03\x00\x00\x00 unpack_data struct.unpack(hhl, pack_data)unpack_data
(1, 2, 3) struct.pack(i, 1234134) # 表示 1234134 安装 i 格式化i 为 int长度为 4因此这里是将数字转换为 4 个二进制数
b\xd6\xd4\x12\x00字符串
import structmsg bpython # 必须是字节型
s struct.pack(5s, msg)
print(s)
print(struct.unpack(5s, s))
print(s.size)bpytho
(bpytho,)
16format specifier 对照表 需要注意的是解包浮点数精度会有所变化这是由一些比如操作系统等客观因素所决定 import structdata_pack struct.pack(f, 12.2)struct.unpack(f, data_pack)
(12.199999809265137,)2.13.2 字节顺序
打包后的字节顺序默认由操作系统决定struct 模块也提供了可以自定义顺序的功能。对于一些底层通讯字节顺序很重要不同的字节顺序会导致字节大小的不同。
我们只需要在 format 字符串前面加上特定的符号即可表示不同的字节顺序存储方式如采用小端存储
data_pack struct.pack(hhl, 1,2,3)2.13.3 利用 buffer使用 pack_into 和 unpack_from 方法
使用二进制打包数据大部分场景都是对性能要求比较高的使用环境pack 方法每次都需要重新创建一个内存空间用于返回也就是每次都要分配相应的内存这是一种很大的浪费。
struct 模块的 pack_into()、unpack_from() 方法正好可以用来解决这种问题。它会对一个提取分配好的 buffer 进行字节填充而不是每次都产生一个新对象进行存储。
pack_into(format, buffer, offerset, v1, v2...) # 格式 buffer, 偏移量必须, 值示例
import struct
import ctypesvalues (1, bpython, 2.7)
s struct.Struct(I6sf)prebuffer ctypes.create_string_buffer(s.size) # 创建一个 buffer 对象data_pack s.pack_into(prebuffer, 0, *values)
data_unpack s.unpack_from(prebuffer, 0)print(data_pack)
print(data_unpack)None
(1, bpython, 2.700000047683716)pack_into() 和 unpack_from() 都是对 buffer 对象进行操作没有产生多余的内存浪费。而且可以将多个 struct 对象 pack 到一个 buffer 对象里然后指定不同的 offset 进行 unpack
import struct
import ctypes
import binasciivalue1 (1, bpython, 2.7)
value2 9999
s1 struct.Struct(I6sf)
s2 struct.Struct(I)prebuffer ctypes.create_string_buffer(s1.size s2.size) # 创建一个 buffer 对象
print(pack之前, binascii.hexlify(prebuffer))data_pack_s1 s1.pack_into(prebuffer, 0, *value1)
data_pack_s2 s2.pack_into(prebuffer, s1.size, value2)data_unpack_s1 s1.unpack_from(prebuffer, 0)
data_unpack_s2 s2.unpack_from(prebuffer, s1.size)print(data_unpack_s1)
print(data_unpack_s2)
print(pack之后, binascii.hexlify(prebuffer))pack之前 b0000000000000000000000000000000000000000
(1, bpython, 2.700000047683716)
(9999,)
pack之后 b01000000707974686f6e0000cdcc2c400f270000参考http://www.cnblogs.com/yuanchenqi/articles/5732581.html
