變數 variable

「變數」是什麼？簡單來說，就是一個「內容會改變」的數，舉凡文字、數字、布林值 ( 邏輯 )、陣列...等內容格式，都可以是變數所包含的內容，變數常見於數學公式，例如 xyz 座標、width 寬度或 height 高度，都是一種數字型態的變數。

認識 Python 的變數 

Python 裡的變數，表示的是「某個物件」的「名稱」，當給予某個變數內容時，其實是將內容放入一個物件「容器」中儲存，然後「給予這個物件一個變數名稱」。

可以想像成將內容放到一個杯子 ( 容器 ) 裡，接著在這個杯子上貼上標籤 ( 名稱 )，這個貼有標籤的杯子，就是一個「變數」。

舉例來說，下面的程式碼，執行後會印出數字 1。

a = 1
print(a) # 得到結果 1

程式執行順序為：

• 第一步：將數字 1 放入一個物件容器。
• 第二步：指定這個物件的名稱為 a ( 變數 a = 1 )。
• 第三步：印出變數 a 的物件內容。

設定多個變數 

因為 Python 變數的特性，同樣一個物件可以賦予多個變數名稱，下面的程式碼，執行後，變數 a、b、c 都會是 1。

就像一個杯子上面，貼了各種不同標籤。

a = 1
b = c = a
print(a) # 得到結果 1
print(b) # 得到結果 1
print(c) # 得到結果 1

程式執行順序為：

• 第一步：將數字 1 放入一個物件容器。
• 第二步：指定這個物件的名稱為 a ( 變數 a = 1 )。
• 第三步：讓這個物件名稱也有 b 和 c。
• 第四步：印出變數 a、b、c 的內容。

如果要一次設定多個變數的名稱和內容，可以使用逗號分隔名稱和內容 ( 注意變數的數量要和賦值的數量相同 )，下面的程式，只用了一行就設定了 a、b、c 三變數。

a, b, c = 1, 2, 3
print(a)   # 1
print(b)   # 2
print(c)   # 3

設定多個變數的陷阱 

如果變數的內容是串列、字典或集合，在處理「多個變數同時賦值」時容易會遇到陷阱，因為變數只是「標籤」，當多個變數同時指向一個串列、字典或集合時，只要變數內容被修改 ( 並非使用等號賦值 )，不論這個變數是全域還是區域變數，另外一個變數內容也會跟著更動。

下方例子的變數 a 使用 append 的方式「修改」串列內容，就會造成 a 和 b 的內容同時被修改，但如果 c 是使用等號再次「宣告賦值」，c 和 d 就會指向不同的內容。

a = []
b = a
a.append(1)
print(a)    # [1]
print(b)    # [1]   # 被影響

c = []
d = c
c = [1]
print(c)    # [1]
print(d)    # []    # 不受影響

同樣的原理也可以應用在會被「全域變數和區域變數」影響的函式，下方的例子執行後，f1 函式的 a 不受作用域的影響，使用 append 發生「改變」後，不論 a 在何處都會被影響，連帶 b 也被影響，但 c 因為是使用等號「宣告賦值」，就會轉變成「區域變數」，因此在 f1 函式作用域之外的 c 就不會被影響，d 也不會被影響。

a = []
b = a
c = []
d = c

def f1():
    a.append(1)
    c = [1]
    print(a)  # [1]
    print(b)  # [1]   # 被影響
    print(c)  # [1]
    print(d)  # []    # 不受影響

def f2():
    print(a)  # [1]   # 被影響
    print(b)  # [1]   # 被影響
    print(c)  # []    # 不受影響
    print(d)  # []    # 不受影響

f1()
f2()

重新設定變數 

在同一層的程式裡，變數名稱都是不會重複的，如果重複使用了變數名稱，則會將名稱指派給另外一個物件，下面的程式碼，執行後會印出數字 2 和 1。

就像從一個杯子上撕下標籤，貼到另外一個杯子上。

a = 1
b = a
a = 2
print(a) # 得到結果 2
print(b) # 得到結果 1

執行順序為：

• 第一步：將數字 1 放入一個物件容器。
• 第二步：指定這個物件的名稱為 a ( 變數 a = 1 )。
• 第三步：讓指定名稱為 a 的物件也有另外一個名稱 b ( 變數 b = 變數 a )。
• 第四步：將數字 2 放入一個物件容器，指定這個物件的名稱為 a ( 將標籤 a 從數字 1 的盒子上撕下來，貼到數字 2 的盒子上 )。
• 第五步：印出變數 a 和名稱 b 的物件內容。

交換變數名稱 

在其他程式語言裡，如果想要交換兩個變數的值，通常會用另外一個變數暫存要交換的數值，在 Python 裡可以一次進行多個變數的交換名稱，下方的例子會將 a、b、c 的數值換成 b、c、a。

a = 1
b = 2
c = 3
print(a, b, c)     # 1, 2, 3
a, b, c = b, c, a  # 交換內容
print(a, b, c)     # 2, 3, 1

同理，如果在變數賦值時，有變數的內容有做運算，同樣會按照交換變數名稱的方法，以當下的變數內容為主，下方的例子雖然按起來很類似，但因為 a 和 b 使用交換變數名稱的方式，因此 a+b 運算時 a 等於 1，而 c 和 d 是按照順序賦值，所以 c+d 時 c 的內容已經改變了。

a = 1
b = 2
a, b = b, a+b
print(a, b)    # 2, 3

c = 1
d = 2
c = d
d = c + d
print(c, d)    # 2, 4

變數後方的逗號 

有時候在瀏覽一些程式時，會遇到宣告變數的後方多了一個「逗號」，在變數後方加上逗號，表示「tuple 的型別轉換」，當 tuple 中「只有一個元素」的時候，變數後方加上逗號，就能將元組型別轉換成文字或數字。

a = (1,)
b = ('b',)
c1 = a
c2, = a    # 宣告時加上逗號
d1 = b
d2, = b    # 宣告時加上逗號
print(c1)  # (1,)    # 還是 tuple
print(c2)  # 1       # 變成數字
print(d1)  # ('b',)  # 還是 tuple
print(d2)  # b       # 變成文字

好的變數名稱 

幫變數命名的時候，需要把握一個重點：「看到變數的名稱，就知道是儲存什麼資料」，因此變數名稱如果取得不好，程式就會難以理解，Python 官方網站提供了以下幾個變數名稱的建議：

• 建議使用小寫英文字母，例如 score。如果需要組合多個英文單字，可以在單字之間加上底線，例如：english_score。
• 如果變數的內容不要被修改（ 其他程式語言稱為「常數」，也就是內容不會改變的數 )，變數名稱建議全部用大寫英文字母，例如 MAX_NUMBER。
• 如果變數名稱包含專有名詞，例如 HTTP、APP，就使用原來的大小寫格式，例如 HTTP_port、APP_port。

 

全域變數、區域變數

一個變數的名稱除了可以代表不同的東西，也表示「哪裡可以使用」這個變數，這篇教學將會介紹全域變數和區域變數的用法和差異。

什麼是全域變數和區域變數？ 

在 Python 裡的主程式與每個函式，都有各自的名稱空間 ( namespace )，簡單的區分規則如下：

• 主程式定義「全域」的名稱空間，在主程式定義的變數是「全域變數」。
• 個別函式定義「區域」的名稱空間，個別函式裡定義的變數就是「區域變數」。
• 每個名稱空間裡的變數名稱都是「唯一的」。
• 不同名稱空間內的變數名稱可以相同，例如函式 A 可以定義 a 變數，函式 B 也可以定義 a 變數，兩個 a 變數是完全不同的變數。

例如有個人叫做小華，在一個家庭裡只會有一個小華，而不同的家庭可以有不同的小華 ( 不同的人，但是都叫做小華 )，不過如果這群小華去到學校，就必須要額外命名，才知道哪個小華是小華 ( 一間學校只會有一個小華，其他的可能是小華一號、小華二號...等 )

預設的名稱空間 

Python 預設提供三個名稱空間，分別是內置預設 Built-in ( Python 預設的函數名稱如 abs、char...等等 )、全域 Global 和區域 Local 三種，當使用變數時，會從最內層 ( 區域命名空間 ) 開始往外層搜尋，直到找到對應的名稱為止 ( 如果找不到就會拋出錯誤 )。

釐清到底用了哪個變數 

下方的程式碼，定義了兩個變數 a，因為兩個變數 a 處在不同的名稱空間裡，所以印出來的結果是不同的。

注意，函式名稱也屬於變數名稱，如果將函式定義為 a，則會覆寫全域變數 a 的內容。

a = 1           # 定義全域變數 a 等於 1
def hello():    # 定義 hello 函式
  a = 2         # 定義區域變數 a 等於 2
  print(a)

hello()         # 2
print(a)        # 1

如果在 hello 函式裡沒有定義變數 a，而是「單純使用變數 a」，這時程式會先尋找 hello 函式的名稱空間裡是否有變數 a，如果找不到，就會往外層尋找，找到之後就會使用該變數的內容，以下方的例子，執行 hello 函式後就會印出 10。

a = 1
def hello():
  print(a+9)    # 使用全域變數的 a

hello()         # 10
print(a)        # 1

如果移除全域變數 a，執行過程最後就會發生錯誤，因為最後一個 print(a) 是尋找全域變數 a，因為找不到所以就會發生錯誤。

def hello():
  a = 1
  print(a)

hello()
print(a)    # 發生錯誤，因為找不到變數 a

同樣的道理，如果是不同函式，如果要互相呼叫對方的變數，也會發生錯誤。

def hello():
  a = 1
  print(a)

def test():
  print(a)

hello()
test()    # 發生錯誤，因為找不到變數 a

使用 global 修改全域變數 

如果要在函式裡修改全域變數，可以使用「global 全域變數」的方式。

a = 1         # 定義全域變數 a 等於 1
def hello():  # 定義 hello 函式
  global a    # 聲明下方的 a 為全域變數 a
  a = 2       # 修改 a 為 2

