非正式的 Python 簡介

下面的例子中，輸入和輸出分別由大于號(hào)和句號(hào)提示符（>>>?和?...?）：如果想重現(xiàn)這些例子，就要在解釋器的提示符后，輸入（提示符后面的）那些不包含提示符的代碼行。需要注意的是在練習(xí)中遇到的從屬提示符表示你需要在最后多輸入一個(gè)空行，解釋器才能知道這是一個(gè)多行命令的結(jié)束。

本指南中的很多示例——包括那些帶有交互提示符的——都含有注釋。Python 中的注釋以#字符起始，直至實(shí)際的行尾。注釋可以從行首開始，也可以在空白或代碼之后，但是不出現(xiàn)在字符串中。文本字符串中的#字符僅僅表示#。由于代碼中的注釋不會(huì)被 Python 解釋，錄入示例的時(shí)候可以忽略它們。

如下面這個(gè)例子：

# 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."

將 Python 當(dāng)做計(jì)算器使用

我們來嘗試一些簡單的 Python 命令。啟動(dòng)解釋器然后等待主提示符>>>出現(xiàn)。（這不會(huì)花很長時(shí)間。）

數(shù)字

解釋器的表示就像一個(gè)簡單的計(jì)算器：可以向其錄入一些表達(dá)式，它會(huì)給出返回值。表達(dá)式語法很直白：運(yùn)算符+，-，*和/與其它語言一樣（例如： Pascal 或 C）；括號(hào)（()）可用于分組。例如：

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

整數(shù)(如 2、4、20)為int類型，有小數(shù)點(diǎn)部分(如 5.0、1.6)則為float型。稍后我們將在后面的教程中看到更多的關(guān)于數(shù)字類型的教程。

除法(/)總是返回一個(gè)float類型。想要得到的一個(gè)整數(shù)(丟棄任何小數(shù)的結(jié)果)你可以使用//運(yùn)算符；要計(jì)算余數(shù)你可以使用%。

>>> 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 中，可以使用**運(yùn)算符來計(jì)算腳注[1]。

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

等號(hào)(=)用于給一個(gè)變量賦值。后來,沒有結(jié)果顯示在下一個(gè)交互式提示符之前。

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

如果一個(gè)變量沒有定義(或分配一個(gè)初值),如果使用它會(huì)報(bào)錯(cuò)。

>>> n  # try to access an undefined variable
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

Python 完全支持浮點(diǎn)數(shù)，不同類型的操作數(shù)混在一起時(shí)，操作符會(huì)把整型轉(zhuǎn)化為浮點(diǎn)數(shù)。

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

在交互模式下，最后打印表達(dá)式賦給變量_。這意味著當(dāng)你使用 Python 作為一個(gè)計(jì)算器，它是 繼續(xù)計(jì)算比較容易，例如：

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

此變量對(duì)于用戶是只讀的。不要嘗試給它賦值 —— 你只會(huì)創(chuàng)建一個(gè)獨(dú)立的同名局部變量，它屏蔽了系統(tǒng)內(nèi)置變量的魔術(shù)效果。

除了int 和 float，Python 支持其他類型的數(shù)字，如小數(shù)和分?jǐn)?shù)。Python 還內(nèi)置了用于復(fù)數(shù)的支持，并使用J或j的后綴來表示虛部（如3+5J）。

字符串

除了數(shù)值，Python 也提供了可以通過幾種不同方式傳遞的字符串。它們可以用單引號(hào)或雙引號(hào)標(biāo)識(shí)。他們可以用單引號(hào)（“……”）或雙引號(hào)（“……”）可以得出相同的結(jié)果腳注 [2]。也可以使用 \ 進(jìn)行轉(zhuǎn)義。

>>> '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.' 

