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 序列化






















































转载于:https://www.cnblogs.com/Sunbreaker/p/11209727.html

你可能感兴趣的:(python常用模块)