目录

• sys
• os
• re
• collections
• string
• time
• datetime
• threading

Python常用模块Top200

sys

This module provides access to some variables used or maintained by the interpreter and to functions that interact strongly with the interpreter.

sys模块用来访问由解释器使用或维护的变量和与解释器进行交互的函数。

sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，用于操控python的运行时环境。

sys常用属性/方法

• sys.argv

用于获取当前正在执行的命令行命令的参数列表(list)。

参考代码：

# encoding: utf-8
# filename: argv_test.py
import sys
# 获取脚本名字
print 'The name of this program is: %s' %(sys.argv[0])
# 获取参数列表
print 'The command line arguments are:'
for i in sys.argv:
    print i
# 统计参数个数
print 'There are %s arguments.'%(len(sys.argv)-1)

运行结果：

E:\p>python argv_test.py arg1 arg2 arg3
The name of this program is: argv_test.py
The command line arguments are:
argv_test.py
arg1
arg2
arg3
There are 3 arguments.

• sys.platform

获取当前执行环境的平台，win32表示Windows 32bit操作系统，linux2表示是linux平台。

# linux 
>>> import sys
>>> sys.platform
'linux2'

# windows
>>> import sys
>>> sys.platform
'win32'

• sys.path

目录列表，模块搜索路径。

>>>import sys
>>>sys.path
# 交互环境下sys.path第一个路径是一个空项，对应当前目录。
['', 
'C:\\Python\\Python36\\python36.zip', 
'C:\\Python\\Python36\\DLLs', 
'C:\\Python\\Python36\\lib', 
'C:\\Python\\Python36', 
'C:\\Python\\Python36\\lib\\site-packages', 
'C:\\Python\\Python36\\lib\\site-packages\\win32', 
'C:\\Python\\Python36\\lib\\site-packages\\win32\\lib', 
'C:\\Python\\Python36\\lib\\site-packages\\Pythonwin']

# foo.py
import sys
print(sys.path)

# 运行
E:\MyProjects\PycharmProjects\bao>python foo.py
['E:\\MyProjects\\PycharmProjects\\bao', 
'C:\\Python\\Python36\\python36.zip', 
'C:\\Python\\Python36\\DLLs', 
'C:\\Python\\Python36\\lib', 
'C:\\Python\\Python36', 
'C:\\Python\\Python36\\lib\\site-packages', 
'C:\\Python\\Python36\\lib\\site-packages\\win32', 
'C:\\Python\\Python36\\lib\\site-packages\\win32\\lib', 
'C:\\Python\\Python36\\lib\\site-packages\\Pythonwin']

• sys.builtin_module_names

返回一个tuple，包含内建模块的名字。

>>>import sys
>>>sys.builtin_module_names
('_ast', '_bisect', '_blake2', '_codecs', '_codecs_cn', '_codecs_hk', 
'_codecs_iso2022', '_codecs_jp', '_codecs_kr', '_codecs_tw', '_collections', 
'_csv', '_datetime', '_functools', '_heapq', '_imp', '_io', '_json', '_locale', 
'_lsprof', '_md5', '_multibytecodec', '_opcode', '_operator', '_pickle', 
'_random', '_sha1', '_sha256', '_sha3', '_sha512', '_signal', '_sre', '_stat', 
'_string', '_struct', '_symtable', '_thread', '_tracemalloc', '_warnings', 
'_weakref', '_winapi', 'array', 'atexit', 'audioop', 'binascii', 'builtins', 
'cmath', 'errno', 'faulthandler', 'gc', 'itertools', 'marshal', 'math', 'mmap', 
'msvcrt', 'nt', 'parser', 'sys', 'time', 'winreg', 'xxsubtype', 'zipimport', 'zlib')

代码示例：

# find_module.py
# encoding: utf-8

import sys
# print sys.builtin_module_names
def find_module(module):
    if module in sys.builtin_module_names:
        print module," => ","__builtin__"
    else:
        print module,"=> ",__import__(module).__file__

