20 Python 常用模块

 1.time和datetime模块

1.时间模块(time)

表示时间的三种方式:

  1.时间戳(timestamp)

  2.格式化的时间字符串(Format String) 

  3.元组(结构化) (struct time)

1.时间戳:

time.sleep()  #使程序滞留一段时间,该时间以 秒 为单位。
time.time()  #时间戳, 即 记录某个时间点

2.格式化时间字符串的各种参数用法:如下

图片 1图片 2

%y 两位数的年份表示(00-99)
%Y 四位数的年份表示(000-9999)
%m 月份(01-12)
%d 月内中的一天(0-31)
%H 24小时制小时数(0-23)
%I 12小时制小时数(01-12)
%M 分钟数(00=59)
%S 秒(00-59)
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天(001-366)
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数(00-53)星期天为星期的开始
%w 星期(0-6),星期天为星期的开始
%W 一年中的星期数(00-53)星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身


print(time.strftime('%Y.%m.%d %X'))
print(time.strftime('%Y.%m.%d %x'))
print(time.strftime('%y%m%d %H%M%S '))
print(time.strftime('%y%m%d %I%M%S %a'))
print(time.strftime('%y%m%d %I%M%S %A'))
print(time.strftime('%y%m%d %I%M%S %A %b'))
print(time.strftime('%y%m%d %I%M%S %A %B'))
print(time.strftime('%y%m%d %I%M%S %A %B %c'))
print(time.strftime('%y%m%d %I%M%S %A %B %c %j'))
print(time.strftime('%y%m%d %I%M%S %A %B %c %j %p'))
print(time.strftime('%y%m%d %I%M%S %A %B %c %j %p %U'))
print(time.strftime('%y%m%d %I%M%S %A %B %c %j %p %U %w'))
print(time.strftime('%y%m%d %I%M%S %A %B %c %j %p %U %W'))
print(time.strftime('%y%m%d %I%M%S %A %B %c %j %p %U %W %Z'))




结果:
2017.08.08 18:51:58
2017.08.08 08/08/17
170808 185158 
170808 065158 Tue
170808 065158 Tuesday
170808 065158 Tuesday Aug
170808 065158 Tuesday August
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017 220
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017 220 PM
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017 220 PM 32
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017 220 PM 32 2
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017 220 PM 32 32
170808 065158 Tuesday August Tue Aug  8 18:51:58 2017 220 PM 32 32 ?D1¨²¡À¨º¡Á?¨º¡À??

View Code

3.元组(结构化):struct_time元组共有9个元素共九个元素:(年,月,日,时,分,秒,一年中第几周,一年中第几天等)

图片 3

m = time.localtime()   #类似命名元组  用于计算比对。
print(m)
print(m.tm_year)

结果:

time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=18, tm_min=54, tm_sec=21, tm_wday=1, tm_yday=220, tm_isdst=0)
2017

Process finished with exit code 0

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

三种格式之间的转换:

  1.时间戳(timestamp)

  2.格式化的时间字符串(Format String) 

  3.元组(结构化) (struct time)

图片 4

图片 5图片 6

#时间戳  转  结构化    和      结构化 转  时间戳
print(time.gmtime())   #伦敦时间
print(time.localtime()) #北京时间
s = time.gmtime(1500000000) #时间戳  转  结构化
d = time.localtime(1500000000) #时间戳  转  结构化
print(s)
print(d)
print(time.mktime(s))   #结构化 转  时间戳
print(time.mktime(d))  #结构化 转  时间戳

结果:
time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=11, tm_min=26, tm_sec=54, tm_wday=1, tm_yday=220, tm_isdst=0)

time.struct_time(tm_year=2017, tm_mon=8, tm_mday=8, tm_hour=19, tm_min=26, tm_sec=54, tm_wday=1, tm_yday=220, tm_isdst=0)

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

1499971200.0
1500000000.0

Process finished with exit code 0

#结构化  转  字符串    和   字符串  转   结构化
print(time.strftime('%Y%m%d %X'))  #结构化转 字符串
print(time.strptime('2017-03-16','%Y-%m-%d'))   #字符串  转   结构化

结果:
20170808 19:29:32
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)

Process finished with exit code 0

View Code

OrderedDict

  使用dict时,Key是无序的。在对dict做迭代时,我们无法确定Key的顺序。

  如果要保持Key的顺序,可以用OrderedDict

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

