python基础—常用模块

一、什么是模块？

模块的本质：一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。

1.模块和包的概念：

模块

随着程序代码越写越多，在一个文件里代码就会越来越长，越来越不容易维护。
为了编写可维护的代码，我们把很多函数分组，分别放到不同的文件里。
这样，每个文件包含的代码就相对较少，很多编程语言都采用这种组织代码的方式。
在Python中，一个.py文件就称之为一个模块（Module）

包

如果不同的人编写的模块名相同怎么办？为了避免模块名冲突，Python又引入了按目录来组织模块的方法，称为包（Package）。
每一个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，否则，Python就把这个目录当成普通目录(文件夹)，而不是一个包。__init__.py可以是空文件，也可以有Python代码，因为__init__.py本身就是一个模块，而它的模块名就是对应包的名字。

更多相关内容：http://www.cnblogs.com/Eva-J/articles/7292109.html

二、常用模块（一）

1.collections模块

在内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

  1. namedtuple: 生成可以使用名字来访问元素内容的tuple
  2. deque: 双端队列，可以快速的从另外一侧追加和推出对象
  3. Counter: 计数器，主要用来计数
  4. OrderedDict: 有序字典
  5. defaultdict: 带有默认值的字典

namedtuple 命名元组

我们知道tuple可以表示不变集合，例如，一个点的二维坐标就可以表示成：

p = (1,2)

但是，看到(1, 2)，很难看出这个tuple是用来表示一个坐标的。

这时，nametuple就派上了用场：nametuple可以为元素的每一个元素名一个名字，这样可以区分元组中的每个元素的意义

 from collections import namedtuple
 Point = namedtuple('Point', ['x', 'y'])  # 获得一个命名元组类
 p = Point(1, 2)  # 为这个类实例化一个对象
 p.x  通过名字取值
 p.y
tu = namedtuple('ryxiong',['name','age','gender','hobby'])
# 获得一个类

t = tu('ryxiong',29,'male', 'programing, prography')
# 实例化一个对象

print(t)
print(t.name)

deque 双端队列

使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。

双端队列和列表的区别：

  • 效率不同
  • 底层的数据结构上，列表先进先出（FIFO），栈先进后出（LIFO）

两者的特点：

  • 双端队列：链表式数据结构，存入值速度快
  • 列表：取值，根据索引，双端队列要一个一个往下找。

使用场景：

  • 从中间插入或者删除比较频繁，使用双端队列
  • 单纯的append和pop最后一个元素的时候，用列表。

列表的用法，尽量只用append和pop

from collections import deque
d = deque([1,2,3,4])

# 右侧添加
d.append(5)  # deque([1, 2, 3, 4, 5])
# print(d)

# 左侧添加
d.appendleft(10)  # deque([10, 1, 2, 3, 4, 5])
# print(d)

# 插入
d.insert(2,99)  # deque([10, 1, 99, 2, 3, 4, 5])
# print(d)

# 删除
d.remove(3)  # 指定元素删除
d.pop()  # 不可根据索引删除，因为是双向的

deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。

OrderedDict 顺序字典

在py3.6版本前，字典中的键是没有顺序的，如果我们要保持key的顺序，可以使用OrderDict：

>>> from collections import OrderedDict
>>> d = dict([('a', 1), ('b', 2), ('c', 3)])
>>> d # dict的Key是无序的
{'a': 1, 'c': 3, 'b': 2}
>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> od # OrderedDict的Key是有序的
OrderedDict([('a', 1), ('b', 2), ('c', 3)])

注意，OrderedDict的Key会按照插入的顺序排列，不是Key本身排序：

defaultdict 默认字典

# 默认字典
d = defaultdict(list)  # defaultdict(<class 'list'>, {})
# print(d)

d['name']  # defaultdict(<class 'list'>, {'name': []})
print(d)

有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。

即： {'k1': 大于66 , 'k2': 小于66}

values = [11, 22, 33,44,55,66,77,88,99,90]

my_dict = {}

for value in  values:
    if value>66:
        if my_dict.has_key('k1'):
            my_dict['k1'].append(value)
        else:
            my_dict['k1'] = [value]
    else:
        if my_dict.has_key('k2'):
            my_dict['k2'].append(value)
        else:
            my_dict['k2'] = [value]
原生字典解决方法
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)
defaultdict字典解决方法

使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdic：

默认字典使用场景：当遇到很多列表类型数据，发现他们的首个元素相同，要合并他们后面的元素进行相应操作，用defaultdict，相当好用。

>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在，返回默认值
'N/A'
实例
# 默认字典中设置默认的具体值
d = defaultdict(lambda :5)
print(['a'])

Counter 计数

Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）。Counter类和其他语言的bags或multisets很相似。

c = Counter('abcdeabcdabcaba')
print c
输出：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

总结：没有什么大用处

2.时间模块

在处理和时间相关的问题时候我们需要用到时间模块，时间模块有很多种，这里介绍三种：time模块，datetime模块，dateutil模块

但是本质上，datetime和dateutil都是基于time模块上实现的。

 时间相关概念

时间戳

  • 时间是格林威治时间1970年01月01日00时00分00秒