find_module('os')
find_module('sys')
find_module('strop')
find_module('zlib')
find_module('string')

# 运行结果：
os =>  E:\Python27\lib\os.pyc
sys  =>  __builtin__
strop  =>  __builtin__
zlib  =>  __builtin__
string =>  E:\Python27\lib\string.pyc

• sys.exit(n)

调用sys.exit(n)可以中途退出程序，当参数非0时，会引发一个SystemExit异常，从而可以在主程序中捕获该异常。

# encoding: utf-8
import sys
print 'running...'
try:
    sys.exit(1)
except SystemExit:
    print 'SystemExit exit 1'

print 'exited'

# 运行结果：
running...
SystemExit exit 1
exited

os

This module provides a portable way of using operating system dependent functionality.

os模块提供了一种方便的使用操作系统函数的方法。

os模块负责程序与操作系统的交互，提供了访问操作系统底层的接口。

os常用属性/方法

re

re模块下的函数

• compile(pattern)：创建模式对象

import re
pat = re.compile('A')
m = pat.search('CBA')
# 等价于re.search('A','CBA')

print m
<_sre.SRE_Match object at 0x9d690c8>
# 匹配到了，返回MatchObject（True）

m = pat.search('CBD')
print m
None
# 没有匹配到，返回None（False）

• search(pattern, string)：在字符串中寻找模式

m = re.search('asd','ASDasd')
print m
<_sre.SRE_Match object at 0xb72cd6e8>
# 匹配到了，返回MatchObject（True）
m = re.search('asd','ASDASD')
print m
None
# 没有匹配到，返回None（False）

• match(pattern, string)：在字符串开始处匹配模式

pat = re.compile('a')
print pat.match('Aasd')
None
print pat.match('aASD')
<_sre.SRE_Match object at 0xb72cd6e8>

# 上面的函数返回都可以在if条件语句中进行判断
if pat.match('asd'):
    print 'OK'

# 找到返回
OK

if re.search('a','ASD'):
    print "OK"

# 没有找到

• split(pattern, string)：根据模式分割字符串，返回列表

re.split(',','a,s,d,asd')
# 返回列表
['a', 's', 'd', 'asd']

pat = re.compile(',')
pat.split('a,s,d,asd')
# 返回列表
['a', 's', 'd', 'asd']

re.split('[, ]+','a ,  s  ,d     ,,,,,asd')
# 正则匹配：[, ]+
['a', 's', 'd', 'asd']

re.split('[, ]+','a ,  s  ,d     ,,,,,asd',maxsplit=2)
# maxsplit，最多分割次数
['a', 's', 'd     ,,,,,asd']

pat = re.compile('[, ]+')
# 正则匹配：[, ]+
pat.split('a ,  s  ,d     ,,,,,asd',maxsplit=2)
# maxsplit，最多分割次数
['a', 's', 'd     ,,,,,asd']

• findall(pattern, string)：列表形式返回所有匹配项

re.findall('a','ASDaDFGAa') 
['a', 'a']
# 列表形式返回匹配到的字符串

pat = re.compile('a')
pat.findall('ASDaDFGAa')
['a', 'a']
# 列表形式返回匹配到的字符串

pat = re.compile('[A-Z]+')
# 正则匹配：'[A-Z]+'
pat.findall('ASDcDFGAa')
['ASD', 'DFGA']
# 找到匹配到的字符串

pat = re.compile('[A-Z]')
pat.findall('ASDcDFGAa')
# 正则匹配：'[A-Z]'
['A', 'S', 'D', 'D', 'F', 'G', 'A']
# 找到匹配到的字符串

pat = re.compile('[A-Za-z]')
# 正则匹配：'[A-Za-z]'
pat.findall('ASDcDFGAa')
['A', 'S', 'D', 'c', 'D', 'F', 'G', 'A', 'a']