print(a)      # 1
hello()       # 執行 hello 函式
print(a)      # 2 ( 全域變數 a 被修改為 2 )

全域變數和區域變數容易遇到的陷阱 

如果變數的內容是串列、字典或集合，在處理「全域變數和區域變數」時，與處理「多個變數同時賦值」時一樣，很容易會遇到賦值的陷阱，因為變數只是「標籤」，當多個變數同時指向一個串列、字典或集合時，只要變數內容被修改 ( 並非使用等號賦值 )，不論這個變數是全域還是區域變數，另外一個變數內容也會跟著更動。

下方的例子執行後，f1 函式的 a 不受作用域的影響，使用 append 發生「改變」後，不論 a 在何處都會被影響，連帶 b 也被影響，但 c 因為是使用等號「宣告賦值」，就會轉變成「區域變數」，因此在 f1 函式作用域之外的 c 就不會被影響，d 也不會被影響，不過如果在 f1 的開頭加上 global c，等同於將 c 從區域變數提升到全域變數，f2 裡的 c 就會被影響。

a = []
b = a
c = []
d = c

def f1():
    # global c        # 如果加上這行，f2 裡的 c 就會被影響
    a.append(1)
    c = [1]
    print(a)  # [1]
    print(b)  # [1]   # 被影響
    print(c)  # [1]
    print(d)  # []    # 不受影響

def f2():
    print(a)  # [1]   # 被影響
    print(b)  # [1]   # 被影響
    print(c)  # []    # 不受影響，但如果 f1 加上 global c，此處就會被影響
    print(d)  # []    # 不受影響

f1()
f2()

global() 和 local() 

global() 和 local() 是兩個可以印出目前變數的方法：

• global()：回傳一個字典，內容是「全域名稱空間」的內容。
• local()：回傳一個字典，內容是「區域名稱空間」的內容。

下方的程式碼，執行 hello 函式後會印出區域名稱空間和全域名稱空間的內容。

a = 1
def hello():
  a = 1
  print(locals())
  print(globals())

hello()
print(a)

如果將 locals() 放到全域名稱空間裡，則印出來的結果和 global() 相同。

a = 1
def hello():
  a = 1
hello()
print(locals())
print(globals())

數字 number

「數字」就是我們常見的阿拉伯數字，但在 Python 裡，數字又分成「整數」、「浮點數」( 小數 ) 和「底數」，數字可以進行各種數學式的運算，也可以進行各種邏輯比較、時間表達等以數字為主的運算。

整數 

整數 integer，表示沒有分數或小數點的十進位數字，使用 type 查看整數的「型別」，可以得到「int」的型別。

type(5)  # int

整數可以透過下方數學式進行一般的算數計算，並依循「先乘除後加減」的規則。

運算子	說明	範例	結果
+	加法	1+2	3
-	減法	20-12	8
*	乘法	2*3	6
/	除法	9/2	4.5
//	除法取整數 ( 無條件捨去 )	9//2	4
%	餘數	9%2	1
**	次方	2**3	8

3 + 2          # 5
3 + 2 * 2      # 7
( 3 + 2 ) * 2  # 10

如果整數的運算會產生小數點，結果就會轉換成浮點數。

type(3/2)  # float

進行整數的運算時，需要注意數字的「開頭」不能為 0 ( 除非是「底數」 )，如果整數開頭為 0，執行時會出現錯誤。

如果要讓一個數值等於「整數」，可以使用「int 函式」來進行型態的轉換，int 函式也會將小數點的部分無條件捨棄、將數字字串轉換成數字，或將布林值轉換成 1 或 0。

int(5.1)   # 5
int(9/2)   # 4
int('5')   # 5
int('+2')  # 2
int(True)  # 1
int(False) # 0

int 函式也可以進行二進制、八進制、十六進制的轉換。

• 十進制：0～9，當 10 的時候會進一位。
• 二進制：只有 1 和 0，當 2 的時候會進一位，變成 10，3 則是 11。
• 八進制：0～7，當 8 的時候會進一位，變成 10，9 則是 11。
• 十六進制：0～15 ( 10～15 由 A～F 表示 )，當 16 的時候會進一位，變成 10，11 則是 17。

int('101', 2)  # 5   二進制
int('101', 8)  # 65  八進制
int('101', 16) # 257 十六進制

注意，如果 int 轉換的是「字串」或「有小數點數字的字串」，就會發生錯誤。

浮點數 

浮點數 float，表示包含小數點的十進位數字，使用 type 查看整數的「型別」，可以得到「float」的型別，從下方的程式可以看到，只要數值包含了小數點，就算是 1.0 或 0.0，都會是「浮點數 float」的型別 ( 注意，由於計算機有位元數限制，有小數點的數字最多只有 15 位有效數字 )。

type(5.1) # float
type(1.0) # float
type(0.0) # float

如果使用浮點數和整數進行運算 ( 或和布林值運算 )，得到的結果會是浮點數。

1.0 + 5      # 6.0
1.0 + True   # 2.0
1.0 + False  # 1.0

浮點數可以透過「float 函式」將整數、數字文字或布林值，轉換成浮點數的數字。

float(5)     # 5.0
float('5')   # 5.0
float('5.1') # 5.1
float(True)  # 1.0
float(False) # 0.0

底數 

底數是在數字的前方，加入 0b、0o 或 0x 的底數，來表示二進制、八進制或十六進制的數字，在「位元級」的模式下，往往是使用二進制、八進制或十六進制進行操作。

底數	代表
0b 或 0B	二進制
0o 或 0O	八進制
0x 或 0X	十六進制

0b1111 # 15 ( 二進制 )
0o1111 # 585 ( 八進制 )
0x1111 # 4369 ( 十六進制 )

布林 

「布林 Bool」只有 True 和 False 兩個值，通常 True 可以表示為 1，Fasle 可以表示為 0，透過特殊函示 bool() 可以將任何資料型態轉換成布林，布林主要運用在邏輯判斷中，可以根據得到的布林值，作出對應的動作，在之後的許多範例中，都可以看見布林的應用。

下列「非 0 數字」會轉換為 True：

bool(True)  # True
bool(1)     # True
bool('ok')  # True
bool(-1)    # True

下列「0 值數字」會轉換為 False：

bool(False)  # False
bool(0)      # False
bool(0.0)    # False

文字與字串 string

字串是 Python 裡最常使用的序列，可以包含字母、數字、符號、標點甚至空格、換行，這篇教學會介紹文字與字串基本的用法。

建立字串 

使用將字元 ( 字母、符號或數字 ) 放在一對「單引號」或「雙引號」裡，就可製作為一個 Python 字串。

print("hello")  # hello
print('hello')  # hello

單引號和雙引號可以互相搭配使用，當單引號被雙引號包覆時，單引號為字串，當雙引號被單引號包覆時，雙引號為字串。

print("'oxxo' is my name")  # 'oxxo' is my name
print('"oxxo" is my name')  # "oxxo" is my name

如果是「多行字串」( 文字很多且會換行 )，則可將多行字串，放在「連續三個」單引號或雙引號裡，就會原封不動的印出結果。

a = """Millions of developers and companies build,
ship, and maintain their software on GitHub—the
largest and most advanced development platform
in the world."""
print(a)

此外，也可以使用「str()」，將資料轉換成字串，下方的程式將數字 123 轉換為字串 123。

a = str(123)
print(a)   # '123'

轉義 

「轉義」表示「轉換字串內一些字元的含義」，只要在需要轉換的字元前方，加上「反斜線 \」，就能賦予其特殊意義，常用的轉義字元有下面幾種：

轉義字元	說明
\( 放在一行結尾 )	接續下一行
\\	顯示反斜線
\'	顯示單引號
\"	顯示雙引號
\b	刪除前一個字元
\n	換行
\t	tab 鍵

下方的例子，在一行字串裡，使用轉義字元，讓結果同時顯示單引號、雙引號和反斜線。

a = 'hello "World", my name is \'oxxo\', \\_\\'
print(a)

# hello "World", my name is 'oxxo', \_\

下方的例子，將一行文字根據「\n」進行換行。

a = 'hello World,\nmy name is oxxo,\nhow are you?'
print(a)

# hello World,
# my name is oxxo,
# how are you?

 

前方加上 r 

如果在字串的前方加上「r」，表示這個字串為「raw string」，不要進行轉義，下方的程式碼執行後，a 會印出「\n」( 因為不進行轉義 )，b 則會將 \n 轉義為換行，就會印出換行的結果。

a = r'123\n456'
b = '123\n456'
print(a)     # 123\n456
print(b)
# 123
# 456

結合字串 

結合字串有三種方式：「+ 號、字串後方放置、括號」，結合的字串「不會加上空格」，所以空格要自己補上。

使用「+ 號」可以針對「變數」與「字串」進行結合。

a = 'hello'
b = ' world'  # 前方補上空格
c = a + b + '!!!'
print(c)

# hello world!!!

使用「字串後方放置」只能針對「字串」( 不是變數 ) 進行結合。

a = 'hello' ' world' '!!!'
print(a)

# hello world!!!

如果有很多字串，可以將其放在「括號」裡進行結合。

a = ('a' "b" 'c' "'" 'ok' "'")
print(a)

# abc'ok'

重複字串 

在字串後方使用「*」加上數字，可以指定該字串要重複幾次，下方的例子，會將 ok 重複 10 次。

a = 'ok'*10
print(a)

# okokokokokokokokokok

如果變數是字串，也可以使用 * 進行重複，下圖的例子，會出現 20 個 ok。

a = 'ok'*5
b = a * 4
print(b)

# okokokokokokokokokokokokokokokokokokokok

取得字元與字串 

使用「 [ ] 」可以取得某個字元 ，因為每個字元在字串中都有各自的「順序 offset」，從左邊數來第一個順序為 0，接下來是 1，如果指定 -1 則會選擇最右邊的字元，-2 則是右邊數來的第二個，依此類推。