时区：

  • 世界各地根据经度的不同划分为24个时区，以英国为零时区，向东向西各划分12个

UTC时间：

协调世界时（coordinated Universal Time,简称UTC）是最主要的世界时间标准，以原子时秒长为标准，在时刻上尽量接近格林威治时间。

  • 比如本地时间比UTC快，如大陆比UTC时间快8小时，则会写作UTC+8，相反写做UTC-10

time模块

python中的时间

1.时间戳(timestamp)：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。

2.结构化时间(struct_time)：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时)

索引（Index）    属性（Attribute）    值（Values）
0    tm_year（年）    比如2011
1    tm_mon（月）    1 - 12
2    tm_mday（日）    1 - 31
3    tm_hour（时）    0 - 23
4    tm_min（分）    0 - 59
5    tm_sec（秒）    0 - 60
6    tm_wday（weekday）    0 - 6（0表示周一）
7    tm_yday（一年中的第几天）    1 - 366
8    tm_isdst（是否是夏令时）    默认为0
结构化时间元素意义

3.格式化时间（format_time）:如2015-02-14 10：25：00

格式化时间字符串化对应表
%Y  Year with century as a decimal number.
%m  Month as a decomal number [01,12].
%d  Day of the month as a decomal number [01, 31].
%H  Hour (24-hour clock) as a decimal number [00,23].
%M  Minute as a decimal number [00,59].
%S  Second as a decimal number [00,61].
%z  Time zone offset from UTC.
%a  Locale's abbreviated weekday name.  # 星期的缩写
%A  Locale's full weekday name.  # 星期的全写
%b  Locale's abbreviated month name.  # 月份的缩写
%B  Locale's full month name.  # 月份的全写
%X  Locale's appropriate time representation.  # 冒号分割的时间
格式化时间字符串化对应表

time模块的常用方法

  • time.time(): 获得当前时间的时间戳
  • time.localtime(timestamp): 获得当前时间的结构化时间,参数默认当前时间的时间戳，可以自己给
  • time.strftime(format,struct_time): 将结构化时间，转成格式化时间格式，format可以任意规定，当时要根据对应表
  • time.strptime(string_time,format): 将格式化时间转换成结构化时间struct_time
  • time.mktime(struct_time): 将结构化时间转换成时间戳
  • time.sleep(second): 休眠多少秒。
  • time.gmtime([sec]): 和localtime方法类似，gmtime是将一个时间转换为UTC时区的struct_time

常用方法：

#导入时间模块
>>>import time

#时间戳
>>>time.time()
1500875844.800804

#时间字符串
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 13:54:37'
>>>time.strftime("%Y-%m-%d %H-%M-%S")
'2017-07-24 13-55-04'

#时间元组:localtime将一个时间戳转换为当前时区的struct_time
time.localtime()
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,
　　　　　　　　　　tm_hour=13, tm_min=59, tm_sec=37, 
                 tm_wday=0, tm_yday=205, tm_isdst=0)
使用方法

小结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的。

几种格式之间的转换

#时间戳-->结构化时间
#time.gmtime(时间戳)    #UTC时间，与英国伦敦当地时间一致
#time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法：与UTC时间相差8小时，UTC时间+8小时 = 北京时间 
>>>time.gmtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
>>>time.localtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)

#结构化时间-->时间戳　
#time.mktime(结构化时间)
>>>time_tuple = time.localtime(1500000000)
>>>time.mktime(time_tuple)
1500000000.0
时间戳 和 结构化时间
#结构化时间-->字符串时间
#time.strftime("格式定义","结构化时间")  结构化时间参数若不传，则显示当前时间
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 14:55:36'
>>>time.strftime("%Y-%m-%d",time.localtime(1500000000))
'2017-07-14'

#字符串时间-->结构化时间
#time.strptime(时间字符串,字符串对应格式)
>>>time.strptime("2017-03-16","%Y-%m-%d")
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)
>>>time.strptime("07/24/2017","%m/%d/%Y")
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)
结构化时间 和 字符串时间

#结构化时间 --> %a %b %d %H:%M:%S %Y串
#time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串
>>>time.asctime(time.localtime(1500000000))
'Fri Jul 14 10:40:00 2017'
>>>time.asctime()
'Mon Jul 24 15:18:33 2017'

#时间戳 --> %a %b %d %H:%M:%S %Y串
#time.ctime(时间戳)  如果不传参数，直接返回当前时间的格式化串
>>>time.ctime()
'Mon Jul 24 15:19:07 2017'
>>>time.ctime(1500000000)
'Fri Jul 14 10:40:00 2017'
UTC时间和时间戳转换

datetime模块

官方文档：http://devdocs.io/python~3.6/library/datetime https://docs.python.org/3/library/time.html#strftime-and-strptime-behavior

由于time模块在时间的加减上很不友好，所以有人写出的datetime模块，time模块是datetime模块的底层模块

datetime包中常用的几个模块

  • from datetime import datetime
  • from datetime import timedelta
  • from datetime import date
from datetime import datetime

# datetime.now(): 获取当前时间
print(datetime.now())  # 2019-03-20 11:38:31.423739

