關於python學習筆記第十四周的信息

本文目錄一覽：

• 1、python3.4學習筆記 3.x和2.x的區別，持續更新
• 2、Python精選5篇教學心得
• 3、初學者如何學習python？如何快速從Python小白到初級Python工程師？
• 4、Python 有哪些入門學習方法和值得推薦的經典教材?
• 5、初學python，感受和C的不同
• 6、讀《瘋狂Python講義》有感

python3.4學習筆記 3.x和2.x的區別，持續更新

python3.4學習筆記(四) 3.x和2.x的區別

在2.x中:print html，3.x中必須改成:print(html)

import urllib2

ImportError: No module named ‘urllib2’

在python3.x裡面，用urllib.request代替urllib2

import thread

ImportError: No module named ‘thread’

在python3.x裡面，用_thread(在前面加一個下劃線)代替thread

在2.x中except Exception,e : 3.x中改為except (Exception):

=================================

print函數

雖然print語法是Python 3中一個很小的改動，且應該已經廣為人知，但依然值得提一下：Python 2中的print語句被Python 3中的print()函數取代，這意味着在Python 3中必須用括號將需要輸出的對象括起來。

在Python 2中使用額外的括號也是可以的。但反過來在Python 3中想以Python2的形式不帶括號調用print函數時，會觸發SyntaxError。

Python 2.7.6

print ‘Python’, python_version()

print ‘Hello, World!’

print(‘Hello, World!’)

print “text”, ; print ‘print more text on the same line’

輸出：

Hello, World!

Hello, World!

text print more text on the same line

—————————

Python 3.4.1

print(‘Python’, python_version())

print(‘Hello, World!’)

print(“some text,”, end=””)

print(‘ print more text on the same line’)

輸出：

Hello, World!

some text, print more text on the same line

print ‘Hello, World!’

File “ipython-input-3-139a7c5835bd”, line 1

print ‘Hello, World!’

^

SyntaxError: invalid syntax

注意：在Python中，帶不帶括號輸出”Hello World”都很正常。

但如果在圓括號中同時輸出多個對象時，就會創建一個元組，這是因為在Python 2中，print是一個語句，而不是函數調用。

print ‘Python’, python_version()

print(‘a’, ‘b’)

print ‘a’, ‘b’

Python 2.7.7

(‘a’, ‘b’)

a b

———————————

整數除法

由於人們常常會忽視Python 3在整數除法上的改動（寫錯了也不會觸發Syntax Error），所以在移植代碼或在Python 2中執行Python 3的代碼時，需要特別注意這個改動。

所以，我還是會在Python 3的腳本中嘗試用float(3)/2或 3/2.0代替3/2，以此來避免代碼在Python

2環境下可能導致的錯誤（或與之相反，在Python 2腳本中用from __future__ import division來使用Python

3的除法）。

Python 2.7.6

3 / 2 = 1

3 // 2 = 1

3 / 2.0 = 1.5

3 // 2.0 = 1.0

Python 3.4.1

3 / 2 = 1.5

3 // 2 = 1

3 / 2.0 = 1.5

3 // 2.0 = 1.0

———————————

Unicode

Python 2有基於ASCII的str()類型，其可通過單獨的unicode()函數轉成unicode類型，但沒有byte類型。

而在Python 3中，終於有了Unicode（utf-8）字符串，以及兩個字節類：bytes和bytearrays。

Python 2.7.6

print type(unicode(‘this is like a python3 str type’))

type ‘unicode’

print type(b’byte type does not exist’)

type ‘str’

print ‘they are really’ + b’ the same’

they are really the same

print type(bytearray(b’bytearray oddly does exist though’))

type ‘bytearray’

Python 3.4.1 has class ‘bytes’

print(‘and Python’, python_version(), end=””)

print(‘ also has’, type(bytearray(b’bytearrays’)))

and Python 3.4.1 also has class ‘bytearray’

1

‘note that we cannot add a string’ + b’bytes for data’

—————————————————————————

TypeError Traceback (most recent call last)

ipython-input-13-d3e8942ccf81 in module()

—- 1 ‘note that we cannot add a string’ + b’bytes for data’

TypeError: Can’t convert ‘bytes’ object to str implicitly

=================================

python 2.4 與 python 3.0 的比較

一、 print 從語句變為函數

原: print 1,2+3

改為: print ( 1,2+3 )

二、range 與 xrange

原 : range( 0, 4 ) 結果 是 列表 [0,1,2,3 ]

改為：list( range(0,4) )

原 : xrange( 0, 4 ) 適用於 for 循環的變量控制

改為：range(0,4)

三、字符串

原: 字符串以 8-bit 字符串存儲

改為: 字符串以 16-bit Unicode 字符串存儲

四、try except 語句的變化

在2.x中except Exception,e : 3.x中改為except (Exception):

五、打開文件

原： file( ….. )

或 open(…..)

改為：

只能用 open(…..)

六、從鍵盤錄入一個字符串

原: raw_input( “提示信息” )

改為: input( “提示信息” )

七、bytes 數據類型

A bytes object is an immutable array. The items are 8-bit bytes, represented by integers in the range 0 = x 256.

bytes 可以看成是“字節數組”對象，每個元素是 8-bit 的字節，取值範圍 0~255。

由於在 python 3.0中字符串以 unicode 編碼存儲，當寫入二進制文件時，字符串無法直接寫入（或讀取），必須以某種方式的編碼為字節序列後，方可寫入。

（一）字符串編碼(encode) 為 bytes

例: s = “張三abc12”

b = s.encode( 編碼方式)

# b 就是 bytes 類型的數據

# 常用的編碼方式為 ： “uft-16” , “utf-8”, “gbk”, “gb2312”, “ascii” , “latin1” 等

# 注 ： 當字符串不能編碼為指定的“編碼方式”時，會引發異常

(二) bytes 解碼(decode)為字符串

s = “張三abc12”

b = s.encode( “gbk”) # 字符串 s 編碼為 gbk 格式的字節序列

s1 = b.decode(“gbk”) # 將字節序列 b以gbk格式 解碼為字符串

# 說明，當字節序列不能以指定的編碼格式解碼時會引發異常

