Python编程新思维(标准库&第三方库)
本专题的内容结构：
第一部分重点讲解：Python标准库time,random,re,os,filecmp,sys,getopt
第二部分重点讲解：Python第三方库pyinstaller,jieba,wordcloud,pipenv,tabulate,QRcode
第一部分的内容结构：
unit1:再看Python计算生态：
标准库和第三方库
Python 计算生态
围绕计算生态的编程新思维
unit2:Python常用标准库解析(上)：
time库的使用
random库的使用
re库的使用
unit3:实例1：蒙特卡洛猜测与计时
蒙特卡洛方法的再次应用
程序计时
unit4:Python常用标准库解析(中)：
os库的使用
filecmp库的使用
unit5:Python常用标准库解析(下)：
sys库的使用
getopt()库的使用
第二部分的内容结构：
unit1:Python第三方库安装方法：
第三方库pip 库安装方法
第三方库集成安装方法
第三方库UCI安装方法
unit2:Python常用第三方库解析(上)：
PyInstaller库的使用
jieba库的使用
wordcloud库的使用
unit3:实例2：四大名著词云分析：
词云的使用
文件及文本处理
unit4:Python常用标准库解析(下):
pipenv库的使用
tabulate库的使用
QRcode库的使用
unit5:实例3：金庸武侠小说写作风格分析：
文件及文本处理
写作风格分析
第一部分的内容：
unit1:再看Python计算生态：
(1),标准库和第三方库：
标准库：Python解释器自带的，无需安装
1,一般都是不超过300个，由Python解释器自带，Standard Libary
2,功能可靠，编程常用，总体空间不大，由社区贡献并被遴选出来
3，需要import引用后再使用
第三方库：需要额外安装的Python功能库：
1,超过14万个，可以由任何人编写贡献，Third-Party Library
2,功能多样，良莠不齐，需要由程序员自我甄别，社区仅维护目录
3，需要import引用后再使用
理解标准库和第三方库：
1，它们都是Python 的功能库，由程序员贡献，没有细致的设计风格和使用风格约束
2，标准库整体质量较好，更多是功能取舍，相同功能也提供多个库
（比如显示时间可以用time库，也可以是datatime库，具体使用要看个人习惯）
3，第三方库是大海捞针，一般要结合专家或专业程序员推荐选用
(2),第三方库主站PYPI：
第三方库主站：https://pypi.org/
1,PYPI :Python Package Index
2,PSF(Python Software Foundation) 维护的展示全球Python计算生态的主站，不过仅维护列表
3，通过搜索及分类等多种方式检索第三方库
例子：
如果你想开发与区块链相关的程序：
步骤1：在pypi.org 搜索blockchain
步骤2：挑选适合开发目标的第三方库，了解相关的功能
步骤3：完成自己的开发任务
判断第三方库可用性的一些方法：（个人观点）
查看开发历史，近半年有更新记录
访问项目主页，文档齐全
评星较高（根据github 上的评分）
一些建议：
1，慎重选择所用的第三方库，尽量选用该领域的高质量库
2，关注时间成本，学习时间和开发时间
3，参看python123.io 平台的Python计算生态推荐榜
(3),Python 计算生态：
为了说清计算生态，我们要从开源运动说起...
当时，UNIX操作系统是市场的主流,但是它并不开源开放，所以普通的程序员使用操作系统
都是要付费的，因此Richard Stallman 启动GNU就是为了搞个开放的操作系统，
1,1983,Richard Stallman 启动GNU项目(GNU's Not Unix)
2,1989,GNU通用许可协议诞生，这个许可协议它规范了知识产权的保护方法，
让参与开源项目开发的人的知识产权有个明确的归属。
GNU通用许可协议的诞生标志着自由软件时代的到来，
3,1991年linus Torvalds 发布了Linux内核，
4,1998年，网景浏览器开源，产生了Mozilla ,
1998年商业公司将商业产品开源的这种行为标志着开源生态逐步建立，
1983年的Richard Stallman的模式是：大教堂的模式
1991年的linus Torvalds 的模式是：集市模式
注：它们虽模式不同，但是都是主张开源，
开源思想深入演化和发展，形成了计算生态：
计算生态以开源项目为组织形式，充分利用“共识原则”和“社会利他”组织人员，
在竞争发展，相互依存和迅速更迭中完成了信息技术的更新换代，形成了技术的自我演化路径
计算生态的特点：
1，没有顶层设计，（哪些api 库是有顶层设计的）
2，以功能为单位，
3，具备三个特点：
竞争发展，相互依存，迅速更迭
注：
API ！= 计算生态
1，计算生态的建设经过野蛮生长和自然选择
2，Python计算生态相互关联，依存发展
3，计算生态是国家科技安全及发展稳固的基础
(4),围绕计算生态的编程新思维：
Python语言的特点：
语法简洁：
1，没有分号，没有函数约束，没有大括号，没有begin/end
2,没有类型声明，没有变量定义，没有指针
相同功能是C语言代码量的10%及以下
开源生态 ：
1，超过14万个第三方免费库可用
2，避免重复造轮子的先进理念
底层可以封装C/C++ 等语言的代码，站在巨人的肩膀上编程
Python编程新思维：三个含义：
含义1：学会利用计算生态编程
含义2：学会围绕Python计算生态框架编程
含义3：学会构建Python计算生态
(5),看见更大的Python世界：
避免几个错误的认识：
错误1：Python仅适合一类或几类应用
Python 是通用的编程语言
错误2：对于关键应用，Python执行速度慢
对于数据处理需求，如果仅仅是利用Python 语法，
那么它的速度的确是比较慢（它是个解释性脚本语言），但是它可以集成C/C++的代码，
并且把它们封装成接口，
错误3：Python 和 C 语言，该选择哪个好？
一定需要熟悉C 语言，甚至要精通C语言，这样才可以说是优秀的程序员
树立几个正确的认识：
1,Python社区是全球最大的开源社区，趋势已经不可逆转
2,Python语言不只是通用编程语言，它将开启整合编程语言之路
3,Python语言的精髓是其优美和先进的语法内涵，而不只是计算生态
unit2:Python常用标准库解析(上)：
(1),time库的使用:
1,time库是Python中处理时间的标准库
1,库名：time ，计算时间的表达
2，提供获取系统时间并格式化输出功能
3，提供系统级精确计时功能，用于程序性能分析
https://docs.python.org/3.7/Library/time.html
2,time库的一些基本定义和概念：
1，计时起点：1970-01-01 0时0分0秒开始，可以用time.gmtime(0)获得
2，UTC时间：Coordinated Universal Time 世界标准时间，与GMT（英国的格林威治时间 ）一致
3，DST时间：Daylight Saving Time ,夏令时时间，源于系统底层C函数
4，struct_time: Python中用于保存时间对象，带有属性标签的数据类型
3,如何表达时间呢？
time库提供了三种方法：
1，浮点数时间：一般从计时起点开始计算，如：153454646151.645644
2，struct_time时间：便于程序员使用的内部结构，如：
time.struct_time(tm_year=2019, tm_mon=8, tm_mday=1, tm_hour=8, tm_min=45, tm_sec=59, tm_wday=3, tm_yday=213, tm_isdst=0)
3，字符串时间：便于用户查看的时间，如：'Sat Jun 2 10:33:52 2019'
那么time库中的函数就是在这三种时间之间相互转换的！
为了更好的理解时间，我们先看下struct_time:
序号 属性名 取值范围
0 tm_year 四位整数，如2019
1 tm_mon [1,12]
2 tm_mday [1,31]
3 tm_hour [0,23]
4 tm_min [0,59]
5 tm_sec [0,61] 60仅用于调时
6 tm_wday [0,6] 星期一为0
7 tm_yday [1,366]
8 tm_isdst 0:DST ,1:非DST,-1:跟随系统
N/A tm_zone 时区的缩写表示
N/A tm_gmtoff 与UTC时间相差的秒数
time.gmtime() 它可以返回个struct_time的时间
>>>t = time.gmtime()
>>>t.tm_zone
'UTC'
>>>t.tm_gmtoff
0
>>>t[0]
2019
4,time 库提供的函数的分类(14个)：
1，时间获取:time() ,gmtime() ,ctime() ,asctime(),localtime(),mktime()
2，时间格式化：strftime() ,strptime()
3, 程序计时：clock(),monotonic(),perf_counter(),process_time(),sleep()
4, 辅助函数：get_clock_info()
1,time库之时间获取：
time() 返回一个从计时起点开始的表示时间的浮点数
>>>time.time()
1534541.153454
gmtime([s]) 返回一个struct_time表示的时间，如果提供s,把s变成struct_time时间
其中 s 是个浮点数的时间戳
>>>time.gmtime()
time.struct_time(tm_year=2019, tm_mon=8, tm_mday=1, tm_hour=9, tm_min=9, tm_sec=36, tm_wday=3, tm_yday=213, tm_isdst=0)
>>>time.gmtime(1555110454)
time.struct_time(tm_year=2019, tm_mon=4, tm_mday=12, tm_hour=23, tm_min=7, tm_sec=34, tm_wday=4, tm_yday=102, tm_isdst=0)
localtime([s]) 返回一个struct_time表示的本地时间，如果提供s ，将s变成本地时间，
本地时间就是，比如我们的电脑在中国，计算机使用的就是中国的时区，返回的就是我们本地的时间
如果使用gmtime()它返回的就是UTC时间
>>>time.localtime()
time.struct_time(tm_year=2019, tm_mon=8, tm_mday=1, tm_hour=17, tm_min=15, tm_sec=1, tm_wday=3, tm_yday=213, tm_isdst=0)
mktime(t) 将一个struct_time 的时间t ,转变成一个浮点数时间
>>> time.mktime(time.localtime())
1564651084.0
>>> time.mktime(time.gmtime())
1564622293.0
asctime([t]) 返回一个字符串表示的方法，如果提供参数t,则把t变成字符串时间
这里的t是struct_time
>>> time.asctime()
'Thu Aug 1 17:20:25 2019' 周四
>>> time.asctime(time.localtime())
'Thu Aug 1 17:23:36 2019'
>>> time.asctime(time.gmtime())
'Thu Aug 1 09:24:04 2019'
ctime([s]) 返回一个字符串表示的时间，如果 提供s，则把s变成字符串时间
>>> time.ctime()
'Thu Aug 1 17:25:37 2019'
>>> time.ctime(546415656)
'Sun Apr 26 14:07:36 1987'
时间获取小结：
1,产生浮点数时间：time() ,mktime(t)
2,产生struct_time时间：gmtime(s),localtime(s)
3,产生字符串时间：ctime(s),asctime(t)
*总结：时间戳 是s ,struct_time 是t
2,time库之时间格式化：
格式化：类似于字符串格式化，通过模板定制输出效果或指定输出模式
struct_time ----> 字符串时间 用 strftime() 格式化为字符串(formate)
struct_time <---- 字符串时间 用 strptiem() 解析字符串(parse)
strftime(template,t) template是格式化字符串，定义输出效果，t 是struct_time变量
>>>t = time.gmtime()
>>>time.strftime("%Y-%m-%d %H:%M:%S hello ZCB",t)
'2019-08-01 09:36:02 hello ZCB'
>>>t = time.localtime()
>>>time.strftime("%Y-%m-%d %H:%M:%S hello ZCB",t)
'2019-08-01 17:37:21 hello ZCB'
理解时间的格式化控制符：
控制符 说明 范围和实例
%Y 年份 0000-9999 ，例如2018
%m 月份 01-12 ，例如10
%B 月份名全称 January-December
%b 月份名简称 Jan-Dec ，例如Apr
%d 日期 01-31 ，例如25
%A 星期 Monday-Sunday
%a 星期缩写 Mon-Sun
%H 小时24制 00-23
%h 小时12制 01-12
%p 上/下午 AM/PM
%M 分钟 00-59
%S 秒 00-59
%Z 时区 字符串，如：'中国标准时间'
%% %字符
strptime(str,template) str 是字符串时间，template是模板
>>>str = "2019-01-26 12:55:20 hello ZCB"
>>>template = "%Y-%m-%d %H:%M:%S hello ZCB"
>>> time.strptime(str,template)
time.struct_time(tm_year=2019, tm_mon=1, tm_mday=26, tm_hour=12, tm_min=55, tm_sec=20, tm_wday=5, tm_yday=26, tm_isdst=-1)
3,time库之程序计时：
time库的五个计时时钟
时钟名称 对应函数 说明
'clock' time.clock() 计时时钟 （根据平台而定的精确度，不稳定）
'monotonic' time.monotonic() 单调计时时钟，不可更改，时间差有意义
'perf_counter' time.perf_counter()*精确计时时钟，含起始和终止的所有时间
（它之所以精确是因为它调用cpu中专门计时的函数，可以达到纳秒级别）
'process_time' time.process_time()进程计时时钟，不含进程sleep()时间
(专门用于进程计时的，它不包含休眠时间，它只计算cpu 用于处理该进程的时间)
'time' time.time() 系统计时时钟，精度不高，用于time()函数
重点掌握 perf_counter() ,还有process_time()
具体时钟的使用：
clock() :返回一个计时时间，调用之差是间隔时间，不同平台精度不同
>>>time.clock()
1.2799989077342653e-06
monotonic():返回一个计时时间，两次调用之差是间隔时间，单位为秒
>>>time.monotonic()
158921.906
perf_counter():返回一个精确计时时间，包含全部时间，单位为秒
>>>time.perf_counter()
169.4631612047691
process_time():返回一个进程计时时间，不包含sleep() 时间，单位为秒
>>>time.monotonic()
0.171875
sleep() :将线程挂起s秒，s 可以是浮点数
>>>time.sleep(5.5)
强调，所有时间库里需要指定时间的都是以秒为单位的
4,time库之辅助函数：
get_clock_info(name):返回以下五种计时时钟的属性值：
'clock','monotonic','perf_counter','process_time','time'
>>>time.get_clock_info('perf_counter')
namespace(adjustable=False, implementation='QueryPerformanceCounter()', monotonic=True, resolution=4.2666630257808847e-07)
>>>time.get_clock_info('process_time')
namespace(adjustable=False, implementation='GetProcessTimes()', monotonic=True, resolution=1e-07)
我们可以通过它来了解不同平台上的时钟的参数的不同，它能帮助我们了解不同操作系统上时钟的精度
(2),random库的使用:
1,random 是Python 中生成随机数的标准库
1，库名：random ,生成随机数
2，提供产生单个或系列随机数的功能
3，提供随机组合等相关操作等功能
https://docs.python.org/3.7/Library/random.html
2,random库函数的分类(21个)：
1,基本随机函数：seed(),random(),getstate(),setstate()
2,扩展随机函数：randint(),getrandbits(),randrange(),choice(),shuffle(),sample()
3,分布随机函数：uniform(),triangular(),betavariate(),expovariate(),gammavariate(),
gauss(),lognormvariate(),normalvariate(),vonmisesvariate(),
paretovariate(),weibullvariate()
注：这里的前两类还是很常用的，
random库随机数产生原理：
随机数种子--->【梅森旋转算法（内部状态机） 】 --->random() 随机序列
seed() 【内部状态机--->getstate() 随机数产生器状态】
【内部状态机 <---setstate() 随机数产生器状态】
用户可以给出随机种子到内部状态机中，那么内部状态机就会根据其产生随机序列，
(序列中的每个数都是随机数，默认采用的随机数是0-1的浮点数)
简化就是：seed()产生种子，random() 产生随机数
内部状态机，我们可以通过getstate() 获得内部状态机的状态
也可以通过setstate() 设置内部状态机的状态
对于同一个状态的内部状态机产生的随机数是相同的，
1，random库之基本随机函数
seed(a=None) 初始化给定的随机数种子，默认为当前系统时间
>>>random.seed()
如果不调用seed() 也是将当前系统时间作为随机数种子
random() 生成一个[0.0,1.0) 之间的随机小数
>>>random.random()
0.06510591538216404
getstate() 返回随机数内部生成器的内部状态，元组类型
>>>t = random.getstate()
>>>type(t)
<class 'tuple'>
setstate() 设置随机数生成器内部状态，该状态从getstate()函数获得
>>>setstate(t)
2,random库之扩展随机函数
randint(a,b) 生成一个[a,b] 之间的整数
>>>random.randint(10,100)
64
randrange(m,n,[k]) 生成一个[m,n)之间以k为步长的随机整数
>>>random.randrange(10,100,10)
80
getrandbits(k) 生成一个k比特长的随机整数
>>>random.getrandbits(16)
choic(sequence) 从序列sequence中随机选择一个元素
>>>random.choic([1,2,3,4,5,6,7,8,9])
8
shuffle(sequence) 将序列sequence中元素随机排列，原序列被修改
>>>ls = [1,2,3,4,5,6,7,8,9]
>>>random.shuffle(ls) # ls被修改
>>> ls
[3, 4, 9, 6, 5, 8, 7, 1, 2]
sample(pop,k) 从序列或集合pop 中随机选择k个元素，原序列或集合不变
>>>ls = [1,2,3,4,5,6,7,8,9]
>>>random.sample(ls,5) #ls不变
[8, 1, 3, 7, 6]
3，random库之分布随机函数
uniform(a,b) 生成一个[a,b] 之间的随机小数，采用等概率分布
>>>random.uniform(10,20)
16.22929803881976
betavariate(alpha,beta) 生成一个[0,1] 之间的随机小数 采用beta分布
triangular(low,high,mode) 生成一个[low,high] 之间的随机小数，采用三角分布(也叫辛普森分布)
expovariate(lambda) 生成一个(0,∞)之间的随机整数，采用指数分布
gammavariate(alpha,beta) 生成一个随机小数，采用gamma分布
gauss(mu,sigma) 生成一个随机小数，采用高斯分布(也叫正太态分布)
lognormvariate(mu,sigma) 生成一个随机小数，采用对数正态分布
normalvariate(mu,sigma) 生成一个随机小数，采用标准正态分布
vonmisesvariate(mu,kappa) 生成一个随机小数，采用冯米赛斯分布
paretovariate(alpha) 生成一个随机小数，采用帕累托分布
weibullvariate(alpha,beta) 生成一个随机小数，采用韦伯分布
(3),re库的使用:
re库是Python中处理正则表达式的标准库
1,库名：re
2,正则表达式：是用来简洁表达一组字符串的表达式
'PN'
'PYN'
'PYTN' <---> 正则表达式： P(Y|YT|YTH|YTHO)?N
'PYTHN'
'PYTHON'
https://docs.python.org/3.7/Library/re.html
正则表达式语法：
由字符和操作符构成：
P(Y|YT|YTH|YTHO)?N
这里的() | ？ 就是操作符，
操作符 说明 实例
. 表达任何单个字符
[] 字符集，对单个字符给出取值范围 [abc] 表示a,b,c ;[a-z]表示 a到z 单个字符
[^] 非字符集，对单个字符给出排除范围 [^abc] 表示非a或b或c的单个字符
* 前一个字符0次或无限次扩展 [abc*] 表示ab,abc,abcc,abccc等
+ 前一个字符1次或无限次扩展 [abc+] 表示abc,abcc,abccc等
? 前一个字符0次或1次扩展 [abc?] 表示ab,abc
| 左右表达式任意一个 [abc|def] 表示abc 或def
{m} 扩展前一个字符m次 ab{2}c 表示abbc
{m,n} 扩展前一个字符m到n次(含n) ab{2,3}c 表示abbc abbbc
^ 匹配字符串开头 ^abc 表示abc 且在一个字符串的开头
$ 匹配字符串结尾 abc$ 表示abc 且在一个字符串的结尾
() 分组标记，内部只能使用|操作符 (abc) 表示abc,(abc|def) 表示abc或def
\d 数字，等价于[0-9]
\w 单词字符，等价于[A-Z,a-z,0-9]
经典的正则表达式实例：
^[A-Za-z]+$ 由26个字母组成的字符串
^[A-Za-z0-9]+$ 由26个字母和数字组成的字符串
^-?\d+$ 整数形式的字符串(前的负号可有可无)
^[0-9]*[1-9][0-9]*$ 正整数形式的字符串(中间的1-9可以排除0的可能)
[1-9]\d{5} 中国境内邮政编码，6位
[\u4e00-\u9fa5] 匹配中文字符
\d{3}-\d{8}|\d{4}-\d{7} 国内电话号码：010-68913536
Python的正则表达式库中引入了一种新的字符串类型：raw string,不包含对转义符解释的字符串
传统的字符串传是包含转义符的，但是raw string 是不包含转义符的
1，表示：
r'text'
2,例子:
r'[1-9]\d{5}' 对比'[1-9]\\d{5}'
r'\d{3}-\d{8}|\d{4}-\d{7}' 对比'\\d{3}-\\d{8}|\\d{4}-\\d{7}'
这种原生字符串raw string 也用在windows的路径上
re库的主要函数(7个)：
1,基础函数：compile()
2,功能函数：search(),match(),findall(),split(),finditer(),sub()
函数1：最常用的叫search()
re.search(pattern,string,flags=0)
在一个字符串中搜索匹配正则表达式的第一个位置，返回match 对象
1,pattern :正则表达式的字符串或原生字符串表示
2，string：待匹配字符串
3, flags：正则表达式使用时的控制标记
控制标记(常用) 说明
re.l re.LGNORECASE 忽略正则表达式的大小写，[A-Z]能够匹配小写字符
re.M re.MULTILINE 正则表达式中的^操作符能够将给定的字符串的每行当做匹配的开始
re.S re.DOTALL 正则表达式中的.操作符能够匹配所有字符，默认匹配除换行符外的所有字符
如果想要将换行符加上就要用re.S
一般情况我们都是用不着flags的
例子：
>>>import re
>>>match = re.search(r'[1-9]\d{5}','BIT 100081')
>>>if match:
print(match.group(0))
100081
match 的属性，后面会介绍
函数2：
re.match(pattern,string,flags =0)
在一个字符串开始位置起匹配正则表达式，返回 match对象
与search（）的区别：search() 可以匹配任意位置，它只能是开始位置
>>>import re
>>>match = re.match(r'[1-9]\d{5}','BIT 100081')
>>>if match:
print(match.group(0))
>>> match.group(0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
>>>import re
>>>match = re.match(r'[1-9]\d{5}','100081 BIT')
>>>if match:
match.group(0)
'100081'
函数3：
re.findall(pattern,string,flags =0)
搜索字符串，以列表类型返回全部能匹配的子串
>>> import re
>>> ls = re.findall(r'[1-9]\d{5}',"BIT 100081 TSU 100084")
>>> ls
['100081', '100084']
findall() 在字符串中找匹配字符串特别常用(因为它返回的是列表类型，（列表类型是基础类型中最常用的）)
函数4：
re.split(pattern,string,maxsplit = 0,flags =0)
将一个字符串按照正则表达式匹配结果进行分割，返回列表类型
maxsplit:最大分割数，剩余部分作为最后一个元素输出
>>> re.split(r'[1-9]\d{5}',"BIT 100081 TSU 100084")
['BIT ', ' TSU ', '']
>>> re.split(r'[1-9]\d{5}',"BIT 100081 TSU 100084",maxsplit=1)
['BIT ', ' TSU 100084']
它也是很常用的
函数5：
re.finditer(pattern,string,flags =0)
搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象
我们可以通过for in 的形式来遍历迭代结果，对每个match对象进行处理
>>> import re
>>> for match in re.finditer(r'[1-9]\d{5}',"BIT 100081 TSU 100084"):
if match:
print(match.group(0))
100081
100084
函数6：
re.sub(pattern,replace,string,count=0,flags =0)
在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串
replace：替换匹配字符串的字符串
count:匹配的最大替换次数
>>> import re
>>> re.sub(r'[1-9]\d{5}',":zipcode", "BIT 100081 TSU 100084")
'BIT :zipcode TSU :zipcode'
re.sub() 扩展了字符串的替换功能，从传统的只能替换固定的字符串变成了替换正则结果的字符串，
更加灵活，更加方便
re库的另一种等价用法：(推荐使用)
我们上面用的时候都是用re.函数名，
这时函数式用法：它是一次性操作
>>>match = re.search(r'[1-9]\d{5}','BIT 100081')
>>>match = re.match(r'[1-9]\d{5}','BIT 100081')
下面介绍的是面向对象用法：编译后的多次操作
这里要用到一个函数compile() 将指定模式编译成内置对象，就可以
>>>pattern = re.compile(r'[1-9]\d{5}')
>>>match = pattern.search('BIT 100081')
>>>match = pattern.match('BIT 100081')
下面看re.compile(pattern,flags =0)的使用
将正则表达式的字符串形式编译正则表达式对象
1,pattern：正则表达式的字符串或原生字符串
2，flags:正则表达式使用时的控制标记
>>>pattern = re.compile(r'[1-9]\d{5}')
我们就可以用pattern去调用这六个函数了，十分方便
re库中很重要的概念：match对象
match对象是一次匹配的结果，包括匹配的各种信息
>>> match = re.search(r'[1-9]\d{5}','BIT 100081')
>>> if match:
... print(match.group(0))
...
100081
>>> type(match)
<class '_sre.SRE_Match'> #自定义的类型
简单说，match 是个对象
它有一些属性：
属性名 说明
.string 待匹配的文本
.re 匹配时使用的pattern对象（通过compile可以生成的pattern）
.pos 正则表达式搜索文本的开始位置
.endpos 正则表达式搜索文本的结束位置
.group(0) 获得匹配后的字符串
.start() 匹配字符串在原始字符串的开始位置
.end() 匹配字符串在原始字符串的结束位置
.span() 返回(.start(),.end()) 元组
例子：
>>> import re
>>> match = re.search(r'[1-9]\d{5}','BIT100081 TSU100084')
>>> match.string
'BIT100081 TSU100084'
>>> match.re
re.compile('[1-9]\\d{5}')
>>> match.pos
0
>>> match.endpos
19
>>> match.group(0)
'100081'
>>> match.start()
3
>>> match.end()
9
>>> match.span()
(3, 9)
re库小结：
1,基础函数：compile()
2,功能函数：search(),match(),findall(),split(),finditer(),sub()
3,compile() 的用法，
4，re的返回对象是match对象
unit3:实例1：蒙特卡罗猜测与计时
需求：蒙特卡洛猜测：计算机匹配正则表达式
1，输入：一个正则表达式，由程序员给出
2，程序：随机产生字符串，匹配正则表达式
3，计时：统计时间及猜测次数
具体是：
1，正则表达式： r'[1-2][^2-8][D-F]0+[A-F]'
2,随机字符串：32个字符长度，字符是0-9或者是A-Z，十六进制字符
3，输出：匹配次数，匹配字符串，程序关键部分所用时间（5个小数）
需求的真实应用：
1，正则表达式其实是一个病毒片段： r'[1-2][^2-8][D-F]0+[A-F]'
2，任何文件都可以表示为十六进制字符的组合形式
3，匹配：病毒引擎的扫描过程
实例编写：
1 import time,random,re 2 3 4 5 def genStr(): 6 7 global sigma 8 9 s = "" 10 11 for i in range(32): 12 13 s +=sigma[random.randint(0,15)] 14 15 return s 16 17 18 19 sigma = "0123456789ABCDEF" 20 21 pattern = re.compile(r'[1-2][^2-8][D-F]0+[A-F]') 22 23 count = 0 24 25 start = time.perf_counter() 26 27 match = pattern.search(genStr()) 28 29 while not match: #如果未匹配就一直匹配 30 31 count +=1 32 33 match = pattern.search(genStr()) 34 35 print("程序匹配：猜测{}次，{}->{}".format(count,match.string,match.group(0))) 36 37 end = time.perf_counter() 38 39 print("程序用时:{:.5f}秒".format(end-start))
结果：
程序匹配：猜测60次，378BBDC7C9F1AE0B8B6F211661ACB2E9->1AE0B
程序用时:0.00371秒
unit4:Python常用标准库解析(中)：
(1),os库的使用:
os库提供了通用的，基本的操作系统交互功能，这种功能是横跨win,mac,Linux 的，
os库提供了几百个与文件系统，操作系统功能相关的函数
这里只介绍常用路径操作，进程管理，环境参数等几类。
1，路径操作：通过os.path子库来完成，处理文件路径及信息
2，进程管理：启动系统中其他程序
3，环境参数：获得系统软硬件信息等环境参数,辅助程序感知所用的操作系统
更过介绍见官方文档：https://docs.python.org/3.7/Library/os.html
1:os库之路径操作：
os.path 子库以path 为入口，用于操作和处理文件路径
import os.path
或
import os.path as op
函数介绍：
os.path.abspath(path) 返回path 在当前系统中的绝对路径
os.path.normpath(path) 归一化path 的表示形式，统一用\\分隔路径
os.path.relpath(path) 返回当前程序与文件之间的相对路径(relative path)
os.path.dirname(path) 返回path 中的目录名称
os.path.basename(path) 返回path 中最后的文件名称
>>>os.path.basename("d:/test/file.txt")
'file.txt'
os.path.join(path,*paths) 组合path和paths ,返回一个路径字符串
>>>os.path.join("d:/","test/file.txt")
"d:/test/file.txt"
建议：如果要是跨平台操作建议使用os.path下的方法，不要使用自己的简单字符串组合，可能会出错
os.path.exists(path) 判断path对应文件或目录是否存在，返回True 或False
>>>os.path.exists("d:/test/file.txt)
os.path.isfile(path) 判断path所对应的是否为已存在的文件，返回True或False
>>>os.path.isfile("d:/test")
False
os.path.isdir(path) 判断path所对应的是否为已存在的目录，返回True或False
os.path.getatime(path) 返回path 对应的文件或目录上一次的访问时间(access)
注：返回的是个时间戳s
os.path.getmtime(path) 返回path 对应的文件或目录上一次的修改时间(modify)
注：返回的是个时间戳s
os.path.getctime(path) 返回path 对应的文件或目录上一次的创建时间(create)
注：返回的是个字符串时间
os.path.getsize(path) 返回path对应文件的大小，以字节为单位
常用
>>>os.path.getsize("d:/test/file.txt")
10808
2,os库之进程管理：
os.system(command)
>执行程序或命令command
>在windows系统中，返回值是cmd的调用返回信息
例子：
>>> import os
>>> def cls():
... os.system("cls")
>>> cls()
这样就可以用cls() 来清理屏幕了
>>> import os
>>> os.system("c:/Windows/System32/calc.exe")
>>>0
这就可以调用计算器出来了,同时返回 0代表计算器成功启动
我们就可以通过system() 来启动操作系统上权限以内的其他程序了，
3,os库之环境参数：
os.chdir(path) 修改当前程序操作的路径
>>>os.chdir("D:")
os.getcwd() 返回程序的当前路径
>>>os.getcwd()
>>>'d:\\'
os.getlogin()获取当前系统登录用户名称
>>>os.getlogin()
os.cpu_count() 获取当前系统的cpu 数量(独立的cpu核的数量)
>>>os.cpu_count()
os.urandom(n) 获取n个字节长度的随机字符串，通常用于加解密运算
>>>os.urandom(10)
b'\x81P)+\x8b\xce\x9aa\no'
相对于random来说它的加密更好，
(2),filecmp库的使用:
filecmp库提供了比较目录和文件的功能
>比较文件：用filecmp提供的函数
>比较目录：用filecmp提供的dircmp类
依据：文件内容，文件属性信息等
more:https://docs.python.org/3.7/Library/filecmp.html
1,文件比较所用的函数：
filecmp.cmp(f1,f2,shallow = True) 比较f1和f2 两文件，当shallow为True时，比较os.stat()
否则比较文件内容
filecmp.cmpfiles(dir1,dir2,common,shallow=True)
#它比较的是目录下的一个或多个文件，
比较dir1和dir2两个目录下的common 文件，common是列表类型
当shallow为True，比较os.stat() ;否则比较文件内容
返回值是([],[],[]) 三个列表
包含 匹配 ，不匹配和错误的文件名
例子：
import filecmp
filecmp.cmpfiles("d:/test","e:/test",['abc','def/abc'])
比较的是：
d:/test/abc 和 e:/test/abc
d:/test/def/abc 和e:/test/def/abc
(并不常用)
2，文件比较所用的类：
dcmp = filecmp.dircmp(dir1,dir2) 目录比较，dcmp 是个对象，通过类的属性来反应目录的比较情况
通过dcmp 的静态属性来表达目录的不同。
它的优点是，因为目录的比较比较耗时，如果用对象来记录比较的结果对后续开发代价更小，
dircmp 类提供的属性如下：
类属性 描述
left 目录dir1
right 目录dir2
left_list 目录dir1的文件和子目录列表
right_list 目录dir2的文件和子目录列表
left_only 仅在目录dir1中的文件和子目录列表
right_only 仅在目录dir2中的文件和子目录列表
same_files 目录dir1和dir2中相同的文件
common 同时在目录dir1和dir2中的文件和子目录列表
diff_files 目录dir1和dir2中都存在但却不相同的文件
common_dirs 同时在目录dir1和dir2中的子目录列表
common_files同时在目录dir1和dir2中的文件列表
类的方法比函数的更好，
类可以一次调用，多次使用，函数就不行了，每次都要执行
unit5:Python常用标准库解析(下)：
(1),sys库的使用:
sys库与系统相关，它与什么系统相关呢？它与python 解释器相关，
所以sys库维护了一些与Python解释器相关的参数变量
>sys库提供的大部分是变量值，少部分是函数
>sys库内容很丰富，这里仅列出常用的部分，
more:https://docs.python.org/3.7/Library/sys.html
1 ,sys库常用参数：
变量参数 描述
sys.float_info 系统浮点数类型的参数信息
sys.int_info 系统整数类型的参数信息
sys.hash_info 系统哈希函数的参数信息
sys.thread_info 系统线程实现的参数信息
sys.byteorder 字节序标识，大端返回'big',小端返回'little'
sys.executable 当前解释器可执行文件的绝对路径
sys.maxunicode 系统支持的最大Unicode值，一般是1114111(0x10FFFF)
sys.path 解释器用来加载Python库的路径列表
sys库常用参数和函数
sys.argv 命令行参数的列表，其中argv[0]表示执行程序本身
sys.dont_write_bytecode 如果为True,则不生成.pyc 字节码
什么是.pyc文件？ 解释器执行代码时，如果生成了.pyc文件，如果下次再次执行(而且程序没有被修改)
这时就会执行.pyc文件，速度会更快，
是否要生成.pyc 文件就要看这个参数的设置，
sys.getrecursionlimit() 获取系统递归最大深度
sys.setrecursionlimit(n) 设置系统递归最大深度为n
sys.getdefaultencoding() 获得当前默认的字符串编码名称
sys.getsizeof(object) 获得object的字节长度，object可以是任意类型
sys.exit([arg] ) 退出Python程序，附带状态码arg
(2),getopt()库的使用:
getopt库提供了鸡西命令行参数sys.argv的功能
>Unix 命令行解释风格，与getopt() 对应的C函数库风格一致
>通过getopt库可以快速构建专业的命令行参数,也可以构建解析命令行参数
>getopt库提供了1个函数和1个异常类型
more:https://docs.python.org/3.7/Library/getopt.html
1个函数：
getopt.getopt(args,shortopts,longopts=[])
>args:程序的命令行参数，不包含程序名称本身，一般是sys.argv[1:]
>shortopts:定义-x或-x <值> 形式的短参数，带值的增加冒号(:)
eg:"abc:d:" 可以表示命令行解析 -a -b -c<值> -d<值> 参数
>longopts:定义 --name或--name <值> 形式的长参数，带值加等号(=)
eg:["name1","name2"=] 定义的是--name1 和 --name2 <值>
通过这样一个函数，我们就可以根据定义的短的长的参数来解析args列表
>返回值 ：
返回两个值：optlist 和 args
>optlist 包含由(option ,value)组成的列表
列表中的每一项是二元元组，第一项是指-a -b --name 这样的参数，如果有值的话放到value中
>args 是未解析参数
1个异常类型：
getopt.GetoptError
参数解析错误时反馈的异常，
通过它可以确定性的给出参数解析错误的原因
具体例子：
1 import getopt,sys 2 3 try: 4 5 # -h -v -i <文件.ico> --distpath <目录> --clean 6 7 optList,args = getopt.getopt(sys.argv[1:],"hi:v",["distpath=","clean"]) 8 9 #optList 是解析到的参数信息 是个二元元组组成的列表， 10 11 #args 是未解析的参数 12 13 14 15 for opt ,val in optList: 16 17 if opt == '-h': 18 19 print("发现-h参数") 20 21 elif opt == '-v': 22 23 print("发现-v 参数") 24 25 elif opt == '-i': 26 27 print("发现-i 参数,及其所对应的值{}".format(val)) 28 29 elif opt == "--distpath": 30 31 print("发现--dispath 参数及其所对应的值：{}".format(val)) 32 33 elif opt =='--clean': 34 35 print("发现--clean参数") 36 37 else: 38 39 print("发现未知参数") 40 41 except getopt.GetoptError: 42 43 print("命令行参数解析错误") 44 45 sys.exit(1)
第二部分的内容：
unit1:Python第三方库安装方法：
(1),第三方库pip 库安装方法（最主要和最主流）
pip 是Python解释器自带的第三方安装工具
>pip 是命令行工具，适用于各种操作系统
>pip 安装方法需要联网或给定安装文件
>绝大部分的Python库可以使用pip 安装，主要的安装方法
pip -h 可以查看帮助，
具体安装方法：
pip install <第三方库名或文件名>
安装指定的第三方库，
pip install jieba 或 pip install jieba-0.39.zip
更新第三方库：
pip install -U jieba
卸载指定的第三方库：
pip uninstall jieba
下载但不安装指定的第三方库
pip dowload jieba
这有是还是很常用的，比如说我们在一台可以上网的电脑上执行这个命令，
然后将下好的文件拷贝到一台不可以上网的电脑上，
然后就可以在不可以上网的电脑上用 pip install +文件名称 来安装了
列出某个指定的第三方库的详细信息：
pip show jieba
根据关键词在名称和介绍中搜索第三方库
pip search blockchain
列出当前系统已经安装的第三方库：
pip list
(2),第三方库集成安装方法:
集成安装：结合特定Python开发工具的批量安装
主要指的是Anaconda
>支持800个第三方库
>包含多个主流工具
>适合数据计算领域开发
(3),第三方库UCI安装方法：
首先，pip 不能解决100% 的安装问题，
>某些第三方库在pip 下载后，需要编译再安装，本地环境或没有编译器
>pip 可能成功下载，但无法安装
所以，对于这些特定库(小众)，是否有编译后的版本供下载安装呢？
是有的，
这就是uci 安装方法：
https://www.lfd.uci.edu/~gohlke/pythonlibs/
这个平台维护了编译后的文件，
UCI安装方法的三个步骤：
1，在UCI 页面搜索对应的第三方库 （ctrl +f）
2，下载对应Python解释器的编译后的版本，
3，本地安装方法：pip install <下载文件名>
(4)小实例：自动化pip 安装脚本
使用python 脚本自动的安装一批第三方库：
>具体需求：安装20个第三方库
>自动运行，自动联网，自动安装，进行简单的错误判断
拟安装的第三方库列表：
库名 用途 安装指令
NumPy N维数据表示和运算 pip install numpy
Matplotlib 二维数据可视化 pip install matplotlib
PIL 图像处理 pip install pillow
Scikit-Learn机器学习和数据挖掘 pip install sklearn
Requests HTTP协议访问及网络爬虫 pip install requests
jieba 中文分词 pip install jieba
BeautifulSoup HTML和XML解析器 pip install beautifulsoup4
Wheel Python第三方库文件打包工具 pip install wheel
PyInstaller 打包Python源代码为可执行文件 pip install pyinstaller
Django Python最流行的web开发框架 pip install django
Flask 轻量级的web开发框架 pip install flask
WeRoBot 微信机器人开发框架 pip install werobot
SymPy 数学符号计算工具 pip install sympy
Pandas 高效数据分析工具 pip install pandas
Networkx 复杂网络和图结构的建模和分析 pip install networkx
PyQt5 基于Qt 的专业级GUI 开发框架 pip install pyqt5
PyOpenGL 多平台OpenGL开发接口 pip install pyopengl
PyPDF2 PDF文件内容提取及处理 pip install pypdf2
docopt Python命令行解析 pip install docopt
PyGame 简单小游戏开发框架 pip install pygame
具体代码：
1 import os 2 3 libs = {'numpy','matplotlib','pillow','sklearn','requests',\ 4 5 'jieba','beautifulsoup4','wheel','networkx','sympy',\ 6 7 'pyinstaller','django','flask','werobot','pyqt5',\ 8 9 'pandas','pyopengl','pypdf2','docopt','pygame'} 10 11 12 13 try: 14 15 for lib in libs: 16 17 os.system("pip install "+lib) 18 19 print("Successful") 20 21 except: 22 23 print("Failed Somehow")
注：也可以将20个库直接下载下来，只需要将pip install变为pip dowload
unit2:Python常用第三方库解析(上)：
(1),PyInstaller库的使用:
PyInstaller库将提供.py源代码转换成可执行文件的功能
简单就是将.py 文件和 它所依赖的库 转成可执行文件
more:https://pyinstaller.readthedocs.io
注：
>它并不是一个Python模块不能嵌入到python代码中，它实际上是个命令行的工具，
>PyInstaller能够使程序脱离解释器运行，还能防止源代码泄漏
>PyInstaller是目前最好用的Python打包工具
简单的使用：
(cmd 命令行) pyinstaller -F <xxx.py>
我们将在xxx.py 同目录下看到：
__pycache__ build dist 目录
其实生成可执行文件就在dist目录中，
dist (distribution 发布)
其他参数：
选项 选项说明
-h /-help 显示帮助信息
-v /-version 显示版本信息
--distpath DIR 指定输出目录，默认是./dist
--workpath WDIR 指定存储临时文件的目录，默认是./build
-y /--noconfirm 强制替换输出目录内容，没有确认询问
-D /--onedir 创建一个目录，包含可执行程序和程序依赖文件
-F /--onefile 创建一个独立的可执行文件
-n NAME /-name NAME 指定输出文件的名称目录
-i <xxx.ico> 指定打包程序使用的图标（icon）文件
例子:
pyinstaller -F a.py 生成一个文件 a.ext
pyinstaller -i b.ico -F a.py 生成一个带有图标的a.exe
pyinstaller -F a.py -n my.exe 生成一个文件my.exe
pyinstaller --distpath ./ -F a.py -n my.exe 当前目录下生成my.exe
(2),jieba库的使用:
jieba 库提供中文分词功能：
>中文文本需要通过分词获得单个的词语信息
>jieba库提供三种分词模式，支持自定义词典
more:https://github.com/fxsjy/jieba
安装： pip install jieba /pip3 install jieba
pip3 是对于3.x版本的安装
jieba库的三种分词模式：
>精确模式（最常用）：将文本精确地切开，分词后无冗余，适合文本分词
>全模式：把文本中所有可能成词的词语都扫描出来，速度快，但不能解决歧义
>搜索引擎模式：在精确模式基础上，对长词再次切分，提高召回率
具体函数：
精确模式：
jieba.cut(s) 精确模式，分词返回一个迭代器，用for in 形式遍历结果
>>>jieba.cut("新时代中国特色社会主义")
<generator object Tokenizer.cut at 0x0000016C91E2B5C8>
迭代器(也叫生成器)
jieba.lcut(s) 精确模式,分词返回一个列表
>>> jieba.lcut("新时代中国特色社会主义")
Building prefix dict from the default dictionary ...
Dumping model to file cache C:\Users\ADMINI~1\AppData\Local\Temp\jieba.cache
Loading model cost 1.485 seconds.
Prefix dict has been built succesfully.
['新', '时代', '中国', '特色', '社会主义']
全模式：
jieba.cut(s,cut_all = True)
>>>jieba.lcut("新时代中国特色社会主义")
<generator object Tokenizer.cut at 0x0000016C91E2B5C8>
jieba.lcut(s,cut_all = True)
>>>jieba.lcut("新时代中国特色社会主义",cut_all = True)
['新', '时代', '中国', '国特', '特色', '社会', '社会主义', '会主', '主义']
搜索引擎模式：(是在精确模式的基础上)
jieba.cut_for_search(s) 返回一个迭代器
jieba.lcut_for_search(s) 返回一个列表
注：也会 产生冗余
增加新词到词典中：
jieba.add_word(w) 向分词的词典中增加新词w
(3),wordcloud库的使用：
wordcloud库提供词云展示功能
more:https://github.com/amueller/word_cloud
安装的时候如果提示未编译，记得采用UCI 的安装方法
wordcloud 库将词云当做一个wordcloud对象
>wordcloud.WordCloud() 代表一个文本对应的词云
>可以根据文本中词语出现的频率等参数绘制词云
>绘制词云的形状，尺寸和颜色可以设定
wordcloud库常规用法：
w = wordcloud.WordCloud()
>以WordCloud对象为基础
>配置参数，加载文本，输出文件
对象w 有两个重要的方法：
w.generate(txt) 向WordCloud对象w中加载文本txt
w.to_file(filename) 将词云输出为图像文件 .png/.jpg
wordcloud库的具体使用步骤：
import wordcloud
c = wordcloud.WordCloud() :配置对象参数
c.generate("One Python, One World") :加载词云文本(字符串)
c.to_file("xxx.png) :输出词云文件
注： 加载词云使用的文本必须是字符串，其中每个词之间用空格来分隔。
它会自动的根据词语出现的频率来绘制单词，
配置对象参数：
默认输出的是width = 400px height = 200px
文本 ----> 【1,分隔：以空格分隔单词 】 ---->词云
文本 ----> 【2,统计：单词出现次数并过滤 】 ---->词云
文本 ----> 【3,字体：根据统计配置字号 】 ---->词云
文本 ----> 【4,布局：颜色环境尺寸 】 ---->词云
具体的WordCloud(<参数>) 的参数：
width 指定词云对象生产图片的宽度，默认400px
height 指定词云对象生产图片的高度，默认200px
>>>w = wordcloud.WordCloud(width = 500,height=300)
min_font_size 词云中最小字号 ，默认是4号
max_font_size 词云中最大字号 ，根据高度自动调节
font_step 指定词云中字体字号的步进间隔，默认为1
font_path 指定字体文件的路径，默认是None
>>> w = wordcloud.WordCloud(font_path="xxx.ttc")
max_words 指定词云显示的最大单词数量 ，默认200
stop_words 指定词云排除的单词，用集合表示
>>> w = wordcloud.WordCloud(stop_words={"Python"})
当然也可以对形状设置:
mask 指定词云形状，需要引用imread()函数，默认为长方形
>>>from scipy.misc import imread
>>>myMask = imread("xxx.png") #参考图片的背景是白色
>>>w = wordcloud.WordCloud(mask=myMask)
background_color 指定词云的背景颜色，默认为黑色
>>> w = wordcloud.WordCloud(background_color="white")
小实例：
import wordcloud
txt = "lift is short ,you need python"
w= wordcloud.WordCloud(background_color="white")
w.generate(txt)
w.to_file(xxx.png)
对中文操作：
由于wordcloud需要空格分开，所以需要jieba 库来给中文先分词 。
import jieba ,wordcloud
txt = "程序设计是给出解决特定问题程序的过程，\
是 软件构造活动中的重要组成部分。\
程序设计往往以某种 程序设计语言为工具，\
给出这种语言下的程序。"
w = wordcloud.WordCloud(width =1000,\
font_path = "msyh.ttc",height =700)
myTxt = " ".join(jieba.lcut(txt))
w.generate(myTxt)
w.to_file(xxx.png)
unit3:实例2：四大名著词云分析：
1 import jieba,wordcloud 2 3 names = {'红楼梦.txt','三国演义.txt','水浒传.txt','西游记.txt'} 4 5 for name in names: 6 7 f = open(name,'r',encoding="utf8") 8 9 t = f.read() 10 11 f.close() 12 13 ls = jieba.lcut(t) 14 15 txt = " ".join(ls) 16 17 w = wordcloud.WordCloud(font_path = "msyh.ttc",\ 18 19 width = 1000,height = 700) 20 21 w.generate(txt) 22 23 w.to_file(name.split('.'[0])+".png")
改进版：
1 import jieba,wordcloud 2 3 names = {'红楼梦.txt','三国演义.txt','水浒传.txt','西游记.txt'} 4 5 6 7 from scipy.misc import imread 8 9 myMask = imread("sun.png")#背景是白色（词云在非白色区域绘制） 10 11 12 13 for name in names: 14 15 f = open(name,'r',encoding="utf8") 16 17 t = f.read() 18 19 f.close() 20 21 ls = jieba.lcut(t) 22 23 txt = " ".join(ls) 24 25 w = wordcloud.WordCloud(font_path = "msyh.ttc",\ 26 27 width = 1000,height = 700,mask = myMask) 28 29 w.generate(txt) 30 31 w.to_file(name.split('.'[0])+"2.png")
unit4:Python常用标准库解析(下):
(1),pipenv库的使用 (特别常用)
pipenv库提供了基于项目的虚拟环境维护及Python库管理功能
项目A 项目A的虚拟环境及库集合
项目B ---> pipenv ---> 项目B的虚拟环境及库集合
项目C 项目C的虚拟环境及库集合
more:https://github.com/pypa/pipenv
>以项目为单位隔离Python环境，进而可以使用不同的Python库版本
>自动管理所安装Python库及其依赖的其他库
>命令行工具：基于virtualenv 和pip ,目前最好的虚拟环境维护工具
python的核心团队都在计划将它引入标准库。
安装：pip install pipenv
pipenv库的原理：
pipenv库使用Pipfile 和Pipfile.lock来管理虚拟环境
>Pipfile:记录虚拟环境的信息，尤其是Python库
>Pipfile.lock: 锁定Pyhon库的版本
>两个文件共同表达了虚拟环境
注： 当lock 锁定之后，即使库升级，在这个项目中使用的版本依然是未升级的
注： pipienv 也是个命令行工具
具体使用：
pipenv -h :帮助
可以创建目录d:/pEnv，然后命令行进入
pipenv --venv :显示当前目录虚拟环境信息
D:\pEnv>pipenv --venv
No virtualenv has been created for this project yet!
Aborted!
(因为现在还是空目录)
如何创建虚拟环境呢？
pipenv --three 建立Python 3.x 虚拟环境 也可以用以下命令：
pipenv --python 3.5
进入虚拟环境的命令行 ：
pipenv shell
会出现如下信息：
(pEnv-g0vMOMWU) λ
在虚拟环境中安装第三方库：
pipenv install jieba
显示第三方库的依赖环境：
pipenv graph
在虚拟环境中执行程序：
pipenv run python a.py
更多：pipenv -h
(2),tabulate库的使用:
提供优雅打印表格数据（二维列表）的功能
使用方法：
print(tabulate(ls))
>支持二维列表，二维迭代类型，字典迭代等类型
>支持NumPy二维数组，pandas.DataFrame类型
>输出表格可以通过参数自定义风格
more:https://bitbucket.org/astanin/python-tabulate
tabulate库只有一个函数tabulate()
引用方式：form tabulate import tabulate
>>> from tabulate import tabulate
>>> ls = [[1,2,3],[4,5,6]]
>>> print(tabulate(ls))
- - -
1 2 3
4 5 6
- - -
参数：
table ,headers
table :表格数据或变量
headers:定义表格的表头
>>> print(tabulate(ls,headers = ['a','b','c']))
a b c
--- --- ---
1 2 3
4 5 6
还有参数：tablefmt :定义表格风格(有很多给出的)
print(tabulate(ls,tablefmt = "jira"))
>>> print(tabulate(ls,tablefmt = 'jira'))
| 1 | 2 | 3 |
| 4 | 5 | 6 |
numalign: 可以设置全表格数字的对齐方式，默认是智能对齐
>>> ls =[[10.5,20,30],[51,25,23]]
>>> print(tabulate(ls,numalign='left'))
---- -- --
10.5 20 30
51 25 23
---- -- --
>>> print(tabulate(ls,numalign='right'))
---- -- --
10.5 20 30
51 25 23
---- -- --
这里只简要介绍这四个参数。
(3),QRcode库的使用：
QRcode库提供二维码生成功能：
支持各类种类数据的二维码生成
more:https://github.com/lincolnloop/python-qrcode
img = make(txt ,border=4)
>txt :待转变为二维码的字符串或字节串等
>border:设置二维码边的宽度
>img :一个PIL 库类型的图像句柄
import qrcode
img = qrcode.make('http://python123.io')
img.save('d:/qr.png')
unit5:实例3：金庸武侠小说写作风格分析：
>从词语频率角度简要分析作者写作风格：字频+词频
字频
1 #飞雪连天射白鹿 笑书神侠倚碧鸳 2 3 fnames = {"飞狐外传", "雪山飞狐", "连城诀", "天龙八部", "射雕英雄传", "白马啸西风", "鹿鼎记", \ 4 5 "笑傲江湖", "书剑恩仇录", "神雕侠侣", "侠客行", "倚天屠龙记", "碧血剑", "鸳鸯刀"} 6 7 def PrintJYChars( fname ): 8 9 txt = open( fname , "r").read() 10 11 d = {} ; cnt = 0 ; rst = "" 12 13 for w in txt: 14 15 cnt += 1 16 17 d[w] = d.get(w, 0) + 1 18 19 for w in "，。“”：？\n 「」∶": 20 21 try : 22 23 del d[w] 24 25 except : 26 27 pass 28 29 ls = list(d.items()) 30 31 ls.sort(key= lambda x :x[1], reverse= True ) 32 33 for i in range(20): 34 35 word, count = ls[i] 36 37 rst += word 38 39 print(rst) 40 41 return rst 42 43 44 45 txt = PrintJYChars("天龙八部" + ".txt") 46 47 A = set(txt.split()) 48 49 for fname in fnames: 50 51 txt = PrintJYChars(fname + ".txt") 52 53 A &= set(txt.split()) 54 55 print(A)
词频：
1 #飞雪连天射白鹿 笑书神侠倚碧鸳 import jieba fnames = {"飞狐外传", "雪山飞狐", "连城诀", "天龙八部", "射雕英雄传", "白马啸西风", "鹿鼎记", \ 2 3 "笑傲江湖", "书剑恩仇录", "神雕侠侣", "侠客行", "倚天屠龙记", "碧血剑", "鸳鸯刀"} 4 5 def PrintJYWords( fname ): 6 7 txt = open( fname , "r").read() 8 9 d = {} 10 11 cnt = 0 12 13 rst = "" 14 15 for w in jieba.lcut(txt): 16 17 cnt += 1 18 19 if len(w) == 1: 20 21 continue 22 23 d[w] = d.get(w, 0) + 1 24 25 ls = list(d.items()) 26 27 ls.sort(key= lambda x :x[1], reverse= True ) 28 29 for i in range(50): 30 31 word, count = ls[i] 32 33 rst += word + "," 34 35 return rst 36 37 38 39 txt = PrintJYWords("天龙八部" + ".txt") 40 41 A = set(txt.strip(",").split(",")) 42 43 for fname in fnames: 44 45 txt = PrintJYWords(fname + ".txt") 46 47 A &= set(txt.split(",")) 48 49 print(A)
