使用计算机时，经常需要列出一个文件夹或者目录的内容，创建和删除文件等操作，在 Python 程序中可以做到同样的事， 甚至能做更多的事。Python 在模块 os（操作系统，operating system）中提供了许多系统函数。本节的所有操作，都要导入这个模块。

1.文件

和其他语言一样，Python 的文件操作很像 Unix。有些函数的名字相同，比如 chown() 和 chmod()，不过也有很多新函数。

用open()创建文件

之前我们使用open()函数来打开文件或者创建文件。下面创建一个oops.txt的文本文件：

In [1]: import os 

In [2]: fout = open('oops.txt','wt') 

In [3]: print('Oops,I created a file.', file=fout) 

In [4]: fout.close() 

我们用这个文件进行一些测试

用exists()检查文件是否存在

要判断文件或者目录是否存在，可以使用 exists()，传入相对或者绝对路径名，如下所示：

In [5]: os.path.exists('oops.txt') 
Out[5]: True

[6]: os.path.exists('./oops.txt') 
Out[6]: True

In [7]: os.path.exists('sjkldfk') 
Out[7]: False

In [8]: os.path.exists('.') 
Out[8]: True

In [9]: os.path.exists('..') 
Out[9]: True

用isfile()检查是否为文件

使用isfile判断是否为文件

In [10]: name = 'oops.txt' 

In [11]: os.path.isfile(name) 
Out[11]: True

使用isdir判断是否为目录：

In [12]: os.path.isdir(name) 
Out[12]: False
一个点号（.）表示当前目录，两个点号（..）表示上层目录。它们一直存在，所以下面 的语句总会返回 True：

In [13]: os.path.isdir('.')
Out[13]: True

In [14]: os.path.isdir('..')
Out[14]: True

os 模块中有许多处理路径名（完整的文件名，由 / 开始并包含所有上级目录）的函数。其 中之一是 isabs()，可以判断参数是否是一个绝对路径名。参数不需要是一个真正的文件。

In [15]: os.path.isabs(name) 
Out[15]: False

In [16]: os.path.isabs('/home/root/oops.txt') 
Out[16]: True

In [17]: os.path.isabs('home/root/oops.txt') 
Out[17]: False

用copy()复制文件

copy() 函数来自于另一个模块 shutil。下面的例子会把文件 oops.txt 复制到文件 ohno.txt：

In [18]: import shutil 

In [19]: shutil.copy('oops.txt','ohno.txt') 
Out[19]: 'ohno.txt'

shutil.move()函数会复制一个文件并删除原始文件。

用rename()重命名文件

下面的例子会把 ohno.txt 文件重命名为 ohwell.txt 文件：

In [20]: os.rename('ohno.txt','ohwell.txt') 

用link()或者symlink()创建链接

在 Unix 中，文件只存在于一个位置，但是可以有多个名称，这种机制叫作链接。在更底 层的硬链接中，找到一个文件的所有名称并不容易。可以考虑使用符号链接，它会把新名 称当作文件存储，这样一次就可以获取到原始名称和新名称。link() 会创建一个硬链接。 symlink() 会创建一个符号链接。islink() 函数会检查参数是文件还是符号链接。
下面这个例子展示了如何把已有文件 oops.txt 硬链接到一个新文件 yikes.txt：

In [21]: os.link('oops.txt','yikes.txt') 

In [22]: os.path.isfile('yikes.txt') 
Out[22]: True

下面的例子展示了如何把已有文件 oops.txt 符号链接到一个新文件 jeepers.txt：

In [23]: os.path.islink('yikes.txt')
Out[23]: False

In [24]: os.symlink('oops.txt','jeepers.txt')

In [25]: os.path.islink('jeepers.txt') 
Out[25]: True

用chmod()修改权限

在 Unix 系统中，chmod() 可以修改文件权限。可以设置用户（如果是你创建了文件，那用 户通常就是你）、当前用户所在用户组以及其他所有用户组的读、写和执行权限。这个命 令接收一个压缩过的八进制（基数为 8）值，这个值包含用户、用户组和权限。举例来说， 下面的命令可以让 oops.txt 只能被拥有者读：

In [26]: os.chmod('oops.txt',0o400) 

如果不想用压缩过的八进制值并且更喜欢符号，可以从 stat 模块中 导入一些常量并用在语句中：

In [27]: import  stat 