# datetime.timestamp(): 将当前时间转成时间戳
time_stamp = datetime.timestamp(datetime.now())
print(time_stamp)


# datetime.strftime(struct_time,format):将结构化时间转换成格式化字符串时间
f = datetime.strftime(datetime.now(),'%Y-%m-%d %X')
print(f)

# datetime.strptime(string_time,format): 将字符串时间转换成格式化时间。
t = datetime.strptime(f,'%Y-%m-%d %H:%M:%S')
print(t)

使用timedelta生成时间间隔，用时间的计算

from datetime import timedelta

d = timedelta(days=1,hours=5)  # 根据参数，生成多少间隔的一个时间间隔对象
print(d)  # 1 day, 5:00:00

# timedelta(): 获取时间差额，用于datetime的增减计算。用时间对象与timedelta运算。
print(datetime.now()-timedelta(days=2))  # 2019-03-18 16:45:04.427857

date模块

from datetime import date,timedelta
today = date.today()
d = timedelta(days=1, hours=5)
future = today + d
print(future)

dateutil模块

第三方库：pip install python-dateutil

官方文档：https://dateutil.readthedocs.io/en/stable/examples.html#relativedelta-examples

原因：timedelta不够用，处理跨星期，跨月，跨年的计算麻烦

  • class datetime.timedelta(days=0, seconds=0, microseconds=0,milliseconds=0, minutes=0, hours=0, weeks=0)
# 下周的星期三是几号
from datetime import datetime
from dateutil.relativedelta import relativedelta
from dateutil.rrule import *   # MO,TU,WE,TH,FR

d = datetime.now()

print(d + relativedelta(weekday=WE))  # 这周

print(d + relativedelta(weekday=WE, weeks=+1))  # 下周

print(d + relativedelta(weekday=WE, weeks=-1))  # 上周

计算过了一个月，或者三个月后是哪一天？不能简单+30

from datetime import date
date(2018, 1, 31) + relativedelta(months=+1)
date(2018,1,25) + relativedelta(months=-10)

3.random模块

随机数模块：产生随机数

random的常用方法：

  • random.random(): 返回0-1之间的随机小数
  • random.randint(a,b): 返回从a到b之间的随机整数，闭区间
  • random.uniform(a,b): 返回a
  • random.randrange(m,n,k): 返回m到n步长为k的整数，前开后闭区间
  • random.choice(有序的iterable): 从有序的可迭代对象中随机选择一个元素
  • random.choices(有序的iterable,k=num): 从有序的可迭代对象中随机选取多个元素，个数可指定，元素之间可重复
  • random.sample(有序的iterabel,k=num): 从有序的可迭代对象中随机选取多个元素，个数可指定，元素之间不重复
  • random.shuffle(iterable): 将有序可迭代对象中的元素打乱顺序。
>>> import random
#随机小数
>>> random.random()      # 大于0且小于1之间的小数
0.7664338663654585
>>> random.uniform(1,3) #大于1小于3的小数
1.6270147180533838
#恒富：发红包

#随机整数
>>> random.randint(1,5)  # 大于等于1且小于等于5之间的整数
>>> random.randrange(1,10,2) # 大于等于1且小于10之间的奇数


#随机选择一个返回
>>> random.choice([1,'23',[4,5]])  # #1或者23或者[4,5]
#随机选择多个返回，返回的个数为函数的第二个参数
>>> random.sample([1,'23',[4,5]],2) # #列表元素任意2个组合
[[4, 5], '23']


#打乱列表顺序
>>> item=[1,3,5,7,9]
>>> random.shuffle(item) # 打乱次序
>>> item
[5, 1, 3, 7, 9]
>>> random.shuffle(item)
>>> item
[5, 9, 7, 1, 3]

练习：生成随机验证码

import random

def v_code():

    code = ''
    for i in range(5):

        num=random.randint(0,9)
        alf=chr(random.randint(65,90))
        add=random.choice([num,alf])
        code="".join([code,str(add)])

    return code

print(v_code())
生成验证码

4.os模块

概念：内置模块，是与当前电脑操作系统做交互的一个接口

常用方法

1.文件相关

os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
os.mkdir('dirname')    生成单级目录；相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印

2.文件相关

os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息

3.环境相关

