1.SyntaxError: EOL while scanning string literal
（忘記 了字符串末尾的單引號）
2.TypeError: ‘int’ object is not iterable
原因：不能直接用int進行迭代，而必須加個range.
for index in range(len(numbers)):正確
for i in len(index):錯誤
3.KeyError: ‘color’
嘗試訪問字典中不存在的鍵，將導致 KeyError 出錯信息。這很像列表的“越界” IndexError 出錯信息。
代碼必須顯式地將整數轉換為字符串，因為 Python 不
能自動完成轉換。
用於兩個整型或浮點型值時，操作符表示乘法。但操作符用於一個字符串 值和一個整型值時，它變成了“字符串復制”操作符。在交互式環境中輸入一個字 符串乘一個數字，看看效果。
>>> ‘Alice’ * 5
‘AliceAliceAliceAliceAlice’
*操作符只能用於兩個數字（作為乘法），或一個字符串和一個整型（作為字符 串復制操作符）
print只輸出str類型，要進行格式轉換
1．只能是一個詞。
2．只能包含字母、數字和下劃線。
3．不能以數字開頭。
變量名使用了駝峰形式
#標志之後的所有文本都是注釋。
input 輸出的str
len輸出的是整數
int對str類型報錯，比如 **int(’7.7‘)**錯誤， **int(7.7)**正確
round() 方法返回浮點數x的四捨五入值。
雖然數字的字符串值被認為與整型值和浮點型值完全不同，但整型值可以與浮點值相等。
因為字符串是文本，而整型值和浮點型都是數字。
表達式和語句的區別
一個表達式會產生一個值,它可以放在任何需要一個值的地方
語句可以理解成一個行為.循環語句和if語句就是典型的語句.一個程序是由一系列語句組成的.
表達式
是由運算符和運算對象組成的,單獨的一個運算對象(常量/變量)也可以叫做表達式，這是最簡單的表達式.
布爾值 True 和 False
不像字符串，兩邊沒有引號，它們總是以大寫字母 T 或 F 開頭，後面的字母小寫
==
等於
!=
不等於
<
小於
>
大於
<=
小於等於
>=
大於等於
==和!=操作符實際上可以用於所有數據類型的值
請注意，整型或浮點型的值永遠不會與字符串相等。表達式 42 == '42’求值為 False 是因為，Python 認為整數 42 與字符串’42’不同。
另一方面，<、>、<=和>=操作符僅用於整型和浮點型值
3 個布爾操作符（and、or 和 not）用於比較布爾值。
not 操作符求 值為相反的布爾值
not True=false
計算機將先求值左邊的表達式，然後再求值右邊的表達式。知道兩個布爾值後， 它又將整個表達式再求值為一個布爾值。
和算術操作符一樣，布爾操作符也有操作順序。在所有算術和比較操作符求值 後，Python 先求值 not 操作符，然後是 and 操作符，然後是 or 操作符。
條件總是求值為一個布爾值，True 或 False。控制 流語句根據條件是 True 還是 False，來決定做什麼。幾乎所有的控制流語句都使用條件。
一些代碼行可以作為一組，放在“代碼塊”中。可以根據代碼行的縮進，知道 代碼塊的開始和結束。代碼塊有 3 條規則。
1．縮進增加時，代碼塊開始。
2．代碼塊可以包含其他代碼塊。
3．縮進減少為零，或減少為外面包圍代碼塊的縮進，代碼塊就結束了。
最常見的控制流語句是 if 語句。if 語句的子句（也就是緊跟 if 語句的語句塊）， 將在語句的條件為 True 時執行。如果條件為 False，子句將跳過。 在英文中，if 語句念起來可能是：“如果條件為真，執行子句中的代碼。”在 Python
中，if 語句包含以下部分：
if 關鍵字；
條件（即求值為 True 或 False 的表達式）；
冒號；
在下一行開始，縮進的代碼塊（稱為 if 子句）。
if name == 'Alice':
print('Hi, Alice.')
if 子句後面有時候也可以跟著 else 語句。只有 if 語句的條件為 False 時，else 子句才會執行。在英語中，else 語句讀起來可能是：“如果條件為真，執行這段 代碼。否則，執行那段代碼”。else 語句不包含條件，在代碼中，else 語句中包 含下面部分：
else 關鍵字；
冒號；
在下一行開始，縮進的代碼塊（稱為 else 子句）。
if name == 'Alice':
print('Hi, Alice.')
else:
print('Hello, stranger.')
雖然只有 if 或 else 子句會被執行，但有時候可能你希望，“許多”可能的子句
中有一個被執行。elif 語句是“否則如果”，總是跟在 if 或另一條 elif 語句後面。它
提供了另一個條件，僅在前面的條件為 False 時才檢查該條件。在代碼中，elif 語句
總是包含以下部分：
elif 關鍵字；
條件（即求值為 True 或 False 的表達式）；
冒號；
在下一行開始，縮進的代碼塊（稱為 elif 子句）。
if name == 'Alice':
print('Hi, Alice.')
elif age < 12:
print('You are not Alice, kiddo.')
注:最多只有一個子句會執行，對於 elif 語句，次序是很重要的。
print("input your name")
name=input()
print('input your age')
age=int(input())
if name=='wpc':
print('hi wpc')
elif age<20:
print('you are not wpc,boy')
elif age >100:
print('you are not wpc,grandfather')
elif age >3000:
print('he is not dead')
利用 while 語句，可以讓一個代碼塊一遍又一遍的執行。只要 while 語句的條件為 True，while 子句中的代碼就會執行。在代碼中，while 語句總是包含下面幾
部分：
關鍵字；
條件（求值為 True 或 False 的表達式）；
冒號；
從新行開始，縮進的代碼塊（稱為 while 子句）。
spam = 0
while spam < 5:
print('Hello, world.')
spam = spam + 1
如果執行遇到 break 語句，就會馬上退出 while 循環子句。在代碼中，break 語句僅包含 break 關鍵字。
while True:
print('Please type your name.')
name = input()
if name == 'your name':
break
print('Thank you!')
continue 語句用於循環內部。如果程序執行遇到 continue語句，就會馬上跳回到循環開始處，重新對循環條件求值（這也是執行到達循環末尾時發生的事情）
如果運行這個程序，它將永遠在屏幕上打印 Hello world！因為 while 語句的條件總是 True。在 IDLE 的交互式環境窗口中，只有兩種辦法停止這個程序：按下 Ctrl-C 或從菜單中選擇 ShellRestart Shell。如果你希望馬上停止程序，即使它不是陷在一個無限循環中，Ctrl-C 也是很方便的
在用於條件時，0、0.0 和’ '（空字符串）被認為是 False，其他值被認為是 True。
在代碼中，for 語句看起來像 for i in range(5):這樣，總是包含以下部分：
for 關鍵字；
一個變量名；
in 關鍵字；
調用 range()方法，最多傳入 3 個參數；
冒號；
從下一行開始，縮退的代碼塊（稱為 for 子句）。
print('My name is')
for i in range(5):
print('Jimmy Five Times (' + str(i) + ')')
range左閉右開,從0開始
實際上可以用 while 循環來做和 for 循環同樣的事，for 循環只是更簡潔。
某些函數可以用多個參數調用，參數之間用逗號分開，range()就是其中之一。
這讓你能夠改變傳遞給 range()的整數，實現各種整數序列，包括從 0 以外的值開始。
for i in range(12, 16):
print(i)
12
13
14
15
# 結果
range()函數也可以有第三個參數。前兩個參數分別是起始值和終止值，第三個參數是“步長”。步長是每次迭代後循環變量增加的值。
調用 range(0, 10, 2)將從 0 數到 8，間隔為 2。
0
2
4
6
8
可以用
負數作為步長參數，讓循環計數逐漸減少，而不是增加。
在開始使用一個模塊中的函數之前，必須用 import 語句導入該模塊。在代碼中，
import 語句包含以下部分：
import 關鍵字；
模塊的名稱；
可選的更多模塊名稱，之間用逗號隔開。
import random, sys, os, math
import random
for i in range(5):
print(random.randint(1, 10))
random.randint()函數調用求值為傳遞給它的兩個整數之間的一個隨機整數。因為 randint()屬於 random 模塊，必須在函數名稱之前先加上 random.，告訴 python 在 random 模塊中尋找這個函數。
import 語句的另一種形式包括 from 關鍵字，之後是模塊名稱，import 關鍵字和 一個星號，例如 from random import *。
使用這種形式的 import 語句，調用 random模塊中的函數時不需要 random.前綴。
但是，使用完整的名稱會讓代碼更可讀，所以最好是使用普通形式的 import 語句。
要介紹的最後一個控制流概念，是如何終止程序。當程序執行到指令的底部時， 總是會終止。但是，通過調用 sys.exit()函數，可以讓程序終止或退出。因為這個函數在 sys 模塊中，所以必須先導入 sys，才能使用它。
import sys
while True:
print('Type exit to exit.')
response = input()
if response == 'exit':
sys.exit()
print('You typed ' + response + '.')
函數的目的:消除重復,將多次執行的代碼放在一起
第一行是 def 語句，它定義了一個名為 hello()的函數。def 語句之後的代碼塊是函數體。這段代碼在函數調用時執行，而不是在函數第一次定義時執行。
def hello(name):
print('Hello ' + name)
hello('Alice')
hello('Bob')
用 def 語句創建函數時，可以用 return 語句指定應該返回什麼值。return 語句包
含以下部分：
return 關鍵字；
函數應該返回的值或表達式。
表達式是值和操作符的組合。函數調用可以用在表達式中，因為它求值為它的返回值。
在 Python 中有一個值稱為 None，它表示沒有值。None 是 NoneType 數據類型的唯一值（其他編程語言可能稱這個值為 null、nil 或 undefined）。就像布爾值 True和 False 一樣，None 必須大寫首字母 N。
所有函數調用都需要求值為一個返回值，那麼 print()就返回 None。print()的返回值為None
大多數參數是由它們在函數調用中的位置來識別的。例如，random.randint(1, 10)與 random.randint(10, 1)不同。函數調用 random.randint(1, 10)將返回 1 到 10 之間的一個隨機整數，因為第一個參數是范圍的下界，第二個參數是范圍的上界（而
random.randint(10, 1)會導致錯誤）。
但是，“關鍵字參數”是由函數調用時加在它們前面的關鍵字來識別的。關鍵 字參數通常用於可選變元。例如，print()函數有可選的變元 end 和 sep，分別指定在 參數末尾打印什麼，以及在參數之間打印什麼來隔開它們
因為 print()函數自動在傳入的字符串末尾添加了換行符。但是，可以設置 end 關鍵字參數，將它變成另一個字符串。例如，
如果程序像這樣：
print(‘Hello’, end=’’)
print(‘World’)
輸出
HelloWorld
如果向 print()傳入多個字符串值，該函數就會自動用一個空格分隔它 們。在交互式環境中輸入以下代碼
print(‘cats’, ‘dogs’, ‘mice’)
cats dogs mice
傳入 sep 關鍵字參數，替換掉默認的分隔字符串。在交互式環境中
輸入以下代碼：
print(‘cats’, ‘dogs’, ‘mice’, sep=’,’)
cats,dogs,mice
在被調用函數內賦值的變元和變量，處於該函數的“局部作用域”。在所有函數之外賦值的變量，屬於“全局作用域”。處於局部作用域的變量，被稱為“局部變量”。處於全局作用域的變量，被稱為“全局變量”。一個變量必是其中一種，不能既是局部的又是全局的。
可以將“作用域”看成是變量的容器。當作用域被銷毀時，所有保存在該作用域內的變量的值就被丟棄了。只有一個全局作用域，它是在程序開始時創建的。如果程序終止，全局作用域就被銷毀，它的所有變量就被丟棄了。否則，下次你運行程序的時候，這些變量就會記住它們上次運行時的值。
一個函數被調用時，就創建了一個局部作用域。在這個函數內賦值的所有變量，存在於該局部作用域內。該函數返回時，這個局部作用域就被銷毀了，這些變量就丟失了。下次調用這個函數，局部變量不會記得該函數上次被調用時它們保存的值。 作用域很重要，理由如下：
全局作用域中的代碼不能使用任何局部變量；
但是，局部作用域可以訪問全局變量；
一個函數的局部作用域中的代碼，不能使用其他局部作用域中的變量。
如果在不同的作用域中，你可以用相同的名字命名不同的變量。
依賴全局變量就是一個壞習慣
def spam():
eggs = 31337
spam()
print(eggs)
#報錯
eggs 變量只屬於 spam()調用所創建的局部作用域。在程序執
行從 spam 返回後，該局部作用域就被銷毀了，不再有名為 eggs 的變量。
def spam():
eggs = 99
bacon()
print(eggs)
def bacon():
ham = 101
eggs = 0
spam()
#輸出為99
要點在於，一個函數中的局部變量完全與其他函數中的局部變量分隔開來。
def spam():
print(eggs)
eggs = 42
spam()
print(eggs)
#打印出42
因為在 spam()函數中，沒有變元名為 eggs，也沒有代碼為 eggs 賦值，所以當 spam()中使用 eggs 時，Python 認為它是對全局變量 eggs 的引用。這就是前面的程序運行時打印出 42 的原因
要想生活簡單，就要避免局部變量與全局變量或其他局部變量同名。但在技術上，在 Python 中讓局部變量和全局變量同名是完全合法的。
def spam():
eggs = 'spam local'
print(eggs) # prints 'spam local'
def bacon():
eggs = 'bacon local'
print(eggs) # prints 'bacon local'
spam()
print(eggs) # prints 'bacon local'
eggs = 'global'
bacon()
print(eggs) # prints 'global'
bacon local
spam local
bacon local
global
當局部域和全局域沖突的時候服從局部域
如果需要在一個函數內修改全局變量，就使用 global 語句。如果在函數的頂部
有 global eggs 這樣的代碼，它就告訴 Python，“在這個函數中，eggs 指的是全局變
量，所以不要用這個名字創建一個局部變量。”
def spam():
global eggs
eggs = 'spam'
eggs = 'global'
spam()
print(eggs)
#輸出spam
因為 eggs 在 spam()的頂部被聲明為 global ，所以當 eggs 被賦值為’spam’時 ，
賦值發生在全局作用域的 spam 上。沒有創建局部 spam 變量。
有 4 條法則，來區分一個變量是處於局部作用域還是全局作用域：
1．如果變量在全局作用域中使用（即在所有函數之外），它就總是全局變量。
2．如果在一個函數中，有針對該變量的 global 語句，它就是全局變量。
3．否則，如果該變量用於函數中的賦值語句，它就是局部變量。
4．但是，如果該變量沒有用在賦值語句中，它就是全局變量。
def spam():
print(eggs) #正常
# eggs = 'spam local'
eggs = 'global'
spam()
def spam():
print(eggs) # ERROR!
eggs = 'spam local'
eggs = 'global'
spam()
#Python 看到 spam()函數中有針對 eggs 的賦值語句，因此認為 eggs 變量是局部變量
在 Python 程序中遇到錯誤，或“異常”，意味著整個程序崩潰。
你不希望這發生在真實世界的程序中。相反，你希望程序能檢測錯誤，處理它們，
然後繼續運行。
def spam(divideBy):
return 42 / divideBy
print(spam(2))
print(spam(12))
print(spam(0))
print(spam(1))
當試圖用一個數除以零時，就會發生 ZeroDivisionError。根據錯誤信息中給出
的行號，我們知道 spam()中的 return 語句導致了一個錯誤。
通常，對於一個函數，你要知道的就是它的輸入值（變元）和輸出值。
你並非總是需要加重自己的負擔，弄清楚函數的代碼實際是怎樣工作的。
如果以這種高層的方式來思考函數，通常大家會說，你將該函數看成是一
個黑盒。 這個思想是現代編程的基礎。
錯誤可以由 try 和 except 語句來處理。那些可能出錯的語句被放在 try 子句中。
如果錯誤發生，程序執行就轉到接下來的 except 子句開始處。
def spam(divideBy):
try:
return 42 / divideBy
except ZeroDivisionError:
print('Error: Invalid argument.')
print(spam(2))
print(spam(12))
print(spam(0))
print(spam(1))
21.0
3.5
Error: Invalid argument.
None
42.0
請注意，在函數調用中的 try 語句塊中，發生的所有錯誤都會被捕捉。請考慮
以下程序，它的做法不一樣，將 spam()調用放在語句塊中：
def spam(divideBy):
return 42 / divideBy
try:
print(spam(2))
print(spam(12))
print(spam(0))
print(spam(1))
except ZeroDivisionError:
print('Error: Invalid argument.')
21.0
3.5
Error: Invalid argument.
print(spam(1))從未被執行是因為，一旦執行跳到 except 子句的代碼，就不會回本文檔由到 try 子句。它會繼續照常向下執行。
# This is a guess the number game.
import random
secretNumber = random.randint(1, 20)
print('I am thinking of a number between 1 and 20.')
# Ask the player to guess 6 times.
for guessesTaken in range(1, 7):#它有了一個秘密數字，並且給玩家 6 次猜測機會
print('Take a guess.')
guess = int(input())
if guess < secretNumber:
print('Your guess is too low.')
elif guess > secretNumber:
print('Your guess is too high.')
else:
break # This condition is the correct guess!
if guess == secretNumber:
print('Good job! You guessed my number in ' + str(guessesTaken) + ' guesses!')
else:
print('Nope. The number I was thinking of was ' + str(secretNumber))
編程題
print('請輸入一個數字吧!!')
input_name=int(input())
def collatz(num):
if num%2 ==0:
return int(num/2)
else:
return int(num*3+1)
if input_name ==1:
print(input_name)
else:
result = collatz(input_name)
print(result)
while 1:
result = collatz(result)
if result == 1:
print(result)
break
else:
print(result)
列表和元組可以包含多個值，這樣編寫程序來處理大量數據就變得更容易。而且，由於列表本身
又可以包含其他列表，所以可以用它們將數據安排成層次結構。
列表用左方括號開始，右方括號結束，即[]。列表中的值也稱為“表項”。表項用逗號分隔（就是說，它們是“逗號分隔的”）。
數據類型可以任意
下標從0開始
如果使用的下標超出了列表中值的個數，Python 將給出 IndexError 出錯信息。
下標只能是整數，不能是浮點值。
雖然下標從 0 開始並向上增長，但也可以用負整數作為下標。整數值−1 指的是列表中的最後一個下標，−2 指的是列表中倒數第二個下標
就像下標可以從列表中取得單個值一樣，“切片”可以從列表中取得多個值，結果是一個新列表。切片輸入在一對方括號中，像下標一樣，但它有兩個冒號分隔的整數。請注意下標和切片的不同
spam[2]是一個列表和下標（一個整數）。
spam[1:4]是一個列表和切片（兩個整數）。
在一個切片中，第一個整數是切片開始處的下標。第二個整數是切片結束處的下標。切片向上增長，直至第二個下標的值，但不包括它。
左閉右開
len()函數將返回傳遞給它的列表中值的個數，就像它能計算字符串中字符的個數一樣。
>>> len(‘hello’)
5
賦值語句左邊是一個變量名，就像 spam = 4。但是，也可以使用列表的下標來改變下標處的值。
+操作符可以連接兩個列表，得到一個新列表，就像它將兩個字符串合並成一個新字符串一樣。*操作符可以用於一個列表和一個整數，實現列表的復制。
>>> [1, 2, 3] + ['A', 'B', 'C']
[1, 2, 3, 'A', 'B', 'C']
>>> ['X', 'Y', 'Z'] * 3
['X', 'Y', 'Z', 'X', 'Y', 'Z', 'X', 'Y', 'Z']
>>> spam = [1, 2, 3]
>>> spam = spam + ['A', 'B', 'C']
>>> spam
[1, 2, 3, 'A', 'B', 'C']
del 語句將刪除列表中下標處的值，表中被刪除值後面的所有值，都將向前移動一個下標。
>>> spam = ['cat', 'bat', 'rat', 'elephant']
>>> del spam[2]
>>> spam
['cat', 'bat', 'elephant']
>>> del spam[2]
>>> spam
['cat', 'bat']
catNames = []
while True:
print('Enter the name of cat ' + str(len(catNames) + 1) +
' (Or enter nothing to stop.):')
name = input()
if name == '':
break
catNames = catNames + [name] # list concatenation
print('The cat names are:')
for name in catNames:
print(' ' + name)
使用列表的好處在於，現在數據放在一個結構中，所以程序能夠更靈活的處理數據，比放在一些重復的變量中方便。
注意:類型要一致
range(4)的返回值是類似列表的值。Python 認為它類似於[0, 1, 2, 3]。
一個常見的 Python 技巧，是在 for 循環中使用 range(len(someList))，迭代列表 的每一個下標。
>>> supplies = ['pens', 'staplers', 'flame-throwers', 'binders']
>>> for i in range(len(supplies)):
print('Index ' + str(i) + ' in supplies is: ' + supplies[i])
Index 0 in supplies is: pens
Index 1 in supplies is: staplers
Index 2 in supplies is: flame-throwers
Index 3 in supplies is: binders
利用 in 和 not in 操作符，可以確定一個值否在列表中。像其他操作符一樣，in和 not in 用在表達式中，連接兩個值：一個要在列表中查找的值，以及待查找的列表。這些表達式將求值為布爾值。
>>> 'howdy' in ['hello', 'hi', 'howdy', 'heyas']
True
>>> spam = ['hello', 'hi', 'howdy', 'heyas']
>>> 'cat' in spam
False
myPets = ['Zophie', 'Pooka', 'Fat-tail']
print('Enter a pet name:')
name = input()
if name not in myPets:
print('I do not have a pet named ' + name)
else:
print(name + ' is my pet.')
多重賦值技巧是一種快捷方式，讓你在一行代碼中，用列表中的值為多個變量賦值。
注:變量的數目和列表的長度必須嚴格相等，否則 Python 將給出 ValueError
>>> cat = ['fat', 'black', 'loud']
>>> size, color, disposition = cat
#等價於
>>> cat = ['fat', 'black', 'loud']
>>> size = cat[0]
>>> color = cat[1]
>>> disposition = cat[2]
+= -= *= /= %=
方法和函數是一回事，只是它是調用在一個值上。每種數據類型都有它自己的一組方法。例如，列表數據類型有一些有用的方法， 用來查找、添加、刪除或操作列表中的值
都要listname.fangfa()
用來查找某個值的下標,如果該值不在列表中，Python 就報 ValueError,如果列表中存在重復的值，就返回它第一次出現的下標。
append()方法調用，將參數添加到列表末尾。insert()方法可以在列表任意下標處插入一個值。insert()方法的第一個參數是新值的下標，第二個參數是要插入的新值。
注:spam = spam.append(‘moose’)和 spam = spam.insert(1, ‘chicken’)書寫出錯誤
append()和 insert()的返回值是 None，列表被當場修改了
spam.append(‘moose’)和 spam.insert(1, ‘chicken’)正確
注:方法屬於單個數據類型。append()和 insert()方法是列表方法，只能在列表上調 用，不能在其他值上調用，例如字符串和整型。
remove()方法傳入一個值，它將從被調用的列表中刪除.試圖刪除列表中不存在的值，將導致 ValueError 錯誤。
如果該值在列表中出現多次，只有第一次出現的值會被刪除。
如果知道想要刪除的值在列表中的下標，del 語句就很好用。
>>> spam = [‘cat’, ‘bat’, ‘rat’, ‘elephant’]
>>> spam.remove(‘bat’)
>>> spam
[‘cat’, ‘rat’, ‘elephant’]
reverse 關鍵字參數為 True，讓 sort()按逆序排序。spam.sort(reverse=True)
注:不能對既有數字又有字符串值的列表排序，因為 Python 不知道如何比較
它們。否則報 TypeError 錯誤.
sort()方法對字符串排序時，使用“ASCII 字符順序”，而不是實際的字典順序。這意味著大寫字母排在小寫字母之前。因此在排序時，小寫的 a 在大寫的Z 之後。
如果需要按照普通的字典順序來排序，就在 sort()方法調用時，將關鍵字參數key 設置為 str.lower
spam.sort(key=str.lower)
在大多數情況下，代碼行的縮進告訴 Python 它屬於哪一個代碼塊。但是，這個規則有幾個例外。例如在源代碼文件中，列表實際上可以跨越幾行。這些行 的縮進並不重要。Python 知道，沒有看到結束方括號，列表就沒有結束。還有print函數
列表並不是唯一表示序列值的數據類型。例如，字符串和列表實際上很相似， 只要你認為字符串是單個文本字符的列表。對列表的許多操作，也可以作用於字符串：按下標取值、切片、用於 for 循環、用於 len()，以及用於 in 和 not in 操作符
但列表和字符串在一個重要的方面是不同的。列表是“可變的”數據類型，它的值可以添加、刪除或改變。但是，字符串是“不可變的”，它不能被更改。嘗試對字符串中的一個字符重新賦值，將導致 TypeError 錯誤。
“改變”一個字符串的正確方式，是使用切片和連接。構造一個“新的”字符串，從老的字符串那裡復制一些部分。
>>> eggs = [1, 2, 3]
>>> eggs = [4, 5, 6]
>>> eggs
[4, 5, 6]
盡管列表值是可變的，這裡 eggs 中的列表值並沒有改變，而是整個新的不同的列表值([4, 5, 6])，覆寫 了老的列表值。
[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-LHjL1V1Z-1595908463702)(C:\Users\wpc\Documents\Markdown文檔\python編程快速上手.assets\1594687941977.png)]
除了兩個方面，“元組”數據類型幾乎與列表數據類型一樣。首先，元組輸入時用圓括號()，而不是用方括號[]。但元組與列表的主要區別還在於，元組像字符串一樣，是不可變的。元組不能讓它們的值被修改、添加或刪除。
>>> eggs = ('hello', 42, 0.5)
>>> eggs[1] = 99
Traceback (most recent call last):
File "<pyshell#5>", line 1, in <module>
eggs[1] = 99
TypeError: 'tuple' object does not support item assignment
如果元組中只有一個值，你可以在括號內該值的後面跟上一個逗號，表明這種 情況。否則，Python 將認為，你只是在一個普通括號內輸入了一個值。逗號告訴 Python，這是一個元組（不像其他編程語言，Python 接受列表或元組中最後表項後 面跟的逗號）
>>> type(('hello',))
<class 'tuple'>
>>> type(('hello'))
<class 'str'>
用元組告訴所有讀代碼的人，你不打算改變這個序列的值。如果需要一個永遠不會改變的值的序列，就使用元組。使用元組而不是列表的第二個好處在於,因為它們是不可變的，它們的內容不會變化，Python 可以實現一些優化，讓使用元組的代碼比使用列表的代碼更快
函數 list()和 tuple()將返回傳遞給它們的值的列表和元組版本。
如果需要元組值的一個可變版本，將元組轉換成列表就很方便。
>>> tuple(['cat', 'dog', 5])
('cat', 'dog', 5)
>>> list(('cat', 'dog', 5))
['cat', 'dog', 5]
>>> list('hello')
['h', 'e', 'l', 'l', 'o']
當你將列表賦給一個變量時，實際上是將列表的“引用” 賦給了該變量。引用是一個值，指向某些數據。列表引用是指向一個列表的值。
>>> **spam = [0, 1, 2, 3, 4, 5]**
>>> **cheese = spam**
>>> **cheese[1] = 'Hello!'**
>>> **spam**
[0, 'Hello!', 2, 3, 4, 5]
>>> **cheese**
[0, 'Hello!', 2, 3, 4, 5]
記住，變量就像包含著值的盒子。因為列表變量實際上沒有包含列表，而是包含了對列表的“引用”（這些引用包含一些 ID 數字，Python 在內部使用這些 ID，但是你可以忽略）。
變量包含對列表值的引用，而不是列表值本身。但對於字符串和整數值，變量 就包含了字符串或整數值。在變量必須保存可變數據類型的值時，例如列表或字典， Python 就使用引用。對於不可變的數據類型的值，例如字符串、整型或元組，Python 變量就保存值本身。 雖然 Python 變量在技術上包含了對列表或字典值的引用，但人們通常隨意地說，該變量包含了列表或字典
要理解參數如何傳遞給函數，引用就特別重要。當函數被調用時，參數的值被復制給變元。對於列表（以及字典），這意味著變元得到的是引用的拷貝。
def eggs(someParameter):
someParameter.append('Hello')
spam = [1, 2, 3]
eggs(spam)
print(spam)
請注意，當 eggs()被調用時，沒有使用返回值來為 spam 賦新值。相反，它直接當場修改了該列表。
[1, 2, 3, ‘Hello’]
盡管 spam 和 someParameter 包含了不同的引用，但它們都指向相同的列表。這就是為什麼函數內的 append(‘Hello’)方法調用在函數調用返回後，仍然會對該列表產生影響。
在處理列表和字典時，盡管傳遞引用常常是最方便的方法，但如果函數修改了傳入的列表或字典，你可能不希望這些變動影響原來的列表或字典。要做到這一點，Python 提供了名為 copy 的模塊，其中包含 copy()和 deepcopy()函數。
copy.copy()，可以用來復制列表或字典這樣的可變值，而不只是復制引用。
[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-K9wY1Uj3-1595908463711)(C:\Users\wpc\Documents\Markdown文檔\python編程快速上手.assets\1594905544970.png)]
copy.deepcopy()函數使用條件:復制的列表中包含了列表,deepcopy()函數將同時復制它們內部的列表。
import copy
origin = [1, 2, [3, 4]]
#origin 裡邊有三個元素：1， 2，[3, 4]
cop1 = copy.copy(origin)
cop2 = copy.deepcopy(origin)
# cop1是否與cop2內容相同
print(cop1 == cop2)
#True
# cop1是否與cop2為同一個引用
print(cop1 is cop2)
#False
#cop1 和 cop2 看上去相同，但已不再是同一個object
origin[2][0] = "hey!"
origin[1]='wpc'
print(origin)
print(cop1)
print(cop2)
#把origin內的子list [3, 4] 改掉了一個元素，觀察 cop1 和 cop2
列表是可變的，這意味著它們的內容可以改變。元組和字符串雖然在某些方面像列表，卻是不可變的，不能被修改。包含一個元組或字符串的變量，可以被一個新的元組或字符串覆寫，但這和現場修改原來的值不是一回事，不像 append()和remove()方法在列表上的效果。
變量不直接保存列表值，它們保存對列表的“引用”。在復制變量或將列表作為函數調用的參數時，這一點很重要。因為被復制的只是列表引用，所以要注意，對該列表的所有改動都可能影響到程序中的其他變量。如果需要對一個變量中的列表修改，同時不修改原來的列表，就可以用 copy()或 deepcopy()。
copy.copy() 函數將淺拷貝列表，而 copy.deepcopy() 函數將深拷貝列表。也就是說，只有 copy.deepcopy() 會復制列表內的所有列表。
關鍵字end可以用於將結果輸出到同一行，或者在輸出的末尾添加不同的字符
end作用就是在b後面加個什麼東西
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.假定有下面這樣的列表：
spam = [‘apples’, ‘bananas’, ‘tofu’, ‘cats’]
編寫一個函數，它以一個列表值作為參數，返回一個字符串。該字符串包含所
有表項，表項之間以逗號和空格分隔，並在最後一個表項之前插入 and。例如，將
前面的 spam 列表傳遞給函數，將返回’apples, bananas, tofu, and cats’。但你的函數應
該能夠處理傳遞給它的任何列表。
def charu(LIST):
length = len(LIST)
count = 0
zifuchuan=''
for inx, val in enumerate(LIST):
if inx == length - 1:
zifuchuan = zifuchuan + 'and ' + val
return zifuchuan
zifuchuan=zifuchuan+val+','
spam = ['apples','bananas','tofu','cats','wpc']
print(charu(spam))
[外鏈圖片轉存失敗,源站可能有防盜鏈機制,建議將圖片保存下來直接上傳(img-3dIbo3B7-1595908463719)(C:\Users\wpc\Documents\Markdown文檔\python編程快速上手.assets\1594993782606.png)]
def PRINT(LIST):
Row=len(LIST)
Colum=len(LIST[1])
print('該list行為' + str(Row))
print('該list列為' + str(Colum))
for i in range(Colum) :
for j in range(Row):
print(LIST[j][i],end='')
if j>=Row-1 :
print('')
grid = [['.', '.', '.', '.', '.', '.'],
['.', 'O', 'O', '.', '.', '.'],
['O', 'O', 'O', 'O', '.', '.'],
['O', 'O', 'O', 'O', 'O', '.'],
['.', 'O', 'O', 'O', 'O', 'O'],
['O', 'O', 'O', 'O', 'O', '.'],
['O', 'O', 'O', 'O', '.', '.'],
['.', 'O', 'O', '.', '.', '.'],
['.', '.', '.', '.', '.', '.']]
PRINT(grid)
像列表一樣，“字典”是許多值的集合。但不像列表的下標，字典的索引可以
使用許多不同數據類型，不只是整數。字典的索引被稱為“鍵”，鍵及其關聯的值
稱為“鍵-值”對。在代碼中，字典輸入時帶花括號{}。
myCat = {‘size’: ‘fat’, ‘color’: ‘gray’, ‘disposition’: ‘loud’}
可以通過它們的鍵訪問這些值
>>> myCat[‘size’]
‘fat’
>>> 'My cat has ’ + myCat[‘color’] + ’ fur.'
‘My cat has gray fur.’
字典仍然可以用整數值作為鍵，就像列表使用整數值作為下標一樣，但它們不
必從 0 開始，可以是任何數字。
>>> spam = {12345: ‘Luggage Combination’, 42: ‘The Answer’}
不像列表，字典中的表項是不排序的。名為 spam 的列表中，第一個表項是 spam[0]。但字典中沒有“第一個”表項。雖然確定兩個列表是否相同時，表項的順序很重要,但在字典中，鍵-值對輸入的順序並不重要,因為字典是不排序的，所以不能像列表那樣切片。
>>> spam = [‘cats’, ‘dogs’, ‘moose’]
>>> bacon = [‘dogs’, ‘moose’, ‘cats’]
>>> spam == bacon
False
>>> eggs = {‘name’: ‘Zophie’, ‘species’: ‘cat’, ‘age’: ‘8’}
>>> ham = {‘species’: ‘cat’, ‘age’: ‘8’, ‘name’: ‘Zophie’}
>>> eggs == ham
True
有 3 個字典方法，它們將返回類似列表的值，分別對應於字典的鍵、值和鍵-值對：keys()、values()和 items()。這些方法返回的值不是真正的列表，它們不能被修改，沒有append()方法。但這些數據類型（分別是 dict_keys、dict_values 和 dict_items）可以用於for 循環。
>>> spam = {‘color’: ‘red’, ‘age’: 42}
>>> for v in spam.values():
print(v)
red
42
這裡，for 循環迭代了 spam 字典中的每個值。for 循環也可以迭代每個鍵，或者鍵-值對：
>>> for k in spam.keys():
print(k)
color
age
>>> for i in spam.items():
print(i)
(‘color’, ‘red’)
(‘age’, 42)
如果希望通過這些方法得到一個真正的列表，就把類似列表的返回值傳遞給 list函數。
>>> spam = {‘color’: ‘red’, ‘age’: 42}
>>> spam.keys()
dict_keys([‘color’, ‘age’])
>>> list(spam.keys())
[‘color’, ‘age’]
利用多重賦值的技巧，在 for 循環中將鍵和值賦給不同的變量。
>>> spam = {‘color’: ‘red’, ‘age’: 42}
>>> for k, v in spam.items():
print('Key: ’ + k + ’ Value: ’ + str(v))
Key: age Value: 42
Key: color Value: red
in 和 not in 操作符可以檢查值是否存在於列表和字典中。
>>> spam = {‘name’: ‘Zophie’, ‘age’: 7}
>>> ‘name’ in spam.keys()
True
>>> ‘Zophie’ in spam.values()
True
>>> ‘color’ in spam.keys()
False
>>> ‘color’ not in spam.keys()
True
>>> ‘color’ in spam
False
注意：‘color’ in spam 本質上是一個簡寫版本。相當於’color’ in spam.keys()
在訪問一個鍵的值之前，檢查該鍵是否存在於字典中，這很麻煩。好在，字典有一個 get()方法，它有兩個參數：要取得其值的鍵，以及如果該鍵不存在時，返回的備用值。
picnicItems = {‘apples’: 5, ‘cups’: 2}
’I am bringing ’ + str(picnicItems.get(‘eggs’, 0)) + ’ eggs.'
‘I am bringing 0 eggs.’
因為 picnicItems 字典中沒有’egg’鍵，get()方法返回的默認值是 0。不使用 get()，代碼就會產生一個錯誤消息，就像下面的例子：
>>> 'I am bringing ’ + str(picnicItems[‘eggs’]) + ’ eggs.'
Traceback (most recent call last):
File “<pyshell#34>”, line 1, in
‘I am bringing ’ + str(picnicItems[‘eggs’]) + ’ eggs.’
KeyError: ‘eggs’
setdefault()方法提供了一種方式，在一行中完成這件事。傳遞給該方法的第一個參數，是要檢查的鍵。第二個參數，是如果該鍵不存在時要設置的值。如果該鍵確實存在，方法就會返回鍵的值。
>>> spam = {‘name’: ‘Pooka’, ‘age’: 5}
>>> spam.setdefault(‘color’, ‘black’)
‘black’
>>> spam
{‘color’: ‘black’, ‘age’: 5, ‘name’: ‘Pooka’}
>>> spam.setdefault(‘color’, ‘white’)
‘black’
>>> spam
{‘color’: ‘black’, ‘age’: 5, ‘name’: ‘Pooka’}
setdefault()方法是一個很好的快捷方式，可以確保一個鍵存在。
例子
message = 'It was a bright cold day in April, and the clocks were striking thirteen.'
count = {}
for character in message:
count.setdefault(character, 0)
count[character] = count[character] + 1
print(count)
統計詞頻
結果{‘I’: 1, ‘t’: 6, ’ ': 13, ‘w’: 2, ‘a’: 4, ‘s’: 3, ‘b’: 1, ‘r’: 5, ‘i’: 6, ‘g’: 2, ‘h’: 3, ‘c’: 3, ‘o’: 2, ‘l’: 3, ‘d’: 3, ‘y’: 1, ‘n’: 4, ‘A’: 1, ‘p’: 1, ‘,’: 1, ‘e’: 5, ‘k’: 2, ‘.’: 1}
中導入 pprint 模塊，就可以使用 pprint()和 pformat()函數，它們將“漂亮打印”一個字典的字。如果想要字典中表項的顯示比 print()的輸出結果更干淨，這就有用了。
import pprint
message = 'It was a bright cold day in April, and the clocks were striking
thirteen.'
count = {}
for character in message:
count.setdefault(character, 0)
count[character] = count[character] + 1
pprint.pprint(count)
字典本身包含嵌套的列表或字典，pprint.pprint()函數就特別有用。
希望得到漂亮打印的文本作為字符串，而不是顯示在屏幕上，那就調用 pprint.pformat()
pprint.pprint(someDictionaryValue)
print(pprint.pformat(someDictionaryValue))
theBoard = {'top-L': 'O', 'top-M': 'O', 'top-R': 'O', 'mid-L': 'X', 'mid-M':
'X', 'mid-R': ' ', 'low-L': ' ', 'low-M': ' ', 'low-R': 'X'}
def printBoard(board):
print(board['top-L'] + '|' + board['top-M'] + '|' + board['top-R'])
print('-+-+-')
print(board['mid-L'] + '|' + board['mid-M'] + '|' + board['mid-R'])
print('-+-+-')
print(board['low-L'] + '|' + board['low-M'] + '|' + board['low-R'])
printBoard(theBoard)
對復雜的事物建模時，可能發現字典和列表中需要包含其他字典和列表。列表適用於包
含一組有序的值，字典適合於包含關聯的鍵與值
allGuests = {'Alice': {'apples': 5, 'pretzels': 12},
'Bob': {'ham sandwiches': 3, 'apples': 2},
'Carol': {'cups': 3, 'apple pies': 1}}
def totalBrought(guests, item):
numBrought = 0
for k, v in guests.items():
numBrought = numBrought + v.get(item, 0)
return numBrought
print('Number of things being brought:')
print(' - Apples ' + str(totalBrought(allGuests, 'apples')))
print(' - Cups ' + str(totalBrought(allGuests, 'cups')))
print(' - Cakes ' + str(totalBrought(allGuests, 'cakes')))
print(' - Ham Sandwiches ' + str(totalBrought(allGuests, 'ham sandwiches')))
print(' - Apple Pies ' + str(totalBrought(allGuests, 'apple pies')))
編程任務
def displayInventory(inventory):
print("Inventory:")
item_total = 0
for k, v in inventory.items():
print(str(v) + ' ' + k)
item_total += v
print("Total number of items: " + str(item_total))
def addToInventory(inventory, addedItems):
for i in addedItems:
if i in inventory :
inventory[i]=inventory[i]+1
else:
inventory.setdefault(i, 1)
return inventory
inv = {'gold coin': 42, 'rope': 1}
dragonLoot = ['gold coin', 'dagger', 'gold coin', 'gold coin', 'ruby']
inv = addToInventory(inv, dragonLoot)
displayInventory(inv)
2．{‘foo’: 42}
3．保存在字典中的項是無序的，而列表中的項是有序的。
4．會得到 KeyError 錯誤。
5．沒有區別。in 操作符檢查一個值是不是字典中的一個鍵。
6．‘cat’ in spam 檢查字典中是不是有一個 ‘cat’ 鍵，而’cat’ in spam.values() 檢查是
否有一個值 ‘cat’ 對應於 spam 中的某個鍵。
7．spam.setdefault(‘color’, ‘black’)
8．pprint.pprint()
字符串以單引號開始和結束
字符串可以用雙引號開始和結束，就像用單引號一樣。使用雙引號的一個好處，就是字符串中可以使用單引號字符。
可以在字符串開始的引號之前加上 r，使它成為原始字符串。“原始字符串”完全忽略所有的轉義字符，打印出字符串中所有的倒斜槓。
>>> print(r’That is Carol’s cat.’)
That is Carol’s cat.
在 Python 中，多行字符串的起止是 3 個單引號或 3 個雙引號。“三重引號”之間的所有引號、制表符或換行，都被認為是字符串的一部分。Python 的代碼塊縮進規則不適用於多行字符串。
print('''Dear Alice,
Eve's cat has been arrested for catnapping, cat burglary, and extortion.
Sincerely,
Bob''')
結果:
Dear Alice,
Eve’s cat has been arrested for catnapping, cat burglary, and extortion.
Sincerely,
Bob
Eve’s 中的單引號字符不需要轉義。在原始字符串中，轉義單引號和雙引號是可選的。
雖然井號字符（#）表示這一行是注釋，但多行字符串"""常常用作多行注釋。
"""This is a test Python program.
Written by Al Sweigart [email protected]
This program was designed for Python 3, not Python 2.
"""
>>> spam = 'Hello world!'
>>> spam[0]
'H'
>>> spam[4]
'o'
>>> spam[-1]
'!'
>>> spam[0:5]
'Hello'
>>> spam[:5]
'Hello'
>>> spam[6:]
'world!'
請注意，字符串切片並沒有修改原來的字符串。可以從一個變量中獲取切片，記錄在另一個變量中。
測試第一個字符串（精確匹配，區分大小寫）是否在第二個字符串中。
upper()和 lower()字符串方法返回一個新字符串，其中原字符串的所有字母都被相應地轉換為大寫或小寫。字符串中非字母字符保持不變。
如果需要進行大小寫無關的比較，upper()和 lower()方法就很有用。
print('How are you?')
feeling = input()
if feeling.lower() == 'great':
print('I feel great too.')
else:
print('I hope the rest of your day is good.')
如果字符串至少有一個字母，並且所有字母都是大寫或小寫，isupper()和 islower()方法就會相應地返回布爾值 True。判斷字符串是否都是大寫或者小寫
isalpha()返回 True，如果字符串只包含字母，並且非空；
isalnum()返回 True，如果字符串只包含字母和數字，並且非空；
isdecimal()返回 True，如果字符串只包含數字字符，並且非空；
isspace()返回 True，如果字符串只包含空格、制表符和換行，並且非空；
istitle()返回 True，如果字符串僅包含以大寫字母開頭、後面都是小寫字母的單詞。
如果需要驗證用戶輸入，isX 字符串方法是有用的。
檢查字符串的開始或結束部分是否等於另一個字符串，而不是整個字符串
如果一致則startswith()和 endswith()方法返回 True，如果它們所調用的字符串以該方法傳入
的字符串開始或結束。否則，方法返回 False。
如果有一個字符串列表，需要將它們連接起來，成為一個單獨的字符串，join()方法就很有用。join()方法在一個字符串上調用，參數是一個字符串列表，返回一個字符串。返回的字符串由傳入的列表中每個字符串連接而成。
>>> ', '.join(['cats', 'rats', 'bats'])
'cats, rats, bats'
>>> ' '.join(['My', 'name', 'is', 'Simon'])
'My name is Simon'
>>> 'ABC'.join(['My', 'name', 'is', 'Simon'])
'MyABCnameABCisABCSimon'
要記住，join()方法是針對一個字符串而調用的，並且傳入一個列表值（很容易不小心用其他的方式調用它）。split()方法做的事情正好相反：它針對一個字符串調用，返回一個字符串列表。
>>> 'My name is Simon'.split()
['My', 'name', 'is', 'Simon']
字符串’My name is Simon’按照各種空白字符分割，諸如空格、制表符或換行符。這些空白字符不包含在返回列表的字符串中。也可以向 split()方法傳入一個分割字符串，指定它按照不同的字符串分割。
>>> 'MyABCnameABCisABCSimon'.split('ABC')
['My', 'name', 'is', 'Simon']
>>> 'My name is Simon'.split('m')
['My na', 'e is Si', 'on']
rjust()和 ljust()字符串方法返回調用它們的字符串的填充版本，通過插入空格來對齊文本。這兩個方法的第一個參數是一個整數長度，用於對齊字符串。
>>> 'Hello'.rjust(10)
' Hello'
>>> 'Hello'.rjust(20)
' Hello'
>>> 'Hello World'.rjust(20)
' Hello World'
>>> 'Hello'.ljust(10)
'Hello
rjust()和 ljust()方法的第二個可選參數將指定一個填充字符，取代空格字符。
>>> 'Hello'.rjust(20, '*')
'***************Hello'
>>> 'Hello'.ljust(20, '-')
'Hello---------------'
center()字符串方法與 ljust()與 rjust()類似，但它讓文本居中，而不是左對齊或右對齊。
如果需要打印表格式數據，留出正確的空格，這些方法就特別有用。
def printPicnic(itemsDict, leftWidth, rightWidth):
print('PICNIC ITEMS'.center(leftWidth + rightWidth, '-'))
for k, v in itemsDict.items():
print(k.ljust(leftWidth, '.') + str(v).rjust(rightWidth))
picnicItems = {'sandwiches': 4, 'apples': 12, 'cups': 4, 'cookies': 8000}
printPicnic(picnicItems, 12, 5)
printPicnic(picnicItems, 20, 6)
刪除字符串左邊、右邊或兩邊的空白字符（空格、制表符和換行符）。strip()字符串方法將返回一個新的字符串，它的開頭或末尾都沒有空白字符。 lstrip()和 rstrip()方法將相應刪除左邊或右邊的空白字符。
>>> spam = ' Hello World '
>>> spam.strip()
'Hello World'
>>> spam.lstrip()
'Hello World '
>>> spam.rstrip()
' Hello World'
向 strip()方法傳入參數’ampS’，告訴它在變量中存儲的字符串兩端，刪除出現的 a、m、p 和大寫的 S。傳入 strip()方法的字符串中，字符的順序並不重要：strip(‘ampS’) 做的事情和 strip(‘mapS’)或 strip(‘Spam’)一樣。
>>> spam = 'SpamSpamBaconSpamEggsSpamSpam'
>>> spam.strip('ampS')
'BaconSpamEggs'
pyperclip 模塊有 copy()和 paste()函數，可以向計算機的剪貼板發送文本，或從它接收文本。將程序的輸出發送到剪貼板，使它很容易粘貼到郵件、文字處理程序或其他軟件中。pyperclip 模塊不是 Python 自帶的。要安裝它
PASSWORDS = {'email': 'F7minlBDDuvMJuxESSKHFhTxFtjVB6',
'blog': 'VmALvQyKAxiVH5G8v01if1MLZF3sdt',
'luggage': '12345'}
import sys, pyperclip
#判斷輸入參數是否有問題 helloworld.py blog
if len(sys.argv) < 2:
print('Usage: py pw.py [account] - copy account password')
sys.exit()
#將查詢的鍵傳給account
account = sys.argv[1] # first command line arg is the account name
if account in PASSWORDS:#查詢是否有account的鍵
pyperclip.copy(PASSWORDS[account])
#復制給剪貼板
print('Password for ' + account + ' copied to clipboard.')
else:
print('There is no account named ' + account)
啟動命令：helloworld.py blog
import pyperclip
text = pyperclip.paste()
# Separate lines and add stars.
lines = text.split('\n')
for i in range(len(lines)): # loop through all indexes for "lines" list
lines[i] = '* ' + lines[i] # add star to each string in "lines" list
text = '\n'.join(lines)
pyperclip.copy(text)
1．轉義字符表示字符串中的一些字符，這些字符用別的方式很難在代碼中打出來。
2．\n 是換行符，\t 是制表符。
3．\轉義字符表示一個反斜槓。
4．Howl’s 中的單引號沒有問題，因為你用了雙引號來標識字符串的開始和結束。
5．多行字符串讓你在字符串中使用換行符，而不必用\n 轉義字符。
6．這些表達式求值為以下值：
• ‘e’
• ‘Hello’
• ‘Hello’
• 'lo world!
7．這些表達式求值為以下值：
• ‘HELLO’
• True
• ‘hello’
8．這些表達式求值為以下值：
• [‘Remember,’, ‘remember,’, ‘the’, ‘fifth’, ‘of’, ‘November.’]
• ‘There-can-be-only-one.’
9．分別用 rjust()、ljust() 和 center() 字符串方法。
10．lstrip() 和 rstrip() 方法分別從字符串的左邊和右邊移除空白字符。
def printTable(tableData):
colWidths = [0] * len(tableData)
for i in range(len(colWidths)):
colWidths[i] = max(len(tableData[i][0]), len(tableData[i][1]), len(tableData[i][2]), len(tableData[i][3]))
for j in range(len(tableData[0])):
for k in range(len(tableData)):
print(tableData[k][j].rjust(colWidths[k]),end=' ')
print()
tableData = [['apples', 'oranges', 'cherries', 'banana'],
['Alice', 'Bob', 'Carol', 'David'],
['dogs', 'cats', 'moose', 'goose']]
printTable(tableData)