图片 7图片 8

 1 from collections import OrderedDict
 2 
 3 d = dict([('a', 2), ('c', 4), ('b', 6)])
 4 # dict的key是无序的
 5 print(d)
 6 
 7 od = OrderedDict([('a', 1), ('c', 3), ('b', 5)])
 8 # OrderedDict的key是有序的
 9 print(od)
10 
11 od['z'] = 6
12 od['y'] = 7
13 od['x'] = 8
14 print(od.keys())  # 按照插入的Key的顺序返回
15 
16 
17 {'a': 2, 'c': 4, 'b': 6}
18 OrderedDict([('a', 1), ('c', 3), ('b', 5)])
19 odict_keys(['a', 'c', 'b', 'z', 'y', 'x'])

OrderedDict

5.序列化模块 

序列化

把对象(变量)从内存中变成可存储或传输的过程称之为序列化,在Python中叫pickling,在其他语言中也被称之为serialization,marshalling,flattening等等,都是一个意思。

序列化目的

  • 持续化某种状态。在断电或者关机之前可以将当前内存中所有的数据保存下来,下次程序运行时可以从当前保存的文件内容继续执行。
  • 跨平台数据交互。

序列化有三个模块json和pickle,shelve

  json   所有编程语言都通用的序列化格式,但是它支持的数据类型非常有限(只支持数字,字符串,序列,字典等,不支持元祖

  pickle  只能在python语言的程序之间传递数据使用,它支持python中所有数据类型

  shelve  在py3之后才有,python专有的序列化模块,只针对文件。它只提供一个open方法,并且只能用字典形式访问内容

json

 Json模块提供了四个功能:dumps、loads,这两个只在内存中操作数据,主要在网络传输中使用,和多个数据类型与文件打交道

             dump、load
,这两个是直接将对象序列化之后写入文件,它依赖于一个文件句柄

import json
dic={'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic) #将字典转换成字符串,转换后的字典中的元素是由双引号表示的
print(str_dic,type(str_dic))#{"k1": "v1", "k2": "v2", "k3": "v3"} <class 'str'>

dic2 = json.loads(str_dic)#将一个字符串转换成字典类型
print(dic2,type(dic2))#{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'} <class 'dict'>

import json
dic={'k1':'v1','k2':'v2','k3':'v3'}
f = open('a.txt','w',encoding='utf-8')
json.dump(dic,f,ensure_ascii=False)  # 先接收要序列化的对象 再接受文件句柄
f.close()

f = open('a.txt','r',encoding='utf-8')
ret = json.load(f)
print(type(ret),ret)

 # json在写入多次dump的时候,不能对应执行多次load来去除数据,pickle可以

#
json如果要写入多个元素,应先将元素dumps序列化,再f.write(序列化+‘n’)写入文件。读的时候先按行读取,再使用loads将读出来的字符串转换成相应数据类型。

pickle(可以把python中的任意数据类型序列化)

  在硬盘上存储文件有很多种方法,文本文件只是其中一种,如果想存储列表或者对象之类的内容,可以把对象转换成字符串的形式写入文本文件,但是如果要从文件中回复对象,则这个就复杂化了。而python提供的pickle恰好能做到这一点:

# 通过pickle存储python原生对象:
import pickle
D = {'a': 1, 'b': 2}
F = open('datafile.pkl', 'wb')
pickle.dump(D, F)       # pickle.dump()可以把任意对象序列化成一个bytes,然后就可以把bytes写入文件
F.close()

# 取回字典,再用pickle模块中load函数进行一次重建
F = open('datafile.pkl', 'rb')
E = pickle.load(F)
F.close()


import pickle
file = 'wish.data'
lis = ['apple', 'banban']
f = open(file, 'wb')
pickle.dump(lis, f)
f.close()

del lis
f = open(file, 'rb')
storedlis = pickle.load(f)
print(storedlis)    # 又得到了列表

关于序列化自定义类的对象:

class A:
    def __init__(self,name,age):
        self.name=name
        self.age=age
a = A('luffy',18)
# import json
# json.dumps(a)   # 报错,说明json无法存储实例化对象
import pickle
ret = pickle.dumps(a)
print(ret)   # 打印出来的是一串字节
obj = pickle.loads(ret)
print(obj)    # 打印出对象地址
print(obj.__dict__)   # {'name': 'luffy', 'age': 18}

在load的时候,必须拥有被load数据类型对应的类在内存里面

shelve(用法专讲链接)

  python专有的序列化模块,只针对文件,只提供了一个open方法,且是用key来访问的,使用起来和字典类似。

import shelve
f = shelve.open('a.txt')
f['key'] = {'int': 10, 'float': 9.5, 'string': 'Sample data'}
f['ds'] = '范围分为we分我发'
f.close()
# 直接对文件句柄进行操作,就可以存储文件,而且程序会给我们自动创建三个后缀为dir,bak,dat的文件,其中以bat结尾的文件存储的就是b字节数据类型的数据

f1 = shelve.open('a.txt')
a = f1['ds']   # 用key直接取出存储的内容,如果key不存在则会报错
f1.close()
print(a)

# 设置只读模式
f2 = shelve.open('a.txt', flag='r')
f2['key']['float'] = 3.14    # 修改结构中得值,不可以
f2['space'] = 'dwd'          # 覆盖原来的结构,可以
f1.close()

f3 = shelve.open('a.txt')
b = f3['key']['float']       # 对结构的值作修改,但是失败了
f3.close()
print(b)    # 9.5

  4.os模块

                      时间模块                                                                                           

  表示时间的三种方式

    在Python中,通常有这三种方式来表示时间:时间戳、元组(struct_time)、格式化的时间字符串:

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

    (2)格式化的时间字符串(Format String): ‘1999-12-06’

图片 9

%y 两位数的年份表示(00-99)
%Y 四位数的年份表示(000-9999)
%m 月份(01-12)
%d 月内中的一天(0-31)
%H 24小时制小时数(0-23)
%I 12小时制小时数(01-12)
%M 分钟数(00=59)
%S 秒(00-59)
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天(001-366)
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数(00-53)星期天为星期的开始
%w 星期(0-6),星期天为星期的开始
%W 一年中的星期数(00-53)星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

    (3)元组(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

 

图片 10图片 11

 1 import time
 2 # time.sleep(10)
 3 # 时间戳
 4 print(time.time())
 5 
 6 # 时间串
 7 print(time.strftime('%Y-%m-%d %H:%M:%S'))
 8 print(time.strftime('%A'))
 9 print(time.strftime('%a'))
10 print(time.strftime('%x'))
11 print(time.strftime('%c'))
12 
13 # 时间元祖
14 print(time.localtime())
15 
16 
17 1510645831.6729546
18 2017-11-14 15:50:31
19 Tuesday
20 Tue
21 11/14/17
22 Tue Nov 14 15:50:31 2017
23 time.struct_time(tm_year=2017, tm_mon=11, tm_mday=14, tm_hour=15, tm_min=50, tm_sec=31, tm_wday=1, tm_yday=318, tm_isdst=0)

View Code

 

几种格式之间的转换

图片 12

图片 13

图片 14图片 15

 1 # 时间元祖
 2 print(time.localtime(1500000000))  # 时间戳转换时间元祖
 3 print(time.gmtime(1200000000))  # 英国时间
 4 print(time.mktime(time.localtime(1500000000)))  # 时间元祖转换时间戳
 5 
 6 print(time.strftime('%Y-%m-%d', time.localtime(1500000000)))  # 时间元祖转换时间串
 7 print(time.strptime("2017-08-03", '%Y-%m-%d'))  # 时间串转换时间元祖
 8 print(time.strptime('2018/05/12', '%Y/%m/%d'))
 9 
10 print(time.asctime(time.localtime(2000000000)))  # 时间元祖转换时间串
11 print(time.ctime())
12 print(time.ctime(1600000000))  # 时间戳转换时间串

练习

图片 16图片 17

1 import time
2 true_time=time.mktime(time.strptime('2017-09-11 08:30:00','%Y-%m-%d %H:%M:%S'))
3 time_now=time.mktime(time.strptime('2017-09-12 11:00:00','%Y-%m-%d %H:%M:%S'))
4 dif_time=time_now-true_time
5 struct_time=time.gmtime(dif_time)
6 print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,
7                                        struct_time.tm_mday-1,struct_time.tm_hour,
8                                        struct_time.tm_min,struct_time.tm_sec))

计算时间差

 

sys模块

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

sys.argv           命令行参数List,第一个元素是程序本身路径
sys.exit(n)        退出程序,正常退出时exit(0),错误退出sys.exit(1)
sys.version        获取Python解释程序的版本信息
sys.path           返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

图片 18图片 19

 1 import sys
 2 print(sys.platform)
 3 print(sys.version)
 4 print(sys.path)
 5 print(sys.argv)
 6 print(sys.exit())
 7 
 8 
 9 win32
10 3.6.1 (v3.6.1:69c0db5, Mar 21 2017, 18:41:36) [MSC v.1900 64 bit (AMD64)]
11 ['C:\Users\panhw\Desktop\学习文档\python\day19作业', 'C:\Users\panhw\Desktop\学习文档\python', 'C:\Users\panhw\AppData\Local\Programs\Python\Python36\python36.zip', 'C:\Users\panhw\AppData\Local\Programs\Python\Python36\DLLs', 'C:\Users\panhw\AppData\Local\Programs\Python\Python36\lib', 'C:\Users\panhw\AppData\Local\Programs\Python\Python36', 'C:\Users\panhw\AppData\Local\Programs\Python\Python36\lib\site-packages']
12 ['C:/Users/panhw/Desktop/学习文档/python/day19作业/作业.py']

View Code

random模块

 

图片 20图片 21

 1 import random
 2 
 3 # 随机小数
 4 print(random.random())  # 随机生成0到1之间的小数
 5 print(random.uniform(1, 10))  # 随机获取n到m之间的小数
 6 
 7 # 0.11930423761507436
 8 # 9.136906780912456
 9 
10 # 随机整数
11 print(random.randint(1, 5))  # 随机生成n到m之间的整数
12 print(random.randrange(10))  # 随机获取0到m之间的整数
13 print(random.randrange(2, 10))  # 随机生成n到m之间的整数
14 print(random.randrange(3, 15, 3))  # 随机生成n到m之间的整数 n的倍数
15 
16 # 2
17 # 4
18 # 5
19 # 6
20 
21 # 随机选择序列的一个元素返回
22 print(random.choice(['a', 'b', 3, 4, 5, 8, 'v']))
23 # 随机返回选择序列的多个元素 返回的个数为取决于第二个参数
24 print(random.sample(['a', 'b', 3, 4, 5, 8, 'v'], 3))
25 
26 # a
27 # ['a', 'b', 3]
28 
29 # 打乱原列表的顺序
30 item = [1, 2, 4, 5, 6, 7]
31 print(item)
32 random.shuffle(item)
33 print(item)
34 
35 # [1, 2, 4, 5, 6, 7]
36 # [1, 2, 4, 5, 6, 7]

View Code

图片 22图片 23

 1 import random
 2 
 3 
 4 def verify(n=6):
 5     """
 6     随机验证码
 7     :param n: 验证码个数 (int)
 8     :return: 返回验证码 (str)
 9     """
10     li = []
11     for i in range(n):
12         num = str(random.randint(0, 9))  # 随机整数转字符串
13         alpha = chr(random.randint(65, 90))  # 大写字母 ASCII
14         alpha2 = chr(random.randint(97, 122))  # 小写字母 ASCII
15         ret = random.choice([num, alpha, alpha2])  # 随机选择一个
16         li.append(ret)
17     return ''.join(li)  # 列表转字符串
18 
19 print(verify(8))

随机验证码

os模块

 os模块是与操作系统交互的一个接口

 

图片 24图片 25

 1 import os
 2 # 和系统路径相关
 3 print(os.getcwd())  # 获取当前工作目录,即当前python脚本工作的目录路径os.chdir('C:\Users')  # 改变当前脚本工作目录;相当于shell下cd
 4 print(os.getcwd())
 5 print(os.curdir)  # 返回当前目录: ('.')
 6 print(os.pardir)  # 获取当前目录的父目录字符串名:('..')
 7 
 8 
 9 # 和系统文件或文件夹相关的
10 os.mkdir('name1')  # 生成单级目录;相当于shell中mkdir dirname
11 os.makedirs('name1/name2')  # 可生成多层递归目录
12 os.rmdir('name1/name2')  # 删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
13 os.removedirs(r'C:UserspanhwDesktop学习文档pythonday20name1name2')  # 若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
14 print(os.listdir(r'C:UserspanhwDesktop学习文档pythonday20name1'))  # 列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
15 os.remove(r'C:UserspanhwDesktop学习文档pythonday4.py')  # 删除一个文件
16 os.rename(r'name3/name4', 'name3/name')  # 重命名文件/目录
17 
18 
19 # 和操作系统特征相关
20 print(os.stat(r'C:UserspanhwDesktop学习文档pythonday4.py'))  # 获取文件/目录信息
21 print(os.sep)  # 输出操作系统特定的路径分隔符,win下为"\",Linux下为"/"
22 print(os.linesep)  # 输出当前平台使用的行终止符,win下为"tn",Linux下为"n"
23 print(os.pathsep)  # 输出用于分割文件路径的字符串 win下为;,Linux下为:
24 print(os.name)  # 输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
25 print(os.environ)  # 获取系统环境变量
26 
27 
28 # 和操作系统命令相关
29 print(os.system('dir'))  # 运行shell命令,直接显示
30 ret = os.popen('dir')  # 运行shell命令,获取执行结果
31 print(ret.read())
32 
33 
34 # 和系统路径相关
35 print(os.path)
36 print(os.path.abspath('name3'))  # 返回path规范化的绝对路径 os.path.split(path) 将path分割成目录和文件名二元组返回
37 print(os.path.dirname(r'C:UserspanhwDesktop学习文档pythonday20name3'))  # 返回path的目录。其实就是os.path.split(path)的第一个元素
38 print(os.path.split(r'C:UserspanhwDesktop学习文档pythonday20name3'))  # 返回path最后的文件名。如何path以/或结尾,那么就会返回空值。
39 print(os.path.basename(r'C:UserspanhwDesktop学习文档pythonday20name3'))  # 即os.path.split(path)的第二个元素
40 print(os.path.exists(r'C:UserspanhwDesktop学习文档pythonday9.py'))  #  如果path存在,返回True;如果path不存在,返回False
41 print(os.path.isabs(r'C:UserspanhwDesktop学习文档pythonday9.py'))  # 如果path是绝对路径,返回True
42 print(os.path.isfile(r'C:UserspanhwDesktop学习文档pythonday9.py'))  # 如果path是一个存在的文件,返回True。否则返回False
43 print(os.path.isdir(r'C:UserspanhwDesktop学习文档pythonday9.py'))  # 如果path是一个存在的目录,则返回True。否则返回False
44 print(os.path.join(r'C:UserspanhwDesktop', '学习文档', 'python', 'day9.py'))  # 将多个路径组合后返回,第一个绝对路径之前的参数将被忽略
45 print(os.path.getsize(r'C:UserspanhwDesktop学习文档pythonday9.py'))  # 返回path的大小
46 print(os.path.getatime(r'C:UserspanhwDesktop学习文档pythonday9.py'))  # 返回path所指向的文件或者目录的最后访问时间
47 print(os.path.getmtime(r'C:UserspanhwDesktop学习文档pythonday9.py'))  # 返回path所指向的文件或者目录的最后修改时间

View Code

 

 

注意: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)是创建时间(详细信息参见平台的文档)。

 