a = 'hello world'
print(a[0])    # h ( 第一個字元 )
print(a[3])    # l ( 第四個字元 )
print(a[-1])   # d ( 最後一個字元 )

如果要取得某一串文字，可以使用「slice」的方式，定義 slice 的方式為一組方括號、一個 start ( 開始順序 )、一個 end ( 結尾順序 ) 和一個中間的 step ( 間隔 )，常見的規則如下：

定義	說明
[ : ]	取出全部字元，從開始到結束
[ start: ]	取出從 start 的位置一直到結束的字元
[ :end ]	取出從開始一直到 end 的「前一個位置」字元
[ start:end ]	取出從 start 位置到 end 的「前一個位置」字元
[ start:end:step ]	取出從 start 位置到 end 的「前一個位置」字元，並跳過 step 個字元

a = '0123456789abcdef'
print(a[:])       # 0123456789abcdef ( 取出全部字元 )
print(a[5:])      # 56789abcdef ( 從 5 開始到結束 )
print(a[:5])      # 01234 ( 從 0 開始到第 4 個 ( 5-1 ) )
print(a[5:10])    # 56789 ( 從 5 開始到第 9 個 ( 10-1 ) )
print(a[5:-3])    # 56789abc ( 從 5 開始到倒數第 4 個 ( -3-1 ) )
print(a[5:10:2])  # 579 ( 從 5 開始到第 9 個，中間略過 2 個 )

len() 取得字串長度 

len() 函式可以取得一串字串的長度 ( 總共幾個字元 )，取得的長度不包含轉義字元，下方的例子會顯示變數 a 的字串長度。

a = '0123456789_-\\\"\''
print(len(a)) # 15，不包含三個反斜線 \

split() 拆分 

split() 函式可以將一個字串，根據指定的「分隔符號」，拆分成「串列」 ( 串列就是許多值組成的序列，將許多值包覆在方括號裡，並使用逗號分隔 )。

a = 'hello world, I am oxxo, how are you?'
b = a.split(',') # 以逗號「,」進行拆分
c = a.split(' ') # 以空白字元「 」進行拆分
d = a.split()    # 如果不指定分隔符號，自動以空白字元進行拆分
print(b)         # ['hello world', ' I am oxxo', ' how are you?']
print(c)         # ['hello', 'world,', 'I', 'am', 'oxxo,', 'how', 'are', 'you?']
print(d)         # ['hello', 'world,', 'I', 'am', 'oxxo,', 'how', 'are', 'you?']

replace() 替換 

replace() 函式可以進行簡單的字串替換，replace() 函式有三個參數「舊的字串，新的字串，替換的數量」，如果沒有指定數量，就會將內容所有指定的字串替換成新的字串。

如果要進行更複雜規則的取代，就必須要使用「正規表達式」。

a = 'hello world, lol'
b = a.replace('l','XXX')
c = a.replace('l','XXX',2)
print(b)  # heXXXXXXo worXXXd, XXXoXXX ( 所有的 l 都被換成 XXX )
print(c)  # heXXXXXXo world, lol ( 前兩個 l 被換成 XXX )

strip() 剝除 

strip() 函式可以去除一段字串開頭或結尾的某些字元，使用 rstrip() 函式可以只去除右邊，使用 lstrip() 函式可以只去除左邊，括號內可以填入指定的字元，就會將開頭或結尾指定的字元剝除。

a = '  hello!!'
b = a.strip()
e = a.strip('!')
c = a.lstrip()
d = a.rstrip()
print(b) # hello!!
print(c) # hello!!
print(d) #   hello!!
print(e) #   hello

搜尋和選擇 

如果要搜尋字串中的某個字，可以使用「find()」或「index()」兩個函式，函式預設從左側開始找起，找到指定的字串或字元時，會回傳第一次出現的位置 ( offset )，如果改成「rfind()」或「rindex()」就會從右側找起，找到指定的字串或字元時，會回傳最後一次出現的位置 ( offset )，如果沒有找到結果，find() 會回報 -1 的數值，index() 會直接顯示錯誤訊息。

a = 'hello world, I am oxxo, I am a designer!'
b = a.find('am')
c = a.rfind('am')
print(b)  # 15 ( 第一個 am 在 15 的位置 )
print(c)  # 26 ( 最後一個 am 在 26 的位置 )

下方列出一些好用的搜尋與選擇函式：

函式	說明
startswith()	判斷開頭字串，符合 True，不符合 False
endswith()	判斷結尾字串，符合 True，不符合 False
isalnum()	判斷是否只有字母和數字，符合 True，不符合 False
count()	計算字串出現了幾次

a = 'hello world, I am oxxo, I am a designer!'
b = a.startswith('hello')
c = a.endswith('hello')
d = a.isalnum()
e = a.count('am')
print(b)   # True  ( 開頭是 hello )
print(c)   # False ( 結尾不是 hello )
print(d)   # False ( 裡面有逗號和驚嘆號 )
print(e)   # 2 ( 出現兩次 am )

大小寫 

Python 針對字串的大小寫，有四種內建的轉換函式可以使用：

函式	說明
title()	單字字首字母變大寫
upper()	所有字母變大寫
lower()	所有字母變小寫
swapcase()	單字字母的大小寫對調

a = 'Hello world, I am OXXO'
b = a.title()
c = a.upper()
d = a.lower()
e = a.swapcase()
print(b) # Hello World, I Am Oxxo
print(c) # HELLO WORLD, I AM OXXO
print(d) # hello world, i am oxxo
print(e) # hELLO WORLD, i AM oxxo

文字與字串 ( 常用方法 )

在「文字與字串」文章中已經認識了字串 String 的基本用法，這篇教學會整理出文字與字串相關的語法。

str(x) 

使用「str(x)」可以將 x 轉換成字串的型態。

a = str(123)
print(a)   # 123 ( 字串型態，不是數字 )

+ 結合字串 

使用「＋」可以將不同的字串結合在一起。

a = 'abc'
b = '123'
print(a + b)   # abc123

＊ 重複字串 

使用「＊」可以將同一個字串重複指定的次數。

a = 'abc'
print(a*3)

str[] 

使用「str[]」可以取出字串中的某些字元。

a = '0123456789abcdef'
print(a[0])       # 0 ( 第一個字元 )
print(a[3])       # 3 ( 第四個字元 )
print(a[-1])      # f ( 最後一個字元 )
print(a[:])       # 0123456789abcdef ( 取出全部字元 )
print(a[5:])      # 56789abcdef ( 從 5 開始到結束 )
print(a[:5])      # 01234 ( 從 0 開始到第 4 個 ( 5-1 ) )
print(a[5:10])    # 56789 ( 從 5 開始到第 9 個 ( 10-1 ) )
print(a[5:-3])    # 56789abc ( 從 5 開始到倒數第 4 個 ( -3-1 ) )
print(a[5:10:2])  # 579 ( 從 5 開始到第 9 個，中間略過 2 個 )

len(str) 

使用「len(str)」可以取得字串長度 ( 有幾個字元 )。

a = 'hello world'
print(len(a))    # 11

str.split(x) 

使用「str.split(x)」可以根據 x 字元拆分字串，使字串變成串列形式。

a = 'hello world, I am oxxo, how are you?'
b = a.split(',') # 以逗號「,」進行拆分
c = a.split(' ') # 以空白字元「 」進行拆分
d = a.split()    # 如果不指定分隔符號，自動以空白字元進行拆分
print(b)         # ['hello world', ' I am oxxo', ' how are you?']
print(c)         # ['hello', 'world,', 'I', 'am', 'oxxo,', 'how', 'are', 'you?']
print(d)         # ['hello', 'world,', 'I', 'am', 'oxxo,', 'how', 'are'

str.join(iter) 

使用「str.join(iter)」可以將原本的字串，結合指定的序列，變成新的字串。

a = ['hello world', 'I am oxxo', 'how are you?']
b = ', '.join(a)  # 使用逗號「,」進行結合
print(b)  # hello world, I am oxxo, how are you?

str.replace(x, y, n) 

使用「str.replace(x, y, n)」可以將字串中的 x 替換為 y，n 為要替換的數量，可不填 ( 表示全部替換 )

a = 'hello world, lol'
b = a.replace('l','XXX')
c = a.replace('l','XXX',2)
print(b)  # heXXXXXXo worXXXd, XXXoXXX ( 所有的 l 都被換成 XXX )
print(c)  # heXXXXXXo world, lol ( 前兩個 l 被換成 XXX )

str.strip() 

使用「str.strip()」可以去除字串開頭或結尾的某些字元。

a = '  hello!!'
b = a.strip()
c = a.strip('!')
d = a.lstrip()
e = a.rstrip()
print(b) # hello!!
print(c) #   hello
print(d) # hello!!    使用 lstrip() 函式可以只去除左邊
print(e) #   hello!!  使用 rstrip() 函式可以只去除右邊

下面的例子，會去除開頭與結尾指定的字元

s = '@!$##$#ABCDE%#$#%#$'
a = s.strip('!@#$%^&*(')
print(a)  # ABCDE

str.capitalize() 

使用「str.capitalize()」將字串的字首變成大寫。

a = 'hello world, i am oxxo!'
b = a.capitalize()
print(b)    # Hello world, i am oxxo!

str.casefold()、str.lower() 

使用「str.casefold()」和「str.lower()」可以將字串全部轉成小寫，str.casefold() 更會將一些其他語系的小寫字母作轉換。

a = 'Hello World, I am OXXO!'
b = a.casefold()
c = a.lower()
print(b)    # hello world, i am oxxo!
print(c)    # hello world, i am oxxo!

str.upper() 

使用「str.upper()」可以將字串全部轉成大寫。

a = 'Hello World, I am OXXO!'
b = a.upper()
print(b)    # HELLO WORLD, I AM OXXO!

str.title() 

使用「str.title()」可以將字串全部轉成標題 ( 每個單字字首大寫 )