In [28]: os.chmod('oops.txt',stat.S_IRUSR)

用chown()修改所有者

这个函数也是 Unix/Linux/Mac 特有的。我们可以指定用户的 ID（uid）和用户组 ID（gid）来 修改文件的所有者或所有用户组：

In [29]: uid = 1004 

In [30]: gid = 1004 

In [31]: os.chown('oops.txt',uid,gid) 

用abspath()获取路径名

这个函数会把一个相对路径名扩展成绝对路径名。如果我们的当前目录是 /root/oops.txt， 其中有文件 oops.txt，那你可以用这个函数得到下面的输出：

In [32]: os.path.abspath('oops.txt') 
Out[32]: '/root/oops.txt'

用realpath()获取符号的路径名

In [33]: os.path.realpath('jeepers.txt')
Out[33]: '/root/oops.txt'

用remove()删除文件

下面的栗子使用 remove() 函数来删除 oops.txt 文件：

In [34]: os.remove('oops.txt')

In [35]: os.path.exists('oops.txt') 
Out[35]: False

2.目录

在大多数操作系统中，文件被存储在多级目录（现在经常被称为文件夹）中。包含所有这 些文件和目录的容器是文件系统（有时候被称为卷）。标准模块 os 可以处理这些东西，下 面是一些可以使用的函数。

使用mkdir()创建目录

如何创建目录

In [1]: import os 

In [2]: os.mkdir('poems') 

In [3]: os.path.exists('poems') 
Out[3]: True

使用rmdir()删除目录

In [4]: os.rmdir('poems') 

In [5]: os.path.exists('poems') 
Out[5]: False

使用listdir()列出目录内容

In [6]: os.mkdir('poems') 
列出内容：
In [7]: os.listdir('poems') 
Out[7]: []
创建一个子目录
In [8]: os.mkdir('poems/mimin') 

In [9]: os.listdir('poems') 
Out[9]: ['mimin']
在子目录中创建一个文件
In [10]: fout = open('poems/mimin/the_good_man','wt') 

In [11]: fout.write('''Cheerful and happy was his mood, 
    ...: He to the poor was kind and good,
    ...: And he oft' times did find them food,
    ...: Also supplies of coal and wood, 
    ...: He never spake a word was rude, 
    ...: And cheer'd those did o'er sorrows brood, 
    ...: He passed away not understood, 
    ...: Because no poet in his lays 
    ...: Had penned a sonnet in his praise, 
    ...: 'Tis sad, but such is world's ways. 
    ...: ''')
Out[11]: 349

In [12]: os.listdir('poems/mimin') 
Out[12]: ['the_good_man']

使用glob()列出匹配文件

glob()函数会使用Unix shell的规则来匹配文件或目录，而不是正则表达式。

In [13]: import glob 
匹配的是当前目录
试着获取所有以 m 开头的文件和目录：
In [14]: glob.glob('m*') 
Out[14]: 
['mp_test.py',
 'master.zip',
 'mongodb-linux-x86_64-rhel70-3.2.11.tgz',
 'mp_pool.py',
 'mp.py']

获取所有名称为两个字符的文件和目录：
In [15]: glob.glob('??')
Out[15]: ['lm', '-c']

获取名称为 10 个字符并且以 m 开头和以 p结尾的文件和目录：
In [16]: glob.glob('m????????p')
Out[16]: ['master.zip']

获取所有以 k、l 或者 m 开头并且以 y结尾的文件和目录：
In [17]: glob.glob('[lkm]*y')
Out[17]: ['mp_test.py', 'mp_pool.py', 'mp.py']

3.程序和进程

当运行一个程序的时候，操作系统机会创建一个进程，它会使用系统资源（CPU，内存和磁盘空间）和操作系统内核中的数据结构（文件，网络连接，用量统计等）。进程之间是互相隔 离的，即一个进程既无法访问其他进程的内容，也无法操作其他进程。

操作系统会跟踪所有正在运行的进程，给每个进程一小段运行时间，然后切换到其他进 程，这样既可以做到公平又可以响应用户操作。

我们可以自己编写程序来获取进程信息。标准库模块 os 提供了一些常用的获取系统信 息的函数。
举例来说，下面的函数会获取正在运行的 Python 解释器的进程号和当前工 作目录：

In [1]: import os 

In [2]: os.getpid() 
Out[2]: 26164

In [3]: os.getcwd() 
Out[3]: '/root'

