模块

一，时间有关的模块

（一）time模块

#常用方法
1.time.sleep(secs)
(线程)推迟指定的时间运行。单位为秒。
2.time.time()
获取当前时间戳

表示时间的三种方式

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

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

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

%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个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）

#导入时间模块
import time

#时间戳
print(time.time())
#1553068478.1886806

#时间字符串
print(time.strftime('%Y-%m-%d %X'))
#2019-03-20 15:54:38
print(time.strftime("%Y-%m-%d %H-%M-%S"))
#2019-03-20 15-54-38

#时间元组:localtime将一个时间戳转换为当前时区的struct_time
print(time.localtime())
#time.struct_time(tm_year=2019, tm_mon=3, tm_mday=20, tm_hour=15, tm_min=54, tm_sec=38, tm_wday=2, tm_yday=79, tm_isdst=0)

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

几种格式之间的转换

.

t = '2019-03-20 10:40:00'
# 这个时间向后退一个月
# 1.转成结构化
f = time.strptime(t,'%Y-%m-%d %X')
# 2.结构化时间转成时间戳
ts = time.mktime(f)
# 3.将时间戳向大变
new_ts = ts + 86400 * 31
# 4.将最新的时间戳转成结构化时间
new_f = time.localtime(new_ts)
# 5.将结构化时间转成字符串时间
print(time.strftime('%Y-%m-%d %X',new_f))

# 获取当前时间求前一月的现在时间
# 1.获取时间戳进行减法计算
new_ts = time.time() - 28*86400
# 2.最新的时间戳转成结构化时间
new_f = time.localtime(new_ts)
# 3.将结构化时间转成字符串时间
print(time.strftime('%Y-%m-%d %X',new_f))
#
# time.strftime()

#结构化时间 --> %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 %d %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' 

t = time.time()
ft = time.ctime(t)
print(ft)

st = time.localtime()
ft = time.asctime(st)
print(ft)

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模块

获取当前日期和时间

from datetime import datetime
print(datetime.now())

#2019-03-20 16:06:02.520754  #毫秒

注意:datetime是模块，datetime模块还包含一个datetime的类，通过from datetime import datetime导入的才是datetime这个类。

如果仅导入import datetime，则必须引用全名datetime.datetime。

datetime.now()返回当前日期和时间，其类型是datetime。

datetime转换为timestamp(时间戳)  

from datetime import datetime

dt = datetime.now()
new_timestamp = dt.timestamp()
print(new_timestamp)

timestamp转换为datetime

import time
from datetime import datetime

new_timestamp = time.time()
print(datetime.fromtimestamp(new_timestamp))

str转换为datetime

from datetime import datetime

t = datetime.strptime('2019-3-20 00:00','%Y-%m-%d %H:%M')
print(t)

datetime转换为str

from datetime import datetime
now = datetime.now()
print(now.strftime('%a, %b %d %H:%M'))

#Wed, Mar 20 19:47

datetime加减

from datetime import datetime, timedelta
now = datetime.now()
print(now)
now1 = now + timedelta(hours=10)
print(now1)
now2 = now - timedelta(days=1)
print(now2)
now3 = now + timedelta(days=2, hours=12)
print(now3)

二、collections模块

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

1.namedtuple: 生成可以使用名字来访问元素内容的tuple

2.deque: 双端队列，可以快速的从另外一侧追加和推出对象

3.Counter: 计数器，主要用来计数

4.OrderedDict: 有序字典

5.defaultdict: 带有默认值的字典

Counter

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

from collections import Counter
c = Counter('adfasdfasdfasdfasdfasdf')
print(c)

#Counter({'a': 6, 'd': 6, 'f': 6, 's': 5})

namedtuple

命名元组

from collections import namedtuple

tu = namedtuple('juge',['name','age','sex','hobby'])
t = tu('腚哥',19,'待定','抽烟,喝酒,烫头')
print(t)      #juge(name='腚哥', age=19, sex='待定', hobby='抽烟,喝酒,烫头')
print(t[2])   #待定

deque

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

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

from collections import deque

d = deque([1,2,3,4])
d.append(5)      #右边添加
print(d)         #deque([1, 2, 3, 4, 5])
d.appendleft(10) # 左边添加
print(d)         #deque([10, 1, 2, 3, 4, 5])
d.insert(2,99)
print(d)         #deque([10, 1, 99, 2, 3, 4, 5])
d.remove(3)
print(d)
print(d.pop())       #5
print(d)             #deque([10, 1, 99, 2, 4])
print(d.popleft())   #10
print(d)             #deque([1, 99, 2, 4])

defaultdict 

from collections import defaultdict

li = [
    {'name':'alex','hobby':'抽烟'},
    {'name':'alex','hobby':'喝酒'},
    {'name':'alex','hobby':'烫头'},
    {'name':'alex','hobby':'撩妹'},
    {'name':'wusir','hobby':'小宝剑'},
    {'name':'wusir','hobby':'游泳'},
    {'name':'wusir','hobby':'打牌'},
    {'name':'太白','hobby':'烫头'},
    {'name':'太白','hobby':'洗脚'},
    {'name':'太白','hobby':'开车'},
]
d = defaultdict(list)
for i in li:
    d[i['name']].append(i['hobby'])
print([dict(d)])

#[{'alex': ['抽烟', '喝酒', '烫头', '撩妹'], 'wusir': ['小宝剑', '游泳', '打牌'], '太白': ['烫头', '洗脚', '开车']}]