• sub(pat, repl, string)：用repl替换pat

re.sub('a', 'A', 'abcasd')
#找到a用A替换，下面见和group的配合使用
'AbcAsd'

pat = re.compile('a')
pat.sub('A', 'abcasd')
'AbcAsd'

pat = re.compile(r'www\.(.*)\..{3}')
# 在Python的string前面加上"r"，是为了告诉编译器这个string是raw string（原生字符串），不要转译反斜杠"\"。
# 例如，在raw string中，\n是两个字符，\和n，而不会被转译为换行符。
# 由于正则表达式和\会有冲突，因此，当一个字符串使用了正则表达式后，最好在前面加上'r'。

# 与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。
# 假如你需要匹配文本中的字符"\"，那么使用string表示的正则表达式里将需要4个反斜杠"\\\\"：
# 前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。
# Python里的“原生字符串”很好地解决了这个问题，"\\\\"可以使用r"\\"表示。
# 同样，匹配一个数字的"\\d"可以写成r"\d"。
# 有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。

# 并不是说加了"r"后"\"就没有转译功能，总之直接记住1句话：
# 当一个字符串使用了正则表达式后，最好在前面加上"r"，这样你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。
pat.match('www.dxy.com').group(1)
'dxy'

re.sub(r'www\.(.*)\..{3}', r'\1', 'hello,www.dxy.com')
'hello,dxy'

pat.sub(r'\1', 'hello,www.dxy.com')
'hello,dxy'
# r'\1'是第一组的意思，
# 通过正则匹配找到符合规则的"www.dxy.com"，取得组1字符串去替换整个匹配。

pat = re.compile(r'(\w+) (\w+)')
# 正则表达式
s = 'hello world ! hello hz !'

pat.findall('hello world ! hello hz !')
[('hello', 'world'), ('hello', 'hz')]
pat.sub(r'\2 \1',s)
# 通过正则得到组1(hello)，组2(world)，再通过sub去替换。
# 即组1替换组2，组2替换组1，调换位置。  
'world hello!hz hello!'

collections

namedtuple

namedtuple是一个函数，用来创建自定义的tuple对象，并且规定了tuple元素的个数，并可以用属性而不是索引来引用tuple的某个元素：

>>> from collections import namedtuple
>>> Point = namedtuple('Point', ['x', 'y'])
>>> p = Point(1, 2)
>>> p.x
1
>>> p.y
2

>>> isinstance(p, Point)
True
>>> isinstance(p, tuple)
True

# namedtuple('名称', [属性list]):
Circle = namedtuple('Circle', ['x', 'y', 'r'])

用namedtuple可以很方便地定义一种数据类型，它具备tuple的不变性，又可以根据属性来引用，使用十分方便。

deque

A list-like sequence optimized for data accesses near its endpoints.

# deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，
# 这样就可以非常高效地往头部添加或删除元素。
>>> from collections import deque
>>> q = deque(['a', 'b', 'c'])
>>> q.append('x')
>>> q.appendleft('y')
>>> q
deque(['y', 'a', 'b', 'c', 'x'])

• append: Add an element to the right side of the deque.
• appendleft: Add an element to the left side of the deque.
• clear: Remove all elements from the deque.
• copy: Return a shallow copy of a deque.
• count: D.count(value) -> integer -- return number of occurrences of value.
• extend: Extend the right side of the deque with elements from the iterable.
• extendleft: Extend the left side of the deque with elements from the iterable.

    >>> a = deque([1,2,3])
    >>> a
    deque([1, 2, 3])
    >>> a.extendleft([4,5,6])
    >>> a
    deque([6, 5, 4, 1, 2, 3])
  