下面的函数会获取当前用户ID和用户组ID：
In [4]: os.getuid()
Out[4]: 621

In [5]: os.getgid() 
Out[5]: 29

使用subprocess创建进程

我们可以使用Python标准库中的subprocess模块来启动和终止其他程序。如果我们只是想在shell中运行其他程序并获取它的输出（标准输出和标准错误输出），可以使用getoutput()函数。
这里获得了Unix date程序的输出：

In [6]: import subprocess

In [7]: ret = subprocess.getoutput('date') 

In [8]: ret 
Out[8]: 'Thu Jan 19 10:36:44 CST 2017'

在程序执行完毕之前，我们获取不到任何内容。因为getoutput()的参数是一个字符串，可以表示一个完整的shell命令，所以我们可以在里面使用参数，管道，I/O重定向<和>，等等：

In [9]: ret = subprocess.getoutput('date -u') 

In [10]: ret 
Out[10]: 'Thu Jan 19 02:39:07 UTC 2017'
把这个输出用管道传给 wc 命令，可以计算出一共有 1 行、6 个单词和 29 个字符：
In [11]: ret = subprocess.getoutput('date -u | wc') 

In [12]: ret 
Out[12]: '      1       6      29'

另一个类似的方法是check_outout()，可以接受一个命令和参数列表。默认情况下，它返回的不是字符串，而是字节类型的标准输出。此外，这个函数并没有使用shell：

In [13]: ret = subprocess.check_output(['date','-u']) 

In [14]: ret 
Out[14]: b'Thu Jan 19 02:41:51 UTC 2017\n'

如果要获取其他程序的退出状态，可以使用getstatusoutput()函数，它会返回一个包含状态码和输出的元组：

In [15]: ret = subprocess.getstatusoutput('date') 

In [16]: ret 
Out[16]: (0, 'Thu Jan 19 10:42:36 CST 2017')

如果只是想要使用退出状态，可以使用call()：

In [17]: ret = subprocess.call('date') 
Thu Jan 19 10:42:55 CST 2017

In [18]: ret 
Out[18]: 0

在Unix类操作系统中，退出状态0通常表示运行成功
上面的日期和时间被打印到输出中，但并没有被我们的程序获取，所以ret中只有状态码。
可以用两种方式来运行带参数的程序。第一种是在字符串中写明参数。我们的示例中使用的是 date -u，这会打印出 UTC 格式的当前日期和时间：

In [19]: ret = subprocess.call('date -u',shell=True) 
Thu Jan 19 02:46:33 UTC 2017

In [20]: ret 
Out[20]: 0

需要加上参数shell=True，这样函数就会用shell来执行命令，shell会把date -u分割成单独的字符串并对通配符（比如 *，我们的例子中没有使用它）进行扩展。
第二种方式是传入一个参数列表，这样函数就不需要调用 shell：

In [21]: ret = subprocess.call(['date','-u']) 
Thu Jan 19 02:47:24 UTC 2017

In [22]: ret 
Out[22]: 0

使用multiprocessing创建进程

你可以在一个单独的进程中运行一个 Python 函数，也可以使用 multiprocessing 模块在 一个程序中运行多个进程。下面我们看一个小程序：

import multiprocessing 
import os 
def do_this(what):
    whoami(what)
def whoami(what):
    print("process %s says: %s" % (os.getpid(),what)) 
if __name__ == "__main__":
    whoami("I'm the main program") 
    for n in range(4):
        p = multiprocessing.Process(target=do_this,args=("I'm function %s" % n,)) 
        p.start()

运行结果：

python pm.py 
process 27943 says: I'm the main program
process 27944 says: I'm function 0
process 27945 says: I'm function 1
process 27946 says: I'm function 2
process 27947 says: I'm function 3

Process()函数会创建一个新的进程来运行do_this()函数。由于我们在一个循环中执行它，所以生成了4个执行do_this()的进程并在执行完毕后退出。

multiprocessing 模块真正的功能比这个例子中所展示的要强大得多。当需要用多进程来 减少运行时间时，它非常有用，比如下载需要抓取的网页、调整图片尺寸等。它支持任务 队列和进程间通信，而且可以等待所有进程执行完毕。

使用terminate()终止进程

