3.1

print語句

（1）字串和數值型別可以直接輸出

（2）變數：無論什麼型別，數值，布林，列表，字典都可以直接輸出

（3）格式化輸出：

1. In [5]: s='hello'

2. In [6]: x=len(s)

3. In [7]: print("The length of %s is %d" %(s,x))

4. The length of hello is 5

%字元：標記轉換說明服的開始

轉換標誌:-表示左對齊；+表示在轉換值之前要加上正負號；""（空白字元）表示整數之前保留空格；0表示轉換值若位數不夠用0補充

最小欄位寬度：轉換後的字串至少應該具有該值指定的寬度。如果是*,則寬度會從值元組中讀出

點(.)後跟精度：如果轉換的是字串，該數字表示最大的欄位寬度

1. In [9]: print("%.3s" %s)

2. hel

（4）如何讓print不換行

應該寫成print(x,end='')

1. In [10]: for x in range(0,10):

2. ...: print(x,end='')

3. ...:

4. 0123456789

 3.2 

賦值語句

 

運算	解釋
spam='Spam'	基本形式
spam,ham = 'yum','YUM'	元組賦值運算（位置性）
[spam,ham]=['yum','YUM']	列表賦值運算（位置性）
a,b,c,d='spam'	序列賦值運算，通用性
a,b,c = [1,2,3]
a,*b = 'spam'	擴充套件的序列解包（Python3.0）
spam = ham = 'lunch'	多目標賦值運算
spams += 42	增強賦值運算（相當於spams = spams + 42）

-------------------------------------------------------------------------------------------------------------------------------------------------------

序列賦值

 

1. >>> nudge = 1

2. >>> wink =2

3. >>> A,B = nudge,wink

4. >>> A,B

5. (1, 2)

6. >>> [C,D] = [nudge,wink]

7. >>> C,D

8. (1, 2)

1. >>> nudge = 1

2. >>> wink =2

3. >>> nudge,wink = wink,nudge

4. >>> nudge,wink

5. (2, 1)

元組賦值語句可以得到Python中一個常用的編寫程式碼的技巧。
因為語句執行時，Python會建立臨時的元組，來儲存右側變數原始的值，分解賦值語句也是一種交換兩變數的值，卻不需要自行建立臨時變數的方式：右側的元組會自動記住先前的變數的值。

 

事實上，Python中原始的元組和列表賦值語句形式，最後已經被通用化，以接受右側可以是任何型別的序列，只要長度相等即可。
你可以將含有一些值的元組賦值給含有一些變數的列表，字串中的字元賦值給含有一些變數的元組。

 

1. >>> [a,b,c]=(1,2,3)

2. >>> a,c

3. (1, 3)

4. >>> (a,b,c)='ABC'

5. >>> a,c

6. ('A', 'C')

-------------------------------------------------------------------------------------------------------------------------------------------------------

高階序列賦值語句模式

可以賦值巢狀序列，而Python會根據其情況分解其組成部分，就像預期的一樣：

1. >>> string = 'SPAM'

2. >>> (a,b),c=string[:2],string[2:]

3. >>> a,b,c

4. ('S', 'P', 'AM')

序列解包賦值語句也會產生另一種Python常見用法，也就是賦值一系列整數給一組變數。

1. >>> red,green,blue = range(3)

2. >>> red,blue

3. (0, 2)

另一個會看見元組賦值語句的地方就是，在迴圈中把序列分割為開頭和剩餘的兩部分，如下：

1. >>> L=[1,2,3,4]

2. >>> while L:

3. front,L = L[0],L[1:]

4. print(front,L)

5.  
6.  

7. 1 [2, 3, 4]

8. 2 [3, 4]

9. 3 [4]

10. 4 []

-------------------------------------------------------------------------------------------------------------------------------------------------------
Python3.0中的擴充套件序列解包

一個帶有單個星號的名稱，可以在賦值目標中使用，以指定對於序列的一個更為通用的匹配——一個列表賦給了帶星號的名稱，該列表收集了序列中沒有賦值給其他名稱的所有項。對於前面示例中把序列劃分為其“前面”和“剩餘”部分的常用編碼模式，這種方法特別方便。

擴充套件解包的實際應用：

