人生苦短，我用Python（Python快速教程 - 基础篇）
Life is short, you need Python
人生苦短，我用Python
-- Bruce Eckel
5.1 Python簡(jiǎn)介
本章將介紹Python的最基本語(yǔ)法，以及一些和深度學(xué)習(xí)還有計(jì)算機(jī)視覺(jué)最相關(guān)的基本使用。
5.1.1 Python簡(jiǎn)史
Python是一門(mén)解釋型的高級(jí)編程語(yǔ)言，特點(diǎn)是簡(jiǎn)單明確。Python作者是荷蘭人Guido van Rossum，1982年他獲得數(shù)學(xué)和計(jì)算機(jī)碩士學(xué)位后，在荷蘭數(shù)學(xué)與計(jì)算科學(xué)研究所（Centrum Wiskunde & Informatica, CWI）謀了份差事。在CWI期間，Guido參與到了一門(mén)叫做ABC的語(yǔ)言開(kāi)發(fā)工作中。ABC是一門(mén)教學(xué)語(yǔ)言，所以擁有簡(jiǎn)單，可讀性好，語(yǔ)法更接近自然語(yǔ)言等特點(diǎn)。在那個(gè)C語(yǔ)言一統(tǒng)天下的年代，ABC就是一股簡(jiǎn)單的清流，畢竟是門(mén)教學(xué)語(yǔ)言，最后沒(méi)有流行起來(lái)，不過(guò)這段經(jīng)歷影響了Guido。1989年的圣誕假期，閑得蛋疼的Guido決定設(shè)計(jì)一門(mén)簡(jiǎn)單易用的新語(yǔ)言，要介于C和Shell之間，同時(shí)吸取ABC語(yǔ)法中的優(yōu)點(diǎn)。Guido用自己喜歡的一部喜劇電視劇來(lái)命名這門(mén)語(yǔ)言：《Monty Python's Flying Circus》。
1991年，第一版基于C實(shí)現(xiàn)的Python編譯器誕生，因?yàn)楹?jiǎn)單，拓展性好，Python很快就在Guido的同事中大受歡迎，不久Python的核心開(kāi)發(fā)人員就從Guido一人變成了一個(gè)小團(tuán)隊(duì)。后來(lái)隨著互聯(lián)網(wǎng)時(shí)代的到來(lái)，開(kāi)源及社區(qū)合作的方式蓬勃發(fā)展，Python也借此上了發(fā)展的快車(chē)道。因?yàn)镻ython非常容易拓展，在不同領(lǐng)域的開(kāi)發(fā)者貢獻(xiàn)下，許多受歡迎的功能和特征被開(kāi)發(fā)出來(lái)，漸漸形成了各種各樣的庫(kù)，其中一部分被加入到Python的標(biāo)準(zhǔn)庫(kù)中，這讓本來(lái)就不需要過(guò)多思考底層細(xì)節(jié)的Python變得更加強(qiáng)大好用。在不過(guò)多考慮執(zhí)行效率的前提下，使用Python進(jìn)行開(kāi)發(fā)的周期相比傳統(tǒng)的C/C++甚至Java等語(yǔ)言都大大縮短，代碼量也大幅降低，所以出bug的可能性也小了很多。因此有了語(yǔ)言專家Bruce Eckel的那句名言：Life is short, you need Python. 后來(lái)這句話的中文版“人生苦短，我用Python”被Guido印在了T恤上。發(fā)展至今，Python漸漸成了最流行的語(yǔ)言之一，在編程語(yǔ)言排行榜TOBIE中常年占據(jù)前5的位置。另外隨著Python的用戶群越來(lái)越壯大，慢慢在本身特點(diǎn)上發(fā)展出了自己的哲學(xué)，叫做Python的禪（The Zen of Python）。遵循Python哲學(xué)的做法叫做很Python（Pythonic），具體參見(jiàn)：
PEP 20 -- The Zen of Python
或者在Python中執(zhí)行：
>> import this
Python擁有很好的擴(kuò)充性，可以非常輕松地用其他語(yǔ)言編寫(xiě)模塊供調(diào)用，用Python編寫(xiě)的模塊也可以通過(guò)各種方式輕松被其他語(yǔ)言調(diào)用。所以一種常見(jiàn)的Python使用方式是，底層復(fù)雜且對(duì)效率要求高的模塊用C/C++等語(yǔ)言實(shí)現(xiàn)，頂層調(diào)用的API用Python封裝，這樣可以通過(guò)簡(jiǎn)單的語(yǔ)法實(shí)現(xiàn)頂層邏輯，故而Python又被稱為“膠水語(yǔ)言”。這種特性的好處是，無(wú)需花費(fèi)很多時(shí)間在編程實(shí)現(xiàn)上，更多的時(shí)間可以專注于思考問(wèn)題的邏輯。尤其是對(duì)做算法和深度學(xué)習(xí)的從業(yè)人員，這種方式是非常理想的，所以如今的深度學(xué)習(xí)框架中，除了MATLAB，或是Deeplearning4j這種擺明了給Java用的，其他框架基本上要么官方接口就是Python，要么支持Python接口。
5.1.2 安裝和使用Python
Python有兩個(gè)大版本，考慮到用戶群數(shù)量和庫(kù)的各種框架的兼容性，本文以Python2（2.7）為準(zhǔn)，語(yǔ)法盡量考慮和Python3的兼容。
Unix/Linux下的Python基本都是系統(tǒng)自帶的，一般默認(rèn)為Python2，使用時(shí)在終端直接鍵入python就能進(jìn)入Python解釋器界面：
在解釋器下就已經(jīng)可以進(jìn)行最基本的編程了，比如：
寫(xiě)程序的話還是需要保存成文件再執(zhí)行，比如我們寫(xiě)下面語(yǔ)句，并且保存為helloworld.py：
print("Hello world!")
然后在終端里執(zhí)行：
安裝更多的python庫(kù)一般有兩種方法，第一是用系統(tǒng)的軟件包管理，以Ubuntu 16.04 LTS為例，比如想要安裝numpy庫(kù)（后面會(huì)介紹這個(gè)庫(kù)），軟件包的名字就是python-numpy，所以在終端中輸入：
>> sudo apt install python-numpy
Python自己也帶了包管理器，叫做pip，使用如下：
>> pip install numpy
安裝和深度學(xué)習(xí)相關(guān)的框架時(shí)，一般來(lái)說(shuō)推薦使用系統(tǒng)自帶的包管理，出現(xiàn)版本錯(cuò)誤的可能性低一些。另外也可以使用一些提前配置好很多第三方庫(kù)的Python包，這些包通常已經(jīng)包含了深度學(xué)習(xí)框架中絕大多數(shù)的依賴庫(kù)，比如最常用的是Anaconda：
Download Anaconda Now!
Windows下的Python安裝簡(jiǎn)單一些，從官方網(wǎng)站下載相應(yīng)的安裝程序就可以了，當(dāng)然也有更方便的已經(jīng)包含了很全的第三方庫(kù)的選擇，WinPython：
WinPython
并且是綠色的，直接執(zhí)行就可以用了。
5.2 Python基本語(yǔ)法
There should be one-- and preferably only one --obvious way to do it.
對(duì)于一個(gè)特定的問(wèn)題，應(yīng)該只用最好的一種方法來(lái)解決。
-- Tim Peters
5.2.1 基本數(shù)據(jù)類型和運(yùn)算
基本數(shù)據(jù)類型
Python中最基本的數(shù)據(jù)類型包括整型，浮點(diǎn)數(shù)，布爾值和字符串。類型是不需要聲明的，比如：
a = 1 # 整數(shù) b = 1.2 # 浮點(diǎn)數(shù) c = True # 布爾類型 d = "False" # 字符串 e = None # NoneType其中#是行內(nèi)注釋的意思。最后一個(gè)None是NoneType，注意不是0，在Python中利用type函數(shù)可以查看一個(gè)變量的類型：
注釋中是執(zhí)行type()函數(shù)后的輸出結(jié)果，可以看到None是單獨(dú)的一種類型NoneType。在很多API中，如果執(zhí)行失敗就會(huì)返回None。
變量和引用
Python中基本變量的賦值一般建立的是個(gè)引用，比如下面的語(yǔ)句：
a = 1 b = a c = 1a賦值為1后，b=a執(zhí)行時(shí)并不會(huì)將a的值復(fù)制一遍，然后賦給b，而是簡(jiǎn)單地為a所指的值，也就是1建立了一個(gè)引用，相當(dāng)于a和b都是指向包含1這個(gè)值的這塊內(nèi)存的指針。所以c=1執(zhí)行的也是個(gè)引用建立，這三個(gè)變量其實(shí)是三個(gè)引用，指向同一個(gè)值。這個(gè)邏輯雖然簡(jiǎn)單，不過(guò)也還是常常容易弄混，這沒(méi)關(guān)系，Python內(nèi)置了id函數(shù)，可以返回一個(gè)對(duì)象的地址，用id函數(shù)可以讓我們知道每個(gè)變量指向的是不是同一個(gè)值：
注釋中表示的仍是執(zhí)行后的結(jié)果。如果這時(shí)候我們接下面兩個(gè)語(yǔ)句：
可以看到b引用到了另一個(gè)變量上。
運(yùn)算符
Python中的數(shù)值的基本運(yùn)算和C差不多，字符串的運(yùn)算更方便，下面是常見(jiàn)的例子：
a = 2 b = 2.3 c = 3 a + b # 2 + 2.3 = 4.3 c – a # 3 - 2 = 1 a / b # 整數(shù)除以浮點(diǎn)數(shù)，運(yùn)算以浮點(diǎn)數(shù)為準(zhǔn)，2 / 2.3 = 0.8695652173913044 a / c # Python2中，整數(shù)除法，向下取整 2 / 3 = 0 a ** c # a的c次方，結(jié)果為8 a += 1 # Python中沒(méi)有i++的用法，自增用+= c -= 3 # c變成0了 d = 'Hello' d + ' world!' # 相當(dāng)于字符串拼接，結(jié)果為'Hello world!' d += ' "world"!'# 相當(dāng)于把字符串接在當(dāng)前字符串尾，d變?yōu)?#39;Hello "world"!' e = r'\n\t\\' print(e) # '\\n\\t\\\\'需要提一下的幾點(diǎn)：1）字符串用雙引號(hào)和單引號(hào)都可以，區(qū)別主要是單引號(hào)字符串中如果出現(xiàn)單引號(hào)字符則需要用轉(zhuǎn)義符，雙引號(hào)也是一樣，所以在單引號(hào)字符串中使用雙引號(hào)，或者雙引號(hào)字符串中使用單引號(hào)就會(huì)比較方便。另外三個(gè)雙引號(hào)或者三個(gè)單引號(hào)圍起來(lái)的也是字符串，因?yàn)閾Q行方便，更多用于文檔。2）Python2中兩個(gè)數(shù)值相除會(huì)根據(jù)數(shù)值類型判斷是否整數(shù)除法，Python3中則都按照浮點(diǎn)數(shù)。想要在Python2種也執(zhí)行Python3中的除法只要執(zhí)行下面語(yǔ)句：
3）字符串前加r表示字符串內(nèi)容嚴(yán)格按照輸入的樣子，好處是不用轉(zhuǎn)義符了，非常方便。
Python中的布爾值和邏輯的運(yùn)算非常直接，下面是例子：
a = True b = False a and b # False a or b # True not a # False基本上就是英語(yǔ)，操作符優(yōu)先級(jí)之類的和其他語(yǔ)言類似。Python中也有位操作：
==, !=和is
判斷是否相等或者不等的語(yǔ)法和C也一樣，另外在Python中也常常見(jiàn)到is操作符，這兩者的區(qū)別在于==和!=比較引用指向的內(nèi)存中的內(nèi)容，而is判斷兩個(gè)變量是否指向一個(gè)地址，看下面的代碼例子：
a = 1 b = 1.0 c = 1 a == b # True，值相等 a is b # False，指向的不是一個(gè)對(duì)象，這個(gè)語(yǔ)句等效于 id(a) == id(b) a is c # True，指向的都是整型值1所以一定要分清要比較的對(duì)象應(yīng)該用那種方式，對(duì)于一些特殊的情況，比如None，本著Pythonic的原則，最好用is None。
注意關(guān)鍵字
Python中，萬(wàn)物皆對(duì)象。不過(guò)這并不是這里要探討的話題，想說(shuō)的是一定要注意關(guān)鍵字，因?yàn)樗袞|西都是對(duì)象，所以一個(gè)簡(jiǎn)簡(jiǎn)單單的賦值操作就可以把系統(tǒng)內(nèi)置的函數(shù)給變成一個(gè)普通變量，來(lái)看下邊例子：
id(type) # 506070640L type = 1 # type成了指向1的變量 id(type) # 35556792L id = 2 # id成了指向2的變量 from __future__ import print_function print = 3 # print成了指向3的變量注意print是個(gè)很特殊的存在，在Python3中是按照函數(shù)用，在Python2中卻是個(gè)命令式的語(yǔ)句，最早print的用法其實(shí)是下邊這樣：
print "Hello world!"這么用主要是受到ABC語(yǔ)法的影響，但這個(gè)用法并不Pythonic，后來(lái)加入了print函數(shù)，為了兼容允許兩種用法并存。所以單純給print賦值是不靈的，在Python2中使用Python3中的一些特性都是用from __future__ import來(lái)實(shí)現(xiàn)。
模塊導(dǎo)入
因?yàn)樘岬搅藢?duì)象名覆蓋和import，所以簡(jiǎn)單講一下。import是利用Python中各種強(qiáng)大庫(kù)的基礎(chǔ)，比如要計(jì)算cos(π)的值，可以有下面4種方式：
# 直接導(dǎo)入Python的內(nèi)置基礎(chǔ)數(shù)學(xué)庫(kù) import math print(math.cos(math.pi))# 從math中導(dǎo)入cos函數(shù)和pi變量 from math import cos, pi print(cos(pi))# 如果是個(gè)模塊，在導(dǎo)入的時(shí)候可以起個(gè)別名，避免名字沖突或是方便懶得打字的人使用 import math as m print(m.cos(m.pi))# 從math中導(dǎo)入所有東西 from math import * print(cos(pi))一般來(lái)說(shuō)最后一種方式不是很推薦，因?yàn)椴恢纈mport導(dǎo)入的名字里是否和現(xiàn)有對(duì)象名已經(jīng)有沖突，很可能會(huì)不知不覺(jué)覆蓋了現(xiàn)有的對(duì)象。
5.2.2 容器
列表
Python中的容器是異常好用且異常有用的結(jié)構(gòu)。這節(jié)主要介紹列表（list），元組（tuple），字典（dict）和集合（set）。這些結(jié)構(gòu)和其他語(yǔ)言中的類似結(jié)構(gòu)并無(wú)本質(zhì)不同，來(lái)看例子了解下使用：
a = [1, 2, 3, 4] b = [1] c = [1] d = b e = [1, "Hello world!", c, False] print(id(b), id(c)) # (194100040L, 194100552L) print(id(b), id(d)) # (194100040L, 194100040L) print(b == c) # True f = list("abcd") print(f) # ['a', 'b', 'c', 'd'] g = [0]*3 + [1]*4 + [2]*2 # [0, 0, 0, 1, 1, 1, 1, 2, 2]因?yàn)樽兞科鋵?shí)是個(gè)引用，所以對(duì)列表而言也沒(méi)什么不同，所以列表對(duì)類型沒(méi)什么限制。也正因?yàn)槿绱?#xff0c;和變量不同的是，即使用相同的語(yǔ)句賦值，列表的地址也是不同的，在這個(gè)例子中體現(xiàn)在id(b)和id(c)不相等，而內(nèi)容相等。列表也可以用list()初始化，輸入?yún)?shù)需要是一個(gè)可以遍歷的結(jié)構(gòu)，其中每一個(gè)元素會(huì)作為列表的一項(xiàng)。“*”操作符對(duì)于列表而言是復(fù)制，最后一個(gè)語(yǔ)句用這種辦法生成了分段的列表。
列表的基本操作有訪問(wèn)，增加，刪除，和拼接：
a.pop() # 把最后一個(gè)值4從列表中移除并作為pop的返回值 a.append(5) # 末尾插入值，[1, 2, 3, 5] a.index(2) # 找到第一個(gè)2所在的位置，也就是1 a[2] # 取下標(biāo)，也就是位置在2的值，也就是第三個(gè)值3 a += [4, 3, 2] # 拼接，[1, 2, 3, 5, 4, 3, 2] a.insert(1, 0) # 在下標(biāo)為1處插入元素0，[1, 0, 2, 3, 5, 4, 3, 2] a.remove(2) # 移除第一個(gè)2，[1, 0, 3, 5, 4, 3, 2] a.reverse() # 倒序，a變?yōu)閇2, 3, 4, 5, 3, 0, 1] a[3] = 9 # 指定下標(biāo)處賦值，[2, 3, 4, 9, 3, 0, 1] b = a[2:5] # 取下標(biāo)2開(kāi)始到5之前的子序列，[4, 9, 3] c = a[2:-2] # 下標(biāo)也可以倒著數(shù)，方便算不過(guò)來(lái)的人，[4, 9, 3] d = a[2:] # 取下標(biāo)2開(kāi)始到結(jié)尾的子序列，[4, 9, 3, 0, 1] e = a[:5] # 取開(kāi)始到下標(biāo)5之前的子序列，[2, 3, 4, 9, 3] f = a[:] # 取從開(kāi)頭到最后的整個(gè)子序列，相當(dāng)于值拷貝，[2, 3, 4, 9, 3, 0, 1] a[2:-2] = [1, 2, 3] # 賦值也可以按照一段來(lái)，[2, 3, 1, 2, 3, 0, 1] g = a[::-1] # 也是倒序，通過(guò)slicing實(shí)現(xiàn)并賦值，效率略低于reverse() a.sort() print(a) # 列表內(nèi)排序，a變?yōu)閇0, 1, 1, 2, 2, 3, 3]因?yàn)榱斜硎怯许樞虻?#xff0c;所以和順序相關(guān)的操作是列表中最常見(jiàn)的，首先我們來(lái)打亂一個(gè)列表的順序，然后再對(duì)這個(gè)列表排序：
import random a = range(10) # 生成一個(gè)列表，從0開(kāi)始+1遞增到9 print(a) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] random.shuffle(a) # shuffle函數(shù)可以對(duì)可遍歷且可變結(jié)構(gòu)打亂順序 print(a) # [4, 3, 8, 9, 0, 6, 2, 7, 5, 1] b = sorted(a) print(b) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] c = sorted(a, reverse=True) print(c) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]元組
元組和列表有很多相似的地方，最大的區(qū)別在于不可變，還有如果初始化只包含一個(gè)元素的tuple和列表不一樣，因?yàn)檎Z(yǔ)法必須明確，所以必須在元素后加上逗號(hào)。另外直接用逗號(hào)分隔多個(gè)元素賦值默認(rèn)是個(gè)tuple，這在函數(shù)多返回值的時(shí)候很好用：
集合
集合是一種很有用的數(shù)學(xué)操作，比如列表去重，或是理清兩組數(shù)據(jù)之間的關(guān)系，集合的操作符和位操作符有交集，注意不要弄混：
字典
字典是一種非常常見(jiàn)的“鍵-值”(key-value)映射結(jié)構(gòu)，鍵無(wú)重復(fù)，一個(gè)鍵不能對(duì)應(yīng)多個(gè)值，不過(guò)多個(gè)鍵可以指向一個(gè)值。還是通過(guò)例子來(lái)了解，構(gòu)建一個(gè)名字->年齡的字典，并執(zhí)行一些常見(jiàn)操作：
注意到初始化字典和集合很像，的確如此，集合就像是沒(méi)有值只有鍵的字典。既然有了人名到年齡的映射，也許你立馬想到是否可以給字典排序？在Python3.6之前，這個(gè)問(wèn)題是錯(cuò)誤的，字典是一種映射關(guān)系，沒(méi)有順序。當(dāng)然了，如果要把(鍵, 值)的這種對(duì)進(jìn)行排序，是沒(méi)有問(wèn)題的，前提是先把字典轉(zhuǎn)化成可排序的結(jié)構(gòu)，items()或者iteritems()可以做到這件事，接上段代碼繼續(xù)：
b = a.items() print(b) # [('Tuffy', 2), ('Spike', 10), ('Tom', 8), ('Tyke', 3), ('Jerry', 7)] from operator import itemgetter c = sorted(a.items(), key=itemgetter(1)) print(c) # [('Tuffy', 2), ('Tyke', 3), ('Jerry', 7), ('Tom', 8), ('Spike', 10)] d = sorted(a.iteritems(), key=itemgetter(1)) print(d) # [('Tuffy', 2), ('Tyke', 3), ('Jerry', 7), ('Tom', 8), ('Spike', 10)] e = sorted(a) print(e) # 只對(duì)鍵排序，['Jerry', 'Spike', 'Tom', 'Tuffy', 'Tyke']items()可以把字典中的鍵值對(duì)轉(zhuǎn)化成一個(gè)列表，其中每個(gè)元素是一個(gè)tuple，tuple的第一個(gè)元素是鍵，第二個(gè)元素是值。變量c是按照值排序，所以需要一個(gè)操作符itemgetter，去位置為1的元素作為排序參考，如果直接對(duì)字典排序，則其實(shí)相當(dāng)于只是對(duì)鍵排序。字典被當(dāng)作一個(gè)普通的可遍歷結(jié)構(gòu)使用時(shí)，都相當(dāng)于遍歷字典的鍵。如果覺(jué)得字典沒(méi)有順序不方便，可以考慮使用OrderedDict，使用方式如下：
這樣初始化時(shí)的順序就保留了，除了有序的特性以外，用法上和字典沒(méi)有區(qū)別。2016年9月，Guido宣布在Python3.6中，字典將默認(rèn)有序，這樣就不用糾結(jié)了。另外需要注意的一點(diǎn)是字典是通過(guò)哈希表實(shí)現(xiàn)的，所以鍵必須是可哈希的， list不能被哈希，所以也不能作為字典的鍵，而tuple就可以。
因?yàn)樯仙隙未a中用到了iteritems()，所以這里順帶提一下迭代器（iterator），迭代器相當(dāng)于一個(gè)函數(shù)，每次調(diào)用都返回下一個(gè)元素，從遍歷的角度來(lái)看就和列表沒(méi)有區(qū)別了。iteritems()就是一個(gè)迭代器，所以效果一樣，區(qū)別是迭代器占用更少內(nèi)存，因?yàn)椴恍枰簧蟻?lái)就生成整個(gè)列表。一般來(lái)說(shuō)，如果只需要遍歷一次，用迭代器是更好的選擇，若是要多次頻繁從一個(gè)可遍歷結(jié)構(gòu)中取值，且內(nèi)存夠，則直接生成整個(gè)列表會(huì)更好。當(dāng)然，用迭代器生成一個(gè)完整列表并不麻煩，所以有個(gè)趨勢(shì)是把迭代器作為默認(rèn)的可遍歷方式，比如前面我們使用過(guò)用來(lái)生成等差數(shù)列列表的range()，在Python2中對(duì)應(yīng)的迭代器形式是xrange()。在Python3中，range()就不再產(chǎn)生一個(gè)列表了，而是作為迭代器，xrange()直接沒(méi)了。
5.2.3 分支和循環(huán)
從這節(jié)開(kāi)始，代碼就未必適合在Python終端中輸入了，選個(gè)順手的編輯器或者IDE。作者良心推薦PyCharm，雖然慢，但好用，社區(qū)版免費(fèi)：
PyCharm
for循環(huán)
上面提到的4種容器類型都是可遍歷的，所以該講講用來(lái)遍歷的for循環(huán)了。for循環(huán)的語(yǔ)法也是簡(jiǎn)單的英語(yǔ)：
a = ['This', 'is', 'a', 'list', '!'] b = ['This', 'is', 'a', 'tuple', '!'] c = {'This': 'is', 'an': 'unordered', 'dict': '!'}# 依次輸出：'This', 'is', 'a', 'list', '!' for x in a:print(x)# 依次輸出：'This', 'is', 'a', 'tuple', '!' for x in b:print(x)# 鍵的遍歷。不依次輸出：'This', 'dict', 'an' for key in c:print(key)# 依次輸出0到9 for i in range(10):print(i)注意到每個(gè)for循環(huán)中，print都有縮進(jìn)，這是Python中一個(gè)讓人愛(ài)恨交織的特點(diǎn)：強(qiáng)行縮進(jìn)來(lái)表明成塊的代碼。這樣做的好處是代碼十分清晰工整，還有助于防止寫(xiě)出過(guò)長(zhǎng)的函數(shù)或者過(guò)深的嵌套，壞處是有時(shí)候不知為什么tab和空格就一起出現(xiàn)了，又或是多重if-else不知怎得就沒(méi)對(duì)齊，還是挺麻煩的。
回到for循環(huán)上，這種把每個(gè)元素拿出來(lái)的遍歷方式叫做for_each風(fēng)格，熟悉Java的話就不會(huì)陌生，C++11中也開(kāi)始支持這種for循環(huán)方式。不過(guò)如果還是需要下標(biāo)呢？比如遍歷一個(gè)list的時(shí)候，希望把對(duì)應(yīng)下標(biāo)也打印出來(lái)，這時(shí)可以用enumerate：
names = ["Rick", "Daryl", "Glenn"]# 依次輸出下標(biāo)和名字 for i, name in enumerate(names):print(i, name)需要注意的是，通過(guò)取下標(biāo)遍歷當(dāng)然是可行的，比如用len()函數(shù)獲得列表長(zhǎng)度，然后用range()/xrange()函數(shù)獲得下標(biāo)，但是并不推薦這樣做：
在使用for循環(huán)時(shí)，有時(shí)會(huì)遇到這樣一種場(chǎng)景：我們需要對(duì)遍歷的每個(gè)元素進(jìn)行某種判斷，如果符合這種判斷的情況沒(méi)有發(fā)生，則執(zhí)行一個(gè)操作。舉個(gè)例子某神秘部門(mén)要審核一個(gè)字符串列表，如果沒(méi)有發(fā)現(xiàn)不和諧的字眼，則將內(nèi)容放心通過(guò)，一種解決辦法是下面這樣：
這樣需要設(shè)置一個(gè)標(biāo)記是否發(fā)現(xiàn)不和諧因素的狀態(tài)變量hexie，循環(huán)結(jié)束后再根據(jù)這個(gè)變量判斷內(nèi)容是否可以放心通過(guò)。一種更簡(jiǎn)潔不過(guò)有些小眾的做法是直接和else一起，如果for循環(huán)中的if塊內(nèi)的語(yǔ)句沒(méi)有被觸發(fā)，則通過(guò)else執(zhí)行指定操作：
這樣不需要一個(gè)標(biāo)記是否和諧的狀態(tài)變量，語(yǔ)句簡(jiǎn)潔了很多。
if和分支結(jié)構(gòu)
上一個(gè)例子中已經(jīng)出現(xiàn)if語(yǔ)句了，所以這部分講講if。Python的條件控制主要是三個(gè)關(guān)鍵字：if-elif-else，其中elif就是else if的意思。還是看例子：
pets =['dog', 'cat', 'droid', 'fly']for pet in pets:if pet == 'dog': # 狗糧food = 'steak' # 牛排elif pet == 'cat': # 貓糧food = 'milk' # 牛奶elif pet == 'droid': # 機(jī)器人food = 'oil' # 機(jī)油elif pet == 'fly': # 蒼蠅food = 'sh*t' # else:passprint(food)需要提一下的是pass，這就是個(gè)空語(yǔ)句，什么也不做，占位用。Python并沒(méi)有switch-case的語(yǔ)法，等效的用法要么是像上面一樣用if-elif-else的組合，要么可以考慮字典：
pets = ['dog', 'cat', 'droid', 'fly'] food_for_pet = {'dog': 'steak', 'cat': 'milk', 'droid': 'oil', 'fly': 'sh*t' }for pet in pets:food = food_for_pet[pet] if pet in food_for_pet else Noneprint(food)這里還用到了一個(gè)if-else常見(jiàn)的行內(nèi)應(yīng)用，就是代替三元操作符，如果鍵在字典中，則food取字典的對(duì)應(yīng)值，否則為None。
if表達(dá)式中的小技巧
通過(guò)鏈?zhǔn)奖容^讓語(yǔ)句簡(jiǎn)潔：
if -1 < x < 1: # 相較于 if x > -1 and x < 1:print('The absolute value of x is < 1')判斷一個(gè)值是不是等于多個(gè)可能性中的一個(gè)：
if x in ['piano', 'violin', 'drum']: # 相較于 if x == 'piano' or x == 'violin' or x =='drum':print("It's an instrument!")Python中的對(duì)象都會(huì)關(guān)聯(lián)一個(gè)真值，所以在if表達(dá)式中判斷是否為False或者是否為空的時(shí)候，是無(wú)需寫(xiě)出明確的表達(dá)式的：
a = True if a: # 判斷是否為真，相較于 a is Trueprint('a is True')if 'sky': # 判斷是否空字符串，相較于 len('sky') > 0print('birds')if '': # 判斷是否空字符串，同上print('Nothing!')if {}: # 判斷是否空的容器(字典)，相較于len({}) > 0print('Nothing!')隱式表達(dá)式為False的是如下?tīng)顩r：
- None
- False
- 數(shù)值0
- 空的容器或序列（字符串也是一種序列）
- 用戶自定義類中，如果定義了__len__()或者_(dá)_nonzero__()，并且被調(diào)用后返回0或者False
while循環(huán)
while的就是循環(huán)和if的綜合體，是一種單純的基于條件的循環(huán)，本身沒(méi)有遍歷的意思，這是和for_each的本質(zhì)差別，這種區(qū)別比起C/C++中要明確得多，用法如下：
i = 0 while i < 100: # 笑100遍print("ha")while True: # 一直笑print("ha")5.2.4 函數(shù)、生成器和類
還是從幾個(gè)例子看起：
def say_hello():print('Hello!')def greetings(x='Good morning!'):print(x)say_hello() # Hello! greetings() # Good morning! greetings("What's up!") # What's up! a = greetings() # 返回值是Nonedef create_a_list(x, y=2, z=3): # 默認(rèn)參數(shù)項(xiàng)必須放后面return [x, y, z]b = create_a_list(1) # [1, 2, 3] c = create_a_list(3, 3) # [3, 3, 3] d = create_a_list(6, 7, 8) # [6, 7, 8]def traverse_args(*args):for arg in args:print(arg)traverse_args(1, 2, 3) # 依次打印1, 2, 3 traverse_args('A', 'B', 'C', 'D') # 依次打印A, B, C, Ddef traverse_kargs(**kwargs):for k, v in kwargs.items():print(k, v)traverse_kargs(x=3, y=4, z=5) # 依次打印('x', 3), ('y', 4), ('z', 5) traverse_kargs(fighter1='Fedor', fighter2='Randleman')def foo(x, y, *args, **kwargs):print(x, y)print(args)print(kwargs)# 第一個(gè)pring輸出(1, 2) # 第二個(gè)print輸出(3, 4, 5) # 第三個(gè)print輸出{'a': 3, 'b': 'bar'} foo(1, 2, 3, 4, 5, a=6, b='bar')其實(shí)和很多語(yǔ)言差不多，括號(hào)里面定義參數(shù)，參數(shù)可以有默認(rèn)值，且默認(rèn)值不能在無(wú)默認(rèn)值參數(shù)之前。Python中的返回值用return定義，如果沒(méi)有定義返回值，默認(rèn)返回值是None。參數(shù)的定義可以非常靈活，可以有定義好的固定參數(shù)，也可以有可變長(zhǎng)的參數(shù)(args: arguments)和關(guān)鍵字參數(shù)(kargs: keyword arguments)。如果要把這些參數(shù)都混用，則固定參數(shù)在最前，關(guān)鍵字參數(shù)在最后。
Python中萬(wàn)物皆對(duì)象，所以一些情況下函數(shù)也可以當(dāng)成一個(gè)變量似的使用。比如前面小節(jié)中提到的用字典代替switch-case的用法，有的時(shí)候我們要執(zhí)行的不是通過(guò)條件判斷得到對(duì)應(yīng)的變量，而是執(zhí)行某個(gè)動(dòng)作，比如有個(gè)小機(jī)器人在坐標(biāo)(0, 0)處，我們用不同的動(dòng)作控制小機(jī)器人移動(dòng)：
moves = ['up', 'left', 'down', 'right']coord = [0, 0]for move in moves:if move == 'up': # 向上，縱坐標(biāo)+1coord[1] += 1elif move == 'down': # 向下，縱坐標(biāo)-1coord[1] -= 1elif move == 'left': # 向左，橫坐標(biāo)-1coord[0] -= 1elif move == 'right': # 向右，橫坐標(biāo)+1coord[0] += 1else:passprint(coord) # 打印當(dāng)前位置坐標(biāo)不同條件下對(duì)應(yīng)的是對(duì)坐標(biāo)這個(gè)列表中的值的操作，單純的從字典取值就辦不到了，所以就把函數(shù)作為字典的值，然后用這個(gè)得到的值執(zhí)行相應(yīng)動(dòng)作：
moves = ['up', 'left', 'down', 'right']def move_up(x): # 定義向上的操作x[1] += 1def move_down(x): # 定義向下的操作x[1] -= 1def move_left(x): # 定義向左的操作x[0] -= 1def move_right(x): # 定義向右的操作x[0] += 1# 動(dòng)作和執(zhí)行的函數(shù)關(guān)聯(lián)起來(lái)，函數(shù)作為鍵對(duì)應(yīng)的值 actions = {'up': move_up,'down': move_down,'left': move_left,'right': move_right }coord = [0, 0]for move in moves:actions[move](coord)print(coord)把函數(shù)作為值取到后，直接加一括號(hào)就能使了，這樣做之后起碼在循環(huán)部分看上去很簡(jiǎn)潔。有點(diǎn)C里邊函數(shù)指針的意思，只不過(guò)更簡(jiǎn)單。其實(shí)這種用法在之前講排序的時(shí)候我們已經(jīng)見(jiàn)過(guò)了，就是operator中的itemgetter。itemgetter(1)得到的是一個(gè)可調(diào)用對(duì)象(callable object)，和返回下標(biāo)為1的元素的函數(shù)用起來(lái)是一樣的：
def get_val_at_pos_1(x):return x[1]heros = [('Superman', 99),('Batman', 100),('Joker', 85) ]sorted_pairs0 = sorted(heros, key=get_val_at_pos_1) sorted_pairs1 = sorted(heros, key=lambda x: x[1])print(sorted_pairs0) print(sorted_pairs1)在這個(gè)例子中我們用到了一種特殊的函數(shù)：lambda表達(dá)式。Lambda表達(dá)式在Python中是一種匿名函數(shù)，lambda關(guān)鍵字后面跟輸入?yún)?shù)，然后冒號(hào)后面是返回值（的表達(dá)式），比如上邊例子中就是一個(gè)取下標(biāo)1元素的函數(shù)。當(dāng)然，還是那句話，萬(wàn)物皆對(duì)象，給lambda表達(dá)式取名字也是一點(diǎn)問(wèn)題沒(méi)有的：
some_ops = lambda x, y: x + y + x*y + x**y some_ops(2, 3) # 2 + 3 + 2*3 + 2^3 = 19生成器（Generator）
生成器是迭代器的一種，形式上看和函數(shù)很像，只是把return換成了yield，在每次調(diào)用的時(shí)候，都會(huì)執(zhí)行到y(tǒng)ield并返回值，同時(shí)將當(dāng)前狀態(tài)保存，等待下次執(zhí)行到y(tǒng)ield再繼續(xù)：
# 從10倒數(shù)到0 def countdown(x):while x >= 0:yield xx -= 1for i in countdown(10):print(i)# 打印小于100的斐波那契數(shù) def fibonacci(n):a = 0b = 1while b < n:yield ba, b = b, a + bfor x in fibonacci(100):print(x)生成器和所有可迭代結(jié)構(gòu)一樣，可以通過(guò)next()函數(shù)返回下一個(gè)值，如果迭代結(jié)束了則拋出StopIteration異常：
a = fibonacci(3) print(next(a)) # 1 print(next(a)) # 1 print(next(a)) # 2 print(next(a)) # 拋出StopIteration異常Python3.3以上可以允許yield和return同時(shí)使用，return的是異常的說(shuō)明信息：
類（Class）
Python中的類的概念和其他語(yǔ)言相比沒(méi)什么不同，比較特殊的是protected和private在Python中是沒(méi)有明確限制的，一個(gè)慣例是用單下劃線開(kāi)頭的表示protected，用雙下劃線開(kāi)頭的表示private：
class A:"""Class A"""def __init__(self, x, y, name):self.x = xself.y = yself._name = namedef introduce(self):print(self._name)def greeting(self):print("What's up!")def __l2norm(self):return self.x**2 + self.y**2def cal_l2norm(self):return self.__l2norm()a = A(11, 11, 'Leonardo') print(A.__doc__) # "Class A" a.introduce() # "Leonardo" a.greeting() # "What's up!" print(a._name) # 可以正常訪問(wèn) print(a.cal_l2norm()) # 輸出11*11+11*11=242 print(a._A__l2norm()) # 仍然可以訪問(wèn)，只是名字不一樣 print(a.__l2norm()) # 報(bào)錯(cuò): 'A' object has no attribute '__l2norm'類的初始化使用的是__init__(self,)，所有成員變量都是self的，所以以self.開(kāi)頭。可以看到，單下劃線開(kāi)頭的變量是可以直接訪問(wèn)的，而雙下劃線開(kāi)頭的變量則觸發(fā)了Python中一種叫做name mangling的機(jī)制，其實(shí)就是名字變了下，仍然可以通過(guò)前邊加上“_類名”的方式訪問(wèn)。也就是說(shuō)Python中變量的訪問(wèn)權(quán)限都是靠自覺(jué)的。類定義中緊跟著類名字下一行的字符串叫做docstring，可以寫(xiě)一些用于描述類的介紹，如果有定義則通過(guò)“類名.__doc__”訪問(wèn)。這種前后都加雙下劃線訪問(wèn)的是特殊的變量/方法，除了__doc__和__init__還有很多，這里就不展開(kāi)講了。
Python中的繼承也非常簡(jiǎn)單，最基本的繼承方式就是定義類的時(shí)候把父類往括號(hào)里一放就行了：
class B(A):"""Class B inheritenced from A"""def greeting(self):print("How's going!")b = B(12, 12, 'Flaubert') b.introduce() # Flaubert b.greeting() # How's going! print(b._name()) # Flaubert print(b._A__l2norm()) # “私有”方法，必須通過(guò)_A__l2norm訪問(wèn)5.2.5 map, reduce和filter
map可以用于對(duì)可遍歷結(jié)構(gòu)的每個(gè)元素執(zhí)行同樣的操作，批量操作：
map(lambda x: x**2, [1, 2, 3, 4]) # [1, 4, 9, 16]map(lambda x, y: x + y, [1, 2, 3], [5, 6, 7]) # [6, 8, 10]reduce則是對(duì)可遍歷結(jié)構(gòu)的元素按順序進(jìn)行兩個(gè)輸入?yún)?shù)的操作，并且每次的結(jié)果保存作為下次操作的第一個(gè)輸入?yún)?shù)，還沒(méi)有遍歷的元素作為第二個(gè)輸入?yún)?shù)。這樣的結(jié)果就是把一串可遍歷的值，減少（reduce）成一個(gè)對(duì)象：
reduce(lambda x, y: x + y, [1, 2, 3, 4]) # ((1+2)+3)+4=10filter顧名思義，根據(jù)條件對(duì)可遍歷結(jié)構(gòu)進(jìn)行篩選：
filter(lambda x: x % 2, [1, 2, 3, 4, 5]) # 篩選奇數(shù)，[1, 3, 5]需要注意的是，對(duì)于filter和map，在Python2中返回結(jié)果是列表，Python3中是生成器。
5.2.6 列表生成（list comprehension）
列表生成是Python2.0中加入的一種語(yǔ)法，可以非常方便地用來(lái)生成列表和迭代器，比如上節(jié)中map的兩個(gè)例子和filter的一個(gè)例子可以用列表生成重寫(xiě)為：
[x**2 for x in [1, 2, 3, 4]] # [1, 4, 9 16][sum(x) for x in zip([1, 2, 3], [5, 6, 7])] # [6, 8, 10][x for x in [1, 2, 3, 4, 5] if x % 2] # [1, 3, 5]zip()函數(shù)可以把多個(gè)列表關(guān)聯(lián)起來(lái)，這個(gè)例子中，通過(guò)zip()可以按順序同時(shí)輸出兩個(gè)列表對(duì)應(yīng)位置的元素對(duì)。有一點(diǎn)需要注意的是，zip()不會(huì)自動(dòng)幫助判斷兩個(gè)列表是否長(zhǎng)度一樣，所以最終的結(jié)果會(huì)以短的列表為準(zhǔn)，想要以長(zhǎng)的列表為準(zhǔn)的話可以考慮itertools模塊中的izip_longest()。如果要生成迭代器只需要把方括號(hào)換成括號(hào)，生成字典也非常容易：
iter_odd = (x for x in [1, 2, 3, 4, 5] if x % 2)print(type(iter_odd)) # <type 'generator'>square_dict = {x: x**2 for x in range(5)} # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}至于列表生成和map/filter應(yīng)該優(yōu)先用哪種，這個(gè)問(wèn)題很難回答，不過(guò)Python創(chuàng)始人Guido似乎不喜歡map/filter/reduce，他曾在表示過(guò)一些從函數(shù)式編程里拿來(lái)的特性是個(gè)錯(cuò)誤。
5.2.7 字符串
Python中字符串相關(guān)的處理都非常方便，來(lái)看例子：
a = 'Life is short, you need Python' a.lower() # 'life is short, you need Python' a.upper() # 'LIFE IS SHORT, YOU NEED PYTHON' a.count('i') # 2 a.find('e') # 從左向右查找'e'，3 a.rfind('need') # 從右向左查找'need'，19 a.replace('you', 'I') # 'Life is short, I need Python' tokens = a.split() # ['Life', 'is', 'short,', 'you', 'need', 'Python'] b = ' '.join(tokens) # 用指定分隔符按順序把字符串列表組合成新字符串 c = a + '\n' # 加了換行符，注意+用法是字符串作為序列的用法 c.rstrip() # 右側(cè)去除換行符 [x for x in a] # 遍歷每個(gè)字符并生成由所有字符按順序構(gòu)成的列表 'Python' in a # TruePython2.6中引入了format進(jìn)行字符串格式化，相比在字符串中用%的類似C的方式，更加強(qiáng)大方便：
a = 'I’m like a {} chasing {}.' # 按順序格式化字符串，'I’m like a dog chasing cars.' a.format('dog', 'cars')# 在大括號(hào)中指定參數(shù)所在位置 b = 'I prefer {1} {0} to {2} {0}' b.format('food', 'Chinese', 'American')# >代表右對(duì)齊，>前是要填充的字符，依次輸出： # 000001 # 000019 # 000256 for i in [1, 19, 256]:print('The index is {:0>6d}'.format(i))# <代表左對(duì)齊，依次輸出： # *--------- # ****------ # *******--- for x in ['*', '****', '*******']:progress_bar = '{:-<10}'.format(x)print(progress_bar)for x in [0.0001, 1e17, 3e-18]:print('{:.6f}'.format(x)) # 按照小數(shù)點(diǎn)后6位的浮點(diǎn)數(shù)格式print('{:.1e}'.format(x)) # 按照小數(shù)點(diǎn)后1位的科學(xué)記數(shù)法格式print ('{:g}'.format(x)) # 系統(tǒng)自動(dòng)選擇最合適的格式template = '{name} is {age} years old.' c = template.format(name='Tom', age=8)) # Tom is 8 years old. d = template.format(age=7, name='Jerry')# Jerry is 7 years old.format在生成字符串和文檔的時(shí)候非常有用，更多更詳細(xì)的用法可以參考Python官網(wǎng)：
7.1. string - Common string operations - Python 2.7.13 documentation
5.2.8 文件操作和pickle
在Python中，推薦用上下文管理器（with-as）來(lái)打開(kāi)文件，IO資源的管理更加安全，而且不用老惦記著給文件執(zhí)行close()函數(shù)。還是舉例子來(lái)說(shuō)明，考慮有個(gè)文件name_age.txt，里面存儲(chǔ)著名字和年齡的關(guān)系，格式如下：
Tom,8 Jerry,7 Tyke,3 ...讀取文件內(nèi)容并全部顯示：
with open('name_age.txt', 'r') as f: # 打開(kāi)文件，讀取模式lines = f.readlines() # 一次讀取所有行for line in lines: # 按行格式化并顯示信息name, age = line.rstrip().split(',')print('{} is {} years old.'.format(name, age))open()的第一個(gè)參數(shù)是文件名，第二個(gè)參數(shù)是模式。文件的模式一般有四種，讀取(r)，寫(xiě)入(w)，追加(a)和讀寫(xiě)(r+)。如果希望按照二進(jìn)制數(shù)據(jù)讀取，則將文件模式和b一起使用（wb, r+b…）。
再考慮一個(gè)場(chǎng)景，要讀取文件內(nèi)容，并把年齡和名字的順序交換存成新文件age_name.txt，這時(shí)可以同時(shí)打開(kāi)兩個(gè)文件：
with open('name_age.txt', 'r') as fread, open('age_name.txt', 'w') as fwrite:line = fread.readline()while line:name, age = line.rstrip().split(',')fwrite.write('{},{}\n'.format(age, name))line = fread.readline()有的時(shí)候我們進(jìn)行文件操作是希望把對(duì)象進(jìn)行序列化，那么可以考慮用pickle模塊：
import picklelines = ["I'm like a dog chasing cars.","I wouldn't know what to do if I caught one...","I'd just do things." ]with open('lines.pkl', 'wb') as f: # 序列化并保存成文件pickle.dump(lines, f)with open('lines.pkl', 'rb') as f: # 從文件讀取并反序列化lines_back = pickle.load(f)print(lines_back) # 和lines一樣注意到，序列化的時(shí)候就得使用b模式了。Python2中有個(gè)效率更高的pickle叫cPickle，用法和pickle一樣，在Python3中就只有一個(gè)pickle。
5.2.9 異常
相比起其他一些語(yǔ)言，在Python中我們可以更大膽地使用異常，因?yàn)楫惓Ｔ赑ython中是非常常見(jiàn)的存在，比如下面這種簡(jiǎn)單的遍歷：
a = ['Why', 'so', 'serious', '?']for x in a:print(x)當(dāng)用for進(jìn)行遍歷時(shí)，會(huì)對(duì)要遍歷的對(duì)象調(diào)用iter()。這需要給對(duì)象創(chuàng)建一個(gè)迭代器用來(lái)依次返回對(duì)象中的內(nèi)容。為了能成功調(diào)用iter()，該對(duì)象要么得支持迭代協(xié)議(定義__iter__())，要么得支持序列協(xié)議(定義__getitem__())。當(dāng)遍歷結(jié)束時(shí)，__iter__()或者_(dá)_getitem__()都需要拋出一個(gè)異常。__iter__()會(huì)拋出StopIteration，而__getitem__()會(huì)拋出IndexError，于是遍歷就會(huì)停止。
在深度學(xué)習(xí)中，尤其是數(shù)據(jù)準(zhǔn)備階段，常常遇到IO操作。這時(shí)候遇到異常的可能性很高，采用異常處理可以保證數(shù)據(jù)處理的過(guò)程不被中斷，并對(duì)有異常的情況進(jìn)行記錄或其他動(dòng)作：
for filepath in filelist: # filelist中是文件路徑的列表try:with open(filepath, 'r') as f:# 執(zhí)行數(shù)據(jù)處理的相關(guān)工作...print('{} is processed!'.format(filepath))except IOError:print('{} with IOError!'.format(filepath))# 異常的相應(yīng)處理...5.2.10 多進(jìn)程（multiprocessing）
深度學(xué)習(xí)中對(duì)數(shù)據(jù)高效處理常常會(huì)需要并行，這時(shí)多進(jìn)程就派上了用場(chǎng)。考慮這樣一個(gè)場(chǎng)景，在數(shù)據(jù)準(zhǔn)備階段，有很多文件需要運(yùn)行一定的預(yù)處理，正好有臺(tái)多核服務(wù)器，我們希望把這些文件分成32份，并行處理：
from multiprocessing import Process#, freeze_supportdef process_data(filelist):for filepath in filelist:print('Processing {} ...'.format(filepath))# 處理數(shù)據(jù)...if __name__ == '__main__':# 如果是在Windows下，還需要加上freeze_support()#freeze_support()# full_list包含了要處理的全部文件列表...n_total = len(full_list) # 一個(gè)遠(yuǎn)大于32的數(shù)n_processes = 32# 每段子列表的平均長(zhǎng)度length = float(n_total) / float(n_processes)# 計(jì)算下標(biāo)，盡可能均勻地劃分輸入文件列表indices = [int(round(i*length)) for i in range(n_processes+1)]# 生成每個(gè)進(jìn)程要處理的子文件列表sublists = [full_list[indices[i]:indices[i+1]] for i in range(n_processes)]# 生成進(jìn)程processes = [Process(target=process_data, args=(x,)) for x in sublists]# 并行處理for p in processes:p.start()for p in processes:p.join()其中if __name__ == '__main__'用來(lái)標(biāo)明在import時(shí)不包含，但是作為文件執(zhí)行時(shí)運(yùn)行的語(yǔ)句塊。為什么不用多線程呢？簡(jiǎn)單說(shuō)就是Python中線程的并發(fā)無(wú)法有效利用多核，如果有興趣的讀者可以從下面這個(gè)鏈接看起：
GlobalInterpreterLock - Python Wiki
5.2.11 os模塊
深度學(xué)習(xí)中的數(shù)據(jù)多是文件，所以數(shù)據(jù)處理階段和文件相關(guān)的操作就非常重要。除了文件IO，Python中一些操作系統(tǒng)的相關(guān)功能也能夠非常方便地幫助數(shù)據(jù)處理。想象一下我們有一個(gè)文件夾叫做data，下邊有3個(gè)子文件夾叫做cat，dog和bat，里面分別是貓，狗和蝙蝠的照片。為了訓(xùn)練一個(gè)三分類模型，我們先要生成一個(gè)文件，里面每一行是文件的路徑和對(duì)應(yīng)的標(biāo)簽。定義cat是0，dog是1，bat是2，則可以通過(guò)如下腳本：
import os# 定義文件夾名稱和標(biāo)簽的對(duì)應(yīng)關(guān)系 label_map = {'cat': 0,'dog': 1,'bat': 2 }with open('data.txt', 'w') as f:# 遍歷所有文件，root為當(dāng)前文件夾，dirs是所有子文件夾名，files是所有文件名for root, dirs, files in os.walk('data'):for filename in files:filepath = os.sep.join([root, filename]) # 獲得文件完整路徑dirname = root.split(os.sep)[-1] # 獲取當(dāng)前文件夾名稱label = label_map[dirname] # 得到標(biāo)簽line = '{},{}\n'.format(filepath, label)f.write(line)其中，os.sep是當(dāng)前操作系統(tǒng)的路徑分隔符，在Unix/Linux中是'/'，Windows中是'\\'。有的時(shí)候我們已經(jīng)有了所有的文件在一個(gè)文件夾data下，希望獲取所有文件的名稱，則可以用os.listdir():
filenames = os.listdir('data')os也提供了諸如拷貝，移動(dòng)和修改文件名等操作。同時(shí)因?yàn)榇蟛糠稚疃葘W(xué)習(xí)框架最常見(jiàn)的都是在Unix/Linux下使用，并且Unix/Linux的shell已經(jīng)非常強(qiáng)大（比Windows好用太多），所以只需要用字符串格式化等方式生成shell命令的字符串，然后通過(guò)os.system()就能方便實(shí)現(xiàn)很多功能，有時(shí)比os，還有Python中另一個(gè)操作系統(tǒng)相關(guān)模塊shutil還要方便：
import os, shutilfilepath0 = 'data/bat/IMG_000001.jpg' filepath1 = 'data/bat/IMG_000000.jpg'# 修改文件名 os.system('mv {} {}'.format(filepath0, filepath1)) #os.rename(filepath0, filepath1)# 創(chuàng)建文件夾 dirname = 'data_samples' os.system('mkdir -p {}'.format(dirname)) #if not os.path.exists(dirname): # os.mkdir(dirname)# 拷貝文件 os.system('cp {} {}'.format(filepath1, dirname)) #shutil.copy(filepath1, dirname) 創(chuàng)作挑戰(zhàn)賽新人創(chuàng)作獎(jiǎng)勵(lì)來(lái)咯，堅(jiān)持創(chuàng)作打卡瓜分現(xiàn)金大獎(jiǎng)總結(jié)
以上是生活随笔為你收集整理的人生苦短，我用Python（Python快速教程 - 基础篇）的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。
- 上一篇： python中写入文件数据及文件定位操作
- 下一篇： python中的多线程-共享全局变量