• index: D.index(value, [start, [stop]]) -> integer -- return first index of value. Raises ValueError if the value is not present.
• insert: D.insert(index, object) -- insert object before index.
• pop: Remove and return the rightmost element.
• popleft: Remove and return the leftmost element.
• remove: D.remove(value) -- remove first occurrence of value.
• reverse: D.reverse() -- reverse *IN PLACE*
• rotate: Rotate the deque n steps to the right (default n=1). If n is negative, rotates left.

defaultdict

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

>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'N/A')
>>> dd['key1'] = 'abc'
>>> dd['key1'] # key1存在
'abc'
>>> dd['key2'] # key2不存在，返回默认值
'N/A'

默认值是调用函数返回的，而函数在创建defaultdict对象时传入。

除了在Key不存在时返回默认值，defaultdict的其他行为跟dict是完全一样的。

OrderdDict

使用dict时，Key是无序的。迭代dict无法保证Key的顺序；OrderedDict的Key会按照插入的顺序排列：

>>> 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)])
>>> list(od.keys()) # 按照插入的Key的顺序返回
['z', 'y', 'x']

OrderedDict可以实现一个FIFO（先进先出）的dict，当容量超出限制时，先删除最早添加的Key：

from collections import OrderedDict

class LastUpdatedOrderedDict(OrderedDict):
    def __init__(self, capacity):
        super(LastUpdatedOrderedDict, 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)
            # OrderdDict.popitem()
            # Remove and return a (key, value) pair from the dictionary.
            # Pairs are returned in LIFO order if last is true or FIFO order if false.
            print('remove:', last)
            # dict.popitem()
            # Remove and return some (key, value) pair as a 2-tuple;
            # but raise KeyError if D is empty.
        if containsKey:
            del self[key]
            print('set:', (key, value))
        else:
            print('add:', (key, value))
        OrderedDict.__setitem__(self, key, value)

Counter

'''Dict subclass for counting hashable items.  Sometimes called a bag
or multiset.  Elements are stored as dictionary keys and their counts
are stored as dictionary values.

>>> c = Counter('abcdeabcdabcaba')  # count elements from a string

>>> c.most_common(3)                # three most common elements
[('a', 5), ('b', 4), ('c', 3)]
>>> sorted(c)                       # list all unique elements
['a', 'b', 'c', 'd', 'e']
>>> ''.join(sorted(c.elements()))   # list elements with repetitions
'aaaaabbbbcccdde'
>>> sum(c.values())                 # total of all counts
15

>>> c['a']                          # count of letter 'a'
5
>>> for elem in 'shazam':           # update counts from an iterable
...     c[elem] += 1                # by adding 1 to each element's count
>>> c['a']                          # now there are seven 'a'
7
>>> del c['b']                      # remove all 'b'
>>> c['b']                          # now there are zero 'b'
0

>>> d = Counter('simsalabim')       # make another counter
>>> c.update(d)                     # add in the second counter
>>> c['a']                          # now there are nine 'a'
9

>>> c.clear()                       # empty the counter
>>> c
Counter()

Note:  If a count is set to zero or reduced to zero, it will remain
in the counter until the entry is deleted or the counter is cleared:

>>> c = Counter('aaabbc')
>>> c['b'] -= 2                     # reduce the count of 'b' by two
>>> c.most_common()                 # 'b' is still in, but its count is zero
[('a', 3), ('c', 1), ('b', 0)]
'''

string

常用方法

字符串常量

字符串模板Template

通过string.Template可以为Python定制字符串的替换标准：

>>>from string import Template
>>>s = Template('$who like $what')
>>>print s.substitute(who='i', what='python')
i like python

>>>print s.safe_substitute(who='i') 
# 使用safe_substitute，缺少key时不会抛错
# 使用substitute，缺少key时会抛错
i like $what

>>>Template('${who}LikePython').substitute(who='I') # 在字符串内时使用{}
'ILikePython'

Template的高级用法：通过继承string.Template，重写变量delimiter（定界符）和idpattern（替换格式），定制不同形式的模板：

import string

template_text = '''$: $de
with_underscore: %with_underscore
notunderscored: %notunderscored
'''

