摘要：本文的分享主要圍繞以下幾個方面能做什么常見應(yīng)用場景介紹如何學(xué)習(xí)語法基礎(chǔ)實戰(zhàn)面向?qū)ο缶幊虒崙?zhàn)練熟基礎(chǔ)小游戲項目的實現(xiàn)與實戰(zhàn)一能做什么一種編程語言往往可以應(yīng)用于多方面，有些方面比較常用，有些方面極為常用。比如表示是一個空列表。

摘要：Python語言的教程雖然隨處可見，但是忙于日常業(yè)務(wù)/學(xué)習(xí)的你或許：一直想要“找個時間學(xué)一點”，但是又不知道該從何下手？本文將從Python能做什么，如何學(xué)習(xí)Python以及Python的基礎(chǔ)知識為你的Python之路點上一盞明燈。

本文內(nèi)容根據(jù)演講視頻以及PPT整理而成。

本文的分享主要圍繞以下幾個方面：

Python能做什么?(常見應(yīng)用場景介紹)

如何學(xué)習(xí)Python？

Python語法基礎(chǔ)實戰(zhàn)

Python面向?qū)ο缶幊虒崙?zhàn)

練熟基礎(chǔ)：2048小游戲項目的實現(xiàn)與實戰(zhàn)

一種編程語言往往可以應(yīng)用于多方面，有些方面比較常用，有些方面極為常用。上圖中標紅的部分是Python極為常用的領(lǐng)域。首先，利用Python可以進行簡單腳本編程，比如使用Python編寫2048小游戲或12306的自動搶票軟件。其次，可以使用Python進行系統(tǒng)編程，開發(fā)系統(tǒng)應(yīng)用。第三點，Python一個較為常用的功能就是開發(fā)網(wǎng)絡(luò)爬蟲。網(wǎng)絡(luò)爬蟲的用途是進行數(shù)據(jù)采集，也就是將互聯(lián)網(wǎng)中的數(shù)據(jù)采集過來。網(wǎng)絡(luò)爬蟲的難點其實并不在于爬蟲本身，由于網(wǎng)站方為了避免被爬取回采取各種各樣的反爬蟲措施，而如果想要繼續(xù)從網(wǎng)站爬取數(shù)據(jù)就需要解決這些反爬蟲措施，所以網(wǎng)絡(luò)爬蟲的難點在于反爬的攻克和處理。第四點，Python極常用于WEB開發(fā)，可以借助Python開發(fā)WEB站點，比如個人博客、在線教育網(wǎng)站以及論壇等。第五點，在運維方面，Python可以用于自動化運維，可以通過寫Python腳本實現(xiàn)對于服務(wù)器集群進行自動化管理。第六點，Python可以用于網(wǎng)絡(luò)編程，比如Socket編程等。第七點，Python極常用的一個方向就是數(shù)據(jù)挖掘、機器學(xué)習(xí)等大數(shù)據(jù)與人工智能領(lǐng)域方向的程序開發(fā)，比如在人工智能領(lǐng)域，使用Python就可以很容易地實現(xiàn)算法模型，并且借助Python可以很容易地處理相應(yīng)的數(shù)據(jù)。

作為系列文章的首篇，本文將為大家分享Python的基礎(chǔ)知識。而學(xué)習(xí)Python基礎(chǔ)的第一步就是認識Python可以干什么，通過上面的內(nèi)容，大家可以了解到Python語言可以做很多事情，或者可以說Python基本上是一門全能的語言。Python在各個領(lǐng)域都很優(yōu)秀，而最重要的一點就是Python比較易學(xué)。綜上所述，Python是一門非常棒的語言。

首先與大家分享一些方法論，究竟應(yīng)該如何學(xué)習(xí)Python？其實學(xué)習(xí)任何一門知識，方法都是類似的，有些同學(xué)習(xí)慣直接看書或看視頻，這些方法都不錯，但是在學(xué)習(xí)的過程中需要掌握一些技巧，這樣學(xué)習(xí)起來會事半功倍。

成體系地學(xué)，不搞“題海戰(zhàn)術(shù)”

首先，要學(xué)就要成體系地學(xué)，不搞“題海戰(zhàn)術(shù)”。遇到新知識就去查，然后就知道了，反復(fù)這樣就是所謂的“題海戰(zhàn)術(shù)”，這樣做的好處就是用到了就會去尋找，但是缺點就是腦海里面的知識體系會非常亂，而且越學(xué)越亂，因為太多東西在腦海中不成體系地堆積導(dǎo)致非常難以利用，所以需要成體系地學(xué)習(xí)。所謂成體系地學(xué)習(xí)，就比如在學(xué)習(xí)基礎(chǔ)時可以先掌握數(shù)據(jù)類型、控制結(jié)構(gòu)、函數(shù)以及模塊等，將這些知識形成體系。構(gòu)建知識體系就像寫書一樣，在寫書的過程中不可能想到哪里就寫到哪里，而應(yīng)該有一個大致的框架。成體系地學(xué)習(xí)的好處就是無論怎樣學(xué)習(xí)都不會亂。而且最開始的體系不一定是非常完備的，比如在剛開始學(xué)習(xí)編程語言的時候可能并不知道迭代器和生成器，但這并不會影響知識體系的建立，而在后續(xù)學(xué)到迭代器和生成器的時候，再將這一部分的知識加入到知識體系中就可以了。但是這樣的前提就是在腦海中一定要有一個非常清晰的體系結(jié)構(gòu)，學(xué)到的新知識都可以歸入到體系中，如果遇到了知識體系中沒有的內(nèi)容就可以對應(yīng)地進行補充，這樣就形成了非常清晰的體系結(jié)構(gòu)，這樣的學(xué)習(xí)方法收益會比較大。