在 Python 交互式解釋器中，字符串的輸出結(jié)果用引號(hào)括起來，特殊字符則通過 \ 反斜杠進(jìn)行轉(zhuǎn)義。我們可能發(fā)現(xiàn)了它們可能和輸入有點(diǎn)不一樣(括起來的引號(hào)變了)，但是它們是相等的。如果字符串包含單引號(hào)并且不包含雙引號(hào)，則輸出結(jié)果用雙引號(hào)括起來，否則用單引號(hào)括起來。 print() 函數(shù)輸出字符串更具有可讀性，它不會(huì)將輸出結(jié)果用引號(hào)括起來。

>>> '"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. 

如果你不想使用反斜杠 \ 來轉(zhuǎn)譯特殊字符，那么你可以在原始字符串前加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

字符串常量可用跨越多行，其中一種使用方式是用三重引號(hào)： """ ... """ 或者 ''' ... '''。如果在第一個(gè)三引號(hào)后面不加反斜杠 \，則字符串之前會(huì)自動(dòng)加一空行?？梢杂梅葱备?\ 阻止這種行為。如下面的列子：

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

下面是輸出結(jié)果(注意，開始一行是沒有空行的)。

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

字符串可以通過+運(yùn)算符進(jìn)行鏈接，或者通過*進(jìn)行重復(fù)鏈接。

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

兩個(gè)或多個(gè)（即那些被引號(hào)引起來的部分）字符串常量則會(huì)自動(dòng)進(jìn)行連接運(yùn)算。

>>> 'Py' 'thon'
'Python'

上面的操作僅適用于兩個(gè)字符串常量，變量和常量是不可以連接的。

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

如果你想將變量和常量連接，則使用 + 運(yùn)算符。

>>> 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.'

字符串可以使用索引操作，第一個(gè)字符的索引為 0，Python 中沒有單獨(dú)的字符類型，一個(gè)字符也字符串。

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

索引可以使負(fù)數(shù)，表示從字符串的右邊開始進(jìn)行索引。

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

注意，因?yàn)?-0 和 0 是一致的，因此負(fù)數(shù)索引是從 -1 開始。 除了索引之外，字符串還支持切片操作。索引用來表示單個(gè)字符，切片允許你包含子串。

>>> 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[i:] 總是等于 s。

>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'

索引切片可以使用默認(rèn)值，切片時(shí)，忽略第一個(gè)索引的話，默認(rèn)為 0，忽略第二個(gè)索引，默認(rèn)為字符串的長度。

>>> 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'

有一個(gè)辦法可以記住切片的工作方式：切片時(shí)的索引是在兩個(gè)字符之間 。左邊第一個(gè)字符的索引為 0，而長度為 n 的字符串其最后一個(gè)字符的右界索引為 n 。例如

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

文本中的第一行數(shù)字給出字符串中的索引點(diǎn) 0...6 。第二行給出相應(yīng)的負(fù)索引。 切片是從 i 到 j 兩個(gè)數(shù)值標(biāo)示的邊界之間的所有字符。

對(duì)于非負(fù)索引，如果上下都在邊界內(nèi)，切片長度就是索引值的差。例如，word[1:3] 是 2 。

嘗試使用一個(gè)索引過大就會(huì)出現(xiàn)錯(cuò)誤。

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

然而，當(dāng)索引越界，切片操作可以很優(yōu)雅的進(jìn)行處理。

>>> word[4:42]
'on'
>>> word[42:]
'' 

Python 字符串是不能改變的—它是不可變量，因此，給某個(gè)索引位置進(jìn)行賦值是不行的。

>>> word[0] = 'J'
  ...
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
  ...
TypeError: 'str' object does not support item assignment

如果你需要一個(gè)不同的字符串，你應(yīng)該創(chuàng)建一個(gè)新的。

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

內(nèi)置函數(shù) len() 返回一個(gè)字符串的長度。

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

列表

Python 有幾個(gè)復(fù)合數(shù)據(jù)類型，用于表示其它的值。最通用的是list(列表) ，它可以寫作中括號(hào)之間的一列逗號(hào)分隔的值。列表的元素不必是同一類型。

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

