# 容器(container)
## 一、 為什麼要使用容器？
### 1. 容器的概念
Python 中的容器（Containers）是指各種結構化數據類型。它們就像字面意思，可以用來裝各種東西。
有的容器有標籤，可以利用它快速取出容器裡的東西；有的容器不會儲存重複元素，可以用它得知容器內有哪些種類的物品。
下面介紹常見的四種容器，每個容器都有自己的特色和功能，學起來後就可以根據你的需要去選擇使用哪種容器儲存資料！
### 2. 容器的優點
#### 組織和存儲數據：
容器可以方便地存儲和組織數據，例如列表可以存儲一系列數據，字典可以用於存儲鍵值對，集合可以用於存儲一組唯一的數據等。
#### 容器操作方便：
容器支持許多常用的操作，例如遍歷、查找、排序、合併等，可以大大簡化編程。
#### 支持迭代：
容器支持迭代，可以使用 for 循環遍歷容器中的所有元素，這種方式比使用 while 循環遍歷更加簡潔和易於理解。
#### 可以容納不同類型的數據：
容器可以容納不同類型的數據，例如列表中可以同時存儲數字、字符串、布爾值等不同類型的數據。
#### 可以動態調整大小：
多數容器可以動態調整大小，可以添加、刪除或修改容器中的元素。少數容器無法自行修改元素，例如：元組(tuple)
總之，容器是 Python 編程中非常實用的數據類型，可以大大簡化編程，提高代碼的可讀性和可維護性。
### 3.常見的容器類型和比較
|容器名稱 | 串列(list) | 元組(tuple) | 字典(dictionary) | 集合(set)|
|-------| ---------- | ---------- | --------------- |-------- |
|順序性 | 有 | 有 | 無 | 無|
|可變性 | 有 | 無 | 有 | 有|
## 二、 List 串列
### 1.特色
list就像可以拼接的箱子，每個箱子裡面放入一個元素。
拼接好的箱子會依序由0開始編號，如同下圖所示。
### 2.優點
#### 儲存不同資料型態的元素：
同一個list可以存放像是int、string，或是容器等型態的東西。
```python=1
list1 = [1, 2, 3, "apple", [4, 5, 6] ]
print(list1)
```
#### 有順序：
每個元素都有自己的索引值（index），方便查找元素
#### 可以修改元素：
若想用其他元素取代原先元素，或是想要刪除該元素
### 3.使用方法
#### 3.1宣告
```python=1
#宣告空list： list名稱 = [ ]
list_name = []
#宣告非空的list： list名稱 = [元素1,元素2, ...]
list_name = ["string", 'c', 123]
```
#### 3.2修改元素
```python=1
List [ index ] = value #修改單個元素：
List[index_start : index_end ] = value1 , value2 , … #修改多個元素
```
#### 3.3取得元素
##### 索引值
* Index不小於零的表示方法：索引值從0開始，第一個元素index=0，第二個元素index=1⋯⋯第n個元素index=n-1。N個元素的index值從頭到尾分別是： 0 , 1 , 2 , 3 , … , n-1
* Index小於零的表示方法：最後一個元素的索引值為 -1，倒數第二個元素的索引值為 -2。N個元素的index值從頭到尾分別是： -n , -(n-1) , … ,-3 , -2 , -1
##### 索引切片運算
```python=1
[m:n:k] #取出索引值為m到索引值為n-1的元素。
```
* m代表切片範圍的最小索引值位置，若m為空則默認為從索引值0開始。
* n代表切片範圍的最大索引值位置的下一個索引值，最多取到index = n-1 的元素，若n為空則默認到最後，包含最後一個元素。
* k代表間隔。「[ : : 2]」會取出索引值為0、2、4 …的元素；「[ : : -1 ]」會反轉容器內元素再按順序取出，依序為索引值為 -1、-2、-3、 …。若k為空則默認為1。
> 範例
```python=1
list1 = [1,2,3,4,5]
Print( list1 [ : ] )
Print( list1 [ 1 : 4 ] ) #會印出索引值為1到索引值為3的list1
Print( list1 [ : -1 ] ) #會印出索引值為0到索引值為 -2的list1
Print( list1 [ -3: -1] ) #會印出索引值為-3到索引值為-2的list1
```
> 輸出
```python=1
[1,2,3,4,5]
[2,3,4]
[1,2,3,4]
[3,4]
```
##### 取得元素
* 取出單個元素：List[n]可以取出第n+1個元素。
* 取出特定範圍元素：List[m:n]可以取出索引值為m到索引值為n-1的元素。
#### 3.4常見函式
> append(x)：將x增加到list的最後方
```python=1
list1=[1,2,3]
#若X為元素：直接增加在最後方
list1.append(4)
print(list1)
#若X為list：在目標list最後一個index的空間存放完整的X
list1.append( [5,6,7] )
print(list1)
```
> 輸出
```python=1
[1, 2, 3, 4]
[ 1, 2, 3, 4, [ 5, 6, 7]]
```
> extend(x)：將x增加到list的最後方
* X為元素：直接增加在最後方
* X為list：將X list內所有元素一個一個放到目標list後方。例如：
```python=1
list1=[1,2,3]
#若X為元素：直接增加在list1最後方
list1.extend(4)
print(list1)
#若X為list：將x內所有元素一個一個放到list1後方。
list1.extend( [5,6,7] )
print(list1)
```
> 輸出
```python=1
[1, 2, 3, 4]
[ 1, 2, 3, 4, 5, 6, 7]
```
> insert(n, x)：在索引值為n的位置插入x元素
```python=1
list1 = [1, 2, 3]
# 在第二個位置插入4
list1.insert(1, 4)
print(list1)
```
> 輸出
```python=1
[1, 4, 2, 3]
```
> pop()：pop()：從list內彈出最後一個元素
```python=1
list1 = [1, 2, 3]
#彈出最後一個元素
list1.pop()
print(list1)
```
> 輸出
```python=1
[1, 2]
```
> pop(n)：從list內彈出指定位置（索引值為n）的元素
```python=1
list1 = [1, 2, 3, 4]
#彈出第二個元素
list1.pop(1)
print(list1)
```
> 輸出
```python=1
[1, 3, 4]
```
> remove(x)：從list內移除第一次出現值為x的元素。
```python=1
list1 = [1, 2, 3, 2]
#移除第一個出現的2
list1.remove(2)
print(list1)
```
> 輸出
```python=1
[1, 3, 2]
```
> reverse()：反轉list內順序
```python=1
list1 = [1, 2, 3]
#反轉順序
list1.reverse()
print(list1)
```
> 輸出
```python=1
[3, 2, 1]
```
> sort()：將list內元素由小到大重新排列。
```python=1
list1 = [3, 1, 2]
# 由小到大重新排列
list1.sort()
print(list1)
```
> 輸出
```python=1
[1, 2, 3]
```
> index(x)：取得list中元素等於x的第一個索引值。
```python=1
list1 = [1, 2, 3, 2]
# 取得2第一次出現的索引值
index = list1.index(2)
print(index)
```
> 輸出
```python=1
1
```
> len()：查詢元素個數
```python=1
list1 = [1, 2, 3]
# 查詢元素個數
count = len(list1)
print(count)
```
> 輸出
```python=1
3
```
> min(list)：取得list中最小數值，前提是list中元素全部都為int型態。
```python=1
list1 = [1, 2, 3]
# 取得最小數值
min_num = min(list1)
print(min_num)
```
> 輸出
```python=1
1
```
> max(list)：取得list中最大數值，前提是list中元素全部都為int型態。
```python=1
list1 = [5, 2, 9, 1, 7]
max_value = max(list1)
print(max_value)
```
> 輸出
```python=1
9
```
> count(n)：計算n在list內出現次數。
```python=1
list1 = [1, 2, 3, 2, 4, 2]
count = list1.count(2)
print(count)
```
> 輸出
```python=1
3
```
### 4.應用
1. 順序排列
```python=1
# 排序一組數據
data = [4, 2, 7, 5, 1, 3, 6]
data.sort()
print(data) # [1, 2, 3, 4, 5, 6, 7]
```
## 三、 Tuple 數組
### 1. 特色
Tuple不可以刪除或更改元素的值，只能刪除所有元素。建立tuple就像把內容刻在石碑上一樣，一旦完成就無法修改。
裡面的內容也會有順序之分
### 2. 優點
#### 保障資料安全：
可以保證 Tuple 內的元素在使用過程中不會被意外更改，使其更可靠、更安全。
#### 佔用內存少：
Tuple在使用上佔用的內存比一般的容器少，是因為Tuple是immutable（不可變）的容器，一旦建立後其內容就無法再被修改，因此Python不需要為了支援修改的操作而保留額外的內存空間。相較之下，list是mutable（可變）的容器，需要保留額外的內存空間以支援新增、刪除等操作。
此外，Tuple也不需要像list一樣保留動態增長的空間，因為Tuple一旦建立後，其元素數量就不會再變化。而list需要保留額外的動態增長空間，以便在容器需要增加元素時可以快速擴展。
#### 高效率：
Tuple 被儲存在連續的內存位置上，而且一旦建立，其大小和結構不會改變。這使得 Tuple 的存取速度非常快，甚至比 List 還快，因為 List 的元素可以隨時被更改，導致在存取時需要額外的計算和記憶體空間。
#### 有順序性：
每個元素都有自己的索引值（index），方便查找元素。
#### 可以儲存不同資料型態的元素：
像是int、string，或是其他list、tuple
### 3.使用方法
#### 3.1 宣告
注意宣告單一元素tuple時，後面必須加上逗號。若沒有逗號，所宣告的型態會是「元素1」的資料型態，而非一個tuple。
```python=1
#宣告空tuple
tuple名稱 = ()
#宣告單一元素tuple
tuple名稱 = (元素1,) #有逗號
#宣告多個元素的tuple
tuple名稱 = (元素1,元素2, …..)
tuple名稱 = 元素1 , 元素2 …….
```
#### 3.2 新增元素
不能使用list所用的append和insert，利用tuple和另一個tuple連接來新增元素。
* 加入單一元素： tuple名稱 += ( 元素1 ,)
> 範例
```python=1
tuple1 = (1, 2, 3)
tuple1 += (4,)
print(tuple1)
```
> 輸出
```python=1
(1, 2, 3, 4)
```
* 加入多個元素： tuple名稱 += ( 元素1 , 元素2 , … , 元素n )
> 範例
```python=1
tuple2 = (1, 2, 3)
tuple2 += (4, 5, 6)
print(tuple2)
```
> 輸出
```python=1
(1, 2, 3, 4, 5, 6)
```
**需要注意的是，使用 += 加入元素後，原本的tuple不會被改變，而是創建一個新的tuple，因此在記憶體使用上需要額外注意。**
#### 3.3 取得元素
(1) 利用索引值取出單個元素：tuple[n]可以取出第n+1個元素。
> 範例：
```python=1
t1 = (1, 2, 3, 4, 5)
print(t1[2])
```
> 輸出
```python=1
3 # 因為索引值為2的元素為3
```
(2) 利用所印值取出多個元素：tuple[m:n]可以取出索引值為m到索引值為n-1的元素。
> 範例
```python=1
t1 = (1, 2, 3, 4, 5)
print(t1[1:4])
```
> 輸出
```python=1
(2, 3, 4) # 因為索引值為1到3的元素為2, 3, 4
```
(3) 利用變數取出元素，稱作**開箱（unpacking）**
> 範例
```python=1
tuple1 = ‘abc’ , ’def’ , ‘ghi’
a , b , c = tuple1
print(a)
```
> 輸出
```python=1
‘abc’
```
輸出結果會是 ’abc’，因為變數a代表tuple1的第一個元素。因此，若改成print(b)則輸出 ’def’
#### 3.4 常見函式
> Tuple(list名稱)：把list內元素存在tuple內
```python=1
list1 = [1, 2, 3]
t1 = tuple(list1)
print(t1)
```
> 輸出
```python=1
(1, 2, 3)
```
> Tuple(string名稱)：把string內每個字存在tuple內
```python=1
str1 = "Hello, world!"
t2 = tuple(str1)
print(t2)
```
> 輸出
```python=1
('H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!')
```
> Index()：index(x) 取得tuple中元素等於x的第一個索引值。
```python=1
t1 = (1, 2, 3, 2)
index = t1.index(2)
print(index)
```
> 輸出
```python=1
1
```
> Len()：取得tuple內元素數量
```python=1
t1 = (1, 2, 3, 2)
length = len(t1)
print(length)
```
> 輸出
```python=1
4
```
> Del()：del(tuple) 刪除整個tuple
```python=1
t1 = (1, 2, 3)
del t1
print(t1) # 會出現NameError: name 't1' is not defined，因為t1已被刪除
```
> 輸出
```python=1
# 會出現NameError: name 't1' is not defined，因為t1已被刪除
```
### 4. 應用
#### 4.1 字典的鍵
tuple儲存的元素可以作為字典的鍵值，以下為幾個原因：
* Tuple 是不可變的：字典的鍵值必須是不可變的，這是因為字典在內部使用哈希表來實現，哈希表中的鍵值必須是不可變的才能被哈希，而 Tuple 是不可變的，所以 Tuple 可以作為字典的鍵值。
* Tuple 可以被比較：Tuple 可以被比較，這意味著你可以對字典中的鍵值進行排序和查找。Tuple 的比較方式是從左到右逐個比較元素，直到找到不同的元素為止。
* Tuple 可以包含多個元素：Tuple 可以包含多個元素，這意味著你可以使用多個值作為一個鍵值，比如下面的例子中，我們使用一個包含兩個元素的 Tuple 作為字典的鍵值，這樣可以方便地表示一個人的姓名和年齡。
> 範例
```python=1
#利用包含名稱和年齡的tuple作為字典的鍵
my_dict = {('John', 30): 'Software Engineer'}
print(my_dict[('John', 30)])
```
> 輸出
```python=1
Software Engineer
```
#### 4.2 保護代碼
```python=1
# 保護代碼
# 如果你有一個常數列表，你希望在整個程序中保護它不被修改
MY_CONSTANTS = (1, 2, 3, 4)
```
#### 4.3 不可變數據結構
Tuple 是不可變的，一旦被創建，就不能被修改，這使得 Tuple 可以用於表示不可變的數據結構，比如日期、時間等：
```python=1
# 不可變數據結構
t = (1, 2, 3)
# t[0] = 4 # TypeError: 'tuple' object does not support item assignment
birthday = (1990, 1, 1) # 不可變的生日日期
```
#### 4.4 多個值的打包與解包
Tuple 可以用於把多個值打包成一個值，在需要的時候再進行解包，比如多個變量賦值：
> 範例
```python=1
# 打包與解包
t = (1, 2, 3)
a, b, c = t # 解包
print(a, b, c)
x = 4
y = 5
z = 6
t = x, y, z # 打包
print(t)
```
> 輸出
```python=1
1 2 3
(4, 5, 6)
```
#### 4.5 函數返回多個值
Tuple 可以用於函數返回多個值，比如：
> 範例
```python=1
# 函數返回多個值
def get_name_and_age():
name = 'Alice'
age = 25
return name, age
name, age = get_name_and_age()
print(name, age)
```
> 輸出
```python=1
Alice 25
```
## 四、 Dictionary 字典
### 1. 特色
元素包含**鍵（key）和值（value）**，key和value的關係就像圖片中的鑰匙和門。但value並不是門，而是門後空間裡所放的東西。
鍵是唯一的，值不是唯一的。Key通常是int或string的型態；Value可以是任何的資料型態，像是int、string，或是其他list、tuple,dictionary…
### 2. 優點
#### 快速查找和存取：
Dictionary 的儲存方式是使用 key 來索引對應的 value。獨一無二的key讓搜尋、查找和存取資料變得非常快速，特別是當資料量很大時，dictionary 可以大幅提升效率。
#### 可變容器：
Dictionary 是一種可變容器，可以隨時新增、修改或刪除資料。這種特性可以讓資料庫或網路應用程式更容易的應對實際的需求。
#### 擴充性：
Dictionary 支援多層嵌套，也就是說可以在一個 dictionary 中儲存另一個 dictionary，這種擴充性可以讓 dictionary 更容易地應對複雜的資料結構和需求。
#### 節省記憶體：
Dictionary 可以避免使用大量的變數或 list 等容器來儲存資料，這可以節省記憶體的使用，提升程式效能。特別是在處理大量資料時，dictionary 可以大幅降低程式的記憶體需求。
在下面的程式中，我們創建了一個 dictionary scores，並儲存了學生的名字和分數。接著，我們使用 for 迴圈來遍歷 scores 中的所有分數，計算學生的總分，最後再除以學生的總數來得到平均分數。
這個程式使用 dictionary 來儲存學生的資料，這樣可以避免創建多個變數或 list 來儲存學生的名字和分數。這樣可以大幅節省記憶體的使用，特別是在處理大量資料時，使用 dictionary 可以顯著提升程式的效能。
> 範例
```python=1
# 創建一個字典來儲存學生的名字和分數
scores = {'John': 90, 'Mary': 85, 'Tom': 92, 'Jane': 88}
# 計算學生的總分和平均分數
total = 0
for score in scores.values():
total += score
average = total / len(scores)
# 輸出平均分數
print("Average score: ", average)
```
> 輸出
```python=1
88.75
```
### 3.使用方法
#### 3.1 宣告
```python=1
#方法1
dictionary名稱 = { key1: value1 , key2: value2}
#方法2
dictionary [key] = value #此做法也可以用來修改dictionary中的元素
```
#### 3.2 取得元素
一維取值
```python=1
dictionary[key]
```
二維取值
```python=1
#key1是最外層dictionary的key值，key2是內層dictionary的key值=1
Dictionary[key1][key2]
#key1是最外層dictionary的key值，內層dictionary可以用index值來取得value
Dictionary[key1][index]
```
#### 3.3 函式（以下dict作為一個dictionary名稱）
> del dict[key]：刪除dictionary裡的key和對應的value
```python=1
dict1 = {1: "apple", 2: "banana", 3: "cherry"}
del dict1[2]
print(dict1)
```
> 輸出
```python=1
{1: "apple", 3: "cherry"}
```
> del(dict)：刪除整個dictionary
```python=1
dict2 = {1: "apple", 2: "banana", 3: "cherry"}
del dict2
print(dict2)
```
> 輸出
```python=1
# 結果不存在，回傳 NameError: name 'dict2' is not defined
```
> clear()：清空整個dictionary
```python=1
dict3 = {1: "apple", 2: "banana", 3: "cherry"}
dict3.clear()
print(dict3)
```
> 輸出
```python=1
{}
```
> get()：get(key) 在dictionary內搜尋key所對應的value。若找不到該key，則回傳None
```python=1
dict4 = {1: "apple", 2: "banana", 3: "cherry"}
print(dict4.get(2))
print(dict4.get(4))
```
> 輸出
```python=1
"banana"
None
```
> len()：取得元素個數
```python=1
dict5 = {1: "apple", 2: "banana", 3: "cherry"}
print(len(dict5))
```
> 輸出
```python=1
3
```
> key()：取得所有key
```python=1
dict6 = {1: "apple", 2: "banana", 3: "cherry"}
print(dict6.keys())
```
> 輸出
```python=1
dict_keys([1, 2, 3])
```
> values()：取得所有value
```python=1
dict7 = {1: "apple", 2: "banana", 3: "cherry"}
print(dict7.values())
```
> 輸出
```python=1
dict_values(["apple", "banana", "cherry"])
```
> items()：取得所有元素，包含key和value
```python=1
dict8 = {1: "apple", 2: "banana", 3: "cherry"}
print(dict8.items())
```
> 輸出
```python=1
dict_items([(1, "apple"), (2, "banana"), (3, "cherry")])
```
### 4.應用
#### 4.1 存儲鍵值對
dictionary 是一種鍵值對存儲結構，它可以用來存儲一個物件或數據的相關信息。例如，可以使用 dictionary 存儲一個人的基本信息，例如姓名、年齡、性別等。
> 範例
```python =1
# 存儲一個人的基本信息
person = {'name': 'John', 'age': 30, 'gender': 'Male'}
print(person['name'])
print(person['age'])
print(person['gender'])
```
> 輸出
```python =1
'John'
30
'Male'
```
#### 4.2 頻率統計
dictionary 可以用於對數據中的頻率進行統計。例如，可以使用 dictionary 統計一個字符串中每個字符出現的頻率，或統計一個列表中每個元素出現的次數。
> 範例
```python=1
# 統計一個字符串中每個字符出現的頻率
s = 'hello world'
freq = {}
for char in s:
freq[char] = freq.get(char, 0) + 1
print(freq)
```
> 輸出
```python=1
{'h': 1, 'e': 1, 'l': 3, 'o': 2, ' ': 1, 'w': 1, 'r': 1, 'd': 1}
```
#### 4.3 計數器
dictionary 可以用作計數器，以計算一個事件發生的次數。例如，可以使用 dictionary 計算一個網站的訪問次數，或計算一個商品的銷量。
> 範例
```python=1
# 計算一個網站的訪問次數
visits = {}
def visit_page(url):
visits[url] = visits.get(url, 0) + 1
visit_page('https://www.google.com')
visit_page('https://www.facebook.com')
visit_page('https://www.google.com')
print(visits)
```
> 範例
```python=1
{'https://www.google.com': 2, 'https://www.facebook.com': 1}
```
#### 4.4 配置文件（補充）
dictionary 可以用作配置文件，以存儲程序的配置信息。例如，可以使用 dictionary 存儲一個網站的設置信息，例如網站名稱、網站 URL、網站樣式等。
> 範例
```python=1
# 存儲一個網站的設置信息
config = {
'site_name': 'My Website',
'site_url': 'https://www.example.com',
'theme': 'light',
'font_size': 16
}
print(config['site_name'])
print(config['theme'])
```
> 輸出
```python=1
'My Website'
'light'
```
#### 4.5 模板替換（補充）
dictionary 可以用於模板替換，以替換模板中的變量。例如，可以使用 dictionary 將一個包含變量的字符串模板替換為具體的數據。
> 範例
```python=1
# 使用 dictionary 將一個包含變量的字符串模板替換為具體的數據
template = 'Welcome {name} to {site}!'
data = {'name': 'John', 'site': 'My Website'}
message = template.format(**data)
print(message)
```
> 輸出
```python=1
'Welcome John to My Website!'
```
## 五、 Set 集合
### 1. 特色
set不包含重複元素且沒有順序性，就像多拉ㄟ夢的百寶袋一樣，若宣告重複元素到set中，set會自動刪除，相同元素只保留一個
**沒有順序，無法使用index取值。若要利用index取值，則要先將set轉換成list**
> 範例
```python=1
# 創建一個set
my_set = {1, 2, 3, 4, 5}
# 將set轉換為list
my_list = list(my_set)
# 印出轉換後的list
print(my_list)
```
> 輸出
```python=1
[1, 2, 3, 4, 5]
```
### 2. 優點
#### 沒有重複元素：
當在一個Set中添加重複元素時，只會保留一個元素，其它的都會被自動刪除，這樣可以避免重複元素對後續操作造成的干擾。
當我們需要去除列表中的重複元素時，可以使用Set來實現，只需要把列表轉換成Set，再轉換回列表即可。
> 範例
```python=1
# 創建一個包含重複元素的列表
my_list = [1, 2, 3, 3, 4, 4, 5]
# 將列表轉換為set
my_set = set(my_list)
# 印出set中的所有元素
print(my_set)
```
> 輸出
```python=1
(1, 2, 3, 4, 5)
```
#### 集合運算：
Set支持許多集合運算，例如聯集、交集、差集等等。這些集合運算可以方便地實現多個集合之間的比較和操作。
* 聯集：兩個集合出現過的所有元素
(圖片來源：維基百科)
* 交集：兩個集合都有的元素
(圖片來源：維基百科)
* 差集：某集合擁有，但另一個集合沒有的元素。
(圖片來源：https://www.newton.com.tw/wiki/補集)
#### 支持多種元素類型：
Set中可以存儲任意類型的元素，例如數字、字符串、元組等等，而且不同類型的元素可以混合存儲在同一個Set中。
> 範例
```python=1
my_set = set() # 建立一個空的set
# 增加元素到set
my_set.add("apple")
my_set.add(3)
my_set.add(3.14)
my_set.add(True)
print(my_set)
```
> 輸出
```python=1
{True, 3.14, 3, 'apple'}
```
### 3. 使用方法
#### 3.1宣告
```python=1
#宣告空集合
set名稱 = set() #注意不能用「set名稱={}」來宣告空集合，不然路被判定為空dictionary
#宣告有元素的集合
set名稱 = { 元素1 , 元素2 , … }
```
#### 3.2函式
> add()：新增元素
```python=1
# 建立一個空的Set
my_set = set()
# 使用add()新增元素
my_set.add(1)
my_set.add('apple')
my_set.add(True)
# 顯示Set中的元素
print(my_set)
```
> 輸出
```python=1
{1, 'apple', True}
```
> remove()：刪除元素
```python=1
# 建立一個Set
my_set = {1, 2, 3, 'apple', 'banana'}
# 使用remove()刪除元素
my_set.remove(2)
my_set.remove('banana')
# 顯示Set中的元素
print(my_set)
```
> 輸出
```python=1
{1, 3, 'apple'}
```
> len()：回傳元素個數
```python=1
# 建立一個Set
my_set = {1, 2, 3, 'apple', 'banana'}
# 使用len()回傳元素個數
print(len(my_set))
```
> 輸出
```python=1
5
```
> min()：回傳最小值。前提是set內所有元素皆為數字型態
```python=1
# 建立一個Set
my_set = {10, 5, 20, 15, 30}
# 使用min()回傳最小值
print(min(my_set))
```
> 輸出
```python=1
5
```
> max()：回傳最大值。前提是set內所有元素皆為數字型態
```python=1
# 建立一個Set
my_set = {10, 5, 20, 15, 30}
# 使用max()回傳最大值
print(max(my_set))
```
> 輸出
```python=1
30
```
> sum()：回傳總和。前提是set內所有元素皆為數字型態
```python=1
# 建立一個Set
my_set = {10, 5, 20, 15, 30}
# 使用sum()回傳總和
print(sum(my_set))
```
> 輸出
```python=1
80
```
> union()：回傳聯集
```python=1
# 定義集合 A 和集合 B
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}
# 集合聯集
union_set = A.union(B)
print(union_set)
# 使用運算子也可以達到相同的效果
union_set2 = A | B
print(union_set2)
```
> 輸出
```python=1
{1, 2, 3, 4, 5, 6, 7, 8}
{1, 2, 3, 4, 5, 6, 7, 8}
```
> intersection()：回傳交集
```python=1
# 定義集合 A 和集合 B
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}
# 集合交集
intersection_set = A.intersection(B)
print(intersection_set)
# 使用運算子也可以達到相同的效果
intersection_set2 = A & B
print(intersection_set2)
```
> 輸出
```python=1
{4, 5}
{4, 5}
```
> difference()：回傳差集
```python=1
# 定義集合 A 和集合 B
A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}
# 集合差集
difference_set = A.difference(B)
print(difference_set)
# 使用運算子也可以達到相同的效果
difference_set2 = A - B
print(difference_set2)
```
> 輸出
```python=1
{1, 2, 3}
{1, 2, 3}
```
### 4. 應用
#### 4.1 重複元素刪除
使用set可以輕鬆地從列表中刪除重複的元素。例如：
```python=1
my_list = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
my_set = set(my_list)
unique_list = list(my_set)
print(unique_list) # 輸出結果：[1, 2, 3, 4]
```
#### 4.2 成員測試
使用set可以很容易地檢查一個元素是否在集合中。例如：
```python=1
my_set = set([1, 2, 3, 4, 5])
if 3 in my_set:
print("3在集合中")
else:
print("3不在集合中")
```
#### 4.3 數學運算
set支援數學運算，例如聯集、交集、差集等。例如：
```python=1
set1 = set([1, 2, 3, 4, 5])
set2 = set([3, 4, 5, 6, 7])
union_set = set1 | set2 # 聯集
intersect_set = set1 & set2 # 交集
diff_set = set1 - set2 # 差集
print(union_set) # 輸出結果：{1, 2, 3, 4, 5, 6, 7}
print(intersect_set) # 輸出結果：{3, 4, 5}
print(diff_set) # 輸出結果：{1, 2}
```
#### 4.4 字符串處理
使用set可以快速地判斷一個字符串是否包含重複的字符。例如：
```python=1
word = "hello"
if len(set(word)) == len(word):
print("沒有重複的字符")
else:
print("有重複的字符")
```
# 練習題
## 是非題
> 1. 宣告list時，必須使用方括號將元素包含起來。
正確答案： 是。
解析：在Python中，宣告list時必須使用方括號，例如：[1, 2, 3]。
> 2. 一個list中可以同時包含不同資料類型的元素。
正確答案： 是。
解析：list可以包含不同資料類型的元素，例如：[1, "hello", True]。
> 3. 修改list中的元素是合法的操作。
正確答案： 是。
解析：list是可變的資料類型，可以通過索引修改其中的元素。
> 4. 在list中，元素的索引從1開始。
正確答案： 否。
解析：list和tuple一樣，元素的索引從0開始。
> 5. list的元素可以被刪除。
正確答案： 是。
解析：list是可變的資料類型，可以使用del關鍵字刪除其中的元素。
> 6. 使用方括號宣告list時，必須使用逗號將元素分開。
正確答案： 是。
解析：在宣告list時，必須使用逗號將元素分開，即使只有一個元素也要加上逗號，例如：[1, ]。
> 7. 宣告list時，必須使用圓括號將元素包含起來。
正確答案： 否。
解析：在Python中，宣告list時必須使用方括號，而不是圓括號。
> 8. 如果忘記宣告list，Python會拋出NameError。
正確答案： 否。
解析：如果忘記宣告list，Python會拋出SyntaxError。
> 1. 一個tuple中可以同時包含不同資料類型的元素
正確答案： 是。
解析：tuple可以包含不同資料類型的元素，例如：(1, "hello", True)。
> 2. 宣告tuple時，必須使用方括號將元素包含起來。
正確答案： 否。
解析：在Python中，宣告tuple時必須使用圓括號，而不是方括號。
> 3.修改tuple中的元素是合法的操作。
正確答案： 否。
解析：tuple是不可變的資料類型，一旦創建了tuple，就無法修改其中的元素。
> 4. 在tuple中，元素的索引從0開始。
正確答案： 是。
解析：tuple和list一樣，元素的索引從0開始。
> 5. 使用tuple時，必須使用逗號將元素分開。
正確答案： 是。
解析：在宣告tuple時，必須使用逗號將元素分開，即使只有一個元素也要加上逗號，例如：t = (1, )。
> 6. tuple的元素可以被刪除。
正確答案： 否。
解析：tuple是不可變的資料類型，一旦創建了tuple，就無法刪除其中的元素。
> 7. 使用tuple時，可以使用list的方法。像是append()等函式。
正確答案： 否。
解析：tuple和list是不同的資料類型，它們有自己的方法。
> 1. set中的元素可以重複。
正確答案：否
解析：set中的元素不會重複，每個元素在set中只會出現一次。
> 2. set支持下標索引。
正確答案：否
解析：set是無序的集合，不支持下標索引。
> 3. 可以使用len()函數來獲取set中元素的數量。
正確答案：是
解析：可以使用len()函數來獲取set中元素的數量。
> 4. set支持添加元素的操作。
正確答案：是
解析：可以使用add()方法向set中添加元素。
> 5. set支持刪除元素的操作。
正確答案：是
解析：可以使用remove()方法刪除set中的元素。
> 6. set支持按值排序。
正確答案：否
解析：set是無序的集合，不支持按值排序。
> 7. 可以使用in關鍵字來判斷元素是否在set中。
正確答案：是
解析：可以使用in關鍵字來判斷元素是否在set中。
> 8. set支持嵌套。
正確答案：否
解析：set中只能包含不可變的元素，不能嵌套其他集合類型。
> 9. set可以進行數學運算，如聯集、交集、差集等。
正確答案：是
解析：set可以進行數學運算，例如可以使用|運算符實現聯集，&運算符實現交集，-運算符實現差集等。
## 選擇題
> 下列哪一個符號可以用來建立一個 dictionary？
> A. []
> B. ()
> C. {}
> D. //
答案：C
解析：大括號 {} 可以用來建立一個 dictionary，括號內包含 key 和 value，以冒號 : 隔開每一對 key 和 value。
> 下列哪一個函式可以用來判斷一個 key 是否在一個 dictionary 中？
> A. in()
> B. append()
> C. pop()
> D. insert()
答案：A
解析：使用 in() 函式可以判斷一個 key 是否在一個 dictionary 中。
> 下列哪一個方法可以用來獲取一個 dictionary 中所有的 keys？
> A. keys()
> B. values()
> C. items()
> D. append()
答案：A
解析：使用 keys() 方法可以獲取一個 dictionary 中所有的 keys。
> 下列哪一個方法可以用來獲取一個 dictionary 中所有的 values？
> A. keys()
> B. values()
> C. items()
> D. append()
答案：B
解析：使用 values() 方法可以獲取一個 dictionary 中所有的 values。
> 下列哪一個方法可以用來獲取一個 dictionary 中所有的 key-value 配對？
> A. keys()
> B. values()
> C. items()
> D. append()
答案：C
解析：使用 items() 方法可以獲取一個 dictionary 中所有的 key-value 配對。
> 下列哪一個方法可以用來刪除一個 dictionary 中指定的 key-value 配對？
> A. delete()
> B. remove()
> C. pop()
> D. discard()
答案：C
解析：使用 pop() 方法可以刪除一個 dictionary 中指定的 key-value 配對。
> 下列哪一個方法可以用來清空一個 dictionary？
> A. clear()
> B. empty()
> C. delete()
> D. remove()
答案：A
解析：使用 clear() 方法可以清空一個 dictionary。
> 下列哪一個符號可以用來修改一個 dictionary 中已有的 value？
> A. []
> B. ()
> C. {}
> D. //
答案：A
解析：使用中括號 [] 可以修改一個 dictionary 中已有的 value，只需要指定要修改的 key 即可。
> 下列哪一個方法可以用來複製一個 dictionary？
> A. copy()
> B. clone()
> C. duplicate()
> D. replicate()
答案：A
解析：使用 copy() 方法可以複製一個 dictionary。
> 下列哪一個方法可以用來新增一個 key-value 配對到一個 dictionary 中？
> A. push()
> B. add()
> C. insert()
> D. update()
答案：D
解析：使用 update() 方法可以新增一個 key-value 配對到一個 dictionary 中。如果 key 已經存在
## 實作題
> 問題
寫一個Python程式，將兩個整數列表 list1 和 list2 合併成一個新的列表 merged_list，並將 merged_list 中的所有元素按照從小到大的順序排列。
使用者可以輸入兩行數字測資，然後進行此功能。
```
提示：可以使用for迴圈去遍歷容器內的所有元素，進行比較等功能。
以下是for迴圈的語法：
for var in sequence:
statements
以下是一個簡單的 for 迴圈的範例：
numbers = [1, 2, 3, 4, 5]
for n in numbers:
print(n)
在這個例子中，我們定義了一個列表 numbers，並使用 for 迴圈遍歷其中的元素。在每次迭代中，我們從列表中取出一個元素，並將其賦值給變數 n，然後打印出 n 的值。這樣，我們就可以依次打印出列表中的所有元素。
```
> 範例測資
5 3 8
2 6 1
> 範例輸出
```
[1, 2, 3, 5, 6, 8]
```
> 參考解答
```python =1
# 使用者輸入兩行數字測資，每行以空格分隔數字，並將其轉換為整數列表
list1 = [int(x) for x in input().split()]
list2 = [int(x) for x in input().split()]
# 將兩個列表合併
merged_list = []
for x in list1:
merged_list.append(x)
for x in list2:
merged_list.append(x)
# 對合併後的列表進行排序
for i in range(len(merged_list)):
for j in range(i+1, len(merged_list)):
if merged_list[i] > merged_list[j]:
merged_list[i], merged_list[j] = merged_list[j], merged_list[i]
# 輸出結果
print(merged_list)
```
> 解析
這個程式碼中，我們使用了兩個 for 迴圈，將 list1 和 list2 兩個列表合併成一個新的列表 merged_list。然後，我們使用兩個嵌套的 for 迴圈來對 merged_list 列表中的元素進行排序。在排序過程中，我們使用了兩個索引 i 和 j，來遍歷所有的元素，並比較它們的大小，如果發現前一個元素比後一個元素大，就交換它們的位置。
最後，我們輸出排序後的列表 merged_list，即得到了最終的結果。
Sign in with Wallet
Connect another wallet