最近準備重新系統學習一下Python語言，著手研讀Python 3.6.1官方教程文件，於是想著不如翻譯整理出來 , 希望能幫到一起學習Python的同學們，與大家一起進步，由於水平有限，翻譯若有不妥之處，請大家指正 。

　　在以下示例中，輸入和輸出通過提示符（>>>和…）是否存在區分：若要重複該示例，你必須在出現提示符後鍵入所有內容; 不是以提示符開始的行從直譯器輸出的結果。 請注意，在一個示例中，一行上的輔助提示符本身就意味著你必須鍵入一個空行; 這用於結束多行命令。
　　本手冊中的許多示例，即使是在互動式提示中輸入的示例，也可以包括註釋。 Python中的註釋以‘#’開頭，並擴充套件到物理行的末尾。 一個註釋可能會出現在行的開頭或後面的空格或程式碼，但不能在字串中。 字串中的‘#’只是一個雜湊字元。由於註釋是為了澄清程式碼而不是解釋Python，所以在輸入示例時可能會省略它們。
例如：

# this is the first comment
spam = 1 # and this is the second comment
　　　　　# … and now a third!
text = “# This is not a comment because it’s inside quotes.”

3.1　使用Python作為計算器

　　我們來嘗試一些簡單的Python命令。 啟動直譯器，等待主提示符>>>。 （不要花很長時間）

3.1.1　Numbers

　　Python直譯器作為一個簡單的計算器：你可以在其中鍵入一個表示式，它將輸出該表示式的結果。 表示式語法很簡單：運算子+， - ，*和/ ，用起來就像大多數其他語言（例如，Pascal或C）一樣; 括號()可用於組合。 例如：

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5 # division always returns a floating point number
1.6

　　整數（例如2，4，20）是int型別，具有小數部分（例如5.0,1.6）的j float型別。 本教程稍後將介紹有關數字型別的更多資訊。
　　除法（/）總是返回一個float。若要進行分割槽並獲得整數結果（丟棄任何分數結果），可以使用//運算子; 計算剩餘部分可以使用％：

>>> 17 / 3 # classic division returns a float
5.666666666666667
>>>
>>> 17 // 3 # floor division discards the fractional part
5
>>> 17 % 3 # the % operator returns the remainder of the division
2
>>> 5 * 3 + 2 # result divisor + remainder*
17

　　在Python語言中，可以使用**運算子來計算指數冪

>>> 5 * 2 # 5 squared*
25
>>> 2 * 7 # 2 to the power of 7*
128

　　等號（=）是用於為變數賦值。它在下一個互動式提示符之前不會顯示結果：

>>> width = 20
>>> height = 5 * 9
>>> width * height
900

　　如果一個變數沒有被定義（賦值），嘗試使用它會給出如下錯誤：

>>> n # try to access an undefined variable
Traceback (most recent call last):
File “”, line 1, in
NameError: name ‘n’ is not defined

　　Python完全支援浮點數; 帶有混合型別運算元的運算子會將整數運算元轉換為浮點數：

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

　　在互動模式下，最後列印的表示式賦給變數‘_’。 這意味著當您使用Python作為桌面計算器時，可更方便於繼續計算，例如：

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

　　該變數應該被使用者視為只讀。 不要顯式分配一個值給‘_’，如果你這麼做，將會建立一個具有相同名稱的獨立本地變數，並遮蔽該內建變數。
　　除了int和float型別外，Python還支援其他型別的數字，例如Decimal和Fraction。 Python還內建了對複數的支援，並使用j或J字尾來表示虛部（例如3 + 5j）。

3.1.2 String

　　除了數字，Python也可以操作字串，可以用以下幾種方式表達。 它們可以用單引號（’…’）或雙引號（“…”）括起來，結果相同， \可以用來轉義引號：

>>> ‘spam eggs’ # single quotes
‘spam eggs’
>>> ‘doesn\’t’ # use \’ to escape the single quote…
“doesn’t”
>>> “doesn’t” # …or use double quotes instead
“doesn’t”
>>> ‘“Yes,” he said.’
‘“Yes,” he said.’
>>> “\”Yes,\” he said.”
‘“Yes,” he said.’
>>> ‘“Isn\’t,” she said.’
‘“Isn\’t,” she said.’

　　在互動式直譯器中，輸出字串用引號括起來，特殊字元用反斜槓轉義。 雖然這有時可能看起來不同於輸入（封閉的引號可能會改變），但是兩個字串是等效的。 如果字串包含單引號並且沒有雙引號，則該字串用雙引號括起來，否則將其括在單引號中。 print()函式產生一個更可讀的輸出，省略封閉引號，並列印轉義和特殊字元：

>>> ‘“Isn\’t,” she said.’
‘“Isn\’t,” she said.’
>>> print(‘“Isn\’t,” she said.’)
“Isn’t,” she said.
>>> s = ‘First line.\nSecond line.’ # \n means newline
>>> s # without print(), \n is included in the output
‘First line.\nSecond line.’
>>> print(s) # with print(), \n produces a new line
First line.
Second line.