a匹配序列中的第一項，b匹配剩下的內容：

 

1. >>> seq = [1,2,3,4]

2. >>> a,*b = seq

3. >>> a

4. 1

5. >>> b

6. [2, 3, 4]

b匹配序列的最後一項，a匹配最後一項之前的所有內容：

1. >>> *a,b=seq

2. >>> a

3. [1, 2, 3]

4. >>> b

5. 4

第一項和最後一項分別賦給了a和c，而b獲取了二者之間的所有內容：

1. >>> a,*b,c = seq

2. >>> a,

3. (1,)

4. >>> b

5. [2, 3]

6. >>> c

7. 4

更一般的，不管帶星號的名稱出現在哪裡，包含該位置的每個未賦值名稱的一個列表都將賦給它：

1. >>> a,b,*c = seq

2. >>> a

3. 1

4. >>> b

5. 2

6. >>> c

7. [3, 4]

和常規的序列賦值一樣，擴充套件的序列解包語法對於任何序列型別都有效，而不只是對列表有效：

1. >>> a,*b = 'spam'

2. >>> a,b

3. ('s', ['p', 'a', 'm'])

1. >>> a,*b,c = 'spam'

2. >>> a,b,c

3. ('s', ['p', 'a'], 'm')

Python3.0有了這一擴充套件，我們處理前面一個小節最後一個例子的列表變得容易得多了：

1. >>> L=[1,2,3,4]

2. >>> while L:

3. front,*L = L

4. print(front,L)

5.  
6.  

7. 1 [2, 3, 4]

8. 2 [3, 4]

9. 3 [4]

10. 4 []

-------------------------------------------------------------------------------------------------------------------------------------------------------
邊界情況

首先，帶星號的名稱可能只匹配單個的項，但是，總是會向其賦值一個列表：

1. >>> seq

2. [1, 2, 3, 4]

3. >>> a,b,c,*d = seq

4. >>> print(a,b,c,d)

5. 1 2 3 [4]

其次，如果沒有剩下的內容可以匹配帶星號的名稱，它會賦值一個空的列表，不顧該名稱出現在哪裡。

1. >>> a,b,c,d,*e = seq

2. >>> print(a,b,c,d,e)

3. 1 2 3 4 []

最後，如果有多個帶星號的名稱，或者如果值少了而沒有帶星號的名稱，以及如果帶星號的名稱自身沒有編寫到一個列表中，都會引起錯誤
-------------------------------------------------------------------------------------------------------------------------------------------------------

一個有用的便利形式：常用的“第一個，其餘的”分片編碼模式可以用擴充套件的解包來編寫

應用於for迴圈：

 

1. for(a,*b,c) in [(1,2,3,4),(5,6,7,8)]:

2. ...

當在這種環境中使用的時候，在每次迭代中，Python直接把下一個值得元組分配給名稱的元組，例如，在第一次迴圈中，就好像我們執行如下的賦值語句：

a,*b,c = (1,2,3,4)  # b gets [2,3]

=======================================================================================
多目標賦值語句

 

多目標賦值語句就是直接把所有提供的變數名都賦值給右側的物件：

 

1. >>> a = b = c = 'spam'

2. >>> a,b,c

3. ('spam', 'spam', 'spam')

4. >>> a is b is c

5. True

其相當於三個賦值語句：

 

1. >>> a = 'spam'

2. >>> b =a

3. >>> c = a

-------------------------------------------------------------------------------------------------------------------------------------------------------
多目標賦值以及共享引用

 

記住，這裡只有一個物件，由三個變數共享（全都指向記憶體內同一物件）。
這種行為對於不可變型別而言並沒有問題，但對於可變物件，我們就要小心一點：

 

1. >>> a = b = 0

2. >>> a += 1

3. >>> a,b

4. (1, 0)

1. >>> a = b = []

2. >>> a.append('test')

3. >>> a,b

4. (['test'], ['test'])

上例中，因為a和b引用相同的物件，通過b在原處附加值上去，而我們通過a也會看見所有的效果。

=======================================================================================
增強賦值

 

x+=y
x*=y
x%=y
x&=y
x^=y
x<<=y
x-=y
x/=y
x**=y
x|=y
x>>=y
x//=y