os.system("bash command")  运行shell命令，直接显示
os.popen("bash command).read()  运行shell命令，获取执行结果
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录；相当于shell下cd

4.路径相关（重要）

os.path
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的大小

注意：os.stat('path/filename')  获取文件/目录信息 的结构说明

stat 结构:

st_mode: inode 保护模式
st_ino: inode 节点号。
st_dev: inode 驻留的设备。
st_nlink: inode 的链接数。
st_uid: 所有者的用户ID。
st_gid: 所有者的组ID。
st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。
st_atime: 上次访问的时间。
st_mtime: 最后一次修改的时间。
st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。
stat 结构
os.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os模块的属性

5.sys模块

概念：sys模块是与python解释器交互的一个接口

常用方法

  • sys.argv: 实现从程序外部向程序传递参数。

  • sys.exit([arg]): 程序中间的退出，arg=0为正常退出。

  • sys.path: 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

  • sys.platform: 获取当前系统平台。

  • sys.version：获取Python解释程序的版本信息

  • sys.modules 返回系统导入的模块字段，key是模块名，value是模块

  • sys.stdout, sys.stdin, sys.stderror：分别和输出输入，错误输出相关。sys.stdout.write和print 都是输出相关的函数print内部也是调用的sys.stdout，sys.stdout默认输出是屏幕。

sys.argv方法

在外部向程序内部传递参数，sys.argv是命令行参数列表，第一个元素是程序本身

# 当我们在命令行cmd中运行某一个文件，后面可以附带参数，这些附带的参数就可以通过sys.argv获得。
比如我们在cmd中输入 python test.py post C://test ，然后我们在test.py文件中打印sys.argv就可以拿到后面的参数post和C://test

import sys
print(sys.argv)

# 运行结果
['D:/PyCharmProject/python全栈S20/01-test/test.py', post, C://test]  # 列表第一个参数是脚本本身

sys.exit(n)

功能：执行到主程序末尾，解释器自动退出，但是如果需要中途退出程序，可以调用sys.exit函数，带有一个可选的整数参数返回给调用它的程序，表示你可以在主程序中捕获对sys.exit的调用。（0是正常退出，其他为异常）

import sys
print('hello')
sys.exit(0)
print('python')

# 运行程序后发现在，程序输出hello后并没有继续输出python。因为在执行到sys.exit(0)的时候程序就结束了。

sys.stdout()

import sys
sys.stdout.write(str)

sys.stdout.write()的打印会将结果先缓存，知道所有结果都在缓存中然后一起打印，如果想挨个显示自己的，可以使用sys.stdout.flush()来逐个刷新。没打印一个就刷新屏幕显示。

sys.stdout和print

import sys
s = 'test stdout'

print('--')
sys.stdout.write(s)
print('--')

class A(object):
    pass

print(A) # 正常

sys.stdout.write(A)  # 报错
注意和print区别

注意：print 什么类型都可以输出，但是sys.stdout.write只可以输出字符串类型,否则报错。print默认是最后换行，但是sys.stdout.write默认不换行。

import sys
file = sys.stdout    # 存储原始的输出对象
sys.stdout = open('1.txt', 'w')  # 重定向所有的写入内容到 1.txt 文件,
print('Citizen_Wang')   # 写入到 1.txt 文件中，在上一行语句中改变了输出流到文件中
print('Always fall in love with neighbours')  # 继续写入到文件中
sys.stdout.close()    # 其实就是 open 文件之后的关闭
sys.stdout = file  # 将 print 命令的结果返回给控制台
print('输出信息返回在控制台')  # 该信息会在控制台也显示
stdout进阶玩法

6.序列化模块

什么叫序列化——将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化。

我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，

在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。

序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。

反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

'''
比如，我们在python代码中计算的一个数据需要给另外一段程序使用，那我们怎么给？
现在我们能想到的方法就是存在文件里，然后另一个python程序再从文件里读出来。
但是我们都知道，对于文件来说是没有字典这个概念的，所以我们只能将数据转换成字典放到文件中。
你一定会问，将字典转换成一个字符串很简单，就是str(dic)就可以办到了，为什么我们还要学习序列化模块呢？
没错序列化的过程就是从dic 变成str(dic)的过程。现在你可以通过str(dic)，将一个名为dic的字典转换成一个字符串，
但是你要怎么把一个字符串转换成字典呢？
聪明的你肯定想到了eval()，如果我们将一个字符串类型的字典str_dic传给eval，就会得到一个返回的字典类型了。
eval()函数十分强大，但是eval是做什么的？e官方demo解释为：将字符串str当成有效的表达式来求值并返回计算结果。
ＢＵＴ！强大的函数有代价。安全性是其最大的缺点。
想象一下，如果我们从文件中读出的不是一个数据结构，而是一句"删除文件"类似的破坏性语句，那么后果实在不堪设设想。
而使用eval就要担这个风险。
所以，我们并不推荐用eval方法来进行反序列化操作(将str转换成python中的数据结构)
'''
为什么要序列化

序列化的目的：

1、以某种存储形式使自定义对象持久化；
2、将对象从一个地方传递到另一个地方。
3、使程序更具维护性。
    把具有复杂结构(引用关系)的数据结构由一种立体结构变成一种线性结构保存在文件中或者是通过网络传输.
如果只是普通的字符串或者是数值等简单的数据类型,不需要序列化,也能完成保存或者是网络传输.

json模块

json数据：用于多种语言交互，编程语言通用数据内置的，不需要安装，直接导入使用，数据持久化

json的四种方法：

  • dumps()：序列化，将一个字典转换成一个字符串
  • loads()：反序列化，将一个字符串格式的字典转换成一个字典
  • dump(对象，文件句柄)：接收一个文件句柄，直接将字典转换成json字符串写入文件
  • load(文件句柄)：接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)  #序列化：将一个字典转换成一个字符串
print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意，json转换完的字符串类型的字典中的字符串是由""表示的

dic2 = json.loads(str_dic)  #反序列化：将一个字符串格式的字典转换成一个字典
#注意，要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}


list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic) #也可以处理嵌套的数据类型 
print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]

