# 5. 陣列 (字串、串列、元組)

在Python中，陣列大致分為3種形式：

* 字串【str】
* 串列【list】：可變動陣列(可簡單刪改內容)
* 元組【tuple】：不可變動陣列(無法簡單刪改內容)

## I. 陣列共通的概念

### A. 何謂陣列

陣列其實就是由一串相連在一起的變數所構成

![](https://i.imgur.com/VgMmod5.png)

* 陣列需要取名稱
* 陣列中的每一格都有專屬編號(索引)
* **陣列索引值由0開始**

### B. 為何需要陣列

之前我們所學的資料儲存方式都是利用變數\
&#x20;每當我們需要一個變數我們都得宣告一次\
&#x20;但倘若哪天我們有上千上萬筆資料空間需求時呢?\
&#x20;除了要大量宣告變數外，變數命名也是非常令人頭疼的事\
&#x20;(例如：a1 = 0, a2 = -2, .... , a100 = 10) 是不是很容易命名到手軟呢\~\
\
&#x20;這時候若能利用陣列來儲存，那就能避免大量變數命名的痛苦了

### C. 陣列的宣告與賦值

#### 字串

```python
s = "我是字串" # 字串的表示方式為：" " 或' '
```

![](https://1394144544-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-Ma3iO86k0kEA04rPhPo%2F-MaiXo_d2DkeEFlZa9Jy%2F-Maiajd6xmzKVT3l7R_s%2Fimage.png?alt=media\&token=5bd9f4da-c2aa-4ada-8657-bf6aa3bfa8e6)

#### 串列

空串列

```python
li = [] # []
```

```python
li = list() # []
```

被賦值的串列

```python
li = list(('USA', 'DE', 'TW')) # ['USA', 'DE', 'TW']
```

```python
li = ["USA", "DE", "TW"] # ['USA', 'DE', 'TW']
```

![](https://1394144544-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-Ma3iO86k0kEA04rPhPo%2F-MaiXo_d2DkeEFlZa9Jy%2F-Maiasqb9Maly-pIGtYB%2Fimage.png?alt=media\&token=ce4092a0-7f93-4949-8aac-ce205b153aec)

```python
li = [-1] * 100 # 創造一個100格，裡面都是-1的陣列
```

```python
li = [0 for i in range(100)] # 創造一個100格，裡面都是0的陣列
```

```python
li = [int(i) for i in range(100)] # 將陣列內容值都改為整數
```

```python
li = list(map(int, li) # 將陣列內容值都改為整數
```

讀取一行多筆資料進串列中

```python
li = input('請輸入六個大特透號碼：').split() # 15 20 49 1 7 33
print(li) # ['15', '20', '49', '1', '7', '33']
```

將字串改為串列

```python
s = '最沒資格抱怨人生的，就是允許自己一直迷惘，卻不試著做點什麼的人'
li = list(s)
print(li) # ['最', '沒', '資', '格', '抱', '怨', '人', '生', '的', '，', '就', '是', '允', '許', '自', '己', '一', '直', '迷', '惘', '，', '卻', '不', '試', '著', '做', '點', '什', '麼', '的', '人']
```

#### 元組

```python
tu = ('我', '是', '元', '組') # 元組的表示方式
```

```python
tu = ('AE',) # 如果Tuple中僅有一個值的情況，最後面要有個逗號，否則會宣告成字串
```

### D. 取陣列中的值

陣列的存取方式都是透過`[]`

```python
s = "make me great again" # 字串
li = ['make', 'me', 'great', 'again'] # 串列
tu = ('make', 'me', 'great', 'again') # 元組

print(s[2], s[4]) # k  
print(li[2], li[0]) # great make
print(tu[2], tu[1]) # great me
```

![](https://1394144544-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-Ma3iO86k0kEA04rPhPo%2F-MaXLeK_5VnBfx3tSivu%2F-MaZ4wpA08tZa2mPrTjI%2Fimage.png?alt=media\&token=ba9feda6-67f4-44fc-a411-dc4675e5cd2c)

![](https://1394144544-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-Ma3iO86k0kEA04rPhPo%2F-MaXLeK_5VnBfx3tSivu%2F-MaZ2Bn3itpnxYLId0J4%2Fimage.png?alt=media\&token=96c256d1-4f5d-47c1-bc55-04382e4ddc1c)

### E. 計算陣列長度

使用`len()`

```python
s = "有拜有保庇" # 字串
li = ['有', '拜', '有', '保', '庇'] # 串列
tu = ('有', '拜', '有', '保', '庇') # 元組

print(len(s)) # 5
print(len(li)) # 5
print(len(tu)) # 5
```

{% hint style="danger" %}
**注意!** 空格、特殊符號都算一種字元唷! 同時也占據一格空間
{% endhint %}

### F. 陣列切片(Slicing)

#### 字串切片

用`:`做切片

```python
s = "Angels Like You"
# 從編號2號的格子到編號4號的格子
print(s[2:5]) # gel

# 從編號0號的格子到編號14號的格子，取樣間隔為2
print(s[0:15:2]) # Agl ieYu

# 從編號10號的格子到編號1號的格子，取樣間隔為-2
print(s[10:0:-2]) # ei lg
```

```python
s = "F**kin’ Perfect"

#如果右邊不放的話就代表到最末一個編號
print(s[2:]) # *kin’ Perfect

#如果左邊不放的話就代表從編號 0 開始
print(s[:5]) # F**ki
```

#### 串列切片

```python
contry = ['CA', 'US', 'TW', 'DE', 'AE', 'IL']
print(contry[:]) # ['CA', 'US', 'TW', 'DE', 'AE', 'IL']
print(contry[-5:-1]) # ['US', 'TW', 'DE', 'AE']
```

#### 元組切片

```python
contry = ('CA', 'US', 'TW', 'DE', 'AE', 'IL')
print(contry[:]) # ('CA', 'US', 'TW', 'DE', 'AE', 'IL')
print(contry[-5:-1]) # ('US', 'TW', 'DE', 'AE')
```

【例題】

下方是某首歌曲中的一小段歌詞\


> &#x20;別逼一個最愛你的人 即興表演\
> &#x20;什麼時候我們開始 沒有了底線\
> &#x20;順著別人的謊言 被動就不顯得可憐

請擷取歌詞中的最後一句

```python
s = '''別逼一個最愛你的人 即興表演
什麼時候我們開始 沒有了底線
順著別人的謊言 被動就不顯得可憐'''

print(s[30:47]) # 順著別人的謊言 被動就不顯得可憐
```

```python
s = '''
別逼一個最愛你的人 即興表演
什麼時候我們開始 沒有了底線
順著別人的謊言 被動就不顯得可憐'''

print(s[31:48]) # 順著別人的謊言 被動就不顯得可憐
```

### G. 更改陣列中的值

#### 字串

更改字串中特定位置的值

```python
a = "電視裡我唱得用力，撕心裂肺誰又會在意"
a = a[:4] + '罵' + a[5:]
print(a) # 電視裡我罵得用力，撕心裂肺誰又會在意
```

將字串裡的所有某子字串全改為另個子字串

使用`replace()`

```python
a = '不要等對的人走進你的生命裡；要努力成為走進別人生命裡那個對的人'
print(a.replace('生命', 'XX')) # 不要等對的人走進你的XX裡；要努力成為走進別人XX裡那個對的人
```

錯誤方式

{% hint style="danger" %}
**注意!** python中，字串不得直接用 `a[] = " "` 的方式更改!
{% endhint %}

```python
a = "AIDS"
a[0] = 'B' # TypeError: 'str' object does not support item assignment
print(a)
```

#### 串列

```python
li = ['USA', 'DE', 'TW']
li[1] = 'CN'
print(li) # ['USA', 'CN', 'TW']
```

#### 元組

無法直接改動元組內容的值

```python
tu = ('AE', 'CN', 'FR')
tu[1] = 'GB' # TypeError: 'tuple' object does not support item assignment
del thistuple[1] # TypeError: 'tuple' object doesn't support item deletiondel thistuple[1] # TypeError: 'tuple' object doesn't support item deletion
```

間接改動元組內容的值(先轉&#x70BA;**`list`**&#x8B8A;動完後再轉&#x56DE;**`tuple`**)

```python
tu = ('AE', 'CN', 'FR')
y = list(tu) # 先轉為list
y[1] = "panda"
tu = tuple(y) # 再轉回tuple
print(tu) # ('AE', 'panda', 'FR')
```

### H. 陣列中的子陣列

#### 使用`index()`

字串

```python
s = 'Those who do nothing but allow themselves to dwell in despair have no right to complain about life.'
print(s.index('dwell')) # 45 (找出串列中第一個相符合的子字串所在的索引值)
print(s.index('to', 45)) # 76 (找出索引值45之後第一個相符合的子字串所在的索引值)
print(s.index('gorgeous')) # ValueError: substring not found
```

串列

```python
fruits = ['orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana']
print(fruits.index('banana')) # 3 (找出串列中第一個相符合的值所在的索引值)
print(fruits.index('banana', 4)) # 6 (找出索引值4之後第一個相符合的值所在的索引值)
print(fruits.index('guava')) # ValueError: 'guava' is not in list
```

元組

```python
fruits = ('orange', 'apple', 'pear', 'banana', 'kiwi', 'apple', 'banana')
print(fruits.index('banana')) # 3
print(fruits.index('banana', 4))  # 6
print(fruits.index('guava')) # ValueError: tuple.index(x): x not in tuple
```

#### 使用`find()`

串列與元組均無法使用`find()`，而`find()`與`index()`最大差異在於：當找不到希望的子陣列時，會回傳`-1`而非`ValueError`

```python
s = 'Those who do nothing but allow themselves to dwell in despair have no right to complain about life.'
print(s.find('dwell')) # 45 (找出串列中第一個相符合的子字串所在的索引值)
print(s.find('to', 45)) # 76 (找出索引值45之後第一個相符合的子字串所在的索引值)
print(s.find('gorgeous')) # -1
```

#### 判斷某子陣列是否有在某陣列中

使用 `in` 或 `not in`

字串

```python
txt = "A beautiful woman wears a smile on her face, carries confidence on her shoulder, keeps courage in her heart, and holds destiny in her hand."

conclusion1 = "shoulder" in txt # 判斷 shoulder 有無在 txt 字串中
conclusion2 = "beautiful" not in txt # 判斷 beautiful 有無在 txt 字串中

print(conclusion1, conclusion2) # True False
```

串列

```python
thislist = ['USA', 'DE', 'TW']
if 'TW' in thislist:
  print('Yes') # Yes
if 'CN' in thislist:
  print('Yes') # (不會印出)
```

元組

```python
thislist = ('USA', 'DE', 'TW')
if 'TW' in thislist:
  print('Yes') # Yes
if 'CN' in thislist:
  print('Yes') # (不會印出)
```

### I. 陣列搭配迴圈

字串

```python
s = "世界が終るまでは"
for x in range(len(s)): 
  print(s[x], end=" ") # 世 界 が 終 る ま で は 
```

```python
s = "世界が終るまでは"
for x in s: # x變數會從字串陣列中的第一格數值開始到最後一格
  print(x, end=" ") # 世 界 が 終 る ま で は 
```

串列

```python
li = ['USA', 'DE', 'TW']
for x in range(len(li)):
  print(li[x] , end=' ') # USA DE TW
```

```python
li = ['USA', 'DE', 'TW']
for x in li:
  print(x , end=' ') # USA DE TW
```

```python
li = [1, 2, 3, 4, 5]
l = [element - 1 for element in li] # 將串列內所有值都-1
print(l) # [0, 1, 2, 3, 4]
```

元組

```python
tu = ('USA', 'DE', 'TW')
for x in tu:
  print(x , end=' ') # USA DE TW
```

```python
tu = (1, 2, 3, 4, 5)
t = [element - 1 for element in tu]
print(t) # [0, 1, 2, 3, 4]
```

### J. 陣列變字串

使用`join()`

#### 字串每隔間插入新字串

```python
s = "有拜有保庇"
print('--'.join(s)) # 有--拜--有--保--庇
```

#### 串列每隔間插入新字串

```python
li = ['有', '拜', '有', '保', '庇']
print(''.join(li)) # 有拜有保庇
```

```python
li = ['有', '拜', '有', '保', '庇']
print('--'.join(li)) # 有--拜--有--保--庇
```

#### 元組每隔間插入新字串

```python
li = ('有', '拜', '有', '保', '庇')
print('--'.join(li)) # 有--拜--有--保--庇
```

### K. 陣列的合併

#### 字串

使用`+`

```python
s1 = '人之初'
s2 = '性本善'
print(s1 + s2) # 人之初性本善

s1 += s2
print(s1) # 人之初性本善
```

#### 串列

{% hint style="success" %}
Python串列中允許同時並存多種形態的值
{% endhint %}

使用`+`

```python
li_1 = ['UK', 'DE', 'AE']
li_2 = [3.14, -9]
print(li_1 + li_2) # ['UK', 'DE', 'AE', 3.14, -9]

li_1 += li_2
print(li_1) # ['UK', 'DE', 'AE', 3.14, -9]
```

使用`extend()`

```python
li_1 = ['UK', 'DE', 'AE']
li_2 = [3.14, -9]

li_1.extend(li_2)
print(li_1) # ['UK', 'DE', 'AE', 3.14, -9]
```

#### 元組

使用`+`

```python
li_1 = ('UK', 'DE', 'AE')
li_2 = (3.14, -9)
print(li_1 + li_2) # ('UK', 'DE', 'AE', 3.14, -9)

li_1 += li_2
print(li_1) # ('UK', 'DE', 'AE', 3.14, -9)
```

### L. 計算陣列中某物件出現次數

使用`count()`

#### 字串

```python
s = "有拜有保庇"
print(s.count('有')) # 2
```

#### 串列

```python
contry = ['CA', 'US', 'CA', 'DE', 'AE', 'IL', 'CA']
print(contry.count('CA')) # 3
```

#### 元組

```python
contry = ('CA', 'US', 'CA', 'DE', 'AE', 'IL', 'CA')
print(contry.count('CA')) # 3
```

### M. 加物件進陣列中

#### 字串

```python
s = "有拜有保庇"
s += '嗎?'
print(s) # 有拜有保庇嗎?
```

```python
s = "有拜有保庇"
s = s[:2]+'媽祖'+s[2:]
print(s) # 有拜媽祖有保庇
```

#### 串列

使用`append()`加物件至串列最末一個位置

```python
li = ['USA', 'DE', 'TW']
li.append('AE')
print(li) # ['USA', 'DE', 'TW', 'AE']
```

使用`insert()`加物件至串列中特定位置

```python
li= ['USA', 'DE', 'TW']
li.insert(1, 18) # 將18插入索引值1的格子中
print(li) # ['USA', 18, 'DE', 'TW']
```

利用`+=`方式

```python
contry = ['AU', 'CH', 'EE']
contry += 'CS'
print(contry) # ['AU', 'CH', 'EE', 'C', 'S']
country += ['CS']
print(contry)  # ['AU', 'CH', 'EE', 'C', 'S', 'CS']
```

在串列中加入子串列(形成多維串列)

```python
thislist = ['UK', 'DE', 'AE']
thislist += [['IN']]
print(thislist) # ['UK', 'DE', 'AE', ['IN']] (二維串列)
```

#### 元組

元組為不可變動陣列，不得隨意增加物件

```python
contry = ('AU', 'CH', 'EE')
contry += 'CS' # TypeError: can only concatenate tuple (not "str") to tuple
print(contry)
```

### N. 移除陣列或其內容

#### 字串

直接使用`+`重組字串

```python
s = "有拜有保庇"
s = s[:1]+s[2:]
print(s) # 有有保庇
```

使用`replace()`

```python
a = '有拜有保庇'
print(a.replace('有', '')) # 拜保庇
```

```python
# 若只想取代其中幾個字可以加上參數
a = '有拜有保庇'
print(a.replace('有', '', 1)) # 拜有保庇
```

#### 串列

使用`remove()`【**移除串列中指定物件】**

```python
thislist = ['apple', 'banana', 'cherry']
thislist.remove('banana')
print(thislist) # ['apple', 'cherry']
```

使用`pop()`【**移除串列中最後一個物件**】

```python
thislist = ['apple', 'banana', 'cherry']
thislist.pop() 
print(thislist) # ['apple', 'banana']
```

使用`pop()`【**移除串列中指定索引值的物件**】

```python
thislist = ['apple', 'banana', 'cherry']
thislist.pop(1) 
print(thislist) # ['apple', 'cherry']
```

使用`del`【**移除串列中指定索引值的物件**】

```python
thislist = ['apple', 'banana', 'cherry']
del thislist[0]
print(thislist) # ['banana', 'cherry']
```

使用`del`【**移除整個串列**】

```python
thislist = ['apple', 'banana', 'cherry']
del thislist
print(thislist) # NameError: name 'thislist' is not defined
```

使用`clear()`【**清空整個串列**】

```python
thislist = ['apple', 'banana', 'cherry']
thislist.clear()
print(thislist) # []
```

使用`del`【**清空整個串列**】

```python
thislist = ['apple', 'banana', 'cherry']
del thislist[:]
print(thislist) # []
```

#### 元組

元組不得直接刪除陣列中內容

### O. 陣列中最大值、最小值、總和

在電腦中，任何字元都有個專屬的編碼，例如：ASCII、Unicode、UTF-8 ... 等

#### 字串

```python
alpha = 'ABCDEFG'
print(max(alpha)) # G
print(min(alpha)) # A
```

#### 串列

```python
num_list = [65, 20, 35, 100, 90, 36]
print(max(num_list)) # 100
print(min(num_list)) # 20
print(sum(num_list)) # 346
```

```python
contry = ['CA', 'US', 'TW', 'DE', 'AE', 'IL']
print(max(contry)) # US
print(min(contry)) # AE
```

下方為補充

```python
contry = ['CA', 'USA', 'TW', 'DE', 'AE', 'I']
print(max(contry, key=len)) # USA
print(min(contry, key=len)) # I
```

#### 元組

```python
num_list = (65, 20, 35, 100, 90, 36)
print(max(num_list)) # 100
print(min(num_list)) # 20
print(sum(num_list)) # 346
```

```python
contry = ('CA', 'US', 'TW', 'DE', 'AE', 'IL')
print(max(contry)) # US
print(min(contry)) # AE
```

下方為補充

```python
contry = ('CA', 'USA', 'TW', 'DE', 'AE', 'I')
print(max(contry, key=len)) # USA
print(min(contry, key=len)) # I
```

## II. 字串(str)專屬用法

### A. 英文字母大小寫轉換

使用`lower()`及`upper()`

```python
a = "Courage is not a proof of Strength, but an act of Persistence."

print(a.lower()) # courage is not a proof of strength, but an act of persistence.
print(a.upper()) # COURAGE IS NOT A PROOF OF STRENGTH, BUT AN ACT OF PERSISTENCE.
```

### B. 字串與變數或數字串接

```python
name = "Lance"
age = 18
print('the age of {} is {}'.format(name, age)) # the age of Lance is 18
```

```python
name = "Lance"
age = 18
print(f'the age of {name} is {age}') # the age of Lance is 18
print(f'the age of{name}is{age}') # the age ofLanceis18
```

```python
print("the age of {} is {}".format("Lance", 18)) # the age of Lance is 18
print(f'the age of {"Lance"} is {18}') # the age of Lance is 18
```

也可以將要放的地方做編號(從0開始)

```python
print("大家好，我是{0}，我今年{1}歲，身高{2}公分".format("皮卡丘", 15, 50)) # 大家好，我是皮卡丘，我今年15歲，身高50公分
print("大家好，我是{1}，我今年{2}歲，身高{0}公分".format("皮卡丘", 15, 50)) # 大家好，我是15，我今年50歲，身高皮卡丘公分
```

### C. 格式化數字

格式化數字【放在`{}`中】有很多種類，在此只舉一些較常用的

|    輸入值    |     格式     |   輸出  | 解釋                                                                                                                                                     |
| :-------: | :--------: | :---: | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| 3.1415926 |   {:.2f}   |  3.14 | <p><code>.2</code>表示保留小數點後2位(4捨5入)<br><code>f</code>表示<code>float</code>(小數)</p>                                                                       |
|     13    |   {:x>5d}  | xxx13 | <p><code>x</code>表示用<code>x</code>字元填補<br><code>></code>表示填補左方(向右對齊)<br><code>d</code>表示<code>decimal</code>(10進位數字)<br><code>5d</code>表示格式寬度為5個字元</p> |
|     13    |   {:#<5d}  | 13### | <p><code>#</code>表示用<code>#</code>填補<br><code>&#x3C;</code>表示填補右方(向左對齊)<br><code>5d</code>表示格式寬度為5個字元</p>                                              |
|     5     |   {:!^5d}  | !!5!! | <p><code>!</code>表示用<code>!</code>填補<br><code>^</code>表示置中對齊</p>                                                                                       |
|     A     |   {0:a^5}  | aaAaa | <p><code>0</code>表示此<code>{}</code>的編號<br>5後面什麼都不放代表字串格式</p>                                                                                           |
|     A     | {name:a^5} | aaAaa | <p><code>name</code>表示此<code>{}</code>的名稱<br>5後面什麼都不放代表字串格式</p>                                                                                        |

## III. 串列 (`list`)專屬用法

### A. 串列複製【補充】

{% hint style="danger" %}
**注意!** Python中不得直接指定整串陣列到另一個，這會使得更動一個串列另一個也跟著連動
{% endhint %}

```python
thislist = ["apple", "banana", "cherry"]
li_tmp = thislist # 這種指定方式非常危險
print(li_tmp) # ['apple', 'banana', 'cherry']

thislist[0] = "WOOOW" 
print(li_tmp) # ['WOOOW', 'banana', 'cherry']
```

方法一

```python
thislist = ["apple", "banana", "cherry"]
li_tmp= thislist.copy()
print(li_tmp) # ['apple', 'banana', 'cherry']

thislist[0] = "WOOOW"
print(li_tmp) # ['apple', 'banana', 'cherry']
```

方法二

```python
thislist = ["apple", "banana", "cherry"]
li_tmp= list(thislist)
print(li_tmp) # ['apple', 'banana', 'cherry']

thislist[0] = "WOOOW"
print(li_tmp) # ['apple', 'banana', 'cherry']
```

#### 深度複製【補充】

使用`copy()`複製多維度的串列會遇到的問題

```python
li_1 = ['CA', ['DE']]
li_2 = li_1.copy()
li_1.append('ZZ') # ['CA', ['DE'], 'ZZ'] ['CA', ['DE']]
print(li_1, li_2)

li_1[1].append('XX')
print(li_1, li_2) # ['CA', ['DE', 'XX'], 'ZZ'] ['CA', ['DE', 'XX']]
```

使用`deepcopy()`可以複製多維度的串列【需要import copy】

```python
import copy # 使用deepcopy前需要引用外部函式

li_1 = ['CA', ['DE']]
li_2 = li_1.deepcopy()
li_1.append('ZZ')
print(li_1, li_2) # ['CA', ['DE'], 'ZZ'] ['CA', ['DE']]

li_1[1].append('XX')
print(li_1, li_2) # ['CA', ['DE', 'XX'], 'ZZ'] ['CA', ['DE']]
```

### B. 排序串列中的物件

#### 由小至大排列

```python
num_list = [65, 20, 35, 100, 90, 36]
contry = ['CA', 'US', 'TW', 'DE', 'AE', 'IL']

# 整形化妝方式
print(sorted(num_list)) # [20, 35, 36, 65, 90, 100]
print(sorted(contry)) # ['AE', 'CA', 'DE', 'IL', 'TW', 'US']
print(num_list) # [65, 20, 35, 100, 90, 36]
print(contry) # ['CA', 'US', 'TW', 'DE', 'AE', 'IL']

# 真正改變的方式
contry.sort()
num_list.sort()
print(num_list) # [20, 35, 36, 65, 90, 100]
print(contry) # ['AE', 'CA', 'DE', 'IL', 'TW', 'US']
```

#### 由大至小排列

```python
num_list = [65, 20, 35, 100, 90, 36]
contry = ['CA', 'US', 'TW', 'DE', 'AE', 'IL']

# 整形化妝方式
print(sorted(num_list, reverse = True)) # [100, 90, 65, 36, 35, 20]
print(sorted(contry, reverse = True)) # ['US', 'TW', 'IL', 'DE', 'CA', 'AE']
print(num_list) # [65, 20, 35, 100, 90, 36]
print(contry) # ['CA', 'US', 'TW', 'DE', 'AE', 'IL']

# 真正改變的方式
contry.sort(reverse = True)
num_list.sort(reverse = True)
print(num_list) # [100, 90, 65, 36, 35, 20]
print(contry) # ['US', 'TW', 'IL', 'DE', 'CA', 'AE']
```

### C. enumerate【補充】

`enumerate()`可將串列轉為**元組**型態的(**數值+索引值**)

```python
drinks = ['coke', 'wine', 'coffee']
enu = enumerate(drinks)
print(enu) # <enumerate object at 0x0000021F15432C40>
print(list(enu)) # [(0, 'coke'), (1, 'wine'), (2, 'coffee')]
```

```python
drinks = ['coke', 'wine', 'coffee']
for i, element in enumerate(drinks):
    print(i, element, end=' , ') # 0 coke , 1 wine , 2 coffee ,
    
for value in enumerate(drinks):
    print(value, end='') # (0, 'coke')(1, 'wine')(2, 'coffee') 
```

### D. 多維度串列

#### 二維串列的表示方式

![](https://1394144544-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-Ma3iO86k0kEA04rPhPo%2F-MaQz2SIB-eHt3FuWrDx%2F-MaU6CVU60l_TCbp0---%2Fimage.png?alt=media\&token=f1550a41-1465-465c-b481-d33c1afbff00)

#### 三維串列的表示方式

![](https://1394144544-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-Ma3iO86k0kEA04rPhPo%2F-MaQz2SIB-eHt3FuWrDx%2F-MaU6gyz8YFZsbLwxpuu%2Fimage.png?alt=media\&token=a482b343-1771-4dd6-baaa-7af148aa27a8)

#### 二維串列的創造

```python
# 創造一個10x5的2維陣列串容均為0
twoDarray = [[0 for i in range(5)] for j in range(10)] 
```

#### 二維串列的長度

```python
# 創造一個2x3的2維陣列
array_2D = [[1, 2, 3], 
            [4, 5, 6]] 

# 印出陣列的row數
print(len(array_2D)) # 2

# 印出陣列的column數
print(len(array_2D[0])) # 3
```

#### 二維串列的存取

```python
 # 創造一個2x3的2維陣列
twoDarray = [[1, 2, 3], 
             [4, 5, 6]]

print(twoDarray[1][0]) # 4
print(twoDarray[0][3]) # IndexError: list index out of range
print(twoDarray[1][1]) # 5
```

#### 多維串列的複製【補充】

使用`deepcopy()`【需要import copy】

```python
import copy
myList = [[0, 1, 2, 3],
          [3, 2, 1, 0],
          [3, 5, 6, 1],
          [3, 8, 3, 4]]
cList = copy.deepcopy(myList)
myList[0][1] = 10
print(cList) # [[0, 1, 2, 3], [3, 2, 1, 0], [3, 5, 6, 1], [3, 8, 3, 4]]
print(myList) # [[0, 10, 2, 3], [3, 2, 1, 0], [3, 5, 6, 1], [3, 8, 3, 4]]
```

## IV. 元組 (tuple)專屬用法

### A. 為何需要`tuple`?

有些程式是需要存取陣列中固定某格當中的值，這時若用`List`來儲存可能會不小心更動到該格的數值進而影響結果，這時使用`Tuple`就能夠避免這類問題發生，因為`Tuple`是不可被變動的

## V. 學習單

{% embed url="https://docs.google.com/presentation/d/e/2PACX-1vQFFwclXjQopW1logMlVTN70ovUtqxmErHCrbB16SffbUD5UT1qmizXxlr1HTdqDk5Kss-ia-5bTy1G/embed?start=false&loop=false&delayms=3000" %}

## VI. 附檔

### A. 提示程式碼

{% file src="https://1394144544-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-Ma3iO86k0kEA04rPhPo%2F-MbZ2fb8vdYk6NUbtUYg%2F-MbZ7UuV5NrL0K1gmyz8%2F%E5%AF%A6%E4%BD%9C7%E6%8F%90%E7%A4%BA%E7%A2%BC.txt?alt=media&token=97c9d0d7-4cef-460e-9ffe-24adeb192e79" %}

{% file src="https://1394144544-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-Ma3iO86k0kEA04rPhPo%2Fuploads%2FDKPp5haVjSlv4ItCM8Yc%2F%E6%8C%91%E6%88%B03%E6%8F%90%E7%A4%BA%E7%A2%BC.txt?alt=media&token=9a430b2d-d074-464a-bdb8-f27353f19f4b" %}

### B. 文章

{% file src="https://1394144544-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-Ma3iO86k0kEA04rPhPo%2F-Mb7hlk3aeRO6G9Q2JaM%2F-Mb7mhEmNQznBThLRj_N%2F%E5%87%BA%E5%B8%AB%E8%A1%A8.txt?alt=media&token=e38d16ea-db95-4e47-8a8a-b634d4dffdbe" %}

{% file src="https://1394144544-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-Ma3iO86k0kEA04rPhPo%2F-Mb7hlk3aeRO6G9Q2JaM%2F-Mb7nKtk7Hrh9UZ2z37J%2F%E4%B8%89%E5%AD%97%E7%B6%93.txt?alt=media&token=fc7f8f33-d1a4-4523-adcd-f54b19bf9940" %}

{% file src="https://1394144544-files.gitbook.io/~/files/v0/b/gitbook-legacy-files/o/assets%2F-Ma3iO86k0kEA04rPhPo%2F-Mb7hlk3aeRO6G9Q2JaM%2F-Mb7nOGMzavIPNp4PlfN%2F%E8%B5%A4%E5%A3%81%E8%B3%A6.txt?alt=media&token=4b198728-ca89-4cf0-b3c9-3d033ab07abe" %}

{% tabs %}
{% tab title="赤壁賦" %}
壬戌之秋，七月既望，蘇子與客泛舟遊於赤壁之下。清風徐來，水波不興。舉酒

屬客，誦明月之詩，歌窈窕之章。少焉，月出於東山之上，徘徊於斗牛之間。白

露橫江，水光接天。縱一葦之所如，凌萬頃之茫然。浩浩乎如馮虛御風，而不知

其所止；飄飄乎如遺世獨立,羽化而登仙。 於是飲酒樂甚，扣舷而歌之。歌曰：

“桂棹兮蘭槳，擊空明兮溯流光。渺渺兮予懷，望美人兮天一方。”客有吹洞簫

者，倚歌而和之。其聲嗚嗚然，如怨如慕，如泣如訴；餘音嫋嫋，不絕如縷。舞

幽壑之潛蛟，泣孤舟之嫠婦。 蘇子愀然，正襟危坐，而問客曰：“何爲其然也？”

客曰：“‘月明星稀，烏鵲南飛。’此非曹孟德之詩乎？西望夏口，東望武昌，山川

相繆，鬱乎蒼蒼，此非孟德之困於周郎者乎？方其破荊州，下江陵，順流而東

也，舳艫千里，旌旗蔽空，釃酒臨江，橫槊賦詩，固一世之雄也，而今安在哉？

況吾與子漁樵於江渚之上，侶魚蝦而友麋鹿，駕一葉之扁舟，舉匏樽以相屬。寄

蜉蝣於天地，渺滄海之一粟。哀吾生之須臾，羨長 江之無窮。挾飛仙以遨遊，

抱明月而長終。知不可乎驟得，託遺響於悲風。” 蘇子曰：“客亦知夫水與月乎？

逝者如斯，而未嘗往也；盈虛者如彼，而卒莫消長也。蓋將自其變者而觀之，則

天地曾不能以一瞬；自其不變者而觀之，則物與我皆無盡也，而又何羨乎！且夫

天地之間，物各有主，苟非吾之所有，雖一毫而莫取。惟江上之清風，與山間之

明月，耳得之而爲聲，目遇之而成色，取之無禁，用之不竭。是造物者之無盡藏

也，而吾與子之所共適。”(共適 一作：共食) 客喜而笑，洗盞更酌。餚核既盡，

杯盤狼籍。相與枕藉乎舟中，不知東方之既白。
{% endtab %}

{% tab title="出師表" %}
臣亮言：先帝創業未半而中道崩殂，今天下三分，益州疲弊，此誠危急存亡之秋

也。然侍衛之臣不懈於內，忠志之士忘身於外者，蓋追先帝之殊遇，欲報之於陛

下也。誠宜開張聖聽，以光先帝遺德，恢弘志士之氣，不宜妄自菲薄，引喻失

義，以塞忠諫之路也。 宮中府中，俱爲一體；陟罰臧否，不宜異同：若有作奸

犯科及爲忠善者，宜付有司論其刑賞，以昭陛下平明之理；不宜偏私，使內外異

法也。 侍中、侍郎郭攸之、費禕、董允等，此皆良實，志慮忠純，是以先帝簡

拔以遺陛下：愚以爲宮中之事，事無大小，悉以諮之，然後施行，必能裨補闕

漏，有所廣益。 將軍向寵，性行淑均，曉暢軍事，試用於昔日，先帝稱之曰

“能”，是以衆議舉寵爲督：愚以爲營中之事，悉以諮之，必能使行陣和睦，優劣

得所。 親賢臣，遠小人，此先漢所以興隆也；親小人，遠賢臣，此後漢所以傾

頹也。先帝在時，每與臣論此事，未嘗不嘆息痛恨於桓、靈也。侍中、尚書、長

史、參軍，此悉貞良死節之臣，願陛下親之、信之，則漢室之隆，可計日而待

也。 臣本布衣，躬耕於南陽，苟全性命於亂世，不求聞達於諸侯。先帝不以臣

卑鄙，猥自枉屈，三顧臣於草廬之中，諮臣以當世之事，由是感激，遂許先帝以

驅馳。後值傾覆，受任於敗軍之際，奉命於危難之間：爾來二十有一年矣。 先

帝知臣謹慎，故臨崩寄臣以大事也。主員受命以來，夙夜憂嘆，恐託付不效，以

傷先帝之明；故五月渡瀘，深入不毛。今南方已定，兵甲已足，當獎率三軍，北

定中原，庶竭駑鈍，攘除奸兇，興復漢室，還於舊都。此臣所以報先帝而忠陛下

之職分也。至於斟酌損益，進盡忠言，則攸之、禕、允之任也。 願陛下託臣以

討賊興復之效，不效，則治臣之罪，以告先帝之靈。若無興德之言，則責攸之、

禕、允等之慢，以彰其咎；陛下亦宜自謀，以諮諏善道，察納雅言，深追先帝遺

詔。臣不勝受恩感激。 今當遠離，臨表涕零，不知所言。
{% endtab %}

{% tab title="三字經" %}
人之初，性本善，性相近， 習相遠  ，  苟不教，  性乃遷，  教 之道， 貴以專，&#x20;

昔孟母，  擇鄰處，子不學，斷機杼， 竇燕山， 有義方，教五子，名 俱揚，

&#x20;養不教， 父之過，教不嚴，師之惰， 子不學， 非所宜，幼不學，老何 為，

&#x20;玉不琢，   不成器，人不學， 不知義， 為人子， 方少時，親師友，習 禮   儀，

&#x20;香九齡， 能溫席，孝於親， 所當執， 融四歲，能讓梨，弟於長，宜先知，&#x20;

首孝弟，次見聞，知某數，識某文， 一而十，十而百，百而千，千而萬，&#x20;

三才者，  天地人，三光者，日月星， 三綱者，君臣義，父子親，夫婦順，&#x20;

日春夏，日秋冬， 此四時，運不窮， 曰南北，曰西東，  此四方，應 乎中，&#x20;

曰水火，  木金土， 此五行，  本乎數，
{% endtab %}
{% endtabs %}