優點：
1.程式設計師輸入減少
2.左側只需計算一次。在完整形式x = x+y中，x出現兩次，必須執行兩次。因此，增強賦值語句通常執行得更快。
3.優化技術會自動選擇。對於支援在原處修改的物件而言，增強形式會自動執行原處的修改運算，而不是相比來說速度更慢的複製。

3.3

python的程式碼縮排

要求嚴格的程式碼縮排是python語法的一大特色，就像C語言家族（C、C++、Java、C#等等）中的花括號一樣重要，在大多數場合還有必要。

在很多程式碼規範裡面也都有要求程式碼書寫按照一定的規則進行換行和程式碼縮排，但是這些要求只是純粹是方便人（程式設計師）來閱讀、使用或修改的，對於編譯器或者直譯器而言，完全是視而不見的。但是對Python直譯器而言，每行程式碼前的縮排都有語法和邏輯上的意義。

在實際情況中，由於程式碼縮排而出現語法錯誤或邏輯錯誤，一是混用tab和空格縮排，二是編輯器對縮排的處理各異。一般認為執行結果應該是顯示a，實際是顯示a、c，原因很簡單，1個tab，python會認為是8個空格。

為了避免因程式碼縮排而產生不必要的麻煩，寫python程式碼應該，使用唯一的縮排方式（要麼tab，要麼空格），使用固定和統一的編輯器，此外，還應該利用好編輯器的一些特性。對於notepad++而言，除了上面所說的顯示空格和製表符外，還有兩個特性可以使用：一是，編輯選單下的blank operation有兩個選項tab to space和space to tab，如果對上圖的那段程式碼做tab to space，程式碼列對齊基本不變，箭頭都變成點，但是執行結果是a；二是，在設定-首選項-語言下可以選上“以空格代替”，這樣以後每次按tab鍵都會自動轉換為空格。

3.4

Python 條件語句

由 13676692808 建立，Carrie 最後一次修改 2015-09-22

Python 條件語句

Python條件語句是通過一條或多條語句的執行結果（True或者False）來決定執行的程式碼塊。

可以通過下圖來簡單瞭解條件語句的執行過程:

Python程式語言指定任何非0和非空（null）值為true，0 或者 null為false。

Python 程式設計中 if 語句用於控制程式的執行，基本形式為：

if 判斷條件：
    執行語句……
else：
    執行語句……

其中"判斷條件"成立時（非零），則執行後面的語句，而執行內容可以多行，以縮排來區分表示同一範圍。

else 為可選語句，當需要在條件不成立時執行內容則可以執行相關語句，具體例子如下：

# coding=utf8
# 例1：if 基本用法

flag = False
name = 'luren'
if name == 'python':         # 判斷變數否為'python'
    flag = True          # 條件成立時設定標誌為真
    print 'welcome boss'    # 並輸出歡迎資訊
else:
    print name              # 條件不成立時輸出變數名稱

輸出結果為：

>>> luren         # 輸出結果

if 語句的判斷條件可以用>（大於）、=（大於等於）、<=（小於等於）來表示其關係。

當判斷條件為多個值是，可以使用以下形式：

if 判斷條件1:
    執行語句1……
elif 判斷條件2:
    執行語句2……
elif 判斷條件3:
    執行語句3……
else:
    執行語句4……

例項如下：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
# 例2：elif用法
 
num = 5     
if num == 3:            # 判斷num的值
    print 'boss'        
elif num == 2:
    print 'user'
elif num == 1:
    print 'worker'
elif num < 0:           # 值小於零時輸出
    print 'error'
else:
    print 'roadman'     # 條件均不成立時輸出

輸出結果為：

>>> roadman     # 輸出結果

由於 python 並不支援 switch 語句，所以多個條件判斷，只能用 elif 來實現，如果判斷需要多個條件需同時判斷時，可以使用 or （或），表示兩個條件有一個成立時判斷條件成功；使用 and （與）時，表示只有兩個條件同時成立的情況下，判斷條件才成功。

 

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 例3：if語句多個條件

num = 9
if num >= 0 and num <= 10:    # 判斷值是否在0~10之間
    print 'hello'
>>> hello		# 輸出結果