a = 'Hello world, I am OXXO! How are you?'
b = a.title()
print(b)    # Hello World, I Am Oxxo! How Are You?

str.swapcase() 

使用「str.swapcase()」可以將字串的大小寫對調。

a = 'Hello world, I am OXXO!'
b = a.swapcase()
print(b)   # hELLO WORLD, i AM oxxo!

str.count(sub, start, end) 

使用「str.count(sub, start, end)」可以計算某段文字在字串中出現的次數 ( start、end 為範圍，可不填 )。

a = 'Hello world, I am OXXO!'
b = a.count('o')
c = a.count('o', 1, 5)
print(b)     # 2
print(c)     # 1

str.index(sub, start, end) 

使用「str.index(sub, start, end)」可以尋找某段文字在字串中出現的位置 ( start、end 為範圍，可不填 )。

a = 'Hello world, I am OXXO!'
b = a.index('w')
print(b)     # 6

str.encode(encoding='utf-8', errors='strict') 

使用*「str.encode(encoding='utf-8', errors='strict')可以針對字串進行編碼。

a = 'Hello world, 喔哈！'
b = a.encode(encoding='utf-8', errors='strict')
c = a.encode(encoding='BIG5', errors='strict')
print(b)    # b'Hello world, \xe5\x96\x94\xe5\x93\x88\xef\xbc\x81'
print(c)    # b'Hello world, \xb3\xe1\xab\xa2\xa1I'

sub in str 

使用「sub in str」可以判斷字串中是否存在某段文字，回傳 True 或 False ( 也可使用 not in 判斷是否不存在 )。

a = 'Hello world!'
print('wo' in a)      # True
print('ok' not in a)  # True

str.isalnum() 

使用「str.isalnum()」可以判斷字串中是否都是英文字母或數字 ( 不能包含空白或符號 )，回傳 True 或 False。

a = 'Helloworld123'
b = 'Helloworld123!!'
c = 'Hello world'
print(a.isalnum())   # True
print(b.isalnum())   # False ( 包含驚嘆號 )
print(c.isalnum())   # False ( 包含空白 )

str.isalpha() 

使用「str.isalpha()」可以判斷字串中是否都是英文字母 ( 不能包含數字、空白或符號 )，回傳 True 或 False。

a = 'Helloworld'
b = 'Helloworld123'
c = 'Hello world'
print(a.isalpha())   # True
print(b.isalpha())   # False ( 包含數字 )
print(c.isalpha())   # Fasle ( 包含空白 )

str.isdigit() 

使用「str.isdigit()」可以判斷字串中是否都是數字 ( 不能包含英文、空白或符號 )，回傳 True 或 False。

a = '12345'
b = 'Hello123'
c = '1 2 3'
print(a.isdigit())   # True
print(b.isdigit())   # False  ( 包含英文 )
print(c.isdigit())   # Fasle  ( 包含空白 )

str.islower() 

使用「str.islower()」可以判斷字串中是否都是小寫英文字母 ( 忽略數字和符號 )，回傳 True 或 False。

a = 'hello world 123'
b = 'Hello World 123'
print(a.islower())    # True
print(b.islower())    # False ( H 和 W 是大寫 )

str.isupper() 

使用「str.isupper()」可以判斷字串中是否都是大寫英文字母 ( 忽略數字和符號 )，回傳 True 或 False。

a = 'HELLO 123'
b = 'Hello 123'
print(a.isupper())    # True
print(b.isupper())    # False

str.istitle() 

使用「str.istitle()」可以判斷字串中是否為標題 ( 每個單字字首大寫 )，回傳 True 或 False。

a = 'Hello World I Am Oxxo 123!!'
b = 'Hello World I Am OXXO 123!!'
c = 'Hello world, I am OXXO 123!!'
print(a.istitle())    # True
print(b.istitle())    # False ( OXXO 全都大寫 )
print(c.istitle())    # False ( world 和 am 字首沒有大寫 )

文字與字串 ( 格式化 )

在 Python 裡，除了可以使用基本功能串接字串，也可以針對不同的格式，將資料插入字串當中，由於 Python 版本的不同，這篇教學會介紹三種格式化字串的方法，透過字串的格式化，也可以輕鬆做出數字「補零」的效果。

% 

「%」的字串格式化是「舊式」的格式化方法，適用於 Python 2 和 3 的版本，操作方式為「格式化字串 % 資料」，輸出結果會將資料插入格式化字串的位置。

格式化字串	轉換型態
%s	字串
%d	十進制整數
%x	十六進制整數
%o	八進制整數
%b	二進制整數
%f	十進制浮點數
%e	指數浮點數
%g	十進制或指數浮點數
%%	常值 %

下面的例子，印出 a 的內容時，會將內容的 %s 替換成 % 後方的字串，%d 會將浮點數的小數點無條件捨去，%f 則會將整數轉換成浮點數。( 如果用 %s 顯示數字，數字的型態會被轉換成文字 )

a = 'Hello world, I am %s!!'
b = 'there are %d dollars'
c = 'there are %f dollars'
print(a % 'oxxo')  # Hello world, I am oxxo!!
print(a % 'xoox')  # Hello world, I am xoox!!
print(b % 2.5)     # there are 2 dollars ( 小數點被無條件捨去 )
print(c % 2)       # there are 2.000000 dollars ( 整數轉換成浮點數 )

格式化字串的 % 和形態代號間，可以加入其他數值，來指定最小寬度、最大字元、對齊與精確度：

格式化數值	說明
不加東西、+	靠右對齊
-	靠左對齊
數字	最小寬度 ( 如果字串超過最小寬度，以字串的寬度為主 )
數字.數字	最小寬度.最大字元數，如果後方是 f (%f)，第二個數字表示小數點位數

下面的例子可以看到 %12s 會在 hello 前方加上七個空格 ( 7 + hello 總共 12 個字元 )，%.3s 會讓 hello 只剩下 hel ( 3 個字元 )，%.3f 會讓 123.456789 只留下小數點三位。

print('%s world' % 'hello')      # hello world
print('%12s world' % 'hello')    #        hello world
print('%+12s world' % 'hello')   #        hello world
print('%-12s world' % 'hello')   # hello        world
print('%.3s world' % 'hello')    # hel world
print('%12.3s world' % 'hello')  #          hel world

print('%.3f world' % 123.456789) # 123.457 world

如果有多個數值需要格式化，可以在 % 後方用小括號包住對應的參數，參數的數量和順序必須和前方的格式化字元相同。

a = '%s world, ther are %f dollars!'
b = a % ('hello', 2.5)
print(b)   # hello world, ther are 2.500000 dollars!

.format 

「{}」和「foramt()」是 Python 3 所使用的「新式」格式化，操作方式為「格式化字串.format(資料)」，輸出結果會將資料插入格式化字串的位置，下面的例子，會將 world 和 oxxo 兩個字串，分別插入字串中的兩個 {}。

a = 'hello {}, I am {}'
b = a.format('world', 'oxxo')
print(b)   # hello world, I am oxxo

{} 裡可以填入數字，數字表示「填入資料的順序」，如果將上面程式裡的 {} 加入數字，就會呈現不同的結果。

a = 'hello {1}, I am {0}'
b = a.format('world', 'oxxo')
print(b)   # hello oxxo, I am world ( world 和 oxxo 互換了 )

{} 裡可以填入具名引數，如果將上面程式裡的 {} 加入名稱，就會放入指定名稱的內容。

a = 'hello {m}, I am {n}'
b = a.format(m='world', n='oxxo')
print(b)   # hello world, I am oxxo

{} 裡可以填入字典的引數，如果將上面程式裡的 {} 加入對應的引數，就會放入指定的字典內容。

a = 'hello {0[x][m]}, I am {0[y][m]}'
b = {'x': {'m':'world', 'n':'oxxo'}, 'y':{'m':'QQ', 'n':'YY'}}
c = a.format(b)
print(c)    # hello world, I am QQ

新式的格式化字串和 % 定義略有不同，可以加入其他數值，來指定最小寬度、最大字元、對齊與精確度：

格式化數值	說明
:	開始需要加上冒號
不加東西、>	靠右對齊
<	靠左對齊
^	置中對齊
填補字元	將不足最小寬度的空白，填滿指定字元
數字.數字	最小寬度.最大字元數，如果後方是 f (%f)，第二個數字表示小數點位數

資料的型態也由 % 改為「:」表示。

格式化字串	轉換型態
:s	字串
:d	十進制整數
:x	十六進制整數
:o	八進制整數
:b	二進制整數
:f	十進制浮點數
:e	指數浮點數
:g	十進制或指數浮點數

下面的例子可以看到 {:-^10s} 會將 world 置中對齊，並將不足最小寬度的部分補上 - 的符號，{:^10.3f} 會讓 123.456789 只留下小數點三位。

a = 'hello {}, I am {}'.format('world','oxxo')
b = 'hello {:10s}, I am {:10s}'.format('world','oxxo')
c = 'hello {:>10s}, I am {:>10s}'.format('world','oxxo')
d = 'hello {:-^10s}, I am {:+^10s}'.format('world','oxxo')
e = 'hello {:-^10.3s}, I am {:-^10s}'.format('world','oxxo')
f = 'hello {:-^10.3s}, I am {:^10.3f}'.format('world',123.456789)
print(a)  # hello world, I am oxxo
print(b)  # hello world     , I am oxxo
print(c)  # hello      world, I am       oxxo
print(d)  # hello --world---, I am +++oxxo+++
print(e)  # hello ---wor----, I am ---oxxo---
print(f)  # hello ---wor----, I am  123.457

f-string 

f-string 是 Python 3.6 加入的字串格式化功能，也是現在比較推薦的格式化方法，操作方式為「f{變數名稱或運算式}」( 開頭可以使用 f 或 F )，輸出結果會將變數或運算式的內容，放入指定的位置，下方的程式執行後，會將變數 a 和 b 的內容，放入 c 的字串裡。