loads和dumps
dumps和loads
import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
f.close()

f = open('json_file')
dic2 = json.load(f)  #load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)
load和dump
import json
f = open('file','w')
json.dump({'国籍':'中国'},f)
ret = json.dumps({'国籍':'中国'})
f.write(ret+'\n')
json.dump({'国籍':'美国'},f,ensure_ascii=False)
ret = json.dumps({'国籍':'美国'},ensure_ascii=False)
f.write(ret+'\n')
f.close()
ensure_ascii关键字参数
Serialize obj to a JSON formatted str.(字符串表示的json对象) 
Skipkeys：默认值是False，如果dict的keys内的数据不是python的基本类型(str,unicode,int,long,float,bool,None)，设置为False时，就会报TypeError的错误。此时设置成True，则会跳过这类key 
ensure_ascii:，当它为True的时候，所有非ASCII码字符显示为\uXXXX序列，只需在dump时将ensure_ascii设置为False即可，此时存入json的中文即可正常显示。) 
If check_circular is false, then the circular reference check for container types will be skipped and a circular reference will result in an OverflowError (or worse). 
If allow_nan is false, then it will be a ValueError to serialize out of range float values (nan, inf, -inf) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (NaN, Infinity, -Infinity). 
indent：应该是一个非负的整型，如果是0就是顶格分行显示，如果为空就是一行最紧凑显示，否则会换行且按照indent的数值显示前面的空白分行显示，这样打印出来的json数据也叫pretty-printed json 
separators：分隔符，实际上是(item_separator, dict_separator)的一个元组，默认的就是(‘,’,’:’)；这表示dictionary内keys之间用“,”隔开，而KEY和value之间用“：”隔开。 
default(obj) is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. 
sort_keys：将数据根据keys的值进行排序。 
To use a custom JSONEncoder subclass (e.g. one that overrides the .default() method to serialize additional types), specify it with the cls kwarg; otherwise JSONEncoder is used.
其他参数说明
import json
data = {'username':['李华','二愣子'],'sex':'male','age':16}
json_dic2 = json.dumps(data,sort_keys=True,indent=2,separators=(',',':'),ensure_ascii=False)
print(json_dic2)
json的格式化输出

json注意点：
1.json写入时，只能一次性写入，无论多少数据只能套入一个字典中写入，所以不支持追加写入
2.json在文件中不认单引号。
3.无论数据怎么创建，只要满足json格式，就可以用json.loads出来。

pickle模块

json和pickle的区别

  • json，用于json字符串 和 字典数据类型进行转换

  • pickle，用于python中所有类型数据的文本化，持久化

pickle模块提供了四个功能：

dumps、dump(序列化，存）、loads（反序列化，读）、load  （不仅可以序列化字典，列表...可以把python中任意的数据类型序列化）

  • dumps(): 将python对象转换成字节数据
  • loads(): 将字节数据转换成python对象
  • dump(obj,文件句柄):将python对象转换成字节数据并写入文件，注意写入方式要用'wb'，而且不能指定编码。
  • load(文件句柄): 将文件中的字节数据读取出来并转换成python对象

注：dump,load有持久化特点，将代码存入文件永久保存。

# dumps(): 将对象（字典数据）转换成字节数据
dic = {'name': 'ryxiong', 'age': 18}
print(pickle.dumps(dic))  # b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x07\x00\x00\x00ryxiongq\x02X\x03\x00\x00\x00ageq\x03K\x12u.'

# loads(): 将字节数据的数据转换成对象（字典数据）
b = b'\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x07\x00\x00\x00ryxiongq\x02X\x03\x00\x00\x00ageq\x03K\x12u.'
print(pickle.loads(b))

# dump(obj,文件句柄):将对象（字典数据）转换成字节数据并写入文件，注意写入方式要用'wb'，而且不能指定编码。
pickle.dump(dic,open('pickle.txt', 'wb'))

# load(文件句柄): 将文件中的字节数据读取出来并转换成对象（字典数据）

data = pickle.load(open('pickle.txt','rb'))
print(data)

这时候机智的你又要说了，既然pickle如此强大，为什么还要学json呢？
这里我们要说明一下，json是一种所有的语言都可以识别的数据结构。
如果我们将一个字典或者序列化成了一个json存在文件里，那么java代码或者js代码也可以拿来用。
但是如果我们用pickle进行序列化，其他语言就不能读懂这是什么了～
所以，如果你序列化的内容是列表或者字典，我们非常推荐你使用json模块
但如果出于某种原因你不得不序列化其他的数据类型，而未来你还会用python对这个数据进行反序列化的话，那么就可以使用pickle。

shelve模块

shelve：返回类似字典的对象，可读可写，key必须是字符串，值可是任何类型

shelve只有一个方法：

  • open():返回类似字典的对象，可读可写，key必须是字符串，值可是任何类型
import shelve

f = shelve.open(r'shelve.txt')
f['name'] = 'ryxiong'
f['age'] = 26
f['hobby'] = {'hobby1':'prograhpy', 'hobby2':'reading'}
print(f['name'])
print(f['hobby'])
f.close()
# print(f['hobby'])  # 报错，文件已关闭，无法操作

# 注：如果遇到字典写不进去的问题，在open()参数中增加参数writeback=True。

f = shelve.open(r'shelve.txt',writeback=True)

三、常用模块（二）

1.logging模块

日志的作用：

 用来记录程序中的重要的操作，或者检测程序是否和预想一样执行

logging两种方法：函数式简单配置，logger对象配置

函数式简单配置

import logging  
logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message')

默认情况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG），默认的日志格式为日志级别：Logger名称：用户输出消息。

简单配置法缺点：

中文显示乱码
不能同时输出到文件和屏幕

灵活配置日志级别，日志格式，输出位置:

默认级别为warning，默认打印到终端

import logging  
logging.basicConfig(level=logging.DEBUG,  
                    format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',  
                    datefmt='%a, %d %b %Y %H:%M:%S',  
                    filename='/tmp/test.log',  
                    filemode='w')  
  
logging.debug('debug message')  
logging.info('info message')  
logging.warning('warning message')  
logging.error('error message')  
logging.critical('critical message')

为logging模块指定全局配置，针对所有logger有效，控制打印到文件中

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

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

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

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

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

 

logging.basicConfig()
配置参数

logger对象配置

'''
logger对象法

步骤：
    1.创建logger对象
    2.创建一个文件操作符
    3.创建一个屏幕操作符
    4.创建一个格式

    5.logger 绑定文件操作符
    6.logger 绑定屏幕操作符
    7.文件操作符 绑定格式
    8.屏幕操作符 绑定格式
'''
import logging

# 1.创建logger对象
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)

