使用计算机时，经常需要列出一个文件夹或者目录的内容，创建和删除文件等操作，在 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
