使用計算機時，經常需要列出一個文件夾或者目錄的內容，創建和刪除文件等操作，在 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