a = 'world'
b = 'oxxo'
c = f'hello {a}, I am {b}'
print(c)   # hello world, I am oxxo

f-string 的格式化字串的定義和 .format 類似，可以加入其他數值，來指定最小寬度、最大字元、對齊與精確度。下面的例子可以看到 {b:+^10} 會將 oxxo 置中對齊，並將不足最小寬度的部分補上 + 的符號，{a:-<10.3} 會將 world 靠左對齊，並指取出 wor 三個字元，空白的部分補上 - 的符號。

a = 'world'
b = 'oxxo'
c = f'hello {a:<10s}, I am {b:>10s}'
d = f'hello {a:-<10s}, I am {b:+^10s}'
e = f'hello {a:-<10.3s}, I am {b:+^10.2s}'
f = f'hello {a.upper()}, I am {b.title()}'
print(c)   # hello world     , I am       oxxo
print(d)   # hello world-----, I am +++oxxo+++
print(e)   # hello wor-------, I am ++++ox++++
print(f)   # hello WORLD, I am Oxxo

了解原理後，就可以透過字串格式化的方式，實作「補零」的效果。

for i in range(1,101):
  print(f'{i:03d}',end=' , ')

'''
001 , 002 , 003 , 004 , 005 , 006 , 007 , 008 , 009 , 010 ,
011 , 012 , 013 , 014 , 015 , 016 , 017 , 018 , 019 , 020 ,
021 , 022 , 023 , 024 , 025 , 026 , 027 , 028 , 029 , 030 ,
031 , 032 , 033 , 034 , 035 , 036 , 037 , 038 , 039 , 040 ,
041 , 042 , 043 , 044 , 045 , 046 , 047 , 048 , 049 , 050 ,
051 , 052 , 053 , 054 , 055 , 056 , 057 , 058 , 059 , 060 ,
061 , 062 , 063 , 064 , 065 , 066 , 067 , 068 , 069 , 070 ,
071 , 072 , 073 , 074 , 075 , 076 , 077 , 078 , 079 , 080 ,
081 , 082 , 083 , 084 , 085 , 086 , 087 , 088 , 089 , 090 ,
091 , 092 , 093 , 094 , 095 , 096 , 097 , 098 , 099 , 100 ,
'''

串列 list ( 基本 )

串列 ( list ) 又稱為列表、清單或陣列，串列和元組 ( tuple ) 類似，都可以將任何一種物件作為它們的元素，串列的應用非常廣泛，在大部分的程式裡都能看到串列的身影，這篇教學將會介紹建立、讀取、添加、修改和刪除的方法。

建立串列 

串列是將一連串的元素放在一個序列中，使其都有各自的編號，放入的元素可以是字串、數字、布林、串列、字典...等基本元素，在 Python 裡，有三種方法可以建立串列：「中括號 ( 方括號 )」、「list()」和「split() + 字串」。

• 中括號 ( 方括號 )

  將要建立為串列的元素，放入中括號裡，並使用逗號分隔，就會成為一個串列，通常會將串列賦值給一個變數，下方的例子 a 是字串的串列，b 是數字串列，c 則是文字、數字和串列所組成的串列。

  a = ['apple','banana','orange']
  b = [1,2,3,4,5]
  c = ['apple',1,2,3,['dog','cat']]
  print(type(a))   # <class 'list'>
  print(type(b))   # <class 'list'>
  print(type(c))   # <class 'list'>
  

• list()

  list() 函式可以建立一個「空的」串列，也能將「可迭代」( 有順序 ) 的資料轉換成串列，例如 tuple、字串、集合或字典，下方的例子 b 會將 tuple 轉換成串列，c 是空的串列，d 則是將 apple 字串變成五個獨立字母的串列。

  a = ('apple','banana','orange')
  b = list(a)
  c = list()
  d = list('apple')
  print(b)   # ['apple', 'banana', 'orange']
  print(c)   # []
  print(d)   # ['a', 'p', 'p', 'l', 'e']
  

• split() + 字串

  split() 函式可以將一個字串，根據指定的分隔符號，拆分成串列，下圖的例子，會根據「.」符號，將字串拆成串列，由於有多個「.」在一起，拆分時會出現「空」的字串元素。

  a = 'apple...banana...orange'
  b = a.split('.')
  print(b)   # ['apple', '', '', 'banana', '', '', 'orange']

合併串列 

合併串列有兩種方法：「使用 + 號」和「extend()」。

• 使用 + 號

  使用「+」號可以讓兩個串列，像字串一樣的相加，在 + 號右方的串列，會加在左方串列的後方。

  a = ['a1','a2','a3']
  b = ['b1','b2','b3']
  c = a + b
  print(c)   # ['a1', 'a2', 'a3', 'b1', 'b2', 'b3']
  

• extend()

  extend() 函式能讓一個串列的後方，合併另外一個串列的內容。

  a = ['a1','a2','a3']
  b = ['b1','b2','b3']
  a.extend(b)
  print(a)   # ['a1', 'a2', 'a3', 'b1', 'b2', 'b3']
  

  注意，extend() 函式會改變串列，但不會回傳串列的值，所以如果寫成下面的程式，會得到 none 的結果。

  a = ['a1','a2','a3']
  b = ['b1','b2','b3']
  c = a.extend(b)
  print(c)   # none
  

讀取串列項目 

要使用串列，就必須要讀取串列的內容，Python 提供了兩種讀取串列項目的方法「offset」和「slice()」。

• offset

  序列中每個元素都有各自的序列編號 ( offset )，只要透過「[offset]」，就能讀取對應的內容，串列中第一個項目的 offset 為 0，第二個 offset 為 1，依此類推，下面的例子，會依序讀取並印出串列中的元素。

  a = ['apple','banana','orange']
  print(a[0])   # apple
  print(a[1])   # banana
  print(a[2])   # orange
  

  offset 預設從左側開始，第一個項目為 0，如果從右側開始，第一個項目為 -1，第二個項目為 -2，依此類推。

  a = ['apple','banana','orange']
  print(a[-1])   # orange
  print(a[-2])   # banana
  print(a[-3])   # apple
  

  如果串列中有串列，就構成了「多維串列」，讀取元素時如果有第二層，就多一個中括號加上 offset，就能讀取第二層的元素。

  a = ['apple','banana','orange',['dog','cat']]
  print(a[3][0])   # dog
  print(a[3][1])   # cat
  

• slice()

  slice() 函式可以取出串列中「某個範圍」的元素，使用方式在中括號裡加上冒號「:」，在冒號的前後放入指定的 offset，就能取出指定範圍的資料 ( 第一個 offset : 第二個 offset - 1 )，如果不指定數值，冒號前方預設為 0，冒號後方預設為 -1。

  範圍也可以使用「負數」，表示從右側數來，但要注意第一個值的順序 ( 不論正負 ) 都必須要在第二個值的前面，不然就讀取不到項目 ( 會回傳空的結果 )。

  a = [0,1,2,3,4,5,6,7,8,9]
  b = a[:3]
  c = a[3:]
  d = a[1:3]
  e = a[-5:-2]
  print(b)   # [0, 1, 2]  取得 0～(3-1) 項
  print(c)   # [3, 4, 5, 6, 7, 8, 9]  取得 3～最後一項
  print(d)   # [1, 2]  取得 1～(3-1) 項
  print(e)   # [5, 6, 7]  取得倒數第 5 項～(倒數第二項-1)
  

  如果使用兩個冒號「::」，表示要「間隔幾個項目」取值，例如「::2」就是間隔兩個項目，「::3」就是間隔三個項目，如果是負數，就是從右側取值，因此「::-1」就可以讓反轉整個串列。

  a = [0,1,2,3,4,5,6,7,8,9]
  b = a[::3]
  c = a[3::2]
  d = a[::-1]
  e = a[::-2]
  print(b)   # [0, 3, 6, 9]  每隔三項目取值
  print(c)   # [3, 5, 7, 9]  從第三個項目開始，每隔兩項目取值
  print(d)   # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]  反轉串列
  print(e)   # [9, 7, 5, 3, 1]  反轉串列，每隔兩個項目取值
  

複製串列 

延續上方 slice() 的做法，如果使用「串列[:]」，效果等同於複製完整的串列，下方的程式碼展示兩種複製串列的方式，如果使用「b=a」的做法，雖然看起來像是複製了，但實際上 a 和 b 指向了同一個串列，所以當 a 刪除了一個項目時，b 也會跟著改變，然而如果使用「d=c[:]」的做法，會建立一個「全新」的串列，當 c 發生改變時，不會影響 d。

a = [1, 2, 3]
b = a
del(a[1])    # 刪除 a 的第二個項目
print(a)     # [1, 3]
print(b)     # [1, 3]

c = [1, 2, 3]
d = c[:]     # 複製 c 的所有項目變成一個新串列
del(c[1])    # 刪除 c 的第二個項目
print(c)     # [1, 3]
print(d)     # [1, 2, 3]

修改串列項目 

串列有別於 tuple，串列的內容項目都是「可以修改」的，修改的方法有下列兩種：「offset」和「slice()」。

• offset

  只要透過每個項目的 offset，就能夠修改指定項目的內容。

  a = ['apple','banana','orange']
  a[0] = 'grap'
  print(a)   # ['grap', 'banana', 'orange']
  

• slice()

  使用 slice() 可以快速更換某一個範圍的串列內容，下方的程式會將第 2、3、4 這三個項目更換為 100、200、300。

  a = ['a','b','c','d','e']
  a[1:4] = [100,200,300]
  print(a)    # ['a', 100, 200, 300, 'e']
  

  指定更換的項目的數量，不一定要和原本的一樣多 ( 可以比較少，也可以比較多 )，更換後會將範圍的內容，完全換成新的內容。

  a = ['a','b','c','d','e']
  a[1:4] = [1,2,3,4,5,6,7,8,9]
  print(a)   # ['a', 1, 2, 3, 4, 5, 6, 7, 8, 9, 'e']
  

  更換的內容不一定要是串列，只要是可以「迭代」的內容，例如字串、tuple，都可以將其替換進入串列中，下方的程式將 1～4 的位置換成 hello 文字，替換後 hello 文字會被拆分成一個個的字母。

  a = ['a','b','c','d','e']
  a[1:4] = 'hello'
  print(a)    # ['a', 'h', 'e', 'l', 'l', 'o', 'e']
  