(三）使用方法舉例

#coding=gbk

f = open(“c:\\1234.txt”, “wb”)

s = “張三李四abcd1234”

# ——————————-

# 在 python2.4 中我們可以這樣寫：

# f.write( s )

# 但在 python 3.0中會引發異常

# ——————————-

b = s.encode(“gbk”)

f.write( b )

f.close()

input(“?”)

讀取該文件的例子:

#coding=gbk

f = open(“c:\\1234.txt”, “rb”)

f.seek(0,2) #定位至文件尾

n = f.tell() #讀取文件的字節數

f.seek(0,0) #重新定位至文件開始處

b = f.read( n )

# ——————————

# 在 python 2.4 中 b 是字符串類型

# 要 python 3.0 中 b 是 bytes 類型

# 因此需要按指定的編碼方式確碼

# ——————————

s = b.decode(“gbk”)

print ( s )

# ——————————

# 在 python 2.4 中 可以寫作 print s 或 print ( s )

# 要 python 3.0 中 必須寫作 print ( s )

# ——————————

f.close()

input(“?”)

運行後應顯示:

張三李四abcd1234

(四) bytes序列，一但形成，其內容是不可變的，例：

s=”ABCD”

b=s.encode(“gbk”)

print b[0] # 顯示 65

b[0] = 66

# 執行該句，出現異常: ‘bytes’ object does not support item assignment

八、 chr( K ) 與 ord( c )

python 2.4.2以前

chr( K ) 將編碼K 轉為字符，K的範圍是 0 ~ 255

ord( c ) 取單個字符的編碼, 返回值的範圍: 0 ~ 255

python 3.0

chr( K ) 將編碼K 轉為字符，K的範圍是 0 ~ 65535

ord( c ) 取單個字符的編碼, 返回值的範圍: 0 ~ 65535

九、 除法運算符

python 2.4.2以前

10/3 結果為 3

python 3.0

10 / 3 結果為 3.3333333333333335

10 // 3 結果為 3

十、字節數組對象 — 新增

(一） 初始化

a = bytearray( 10 )

# a 是一個由十個字節組成的數組，其每個元素是一個字節，類型借用 int

# 此時，每個元素初始值為 0

（二） 字節數組 是可變的

a = bytearray( 10 )

a[0] = 25

# 可以用賦值語句更改其元素，但所賦的值必須在 0 ~ 255 之間

(三) 字節數組的切片仍是字節數組

(四) 字符串轉化為字節數組

#coding=gbk

s =”你好”

b = s.encode( “gbk”) # 先將字符串按某種“GBK”編碼方式轉化為 bytes

c = bytearray( b ) #再將 bytes 轉化為 字節數組

也可以寫作

c = bytearray( “你好”, “gbk”)

(五) 字節數組轉化為字符串

c = bytearray( 4 )

c[0] = 65 ; c[1]=66; c[2]= 67; c[3]= 68

s = c.decode( “gbk” )

print ( s )

# 應顯示： ABCD

(六) 字節數組可用於寫入文本文件

#coding=gbk

f = open(“c:\\1234.txt”, “wb”)

s = “張三李四abcd1234”

# ——————————-

# 在 python2.4 中我們可以這樣寫：

# f.write( s )

# 但在 python 3.0中會引發異常

# ——————————-

b = s.encode(“gbk”)

f.write( b )

c=bytearray( “王五”,”gbk”)

f.write( c )

f.close()

input(“?”)

Python精選5篇教學心得

Python是一種跨平台的計算機程序設計語言，是一種面向對象的動態類型語言，越來越多被用於獨立的，大型項目的開發，已被逐漸廣泛應用於系統管理任務的處理和Web編程。下面給大家帶來一些關於Python 學習心得 ，希望對大家有所幫助。

python學習心得1

最近這段時間我們學習了很多內容，增長了很多關於Python的知識，萬事萬物是相通的，正如學習新的知識就像吃飯一樣。

吃多了就會消化不良，反映到學習上也是一樣，不知各位最近的感覺怎樣，反正學記是需要一些時間好好消化，掌握到手中，為下一步的知識補齊缺口。

接下來，學記和大家一起回顧一下最近學習的內容，循序漸進，循序漸進。

分支結構

分支結構就像上圖一樣，是用來選擇道路的。

所用的關鍵字是

If elif else

這三個詞的意思分別是

如果 否則如果 其他的

分支語句的寫法需要將與關鍵字與關鍵字對齊

循環結構

循環結構應用於一些重複的進程

通常我們只接觸兩種循環

for-in循環 和 while循環

for-in循環適用於

確切的知道到底循環幾次

while循環適用於

不知道到底有幾次循環

此時要搭配bool 來進行

即 True 和 Flase

關鍵字

關鍵字的熟練運用對於今後的開發工作

有非常重要的作用，但這麼多關鍵字我們不能去死記硬背

只有在一個一個代碼的驗證當中去熟悉去掌握

那樣是最可靠的

def 設置模組

len 計算字符串長度

capitalize 獲得字符串首字母大寫的拷貝

upper 獲得字符串變大寫後的拷貝

find 從字符串中查找子串所在位置

index 與find類似但找不到子串時會引發異常

startswith 檢查字符串是否以指定的字符串開頭

endswith 檢查字符串是否以指定的字符串結尾

center 將字符串以指定的寬度居中並在兩側填充指定的字符

rjust 將字符串以指定的寬度靠右放置左側 填充指定的字符

isdigit 檢查字符串是否由數字構成

isalpha 檢查字符串是否以字母構成

isalnum 檢查字符串是否以數字和字母構成

append 添加元素

remove 刪除元素

clear 清空元素

sorted 排序

大家可能會有些疑惑，學習這些東西真的有用嗎?這些隨處可見的基礎方面的知識真的有用嗎?

我可以非常肯定地告訴大家

有用的!

這些知識就像是建築工地隨處可見的磚石，不管這些磚石怎樣的不起眼，但是沒有一幢建築可以離開磚石，學習的過程是枯燥的，不過這也正符合非常現實的一條規律。

學如逆水行舟，不進則退!

也正是因為它枯燥苦悶，學習有難度，才保證了，我們學習了這些知識以後，可以靠它們為生，在這個知識時代闖出自己的一片天!

不要放棄，絕對不要放棄!

黎明之前是最黑暗的!

為了自己的未來好好堅守吧!

青年學記 陪伴着各位青年

python學習心得2

python是一門非常有潛力的高級語言，歷經多年的發展，其在編程上發揮着越來越大的作用。在這學期中，通過選修python課上的基礎知識學習，我對python也有了一定的認識。而且，在字符串上的處理，python相對於c語言也是給程序員極大的便利。而python不僅如此，它的庫也很多，正因為它強大的庫，讓編程變得不再艱難。但是，我認為python雖然在許多方 面相 對於c語言比較方便，但也有其相對於弱一點的方面，比如說for循環等方面。雖然一學期下來，我對python的學習也僅僅只是它的基礎方面，但python的強大，也是足足地吸引着我，希望自己能夠在不斷地學習中，將python學習的更加好。

python是一門非常有潛力的高級語言，歷經多年的發展，其在編程上發揮着越來越大的作用。在這學期中，通過選修python課上的基礎知識學習，我對python也有了一定的認識。

在學習python的第一節課上，其對我的最初的印象就是，相較於我學習過的c語言編程，它更加的簡潔。所有的變量都不需要像c語言編程那樣需要提前去定義，這樣給了編程者很大的自由空間與方便。如x=2，即可同時完成變量的定義與賦值。對於簡化程序的代碼，起到了許多的作用。而且，在字符串上的處理，python相對於c語言也是給程序員極大的便利。在c語言中，只能用字符類的數組對字符串進行相應的操作，步驟也是相對於比較繁瑣的，而在python中，當我們需要創建一個字符串的時候，只需要在創建字符串的時候用“s=”就可以了。而python不僅如此，它的庫也很多，正因為它強大的庫，讓編程變得不再艱難。我們只需要調用庫中的函數，而對於函數的具體實現，也沒有特殊的需求。

但是，我認為python雖然在許多方面相對於c語言比較方便，但也有其相對於弱一點的方面，比如說for循環等方面。不過也依然不會影響到python的強大，而隨着近幾年來的發展，python的受歡迎度也越來越高，而它的運用的領域也是越來越多，比如人工智能和大數據等領域，python都是在其中扮演者重要的角色。雖然一學期下來，我對python的學習也僅僅只是它的基礎方面，但python的強大，也是足足地吸引着我，希望自己能夠在不斷地學習中，將python學習的更加好。

python學習心得3

由於我是自學Python，非科班出生，所以只能分享一些關於我的學習心得，如果有不對地方歡迎指正。

不過非科班出生雖然是一個痛點，但是在工作上，我其實不輸給我其他同事，這點我倒是很有自信，而且我也統一一句話“目前互聯網上的免費編程課程，足夠讓你成為一個合格的碼農”。

編程入門

我剛開始學習編程，主要是因為自己想動手做個網站，但是由於技術原因，再加上朋友都比較忙，最後抱着“求人不如求己”的想法，乾脆自學。

編程難不難?

這個問題我覺得所有認真學過的人，都一定會肯定告訴你編程不難，但是精通那是相當困難的。

如果你還沒去學習，就覺得編程一定很難，那麼其實你是沒有資格說這句話的，任何事情一定是要去嘗試後，才能這麼說。

編程其實很像堆積木，然後根據需求，把東西造出來，可以是房子，也可以是橋樑。

學習編程無非運用這些積木，來創造你要的東西。

編程語言選擇

這邊說個題外話，關於當時編程語言的選擇，很多時候我覺得不是你選擇編程語言，而是編程語言選擇你，也就是你的“本命編程語言”。

人的性格會影響你適合的編程語言，比如你做事有條理，喜歡定期清理房間，那麼可能C語言很適合你;如果你不喜歡打掃房間，實在受不了，才打掃一次，可能你適合Java。

哈哈，開個玩笑，不過確實有這種很玄的存在。

我當時在編程語言的選擇上，用了一個笨 方法 。

我跑到w3cschool上面，把所有編程語言的第一章都去試了一遍，看看自己喜歡哪個語言，然後就選哪個語言，如果你不知道選哪門語言，可以用我的方法試試看。

至於編程語言，沒有高低之分，因為無論你學習哪門語言，你都非常有市場，而且你都能夠拿到高薪，關鍵是哪門語言適合你，並且能夠讓你有興趣學下去，能學好，這個很關鍵。

興趣是學習編程最大的驅動力!

為什麼是Python

說下為什麼選擇Python?

因為簡單，Python是公認的最容易入門的編程語言，而且也是公認有發展前景的編程語言，適用於機器人、大數據、人工智商等未來高科技。

基於以上的原因，我選擇Python來作為自己的入門語言，而且我覺得我適合Python這麼語言。(因為我很懶)

之前有個梗，大概就是其他編程語言在討論某個問題，怎麼解決，而Python的程序員已經下班了，由此可見Python的效率。

總結 ：Python的語言特點就是“一氣呵成，痛快如拉稀”。

學習心得

由於我是自學的，所以參考的網站比較多，小夥伴可以按照我的學習路線，一般來說不會出現什麼問題。

基礎：教程+視頻

進階：視頻+實踐

進階pro：視頻+實踐+書籍+交流

基礎

剛開始學習的時候，我比較推薦w3cschool和菜鳥教程這兩個網站。

w3cschool-學編程，從w3cschool開始!

菜鳥教程 – 學的不僅是技術，更是夢想!

這兩個網站在我看來，是編程自學的福音。

w3cschool這個網站手冊非常棒，另外這個網站的編程微課以及編程實戰對新手來說非常友好!

我當時就是靠這兩個，引發我學習的樂趣，不然對着枯燥的代碼，說實話，很無聊的。

菜鳥教程，這個網站的實例是最棒的，很多時候，你不僅僅要自己看教程，還要去看看為什麼，而菜鳥教程的實例就能夠讓你清晰的知道，為什麼，並且會原來如此。

總的來說，這兩個網站就像新手村剛出來的劍和盾!是新手入門絕對不能少的，尤其是w3cschool，強烈推薦。

還有一個就是視頻，視頻我是在慕課網上面看的，我很喜歡慕課網這個網站，網站風格很棒，而且視頻也很清晰。

也可以在阿里雲上面看Python的視頻，也很不錯，並且是免費的。

進階

進階結束後，代表你是個初級工程師。

這一步實踐非常重要，你要自己動手，做一些小玩意，實踐才是最重要的，在實踐中發現問題，那是學習最快並且效率最高的時刻。

你可以先給自己定下一個目標，比如我要做一個簡單的頁面，或者我要做一個簡單的小程序。

然後就開始動手去實踐，這步很重要。

同時還是要多看書籍。

進階pro

到這一步，我建議務必買書，你需要書籍幫你反向梳理你的知識，這決定了你以後的高度，而不是這個也懂，那個也懂，但是東西就是做不出來。

我記得當時我買完書，看完後的第一感受就是：原來這個世界是這樣的!

書會非常系統性的幫你梳理你自己學過的知識!

這裡只推薦兩本書：《Python入門手冊》和《Python核心編程》

小夥伴可以自己去亞馬遜購買。

然後就是和身邊的小夥伴交流!

多看看別人的代碼，自己多敲敲代碼，是必經之路，也是一定要做的。

以上，希望對想入門Python的小夥伴能夠提供一點點幫助。

python學習心得4

017年11月，一群編程零基礎的小夥伴們成立了Python學習小組，12名學員從此夜以繼日地奔赴學習的征程。一個月過去了，從在屏幕上用最簡單的語句打印出“Hello, Python; Hello, World”開始，我們逐步地學習Python語法，學習操作列表、字典，學習For，While，If語句，現在遇到了第一個難點：類。通過研讀、練習、交流、討論，作為程序界的小白，我們逐步地理解了類的概念，明白了面向對象與面向過程編程的差異，以下是我們的小小心得，與大家分享：

編程基本思想

現實世界中，每個複雜的事務都可以拆分為多個組成部分，其中的每一部分就可稱之為對象。比如要實現一個很大很複雜的項目，我們可以把項目拆分成不同的組成部分，然後分別對不同部分通過編程實現，最終再把各個部分組裝起來完成整個項目。這讓我們能夠從整體上來控制項目，從而讓程序開發更有效。

比如汽車製造，汽車廠所做的僅僅是各個部件的組裝和匹配，而各個部件的生產是由相對專業的廠商完成。如果需要研發新型號汽車，整車廠所考慮的是如何對各個新式的零部件進行新的組裝和匹配，而不是從頭到尾重新生產一輛汽車。

面向對象的編程

VS

面向過程的編程

面向過程編程是針對一個需求的具體實現過程，但是對於大型項目的複雜需求，一步一步的做，這種編程效率顯然是低下的。

面向對象編程則是對項目進行拆分後(一般按照功能拆分)，分別實現，再將各個對象組裝起來。因此簡單的小程序使用面向過程方法編程更適合。面向對象的編程特性是易維護(可讀性高)，效率高，質量高(重用性)，擴展性好(高內聚,低耦合)。

對象

通俗的講，對象就是事物，一個公司、一個部門、一個人，甚至一本書都可以是一個對象，程序員可以自由決定把什麼作為對象。

比如eHR系統，需要對組織架構，員工進行管理，所以使用的對象可能是公司，部門，崗位，員工，等等。對象可大可小，可複雜也可簡單，如果僅僅是做一個考勤系統，員工這個對象一定要比eHR系統中的員工對象簡單。

類

現實世界中，類代表一組有共同特性的事物，把不同對象之間的共性抽象出來，就形成類的概念。比如說男人、女人可以抽象成人這個類;處長、秘書可以抽象成員工類。至於類如何去抽象，粒度的粗細，這是一個需要在學習和實踐中摸索的過程。

實例

以下是一個實例，大家體會一下：

1. 定義父類：

class Employee:

def __init__(self, name, age): #抽象員工共性(名字，年齡)

self.name = name

self.age = age

def signON(self):

print(self.name+” sign on.”) #抽象簽到的動作

def work(self):

print(self.name + ” on work.”) #抽象工作的動作

2. 繼承出子類：

class MEmployee(Employee): #繼承父類的共性

def __init__(self, name, age):

super().__init__(name, age)

def work(self): #重寫子類的方法(抽象出從事管理崗位工作的動作)

print(self.name + ” on manager_work.”)

3. 繼承出第二個子類：

class TEmployee(Employee):

def __init__(self, name, age, devLanguage): #繼承父類的共性，增加語言的屬性

super().__init__(name, age)

self.devLanguage = devLanguage

def work(self): #重寫子類的方法(抽象出從事技術崗位工作的動作)

print(self.name + ” on technology_work.”)

def showLanguage(self): #增加子類的方法(抽象出會某種編程語言的動作)

print(“use “+self.devLanguage+” language.”)

在上面的程序中，我們先定義了一個父類：包含員工的姓名、年齡等一般特性，可以執行簽到、工作這兩類動作。在第一個子類中，管理層在前面一般特性的基礎上，執行管理工作;在第二個子類中，作為一般員工在前面一般特性的基礎上，執行技術工作，從事編程。

python學習心得5

1、定義方法

關鍵字 def 是方法定義的標誌。接下來緊跟方法名和被圓括號所包圍的參數列表。方法的主

體語句將在下一行開始並且必須縮進。

方法主體的首句可選擇性地是一句字符，用來說明方法的主要功能

例如：

“””print a finabo series up to n.”””

2、默認參數值

默認值僅被設置一次，這與以前默認值為可變對象(如列表、字典和多數類實

例時)有很大的區別。

例如：

i=5

def f(arg=i):

print(arg)

i=6

f()

將會輸出 5

3、關鍵字參數

可以通過形式關鍵字參數調用方法

在方法調用中，關鍵字參數必須遵循位置參數。 所有的關鍵參數必須符合方法接受的參數

其中之一。但是他們的次序不重要，這包含非選擇的參數。沒有參數可以多次接受一個值。

當最後一個形參是__ name 時，它可以接受包含除了形式參數之外的所有關鍵字的字典，

_ name 必須在__ name 之前出現

4、可變參數列表

正常來說，這些可變參數常常放在正式參數列表的後面，因為它們會包攬所有傳遞給該方法

的剩餘輸入參數。任何出現在_ args 參數後低的正式參數會被認為是關鍵字參數，意味着它

們只能當關鍵字使用而不是位置參數。

def concat(_ args,sep=”/”):

…returnsep.join(args)

…

concat(“earth”,”mars”,”venus”)

’earth/mars/venus’

concat(“earth”,”mars”,”venus”, sep=”.”)

’earth.mars.venus’

5、拆分參數列表

當參數已經存在列表或者元組中，但是需要分拆以供要求分離位置參數調用的方法，如果單獨

分開它們無法使用，就需要寫一個方法用 _ 操作符來調用實現分拆列表或者元組中的參數。

同樣的使用形式，字典可以用__ 操作符實現關鍵字參數。

6、形式

lamdba a,b:a+b 該函數表示兩個數的和，像內嵌函數

7、代碼風格

對於 python，PEP8 作為許多項目應該遵守的編碼指導書而做的。 它提出了一種可讀而悅

目的編碼風格。 每位 python 開發者應該讀它。這裡抽出一個重要的事項與你分享 ：

? 用四個空格代替 tab 鍵

? 每行不要超過 79 個字符。

? 用空行分離方法和類，大塊代碼中的方法。

? 必要的時候為每行添加註釋。

? 用文檔字符串

? 在操作符兩邊用空格

? 用統一的風格命名自定義的方法和類

? 如果你的代碼打算用在國際環境中，請不要用想象的字符編碼。Python 默認的是

utf-8,在任何情況下可以用 Ascii .

? 同樣的，即使有很少機會讓說不同語言的人們讀代碼或者維護代碼，但在定義中不

要用非 ASCII 編碼字符。

初學者如何學習python？如何快速從Python小白到初級Python工程師？

制定目標

我的學習歷程：我想免費學習Python，因此我必須養成每天的學習習慣（每天4個小時），甚至要利用我的周末。我的總體規劃是設定目標並追逐目標。我為7個星期設定了7個目標！

第1周

我的第一周目標-（Python基礎知識）作為初學者，我們的第一周目標應該是-熟悉Python基礎知識，例如變量，條件，列表，循環，函數。（好奇並探索您可以使用Python進行的操作）。由於我想免費學習python，所以我開始在互聯網上進行挖掘，幸運的是發現了一個Python備忘單，對我有很大幫助。

第2周

第二周目標-（提高我的編碼能力）解決100多個編碼問題。反向字符串，迴文，GCD，合併排序數組，If-then-else語句，循環，函數和python軟件包問題。“越努力，您就會成為更好的開發者”

第3周

第三周目標-（了解數據結構和算法），提升您的技能和知識，並學習基礎知識，例如堆棧，隊列，元組，樹，字典，鏈接列表，搜索（線性和二進制搜索），遞歸函數（階乘，斐波那契數列），排序（氣泡排序，選擇排序）和時間複雜度（線性，二次和常數）。

第4周

第四（探索Python庫）Python之所以在開發人員中如此受歡迎，是因為其令人讚歎的庫可供用戶使用。您可以使用的一些最常見的庫是Numpy，Scipy，Scikit-learn，Theano，TensorFlow，Keras，PyTorch和Pandas。

OpenCV是計算機視覺庫，可為您提供圖像處理功能！很酷吧？

SimpleCV，另一個CV庫，本質上是OpenCV的子集，但學習曲線要低得多。

我發現個驚人的博客約有56個Python庫。

PyGame，一個遊戲開發庫，可讓您製作出色的遊戲。

第5周

第五周目標-（學習Python框架）您必須學習至少3個流行的框架。閱讀框架文檔，在B站上找到視頻教程。必須以Numpy，Django，pandas和Scrapy開頭。

Django-一個Web應用程序框架。從這裡您可以學習Django。

Flask（Python Microframework），另一種流行的Web應用程序框架，更加紮實（因此更加靈活）的Web應用程序開發方法

第6周

第六周目標-（從事Python項目）這是最重要的。在這裡，您必須測試並應用您的知識。在第6周，您要做的就是至少處理3個python項目。我知乎分享了我以前的答案，您將在這裡獲得一些適合初學者和中級學習者的出色python項目：使用Python構建的一些出色項目？

第7周

第七周目標-（Python面試練習）恭喜！現在，您擁有在全球任何一家技術公司中申請任何軟件工程工作所需的資源。現在，練習您的軟技能，並儘可能練習面試問題。

Python 有哪些入門學習方法和值得推薦的經典教材?

如果你有一定的計算機編程知識基礎，那麼很容易學；再如果你對編程十分感興趣，那麼很容易學的。

1，找到合適的入門書籍，大致讀一次，循環啊判斷啊，常用類啊，搞懂（太難的跳過）

2，做些簡單習題，字符串比較，讀取日期之類 Python Cookbook不錯（太難太無趣的，再次跳過，保持興趣是最重要的，不會的以後可以再學）

3，加入Python討論群，態度友好笑眯眯（很重要，這樣高手才會耐心糾正你錯誤常識）。很多小問題，糾結許久，對方一句話點播思路，真的節約你很多時間。耐心指教我的好人，超級超級多謝。

4，解決自己電腦問題。比如下載美劇，零散下載了2，4，5，8集，而美劇共12集，怎樣找出漏下的那幾集？然後問題分解，1讀取全部下載文件名，2提取集的數字，3數字排序和（1–12）對比，找出漏下的。

5，時刻記住目的，不是為了當程序員，是為了解決問題。比如，想偷懶抓網頁內容，用urllib不行，用request也不行，才發現抓取內容涉及那麼多方面（cookie，header，SSL，url，javascript等等），當然可以聽人家勸，回去好好讀書，從頭讀。 或者，不求效率，只求解決，用ie打開網頁再另存為行不行？ie已經渲染過全部結果了。 問題變成：1–打開指定的10個網頁（一行代碼就行）。更複雜的想保存呢？利用已經存在的包，比如PAM30（我的是Python3），直接打開ie，用函數outHTML另存為文本，再用搜索函數（str搜索也行，re正則也行）找到數據。簡單吧？而且代碼超級短。

6，保持興趣，用最簡單的方式解決問題，什麼底層驅動，各種交換，留給大牛去寫吧。我們利用已經有的包完成。

7，耐心讀文檔，並且練習快速讀文檔。拿到新包，找到自己所需要的函數，是需要快速讀一次的。這個不難，讀函數名，大概能猜到是幹嘛的，然後看看返回值，能判斷是不是自己需要的。

8，寫幫助文件和學習筆記，並發布共享。教別人的時候，其實你已經自己再次思考一次了。 我覺得學程序就像學英文，把高頻率的詞（循環，判斷，常用包，常用函數）搞懂，就能拼裝成自己想要的軟件。 一定要保持興趣，太複雜的跳過，就像小學數學，小學英語，都是由簡入深。 網絡很平面，無數國際大牛著作好書，關於Python，算法，電腦，網絡，或者程序員思路，或者商業思維（浪潮之巔是本好書）等等，還有國際名校的網絡公開課（中英文字幕翻譯完畢，觀看不是難事），講計算機，網絡，安全，或者安卓系統，什麼都有，只要能持續保持興趣，一點點學習下去，不是難事。 所有天才程序員，都曾是兒童，回到兒童思維來理解和學習。覺得什麼有趣，先學，不懂的，先放着，遇到問題再來學，效果更好。 唯一建議是，不要太貪心，耐心學好一門優雅的語言，再學其它。雖然Javascript做特效很炫，或提某問題時，有大牛建議，用Ruby來寫更好之類，不要改方向。就像老笑話：“要學習遞歸，必須首先理解遞歸。”然後死循環一直下去。堅持學好一門語言，再研究其他。 即使一門語言，跟網絡，數據庫等等相關的部分，若都能學好，再學其他語言，是很快的事情。 另外就是，用學英文的耐心來學計算機，英文遇到不懂的詞，抄下，查詢。 python里，看到Http，查查定義，看到outHtml，查查定義，跟初學英語時候一樣，不要直接猜意思，因為精確描述性定義，跟含糊自然語有區別的。而新人瞎猜，很容易錯誤理解，wiki，google很有用。

對於python初學者來說，能找到一個好老師學習格外重要，這能決定你是不是可以做出好的項目，在python開發的路上越走越輕鬆，如果現在的你缺乏學習經驗，找不到老師指導你學習，可以加企 鵝扣-Q前面112再加上中間的983以及最後四位數4903，連在一起就可以了。

如果說彙編是第一代編程語言，那麼C和C++是第二代編程語言，C#和Java等等是第三代編程語言，Python和其他類似的腳本語言就是第四代編程語言（除彙編外這些語言都是C語系下的編程語言，可以進行類比），從C++開始是個分水嶺，它是通過面向對象和對底層技術的封裝，使編程向高級編程過度，到Python已經是很簡歷通俗了，至少是跟之前比，所以如果說python不易學，那其他語言怎麼辦呢，幾乎每本python的教材都會先表明python是一門易學易用的語言，這也是這個語言被創造出來的宗旨之一，另外Google的程序猿很喜歡用Python編寫各類工具，因為它的語言簡歷，編碼效率高，讓用慣了其他語言的人，樂意去用這門新的語言，也說明它的易學性。

另外從廣義講，Python不僅是一門編程語言，還是一個編程的平台，在這個平台下，有着安裝各種擴展、框架的工具pip，有着打包工具setuptools等等等等，這些工具已經很成熟，而且易於上手，另外Python有很多很好的編程工具（集成開發環境）可以用，如PyCharm等，這也使的新人很容易上手，不像其他不成熟的編程語言工具貧乏，編寫和運行程序如連電路板一般。

初學python，感受和C的不同

從開始看Python到現在也有半個多月了，前後看了Python核心編程和Dive into

Python兩本書。話說半個月看兩本，是個人都知道有多囫圇吞棗，這也是因為我暫時沒有需求拿這個做大型開發，主要是平時的小程序test用一用。所以

我的策略是，整體瀏覽，用到時候現查。話說這核心編程第一版太古老了，老在講2.2之前的東西，我看的翻譯電子版，翻譯得也不好，很晦澀。看完這個後還有

點雲里霧裡，看網上人家說DIP好，啄木鳥還有免費電子文檔，就找來看這個。怎麼說呢，講的比核心編程好，但不適合第一次看的初學者。我之所以覺得講得

好，是因為看核心編程，有些概念還有些模糊，看了這本書就明白不少了。要是初學者上來就看這本，保證不好理解。

下面就是在學習的過程中，在翻閱資料的過程中，總結的一些C和python比較明顯的不同之處，有大方向的，也有細節的。肯定沒有總結完，比如動態

函數，lambda這些，我都懶得往上寫了。實際上，作為兩種完全不同的語言，下面這些差異只是冰山一角而已。權當拋磚引玉吧，至少應該對和我有相同研究

興趣，正在考慮是否學習另一門語言的朋友有點幫助。此文也算是DIP的學習筆記吧。順帶說一句，要是有朋友了解，可以幫忙推薦一下實戰性強的Python

教材，語言這東西，不多練手，光比劃，是不可能學好的。

學習目的

我的以後的研究方向是嵌入式，顯然，C語言是我的主要語言。我不是一個語言愛好者，我以前覺得，對於做研究而不是應用的人來說，了解多門語言，不如

精通一門語言。之所以去看python，主要還是因為python更有利於快速開發一些程序，也是因為現在認識到，研究和應用是不能分離的。個人以為，要

想在計算機工程的競爭中立足，必須懂C語言。因為真正要做高性能編程,

不可能將機器的體系架構拋到腦後讓Python虛擬機（或Java虛擬機等）幫你搞定所有底層。越來越多的CPU

core，越來越恐怖的內存性能瓶頸，對於上層開發人員來說，無所謂，但是對高性能程序開發人員來說，這些是無法透明的。很多應用，還是自己掌控比較有

效。這些場合中，彙編和C還是不可替代的。但是，光知道C是不夠的，掌握一門面向對象語言，相對更高層的語言，不僅對以後的個人發展有利，也會對自己的技

術認識產生幫助。

如果要問對我來說誰更重要，我覺得還是C更重要。C的學習曲線更陡，貌似簡單，實際上到處都是陷阱，看上去比較簡單低效的程序，也不是學1，2個月

就能搞定的。談到優化的深層次和難度嘛，需要的功底是按年算的。但是一旦你C語言的基礎打好了，對計算機的理解，對其他語言的理解都是大有裨益的。比如，

如果你有C基礎，可以說，學過1天python，就能寫的出來一些不短的程序。後面的優化也不是什麼大不了的算法，都是非常基本的語句換來換去。當然這裡

不是說 Python不好，實際上，上層應用，Python比C方便的不是一個層次。

很多人覺得，既然懂C了，那麼進一步掌握C＋＋應該是水到渠成，但C++不是C的超集，而我又不喜歡C＋＋的繁瑣和巨大，所以才決定看一看Python。我很喜歡Python的優雅與快捷。

語言類型

和C不一樣，Python是一種動態類型語言，又是強類型語言。這個分類怎麼理解呢？大概是可以按照下列說明來分類的：

靜態類型語言

一種在編譯期間就確定數據類型的語言。大多數靜態類型語言是通過要求在使用任一變量之前聲明其數據類型來保證這一點的。Java和 C 是靜態類型語言。

動態類型語言

一種在運行期間才去確定數據類型的語言，與靜態類型相反。Python 是動態類型的，因為它們確定一個變量的類型是在您第一次給它賦值的時候。

強類型語言

一種總是強制類型定義的語言。Java 和 Python 是強制類型定義的。您有一個整數，如果不明確地進行轉換 ，不能將把它當成一個字符串。

弱類型語言

一種類型可以被忽略的語言，與強類型相反。VBScript 是弱類型的。在 VBScript 中，您可以將字符串 ‘12′ 和整數 3 進行連接得到字符串’123′，然後可以把它看成整數 123 ，所有這些都不需要任何的顯示轉換。

對象機制

具體怎麼來理解這個“動態確定變量類型”，就要從Python的Object對象機制說起了。Objects（以下稱對象）是Python對於數據

的抽象，Python中所有的數據，都是由對象或者對象之間的關係表示的，函數是對象，字符串是對象，每個東西都是對象的概念。每一個對象都有三種屬性：

實體，類型和值。理解實體是理解對象中很重要的一步，實體一旦被創建，那麼就一直不會改變，也不會被顯式摧毀，同時通常意義來講，決定對象所支持的操作方

式的類型（type，包括number，string，tuple及其他）也不會改變，改變的只可能是它的值。如果要找一個具體點的說明，實體就相當於對

象在內存中的地址，是本質存在。而類型和值都只是實體的外在呈現。然後Python提供一些接口讓使用者和對象交互，比如id(）函數用來獲得對象實體的

整形表示（實際在這裡就是地址），type()函數獲取其類型。

這個object機制，就是c所不具備的，主要體現在下面幾點：

1 剛才說了，c是一個靜態類型語言，我們可以定義int a, char

b等等，但必須是在源代碼裡面事先規定。比如我們可以在Python裡面任意一處直接規定a =

“lk”，這樣，a的類型就是string，這是在其賦值的時候才決定的，我們無須在代碼中明確寫出。而在C裡面，我們必須顯式規定char *a =

“lk”，也就是人工事先規定好a的類型

2 由於在C中，沒有對象這個概念，只有“數據的表示”，比如說，如果有兩個int變量a和b，我們想比較大小，可以用a ＝＝

b來判斷，但是如果是兩個字符串變量a和b，我們就不得不用strcmp來比較了，因為此時，a和b本質上是指向字符串的指針，如果直接還是用＝＝比較，

那比較的實際是指針中存儲的值——地址。

在Java中呢，我們通過使用 str1 == str2 可以確定兩個字符串變量是否指向同一塊物理內存位置，這叫做“對象同一性”。在 Java 中要比較兩個字符串值，你要使用 str1.equals(str2)。

然後在Python中，和前兩者都不一樣，由於對象的引入，我們可以用“is”這個運算符來比較兩個對象的實體，和具體對象的type就沒有關係

了，比如你的對象是tuple也好，string也好，甚至class也好，都可以用”is”來比較，本質上就是“對象同一性”的比較，和Java中

的＝＝類似，和 C中的pointer比較類似。Python中也有＝＝比較，這個就是值比較了。

3

由於對象機制的引入，讓Python的使用非常靈活，比如我們可以用自省方法來查看內存中以對象形式存在的其它模塊和函數，獲取它們的信息，並對它們進行

操作。用這種方法，你可以定義沒有名稱的函數，不按函數聲明的參數順序調用函數，甚至引用事先並不知道名稱的函數。 這些操作在C中都是不可想象的。

4 還有一個很有意思的細節，就是類型對對象行為的影響是各方面的，比如說，a = 1; b =

1這個語句中，在Python裡面引發的，可能是a，b同時指向一個值為1的對象，也可能是分別指向兩個值為1的對象。而例如這個語句，c = []; d

= []，那麼c和d是肯定指向不同的，新創建的空list的。沒完，如果是”c = d =

[]“這個語句呢？此時，c和d又指向了相同的list對象了。這些區別，都是在c中沒有的。

最後，我們來說說為什麼python慢。主要原因就是function call

overhead比較大。因為所有東西現在都是對象了，contruct 和destroy 花費也大。連1 + 1 都是 function

call，像’12′+’45′ 這樣的要 create a third string object, then calls the string

obj’s __add。可想而知，速度如何能快起來？

列表和數組

分析Python中的list和C中的數組總是很有趣的。相信可能一些朋友和一樣，初學列表的時候，都是把它當作是數組來學的。最初對於list和數組區別的定性，主要是集中在兩點。首先，list可以包含很多不同的數據類型，比如

[“this”, 1, “is”, “an”, “array”]

這個List，如果放在C中，其實是一個字符串數組，相當於二維的了。

其次呢，list有很多方法，其本身就是一個對象，這個和C的單純數組是不同的。對於List的操作很多樣，因為有方法也有重載的運算符。也帶來一些問題，比如下面這個例子：

加入我們要產生一個多維列表，用下面這個語句

A = [[None] * 2] * 3

結果，A的值會是

[[None, None], [None, None], [None, None]]

初一看沒問題，典型的二維數組形式的列表。好，現在我們想修改第一個None的值，用語句

A[0][0] = 5

現在我們再來看看A的值：

[[5, None], [5, None], [5, None]]

發現問題沒有？這是因為用 * 來複制時，只是創建了對這個對象的引用，而不是真正的創建了它。 *3 創建了一個包含三個引用的列表，這三個引用都指向同一個長度為2的列表。其中一個行的改變會顯示在所有行中，這當然不是你想要的。解決方法當然有，我們這樣來創建

A = [None]*3

for i in range(3):

A[i] = [None] * 2

這樣創建了一個包含三個不同的長度為2的列表。

所以，還是一直強調的，越複雜的東西，越靈活，也越容易出錯。

代碼優化

C是一個很簡單的語言，當我們考慮優化的時候，通常想得也很簡單，比如系統級調用越少越好（緩衝區機制），消除循環的低效率和不必要的系統引用，等

等，其實主要都是基於系統和硬件細節考慮的。而Python就完全不一樣了，當然上面說的這些優化形式，對於Python仍然是實用的，但由於

Python的語法形式千差萬別，庫和模塊多種多樣，所以對於語言本身而言，就有很多值得注意的優化要點，舉幾個例子吧。

比如我們有一個list L1，想要構建一個新的list L2，L2包括L1的頭4個元素。按照最直接的想法，代碼應該是

L2 = []

for i in range[3]:

L2.append(L1[i])

而更加優化和優美的版本是

L2 = L1[:3]

再比如，如果s1..s7是大字符串(10K+)，那麼join([s1,s2,s3,s4,s5,s6,s7])就會比

s1+s2+s3+s4+s5+s6+s7快得多,因為後者會計算很多次子表達式，而join()則在一次過程中完成所有的複製。還有，對於字符串操作，

對字符串對象使用replace()方法。僅當在沒有固定字符串模式時才使用正則表達式。

所以說，以優化為評判標準，如果說C是短小精悍，Python就是博大精深。

include和import

在C語言中的include非常簡單，因為形式單一，意義明確，當你需要用到外部函數等資源時，就用include。而Python中有一個相似的

機制，就是import。乍一看，這兩個傢伙挺像的，不都是我們要用外部資源（最常見的就是函數或者模塊（Python））時就用這個來指明么？其實不

然，兩者的處理機制本質區別在於，C中的include是用於告訴預處理器，這個include指定的文件的內容，你都給我當作在本地源文件中出現過。而

import呢，不是簡單的將後面的內容*直接*插入到本地裡面去，這玩意更加靈活。事實上，幾乎所有類似的機制，Python都比C靈活。這裡不是說C

不好，C很簡練，我其實更喜歡C。

簡單說說這個靈活性。import在python中有三種形式，import X, from X import *( or a,b,c……),

X = __import__(’x’)。最常用的是第二種，因為比較方便，不像第一種那樣老是用X.module來調用模塊。from X

import *只是import那些public的module(一般都是不以__命名的模塊)，也可以指定a,b,c來import。

什麼時候用哪一種形式呢？應該說，在大多數的模塊文檔里，都會明確告訴你應該用哪種形式。如果需要用到很多對象，那麼from X import

*可能更合適一些，但是，就目前來看，大多數第三方Python庫都不推薦使用from modulename import *

這種格式。這樣做會使引入者的namespace混亂。很多人甚至對於那些專門設計用於這種模式的模塊（包括Tkinter,

threading和matplot）都不採用這種方式。而如果你僅僅需要某個對象類a，那麼用from X import a比用import

X.a更好，因為以後你調用a的函數直接用a.function()既可以了，不用加X。

如果你連自己希望import的模塊都不知道怎麼辦？請注意，此時Python的優勢就體現出來了，我們可以用

__import__(module)來調用module，其中這個module是字符串，這樣，可以在運行時再決定，你到底要調用什麼module。舉

個例子：

def classFromModule (module, Name):

mod = __import__ (module)

return getattr (mod, Name)

這裡，定義了一個函數classFromModule，你可以在代碼的任何時候調用它，

o = classFromModule (ModuleOfTheClass, NameOfTheAttribute)()

只需要傳入字符串形式的你希望import的模塊ModuleOfTheClass和其中屬性的名字NameOfTheAttribute（當然可以是數據也可以是方法），就能調用了，這個名字字符串不用事先指定，而是根據當時運行的情況來判斷。

順帶說一句，Python中import的順序也有默認規定，這個和C中的include有點類似，因為我們一般都是先include系統文件，再

include自己的頭文件（而且還有和“”的區別）。Python中呢，一般應該按照以下順序import模塊：

1. 標準庫模塊 — 如 sys, os, getopt 等

2. 第三方模塊

3. 本地實現的模塊。

全局變量

這裡談全局變量呢，倒不是說Python和c的全局變量概念不同，他們的概念是相同的。只是在使用機制上，是有一些差異的。舉個例子：

– module.py –

globalvar = 1

def func():

print globalvar

# This makes someglobal readonly,

# any attempt to write to someglobal

# would create a new local variable.

def func2():

global globalvar

globalvar = 2

# this allows you to manipulate the global

# variable

在 func這個函數中，globalvar是只讀的。如果你使用了globalvar =

xxx這種賦值語句，Python會重新創造一個新的本地對象並將新值賦給它，原來的對象值不變。而在func2函數中，由於我們事先申明了

globalvar是global的，那麼此時的更改就直接在全局變量上生效。

讀《瘋狂Python講義》有感

一、弱類型包含兩方面的含義：

2、變量的數據類型可以隨時改變

Python是一門弱類型語言

二、str的常用方法

str.title():將每個單詞的首字母改為大寫

str.lower():將整個字符串改為小寫

str.upper():將整個字符串改為大寫

str.strip():刪除字符串前後的空白

str.split():將字符串按指定分割符分割成多個短字符串

實例：print(s.split(‘.’)) #使用點進行分割

str.join():將多個短字符串連接成一個長字符串

實例：print(‘/ ‘.join(list)) #使用’/’作為分割符，將list中的所有短字符串連接成一個長字符串

三、三目運算符：“a大於b”if a b else “a不大於b” #輸出a大於b

四、lambda表達式的幾個要點：

1、lamdba表達式必須使用lamdba關鍵字定義

2、在lamdba關鍵字之後，冒號左邊的是參數列表，冒號右邊的是該lamdba表達式的返回值

五、函數裝飾器：

1、將被修飾的函數（函數B）作為參數傳給@符號引用的函數（函數A）

2、將函數B替換成第1步的返回值

六、Python並沒有真正的隱藏機制，所以Python類定義的所有成員默認都是公開的，如果程序希望將Python類中的某 些成員隱藏起來，那麼只要讓該成員的名字以上下劃線開頭即可

七、object類是所有類的父類

八、__repr__是python類中的一個特殊方法，它返回一個對象的“自我描述”信息，

所有的python對象都具有__repr__方法

九、雙端隊列（deque）：

如果要把deque當成棧使用，只需要在一端添加、刪除元素，因此調用append和pop方法即可

如果要把deque當成隊列使用，只要在一端添加元素，另一端刪除元素，因此調用append和popleft方法即可

十、目錄函數Path的使用：

Path.iterdir()：該方法可返回Path對應目錄下的所有子目錄和文件

Path.glob()：該方法可獲取Path對應目錄及其子目錄下匹配指定模式的所有文件

十一、os模塊的使用：

os.getcwd()：獲取當前目錄

os.mkdir(path,mode)：創建path對應的目錄，mode用於指定該目錄的權限

os.makedirs(path,mode)：它與mkdir的區別在於它可以遞歸創建目錄

十二、線程的生命周期：

線程的生命周期要經過新建（New）、就緒（Ready）、運行（Running）、

阻塞（Blocked）和死亡（Dead）5種狀態

十三、解決線程死鎖問題的幾種方式：

1.避免多次鎖定，盡量避免同一個線程對多個Lock進行鎖定

2.保證相同的加鎖順序，如果多個線程需要對多個Lock進行鎖定，則應該保證它們以相同的順序請求加鎖

3.使用定時鎖

4.死鎖檢測機制

十四、Python為進程通信提供了兩種機制：

1.Queue：一個進程向Queue中放入數據，另一個進程從Queue中讀取數據

2.Pipe：Pipe代表連接兩個進程的管道，程序在調用Pipe()函數時會產生兩個連接端，

分別交給通信的兩個進程，接下來進程既就可從該連接端讀取和寫入數據

十五、基於TCP協議的網絡編程：

1.服務器端編程的基本步驟：

a.創建一個socket對象

b.綁定指定IP地址和端口

c.調用listen()方法監聽網絡

d.調用accept()方法接收客戶端的連接

2.客戶端編程的基本步驟：

a.創建socket對象

b.調用connect()方法連接遠程服務器

十六、單元測試

1.單元測試的邏輯覆蓋包括：

a.語句覆蓋：每條語句都至少執行一次

b.判定覆蓋：每條語句都執行，每個判定的所有可能結果都至少執行一次

c.條件覆蓋：每條語句都執行，判定表達式的每種可能都取得各種結果

d.判定-條件覆蓋：同時滿足判定覆蓋和條件覆蓋，每個判定條件的各種可能組合都至少出現一次

e.路徑覆蓋：程序的每條可能路徑都至少執行一次

總結：通常在實際測試中，基本要求是做到判定覆蓋即可