如果创建了一个或者多个进程并且想终止它们，可以使用 terminate()。下面的例子 中，我们的进程会一直计数到一万，每次计数之后都会等待 1 秒并打印出相关信息。然 而，主程序只会保持 5 秒耐心，之后就会终止进程：

import multiprocessing 
import time 
import os  
def whoami(name):
     print("I'm %s, in process %s" % (name, os.getpid()))  
def loopy(name):
     whoami(name)
     start = 1
     stop = 1000000
     for num in range(start, stop): 
        print("\tNumber %s of %s. Honk!" % (num, stop)) 
        time.sleep(1)  
if __name__ == "__main__":
     whoami("main")
     p = multiprocessing.Process(target=loopy, args=("loopy",))
     p.start()
     time.sleep(5)
     p.terminate()

时间和日期

可以用多种方式来表示日期，甚至多到让人厌烦。
表示日期的方法：
• July 29 1984
• 29 Jul 1984
• 29/7/1984
• 7/29/1984
表示日期的第一个问题就是二义性。从上面的例子可以很容易看出，7 表示月份，29 表示 天数，因为月份不可能是 29。但是 1/6/2012 呢？它到底是 1 月 6 日还是 6 月 1 日呢？
下面 的代码可以检测是否是闰年：

In [1]: import calendar

In [2]: calendar.isleap(1900) 
Out[2]: False

In [3]: calendar.isleap(1996) 
Out[3]: True

In [4]: 

In [4]: calendar.isleap(1999) 
Out[4]: False

In [5]:  calendar.isleap(2000) 
Out[5]: True

In [6]: calendar.isleap(2002)  
Out[6]: False

In [7]: calendar.isleap(2004)  
Out[7]: True

Python 的标准库中有很多日期和时间模块：datetime、time、calendar、dateutil，等等。

datetime模块

datetime模块定义了4个主要的对象，每个对象都有很多方法：

• date处理年月日
• time处理时分秒和分数
• datetime处理时期和时间同时出现的情况
• timedelta 处理日期和时间间隔

我们可以指定年月日来创建一个对象，这些值之后会变成对象的属性：

In [12]: from datetime import date 

In [13]: hallw = date(2017,1,22) 

In [14]: hallw 
Out[14]: datetime.date(2017, 1, 22)

In [15]: hallw
Out[15]: datetime.date(2017, 1, 22)

In [16]: hallw.day
Out[16]: 22

In [17]: hallw.month
Out[17]: 1

In [18]: hallw.year
Out[18]: 2017

可以使用isoformat()方法打印一个date对象：
iso 是指 ISO 8601，一种表示日期和时间的国际标准。这个标准的显示顺序是从一般（年） 到特殊（日）。它也可以对日期进行正确的排序：先按照年，然后是月，最后是日。
In [19]: hallw.isoformat()
Out[19]: '2017-01-22'

可以使用today()方法生成今天的日期：
In [20]: now = date.today() 

In [21]: now 
Out[21]: datetime.date(2017, 1, 22)

可以使用timedelta对象来实现date的加法：
In [22]: from datetime import timedelta

In [23]: ond_days = timedelta(days=1) 

In [24]: tomorrow = now +ond_days

In [25]: tomorrow 
Out[25]: datetime.date(2017, 1, 23)

In [26]: now + 17*ond_days
Out[26]: datetime.date(2017, 2, 8)

In [27]: yesterday = now - ond_days

In [28]: yesterday
Out[28]: datetime.date(2017, 1, 21)

date 的 范 围 是 date.min（ 年 = 1， 月 = 1， 日 = 1） 到 date.max（ 年 = 9999， 月 = 12， 日 = 31）。因此，不能使用它来进行和历史或者天文相关的计算。

datetime模块中的time对象用来表示一天中的时间：

In [29]: from datetime import time 

In [30]: noon = time(9,25,28) 

In [31]: noon 
Out[31]: datetime.time(9, 25, 28)

In [32]: noon.hour
Out[32]: 9

In [33]: noon.minute
Out[33]: 25

In [34]: noon.second
Out[34]: 28

In [35]: noon.microsecond
Out[35]: 0

参数的顺序是按照时间单位从大（时）到小（微秒）排列。如果没有参数，time 会默认全 部使用 0。顺便说一句，能够存取微秒并不意味着你能从计算机中得到准确的微秒。每秒 的准确度取决于硬件和操作系统中的很多因素。

datetime 对象既包含日期也包含时间。我们可以直接创建一个 datetime 对象：