# 2.创建一个文件操作符
fh = logging.FileHandler('log',encoding='utf-8')

# 3.创建一个屏幕操作符
sh = logging.StreamHandler()

# 4.创建一个格式
fmt = logging.Formatter('%(asctime)s-%(name)s-%(levelname)s-%(message)s')

# 5.给logger绑定文件操作符
logger.addHandler(fh)

# 6.给logger绑定屏幕操作符
logger.addHandler(sh)

# 7.给文件操作符绑定格式
fh.setFormatter(fmt)

# 8.给屏幕操作符绑定格式
sh.setFormatter(fmt)


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

logging库提供了多个组件：Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口，Handler发送日志到适当的目的地，Filter提供了过滤日志信息的方法，Formatter指定日志显示格式。另外，可以通过：logger.setLevel(logging.Debug)设置级别,当然，也可以通过

fh.setLevel(logging.Debug)单对文件流设置某个级别。

logging模块的Formatter，Handler，Logger，Filter对象

#logger：产生日志的对象

#Filter：过滤日志的对象

#Handler：接收日志然后控制打印到不同的地方，FileHandler用来打印到文件中，StreamHandler用来打印到终端

#Formatter对象：可以定制不同的日志格式对象，然后绑定给不同的Handler对象使用，以此来控制不同的Handler的日志格式
'''
critical=50
error =40
warning =30
info = 20
debug =10
'''


import logging

#1、logger对象：负责产生日志，然后交给Filter过滤，然后交给不同的Handler输出
logger=logging.getLogger(__file__)

#2、Filter对象：不常用，略

#3、Handler对象：接收logger传来的日志，然后控制输出
h1=logging.FileHandler('t1.log') #打印到文件
h2=logging.FileHandler('t2.log') #打印到文件
h3=logging.StreamHandler() #打印到终端

#4、Formatter对象：日志格式
formmater1=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S %p',)

formmater2=logging.Formatter('%(asctime)s :  %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S %p',)

formmater3=logging.Formatter('%(name)s %(message)s',)


#5、为Handler对象绑定格式
h1.setFormatter(formmater1)
h2.setFormatter(formmater2)
h3.setFormatter(formmater3)

#6、将Handler添加给logger并设置日志级别
logger.addHandler(h1)
logger.addHandler(h2)
logger.addHandler(h3)
logger.setLevel(10)

#7、测试
logger.debug('debug')
logger.info('info')
logger.warning('warning')
logger.error('error')
logger.critical('critical')
区别

Logger与Handler的级别

logger是第一级过滤，然后才能到handler，我们可以给logger和handler同时设置level，但是需要注意的是

Logger is also the first to filter the message based on a level — if you set the logger to INFO, and all handlers to DEBUG, you still won't receive DEBUG messages on handlers — they'll be rejected by the logger itself. If you set logger to DEBUG, but all handlers to INFO, you won't receive any DEBUG messages either — because while the logger says "ok, process this", the handlers reject it (DEBUG < INFO).



#验证
import logging


form=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S %p',)

ch=logging.StreamHandler()

ch.setFormatter(form)
# ch.setLevel(10)
ch.setLevel(20)

l1=logging.getLogger('root')
# l1.setLevel(20)
l1.setLevel(10)
l1.addHandler(ch)

l1.debug('l1 debug')
重要，重要，重要！！！

Logger的继承（了解）

import logging

formatter=logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S %p',)

ch=logging.StreamHandler()
ch.setFormatter(formatter)


logger1=logging.getLogger('root')
logger2=logging.getLogger('root.child1')
logger3=logging.getLogger('root.child1.child2')