添加串列項目 

Python 提供兩種串列添加項目的方法：「append()」和「insert()」。

• append()

  append() 函式可以將項目添加在一個串列的尾端，如果添加的是一個序列 tuple，會原封不動的變成一個新元素 ( 只佔有一個 offset，變成第二層序列或 tuple )。

  a = ['a','b','c','d','e']
  a.append(100)
  b = ['a','b','c','d','e']
  b.append([100,200,300])
  print(a)   # ['a', 'b', 'c', 'd', 'e', 100]
  print(b)   # ['a', 'b', 'c', 'd', 'e', [100, 200, 300]]
  

• insert()

  如果已經知道要添加的位置 offset，使用 insert() 函式，就可以將指定的內容，從指定的位置加入，如果插入的位置設定為 0，會將內容插入在串列的開頭，如果設定的位置大於串列長度，就會插入在尾端 ( 如果設定 -1，會插入在倒數第二個 )。

  a = ['a','b','c','d','e']
  a.insert(3,100)
  b = ['a','b','c','d','e']
  b.insert(0,100)
  c = ['a','b','c','d','e']
  c.insert(100,100)
  d = ['a','b','c','d','e']
  d.insert(-1,100)
  print(a)   # ['a', 'b', 'c', 100, 'd', 'e']
  print(b)   # [100, 'a', 'b', 'c', 'd', 'e']
  print(c)   # ['a', 'b', 'c', 'd', 'e', 100]
  print(d)   # ['a', 'b', 'c', 'd', 100, 'e']
  

刪除串列項目 

Python 提供了四種方法，來刪除串列的資料：「del」、「remove()」、「pop()」和「clear()」。

• del

  如果已經知道欲刪除項目的「位置 offset」，就能夠使用「del list(offset)」來刪除指定的項目，項目支援中括號的語法 ( 參考上方 slice() 的做法 )，可以刪除某個範圍的項目，當項目被刪除時，後方的項目會往前遞補，取代原本的位置。

  a = [0,1,2,3,4,5,6,7,8,9]
  del a[2]
  b = [0,1,2,3,4,5,6,7,8,9]
  del b[2:6]
  print(a)   # [0, 1, 3, 4, 5, 6, 7, 8, 9]
  print(b)   # [0, 1, 6, 7, 8, 9]
  

• remove()

  如果不知道欲刪除項目的「位置 offset」，可以使用 remove(項目內容) 刪除該項目，如果有多個同樣內容的項目，remove() 只會刪除第一個找到的項目。

  a = ['apple','apple','banana','orange']
  a.remove('apple')
  print(a)   # ['apple', 'banana', 'orange']
  

• pop()

  pop() 函式可以「取出並移除」串列裡的「一個項目」，使用的方式為「pop(offset)」，如果不指定數值或數值為 -1，則會取出最後一個項目，取出的項目如果沒有賦值給變數，這些項目就會消失。

  a = [0,1,2,3,4,5]
  b = a.pop(2)
  print(a)   # [0, 1, 3, 4, 5]
  print(b)   # 2
  

• clear()

  clear() 函式會清空整個串列的內容，使其變成一個空的串列。

  a = [0,1,2,3,4,5]
  a.clear()
  print(a)   # []
  

串列 ( 常用方法 )

在「串列 list」文章裡已經介紹了串列的建立、新增、修改...等功能，這篇教學會介紹串列的查詢、排序、複製...等其他相關的操作方法。

sort()、 sorted() 

Python 提供 sort() 和 sorted() 兩種串列的函式，函式內包含 key 和 reverse 參數 ( 可都不填 )，key 則表示進行比較的元素，reverse 不填則使用預設 False，進行升序排序 ( 小到大 )，如果參數為 True 進行降序排序 ( 大到小 )，如果排序的是字串，以字母的順序進行排序。

• sort()

  sort() 函式使用後，會直接將原本的串列項目進行排序，因此「會改變」原始的串列。

  a = [0,3,2,1,4,9,6,8,7,5]
  a.sort()
  print(a)   # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  a.sort(reverse=True)
  print(a)   # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
  

• sorted()

  sorted() 函式使用後，會產生一個排序過後的新串列，因此「不會改變」原始的串列。

  a = [0,3,2,1,4,9,6,8,7,5]
  b = sorted(a)
  c = sorted(a, reverse=True)
  print(a)   # [0, 3, 2, 1, 4, 9, 6, 8, 7, 5]
  print(b)   # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  print(c)   # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
  

  如果序列的內容也是序列，排序時可以透過 key 參數，指定對應的項目進行排序，下面的範例使用匿名函式 lambda ( 參考 匿名函式 lambda )，針對每個項目的第二個子項目進行排序 ( 如果沒有設定 key 參數，預設都以第一個項目進行排序 )。

  a = [[1,2,3],[9,8,7],[2,4,6],[3,1,9]]
  b = sorted(a)
  c = sorted(a, key = lambda s: s[1])
  print(a)   # [[1, 2, 3], [9, 8, 7], [2, 4, 6], [3, 1, 9]]
  print(b)   # [[1, 2, 3], [2, 4, 6], [3, 1, 9], [9, 8, 7]] 使用第一個項目 1,2,3,9 排序
  print(c)   # [[3, 1, 9], [1, 2, 3], [2, 4, 6], [9, 8, 7]] 使用第二個項目 1,2,4,8 排序

反轉串列 

Python 提供了兩種反轉串列的方法：

• slice

  使用 slice 反轉串列方法不會改變原始串列，會產生一個新的串列，在產生新串列時使用「[::-1]」，就能反轉串列內容。

  a = [0,1,2,3,4,5]
  b = a[::-1]
  print(a)   # [0, 1, 2, 3, 4, 5]
  print(b)   # [5, 4, 3, 2, 1, 0]
  

• reverse()

  使用 reverse() 函式可以反轉串列，但反轉之後，會改變原始串列。

  a = [0,1,2,3,4,5]
  a.reverse()
  print(a)   # [5, 4, 3, 2, 1, 0]
  

複製串列 

Python 提供四種複製串列的方法：

• slice、copy()、list()

  slice、copy()、list() 三種方式都可以快速複製一個新的串列。

  a = [0,1,2,3,4,5]
  b = a[:]
  c = a.copy()
  d = list(a)
  print(a)   # [0, 1, 2, 3, 4, 5]
  print(b)   # [0, 1, 2, 3, 4, 5]
  print(c)   # [0, 1, 2, 3, 4, 5]
  print(d)   # [0, 1, 2, 3, 4, 5]
  

• deepcopy()

  上述的三種方式只能針對「項目內容不會發生變化」的串列，如果項目的「深層內容」會發生變化，就會出現奇怪的現象，舉例來說，下方的程式碼執行後，當 a 改變時理應不該影響到 b、c、d 這三個新串列，但執行結果卻發現 b、c、d 的內容也跟著改變了。

  a = [0,1,2,3,4,[100,200]]
  b = a[:]
  c = a.copy()
  d = list(a)
  a[-1][0]=999
  print(a)   # [0, 1, 2, 3, 4, [999, 200]]
  print(b)   # [0, 1, 2, 3, 4, [999, 200]]
  print(c)   # [0, 1, 2, 3, 4, [999, 200]]
  print(d)   # [0, 1, 2, 3, 4, [999, 200]]
  

  如果要解決這個問題，就必須要 import copy() 模組，使用 deepcopy() 進行深度複製，就能產生一個完全獨立的新串列。

  import copy
  a = [0,1,2,3,4,[100,200]]
  b = a[:]
  c = a.copy()
  d = list(a)
  e = copy.deepcopy(a)
  a[-1][0]=999
  print(a)   # [0, 1, 2, 3, 4, [999, 200]]
  print(b)   # [0, 1, 2, 3, 4, [999, 200]]
  print(c)   # [0, 1, 2, 3, 4, [999, 200]]
  print(d)   # [0, 1, 2, 3, 4, [999, 200]]
  print(e)   # [0, 1, 2, 3, 4, [100, 200]]  使用 deepcopy 的沒有被改變

index() 取得項目 offset 

index() 函式可以取得串列中某個內容的 offset，如果有多個同樣內容的項目，以第一個找到的為主。

a = ['apple','banana','banana','orange']
print(a.index('banana'))   # 1

len() 取得串列長度 

len() 函式可以取得串列的長度 ( 裡面有幾個項目 )。

a = ['apple','banana','banana','orange']
print(len(a))   # 4

count() 計算內容出現次數 

count() 函式可以計算串列中，某些內容出現的次數。

a = ['apple','banana','banana','orange']
print(a.count('banana'))   # 2
print(a.count('grap'))     # 0

join() 結合串列內容 

join() 函式可以將一個串列裡面所有的項目，串連起來變成一個字串，使用時用一個要接起來的字串，連結要結合的每個項目。

a = ['hello world', 'I am oxxo', 'how are you?']
b = ', '.join(a)  # 使用逗號「,」進行結合
print(b)  # hello world, I am oxxo, how are you?

in 檢查內容是否存在 

透過「元素 in 串列」的方法，可以檢查串列中是否存在某些內容，如果存在則回傳 True，不存在則回傳 False ( 使用「元素 not in 集合」可以判斷不存在 )。

a = ['apple','banana','banana','orange']
print('orange' in a)    # True
print('melon' in a)     # False

比較串列 

使用等號「==」、「!=」，可以比較兩個串列是否相等，使用大於小於符號「<」、「<=」、「>=」、「>」，可以比較串列裡頭「同樣位置」元素的編碼是否相等，注意，串列的比較只能針對「同樣型別」的資料，如果比較數值和字串的內容，就會發生錯誤。