num = 10
if num < 0 or num > 10:    # 判斷值是否在小於0或大於10
    print 'hello'
else:
	print 'undefine'
>>> undefine		# 輸出結果

num = 8
# 判斷值是否在0~5或者10~15之間
if (num >= 0 and num <= 5) or (num >= 10 and num <= 15):    
    print 'hello'
else:
    print 'undefine'
>>> undefine		# 輸出結果

 

當if有多個條件時可使用括號來區分判斷的先後順序，括號中的判斷優先執行，此外 and 和 or 的優先順序低於>（大於）、<（小於）等判斷符號，即大於和小於在沒有括號的情況下會比與或要優先判斷。

簡單的語句組

你也可以在同一行的位置上使用if條件判斷語句，如下例項：

 

#!/usr/bin/python 
# -*- coding: UTF-8 -*-
 
var = 100 
 
if ( var  == 100 ) : print "變數 var 的值為100" 
 
print "Good bye!"

 

以上程式碼執行輸出結果如下：

 

變數 var 的值為100
Good bye!

3.5

Python3 迴圈語句

本章節將為大家介紹Python迴圈語句的使用。

Python中的迴圈語句有 for 和 while。

Python迴圈語句的控制結構圖如下所示：

---

while 迴圈

Python中while語句的一般形式：

while 判斷條件：
    語句

執行 Gif 演示：

同樣需要注意冒號和縮排。另外，在 Python 中沒有 do..while 迴圈。

以下例項使用了 while 來計算 1 到 100 的總和：

例項

#!/usr/bin/env python3 n = 100 sum = 0 counter = 1 while counter <= n: sum = sum + counter counter += 1 print("1 到 %d 之和為: %d" % (n,sum))

執行結果如下：

1 到 100 之和為: 5050

無限迴圈

我們可以通過設定條件表示式永遠不為 false 來實現無限迴圈，例項如下：

例項

#!/usr/bin/python3 var = 1 while var == 1 : # 表示式永遠為 true num = int(input("輸入一個數字 :")) print ("你輸入的數字是: ", num) print ("Good bye!")

執行以上指令碼，輸出結果如下：

輸入一個數字  :5
你輸入的數字是:  5
輸入一個數字  :

你可以使用 CTRL+C 來退出當前的無限迴圈。

無限迴圈在伺服器上客戶端的實時請求非常有用。

while 迴圈使用 else 語句

在 while … else 在條件語句為 false 時執行 else 的語句塊：

例項

#!/usr/bin/python3 count = 0 while count < 5: print (count, " 小於 5") count = count + 1 else: print (count, " 大於或等於 5")

執行以上指令碼，輸出結果如下：

0  小於 5
1  小於 5
2  小於 5
3  小於 5
4  小於 5
5  大於或等於 5

簡單語句組

類似if語句的語法，如果你的while迴圈體中只有一條語句，你可以將該語句與while寫在同一行中， 如下所示：

例項

#!/usr/bin/python flag = 1 while (flag): print ('歡迎訪問菜鳥教程!') print ("Good bye!")

注意：以上的無限迴圈你可以使用 CTRL+C 來中斷迴圈。

執行以上指令碼，輸出結果如下：

歡迎訪問菜鳥教程!
歡迎訪問菜鳥教程!
歡迎訪問菜鳥教程!
歡迎訪問菜鳥教程!
歡迎訪問菜鳥教程!
……

---

for 語句

Python for迴圈可以遍歷任何序列的專案，如一個列表或者一個字串。

for迴圈的一般格式如下：

for <variable> in <sequence>: <statements> else: <statements>

Python loop迴圈例項：

例項

>>>languages = ["C", "C++", "Perl", "Python"] >>> for x in languages: ... print (x) ... C C++ Perl Python >>>

以下 for 例項中使用了 break 語句，break 語句用於跳出當前迴圈體：

例項

#!/usr/bin/python3 sites = ["Baidu", "Google","Runoob","Taobao"] for site in sites: if site == "Runoob": print("菜鳥教程!") break print("迴圈資料 " + site) else: print("沒有迴圈資料!") print("完成迴圈!")

執行指令碼後，在迴圈到 "Runoob"時會跳出迴圈體：