logger1.addHandler(ch)
logger2.addHandler(ch)
logger3.addHandler(ch)
logger1.setLevel(10)
logger2.setLevel(10)
logger3.setLevel(10)

logger1.debug('log1 debug')
logger2.debug('log2 debug')
logger3.debug('log3 debug')
'''
2017-07-28 22:22:05 PM - root - DEBUG -test:  log1 debug
2017-07-28 22:22:05 PM - root.child1 - DEBUG -test:  log2 debug
2017-07-28 22:22:05 PM - root.child1 - DEBUG -test:  log2 debug
2017-07-28 22:22:05 PM - root.child1.child2 - DEBUG -test:  log3 debug
2017-07-28 22:22:05 PM - root.child1.child2 - DEBUG -test:  log3 debug
2017-07-28 22:22:05 PM - root.child1.child2 - DEBUG -test:  log3 debug
'''
View Code

 应用

"""
logging配置
"""

import os
import logging.config

# 定义三种日志输出格式 开始

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 = '[%(levelname)s][%(asctime)s] %(message)s'

# 定义日志输出格式 结束

logfile_dir = os.path.dirname(os.path.abspath(__file__))  # log文件的目录

logfile_name = 'all2.log'  # log文件名

# 如果不存在定义的日志目录就创建一个
if not os.path.isdir(logfile_dir):
    os.mkdir(logfile_dir)

# log文件的全路径
logfile_path = os.path.join(logfile_dir, logfile_name)

# log配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
    },
    'filters': {},
    'handlers': {
        #打印到终端的日志
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        #打印到文件的日志,收集info及以上的日志
        'default': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': logfile_path,  # 日志文件
            'maxBytes': 1024*1024*5,  # 日志大小 5M
            'backupCount': 5,
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },
    },
    'loggers': {
        #logging.getLogger(__name__)拿到的logger配置
        '': {
            'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递
        },
    },
}


def load_my_logging_cfg():
    logging.config.dictConfig(LOGGING_DIC)  # 导入上面定义的logging配置
    logger = logging.getLogger(__name__)  # 生成一个log实例
    logger.info('It works!')  # 记录该文件的运行状态

if __name__ == '__main__':
    load_my_logging_cfg()
logging配置文件
"""
MyLogging Test
"""

import time
import logging
import my_logging  # 导入自定义的logging配置

logger = logging.getLogger(__name__)  # 生成logger实例


def demo():
    logger.debug("start range... time:{}".format(time.time()))
    logger.info("中文测试开始。。。")
    for i in range(10):
        logger.debug("i:{}".format(i))
        time.sleep(0.2)
    else:
        logger.debug("over range... time:{}".format(time.time()))
    logger.info("中文测试结束。。。")

if __name__ == "__main__":
    my_logging.load_my_logging_cfg()  # 在你程序文件的入口加载自定义logging配置
    demo()
使用
注意注意注意：


#1、有了上述方式我们的好处是：所有与logging模块有关的配置都写到字典中就可以了，更加清晰，方便管理


#2、我们需要解决的问题是：
    1、从字典加载配置：logging.config.dictConfig(settings.LOGGING_DIC)

    2、拿到logger对象来产生日志
    logger对象都是配置到字典的loggers 键对应的子字典中的
    按照我们对logging模块的理解，要想获取某个东西都是通过名字，也就是key来获取的
    于是我们要获取不同的logger对象就是
    logger=logging.getLogger('loggers子字典的key名')

    
    但问题是：如果我们想要不同logger名的logger对象都共用一段配置，那么肯定不能在loggers子字典中定义n个key   
 'loggers': {    
        'l1': {
            'handlers': ['default', 'console'],  #
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递
        },
        'l2: {
            'handlers': ['default', 'console' ], 
            'level': 'DEBUG',
            'propagate': False,  # 向上（更高level的logger）传递
        },
        'l3': {
            'handlers': ['default', 'console'],  #
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递
        },

}

    
#我们的解决方式是，定义一个空的key
    'loggers': {
        '': {
            'handlers': ['default', 'console'], 
            'level': 'DEBUG',
            'propagate': True, 
        },

}

这样我们再取logger对象时
logging.getLogger(__name__)，不同的文件__name__不同，这保证了打印日志时标识信息不同，但是拿着该名字去loggers里找key名时却发现找不到，于是默认使用key=''的配置
!!!关于如何拿到logger对象的详细解释！！！

2.configparser模块

使用类似键值对套键值对的方式在文件中储存数据。文件是一个大字典，每一块是字典的键，每一块下面的键值对又是一个字典，作为每一个块的值。

配置文件样式如下

# 注释1
# 注释2

[section1]
k1 = v1
k2:v2
user=egon
age=18
is_admin=true
salary=31

[section2]
k1 = v1

读取操作

import configparser

config=configparser.ConfigParser()
config.read('a.cfg')

#查看所有的标题
res=config.sections() #['section1', 'section2']
print(res)

#查看标题section1下所有key=value的key
options=config.options('section1')
print(options) #['k1', 'k2', 'user', 'age', 'is_admin', 'salary']