不僅要“摹”，還要“臨”

其次，不僅要“摹”，還要“臨”?！芭R摹”是練習(xí)書法的手段，所謂“臨”就是看著字帖中的字，憑著印象在紙上書寫并且盡量復(fù)現(xiàn)字帖中的字；所謂“摹”就是在字帖上面蒙上一層薄白紙，然后在上面跟著字帖直接描。在“臨”與“摹”中，顯然后者更為簡單。其實，學(xué)習(xí)任何一門知識都一樣，不僅要“摹”，還要“臨”。在學(xué)習(xí)Python等編程語言時，一些同學(xué)可能學(xué)習(xí)時看看視頻就過去了，這樣顯然是不可取的，好一點的同學(xué)會在看過視頻之后，跟著視頻把代碼敲一遍，但是這樣只是進行了“摹”，應(yīng)該在此基礎(chǔ)之上加上“臨”的步驟，也就是關(guān)上視頻、合上書本之后，憑借記憶對代碼進行復(fù)現(xiàn)，去想自己的代碼需要實現(xiàn)哪些功能，這樣才能將知識真正地吸收。這樣練習(xí)久了之后就會發(fā)現(xiàn)自己的能力提升得非?？臁?/p>

通所有不如精一物，精一物方可通所有

第三個學(xué)習(xí)方法就是通所有不如精一物，精一物方可通所有。大家在學(xué)習(xí)的時候可能會遇到很多的框架，但是其實并不需要掌握所有的框架，比如對于爬蟲而言，既可以學(xué)習(xí)Scrapy，也可以學(xué)習(xí)urllib，還可以學(xué)習(xí)其他的框架。其實并不用掌握所有的框架，學(xué)習(xí)時可以深入地掌握其中一兩個框架，之后就會發(fā)現(xiàn)所有的框架都是萬變不離其宗的。精通一兩個框架之后，其他的框架也會很容易掌握。學(xué)習(xí)編程語言也是一樣的，當你精通了PHP或者Java，Python也能很快學(xué)會，但是如果同時學(xué)習(xí)Java、Python和PHP，最終可能導(dǎo)致每一門語言都不精通。其實學(xué)習(xí)過程的曲線在剛開始的基礎(chǔ)階段上升會非常慢，但是只要上手之后，進度就會非?？欤源蠹以趯W(xué)習(xí)基礎(chǔ)的時候一定不要著急。

走心學(xué)，忌浮躁

第四個學(xué)習(xí)方法就是走心學(xué)，忌浮躁。學(xué)習(xí)的時候一定要投入心思，不要著急，盡量地將知識掌握和精通。更加具體的學(xué)習(xí)方法，大家可以關(guān)注云棲社區(qū)上的這個聚能聊：https://yq.aliyun.com/roundta...。

在Python語法的基礎(chǔ)實戰(zhàn)這部分將與大家分享數(shù)據(jù)類型、控制結(jié)構(gòu)、函數(shù)與模塊、文件操作與數(shù)據(jù)庫操作以及異常處理等內(nèi)容。

Python基礎(chǔ)知識入門

在Python中輸出直接使用print()函數(shù)，如果在Python文件中重復(fù)四次print("Hello Python")，那么輸出時就是四次“Hello Python”。如果想讓某一行代碼不起作用，可以使用注釋。在Python中有兩種比較常見的注釋方案，第一種是單行注釋，在行首加“#”，這樣就會注釋掉這一行代碼；第二種是多行注釋，多行注釋一般使用“"""”或“"""”(三引號)實現(xiàn)，直接將需要注釋的代碼段的首部和尾部加上三個引號即可。

數(shù)據(jù)類型

在學(xué)習(xí)任何一門編程語言時，都需要了解這門編程語言有哪些數(shù)據(jù)類型。在Python中，常見的數(shù)據(jù)類型有數(shù)、字符串、列表、元祖、集合以及字典等。

數(shù)：就是數(shù)學(xué)上的數(shù)字，比如“a=7”就是將數(shù)字7賦值給a，這里的等號是賦值的意思。想要查看對應(yīng)的數(shù)據(jù)是什么類型可以使用type()函數(shù)查看，比如7就是int整形，7.0就是float浮點型。