d = {'de': 'replaced',
     'with_underscore': 'replaced',
     'notunderscored': 'replaced'}

class MyTemplate(string.Template):
    # 重写模板，定界符(delimiter)为"%"，替换模式（idpattern）必须包含下划线"_"
    delimiter = '%'
    idpattern = '[a-z]+_[a-z]+'

print string.Template(template_text).safe_substitute(d)
# 采用原来的Template渲染

print MyTemplate(template_text).safe_substitute(d)
# 使用重写后的MyTemplate渲染

# 输出：
# $: replaced
# with_underscore: %with_underscore
# notunderscored: %notunderscored
# 
# $: $de
# with_underscore: replaced
# notunderscored: %notunderscored
# 
# 原生的Template只会渲染界定符为$的情况，
# 重写后的MyTemplate会渲染界定符为%且替换格式带有下划线的情况。

字符串常用技巧

• 反转字符串

>>> s = '1234567890'
>>> print s[::-1]
0987654321

• 连接字符串

尽量使用join()连接字符串，因为“+”号连接n个字符串需要申请n-1次内存，使用join()只需申请1次内存。

• 分割固定长度字符串

>>> import re
>>> s = '1234567890'
>>> re.findall(r'.{1,3}', s)
['123', '456', '789', '0']

• 使用()括号生成字符串

sql = ('SELECT count() FROM table '
       'WHERE id = "10" '
       'GROUP BY sex')
print sql

# SELECT count() FROM table WHERE id = "10" GROUP BY sex

• 将print的字符串写入文件

>>> print >> open("somefile.txt", "w+"), "Hello World"
# python3写法：print("Hello World!", file=open("somefile.txt", "w+"))
# 将Hello World写入文件somefile.txt

time

在Python中，有三种方式表示时间：

1. 时间戳(timestamp)：时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。运行type(time.time())，返回float类型的timestamp
2. 格式化时间字符串(Format String)
3. 结构化时间(struct_time)：struct_time元组共有9个元素（年，月，日，时，分，秒，一年中第几周，一年中第几天，夏令时）

UTC（Coordinated Universal Time，世界协调时）也叫格林威治天文时间，是世界标准时间。在我国为UTC+8。

DST（Daylight Saving Time，夏令时），又称阳光节约时。是一种为节约能源而人为调整地方时间的制度，利用夏季天亮得早这一自然现象，人为地将时间提前一小时。这样可以使人们早起早睡，以充分利用光照资源，减少照明时间，从而节约照明用电。

>>> import time

# 时间戳
>>> time.time()
1529905431.7368107

# time.strftime(format[, t])
# 将日期转换为字符串，可选参数是一个struct_time对象。
>>> time.strftime("%Y-%m-%d %X")
'2018-06-25 13:44:15'
>>> time.strftime('Weekday: %w; Day of the yesr: %j.')
'Weekday: 1; Day of the yesr: 176.'
>>> time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime())
'2018-06-25 09:43:38'

# time.strptime(string, format)
# 按指定格式解析（parse）一个表示时间的字符串，返回struct_time对象
>>> time.strptime('2009-06-23 15:30:53', '%Y-%m-%d %H:%M:%S')
time.struct_time(tm_year=2009, tm_mon=6, tm_mday=23, tm_hour=15, tm_min=30, tm_sec=53, tm_wday=1, tm_yday=174, tm_isdst=-1)

# 本地时区的struct_time
>>> time.localtime()
time.struct_time(tm_year=2018, tm_mon=6, tm_mday=25, tm_hour=13, tm_min=44, tm_sec=30, tm_wday=0, tm_yday=176, tm_isdst=0)

# UTC时区的struct_time
>>> time.gmtime()
time.struct_time(tm_year=2018, tm_mon=6, tm_mday=25, tm_hour=5, tm_min=44, tm_sec=44, tm_wday=0, tm_yday=176, tm_isdst=0)