序列化模块

 

 

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

 

  序列化的目的

 

    1、以某种存储形式使自定义对象持久化;

 

    2、将对象从一个地方传递到另一个地方。

 

    3、使程序更具维护性。

 

图片 26

 

 

6.hashlib模块

4.sys模块:

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

sys.argv           命令行参数List,第一个元素是程序本身路径
sys.exit(n)        退出程序,正常退出时exit(0)
sys.version        获取Python解释程序的版本信息
sys.maxint         最大的Int值
sys.path           返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

Counter

 

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

图片 27图片 28

1 from collections import Counter
2 c = Counter('hello')
3 c1 = Counter({'a': 4, 'b': 2})
4 c2 = Counter(a=4, b=6)
5 print(c1)
6 print(c)
7 print(c2)

Counter

  当所访问的键不存在时,返回0,而不是KeyError;否则返回它的计数。

图片 29图片 30

1 from collections import Counter
2 c = Counter('abcdefgab')
3 print(c['a'])
4 print(c['h'])
5 print(c['d'])
6 
7 2
8 0
9 1

计数值的访问

  可以使用一个iterable对象或者另一个Counter对象来更新键值。

  计数器的更新包括增加和减少两种。其中,增加使用update()方法和减少则使用subtract()方法

图片 31图片 32

 1 from collections import Counter
 2 c = Counter('which')
 3 c.update('witch')
 4 print(c['h'])
 5 
 6 d = Counter('watch')
 7 c.update(d)
 8 print(c['h'])
 9 