#查看标题section1下所有key=value的(key,value)格式
item_list=config.items('section1')
print(item_list) #[('k1', 'v1'), ('k2', 'v2'), ('user', 'egon'), ('age', '18'), ('is_admin', 'true'), ('salary', '31')]

#查看标题section1下user的值=>字符串格式
val=config.get('section1','user')
print(val) #egon

#查看标题section1下age的值=>整数格式
val1=config.getint('section1','age')
print(val1) #18

#查看标题section1下is_admin的值=>布尔值格式
val2=config.getboolean('section1','is_admin')
print(val2) #True

#查看标题section1下salary的值=>浮点型格式
val3=config.getfloat('section1','salary')
print(val3) #31.0

写入操作

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',18) #报错,必须是字符串


#最后将修改的内容写入文件,完成最终的修改
config.write(open('a.cfg','w'))
import configparser
  
config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '45',
                      'Compression': 'yes',
                     'CompressionLevel': '9'}
  
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
config['DEFAULT']['ForwardX11'] = 'yes'
with open('example.ini', 'w') as configfile:
   config.write(configfile)
练习：基于上述方法添加一个ini文档

3.hashlib模块

'''概念'''
1、什么叫hash:hash是一种算法（3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法），该算法接受传入的内容，经过运算得到一串hash值
2、hash值的特点是：
    只要传入的内容一样，得到的hash值必然一样=====>要用明文传输密码文件完整性校验
    不能由hash值返解成内容=======》把密码做成hash值，不应该在网络传输明文密码
    只要使用的hash算法不变，无论校验的内容有多大，得到的hash值长度是固定的

hash算法就像一座工厂，工厂接收你送来的原材料（可以用m.update()为工厂运送原材料），经过加工返回的产品就是hash值

md5和sha的区别：

md5:速度快，但是现在容易被破解
sha:密文长，更安全，但是速度慢

'''
md5加密
'''
import hashlib

m = hashlib.md5()  # m=hashlib.sha256()
# 选择加密方式，获取一个加密对象
print(m)  # <md5 HASH object @ 0x000001F0F0807558>

m.update('hello'.encode('utf-8'))  # 将明文转成字节然后加密
print(m.hexdigest())  # 5d41402abc4b2a76b9719d911017c592
普通加密

注意：把一段很长的数据update多次，与一次update这段长数据，得到的结果一样
但是update多次为校验大文件提供了可能。

以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密。

'''
md5加密+加盐
'''
m1 = hashlib.md5('盐'.encode('utf-8'))  # 这一步相当于给密码加盐
m1.update('passwd'.encode('utf-8'))

'''
256加密
'''
sha = hashlib.sha256('hello'.encode('utf-8'))  # 这一步相当于给密码加盐

sha.update('alex'.encode('utf-8'))
print(sha.hexdigest())
加盐的加密
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))
模拟撞库破解密码

python 还有一个 hmac 模块，它内部对我们创建 key 和 内容 进行进一步的处理然后再加密:

import hmac
h = hmac.new('alvin'.encode('utf8'))
h.update('hello'.encode('utf8'))
print (h.hexdigest())#320df9832eab4c038b6c1d7ed73a5940
#要想保证hmac最终结果一致，必须保证：
#1:hmac.new括号内指定的初始key一样
#2:无论update多少次，校验的内容累加到一起是一样的内容

import hmac

h1=hmac.new(b'egon')
h1.update(b'hello')
h1.update(b'world')
print(h1.hexdigest())

h2=hmac.new(b'egon')
h2.update(b'helloworld')
print(h2.hexdigest())

h3=hmac.new(b'egonhelloworld')
print(h3.hexdigest())

'''
f1bf38d054691688f89dcd34ac3c27f2
f1bf38d054691688f89dcd34ac3c27f2
bcca84edd9eeb86f30539922b28f3981
'''
注意！注意！注意

4.suprocess模块

import  subprocess

'''
sh-3.2# ls /Users/egon/Desktop |grep txt$
mysql.txt
tt.txt
事物.txt
'''

res1=subprocess.Popen('ls /Users/jieli/Desktop',shell=True,stdout=subprocess.PIPE)
res=subprocess.Popen('grep txt$',shell=True,stdin=res1.stdout,
                 stdout=subprocess.PIPE)

print(res.stdout.read().decode('utf-8'))


#等同于上面,但是上面的优势在于,一个数据流可以和另外一个数据流交互,可以通过爬虫得到结果然后交给grep
res1=subprocess.Popen('ls /Users/jieli/Desktop |grep txt$',shell=True,stdout=subprocess.PIPE)
print(res1.stdout.read().decode('utf-8'))


#windows下:
# dir | findstr 'test*'
# dir | findstr 'txt$'
import subprocess
res1=subprocess.Popen(r'dir C:\Users\Administrator\PycharmProjects\test\函数备课',shell=True,stdout=subprocess.PIPE)
res=subprocess.Popen('findstr test*',shell=True,stdin=res1.stdout,
                 stdout=subprocess.PIPE)

print(res.stdout.read().decode('gbk')) #subprocess使用当前系统默认编码，得到结果为bytes类型，在windows下需要用gbk解码
posted @ 2019-03-29 19:45  ryxiong728  阅读(824)  评论(0)  编辑  收藏  举报