字符串：一系列字符所組成的序列叫做字符串。字符串一般使用引號將其引起來，這里使用單引號和雙引號均可。比如：

a1="abc"
a2="abc"
a3="""ab
c"""

上述代碼所表達的內(nèi)容是相同的，區(qū)別在于使用單引號和雙引號所引起來的內(nèi)容不能直接換行，而使用三引號就可以。

列表：存儲多個元素的容器，列表中的元素可以被重新賦值，也就是說列表中的元素是可以變化的。建立列表可以通過“[]”實現(xiàn)，在其中可以放置數(shù)據(jù)。比如：a=[]表示a是一個空列表。再比如a=[a1,a3]，列表中每個元素之間使用逗號隔開，a這個列表中包含了a1和a3兩個元素。取其中的元素可以通過下標實現(xiàn)，比如a[1]就可以取出a1的值。而列表中的元素可以被重新定義，比如使用a[1]="hello" 就可以對原本a[1]的位置進行賦值，這就說明了列表中的元素是可以變化的。

元組：存儲多個元素的容器，但是元組中的元素不可以被重新賦值。比如c=(7,"cd",9)，c存儲了一組數(shù)據(jù)，如果想要對c中任意位置賦值成為其他的數(shù)據(jù)，都是不可以的，因為元組內(nèi)的數(shù)據(jù)是不能被更改的。所以，元組一般在對數(shù)據(jù)安全要求較高時使用，這也是元組與列表的區(qū)別。

字典：字典相當于關(guān)聯(lián)數(shù)組，所謂關(guān)聯(lián)數(shù)組就是里面需要存儲一對信息的數(shù)組。列表和元組存儲的元素都是一個，而字典存儲的元素都是一對信息如d={"name":"weiwei","sex":"boy","job":"teacher"}這樣的{鍵：值, 鍵：值, ...}。在取值的時候直接使用字典名["對應(yīng)鍵名"]即可，比如對于上訴d這個字典，使用d["name"]就可以取到"weiwei"這個值。

集合：集合也是用于存儲一組數(shù)據(jù)的，只不過集合的特性是不允許出現(xiàn)重復(fù)的元素，這一點大家早在高中就已經(jīng)學(xué)習(xí)了。所以，集合的一個非常簡單的應(yīng)用就是去重，之所以說這個方法簡單，是因為去重還有很多的實現(xiàn)方法，比如布隆過濾器等都是非常好的去重方式。在Python中直接通過set就可以直接建立集合，比如e=set("abcdefgabc")，而集合是通過“{}”存儲的，只不過大括號里面直接存儲元素。而當輸出e時就會發(fā)現(xiàn)，原本重復(fù)的內(nèi)容就只保留一個。此外，集合還可以用于差集的運算，比如e=set("abcgjkhsgkjha")，f=set("jikhsdghsdueigdsfzau")直接使用g=e-f就可以獲得e與f的差集。

運算符

以上的這些數(shù)據(jù)類型歸根結(jié)底都是數(shù)據(jù)。數(shù)據(jù)是靜態(tài)的，而通過運算符進行運算就可以讓這些數(shù)據(jù)動起來。Python里面的運算符有哪些呢？首先就是大家非常熟悉的“+-/%”，這些運算都滿足數(shù)學(xué)規(guī)律。除了“+-/%”之外，還有字符串連接符“+”，如果想要將兩個字符串連接起來只需要用“+”即可。

縮進問題

可能某些同學(xué)對于Python的縮進比較反感，會覺得縮進很麻煩并且非常容易出錯。但是實際上，縮進很美，當打開Python項目時就會發(fā)現(xiàn)層次感很強，會感受到代碼的美感，哪些代碼屬于同一層級是一目了然的?？s進所需要掌握的規(guī)律就是最開始的代碼頂格，第二點就是同一層級的代碼在同一個縮進幅度上，下一個層級的代碼在下一個縮進幅度上。當掌握了縮進規(guī)律之后，再去寫Python代碼就會很容易了。

控制結(jié)構(gòu)
所謂控制結(jié)構(gòu)就是程序的執(zhí)行結(jié)構(gòu)，程序可以像流水賬一樣順序執(zhí)行下去，也可以跳躍、循環(huán)以及分支執(zhí)行，這些多種的執(zhí)行方式叫做控制結(jié)構(gòu)。實際上，Python中最常用的控制結(jié)構(gòu)只有三種就是：順序結(jié)構(gòu)、選擇結(jié)構(gòu)和循環(huán)結(jié)構(gòu)，當然還有一些不常用的控制結(jié)構(gòu)比如中斷結(jié)構(gòu)等。

順序結(jié)構(gòu)不必多講，就是按照順序?qū)?，程序也就按照順序?zhí)行。在Python中，分支結(jié)構(gòu)通常使用if語句實現(xiàn)，如果if的條件為真，則執(zhí)行下面對應(yīng)的代碼，否則繼續(xù)向下看是否有分支結(jié)構(gòu)，如果有則繼續(xù)執(zhí)行，否則就執(zhí)行這一部分內(nèi)容；如果if的條件為假，就不執(zhí)行下面對應(yīng)的代碼。如下示例代碼：