10 c = Counter('which')
11 c.subtract('witch')
12 print(c['h'])
13 
14 d = Counter('watch')
15 c.subtract(d)
16 print(c['a'])
17 
18 
19 3
20 4
21 1
22 -1

View Code

 

使用模块好处:

  提高了代码的可维护性。

  当一个模块编写完毕,就可以被其他地方引用。

  使用模块可以避免函数名和变量名冲突。

3.OS模块

 

'''
os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录;相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名:('..')
os.makedirs('dirname1/dirname2')    可生成多层递归目录
os.removedirs('dirname1')    若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
os.mkdir('dirname')    生成单级目录;相当于shell中mkdir dirname
os.rmdir('dirname')    删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
os.listdir('dirname')    列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
os.remove()  删除一个文件
os.rename("oldname","newname")  重命名文件/目录
os.stat('path/filename')  获取文件/目录信息
os.sep    输出操作系统特定的路径分隔符,win下为"\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符,win下为"tn",Linux下为"n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令,直接显示
os.popen("bash command)  运行shell命令,获取执行结果
os.environ  获取系统环境变量

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的大小
'''

json

 

  Json模块提供了四个功能:dumps、dump、loads、load

 

图片 33图片 34

 1 import json
 2 dic = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3', 'k4': 'v4'}
 3 str_dic = json.dumps(dic)  # 序列化:将一个字典转换成一个字符串
 4 print(str_dic, type(str_dic))
 5 # 注意,json转换完的字符串类型的字典中的字符串是由""表示的
 6 
 7 dic2 = json.loads(str_dic)  # 反序列化:将一个字符串格式的字典转换成一个字典
 8 print(dic2, type(dic2))
 9 #注意,要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
