内置模块
.random随机模块
import random --->需要导入
- random.random():获取[0.0,1.0)浮点数0到1.0
- random.randint(a,b):整数[a,b]a到b 整数
- random.uniform(a,b):浮点数[a,b] a到b的浮点
- random.shuffle(x): 把参数指定的数据中的元素混洗。参数必须是一个可变的数据类型
- random：sample（x,k）从x随机里面抽取K个数据，组成列表返回
time时间模块
封装了获取时间戳和字符串形式的时间的一些方法.
import time --->需要导入
time.time()
时间戳:从时间元年(1970.1.1 00:00:00)到限制的秒数(有些语言为毫秒数)
格式化时间对象(9个字段)(给计算机看的)(不利于阅读,利于传输)
- time.gmtime(时间戳,默认当前时间戳)(GMT时间)
- time.localtime(时间戳,默认当前时间戳) 当地时间
格式化时间对象和时间字符串之间的转换(有些小问题)
- s = time.strftime()
- s = time.strptime()
时间戳与格式化时间对象
- time.mktime()
- print(time.mktime(time.localtime())) 格式化时间对象转换为时间戳.
暂停当前程序,睡眠XXX秒
- time.sleep()
datetime(日期,时间模块.)
封装了一些和日期,时间相关的类
import datetime
date类(年月日)
d =datetime.date(1010,10,10)
print(d)
print(d.year)
print(d.month)
print(d.day)
time类(时分秒)
t = datetime.time(10,20,20)
print(t)
print(t.hour)
print(t.minute)
print(t.second)
datatime类(年月日时分秒)
datetime.datetime.now() #获取当前时间
timedelta(一般用于数学计算)
dt =datetime.datetime(2011,11,11,11,11,11)
td = datetime.timedelta(days=1)
print(td)
dt = dt+td
print(dt)
+ 时间变化量的计算是否会影响上一级(是否会产生进位)
+ 会进位.
+ timedelta 和时间段运行结果 去决于被运行的时间类型保持一致.
OS模块
操作文件
os.rename() ;可以重命名文件也可以重命名文件夹
os.rename("aaa.txt","ccc") #导入os模块进行重命名
os.remove() ;可以删除文件,不能删除文件夹(shutil模块可以)
os.remove("ccc.txt")
操作文件夹
文件夹的创建
os.mkdir() ;
os.mkdir("rrr") #无法创建嵌套文件夹、
os.makedirs("111/222/333") #创建嵌套文件夹
获取当前路径
os.getcwd();
print(os.getcwd())
进入：相当于Linux的cd
os.chdir;
os.chdir("333/111")
os.chdir("../../")
print(os.getcwd())
获取目录列表:相当于Linux命令中的ls
os.listdir();
print(os.listdir()) #不写参数时候显示当前目录下所有文件
print(os.listdir("aaa")) #显示指定目录下的所有文件及文件夹
删除目录：只能删除空目录
os.rmdir();
os.rmdir("bbb")
判断一个文件或者一个文件夹是否存在
os.path.exists
print(os.path.exists("123.txt")) #在就返回true，不在返回flase
print(os.path.exists("aaa")) # 文件和文件夹都可以判断
判断一个路径是文件还是文件夹
os.path.isfile
print(os.path.isfile("aaa")) #判断是否是文件
print(os.path.isdir("aaa")) #判断是否是文件夹
返回最后一个文件/文件夹.若以/\结尾返回none
os.path.basename()
print(os.path.basename("F:\PyCharms wenjian\day23"))
切分最后一个路径和前面所有路径
os.path.split()
print(os.path.split("F:\PyCharms wenjian\day23"))
结果为:('F:\\PyCharms wenjian', 'day23')
拼接路径,从第一个绝对路径开始
os.path.join(path1,path2)
print(os.path.join(r"F:\aa\bb","f")) #结果为F:\aa\bb\f
print(os.path.join(r"aa",r"F:\aa","bb")) #结果为F:\aa\bb
返回目录或文件的最后访问时间(时间戳)
os.path.getatime()
print(os.path.getatime("F:\PyCharms wenjian\day23"))
返回值为:1559303907.7618327
返回path所指向的文件或者目录的最后修改时间
os.path.getmtime()
print(os.path.getmtime("F:\PyCharms wenjian\day23"))
返回值为:1559302621.9885674
返回路径目录或者文件的大小
os.path.getsize()
print(os.path.getsize(r"F:\PyCharms wenjian\day20")) 文件夹大小为o
print(os.path.getsize(r"F:\PyCharms wenjian\day23\argvpp.py"))
返回值为:613字节
sys模块
sys.argv 在脚本程序运行时候运行的参数
res = sys.argv[0] #脚本名
res1 = sys.argv[1] #第一个参数
res1 = sys.argv[2] #第二个参数
sys.modules 返回系统已经加载的模块,以字典形式返回
sys.path 解释器寻找模块路径
sys.exit(n) 退出程序，正常退出时exit(0),错误退出sys.exit(1)
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 ***
sys.version 获取Python解释程序的版本信息
json和pickle
json
javascript object notation --- java脚本兑现标记语言:
一种简单的数据交换格式(将所有数据转换为str模式)(set不行)元组会转换为列表.
- 将数据转换成字符串,用于存储或网络传输
- json.dumps(obj) 写到内存
- json.dump(obj,f) 写到文件
- json.loads(obj) 反解内存
- json.load(f) 从文件反解到内存
- json 文件通常是一次性写,一次性读.
- 使用另一种方式可以多次写,多次读
- 把需要序列化的对象,通过多次序列化的方式.用文件的write方法.把多次序列化后的json字符串写到文件中.
拆分的过程叫序列化过程(serialization)
- 专业:将内存中的数据,转化成字节串.用以保存在文件或网络传输.称为序列化过程
拆分后组合过程叫反序列化过程(deserialization)
- 专业:从文件中,网络中获取的数据,转换成内存中原来的数据类型,称为反序列化过程
pickle与json用法，基本相同。
- 将python中所有的数据类型.转换成字节串.序列化过程
- 将字节串转化成python中数据类型.反序列号过程
json和pickle的区别
- josn
- 不是所有数据类型都可以序列化
- 不能多次对同一个文件进行序列化
- json可以跨语言使用
- pickle
- 所有python类型都能序列化,结果是字节
- 能多次对同一个文件进行序列化
- pickle不能跨语言
结构化数据和线性数据
结构化数据(互相之间有联系. 可以拆分后组织. )(磁盘与内存,网络之间的传输)
线性数据(磁盘是一个典型的线性数据.数据之间没有引用关系)
collections模块
namedtuple(命名元组)
我们知道tuple可以表示不变集合，例如，一个点的二维坐标就可以表示成：
p = (1, 2)
但是，看到(1, 2)，很难看出这个tuple是用来表示一个坐标的。
这时，namedtuple就派上了用场：
>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(1, 2)
>>> p.x
1
>>> p.y
2
depue(双端队列)
使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。
deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：
from collections import deque
q = deque(['a', 'b', 'c'])
q.append('x')
q.appendleft('y')
print(q)
--->deque(['y', 'a', 'b', 'c', 'x'])
q.pop("x")
q.popleft("y")
print(q)
--->deque(['a', 'b', 'c'])
orderedDict(有序字典)
使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。
如果要保持Key的顺序，可以用OrderedDict：
from collections import OrderedDict
od=OrderedDict([("a",1),('b',2),('c',3)])
print(od)
注意，OrderedDict的Key会按照插入的顺序排列，不是Key本身排序：
defaultdict(默认值字典)
li = [11,22,33,44,55,77,88,99,90]
result = {}
for row in li:
if row > 66:
if 'key1' not in result:
result['key1'] = []
result['key1'].append(row)
else:
if 'key2' not in result:
result['key2'] = []
result['key2'].append(row)
print(result)
from collections import defaultdict
values = [11, 22, 33,44,55,66,77,88,99,90]
my_dict = defaultdict(list)
for value in values:
if value>66:
my_dict['k1'].append(value)
else:
my_dict['k2'].append(value)
counter(计数模块)
Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）。Counter类和其他语言的bags或multisets很相似。
c=collections.Counter('asdadasfkasldklas;dkadas')
print(c) ---> Counter({'a': 7, 's': 5, 'd': 5, 'k': 3, 'l': 2, 'f': 1, ';': 1})
print(c['a']) ---> 7
得到结果可以类似字典取值
hashlie模块
- 用于封装一些用于加密的类(md,sha1 等等)
- 加密的目的:用于判断和验证,而并非解码
特点
- 把一个大的数据切分成不同的小块.分别对不同的块进行加密,再汇总的结果和对大的数据直接加密的结果一样
- 单向加密不可逆
- 原始数据一点小的变化,将导致结果的非常大的差异(雪崩差异)
给一个数据加密的三大步骤
- 获取一个加密对象
- 使用加密对象update,进行加密.update可以调用多次
- 通过hexdigest 获取加密结果.或digest() 字节串方式
用法
- 给一个数据加密
- 验证:用另外一个数据加密结果和第一次加密的结果对比
- 如果结果相同,说明原文相同.如果不同则说明原文不同.
- 不同加密算法:实际上就是加密结果长度不同
- 在创建加密对象时,可以指定参数.称为salt.
import hashlib
md5 = hashlib.md5()
md5.update('123456'.encode('utf-8')) #加密数据类型必须是bytes类型
print(md5.hexdigest())
# 计算结果如下：
'e10adc3949ba59abbe56e057f20f883e'
加盐：
ret = hashlib.md5('luyi'.encode('utf-8')) # luyi就是固定的盐，必须是bytes类型
ret.update('a'.encode('utf-8'))
print(ret.hexdigest())
动态加盐：
username='luyi'
ret = hashlib.md5(username[::2].encode('utf-8')) # 针对于每个账户，每个账户的盐都不一样
ret.update('a'.encode('utf-8'))
print(ret.hexdigest())
re模块
正则就是用一些具有特殊含义的符号组合到一起（称为正则表达式）来描述字符或者字符串的方法。或者说：正则就是用来描述一类事物的规则。（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。**
正则
| 元字符 | 匹配内容 |
|---|---|
| \w | 匹配字母（包含中文）或数字或下划线 |
| \W | 匹配非字母（包含中文）或数字或下划线 |
| \s | 匹配任意的空白符 |
| \S | 匹配任意非空白符 |
| \d | 匹配数字 |
| \D | p匹配非数字 |
| \A | 从字符串开头匹配 |
| \z | 匹配字符串的结束，如果是换行，只匹配到换行前的结果 |
| \n | 匹配一个换行符 |
| \t | 匹配一个制表符 |
| ^ | 匹配字符串的开始 |
| $ | 匹配字符串的结尾 |
| . | 匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。 |
| [...] | 匹配字符组中的字符 |
| [^...] | 匹配除了字符组中的字符的所有字符 |
| * | 匹配0个或者多个左边的字符。 |
| + | 匹配一个或者多个左边的字符。 |
| ？ | 匹配0个或者1个左边的字符，非贪婪方式。 |
| 精准匹配n个前面的表达式。 | |
| 匹配n到m次由前面的正则表达式定义的片段，贪婪方式 | |
| a|b | 匹配a或者b。 |
| () | 匹配括号内的表达式，也表示一个组 |
什么是正则表达式
一套规则 匹配的字符串的规则
能做什么
- 检测一个输入的字符串是否合法 (web开发项目 表单验证)
- 用户输入一个内容的时候,我们要提前做检测,能够提高程序的效率并且减轻服务器的压力.
- 从一个大文件中找到符合规则的内容 (爬虫,日志分析)
- 能够高效的从一大段文字中快速找到符合规则的内容
正则规则
字符组[] 描述的是一个位置上能出现的所有可能性
一个中括号只表示一个字符位置
- [abc] 匹配a或者b或者c
- [0-9] 根据ascii 进行范围的比对
- [a-z] 小写字母
- [A-Z] 大写字母
- [a-zA-Z] 大小写字母
可以描述多个范围.多个[]
在正则表达式中能帮助我们表示匹配内容的符号(叫做元字符,表示能匹配那些内容,一个元字符匹配一个字符位置的内容)
- [\d]匹配一位任意数字(digit)
- [\w] 匹配任意一位数字,字母,下划线(word)
- [\s]匹配任何空格(\n,\t, )
- [\n] entet 回车
- [\t] 制表符
- [\W]对\w取反
- [\D]对\d取反
- [\S]对\s取反
- [\d\D] [\s\S][\w\W]匹配所有
- . 匹配出了换行之外的所有
- [^]非字符组
- [^\d]除了所有的数字
- ＾ 匹配一个字符串的开始
- ＄ 匹配一个字符串的结尾
- ｜ 或 ａ｜ｂ 匹配ａ或者ｂ 中的一个，如果匹配ａ成功不会和ｂ匹配．如果a,b有重叠部分,总是把长的放在前面
- () 约束或描述的内容的范围
- \ 取消字符的特殊意义
- \b 匹配单词的边界(不太常用)
量词(约束前一个位置元字符,分)
- {n}表示匹配n次
- {n,} 表示匹配至少n次
- {n,m} 表示至少匹配n次 至多m次
- ?表示匹配0次或1次
- +表示1次或多次
- *表示0次或多次
贪婪匹配
在量词范围允许的情况下,尽量多的匹配
.*x 匹配任意字符,任意多次数,遇到最后一个x才停下来
非贪婪匹配(惰性)
在量词后加一个? 在量词范围允许的情况下,尽量少的匹配.只要遇到合适立刻停止.
.*?x 匹配任意字符,任意多次数,但是一旦遇到x就停下来
转义符
- 原本有特殊意义的字符,到了表达他本身的时候,需要转义.
- 有一些有特殊意义的内容,放在字符组中,会取消他的特殊意义.[().*+?]
- -在字符组中表示范围,如果不希望他表示范围,需要转义或者放在字符组首尾
re和正则的关系
有了re模块就可以再python语言中更好的操作正则表达式
re模块
findall 还是安装完整的正则进行匹配.只是只显示括号里匹配到的内容.
search 还是安装完整的正则进行匹配,显示也显示匹配到的第一个内容,但是我们可以通过group方法传参数来获取具体组中的内容
import re
ret=re.findall("1(\d)(\d)","123")
print(ret) #[('2', '3')]
我们要查找的内容并没有一个突出的与众不同的特地,甚至会和不需要的杂乱的数据混合在一起,这时候我们就需要把所有的数据统计出来,然后对这个数据进行筛选.把我们真正需要的数据对应的正则表达式用()圈起来,就可以筛选出真正的数据了
取消分组优先显示
ret=re.findall("1(?:\d)(\d)","123")
print(ret) #['3']
sh·util模块
将文件内容拷贝到另一个文件中
shutil.copyfileobj(fsrc, fdst[, length])
shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))
拷贝文件
shutil.copyfile(src,dst)
shutil.copyfile(r"F:\PyCharms wenjian\day23\argvpp.py",r"F:\PyCharms wenjian\day23\argvpp1.py")
拷贝文件和权限(shutil.copy2()为拷贝文件和状态信息)
shutil.copy(src,dst)
shutil.copy(r"F:\PyCharms wenjian\day23\argvpp.py",r"F:\PyCharms wenjian\day23\argvpp1.py")
递归拷贝文件夹
shutil.copytree()
shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*')) #目标目录不能存在，注意对folder2目录父级目录要有可写权限，ignore的意思是排除
递归删除文件
shutil.rmtree()
shutil.rmtree()
递归的移动文件
shutil.move()
shutil.move("F:\PyCharms wenjian\day23","F:\PyCharms wenjian\day20")
压缩 解压文件
import zipfile,os
z=zipfile.ZipFile("F:\PyCharms wenjian\day23\laxi.zip","w") #创建一个新的空压缩包(z可以理解为压缩包的文件句柄)
z.write("argvpp.py") # 将文件写入压缩包
z.close() #目测需要关闭操作(和文件句柄相似)
s=zipfile.ZipFile("F:\PyCharms wenjian\day23\laxi.zip","r") #创建一个打开压缩包的s(s可以理解为压缩包的文件句柄)
s.extractall(path=r"F:\PyCharms wenjian\day22") #将文件解压到指定路径
s.close() #目测需要关闭操作(和文件句柄相似)