a=1000
b=1
if(a>19 and a<30):
    print(a)
    if(b<9):
        print(b)
elif(a>9 and a<=19):
    print("a>9 and a<=19")
elif(a<9):
    print("a<9")
else:
    print("gsdajk")

上述代碼中第3行的if條件判定結(jié)果為真，程序會執(zhí)行第4行至第6行代碼。如果第3行的if判定為假，則繼續(xù)向下面找尋分支。第7行和第9行都存在elif，其意思就是在不滿足if的情況下如果滿足elif的條件，就執(zhí)行elif下面的代碼，如果上述兩行的elif條件都不滿足，在第11行還有一個else，其意思就是在上述條件都不滿足的情況下，執(zhí)行else下面的代碼。上述代碼最終將會輸出“gsdajk”。這里值得說明的一點就是如果實際情況不需要，可以沒有elif以及else等語句，也就是可以多帶帶使用if語句。

循環(huán)結(jié)構(gòu)也是一個極為重要的結(jié)構(gòu)。在Python中，循環(huán)結(jié)構(gòu)有相應(yīng)的方法去實現(xiàn)，常用的有兩種：while和for語句。while語句的格式如下所示：

a=0
while(a<10):
    print("hello")
    a+=1

首先寫while的條件，所謂的條件就是while括號中的表達式。如果條件為真就意味著滿足了while的條件，這樣就會執(zhí)行while下面的代碼段，而在執(zhí)行時不是僅執(zhí)行一次就結(jié)束，而是只要while循環(huán)的條件一直滿足，這段代碼就會一直執(zhí)行。上述代碼中，a的初始值為0，循環(huán)結(jié)構(gòu)中將會打印“hello”并使得a自增1，當a<10時循環(huán)結(jié)構(gòu)就會一直執(zhí)行，所以將會輸出10次“hello”。當?shù)綀?zhí)行到第10次之后，a就不滿足小于10的條件了，于是就會跳出循環(huán)。

除了while循環(huán)之外，還有for循環(huán)。for循環(huán)的寫法稍有不同，常用的格式是for i in x，x一般而言是一組數(shù)據(jù)。for循環(huán)遍歷列表示例如下，該程序?qū)h(huán)輸出列表中的各個元素。

a=["aa","b","c","d"]
for i in a:
    print(i)

for進行常規(guī)循環(huán)的寫法是for i in range()，也就是從X到Y(jié)的意思。比如for i in range(2,5)就是遍歷2、3、4，這里值得注意的就是遍歷不到最后的元素，在該例子中遍歷不到5。如下列代碼將會輸出10次“hello”。

for i in range(0,10):
    print("hello")

中斷結(jié)構(gòu)是一種特殊的控制結(jié)構(gòu)，就是在程序執(zhí)行過程中進行中斷，一般而言都是在循環(huán)過程中進行中斷。通常，中斷結(jié)構(gòu)有兩種寫法：break與continue。break的含義是直接退出循環(huán)，整個循環(huán)都會中斷。continue指的是中斷單次循環(huán)，會繼續(xù)下一次循環(huán)。

a=["aa","b","c","d"]
for i in a:
    if(i=="c"):
        break
    print(i)

上述代碼使用break中斷循環(huán)，使用i循環(huán)遍歷a列表，如果i=="c"則中斷循環(huán)，直接break。上述代碼的結(jié)果就是輸出aa與b，但是不會輸出c之后的元素，因為當循環(huán)遍歷到c時就會break，然后終止整個循環(huán)。

a=["aa","b","c","d"]
for i in a:
    if(i=="c"):
        continue
    print(i)

而當將break替換為continue后，運行該段代碼的輸出結(jié)果除了aa、b之外，還會輸出d，這是因為continue僅中斷單詞循環(huán)，不會影響下一次循環(huán)。上述代碼在遍歷到數(shù)組中元素c時，會中斷所以不輸出c，然后循環(huán)還會繼續(xù)。
使用Python輸出乘法口訣表

for i in range(1,10):
    for j in range(1,i+1):
        print(str(i)+"*"+str(j)+"="+str(i*j),end="  ")
    print()

如上述代碼所示，乘法口訣表分為行和列的控制，最外層循環(huán)控制行數(shù)，所以外層循環(huán)是for i in range(1,10)，就是從1一直遍歷到10。而對于列的控制就需要內(nèi)層循環(huán)，顯然就是在i層下面再進行一層循環(huán)，如上述代碼中的for j in range(1,i+1)，因為當遍歷到1的時候，結(jié)果是11，不需要繼續(xù)寫12，所以這里只需要遍歷到i+1即可。具體的輸出只需要進行簡單的數(shù)學(xué)運算和字符串拼接即可，在print輸出之后如果不通過end控制是會默認更換一行的，這樣輸出的結(jié)果不夠美觀，上述代碼的寫法可以使得同一行print輸出的結(jié)果之間隔一個空格。而在完成了j的遍歷之后需要另起一行，所以需要print()。運行結(jié)果如下圖所示：

