PS:Python之所以自称“batteries included”，就是因为内置了许多非常有用的模块，无需额外安装和配置，即可直接使用。下面就来看看一些常用的内建模块。

参考原文

datetime

　　dateime是Python中处理日期和时间的标准库。

获取当前日期和时间

>>> from datetime import datetime

>>> now = datetime.now() # 获取当前的时间

>>> print(now)

2018-05-06 18:18:41.431549

>>> print(type(now))

<class 'datetime.datetime'>

　　注意：datetime是模块，datetime模块还包含一个datetime类，通过from datetime import datetime导入的才是datetime这个类。 如果仅导入import datetime，则必须引用全名datetime.datetime。 datetime.now()返回当前日期和时间，其类型是datetime。

获取指定日期和时间

　　要指定某个日期和时间，我们直接用参数构造一个datetime：

>>> from datetime import datetime

>>> dt = datetime(2015, 4, 19, 12, 20) #用指定日期时间创建一个datetime

>>> print(dt)

2015-04-19 12:20:00

datetime转换为timestamp

　　在计算机中，时间实际上是用数字表示的。我们把1970年1月1日 00:00:00 UTC+00:00时区的时刻称为epoch time，记为（1970年以前的时间timestamp为负数），当前时间就是相对于epoch time的秒数，称为timestamp。

　　注意：timestamp的值与时区毫无关系，因为timestamp一旦确定，其UTC时间就确定了，转换到任意时区的时间也是完全确定的，这就是为什么计算机存储的当前时间是以timestamp表示的，因为全球各地的计算机在任意时刻的timestamp都是完全相同的（假定时间已校准）。

　　把一个datetime类型转换为timestamp，只需要调用timestamp（）方法：

>>> from datetime import datetime

>>> dt = datetime(2015, 4, 19, 12, 20)

>>> dt.timestamp() #把datetime转换为timestamp

1429417200.0

Tips:Python的timestamp是一个浮点数。如果有小数位，小数位表示毫秒数。某些编程语言（如Java和JavaScript）的timestamp使用整数表示毫秒数，这种情况下只需要把timestamp除以1000就得到Python的浮点表示方法。

timestamp转换为datetime

　　要把timestamp转换为datetime，使用datetime提供的fromtimestamp()方法：

>>> from datetime import datetime

>>> t = 1429417200.0

>>> print(datetime.fromtimestamp(t))

2015-04-19 12:20:00

　　这转换出来的是本地时间，可以使用utcfromtimestamp()方法转化成UTC时间：

>>> t = 1429417200.0

>>> print(datetime.utcfromtimestamp(t))

2015-04-19 04:20:00

str转换为datetime

　　我们知道用户输入的日期和时间是字符串，要处理日期和时间，首先必须把str转换为datetime。转换方法是datetime.strptime()。需要一个日期和时间的格式化字符串：

>>> from datetime import datetime

>>> cday = datetime.strptime('2015-6-1 18:19:59', '%Y-%m-%d %H:%M:%S')

>>> print(cday)

2015-06-01 18:19:59

　　字符串'%Y-%m-%d %H:%M:%S'规定了日期和时间部分的格式。详细的说明请参考Python文档。

datetime转换为str

　　如果已经有了datetime对象，要把它格式化为字符串显示给用户，就需要转换为str，转换方法是通过strftime()实现的，同样需要一个日期和时间的格式化字符串：

>>> from datetime import datetime

>>> now = datetime.now()

>>> print(now.strftime('%a, %b %d %H:%M'))

Sun, May 06 21:54

datetime加减

　　对日期和时间进行加减实际上就是把datetime往后或往前计算，得到新的datetime。加减可以直接用+和-运算符，不过需要导入timedelta这个类：

>>> from datetime import datetime, timedelta

>>> now = datetime.now()

>>> now

datetime.datetime(2018, 5, 7, 8, 39, 26, 14014)

>>> now + timedelta(hours=10)

datetime.datetime(2018, 5, 7, 18, 39, 26, 14014)

>>> pre = now - timedelta(days=2, hours=12)

>>> print(pre)

2018-05-04 20:39:26.014014

本地时间转换为UTC时间格式

　　利用datetime类型的时区属性tzinfo，但是默认为None，所以需要自己设置：

>>> from datetime import datetime, timedelta, timezone

>>> tz_utc_8 = timezone(timedelta(hours=8)) #创建时区UTC+8:00

>>> now = datetime.now()

>>> da = now.replace(tzinfo=tz_utc_8) #强制设置为UTC+8:00

>>> print(da)

2018-05-07 08:53:23.570143+08:00

时区转换

　　我们可以先通过utcnow()拿到当前的UTC时间，再转换为任意时区的时间：

>>> utc_dt = datetime.utcnow().replace(tzinfo=timezone.utc) #UTC：时区为0

>>> bj_dt = utc_dt.astimezone(timezone(timedelta(hours=8))) #北京时区

>>> print(bj_dt)

2018-05-07 09:06:54.443310+08:00