# 接收struct_time对象作为参数，返回用秒数来表示时间的浮点数
>>> time.mktime(time.localtime())
1529920484.0

# time.asctime()
# struct_time -> '%a %b %d %H:%M:%S %Y'
>>> time.asctime(time.localtime())
'Mon Jun 25 18:04:02 2018'

# time.ctime()
# timestamp -> '%a %b %d %H:%M:%S %Y'
>>> time.ctime(time.time())
'Mon Jun 25 18:04:23 2018'

# time.sleep()
# 调用time.sleep来挂起当前进程。time.sleep接收一个浮点型参数，表示进程挂起的时间。
>>> time.sleep(3.6)

# time.clock()
# 在Windows上，返回第一次调用该方法到现在的秒数，精确度高于1微秒
# 可用来记录程序执行时间
>>> time.clock()
3.208019535555764e-07
>>> time.clock()
1.8889197571657532

datetime

datetime模块定义了以下几个类：

• datetime.date：表示日期的类。常用属性有year，month，day；
• datetime.time：表示时间的类。常用属性有hour，minute，second，microsecond；
• datetime.datetime：表示日期时间的类；
• datetime.timedelta：表示时间间隔，即两个时间点之间的长度；
• datetime.tzinfo：与时区有关的相关信息。

datetime模块定义了两个常量：datetime.MINYEAR和datetime.MAXYEAR，分别表示datetime所能表示的最小、最大年份。MINYEAR = 1，MAXYEAR = 9999。

注：以上类型的对象都是不可变（immutable）的。

date类

• class datetime.date(year, month, day)

  • year的范围是[MINYEAR, MAXYEAR]，即[1, 9999]；
  • month的范围是[1, 12]（月份从1开始）；
  • day的最大值根据给定的year，month决定。例如闰年2月份有29天。

• date类的常用类属性与类方法：

  • date.max、date.min：date对象所能表示的最大、最小日期；
  • date.resolution：date对象表示日期的最小单位，天；
  • date.today()：返回表示当前本地日期的date对象；
  • date.fromtimestamp(timestamp)：根据给定的时间戮，返回一个date对象；
  • date.fromordinal(ordinal)：将Gregorian日历时间转换为date对象（Gregorian Calendar：一种日历表示方法，类似于我国的农历，西方国家使用较多，此处不详细讨论）。

• date实例的常用属性与方法：

  • date.year、date.month、date.day：年、月、日；
  • date.replace([year[, month[, day]]])：生成一个新的日期对象（原有对象仍保持不变），用参数指定的年，月，日代替原有对象中的属性；
  • date.timetuple()：返回对应的time.struct_time对象；
  • date.toordinal()：返回对应的Gregorian Calendar日期；
  • date.weekday()：返回星期几，0-6，0表示星期一；
  • data.isoweekday()：返回星期几，1-7，1表示星期一；
  • date.isocalendar()：返回一个元组，(year, month, day)；
  • date.isoformat()：返回字符串，'YYYY-MM-DD'；
  • date.strftime(fmt)：返回自定义格式化字符串。

• date类对某些操作进行了重载，允许对日期进行如下操作：

# date2 = date1 + timedelta   # 日期加上一个间隔，返回一个新的日期对象
# date2 = date1 – timedelta   # 日期隔去间隔，返回一个新的日期对象
# timedelta = date1 – date2   # 两个日期相减，返回一个时间间隔对象
# date1 < date2               # 两个日期进行比较

>>> now = date.today()
>>> tomorrow = now.replace(day = 26)
>>> delta = tomorrow - now
>>> print("now:", now, "tomorrow:", tomorrow)
now: 2018-06-25 tomorrow: 2018-06-26
>>> print("timedelta:", delta)
timedelta: 1 day, 0:00:00
>>> print(now + delta)
2018-06-26
>>> print(tomorrow > now)
True