在理解了乘法口訣表的實現(xiàn)之后，大家應(yīng)該思考如何將乘法口訣表逆序輸出，形成倒三角形式。顯然，只需要對代碼做如下修改即可：

for i in range(9,0,-1):
    for j in range(i,0,-1):
        print(str(i)+"*"+str(j)+"="+str(i*j),end="  ")
    print()

對于控制結(jié)構(gòu)而言，大家需要重點掌握循環(huán)和分支。
函數(shù)與模塊
函數(shù)相當于功能的封裝。舉例而言，某個程序段可能會被經(jīng)常調(diào)用，如果不進行功能封裝，那么每次調(diào)用這個功能時就需要重新實現(xiàn)一遍該段程序，這就會帶來很多麻煩。而現(xiàn)在可以將這個經(jīng)常被調(diào)用的程序段封裝成一個函數(shù)，如果需要實現(xiàn)這個功能就可以直接調(diào)用這個封裝好的函數(shù)。接下來就與大家分享與函數(shù)相關(guān)的內(nèi)容。
作用域：作用域一般而言指的是變量的作用范圍。

i=10
def func():
    print(i)
func()

如上述代碼，將10賦值給i之后，i的作用范圍就是后面的全部代碼，一直到程序結(jié)束為止，那么這些被覆蓋到的范圍就是變量i的作用域。而在下面的代碼中，當i在函數(shù)里面被定義，并且沒有用global關(guān)鍵字聲明，正常情況下其作用范圍僅限于該函數(shù)。

def func():
    i=10
    print(i)
func()

上述代碼中，i的作用范圍僅限于func()函數(shù)中。而如果變量在函數(shù)外部定義，那么在函數(shù)內(nèi)部可以使用該變量，但是卻無法直接修改該變量的值。如果對其進行修改就會造成命名空間沖突，出現(xiàn)錯誤。解決上述問題的答案其實很簡單，就是將變量用global關(guān)鍵字聲明為全局變量即可。

i=10
def func():
    global i
    print(i)
func()

上述代碼中的i就是全局變量，當將變量聲明為全局變量之后就不會受局部變量的影響了。
函數(shù)定義的格式：函數(shù)定義的格式就是如何將一串代碼封裝為成函數(shù)的方式。函數(shù)是通過def關(guān)鍵字定義的，函數(shù)定義格式如下：

def 函數(shù)名(參數(shù)):
    函數(shù)體

下面的代碼建立了函數(shù)abc()，函數(shù)的參數(shù)可以沒有，但需要注意即使沒有參數(shù)也需要加括號。示例代碼中相當于將兩個print語句進行了封裝。如果想要將上述兩個print語句統(tǒng)一進行一次執(zhí)行時只需要調(diào)用abc()函數(shù)即可。在調(diào)用函數(shù)時只需要使用“函數(shù)名(參數(shù))”。

def abc():
    print("abcde")
    print("456")
abc()

函數(shù)參數(shù)：如果函數(shù)沒有參數(shù)，那么這個函數(shù)就是固定的，因為該函數(shù)內(nèi)部的代碼是固定的，所以無論怎樣執(zhí)行都是同樣的結(jié)果。而如何使得函數(shù)能夠?qū)崿F(xiàn)具體問題具體分析呢？此時可以為其傳入相應(yīng)的參數(shù)，這樣函數(shù)就可以根據(jù)所傳入的參數(shù)進行相應(yīng)的數(shù)據(jù)處理。參數(shù)就相當于函數(shù)與外界溝通的接口。參數(shù)分為形參和實參，一般而言在函數(shù)定義的時候使用參數(shù)就是形參，所謂形參就是“形式上的參數(shù)”；在函數(shù)調(diào)用的時候使用的就是實參，而所謂的實參就是“實際的參數(shù)”。如下的代碼段中實現(xiàn)了兩個數(shù)據(jù)比較大小的功能：

def func2(a,b):
    if(a>b):
        print(str(a)+"比"+str(b)+"大")
    else:
        print(str(b)+"比"+str(a)+"大或者"+str(b)+"與"+str(a)+"相等")

上述代碼中封裝了一個名為func2的函數(shù)，里面?zhèn)鬟f兩個參數(shù)，參數(shù)的名字可以自行定義，函數(shù)里面則可以根據(jù)具體的形參進行判斷。上述代碼中如果a>b，輸出“a比b大”，否則就輸出“b比a大或者b與a相等”。對于上述函數(shù)，每次調(diào)用時可以傳遞不同的參數(shù)進去，進而根據(jù)具體情況具體分析，并得到相應(yīng)的結(jié)果。綜上所述，函數(shù)就是將一串代碼進行封裝，即函數(shù)一般用于功能的封裝。
模塊：模塊就相當于函數(shù)的再次封裝。Python中有一些常用的模塊，這些常用的模塊存在于Python的安裝目錄之下，其中有一個名為“l(fā)ib”的目錄，該目錄一般就用于放置模塊，而且大家也可以自己寫模塊，這樣的模塊就叫做自定義模塊。
在Python中想要使用模塊需要掌握兩個知識點：導(dǎo)入和使用。一般而言有幾種方法導(dǎo)入模塊，第一種方法就是使用import語句直接導(dǎo)入某個模塊，第二種方法就是從某個模塊中僅導(dǎo)入某個方法。如下代碼所示，可以從time模塊中導(dǎo)入sleep方法，也可以使用from time import *將time模塊的所有方法都導(dǎo)入進來。

