3. 一個非正式的 Python 簡介

在下面的例子中，輸入與輸出的區別在於有無提示字元（prompt，>>> 和 ...）：如果要重做範例，你必須在提示字元出現的時候，輸入提示字元後方的所有內容；那些非提示字元開始的文字行是直譯器的輸出。注意到在範例中，若出現單行只有次提示字元時，代表該行你必須直接換行；這被使用在多行指令結束輸入時。

在範例區域中，你可以點擊右上角的 >>> 來切換是否要顯示提示字元及輸出。若你隱藏了範例中的提示字元及輸出，那麼你就能夠輕易地複製輸入的內容，並貼上到你的直譯器中。

在本手冊中的許多範例中，即便他們為互動式地輸入，仍然包含註解。Python 中的註解 (comments) 由 hash 字元 # 開始一直到該行結束。註解可以從該行之首、空白後、或程式碼之後開始，但不會出現在字串文本 (string literal) 之中。hash 字元在字串文本之中時仍視為一 hash 字元。因為註解只是用來說明程式而不會被 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. 數字 (Number)

直譯器如同一台簡單的計算機：你可以輸入一個 expression（運算式），它會寫出該式的值。Expression 的語法可以使用：運算子 +、-、* 和 / 可以用來執行運算；括號 () 可以用來分群。例如：

>>> 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）為 float 型態。我們將在之後的教學中看到更多數字相關的型態。

除法 (/) 永遠回傳一個 float。如果要做 floor division 並拿到整數的結果，你可以使用 // 運算子；計算餘數可以使用 %：

>>> 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  # floored quotient * divisor + remainder
17

在 Python 中，計算冪次 (powers) 可以使用 ** 運算子 [1]：

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

等於符號 (=) 可以用於為變數賦值。賦值完之後，在下個指示字元前並不會顯示任何結果：

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

如果一個變數未被「定義 (defined)」（即變數未被賦值），試著使用它時會出現一個錯誤：

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

浮點數的運算有完善的支援，運算子 (operator) 遇上混合的運算元 (operand) 時會把整數的運算元轉換為浮點數：

>>> 4 * 3.75 - 1
14.0

在互動式模式中，最後一個印出的運算式的結果會被指派至變數 _ 中。這表示當你把 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 亦內建支援複數 (complex numbers)，並使用 j 和 J 後綴來指定虛數的部份（即 3+5j）。

3.1.2. 文字

Python 可以操作文本（由 str 型別表示，即所謂的「字串 (strings)」）和數字。這包括字元 "!"、單詞 "rabbit"、名稱 "Paris"、句子 "Got your back." 等等。"Yay! :)"。它們可以用單引號 ('...') 或雙引號 ("...") 括起來，會具有相同的結果 [2]。

>>> 'spam eggs'  # single quotes
'spam eggs'
>>> "Paris rabbit got your back :)! Yay!"  # double quotes
'Paris rabbit got your back :)! Yay!'
>>> '1975'  # digits and numerals enclosed in quotes are also strings
'1975'

要引用引文，我們需要在其前面加上 \ 來「跳脫」它。或者我們也可以使用其他種類的引號：

>>> 'doesn\'t'  # use \' to escape the single quote...
"doesn't"
>>> "doesn't"  # ...or use double quotes instead
"doesn't"
>>> '"Yes," they said.'
'"Yes," they said.'
>>> "\"Yes,\" they said."
'"Yes," they said.'
>>> '"Isn\'t," they said.'
'"Isn\'t," they said.'

在 Python shell 中，字串定義和輸出字串可能看起來不同。print() 函式透過省略引號並印出跳脫字元和特殊字元來生成更具可讀性的輸出：

>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s  # without print(), special characters are included in the string
'First line.\nSecond line.'
>>> print(s)  # with print(), special characters are interpreted, so \n produces new line
First line.
Second line.

如果你不希望字元前出現 \ 就被當成特殊字元時，可以改使用 raw string，在第一個包圍引號前加上 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

原始字串有一個微妙的地方：原始字串可能不會以奇數個 \ 字元結尾；請參閱常見問答集來了解更多資訊和解決方法。

String literals can span multiple lines. One way is using triple-quotes: """...""" or '''...'''. End of lines are automatically included in the string, but it's possible to prevent this by adding a \ at the end of the line. In the following example, the initial newline is not included:

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

>>>

字串可以使用 + 運算子連接 (concatenate)，並用 * 重覆該字串的內容：

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

兩個以上相鄰的字串文本（string literal，即被引號包圍的字串）會被自動連接起來：

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

當你想要分段一個非常長的字串時，兩相鄰字串值自動連接的特性十分有用：

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

但這特性只限於兩相鄰的字串值間，而非兩相鄰變數或表達式：

>>> prefix = 'Py'
>>> prefix 'thon'  # can't concatenate a variable and a string literal
  File "<stdin>", line 1
    prefix 'thon'
           ^^^^^^
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
  File "<stdin>", line 1
    ('un' * 3) 'ium'
               ^^^^^
SyntaxError: invalid syntax

如果要連接變數們或一個變數與一個字串值，使用 +：

>>> prefix + 'thon'
'Python'

字串可以被「索引 indexed」(下標，即 subscripted)，第一個字元的索引值為 0。沒有獨立表示字元的型別；一個字元就是一個大小為 1 的字串：