a = [1,2,3,4]
b = [1,2,3,4,5]
c = [4,5,6]
print(a==b)     # False
print(a>=b)     # False
print(a>c)      # False
print(a<c)      # True
print(a<b)      # True
print(a!=b)     # True

使用 ＊ 號重複項目 

使用星號「＊」可以重複串列的內容，使其變成一個新的串列。

a = ['apple','banana']
b = a*3
print(a)   # ['apple', 'banana']
print(b)   # ['apple', 'banana', 'apple', 'banana', 'apple', 'banana']

元組 ( 數組 ) tuple

Python 有兩種序列結構，分別是元組 ( tuple ) 和串列 ( list )，兩種序列都可以將任何一種物件作為它們的元素，這篇教學將會介紹 tuple 的用法與限制 ( tuple 的發音可以唸成 too-pull 也可唸成 tub-pull，中文稱為元組或數組 )。

tuple 與串列 list 的差異 

tuple 和串列非常的類似，都是一個儲存資料的「容器」，可以將物件存入，變成有順序的序列結構，不過 tuple 和串列有以下幾點不同：

• tuple「只要建立了，就不能修改內容」。
• tuple 使用「小括號」，串列 list 使用「方括號」。
• 如果 tuple 裡只有一個元素，後方必須加上「逗號」( 多個元素就不用 )。

使用 tuple 的好處 

雖然 tuple 在使用上有不少限制，但 tuple 也是有一些好處：

• 讀取速度比串列快。
• 佔用的空間比較少。
• 資料更安全 ( 因為無法修改 )。

建立 tuple 

建立 tuple 有兩種方法：「使用小括號和逗號」和「使用 tuple()」。

• 使用小括號和逗號

  透過小括號包覆內容，用逗號將內容隔開，就可以建立一個基本的 tuple，下方的例子，可以看到 a 和 b 的型別都是 tuple ( 注意，因為 b 只有一個元素，所以元素後方要加上逗號 )。

  a = ('apple','banana','orange','grap')
  b = ('apple',)
  type(a)  # tuple
  type(b)  # tuple
  

• 使用 tuple()

  使用「tuple(串列)」可以將串列轉換成 tuple。

  a = ['apple','banana','orange','grap']
  b = tuple(a)
  type(b)  # tuple
  

讀取 tuple 的內容 

讀取 tuple 的內容有兩種方法：「使用變數」、「索引值 offset」。

• 使用變數

  因為 tuple 可以一次賦予多個變數內容，透過這個方法可以一次將項目丟給不同的變數，接著只要讀取變數，就能讀取對應內容 ( 注意，使用這個方法時，變數的數量要等於 tuple 的內容數量 )。

  t = ('apple','banana','orange','grap')
  a, b, c, d = t
  print(a)   # apple
  print(b)   # banana
  print(c)   # orange
  print(d)   # grap
  

• 索引值 offset

  在 tuple 裡每個項目都有自己的索引值 offset，指定 offset 就能讀取該資料的內容。

  t = ('apple','banana','orange','grap')
  print(t[0])   # apple
  print(t[1])   # banana
  print(t[2])   # orange
  print(t[3])   # grap

使用 + 號結合 tuple 

類似字串的結合方式，使用 + 號，可以將不同的 tuple 合併。

t1 = ('apple','banana','orange')
t2 = ('grap','pineapple')
t = t1 + t2
print(t)   # ('apple', 'banana', 'orange', 'grap', 'pineapple')

使用＊號重複項目 

使用＊號，可以將重複一個 tuple 內的所有項目，並產生一個新的 tuple。

a = ('apple','banana','orange')
b = a*3
print(b)   # ('apple', 'banana', 'orange', 'apple', 'banana', 'orange', 'apple', 'banana', 'orange')

強制修改 tuple 

使用串列 list 存取 tuple 資料，修改資料後，再轉換為新的 tuple ( 注意，雖然變數名稱相同，但兩個 tuple 是完全不同的 )。

a = ('apple','banana','orange')
b = list(a)
b.append('grap')
a = tuple(b)
print(a)   # ('apple', 'banana', 'orange', 'grap')

字典 dictionary

字典 ( dictionary )跟串列類似，都能作為儲存資料的容器，可以放入字串、整數、布林、串列或字典，顧名思義就像「查詢用的字典」一樣，透過要查詢的「鍵 key」( 關鍵字 )，就能夠查詢到對應的「值 value」( 解釋說明 )，也是使用頻率相當高的資料型態。

建立字典 

建立字典有兩種方法，建立時必須要包含「鍵 key」和「值 value」兩個項目，鍵在左側，值在右側。

字典和串列的差別在於串列有「順序性」，串列中的項目都有各自的索引值 offset，但字典中的項目沒有順序性，是按照鍵 key 的位置來做紀錄。

• 大括號 {}

  使用大括號建立字典是最常見的建立字典方式，使用方式為「{'鍵':值}」，鍵必須是「字串」，前後必須加上「引號」，值則可以是任意的 Python 物件 ( 字串、數字、串列、字典...等 )，不同鍵值中間使用逗號「,」分隔。

  下方的程式碼，第一個鍵為 name 值為字串 oxxo，第二個鍵為 age 值為數字 18，第三個鍵為 eat 值為串列，最後印出 a 的 type 型別是 dict 字典。

  a = {'name':'oxxo','age':18,'eat':['apple','banana']}
  print(type(a));    # <class 'dict'>
  

  單純只要使用大括號，可以建立一個空的字典。

  a = {}
  print(type(a));   # <class 'dict'>
  

• dict()

  使用 dict() 建立字典使用「dict(鍵=值)」，注意鍵的前後「不需要加上引號」。

  a = dict(name='oxxo', age=18, eat=['apple','banana'])
  print(a)          # {'name': 'oxxo', 'age': 18, 'eat': ['apple', 'banana']}
  print(type(a));   # <class 'dict'>
  

  dict() 函式除了可以建立字典，也可以將有「兩個值的二維串列或 tuple」轉換成字典，轉換時會將第一個值當作鍵，第二個當成值。

  a = [['x','100'],['y','200'],['z','300']]
  b = dict(a)
  print(b)    # {'x': '100', 'y': '200', 'z': '300'}
  

  如果是「雙字元」的字串串列或 tuple，也可以使用 dict() 轉換成字典。

  a = ['ab','cd','ef']
  b = dict(a)
  print(b)    # {'a': 'b', 'c': 'd', 'e': 'f'}

讀取字典 

讀取字典的項目時，有別於串列或 tuple 使用索引值 offset，只要知道字典的鍵，就能讀取對應的值。

• 中括號 []

  使用「字典['鍵']」的方式，就能讀取對應的值，如果讀取到的是串列或 tuple，就可以使用讀取串列或 tuple 的方式取出對應的項目，例如下方程式的變數 c，先取出串列，接著再取出串列的第一個項目。

  a = {'name':'oxxo', 'age':18, 'eat':['apple','banana']}
  b = a['name']
  c = a['eat'][0]
  print(b)   # oxxo
  print(c)   # apple
  

• get()

  使用中括號取值時，如果沒有對應的鍵，就會發生錯誤，如果要避免這種情況，就可以使用 get() 函式來取值，使用方法為「get('鍵')」，如果有鍵就會回傳值，如果找不到鍵，就會回傳 None。

  a = {'name':'oxxo', 'age':18, 'eat':['apple','banana']}
  b = a.get('name')
  c = a.get('school')
  print(b)   # oxxo
  print(c)   # None
  

修改字典 

字典內的所有元素都是可以修改的，修改的方法有兩種：

• 中括號 []

  透過「字典['鍵']=新值」的方式，就能夠將字典中某個鍵對應的值，修改為新的值，下方程式碼將 name 換成 XXXX，age 換成 100。

  a = {'name':'oxxo', 'age':18}
  a['name'] = 'XXXX'
  a['age'] = 100
  print(a)   # {'name': 'XXXX', 'age': 100}
  

  如果修改字典時，鍵不存在於字典中，會直接加入一個新的鍵和值，例如下方程式碼，原本的字典中沒有 ok 這個鍵，所以執行後就會將鍵為 ok 值為 True 的項目加入字典中。

  a = {'name':'oxxo', 'age':18}
  a['name'] = 'XXXX'
  a['age'] = 100
  a['ok'] = True
  print(a) # {'name': 'XXXX', 'age': 100, 'ok': True}
  

• setdefault()

  setdefault() 函式用法和 get() 類似，都是可以取出某個鍵的值，但如果字典中沒有對應的鍵，執行 setdefault() 就會將新的鍵和值加入字典中，使用的方式為「setdefault('鍵',值)」，第二個值只針對「新的鍵」才有作用，下方的程式碼，變數 b 取得的值仍然是 18 ( 因為 a 原本的 age 就是 18 )，但 c 取到 True 之後，字典 a 裡就會加入 ok 為 True 的項目。

  a = {'name':'oxxo', 'age':18}
  b = a.setdefault('age', 100)
  c = a.setdefault('ok', True)
  print(a)   # {'name': 'oxxo', 'age': 18, 'ok': True}
  print(b)   # 18
  print(c)   # True

刪除字典 

刪除字典有三種做法，包含了刪除個別的鍵值，清空個字典或將整個字典移除：

• del

  使用「del 字典['鍵']」可以刪除字典中個別的鍵值，如果使用「del 字典」，則會將整個字典刪除 ( 從記憶體中消失 )，下方程式碼可以看出，刪除了鍵為 name 的字典 a，只剩下 age 一個鍵，不過如果刪除了整個字典 b，讀取 b 時就會發生錯誤。

  a = {'name':'oxxo', 'age':18}
  del a['name']
  print(a)   # {'age': 18}
  
  b = {'name':'oxxo', 'age':18}
  del b
  print(b)   # name 'b' is not defined
  