import random
from time import sleep
from time import *
a=["中獎","不中獎","不中獎"]
print(random.choice(a))

random模塊主要用于隨機數(shù)的處理。上述代碼使用random實現(xiàn)了一個抽獎功能，首先導(dǎo)入了random，然后建立一個列表，里面有“中獎”和“不中獎”選項，random.choice(a)將會隨機在列表a中選擇一個選項并輸出對應(yīng)的結(jié)果。time模塊也有一些比較常用的功能，比如time.sleep()，其實現(xiàn)了延時功能。如果想要修改模塊的源代碼，只需要在lib目錄下找到相應(yīng)的模塊進行修改即可。

此外，第三方的模塊一般放置在lib目錄下的site-packages中。

文件操作

文件的打開：使用Python打開文件方法的格式就是open(文件地址,操作形式)，open函數(shù)的參數(shù)中的操作形式有：w(寫入)、r(讀取)、b(二進制)、a(追加)，其中的a表示可以實現(xiàn)追加寫入，這樣就不會丟失原來的內(nèi)容，如果使用w就是全新寫入，將會覆蓋原本的內(nèi)容。

    fh=open("D:/我的教學(xué)/Python/20180120內(nèi)訓(xùn)/第1天代碼/文本1.txt","r",encoding="utf-8")
#

    文件讀取
    data=fh.read()
    line=fh.readline()

上述代碼中的操作形式是“r”，也就是讀取文檔，并且可以通過encoding設(shè)置編碼格式，比如utf-8或者gbk等，這樣就可以打開文件。之后就可以通過read()或者readline()等方法進行讀取。read()指的是將文件中的內(nèi)容全部讀取出來，readline()則是一行行地讀取。

x=0
fh=open("D:/我的教學(xué)/Python/20180120內(nèi)訓(xùn)/第1天代碼/文本1.txt","r",encoding="gbk")
while True:
    line2=fh.readline()
    if(len(line2)==0):
        break
    print(line2)
    x+=1
fh.close()

上述代碼中使用readline()一行行地讀取文件，這里通過設(shè)置while循環(huán)來讀取文件全部內(nèi)容，如果某一行的長度為0則說明文件已經(jīng)讀完，此時就可以break，而如果不為0則說明還有內(nèi)容，就可以繼續(xù)讀取下一行。上述代碼中還通過變量x統(tǒng)計共讀取了多少次，在文件讀取完后通過fh.close()關(guān)閉文件。結(jié)果輸出后還可以通過x獲取讀取的總行數(shù)。

文件的寫入(w/a+)：在進行文件寫入時，在open函數(shù)中的操作形式的參數(shù)應(yīng)該為“w”或者“a”，參數(shù)中的文件地址則是輸出地址。如下代碼段所示：

-

 data="一起學(xué)Python！"

fh2=open("D:/我的教學(xué)/Python/20180120內(nèi)訓(xùn)/第1天代碼/文本3.txt","w")
fh2.write(data)
fh2.close()

在文件地址中，不能夠使用“”，而應(yīng)該使用“”或者“/”。在打開文件之后使用write方法將數(shù)據(jù)寫入之后，將文件關(guān)閉即可。如果操作形式為“w”，將會把原本的文件內(nèi)容替換掉，也就是全新寫入的意思，而如果使用“a+”就是在原本內(nèi)容的基礎(chǔ)上進行追加。

數(shù)據(jù)庫操作

Python除了用于操作文件之外，還常用于操作數(shù)據(jù)庫，本文以操作MySQL數(shù)據(jù)庫為例講解。在使用Python操作數(shù)據(jù)庫之前需要先安裝pymysql模塊，在cmd命令行中輸入“pip install pymysql”即可完成該模塊的安裝。

在安裝完pymysql之后，還需要將其中的源代碼進行一定的修改，因為使用其默認編碼會出現(xiàn)錯誤。在site-packages下面找到pymysql，并找到connections.py文件，搜索“charset=”關(guān)鍵詞就可以定位到需要進行修改的地方。

在connections.py中的charset=部分原本是沒有編碼的，現(xiàn)在加上編碼這樣就不會出錯了，這里的編碼一般建議使用“utf8”。需要注意的是寫入“utf8”而非“utf-8”，通過這樣的設(shè)置基本上就可以解決亂碼的問題。
使用Python進行數(shù)據(jù)庫的操作的前提是需要一個MySQL數(shù)據(jù)庫，至于MySQL數(shù)據(jù)庫的安裝和配置不是本文所關(guān)心的對象，大家可以自行學(xué)習(xí)。在擁有了MySQL數(shù)據(jù)庫之后首先應(yīng)該進行數(shù)據(jù)庫的連接。