　　如果您不希望以\開頭的字元被轉義為特殊字元，則可以在第一個引號之前新增一個r來使用原始字串：

>>> print(‘C:\some\name’) # here \n means newline!
C:\some
ame
>>> print(r’C:\some\name’) # note the r before the quote
C:\some\name

　　字串文字可以跨越多行。 一種方法是使用三重引號：“”“…”“”或“”…”。行的尾部被自動包括在字串中的，但它能夠通過在該行的末尾新增一個\來防止這一點。例如：

print(“”“\
Usage: thingy [OPTIONS]
　　-h Display this usage message
　　-H hostname Hostname to connect to
“”“)

輸出結果如下：

Usage: thingy [OPTIONS]
　　-h Display this usage message
　　-H hostname Hostname to connect to

　　字串可以用+操作符連線（膠合在一起），也可以用*複製：

>>> # 3 times ‘un’, followed by ‘ium’
>>> 3 * ‘un’ + ‘ium’
‘unununium’

　　兩個或多個字串文字（即引號之間的引號）彼此相鄰的字串文字自動合併。

>>> ‘Py’ ‘thon’
‘Python’

　　這隻適用於兩個字串，但不適用於變數或表示式：

>>> prefix = ‘Py’
>>> prefix ‘thon’ # can’t concatenate a variable and a string literal
…
SyntaxError: invalid syntax
>>> (‘un’ * 3) ‘ium’
…
SyntaxError: invalid syntax

　　如果要連線變數或變數和字串，請使用+：

>>> prefix + ‘thon’
‘Python’

　　當您想要打斷長字串時，此功能特別有用：

>>> text = (‘Put several strings within parentheses ’
… ‘to have them joined together.’)
>>> text
‘Put several strings within parentheses to have them joined together.’

　　字串可以通過下標索引，第一個字元的下標索引為0. 沒有單獨的字元型別; 一個字元是一個大小為一的字串：

>>> word = ‘Python’
>>> word[0] # character in position 0
‘P’
>>> word[5] # character in position 5
‘n’

　　索引數也可能是負數，從意味著從右邊開始計數：

>>> word[-1] # last character
‘n’
>>> word[-2] # second-last character
‘o’
>>> word[-6]
‘P’

　　注意，由於-0與0相同，負索引從-1開始。
　　除索引之外，Python還支援slice。 當使用索引來獲取單個字元時，slice可以讓您獲取子字串：

>>> word[0:2] # characters from position 0 (included) to 2 (excluded)
‘Py’
>>> word[2:5] # characters from position 2 (included) to 5 (excluded)
‘tho’

　　注意若索引值冒號前預設，則認為是從第一個開始：如s[:i]== s[0:i]，若索引值冒號後預設，則認為不包含i, 例如s[i:]是不包含s[i]這個字元的。即確保s [：i] + s [i：]始終等於s：

>>> word[:2] + word[2:]
‘Python’
>>> word[:4] + word[4:]
‘Python’

　　Slice需要有有效的預設值索引值; 省略的第一個索引預設為零，省略的第二個索引預設為要分割的字串的大小。

>>> word[:2] # character from the beginning to position 2 (excluded)
‘Py’
>>> word[4:] *# characters from position 4 (included) to the end
‘on’*
>>> word[-2:] # characters from the second-last (included) to the end
‘on’

　　記住slice如何工作的一種方式是將索引視為指向字元之間，第一個字元的左邊緣編號為0.然後n個字串的最後一個字元的右邊緣具有索引n，例如：

+—+—+—+—+—+—+
 | P  | y  |  t  |   h | o  | n  |
+—+—+—+—+—+—+
0    1     2    3    4    5     6
-6  -5   -4   -3   -2  -1

　　第一行數字給出了字串中的索引0 … 6的位置; 第二行給出相應的負索引。 從i到j的slice分別由標記為i和j的邊緣之間的所有字元組成。
　　對於非負指數，slice的長度是索引的差值，如果兩者都在範圍內。 例如，字[1：3]的長度為2。
　　如果使用過大的索引值將導致錯誤：

>>> word[42] # the word only has 6 characters
Traceback (most recent call last):
File “”, line 1, in
IndexError: string index out of range

　　但是，超出範圍的slice索引可以正常處理：

＼>>> word[4:42]
‘on’
＼>>> word[42:]
”

　　Python字串不能被更改，它們是不可變的。 因此，賦值字串中的索引位置會導致錯誤：

>>> word[0] = ‘J’
…
TypeError: ‘str’ object does not support item assignment
>>> word[2:] = ‘py’
…
TypeError: ‘str’ object does not support item assignment

　　如果您需要一個不同的字串，您應該建立一個新的字串：