• pop()

  使用「pop('鍵')」可以將字典中某個鍵「取得並移出」，如果沒有賦值給任何變數，這個鍵值就會刪除，下方程式碼會將 name 從字典 a 中取出並移除，並將 name 賦值給 b ( 注意，有別於串列的 pop() 可為空，字典的 pop('鍵') 操作一定要有鍵，不然會發生錯誤 )。

  a = {'name':'oxxo', 'age':18}
  b = a.pop('name')
  print(a)   # {'age': 18}
  print(b)   # oxxo
  

• clear()

  使用「字典.clear()」可以將字典中所有項目刪除，變成一個空的字典。

  a = {'name':'oxxo', 'age':18}
  a.clear()
  print(a)   # {}
  

結合字典 

如果要將多個字典結合成一個字典，Python 提供兩種方法：

• 兩個星號＊＊

  使用兩個星號「**字典」，會將字典拆解為 keyword arguments 列表，再透過大括號組合，就可以將不同的字典結合為新的字典，下面的程式碼，a、b、c 就會結合成 d。

  a = {'name':'oxxo', 'age':18}
  b = {'weight':60, 'height':170}
  c = {'ok':True}
  d = {**a, **b, **c}
  print(d)   # {'name': 'oxxo', 'age': 18, 'weight': 60, 'height': 170, 'ok': True}
  

• update()

  使用「字典1.update(字典2)」，會將字典 2 的內容與字典 1 結合，下面的程式碼，會將 b 和 c 依序和 a 結合。

  a = {'name':'oxxo', 'age':18}
  b = {'weight':60, 'height':170}
  c = {'ok':True}
  a.update(b)
  a.update(c)
  print(a)   # {'name': 'oxxo', 'age': 18, 'weight': 60, 'height': 170, 'ok': True}
  

取得所有鍵和值 

字典由鍵和值組成，透過「字典.keys()」能夠將所有的鍵取出變成「dict_keys()」，透過「字典.values()」能夠將所有的值取出變成「dict_values()」，兩者都可以透過串列或 tuple 的方法，轉換成串列或 tuple。

a = {'name':'oxxo', 'age':18, 'weight':60, 'height':170}
b = a.keys()
c = a.values()
print(b)         # dict_keys(['name', 'age', 'weight', 'height'])
print(c)         # dict_values(['oxxo', 18, 60, 170])
print(list(b))   # ['name', 'age', 'weight', 'height']
print(list(c))   # ['oxxo', 18, 60, 170]

使用 in 檢查鍵 

in 可以判斷某個鍵是否存在於字典中，使用方法為「鍵 in 字典」，如果字典中存在這個鍵，就會回傳 True，如果不存在，就回傳 Fasle。

a = {'apple':10, 'banana':20, 'orange':30}
print('apple' in a)   # True
print('grap' in a)    # False

複製字典 

Python 提供兩種複製字典的方法：

• copy()

  copy() 可以快速複製一個新的字典，使用方式為「字典.copy()」。

  a = {'x':10, 'y':20, 'z':30}
  b = a.copy()
  print(b)   # {'x': 10, 'y': 20, 'z': 30}
  

• deepcopy()

  copy() 的方法只能針對「項目內容不會發生變化」的字典，如果字典的「深層內容」會發生變化，就會出現奇怪的現象，舉例來說，下方的程式碼執行後，當 a 改變時理應不該影響到 b，但執行結果卻發現 b 的內容也跟著改變了。

  a = {'x':10, 'y':20, 'z':[100,200,300]}
  b = a.copy()
  a['z'][0] = 999
  print(a)   # {'x': 10, 'y': 20, 'z': [999, 200, 300]}
  print(b)   # {'x': 10, 'y': 20, 'z': [999, 200, 300]}
  

  如果要解決這個問題，就必須要 import copy() 模組，使用 deepcopy() 進行深度複製，就能產生一個完全獨立的新串列。

  import copy
  a = {'x':10, 'y':20, 'z':[100,200,300]}
  b = copy.deepcopy(a)
  a['z'][0] = 999
  print(a)   # {'x': 10, 'y': 20, 'z': [999, 200, 300]}
  print(b)   # {'x': 10, 'y': 20, 'z': [100, 200, 300]} 使用 deepcopy 的沒有被改變

集合 set

集合 ( set ) 就像是「只有鍵，沒有值」的字典，一個集合裡所有的鍵都不會重複，因為集合不會包含重複的資料的特性，常用來進行去除重複的字元、或判斷元素間是否有交集、聯集或差集之類的關聯性。

建立集合 

集合由「數字、字串或布林」所組成，同一個集合裡的項目，可以是不同的型別，建立集合有兩種方式：

• set()

  使用 set() 可以建立空集合，或將串列、tuple、字串或字典轉換為集合，使用的方法為「set(要變成集合的元素)」。

  如果建立時出現重複的項目，只會保留一個，如果是字典，只會保留鍵，如果是布林，True 等同 1，False 等同 0。

  a = set()
  b = set([1,2,3,4,5,1,2,3,4,5])
  c = set({'x':1,'y':2,'z':3})
  d = set('hello')
  print(a)   # set()
  print(b)   # {1, 2, 3, 4, 5}  只留下不重複的部分
  print(c)   # {'x', 'y', 'z'}  如果是字典，只保留鍵
  print(d)   # {'l', 'o', 'h', 'e'}  只留下不重複的部分
  

• 大括號 {}

  如果不是空集合，可以使用「{項目}」建立集合 ( 單純寫大括號，會變成「空字典」 )。

  a = {0,1,2,3,'a','b',False}
  print(a)  # {0, 1, 2, 3, 'a', 'b'}  False 等同於 0，所以只保留 0

add() 加入項目 

使用「集合.add(項目)」可以將某個項目加入集合中，下面的程式會將 x 和 y 兩個文字加入 a 集合。

a = {0,1,2,3,4,5}
a.add('x')
a.add('y')
print(a)   # {0, 1, 2, 3, 4, 5, 'x', 'y'}

移除項目 

有兩種方法可以移除集合裡的某個項目：

• remove()

  使用「集合.remove(項目)」，可以將指定的項目移除，不過如果該項目不存在，就會執行錯誤。

  a = {0,1,2,3,'x','y','z'}
  a.remove('x')
  print(a)   # {0, 1, 2, 3, 'y', 'z'}
  

• discard()

  如果不希望在移除項目時發生執行錯誤的狀況，可以使用「集合.discard(項目)」，將指定項目移除

  a = {0,1,2,3,'x','y','z'}
  a.discard('x')
  a.discard('a')   # 不會發生錯誤
  print(a)         # {0, 1, 2, 3, 'y', 'z'}

交集、聯集、差集、對稱差集 

集合有四種運算型態，分別是「交集、聯集、差集、對稱差集」，透過下圖可以了解四種運算型態。

使用集合運算有兩種方法，一種是使用特定的方法，另外一種則是使用「符號」( 集合運算子 )

集合	方法	運算子
交集	a.intersection(b)	a&b
聯集	a.union(b)	a｜b
差集	a.difference(b)	a-b
對稱差集	a.symmetric_difference(b)	a^b

下方的程式，會呈現進行 a 對 b 進行集合運算後的結果。

a = {1,2,3,4,5}
b = {3,4,5,6,7}

# 交集
print(a.intersection(b))   # {3, 4, 5}
print(a&b)                 # {3, 4, 5}
# 聯集
print(a.union(b))          # {1, 2, 3, 4, 5, 6, 7}
print(a|b)                 # {1, 2, 3, 4, 5, 6, 7}
# 差集
print(a.difference(b))     # {1, 2}
print(a-b)                 # {1, 2}
# 對稱差集
print(a.symmetric_difference(b))  # {1, 2, 6, 7}
print(a^b)                        # {1, 2, 6, 7}

子集合、超集合 

假設有 A、B 兩個集合，超集合和子集合的關係可以參考下圖：

集合	說明
超集合	A 完全包含 B，A 和 B 所包含的元素可能完全相同
真超集合	A 完全包含 B，且具有 B 沒有的的元素
子集合	B 完全被 A 包含，A 和 B 所包含的元素可能完全相同
真子集合	B 完全被 A 包含，且 A 具有 B 沒有的的元素

下面的程式列出四個集合，使用「大於、小於、等於」可以呈現彼此的關係，從印出的結果可以看到各個集合之間的關係。

a = {1,2,3,4,5,6,7}
b = {3,4,5,6,7}
c = {1,2,3,4,5,6,7}
d = {6,7,8,9}

print(a<=a)   # True 自己是自己的子集合
print(b<=a)   # True b 是 a 的子集合
print(b<a)    # True b 也是 a 的真子集合 ( 因爲沒有等於，完全包含 )
print(c<=a)   # True c 是 a 的子集合
print(a<=c)   # True a 也是 c 的子集合
print(d<a)    # False d 和 a 沒有子集合或超集合關係

此外，使用「b.issubset(a)」方法可以檢測 b 是否為 a 的子集合、「a.issuperset(b)」方法可以檢測 a 是否為 b 的超集合。

a = {1,2,3,4,5,6,7}
b = {3,4,5,6,7}
c = {1,2,3,4,5,6,7}
d = {6,7,8,9}

print(b.issubset(a))     # True b 是 a 的子集合
print(a.issuperset(b))   # True a 是 b 的超集合
print(c.issubset(a))     # True c 是 a 的子集合
print(d.issubset(a))     # Fasle d 不是 a 的子集合

len() 取得長度 

使用「len(集合)」可以回傳某個集合的長度 ( 有幾個元素 )。

a = {1,2,3,4,5,6,7}
print(len(a))   # 7

in 檢查是否存在 

使用「元素 in 集合」可以檢查集合中是否存在某個元素，如果存在就是 True，不存在就是 False ( 使用「元素 not in 集合」可以判斷不存在 )。

a = {'a','b','c','d',1,2,3}
print('b' in a)    # True
print(2 in a)      # True
print(99 in a)     # False