内置模块

1.容器元素模块---collections

1 Counter--计数器
 Counter是dict的子类，用于计数**可哈希对象**。它是一个无序的容器，元素被存储为字典键，它们的计数被存储为字典值。计数允许包括零或负计数的任何整数值

方法
dict的子类所有字典支持的方法都支持(除了fromkeys 和update,这两个工作方式和计数器不同),并且还支持其他的三种新方法
Counter.most_common(n) 返回计数最多的n个元素,,列表套元组形式,
counter.elements() 返回一个迭代器，对元素重复迭代其计数次。元素以随机顺序返回。如果元素的计数小于1，elements()将忽略它。
subtract([iterable-or-mapping]) 从一个可迭代对象或从另一个映射（或计数器）中减去元素。类似dict.update()，但减去计数，而不是替换它们。输入和输出都可以为零或负。

几个数学运算被提供以组合Counter对象来产生multisets（计数器大于零的计数器）。加法和减法通过相加或相减相应元素的计数来组合计数器。交集和并集返回相应计数的最小值和最大值。每个操作的输入都可以接受带有符号的计数，但输出将排除计数为零或更少的结果。
>>> c = Counter(a=3, b=1)
>>> d = Counter(a=1, b=2)
>>> c + d                       # add two counters together:  c[x] + d[x]
Counter({'a': 4, 'b': 3})
>>> c - d                       # subtract (keeping only positive counts)
Counter({'a': 2})
>>> c & d                       # intersection:  min(c[x], d[x]) 
Counter({'a': 1, 'b': 1})
>>> c | d                       # union:  max(c[x], d[x])
Counter({'a': 3, 'b': 2})

使用计数器对象的常见模式：

sum(c.values())                 # total of all counts
c.clear()                       # reset all counts
list(c)                         # list unique elements
set(c)                          # convert to a set
dict(c)                         # convert to a regular dictionary
c.items()                       # convert to a list of (elem, cnt) pairs
Counter(dict(list_of_pairs))    # convert from a list of (elem, cnt) pairs
c.most_common()[:-n-1:-1]       # n least common elements
+c                              # remove zero and negative counts

2 namedtuple 命名元组
命名元组赋予元组中的每个位置一定的含义，允许更具可读性、自带文档的代码。它们可以用作常规元组可以使用的任何地方，并且它们添加能够按名称而不是位置索引字段的能力。
collections.namedtuple(typename, field_names, verbose=False, rename=False)
返回一个叫做typename的新的元组子类。这个新的子类用来创建类元组对象，这个对象拥有可以通过属性访问的字段，并且可以通过下标索引和迭代。这个子类的实例还拥有十分友好的文档字符串（包括类型名和字段名）和十分好用的__repr__() 方法，以name=value的方式列出了元组中的内容。

tu = namedtuple("test",["x","y","c","a"])  # 定义一个命名元组类
tu1 = tu(12,23,45,56)  # 实例化一个 命名元组
print(tu1) #打印查看
print(tu1[0],tu1.x) # 命名元组内元素可按索引或.name取值

3 deque ---双向队列
一个能在“队列”两端快速出队、入队的，类似于队列的（list-like）的容器 (译者注:就是双向队列)
拥有列表的所有操作,并且添加了在左侧操作的方法,添加了rotate方法

s="asdfhgfgasdawefadca"
d1= deque(s)
print(d1)
d1.popleft()
print(d1)
d1.rotate(3)
print(d1)
d1.rotate(-5)
print(d1)

4defaultdict 调用一个工厂函数来为dict的values缺失提供值
使用示例

使用list作为default_factory，可以很容易地将一系列键值对分组为一个值为列表字典：
>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> d = defaultdict(list)
>>> for k, v in s:
...     d[k].append(v)
...
>>> sorted(d.items())
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]

当每个键第一次遇到时，它不在映射中；因此使用返回空list的default_factory函数自动创建一个条目。然后，list.append()操作将值附加到新列表。当再次遇到这个键时，查找正常继续（返回该键的列表），并且list.append()操作向列表中添加另一个值。这种技术比使用等效的dict.setdefault()技术更简单和更快：

2 时间模块

# print(datetime.now())  #2019-03-20 11:35:25.(471359)毫秒
# 时间对象

# f = datetime.timestamp(datetime.now())  # 将时间对象转换成时间戳
# print(datetime.fromtimestamp(f))        # 将时间戳转成时间对象


# print(datetime.strptime('2018-11-30','%Y-%m-%d'))
# # 将字符串转成时间对象
# f = datetime.now()
# print(datetime.strftime(f,'%Y-%m-%d'))
# 将时间对象转成字符串

from datetime import datetime,timedelta  # 从xx导入 建议
print(datetime.now() - timedelta())
# 这个是datetime的精华

3 #time 模块

import time
# print(time.time()) # 浮点型(小数)  给计算机看 计算
# 三种:
# 时间戳 time.tiem
# 结构化时间 修改
# 字符串时间 给人看的

# print(time.localtime())
# 命名元组 :time.struct_time(tm_year=2019, tm_mon=3, tm_mday=20, tm_hour=10,
# tm_min=21, tm_sec=36, tm_wday=2, tm_yday=79, tm_isdst=0)

# print(time.strftime('%Y-%m-%d %X'))
# print(time.strftime('%Y-%m-%d %H:%M:%S'))
# 字符串时间

# 1.先转换成结构化时间
# 2.结构化转成字符串

# print(time.localtime(time.time()))
# f = time.localtime(time.time() - 86000 * 3)  # 150000000 秒  86000
# print(time.strftime('%Y-%m-%d %H:%M:%S',f))
# print(time.strftime('%Y-%m-%d %X',f))

# '2018-11-30 12:30'

# print(type(time.strftime('%Y-%m-%d %X')))

# f = time.strptime('2018-11-30 12:30','%Y-%m-%d %H:%M')
# # 支持索引 和.点的方法
# new_time = time.mktime(f) + 2*3600
# new_t = time.localtime(new_time)
# print(time.strftime('%Y-%m-%d %H:%M:%S',new_t))

# 时间戳 -- 结构化时间
# 结构化时间 -- 字符串时间

# 字符串时间 -- 结构化时间
# 结构化时间 -- 时间戳
# f = time.localtime()
# print(time.strftime('%X %Y-%m-%d',f))


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 * 30
# # 4.将最新的时间戳转成结构化时间
# new_f = time.localtime(new_ts)
# # 5.将结构化时间转成字符串时间
# print(time.strftime('%Y-%m-%d %X',new_f))

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

# time.strftime()

# 总结:
#     6个
#       时间戳 -- 结构化   1    ****
#       结构化 -- 时间戳   1    ****
#       结构化 -- 字符串   1    ****
#       字符串 -- 结构化   1    ****
#       # time.time()     1 # 获取当前时间戳
#       # strftime()      1 # 获取当前字符串时间

# strftime('格式','结构化时间')  # 格式可以少写
# strptime('字符串时间','格式')  # 格式一一对应