>>> 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 開始。

除了索引外，字串亦支援「切片 slicing」。索引用來拿到單獨的字元，而切片則可以讓你拿到一個子字串 (substring)：

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

切片索引 (slice indices) 有很常用的預設值，省略起點索引值時預設為 0，而省略第二個索引值時預設整個字串被包含在 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'

注意到起點永遠被包含，而結尾永遠不被包含。這確保了 s[:i] + s[i:] 永遠等於 s：

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

這裡有個簡單記住 slice 是如何運作的方式。想像 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 的長度等於其索引值之差，如果索引值落在字串邊界內。例如，word[1:3] 的長度是 2。

嘗試使用一個過大的索引值會造成錯誤：

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

然而，超出範圍的索引值在 slice 中會被妥善的處理：

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

Python 字串無法被改變 --- 它們是 immutable。因此，嘗試對字串中某個索引位置賦值會產生錯誤：

>>> word[0] = 'J'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

如果你需要一個不一樣的字串，你必須建立一個新的：

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

內建的函式 len() 回傳一個字串的長度：

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

也參考

Text Sequence Type --- str

字串是 sequence 型別的範例之一，並支援該型別常用的操作。

String Methods

字串支援非常多種基本轉換和搜尋的 method（方法）。

f-string（f 字串）

包含有運算式的字串文本。

格式化文字語法

關於透過 str.format() 字串格式化 (string formatting) 的資訊。

printf-style String Formatting

在字串為 % 運算子的左運算元時，將觸發舊的字串格式化操作，更多的細節在本連結中介紹。

3.1.3. List（串列）

Python 理解數種複合型資料型別，用來組合不同的數值。當中最多樣變化的型別為 list，可以寫成一系列以逗號分隔的數值（稱之元素，即 item），包含在方括號之中。List 可以包合不同型別的元素，但通常這些元素會有相同的型別：

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

如同字串（以及其他內建的 sequence 型別），list 可以被索引和切片 (slice)：

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

List 對支援如接合 (concatenation) 等操作：

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

不同於字串是 immutable，list 是 mutable 型別，即改變 list 的內容是可能的：

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

你也可以在 list 的最後加入新元素，透過使用 list.append() 方法 (method)（我們稍後會看到更多方法的說明）：

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

Python 中的簡單賦值永遠不會複製資料。當你將 list 指派給變數時，該變數會參照現有 list。任何透過一個變數對 list 所做的更改都將能夠透過參照該變數的所有其他變數看到。

>>> rgb = ["Red", "Green", "Blue"]
>>> rgba = rgb
>>> id(rgb) == id(rgba)  # they reference the same object
True
>>> rgba.append("Alph")
>>> rgb
["Red", "Green", "Blue", "Alph"]

所有切片操作都會回傳一個新的 list ，包含要求的元素。這意謂著以下這個切片回傳了原本 list 的淺複製：

>>> correct_rgba = rgba[:]
>>> correct_rgba[-1] = "Alpha"
>>> correct_rgba
["Red", "Green", "Blue", "Alpha"]
>>> rgba
["Red", "Green", "Blue", "Alph"]

也可以對 slice 賦值，這能改變 list 的大小，甚至是清空一個 list：

>>> 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() 亦可以作用在 list 上：

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

也可以嵌套多層 list （建立 list 包含其他 list），例如：

>>> 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 來處理比 2 加 2 更複雜的工作。例如，我們可以印出費氏數列的首幾項序列：

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

這例子引入了許多新的特性。

  • 第一行出現了多重賦值：變數 a 與 b 同時得到了新的值 0 與 1。在最後一行同樣的賦值再被使用了一次，示範了等號的右項運算 (expression) 會先被計算 (evaluate)，賦值再發生。右項的運算式由左至右依序被計算。

  • while 迴圈只要它的條件為真（此範例：a < 10），將會一直重覆執行。在 Python 中如同 C 語言，任何非零的整數值為真 (true)；零為假 (false)。條件可以是字串、list、甚至是任何序列型別；任何非零長度的序列為真，空的序列即為假。本例子使用的條件是個簡單的比較。標準的比較運算子 (comparison operators) 使用如同 C 語言一樣的符號：<（小於）、>（大於）、==（等於）、<=（小於等於）、>=（大於等於）以及 !=（不等於）。

  • 迴圈的主體會縮排：縮排在 Python 中用來關連一群陳述式。在互動式提示字元中，你必須在迴圈內的每一行一開始鍵入 tab 或者（數個）空白來維持縮排。實務上，你會先在文字編輯器中準備好比較複雜的輸入；多數編輯器都有自動縮排的功能。當一個複合陳述式以互動地方式輸入，必須在結束時多加一行空行來代表結束（因為語法剖析器無法判斷你何時輸入複合陳述的最後一行）。注意在一個縮排段落內的縮排方式與數量必須維持一致。

  • print() 函式印出它接收到引數（們）的值。不同於先前僅我們寫下想要的運算（像是先前的計算機範例），它可以處理複數個引數、浮點數數值和字串。印出的字串將不帶有引號，並且不同項目間會插入一個空白，因此可以讓你容易格式化輸出，例如：

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

    關鍵字引數 end 可以被用來避免額外的換行符加入到輸出中，或者以不同的字串結束輸出：

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

註解