就像字符串索引（和所有其他內(nèi)置的序列類型），列表可以被切片和連接。

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

所有的切片操作都會(huì)返回新的列表，包含求得的元素。這意味著以下的切片操作返回列表a的一個(gè)淺拷貝的副本。

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

列表還支持級(jí)聯(lián)操作。

>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

不像不可變的字符串，列表是可變類型，允許修改列表的內(nèi)容。

>>> 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] 

利用append()方法，你還可以在列表末尾添加新的項(xiàng)目。（我們將在后面看到更多的方法）

>>> 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]

也可以對(duì)切片賦值，此操作可以改變列表的尺寸，或清空它。

>>> 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
[]

內(nèi)置函數(shù)len()也適用于列表。

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

它可以嵌套列表（創(chuàng)建包含其他列表的列表），例如：

>>> 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'

編程的第一步

當(dāng)然，我們可以使用 Python 完成比二加二更復(fù)雜的任務(wù)。例如，我們可以寫一個(gè)生成?菲波那契?子序列的程序，如下所示:

>>> # 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

這個(gè)例子介紹了幾個(gè)新功能。

• 第一行包括了一個(gè)?多重賦值：變量a和b同時(shí)獲得了新的值 0 和 1 最后一行又使用了一次。在這個(gè)演示中，變量賦值前，右邊首先完成計(jì)算。右邊的表達(dá)式從左到右計(jì)算。
• 條件（這里是b?<?10）為 true 時(shí)，while循環(huán)執(zhí)行。在 Python 中，類似于 C ，任何非零整數(shù)都是 true；0 是 false 條件也可以是字符串或列表，實(shí)際上可以是任何序列，所有長度不為零的是 true ，空序列是 false。示例中的測(cè)試是一個(gè)簡單的比較。標(biāo)準(zhǔn)比較操作符與 C 相同：<（小于），>（大于），==（等于），<=（小于等于），>=（大于等于）和!=（不等于）。
• 循環(huán)體是縮進(jìn)的：縮進(jìn)是 Python 是 Python 組織語句的方法。 Python 不提供集成的行編輯功能，所以你要為每一個(gè)縮進(jìn)行輸入 TAB或空格。實(shí)踐中建議你找個(gè)文本編輯來錄入復(fù)雜的 Python 程序，大多數(shù)文本編輯器提供自動(dòng)縮進(jìn)。交互式錄入復(fù)合語句時(shí)，必須在最后輸入一個(gè)空行來標(biāo)識(shí)結(jié)束（因?yàn)榻忉屍鳑]辦法猜測(cè)你輸入的哪一行是最后一行），需要 注意的是同一個(gè)語句塊中的語句塊必須縮進(jìn)同樣數(shù)量的空白。
• 關(guān)鍵字print語句輸出給定表達(dá)式的值。它控制多個(gè)表達(dá)式和字符串輸出為你想要字符串（就像我們?cè)谇懊嬗?jì)算器的例子中那樣）。字符串打印時(shí)不用引號(hào)包圍，每兩個(gè)子項(xiàng)之間插入空間，所以你可以把格式弄得很漂亮，像這樣:

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

關(guān)鍵字參數(shù)端可用來避免輸出后換行，或者用不同的字符串結(jié)束輸出。

>>> 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,

腳注

[1] 由于**的優(yōu)先級(jí)高于- ，-3**2 將被解釋為 -（3**2），從而導(dǎo)致結(jié)果為 -9。為了避免這種情況，并得到 9，你可以使用（-3）** 2

[2] 與其他語言不同,特殊字符如\n，具有相同含義的兩個(gè)單引號(hào)('…')和雙引號(hào)(“…”)。兩者之間唯一的區(qū)別是在單引號(hào)不需要轉(zhuǎn)碼建 ”(但你必須有轉(zhuǎn)碼鍵\')，反之亦然。