>>> tokyo_dt = utc_dt.astimezone(timezone(timedelta(hours=9))) #用utc_dt转换为东京时区

>>> print(tokyo_dt)

2018-05-07 10:06:54.443310+09:00

>>> tokyo_dt = bj_dt.astimezone(timezone(timedelta(hours=9))) #用bj_dt转换为东京时区

>>> print(tokyo_dt)

2018-05-07 10:06:54.443310+09:00

Tips:时区转换的关键在于，拿到一个datetime时，要获知其正确的时区，然后强制设置时区，作为基准时间。利用带时区的datetime，通过astimezone()方法，可以转换到任意时区。注：不是必须从UTC+0:00时区转换到其他时区，任何带时区的datetime都可以正确转换，例如上述bj_dt到tokyo_dt的转换。

　　小结：datetime表示的时间需要时区信息才能确定一个特定的时间，否则只能视为本地时间。如果要存储datetime，最佳方法是将其转换为timestamp再存储，因为timestamp的值与时区完全无关。

collections

　　collections是Python内建的一个集合模块，提供了许多有用的集合类。

namedtuple

　　我们知道tuple可以表示不变集合,于是我们可以利用namedtuple函数来创建一个自定义的tuple对象，并且规定了tuple元素的个数，并可以用属性而不是索引来引用tuple的某个元素。

>>> from collections import namedtuple

>>> Point = namedtuple('Point', ['x', 'y'])

>>> p = Point(1, 2)

>>> p.x

1

>>> p.y

2

　　注：创建出来的Point对象是tuple的一个子类，可以用isinstance()来验证。

deque

　　使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。 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()，这样就可以非常高效地往头部添加或删除元素。

defaultdict

　　使用dict时，如果引用的Key不存在，就会抛出KeyError。如果希望key不存在时，返回一个默认值，就可以用defaultdict：

>>> from collections import defaultdict

>>> dd = defaultdict(lambda: 'N/A')

>>> dd['k1'] = 'a'

>>> dd['k1']

'a'

>>> dd['k2']

'N/A'

OrderedDict

　　使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。 如果要保持Key的顺序（按照插入顺序），可以用OrderedDict：

>>> from collections import OrderedDict

>>> d = dict([('a', 1), ('b', 2), ('c', 3)])

>>> d  #dict是无序的

{'b': 2, 'a': 1, 'c': 3}

>>> od = OrderedDict([('a', 1), ('b', 2), (3, 'c')])

>>> od   #Ordered的Dict的key是有序的

OrderedDict([('a', 1), ('b', 2), (3, 'c')])

　　这样OrderedDict就可以实现一个FIFO（先进先出）的dict（类似队列)，当容量超出限制时，先删除最早添加的Key：

from collections import OrderedDict

class LastUpdateOrderedDict(OrderedDict):

    def __init__(self, capacity):

        super(LastUpdateOrderedDict,self).__init__() #调用父类

        self._capacity = capacity

    def __setitem__(self, key, value):

        containsKey = 1 if key in self else 0

        if len(self) - containsKey >= self._capacity:

            last = self.popitem(last=False)

            print('remove:', last)

        if containsKey:

            del self[key]  #delete previous

            print('set:', (key, value))

        else:

            print('add:', (key, value))

        OrderedDict.__setitem__(self, key, value)

Counter

　　Counter实际上也是dict的一个子类，是一个简单的计数器，例如，统计字符出现的个数：

>>> from collections import Counter

>>> c = Counter()

>>> for ch in 'Programming':

...     c[ch] = c[ch] + 1

...

>>> c

Counter({'m': 2, 'r': 2, 'g': 2, 'n': 1, 'o': 1, 'a': 1, 'i': 1, 'P': 1})

base64

　　Base64是一种用64个字符来表示任意二进制数据的方法。Base64编码会把3字节的二进制数据编码为4字节的文本数据，长度增加33%，好处是编码后的文本数据可以在邮件正文、网页等直接显示。

>>> import base64

>>> base64.b64encode(b'binary\x00string')

b'YmluYXJ5AHN0cmluZw=='

>>> base64.b64decode(b'YmluYXJ5AHN0cmluZw==')

b'binary\x00string'

struct

　　Python没有专门处理字节的数据类型。但由于b'str'可以表示字节，所以，字节数组＝二进制str。

　　struct的pack函数可以把任意数据类型变成bytes：　　

>>> import struct

>>> struct.pack('>I', 10240099)

b'\x00\x9c@c'

　　pack的第一个参数是处理指令，'>I'的意思是： >表示字节顺序是big-endian，也就是网络序，I表示4字节无符号整数。后面的参数个数要和处理指令一致。

　　unpack把bytes变成相应的数据类型：

>>> struct.unpack('>IH', b'\xf0\xf0\xf0\xf0\x80\x80')

(4042322160, 32896)

　　根据>IH的说明，后面的bytes依次变为I：4字节无符号整数和H：2字节无符号整数。所以，尽管Python不适合编写底层操作字节流的代码，但在对性能要求不高的地方，利用struct就方便多了。

巴特西

Python常用的内建模块