In [36]: from datetime import datetime

In [37]: some_day = datetime(2017,1,22,9,27,37,25) 

In [38]: some_day 
Out[38]: datetime.datetime(2017, 1, 22, 9, 27, 37, 25)

datetime对象也有一个isoformat()方法：
In [39]: some_day.isocalendar() 
Out[39]: (2017, 3, 7)

In [40]: some_day.isoformat() 
Out[40]: '2017-01-22T09:27:37.000025'
中间的T把日期和时间分割开。

datetime有一个now()方法，可以用它获取当前日期和时间：
In [41]: now = datetime.now() 

In [42]: now 
Out[42]: datetime.datetime(2017, 1, 22, 9, 30, 47, 837244)

In [43]: now.month() 
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-43-c68ec01f3e6a> in <module>()
----> 1 now.month()

TypeError: 'int' object is not callable

In [44]: now.month
Out[44]: 1

In [45]: now.day
Out[45]: 22

In [46]: now.hour
Out[46]: 9

In [47]: now.minute
Out[47]: 30

In [48]: now.second
Out[48]: 47

In [49]: now.microsecond
Out[49]: 837244

可以使用combin()方法把一个date对象和一个time对象合并成一个datetime()对象：
In [50]: from datetime import datetime,time,date 

In [51]: noon = time(9,33)

In [52]: this_day = date.today()

In [53]: noon_today =datetime.combine(this_day,noon) 

In [54]: noon_today
Out[54]: datetime.datetime(2017, 1, 22, 9, 33)

可以使用date()和time()方法从datetime中取出date和time部分：
In [55]: noon_today.date() 
Out[55]: datetime.date(2017, 1, 22)

In [56]: noon_today.time() 
Out[56]: datetime.time(9, 33)

使用time模块

一种表示绝对时间的方法是计算某个从开始点开始的秒数。Unix时间使用的是从1970年1月1日0点开始的秒数。这个值通常被称为纪元，它是不同系统之间最简单的交换日期 时间的方法。

time模块的time()函数会返回当前时间的纪元值：

In [57]: import time

time模块的time()函数会返回当前时间的纪元值：
In [58]: now = time.time() 

In [59]: now 
Out[59]: 1485051693.6350434

可以使用ctime()把一个纪元值转换成一个字符串：
In [60]: time.ctime(now) 
Out[60]: 'Sun Jan 22 10:21:33 2017'

纪元值是不同系统（比如javascript）之间交换日期和时间的一种非常有用的方法。
但是， 有时候想要真正的日期而不是一串数字，这时可以使用 struct_time 对象。localtime() 会 返回当前系统时区下的时间，gmtime() 会返回 UTC 时间：

In [61]: time.localtime(now) 
Out[61]: time.struct_time(tm_year=2017, tm_mon=1, tm_mday=22, tm_hour=10, tm_min=21, tm_sec=33, tm_wday=6, tm_yday=22, tm_isdst=0)

In [62]: time.gmtime(now) 
Out[62]: time.struct_time(tm_year=2017, tm_mon=1, tm_mday=22, tm_hour=2, tm_min=21, tm_sec=33, tm_wday=6, tm_yday=22, tm_isdst=0)

In [63]: tm = time.localtime(now) 

如果省略 localtime() 或者 gmtime() 的参数，默认会返回当前时间。

对应上面两个函数的是mktime()，它会把struct_time对象转换回纪元值。

In [64]: time.mktime(tm) 
Out[64]: 1485051693.0

这个值和之前的now返回的纪元值不完全相同，因为struct_time对象只能精确到秒。

建议：尽量多使用 UTC 来代替时区。UTC 是绝对时间，和时区无关。如果你有服务 器，把它的时间设置为 UTC，不要使用本地时间。：如果有可能，绝对不使用夏时制时间。如果使用了夏时制 时间，那每年的一段时间（春季）会少一个小时，另一段时间（秋季）会多一个小时。出 于某些原因，许多组织在它们的计算机系统中使用夏时制，但是每年都需要处理数据重复 和丢失。

读写日期和时间

isoformat()并不是唯一一个可以打印日期和时间的方法。前面已经见过，time 模块中的 ctime() 函数可以把纪元转换成字符串：
也可以使用strftime()把时间和日期转换成字符串。这个方法在datetime，date和time对象中都有，在time模块中也有。strftime()使用格式化字符串来指定输出。