迴圈資料 Baidu
迴圈資料 Google
菜鳥教程!
完成迴圈!

---

range()函式

如果你需要遍歷數字序列，可以使用內建range()函式。它會生成數列，例如:

例項

>>>for i in range(5): ... print(i) ... 0 1 2 3 4

你也可以使用range指定區間的值：

例項

>>>for i in range(5,9) : print(i) 5 6 7 8 >>>

也可以使range以指定數字開始並指定不同的增量(甚至可以是負數，有時這也叫做'步長'):

例項

>>>for i in range(0, 10, 3) : print(i) 0 3 6 9 >>>

負數：

例項

>>>for i in range(-10, -100, -30) : print(i) -10 -40 -70 >>>

您可以結合range()和len()函式以遍歷一個序列的索引,如下所示:

例項

>>>a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ'] >>> for i in range(len(a)): ... print(i, a[i]) ... 0 Google 1 Baidu 2 Runoob 3 Taobao 4 QQ >>>

還可以使用range()函式來建立一個列表：

例項

>>>list(range(5)) [0, 1, 2, 3, 4] >>>

---

break和continue語句及迴圈中的else子句

break 語句可以跳出 for 和 while 的迴圈體。如果你從 for 或 while 迴圈中終止，任何對應的迴圈 else 塊將不執行。 例項如下：

例項

#!/usr/bin/python3 for letter in 'Runoob': # 第一個例項 if letter == 'b': break print ('當前字母為 :', letter) var = 10 # 第二個例項 while var > 0: print ('當期變數值為 :', var) var = var -1 if var == 5: break print ("Good bye!")

執行以上指令碼輸出結果為：

當前字母為 : R
當前字母為 : u
當前字母為 : n
當前字母為 : o
當前字母為 : o
當期變數值為 : 10
當期變數值為 : 9
當期變數值為 : 8
當期變數值為 : 7
當期變數值為 : 6
Good bye!

continue語句被用來告訴Python跳過當前迴圈塊中的剩餘語句，然後繼續進行下一輪迴圈。

例項

#!/usr/bin/python3 for letter in 'Runoob': # 第一個例項 if letter == 'o': # 字母為 o 時跳過輸出 continue print ('當前字母 :', letter) var = 10 # 第二個例項 while var > 0: var = var -1 if var == 5: # 變數為 5 時跳過輸出 continue print ('當前變數值 :', var) print ("Good bye!")

執行以上指令碼輸出結果為：

當前字母 : R
當前字母 : u
當前字母 : n
當前字母 : b
當前變數值 : 9
當前變數值 : 8
當前變數值 : 7
當前變數值 : 6
當前變數值 : 4
當前變數值 : 3
當前變數值 : 2
當前變數值 : 1
當前變數值 : 0
Good bye!

迴圈語句可以有 else 子句，它在窮盡列表(以for迴圈)或條件變為 false (以while迴圈)導致迴圈終止時被執行,但迴圈被break終止時不執行。

如下例項用於查詢質數的迴圈例子:

例項

#!/usr/bin/python3 for n in range(2, 10): for x in range(2, n): if n % x == 0: print(n, '等於', x, '*', n//x) break else: # 迴圈中沒有找到元素 print(n, ' 是質數')

執行以上指令碼輸出結果為：

2  是質數
3  是質數
4 等於 2 * 2
5  是質數
6 等於 2 * 3
7  是質數
8 等於 2 * 4
9 等於 3 * 3

---

pass 語句

Python pass是空語句，是為了保持程式結構的完整性。

pass 不做任何事情，一般用做佔位語句，如下例項

例項

>>>while True: ... pass # 等待鍵盤中斷 (Ctrl+C)

最小的類:

例項

>>>class MyEmptyClass: ... pass

以下例項在字母為 o 時 執行 pass 語句塊:

例項

#!/usr/bin/python3 for letter in 'Runoob': if letter == 'o': pass print ('執行 pass 塊') print ('當前字母 :', letter) print ("Good bye!")

執行以上指令碼輸出結果為：

當前字母 : R
當前字母 : u
當前字母 : n
執行 pass 塊
當前字母 : o
執行 pass 塊
當前字母 : o
當前字