注：对日期进行操作时，要防止日期超出它所能表示的范围。

time类

• class datetime.time(hour[, minute[, second[, microsecond[, tzinfo]]]])

  • hour范围，[0, 24)
  • minute范围，[0, 60)
  • second范围，[0, 60)
  • microsecond范围，[0, 1000000)
  • tzinfo表示时区信息

• time类的常用类属性：

  • time.min、time.max：time类所能表示的最小、最大时间。time.min = time(0, 0, 0, 0)， time.max = time(23, 59, 59, 999999)；
  • time.resolution：time的最小单位，1微秒；

• time实例的常用属性和方法：

  • time.hour、time.minute、time.second、time.microsecond：时、分、秒、微秒；
  • time.tzinfo：时区信息；
  • time.replace([hour[, minute[, second[, microsecond[, tzinfo]]]]])：创建一个新的时间对象（原有对象仍保持不变），用参数指定的时、分、秒、微秒代替原有对象中的属性；
  • time.isoformat()：返回字符串，'HH:MM:SS'；
  • time.strftime(fmt)：返回自定义格式化字符串。

datetime类

datetime是date与time的结合体，包括date与time的所有信息。

• datetime.datetime(year, month, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]])

  • 要注意参数值的范围。

• datetime类的常用类属性与类方法：

  • datetime.min、datetime.max：datetime类所能表示的最小、最大值；
  • datetime.resolution：datetime最小单位；
  • datetime.today()：返回一个表示当前本地时间的datetime对象；
  • datetime.now([tz])：返回一个表示当前本地时间的datetime对象，如果提供了参数tz，则获取tz参数所指时区的本地时间；
  • datetime.utcnow()：返回一个当前UTC时间的datetime对象；
  • datetime.fromtimestamp(timestamp[, tz])：根据时间戮创建datetime对象，参数tz指定时区信息；
  • datetime.utcfromtimestamp(timestamp)：根据时间戮创建datetime对象；
  • datetime.combine(date, time)：根据date和time，创建datetime对象；
  • datetime.strptime(date_string, format)：将格式字符串转换为datetime对象。

• datetime实例的常用属性与方法：

  • datetime.year、month、day、hour、minute、second、microsecond、tzinfo；
  • datetime.date()：获取date对象；
  • datetime.time()：获取time对象；
  • datetime.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]])；
  • datetime.timetuple()；
  • datetime.utctimetuple()；
  • datetime.toordinal()；
  • datetime.weekday()；
  • datetime.isocalendar()；
  • datetime.isoformat([sep])；
  • datetime.ctime()：返回一个'Mon Jun 25 19:51:43 2018'格式的字符串，等效于time.ctime(time.mktime(dt.timetuple()))；
  • datetime.strftime(format)。

格式化字符串

datetime、date、time都提供了strftime()方法，该方法接收一个格式字符串，输出日期时间的字符串表示。

threading

死锁模型

import threading
import time

class MyThread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        print('[%s]: %s is running' % (time.ctime(), self.name))
        self.foo()
        self.bar()
    def foo(self):
        print('[%s]: %s is trying to get LOCKA' % (time.ctime(), self.name))
        LockA.acquire()
        print('[%s]: %s GET LOCKA' % (time.ctime(), self.name))

        print('[%s]: %s is trying to get LOCKB' % (time.ctime(), self.name))
        LockB.acquire()
        print('[%s]: %s GET LOCKB' % (time.ctime(), self.name))

        print('[%s]: %s is gonna release LOCKB' % (time.ctime(), self.name))
        LockB.release()
        print('[%s]: %s LOSE LOCKB' % (time.ctime(), self.name))

        print('[%s]: %s is going to sleep' % (time.ctime(), self.name))
        time.sleep(1)
        print('[%s]: %s is awake now, runing again' % (time.ctime(), self.name))

        print('[%s]: %s is gonna release LOCKA' % (time.ctime(), self.name))
        LockA.release()
        print('[%s]: %s LOSE LOCKA' % (time.ctime(), self.name))


    def bar(self):
        print('[%s]: %s is trying to get LOCKB' % (time.ctime(), self.name))
        LockB.acquire()
        print('[%s]: %s GET LOCKB' % (time.ctime(), self.name))

        print('[%s]: %s is trying to get LOCKA' % (time.ctime(), self.name))
        LockA.acquire()
        print('[%s]: %s GET LOCKA' % (time.ctime(), self.name))

        print('[%s]: %s is gonna release LOCKA' % (time.ctime(), self.name))
        LockA.release()
        print('[%s]: I am %s LOSE LOCKA' % (time.ctime(), self.name))

        print('[%s]: %s is gonna release LOCKB' % (time.ctime(), self.name))
        LockB.release()
        print('[%s]: I am %s LOSE LOCKB' % (time.ctime(), self.name))