>>> ‘J’ + word[1:]
‘Jython’
>>> word[:2] + ‘py’
‘Pypy’

　　內建函式len（）返回字串的長度：

>>> s = ‘supercalifragilisticexpialidocious’
>>> len(s)
34

也可以參考

文字序列型別 - str
　　字串是序列型別的示例，並支援這些型別支援的常見操作。
String方法
　　字串支援大量的基本轉換和搜尋方法。
格式化字串文字
　　具有嵌入表示式的字串文字。
格式化字串語法
　　有關使用str.format（）的字串格式化的資訊。
Printf型別的字串格式
　　當字串是％操作符的左運算元時呼叫的舊格式化操作在此更詳細地描述。

3.1.3. Lists

　　Python支援複合資料型別，用於將其他值組合在一起。 最通用的是list列表，可以寫成方括號之間的逗號隔開的列表。 列表可能包含不同型別的item，但通常這些item都具有相同的型別。

>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

　　像字串（和所有其他內建的序列型別）一樣，list可以索引和slice：

>>> squares[0] # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:] # slicing returns a new list
[9, 16, 25]

　　所有slice操作返回的是包含所請求元素的新列表。 這意味著以下切片返回列表的新列表：

>>> squares[:]
[1, 4, 9, 16, 25]
　　列表還支援連線操作：
>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

　　不同於不可變的字串，列表是可變型別，即可以更改其內容：

>>> cubes = [1, 8, 27, 65, 125] # something’s wrong here
>>> 4 ** 3 # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64 # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]

　　你還可以在列表末尾新增新item，方法是使用append()方法（稍後將會詳細介紹有關方法）：

>>> cubes.append(216) # add the cube of 6
>>> cubes.append(7 * 3) # and the cube of 7*
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

　　賦值到slice也是可以的，它甚至可以更改列表的大小或完全清除它：

>>> letters = [‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’]
>>> letters
[‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’]
>>> # replace some values
>>> letters[2:5] = [‘C’, ‘D’, ‘E’]
>>> letters
[‘a’, ‘b’, ‘C’, ‘D’, ‘E’, ‘f’, ‘g’]
>>> # now remove them
>>> letters[2:5] = []
>>> letters
[‘a’, ‘b’, ‘f’, ‘g’]
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters
[]

　　內建函式len()也適用於列表：

>>> letters = [‘a’, ‘b’, ‘c’, ‘d’]
>>> len(letters)
4

　　Python也可以支援巢狀列表（建立包含其他列表的列表），例如：

>>> a = [‘a’, ‘b’, ‘c’]
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[[‘a’, ‘b’, ‘c’], [1, 2, 3]]
>>> x[0]
[‘a’, ‘b’, ‘c’]
>>> x[0][1]
‘b’

3.2 開始程式設計的第一步

　　當然，我們可以使用Python進行更復雜的任務，而不是將兩個新增在一起。 例如，我們可以寫一個Fibonacci series的初始子序列：

>>> # Fibonacci series:
… # the sum of two elements defines the next
… a, b = 0, 1
>>> while b < 10:
…　　print(b)
…　　a, b = b, a+b
…
1
1
2
3
5
8

　　此示例介紹了幾個新特性。
　　第一行包含一個多重賦值：變數a和b同時獲取新的值0和1. 在最後一行，也是這樣，表明在任何賦值之前，右側的表示式先執行（計算）。右側表示式從左到右進行執行（計算）。
　　只要條件（這裡：b <10）保持為true，則while迴圈繼續將執行。在Python中，像在C中，任何非零整數值都為真;零是假的條件也可以是任何序列包括字串或列表值;任何具有非零長度的東西都是真的，空的序列是假的。該示例中使用的是一個簡單的比較。標準比較運算子與C語言一樣：<（小於），>（大於），==（等於），<=（小於或等於），> =（大於或等於）和！=（不等於）。
　　迴圈體是縮排的：縮排是Python對語句進行分組的方法。在互動式提示符下，您必須為每個縮排行鍵入一個tab鍵或空格。在實踐中，你需要使用文字編輯器來編寫更復雜的Python程式碼; 好的程式碼編輯器都有自動縮排功能。當以互動方式輸入複合語句時，它必須後跟一個空行來指示完成（因為解析器無法猜測哪一行是最後一行）。請注意，基本塊中的每一行必須縮排相同的數量。
　　print()函式寫入給定的引數的值。它不同於只需要以處理多個引數，浮點數量和字串的方式編寫表示式（如我們之前在計算器示例中所做的那樣）。列印沒有帶引號字串，並且在item之間插入一個空格，所以你可以很好地格式化它們，如下所示：

>>> i = 256*256
>>> print(‘The value of i is’, i)
The value of i is 65536

　　關鍵字引數end可以用於避免輸出被換行，或者用不同的字串結束輸出：

>>> a, b = 0, 1
>>> while b < 1000:
…　　print(b, end=’,’)
…　　a, b = b, a+b
…
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,