python比较实用的模块_python常用模块

python常用模块

一 collection

python 常用 数据类型 :整型 浮点型 字符串 列表 字典 集合 元组 布尔值

具名元祖 namedtuple

from collections import namedtuple

point=namedtuple('坐标' , ['x','y','z'] ) 或者 point =namedtuple (' x' 'y' 'z')

注意的是元素个数必须跟namedtuple 第二个参数的值数量一致

print(p,p.x ,p.y ,p.z)

用具名元组来记录一个城市的信息

>>> from collections import namedtuple

>>> City = namedtuple('City', 'name country population coordinates') # 第一个是类名，第二个是类的各个字段的名字。后者可以是由数个字符串组成的可迭代对象，或者是由空格分隔开的字段名组成的字符串

>>> tokyo = City('Tokyo', 'JP', 36.933, (35.689722, 139.691667))

>>> tokyo

City(name='Tokyo', country='JP', population=36.933, coordinates=(35.689722, 139.691667))

>>> tokyo.population

36.933

>>> tokyo.coordinates

(35.689722, 139.691667)

>>> tokyo[1]

'JP'

队列 先进先出 (FIFO first in first out )

import queue

q= queue.Queue

q.put('first')

q.put('second')

q.get()

q.get()

双端队列

deque

from collections import deque:

dq=queue(['a','b','c'])

apend apendleft

pop popleft

dq.insert(1,'插入值') 双端队列的特殊点在于可以任意位置插入值

deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：

>>> from collections import deque

>>> q = deque(['a', 'b', 'c'])

>>> q.append('x')

>>> q.appendleft('y')

>>> q

deque(['y', 'a', 'b', 'c', 'x'])

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

有序字典

OrderedDict

from collections import OrderedDict

od=OrderedDict([(1,1),(2,2),(3,3)])

OrderedDict的key会按照插入的顺序排序 而不是元素的本身的排序

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

>>> 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本身排序：

>>> od = OrderedDict()

>>> od['z'] = 1

>>> od['y'] = 2

>>> od['x'] = 3

>>> od.keys() # 按照插入的Key的顺序返回

['z', 'y', 'x']

默认值字典

defauldict

使用原生dict时 如果引用的key不存在 就会抛出keyERRoR 错误 如果希望key不存在是 返回一个默认值 就可以用defaultdict

from collections import defaultdict

dd=defaultdict(lambda : 'n/a')

dd['k1']='abc'

dd['k1'] 返回abc

dd['k2'] 返回'n/a'

计数器

Counter

追踪容器中值出现的个数 ,是一个无序容器 类型,以字典的键值对 的方式储存 ,其中 元素作为key 技术作为value

技术值可以包括0和负数 类似于bags multisets

import collections

c=collections.Counter('sssasaaad')

print(c)

Counter({'s': 4, 'a': 4, 'd': 1})

二丶 time模块:

主要内容

时间戳

线程推迟 time.sleep(secs)

格式化时间

结构化时间

import time

time.time()

time.strftime('%Y-%m*%d %H:%M:%S') 年月日 时分秒

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

格式多变 链接符号任意

time.localtime() 当地时间

datatime.datatime.today()

#时间元组: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'

import time

true_time=time.mktime(time.strptime('2017-09-11 08:30:00','%Y-%m-%d %H:%M:%S'))

time_now=time.mktime(time.strptime('2017-09-12 11:00:00','%Y-%m-%d %H:%M:%S'))

dif_time=time_now-true_time

struct_time=time.gmtime(dif_time)

print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,

struct_time.tm_mday-1,struct_time.tm_hour,

struct_time.tm_min,struct_time.tm_sec))

datetime模块

import datetime

# 自定义日期

res = datetime.date(2019, 7, 15)

print(res) # 2019-07-15

# 获取本地时间

# 年月日

now_date = datetime.date.today()

print(now_date) # 2019-07-01

# 年月日时分秒

now_time = datetime.datetime.today()

print(now_time) # 2019-07-01 17:46:08.214170

# 无论是年月日，还是年月日时分秒对象都可以调用以下方法获取针对性的数据

# 以datetime对象举例

print(now_time.year) # 获取年份2019

print(now_time.month) # 获取月份7

print(now_time.day) # 获取日1

print(now_time.weekday()) # 获取星期(weekday星期是0-6) 0表示周一

print(now_time.isoweekday()) # 获取星期(weekday星期是1-7) 1表示周一

# timedelta对象

# 可以对时间进行运算操作

import datetime

# 获得本地日期 年月日

tday = datetime.date.today()

# 定义操作时间 day=7 也就是可以对另一个时间对象加7天或者减少7点

tdelta = datetime.timedelta(days=7)

# 打印今天的日期

print('今天的日期:{}'.format(tday)) # 2019-07-01

# 打印七天后的日期

print('从今天向后推7天:{}'.format(tday + tdelta)) # 2019-07-08

# 总结:日期对象与timedelta之间的关系

"""

日期对象 = 日期对象 +/- timedelta对象

timedelta对象 = 日期对象 +/- 日期对象

验证:

"""

# 定义日期对象

now_date1 = datetime.date.today()

# 定义timedelta对象

lta = datetime.timedelta(days=6)

now_date2 = now_date1 + lta # 日期对象 = 日期对象 +/- timedelta对象

print(type(now_date2)) #

lta2 = now_date1 - now_date2 # timedelta对象 = 日期对象 +/- 日期对象

print(type(lta2)) #

# 小练习 计算举例今年过生日还有多少天

birthday = datetime.date(2019, 12, 21)

now_date = datetime.date.today()

days = birthday - now_date