LockA = threading.Lock()
LockB = threading.Lock()

for i in range(9):
    t = MyThread()
    t.start()

# 运行结果可能不同
# [Wed Aug 22 10:03:15 2018]: Thread-1 is running
# [Wed Aug 22 10:03:15 2018]: Thread-1 is trying to get LOCKA
# [Wed Aug 22 10:03:15 2018]: Thread-1 GET LOCKA
# [Wed Aug 22 10:03:15 2018]: Thread-1 is trying to get LOCKB
# [Wed Aug 22 10:03:15 2018]: Thread-1 GET LOCKB
# [Wed Aug 22 10:03:15 2018]: Thread-1 is gonna release LOCKB
# [Wed Aug 22 10:03:15 2018]: Thread-1 LOSE LOCKB
# [Wed Aug 22 10:03:15 2018]: Thread-1 is going to sleep
# [Wed Aug 22 10:03:15 2018]: Thread-2 is running
# [Wed Aug 22 10:03:15 2018]: Thread-2 is trying to get LOCKA
# [Wed Aug 22 10:03:15 2018]: Thread-3 is running
# [Wed Aug 22 10:03:15 2018]: Thread-3 is trying to get LOCKA
# [Wed Aug 22 10:03:15 2018]: Thread-4 is running
# [Wed Aug 22 10:03:15 2018]: Thread-4 is trying to get LOCKA
# [Wed Aug 22 10:03:15 2018]: Thread-5 is running
# [Wed Aug 22 10:03:15 2018]: Thread-5 is trying to get LOCKA
# [Wed Aug 22 10:03:15 2018]: Thread-6 is running
# [Wed Aug 22 10:03:15 2018]: Thread-6 is trying to get LOCKA
# [Wed Aug 22 10:03:15 2018]: Thread-7 is running
# [Wed Aug 22 10:03:15 2018]: Thread-7 is trying to get LOCKA
# [Wed Aug 22 10:03:15 2018]: Thread-8 is running
# [Wed Aug 22 10:03:15 2018]: Thread-8 is trying to get LOCKA
# [Wed Aug 22 10:03:15 2018]: Thread-9 is running
# [Wed Aug 22 10:03:15 2018]: Thread-9 is trying to get LOCKA
# [Wed Aug 22 10:03:16 2018]: Thread-1 is awake now, runing again
# [Wed Aug 22 10:03:16 2018]: Thread-1 is gonna release LOCKA
# [Wed Aug 22 10:03:16 2018]: Thread-1 LOSE LOCKA
# [Wed Aug 22 10:03:16 2018]: Thread-1 is trying to get LOCKB
# [Wed Aug 22 10:03:16 2018]: Thread-1 GET LOCKB
# [Wed Aug 22 10:03:16 2018]: Thread-1 is trying to get LOCKA
# [Wed Aug 22 10:03:16 2018]: Thread-2 GET LOCKA
# [Wed Aug 22 10:03:16 2018]: Thread-2 is trying to get LOCKB