strftime()的格式化字符串:

格式化字符串    日期/时间单元        范围
%Y                    年                           1900-......
%m                    月                           01-12 
%B                    月名                        January，......
%b                     月名缩写                Jan,......
%d                     日                            01-31
%A                     星期                        Sunday，......
%a                     星期缩写                 Sun，......
%H                    时（24小时制）       00-23
%I                      时（12小时制）      01-12
%p                     上午/下午                 AM,PM
%M                   分                              00-59
%s                     秒                             00-59

数字都是左边补零

下面时time模块中的strftime()函数。它会把struct_time对象转换成字符串。我们先定义格式化字符串fmt，然后使用它：

In [1]: import time

In [2]: fmt = "It's %A,%B %d,%Y,local time %I:%M:%s%p" 

In [3]: t =time.localtime() 

In [4]: t 
Out[4]: time.struct_time(tm_year=2017, tm_mon=1, tm_mday=22, tm_hour=14, tm_min=47, tm_sec=19, tm_wday=6, tm_yday=22, tm_isdst=0)

In [5]: time.strftime(fmt,t) 
Out[5]: "It's Sunday,January 22,2017,local time 02:47:1485067639PM"

注意上面我们使用的是time模块。

如果使用date对象的strftime()函数，只能获取部分日期，时间默认是午夜：

In [6]: from   datetime   import  date

In [7]: some_day = date(2017,1,22)

In [8]: fmt = "It's %A,%B %d,%Y,local time %I:%M:%s%p" 

In [9]: some_day.strftime(fmt) 
Out[9]: "It's Sunday,January 22,2017,local time 12:00:1485014400AM"

对于time对象，只会转换时间部分:

In [15]: from datetime  import time 

In [16]: some_time = time(14,56)

In [17]: fmt = "It's %A,%B %d,%Y,local time %I:%M:%s%p"

In [18]: some_time.strftime(fmt) 
Out[18]: "It's Monday,January 01,1900,local time 02:56:-2208964183PM"

如果把字符串转换成日期或者时间，可以对同样的格式化字符串使用strftime()函数。
这里不能使用正则表达式，字符串的非格式化部分（没有%的部分）必须完全匹配。
假设 可以匹配格式“年 - 月 - 日”，比如 2012-01-29，如果目标字符串中用空格代替破折号， 解析时就会错误：

In [1]: import time 

In [2]: fmt = "%Y-%m-%d" 

In [3]: time.strptime("2017 01 22",fmt) 
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-3-f55b9b517cc5> in <module>()
----> 1 time.strptime("2017 01 22",fmt)

/usr/local/lib/python3.5/_strptime.py in _strptime_time(data_string, format)
    502     """Return a time struct based on the input string and the
    503     format string."""
--> 504     tt = _strptime(data_string, format)[0]
    505     return time.struct_time(tt[:time._STRUCT_TM_ITEMS])
    506 

/usr/local/lib/python3.5/_strptime.py in _strptime(data_string, format)
    341     if not found:
    342         raise ValueError("time data %r does not match format %r" %
--> 343                          (data_string, format))
    344     if len(data_string) != found.end():
    345         raise ValueError("unconverted data remains: %s" %

ValueError: time data '2017 01 22' does not match format '%Y-%m-%d'

当我们传入strptime()的字符中有破折号就不会报错：

In [4]: time.strptime("2017-01-22",fmt) 
Out[4]: time.struct_time(tm_year=2017, tm_mon=1, tm_mday=22, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=22, tm_isdst=-1)

即使字符串看起来可以匹配格式，但如果超出范围也会报错：

In [5]: time.strptime("2017-01-33",fmt) 
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-5-d0c6d47bc245> in <module>()
----> 1 time.strptime("2017-01-33",fmt)

/usr/local/lib/python3.5/_strptime.py in _strptime_time(data_string, format)
    502     """Return a time struct based on the input string and the
    503     format string."""
--> 504     tt = _strptime(data_string, format)[0]
    505     return time.struct_time(tt[:time._STRUCT_TM_ITEMS])
    506 

/usr/local/lib/python3.5/_strptime.py in _strptime(data_string, format)
    344     if len(data_string) != found.end():
    345         raise ValueError("unconverted data remains: %s" %
--> 346                           data_string[found.end():])
    347 
    348     year = None

ValueError: unconverted data remains: 3