import pymysql
conn=pymysql.connect(host="127.0.0.1",user="root",passwd="root",db="mypydb")
#執(zhí)行sql語句-無返回
conn.query("INSERT INTO mytb(title,keywd) VALUES("new title","23456")")
conn.commit()
#執(zhí)行SQL語句-有返回
cs=conn.cursor()
cs.execute("select * from mytb")
for i in cs:
    print("當前是第"+str(cs.rownumber)+"行")
    print("標題是："+i[0])
    print("關(guān)鍵詞是："+i[1])
conn.close()

如上述代碼所示，使用pymysql下面的connect方法就可以進行連接。connect方法中的參數(shù)的含義：host代表主機IP地址，user代表用戶名，passwd代表密碼，db代表所選擇的數(shù)據(jù)庫。在Python中操作數(shù)據(jù)庫也是使用SQL語句，而這里的SQL語句可以分為兩種，一種無返回結(jié)果，一種有返回結(jié)果。比如插入數(shù)據(jù)等操作無返回結(jié)果，查詢則屬于有返回結(jié)果的，而這兩種語句的使用方法是不同的。對于無返回結(jié)果的SQL語句，在使用時只需要使用query方法就可以執(zhí)行。上述代碼中指的是插入一條數(shù)據(jù)，插入完成之后使用commit方法就可以完成提交；對于有返回結(jié)果的SQL語句，首先需要通過conn的cursor方法建立游標，之后使用execute方法執(zhí)行SQL語句，這樣就可以遍歷游標，查詢結(jié)果存儲在cs中，使用for i in cs就可逐個將查詢結(jié)果取出來。

異常處理

在Python中經(jīng)常會出現(xiàn)這樣或那樣的錯誤，有些錯誤是不可避免的，甚至是未知的。對于未知的錯誤，當Python執(zhí)行時遇到后就會自動終結(jié)。而如果希望在遇到錯誤之后程序能夠繼續(xù)運行則需要使用異常處理。異常處理的格式如下：

try:
    程序
except Exception as 異常名稱:
    異常處理部分

try后面的代碼段就是嘗試著去執(zhí)行這段程序，如果出現(xiàn)異常則會觸發(fā)except從句。except后面是對應(yīng)的Exception類型，這里有一種的“必殺技”，就是直接使用Exception——通用異常，只要發(fā)生異常，Exception都會將其捕獲到。as表示對于異常起一個別名，而接下來就是對應(yīng)的異常處理的代碼。

try:

for i in range(0,10):

 >         print(i)
 >         if(i==4):
 >             print(jkj)
 >     print("hello") except Exception as err:
 >     print(err)

如上述代碼段，當i循環(huán)到4的時候?qū)霈F(xiàn)異常，因為jkj沒有在程序中定義。如果沒有異常處理，程序?qū)苯咏K結(jié)，而使用了異常處理之后，當發(fā)生異常也不會直接標紅，而是將異常輸出。

異常處理的目的是讓程序在出現(xiàn)異常的情況下繼續(xù)執(zhí)行下去，所以需要將異常盡量細化，使異常處理與所需要監(jiān)控的代碼更加緊密。對于上述代碼進行異常處理細化之后如下：

for i in range(0,10):
    try:
        print(i)
        if(i==4):
            print(jkj)
    except Exception as err:
        print(err)
print("hello")

這樣即使出現(xiàn)了異常，也可以繼續(xù)下一次循環(huán)。所以需要注意，異常處理需要盡量細化，盡量放于代碼里層，放于外層可能無法實現(xiàn)完美的異常處理。

上述內(nèi)容幫助大家了解了Python在語法層面的基礎(chǔ)知識，接下來為大家分享Python中面向?qū)ο缶幊虒崙?zhàn)。面向?qū)ο缶幊桃话銋^(qū)別于面向過程，其更適合于中大型的項目的開發(fā)。

認識類和對象

面向?qū)ο缶幊讨饕峭ㄟ^“類”和“對象”實現(xiàn)的。舉例而言，具體的某個人就是“對象”，小明是一個對象，小張也是一個對象，而將“對象”共有的特點抽象出來就能夠形成“類”，比如小張和小明都是“人”，那么“人”就是一個“類”，所以“類”就是類型的意思。只不過面向?qū)ο蟮念愂亲远x的?！邦悺笔浅橄蟪鰜淼?，“對象”則是具體的。

如果想要建立一個類則可以使用class字段進行聲明：

class 類名:
    類里面的內(nèi)容

如下示例代碼，建立了一個名為cl1的類，類中的內(nèi)容是“pass”，就是一個占位符，不會起到任何作用，但如果沒有pass則會出現(xiàn)縮進錯誤。