10 
11 list_dic = [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]
12 str_dic = json.dumps(list_dic)  # 也可以处理嵌套的数据类型
13 print(type(str_dic), str_dic)
14 
15 list_dic2 = json.loads(str_dic)
16 print(type(list_dic2), list_dic2)

dumps/loads

 

图片 35图片 36

 1 import json
 2 f = open('json_file', 'w', encoding='utf8')
 3 dic = {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
 4 json.dump(dic, f)  # dump方法接收一个文件句柄,直接将字典转换成json字符串写入文件
 5 f.close()
 6 
 7 f = open('json_file')
 8 dic2 = json.load(f)  # load方法接收一个文件句柄,直接将文件中的json字符串转换成数据结构返回
 9 f.close()
10 print(type(dic2), dic2)

dump/load

图片 37图片 38

 1 import json
 2 f = open('file', 'w', encoding='utf8')
 3 json.dump({'国籍': '中国'}, f)
 4 ret = json.dumps({'国籍': '中国'})
 5 f.write(ret + 'n')
 6 
 7 json.dump({'国籍': '美国'}, f, ensure_ascii=False)
 8 ret = json.dumps({'国籍': '美国'}, ensure_ascii=False)
 9 f.write(ret + 'n')
10 f.close()

View Code

 2. random模块

  1.时间模块 (time)

算法介绍

Python的hashlib提供了常见的摘要算法,如MD5,SHA1等等。

什么是摘要算法呢?摘要算法又称哈希算法、散列算法。它通过一个函数,把任意长度的数据转换为一个长度固定的数据串(通常用16进制的字符串表示)。

摘要算法就是通过摘要函数f()对任意长度的数据data计算出固定长度的摘要digest,目的是为了发现原始数据是否被人篡改过。

摘要算法之所以能指出数据是否被篡改过,就是因为摘要函数是一个单向函数,计算f(data)很容易,但通过digest反推data却非常困难。而且,对原始数据做一个bit的修改,都会导致计算出的摘要完全不同。

我们以常见的摘要算法MD5为例,计算出一个字符串的MD5值:

图片 39图片 40

1 import hashlib
2  
3 md5 = hashlib.md5()
4 md5.update('how to use md5 in python hashlib?')
5 print md5.hexdigest()
6 
7 计算结果如下:
8 d26a53750bc40b38b65a520292f69306

md5

如果数据量很大,可以分块多次调用update(),最后计算的结果是一样的:

图片 41图片 42

1 import hashlib
2  
3 sha1 = hashlib.sha1()
4 sha1.update('how to use sha1 in ')
5 sha1.update('python hashlib?')
6 print sha1.hexdigest()

分组MD5

SHA1的结果是160
bit字节,通常用一个40位的16进制字符串表示。比SHA1更安全的算法是SHA256和SHA512,不过越安全的算法越慢,而且摘要长度更长。

7.configparser

5.序列化模块:

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

序列化的目的

1、以某种存储形式使自定义对象持久化;

2、将对象从一个地方传递到另一个地方。

3、使程序更具维护性。

图片 26

json:

  Json模块提供了四个功能:dumps、dump、loads、load

图片 44图片 45

import json
d = {'k':1}
ret1= json.dumps(d)   #字典转字符串
print(ret1,type(ret1))
ret2= json.loads(ret1)   #字符串转字典
print(ret2,type(ret2))

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

f = open('json_file')
dic2 = json.load(f)   #load方法接收一个文件句柄,直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)

结果:
{"k": 1} <class 'str'>
{'k': 1} <class 'dict'>
{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

Process finished with exit code 0

View Code

pickle:

用于序列化的两个模块

 

  • json,用于字符串 和 python数据类型间进行转换
  • pickle,用于python特有的类型 和 python的数据类型间进行转换

 

pickle模块提供了四个功能:dumps、dump(序列化,存)、loads(反序列化,读)、load
 (不仅可以序列化字典,列表…可以把python中任意的数据类型序列化

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

shelve:

shelve也是python提供给我们的序列化工具,比pickle用起来更简单一些。
shelve只提供给我们一个open方法,是用key来访问的,使用起来和字典类似。

图片 46图片 47

import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}  #直接对文件句柄操作,就可以存入数据
f.close()

import shelve
f1 = shelve.open('shelve_file')
existing = f1['key']  #取出数据的时候也只需要直接用key获取即可,但是如果key不存在会报错
f1.close()
print(existing)

View Code

这个模块有个限制,它不支持多个应用同一时间往同一个DB进行写操作。所以当我们知道我们的应用如果只进行读操作,我们可以让shelve通过只读方式打开DB

图片 48图片 49

import shelve
f = shelve.open('shelve_file', flag='r')
existing = f['key']
f.close()
print(existing)

View Code

由于shelve在默认情况下是不会记录待持久化对象的任何修改的,所以我们在shelve.open()时候需要修改默认参数,否则对象的修改不会保存。

图片 50图片 51

import shelve
f1 = shelve.open('shelve_file')
print(f1['key'])
f1['key']['new_value'] = 'this was not here before'
f1.close()

f2 = shelve.open('shelve_file', writeback=True)
print(f2['key'])
f2['key']['new_value'] = 'this was not here before'
f2.close()

View Code

writeback方式有优点也有缺点。优点是减少了我们出错的概率,并且让对象的持久化对用户更加的透明了;但这种方式并不是所有的情况下都需要,首先,使用writeback以后,shelf在open()的时候会增加额外的内存消耗,并且当DB在close()的时候会将缓存中的每一个对象都写入到DB,这也会带来额外的等待时间。因为shelve没有办法知道缓存中哪些对象修改了,哪些对象没有修改,因此所有的对象都会被写入。

 

浅拷贝copy

浅拷贝copy

>>> c = Counter("abcdcba")
>>> c
Counter({'a': 2, 'c': 2, 'b': 2, 'd': 1})
>>> d = c.copy()
>>> d
Counter({'a': 2, 'c': 2, 'b': 2, 'd': 1})

 

3. OS模块(是与操作系统交互的一个接口)

#
有的文件可能转义可能会出现问题,一般要在双引号前加r,取消转义,或者用双斜杠表示

# 和当前执行的python文件工作目录相关的工作路径
os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径
os.chdir("dirname")  改变当前脚本工作目录;相当于shell下cd
os.curdir  返回当前目录: ('.')
os.pardir  获取当前目录的父目录字符串名:('..')

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

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

# 和操作系统差异相关
os.sep    输出操作系统特定的路径分隔符,win下为"\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符,win下为"tn",Linux下为"n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'

# 和执行系统命令相关
os.system("bash command")   运行shell命令,直接显示,但是显示的看不懂

 os.popen(“bash
command).read() 
运行shell命令,获取执行结果,可看懂,如os.popen(‘dir’).read()

os.environ 获取系统环境变量

# 路径相关系列
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的大小,文件夹的大小不准确,只显示最大值4096字节,文件准确

ret = os.path.join('F:每天视频以及笔记','day5视频')
print(ret)
---F:每天视频以及笔记day5视频    # 组合成一个完整路径

考虑如何计算文件夹中所有文件大小?示例路径:F:每天视频以及笔记python11期day01

图片 52图片 53

import os
def ram(file_name):
    sum = 0
    for file in os.listdir(file_name):
        path = os.path.join(file_name, file)  # 组合成一个完整路径
        if os.path.isfile(path):   # 路径下是文件
            sum += os.path.getsize(path)
        else:
            sum += ram(path)
    return sum

print(ram('F:每天视频以及笔记python11期day01'))

采用递归思想

图片 54图片 55

import os
def get_size(path):
    l = [path]
    sum_size = 0
    while l:
        path = l.pop()    # l = ['D:python11day2','D:python11day3'...]
        for item in os.listdir(path):    #path = 'D:python11'
            path2 = os.path.join(path, item)   # path2 = 'D:python11day2'
            if os.path.isfile(path2):
                sum_size += os.path.getsize(path2)   # sum = 文件的大小 + 0
            else:                           
                l.append(path2)
    return sum_size
print(get_size('D:python11'))

栈的思想

  #
复制文件的函数在os模块中并不存在,因为复制文件并非由操作系统提供的系统调用。但是我们可以调用shuti模块中的copyfile()实现,该模块相当于os模块的一个补充。

今日内容:

摘要算法应用

任何允许用户登录的网站都会存储用户登录的用户名和口令。如何存储用户名和口令呢?方法是存到数据库表中:

name    | password
--------+----------
michael | 123456
bob     | abc999
alice   | alice2008

如果以明文保存用户口令,如果数据库泄露,所有用户的口令就落入黑客的手里。此外,网站运维人员是可以访问数据库的,也就是能获取到所有用户的口令。正确的保存口令的方式是不存储用户的明文口令,而是存储用户口令的摘要,比如MD5:

username | password
---------+---------------------------------
michael  | e10adc3949ba59abbe56e057f20f883e
bob      | 878ef96e86145580c38c87f0410ad153
alice    | 99b1c2188db85afee403b1536010c2c9

考虑这么个情况,很多用户喜欢用123456,888888,password这些简单的口令,于是,黑客可以事先计算出这些常用口令的MD5值,得到一个反推表:

'e10adc3949ba59abbe56e057f20f883e': '123456'
'21218cca77804d2ba1922c33e0151105': '888888'
'5f4dcc3b5aa765d61d8327deb882cf99': 'password'

这样,无需破解,只需要对比数据库的MD5,黑客就获得了使用常用口令的用户账号。

对于用户来讲,当然不要使用过于简单的口令。但是,我们能否在程序设计上对简单口令加强保护呢?

由于常用口令的MD5值很容易被计算出来,所以,要确保存储的用户口令不是那些已经被计算出来的常用口令的MD5,这一方法通过对原始口令加一个复杂字符串来实现,俗称“加盐”:

hashlib.md5("salt".encode("utf8"))

经过Salt处理的MD5口令,只要Salt不被黑客知道,即使用户输入简单口令,也很难通过MD5反推明文口令。

但是如果有两个用户都使用了相同的简单口令比如123456,在数据库中,将存储两条相同的MD5值,这说明这两个用户的口令是一样的。有没有办法让使用相同口令的用户存储不同的MD5呢?

如果假定用户无法修改登录名,就可以通过把登录名作为Salt的一部分来计算MD5,从而实现相同口令的用户也存储不同的MD5。

摘要算法在很多地方都有广泛的应用。要注意摘要算法不是加密算法,不能用于加密(因为无法通过摘要反推明文),只能用于防篡改,但是它的单向计算特性决定了可以在不存储明文口令的情况下验证用户口令。

 

logging模块

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website