print('生日：{}'.format(birthday))

print('今天的日期：{}'.format(tday))

print('距离生日还有{}天'.format(days))

# 总结年月日时分秒及时区问题

import datetime

dt_today = datetime.datetime.today()

dt_now = datetime.datetime.now()

dt_utcnow = datetime.datetime.utcnow() # UTC时间与我们的北京时间cha ju

print(dt_today)

print(dt_now)

print(dt_utcnow

三 丶随机数模块

random

import random

random.random (0-1的小数)

random.randint(1,6) 随机1-6的整数

random.randrange(1,10,2)1-10之间的奇数

random.choice () 随机返回一个

random.sample([1,2,3,['as'],2]) 随机返回包含任意元素2个的列表

random.shuffle 打乱次序

五 丶os模块

与操作系统交互的模块

import os

BASE_DIR=os.path.dirname(__file__)

DATA_DIR=os.path.join(BASE_DIR,'data数据')

DATA_list=os.listdir(DATA_DIR)

os.remove()

os.rename()

os.replace()

os.getcwd() 切换当前目录

os.path.getsize() 获取文件大小

os.rmdir() 删除空文件夹

os.path.isfile() 是否是文件

os.path.exists( ) 是否 存在

六丶 sys 模块

与python解释器交互的模块

import sys

sys.argv 用来在命令行启动文件是 校验 使用者身份

[ (路径) , (用户名) ,(密码) ] 自己设定的 字典键值对

七丶 序列化模块

简单的来说 序列化 就是 将其他的数据类型转换成 字符串的的过程

原因在于 不论是硬盘写入 还是网络传输 都只能传输2进制的格式的数据 ,

而且 我们编程的时候 只有字符串可以编译为二进制 ,所以要对数据进行字符串处理

反序列化 字符串转成其他数据类型

jason模块 通用数据类型之一 字符串 列表 字典 整型 元组(转成列表) 布尔值只能支持这几种

import json

json.dumps()loads( ) 与dump 与load比起来 dump需要输入文件句柄参数

dumps loads 可以直接操作常用数据类型

load不能够多次对一个文件反序列化

pickle模块 python自己支持的所有数据类型 不能跨平台

通用4个方法 用pickle时 必须是使用B模式 既只能是二进制

load反序列化 dump序列化 loads反序列化 dumps 序列化

time.localtime() 当地时间

datatime.datatime.today()

三 丶随机数模块

random

import random

random.random (0-1的小数)

random.randint(1,6) 随机1-6的整数

random.randrange(1,10,2)1-10之间的奇数

random.choice () 随机返回一个

random.sample([1,2,3,['as'],2]) 随机返回包含任意元素2个的列表

random.shuffle 打乱次序

五 丶os模块

与操作系统交互的模块

import os

BASE_DIR=os.path.dirname(__file__)

DATA_DIR=os.path.join(BASE_DIR,'data数据')

DATA_list=os.listdir(DATA_DIR)

os.remove()

os.rename()

os.replace()

os.getcwd() 切换当前目录

os.path.getsize() 获取文件大小

os.rmdir() 删除空文件夹

os.path.isfile() 是否是文件

os.path.exists( ) 是否 存在

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

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.system("bash command") 运行shell命令，直接显示

os.popen("bash command).read() 运行shell命令，获取执行结果

os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径

os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd

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

六丶 sys 模块

与python解释器交互的模块

import sys

sys.argv 用来在命令行启动文件是 校验 使用者身份

[ (路径) , (用户名) ,(密码) ] 自己设定的 字典键值对

sys.argv 命令行参数List，第一个元素是程序本身路径

sys.exit(n) 退出程序，正常退出时exit(0),错误退出sys.exit(1)

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

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

sys.platform 返回操作系统平台名称

七丶 序列化模块

持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。

序列化使其他代码可以查看或修改，那些不序列化便无法访问的对象实例数据。确切地说，代码执行序列化需要特殊的权限：

即指定了 SerializationFormatter 标志的 SecurityPermission。在默认策略下，通过 Internet 下载的代码或 Internet 代码不会授予该权限；只有本地计算机上的代码才被授予该权限。

通常，对象实例的所有字段都会被序列化，这意味着数据会被表示为实例的序列化数据。这样，能够解释该格式的代码有可能能够确定这些数据的值，而不依赖于该成员的可访问性。

类似地，反序列化从序列化的表示形式中提取数据，并直接设置对象状态，这也与可访问性规则无关。

对于任何可能包含重要的安全性数据的对象，如果可能，应该使该对象不可序列化。如果它必须为可序列化的，请尝试生成特定字段来保存不可序列化的重要数据。

如果无法实现这一点，则应注意该数据会被公开给任何拥有序列化权限的代码，并确保不让任何恶意代码获得该权限。

简单的来说 序列化 就是 将其他的数据类型转换成 字符串的的过程

原因在于 不论是硬盘写入 还是网络传输 都只能传输2进制的格式的数据 ,

而且 我们编程的时候 只有字符串可以编译为二进制 ,所以要对数据进行字符串处理

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

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

3、使程序更具维护性

反序列化 字符串转成其他数据类型

jason模块 通用数据类型之一 字符串 列表 字典 整型 元组(转成列表) 布尔值只能支持这几种

import json

json.dumps()loads( ) 与dump 与load比起来 dump需要输入文件句柄参数

dumps loads 可以直接操作常用数据类型

load不能够多次对一个文件反序列化

pickle模块 python自己支持的所有数据类型 不能跨平台

通用4个方法 用pickle时 必须是使用B模式 既只能是二进制

load反序列化 dump序列化 loads反序列化 dumps 序列化