class cl1:
    pass
    

而將類實例化成為對象可以使用類名后面加括號并直接賦值給一個對象，如a=cl1()，那么a就是cl1這個類的一個對象。

構(gòu)造函數(shù)

構(gòu)造函數(shù)也叫作構(gòu)造方法。所謂構(gòu)造方法就是專門用于初始化的方法。這里還需要介紹self，一般在類中的方法必須加上self參數(shù)，其代表類本身。在Python中__init__(self,參數(shù))就是構(gòu)造方法，構(gòu)造方法的名字是固定的，在括號里面加上self以及對應(yīng)的參數(shù)即可。構(gòu)造函數(shù)的實際意義就是初始化。

class cl2:

def __init__(self):
    print("I am cl2 self!")

如上述代碼所示，cl2類有一個構(gòu)造方法，構(gòu)造方法中會輸出“I am cl2 self!”，這就意味著該類只要創(chuàng)建對象就會首先執(zhí)行這一串代碼。如果想要給構(gòu)造方法加上參數(shù)，在self后面加上參數(shù)即可，參數(shù)與參數(shù)之間通過逗號隔開。
class cl3:

def __init__(self,name,job):
    print("My name is "+name+" My job is "+job)

這樣就相當于給類加上了參數(shù)，因為在實例化該類時會需要傳遞相應(yīng)的參數(shù)。這里需要注意的是為類加上參數(shù)，并不是在類定義中的括號中加參數(shù)，在類定義中的括號是用于繼承的，而不是用于加參數(shù)的，這里的加參數(shù)指的是在實例化時加上參數(shù)。
屬性和方法
屬性就相當于是類中的變量，方法就相當于類中的函數(shù)，屬性是靜態(tài)的，方法是動態(tài)的。舉例而言，對于“人”這個類，手、頭這些都屬于屬性，而人會說話、寫字這些都是方法。在Python里面，屬性的使用方式一般是self.屬性即可。
class cl4:

def __init__(self,name,job):
    self.myname=name
    self.myjob=job

在上述代碼的cl4這個類的構(gòu)造方法中，可以看到傳遞了兩個參數(shù)，之后就在構(gòu)造函數(shù)中變成了類的屬性。接下來在使用到時候直接調(diào)用self.屬性即可。
class cl5:

def myfunc1(self,name):
    print("hello "+name)

class cl6:

def __init__(self,name):
    self.myname=name
def myfunc1(self):
    print("hello "+self.myname)

如上述代碼所示，方法就是類里面的函數(shù)，包括__init__()也都是方法。上述的cl6就能為大家解釋self為什么能夠存在，cl6中的__init__()和myfuncl()是兩個函數(shù)，按照道理而言，myname在不同的函數(shù)中都屬于局部變量，是不能通用的，那么如果想讓局部變量在多個函數(shù)之間傳遞，那么一種方法就是將變量存儲到類里面，也就是創(chuàng)建self字段，將變量存到類里面，而self就提供了一個區(qū)域用于存儲變量，這就是self存在的必要性。
繼承

簡單而言，繼承就是將某個類中所有的屬性和方法都拿過來直接使用，舉例而言：某一個家庭有父親、母親、兒子和女兒，父親可以說話，母親可以寫字，大兒子繼承了父親，女兒同時繼承了父母，并且有新能力聽東西，小兒子繼承了父親，但是優(yōu)化（或減弱）了父親的說話能力，這樣的模型應(yīng)該如何建立呢？被繼承的這個類被稱為基類或者父類，繼承的類叫做子類。所以模型中的服務(wù)都是基類，兒子和女兒都是子類。
首先創(chuàng)建父親類，他的功能是可以說話：
class father():

def speak(self):
    print("I can speak!")

接下來建立大兒子這個子類：

class son(father):
    pass

該類繼承了父親類，所以在son類定義的時候括號里寫上了father。雖然son類中沒有寫任何方法，但是其仍然擁有speak方法，這是因為其集成了father類的所有方法。
母親類具備寫的能力：

class mother():
    def write(self):
        print("I can write")

女兒類同時繼承了父親和母親，這就屬于多繼承了。多繼承只需要在類定義時加多個參數(shù)即可。除了繼承了兩個基類之外，她還有新的聽的能力，這樣只需要在該類中寫一個新的方法即可。
class daughter(father,mother):

def listen(self):
    print("I can listen!")

而小兒子發(fā)生了變異，這里的變異指的是重載或者重寫。小兒子繼承了父親類，但是優(yōu)化了說的能力，所以需要實現(xiàn)一個同名方法，而在實際使用的時候也會調(diào)用自己所重載的speak方法。

class son2(father):
    def speak(self):
        print("I can speak 2!")
        

上面為大家介紹的Python知識非常零散，但是也非常重要，既然想要掌握Python，就需要使用實際項目進行鞏固和提升，當將項目實現(xiàn)之后，對應(yīng)的能力也就自然掌握了。

本文由云棲志愿小組賈子甲整理，編輯百見，原文