Python串列資料應用
Revised on August 20, 2021
 串列資料結構
 串列函式
 串列方法
 串列的運算子
 字串與串列轉換
 串列的排序作業
 多維串列
 應用實例：撲克牌梭哈遊戲

 程式使用變數來儲存運算資料及結果，假設要處理 5 位學生的測驗成
績，若個別以變數宣告，必須宣告 5 個 int 整數變數來儲存這5個成績：
quiz1 = 71
quiz2 = 83
quiz3 = 67
quiz4 = 49
quiz5 = 59
 而如果是 50 位學生的成績，我們需要 50 個變數；不僅不利於系統化
作業，程式碼維護變得相當麻煩
 觀察上述測驗成績的 5 個變數，其擁有的共同特性：
 變數有循序性，擁有順序的編號 1~5
 變數的資料型態相同都是 int
串列資料 1/7
2

 我們可以將 5 個成績變數集合起來，使用⼀個名稱 quizzes 代表：
quizzes = [71, 83, 67, 49, 59]
 上述quizzes 變數稱為串列 (List)，它如同是排成⼀列的箱子，每⼀個
箱子可儲存⼀筆資料，稱為「元素 (Element)」，在此，quizzes 串列
內有 5 個元素，每個元素是單⼀值，稱為⼀維串列
串列資料 2/7
71
83
67
49
59
索引
0
1
2
3
4
3

 Python串列類似其它程式語言的陣列 (Array)，但Python 串列中的元
素允許是不同資料型別，而且提供串列作業函式、方法與運算，是非
常方便好用資料結構
 串列名稱 = [元素1, 元素2, 元素3, ...]
quizzes = [71, 83, 67, 49, 59] #整數串列
fruit = ['apple', 'orange', 'melon'] #字串串列
price = ['apple', 17, 'orange', 23] #不同資料型別組成之串列
mylist = [] #空串列
 串列使用索引值 (Index) 來存取串列元素，索引值從0開始，不得超出
串列範圍
print(quizzes[0]) #71
 索引值可以是負數，-1 表⽰最後⼀個元素，-2 表⽰倒數第二個元素，
⼀樣不能超過串列範圍
print(quizzes[-1]) #59
串列資料 3/7
4

 冒號運算子(slicing語法) 用來取得串列資料的子串列或元素
 串列名稱[start:end]
取出從 start 到 end-1子串列
 串列名稱[start:end:inc]
取出從 start 到 end-1，每次遞減inc值之子串列
 串列名稱[start:end:decrement]
取出從 start 到 end+1，每次遞減dec值之子串列
numlist = [1, 2, 3, 4, 5, 6]
print(numlist[:]) #[1, 2, 3, 4, 5, 6]
print(numlist[1:3]) #[2, 3]
print(numlist[1:-2]) #[2, 3, 4]，-2表示倒數第二個元素
print(numlist[0:5:2]) #[1, 3, 5]
print(numlist[5:0:-2]) #[6, 4, 2]
串列資料 4/7
5

 字串資料可視為字元串列處理
data = 'abcdefg' 相當於 datalist = ['a','b','c','d','e','f','g']
numeric = '0123456789'
print(numeric[1:5]) #1234
print(numeric[1:7:2]) #135
print(numeric[7:1:-2]) #753
print(numeric[3:15:-1]) #
print(numeric[::-3]) #9630
串列資料 5/7
6

 更新串列元素
 如同變數⼀樣，允許在程式中更新串列元素內容
 串列名稱[索引] = 資料
quizzes = [71, 83, 67, 49, 59] #整數串列
print(quizzes[4]) #59
quizzes[4] = 60 #
print(quizzes) #[71, 83, 67, 49, 60]
串列資料 6/7
7

 刪除串列元素
 del 也可用來刪除串列元素
 del list[n1:n2]
刪除 list 串列 n1 到 n2-1 元素
 del list[n1:n2:n3]
刪除 list 串列 n1 到 n2-1 元素，刪除間隔為 n3
串列資料 7/7
8

 以下函式可作用在串列資料
 len(list)
取得串列元素個數
 min(list)
取得list串列中最小的元素值
 max(list)
取得list串列中最大的元素值
 sum(list)
計算list串列元素的總和
 sorted(list)
回傳⼀個由小到大排序的 list，並不會改變原來的串列資料
串列函式 1/2
9

quizzes = [71, 83, 67, 49, 59, 87, 95] #整數串列
print(len(quizzes)) #7
print(min(quizzes)) #49
print(max(quizzes)) #95
print(sum(quizzes)/len(quizzes)) #73.0
print(sorted(quizzes)) #[49, 59, 67, 71, 83, 87, 95]
print(quizzes) #[71, 83, 67, 49, 59, 87, 95]
串列函式 2/2
10

 串列提供以下操作方法
 list.append(n1)
將 n1 加到 list 串列最後，n1 可以是元素或串列
 list.clear()
刪除串列所有的元素
 list.count(n1)
統計 n1 元素在 list 串列中出現的次數
 list.extend(list2)
將 list2 串列加到 list 串列最後
 list.index(n1)
list 串列中第 1 個 n1 元素的索引值
串列方法 1/3
11

 list.insert(n, n1)
在 listl 串列的位置 n 插入 n1 元素
 list.pop(n)
從 list 串列取出位置 n 元素，並將該元素自 list 串列中移除；省略參數 n
表⽰最後⼀個元素
 list.remove(n1)
從 list 串列移除第⼀個 n1 元素
 list.reverse()
反轉串列順序
 list.sort()
將串列由小到大排序
串列方法 2/3
12

score = []
total = inscore = 0
while(inscore != -1):
inscore = int(input('請輸入學生的成績(-1結束)：'))
score.append(inscore)
score.remove(-1)
print(score)
print('共有%d位學生' % (len(score)))
average = sum(score) / (len(score))
print('最高分：%d分，最低分：%d分，平均成績：%5.2f分' % (max(score),
min(score), average))
測試：
請輸入學生的成績(-1結束)：83
請輸入學生的成績(-1結束)：62
請輸入學生的成績(-1結束)：79
請輸入學生的成績(-1結束)：92
請輸入學生的成績(-1結束)：86
請輸入學生的成績(-1結束)：-1
[83, 62, 79, 92, 86]
共有5位學生
最高分：92分，最低分：62分，平均成績：80.40分
串列方法 3/3
13

 以下運算子可作用在串列資料
 n in list1
檢查指定資料 n 是否存在於 list1 串列中
 n not in list 1
檢查指定資料 n 是否不存在於 list1 串列中
 x = list1
使變數 x 參用到 list1，x 與 list1 會共用同⼀串列資料
 list1 + list2
將 list2 內容串接在 list1內容之後，產生新串列
 list1 * n
將 list1 內容重複串接 n 次，產生新串列
串列運算子 1/2
14

list1 = [10, 20, 30, 40]
print(10 in list1) #True
print(25 not in list1) #True
list2 = list1
print(list2) #[10, 20, 30, 40]
print(id(list1))
print(id(list2)) #與id(list1)相同
list2[0] = 5
print(list1) #[5, 20, 30, 40]
print(list2) #[5, 20, 30, 40]
list3 = list1 * 2
print(id(list3))
print(list3) #[5, 20, 30, 40, 5, 20, 30, 40]
print(list1 + ['a', 'b', 'c']) #[5, 20, 30, 40, 'a', 'b', 'c']
串列運算子 2/2
15

 字串資料可使用 spilt() 方法分割為字串串列
 字串串列 = 字串.split(切割字元, 分割次數)
 預設使用空字元 (空格、换行n 或跳格t) 做為切割字元
 分割次數，預設為 -1，表⽰全部分割
url = 'https://www.python.org/static/img/python-logo.png'
print(url.split('/'))
#['https:', '', 'www.python.org', 'static', 'img', 'python-logo.png']
print(url.split('/', 1))
#['https:', '/www.python.org/static/img/python-logo.png']
字串與串列轉換 1/2
16

 字串串列的元素可使用 join 方法，連接成⼀個⻑字串
 字串 = '連結字元'.join(字串串列)
path = ['https:', '', 'www.python.org', 'static', 'img', 'python-logo.png']
url = '/'.join(path)
print(url) #https://www.python.org/static/img/python-logo.png
字串與串列轉換 2/2
17

 串列的元素，可以按資料值由小到大的排列方式，重新安排元素順序
 串列名稱.sort()
將串列元素由小到大排列
 串列名稱.sort(reverse = True)
將串列元素由大到小排列
 串列的元素，可以按反方向重新排列元素的順序
 串列名稱.reverse()
quizzes = [71, 83, 67, 49, 59]
quizzes.sort()
print(quizzes) #[49, 59, 67, 71, 83]
quizzes.sort(reverse = True)
print(quizzes) #[83, 71, 67, 59, 49]
quizzes.reverse()
print(quizzes) #[49, 59, 67, 71, 83]
串列的排序 1/2
18

 使用 sort() 方法排序串列，是採就地排序方式，串列經排序後會失去
原有的排列順序。若要有排序後的結果，又要保有排序前的原貌，就
得使用 sorted() 函式來複製串列並排序
 新串列 = sorted(串列名稱, reverse = True|False)
 reverse = True，進行由大到小排序；reverse = False，由小到大排序
quizzes = [71, 83, 67, 49, 59]
score1 = sorted(quizzes, reverse = True)
score2 = sorted(quizzes, reverse = False)
print(quizzes) #[49, 59, 67, 71, 83]
print(score1) #[83, 71, 67, 59, 49]
print(score2) #[49, 59, 67, 71, 83]
串列的排序 2/2
19

 串列的元素可以是另⼀個串列，形成二維串列
employee = [['joe', 23], ['mary', 21], ['David', 22]]
 允許每⼀維元素為不規則 (元素個數不相同)
 二維串列有兩組索引值，第⼀組索引稱為「列」(row)，第二組索引稱
為「行」(column)
print(employee[1]) #['mary', 21]
print(employee[1][1]) #21
 凡是能以表格方式呈現的資料，都可以使用二維串列，如：座位表、
課表
 二維串列中，每⼀列的個數沒有限定要相同；若每⼀列的個數都相同，
就構成了⼀個矩陣串列
二維串列 1/5
20

 建立二維矩陣串列
 直接建立
串列名稱 = [[元素00, 元素01, 元素02, ...],
[元素10, 元素11, 元素12, ...],
[元素20, 元素21, 元素22, ...],
...]]
test1 = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
 使用列表生成
m = n = 3
test2 = [[0 for i in range(m)] for j in range(n)]
print (test2) #[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
test3 = [[i for i in range(m)] for j in range(n)]
print (test3) #[[0, 1, 2], [0, 1, 2], [0, 1, 2]]
二維串列 2/5
21

 建立不規則二維串列
test3 = [[] for i in range(3)]
test3[0] = [1, 2, 3]
test3[1] = [4, 5]
test3[2] = [6, 7, 8, 9]
print(test3)
test4 =[[1, 2, 3], [4, 5], [6, 7, 8, 9]]
print(test4)
二維串列 3/5
22

 使用二維串列記錄學生各科目成績
no = [1, 2, 3, 4, 5] #編號
score = [[87,64,88], [93,72,86], [80,88,89], [79,91,90], [78, 90, 76]] #成績
course = ['語文', '數理', '智力'] #科目名稱
print('編號t%st%st%st總分' %(course[0], course[1], course[2]))
print('====================================')
for i in range(len(no)):
print('%2d' %no[i], end = 't')
hSum = 0
for j in range(len(score[i])):
print('%4d' %score[i][j], end = 't')
hSum += score[i][j]
print('%3d' %hSum)
print('平均', end = 't')
for j in range(len(score[0])):
vSum = 0
for i in range(len(no)):
vSum += score[i][j]
print('%4.1f' %(vSum/len(no)), end = 't')
二維串列 4/5
23

測試：
編號 語文 數理 智力 總分
====================================
1 87 64 88 239
2 93 72 86 251
3 80 88 89 257
4 79 91 90 260
5 78 90 76 244
平均 83.4 81.0 85.8
二維串列 5/5
24

 將二維串列的概念擴展，就可形成多維串列
 多維串列元素的存取是使用多個中括號索引組合，例如三維串列就需
要三個索引
多維串列
25

 設計程式玩家人數，每位玩家發5張牌，自動分析玩家手牌內容，顯⽰
手牌內容及梭哈牌型
輸入玩家人數:4
第1位玩家：
方塊J 梅花A 紅心10 方塊3 黑桃7
梭哈牌型：散牌
第2位玩家：
方塊2 紅心6 梅花2 黑桃2 黑桃3
梭哈牌型：三條
第3位玩家：
黑桃4 黑桃Q 方塊A 梅花7 方塊9
梭哈牌型：散牌
第4位玩家：
紅心2 紅心J 紅心K 黑桃10 梅花J
梭哈牌型：⼀對
應用實例：撲克牌梭哈遊戲 1/9
26

 梭哈牌型
應用實例：撲克牌梭哈遊戲 2/9
27
牌型名稱 說明 實例
同花順
Straight Flush
五張牌同樣花色，而且牌值連續 紅心A、紅心2、紅心3、紅心4、紅心5
鐵支
Four of a Kind
五張牌中有四張同樣數字的牌 紅心A、黑桃A、方塊A、梅花A、梅花2
胡蘆
Full house
五張牌有三張同樣牌值，且另兩張也同樣牌值 紅心A、黑桃A、方塊A、梅花2、梅花2
同花
Flush
五張牌為同樣花色 紅心A、紅心8、紅心9、紅心3、紅心Q
順子
Straight
五張牌的牌值為連續 紅心A、黑桃2、紅心3、紅心4、梅花5
三條
Three of a Kind
五張牌中有三張同樣牌值的牌 紅心A、方塊A、梅花A、紅心3、紅心4
兩對
Two Pairs
五張牌中有兩組兩張同樣牌值的牌 紅心A、黑桃A、方塊K、黑桃K、紅心2
一對
One Pair
五張牌中有二張同樣牌值的牌 方塊A、黑桃A、紅心3、梅花4、紅心5
散牌
High card
五張牌花色沒有全部相同，牌值皆不相同，且
牌值不連續
方塊A、黑桃8、紅心9、梅花J、紅心10

import random
suits = ['黑桃', '紅心', '方塊', '梅花'] #撲克牌花色名稱串列
#建立撲克牌串列，0~12表⽰黑桃，13~25表⽰紅心，26~38表⽰方塊，39~51表⽰梅花
deck = [i for i in range(52)]
#show_card()副程式，顯⽰card值對應的撲克牌，card值0~51，0顯⽰紅心A，51顯⽰梅花K
def show_card(card):
suit = card // 13
print(' %s' %(suits[suit]), end = '') #顯⽰花色名稱
number = card % 13
if (number == 0): #顯⽰牌值
print('A', end = '')
elif(number == 10):
print('J', end = '')
elif(number == 11):
print('Q', end = '')
elif(number == 12):
print('K', end = '')
else:
print(number + 1, end='')
應用實例：撲克牌梭哈遊戲 3/9
28

#show_hand()副程式，顯⽰玩家手牌的梭哈牌型，player_id為玩家為編號
def show_hand(player_id):
if(flush[player_id] and straight[player_id]):
print('同花順n')
return
if(count[player_id][4] == 1):
print('鐵支n')
return
if(count[player_id][3] == 1 and count[player_id][2] == 1):
print('葫蘆n')
return
if(flush[player_id]):
print('同花n')
return
if (straight[player_id]):
print('順子n')
return
if (count[player_id][3] == 1): print('三條n')
if (count[player_id][2] == 2): print('兩對n')
if (count[player_id][2] == 1): print('⼀對n')
if (count[player_id][1] == 5): print('散牌n')
應用實例：撲克牌梭哈遊戲 4/9
29

player = int(input('輸入玩家人數:')) #輸入玩家入數
random.shuffle(deck) #洗牌
#發牌
card = [[] for i in range(player)] #玩家手牌串列
k = 0
for i in range(5): #每位玩家發5張牌
for j in range(player): #依玩家順序張牌
card[j].append(deck[k])
k += 1
#card=[[0,1,2,3,4]] #單⼀玩家測試用資料
應用實例：撲克牌梭哈遊戲 5/9
30
player
card[[]] int int int int int
int int int int int
int int int int int

#建立rank二維串列，用來統計玩家各牌值撲克牌之張數，ACE牌可算1或14
rank = [[0 for i in range(14)] for j in range(player)]
for i in range(player):
for j in range(5):
rank[i][card[i][j] % 13] += 1
rank[i][13] = rank[i][0] #ACE牌也可當14點
應用實例：撲克牌梭哈遊戲 6/9
31
player
rank[[]] int int ... int
int int ... int
int int ... int
14

#建立flush串列，用來記錄玩家的撲克牌是否為同花
flush = [False for i in range(player)]
for i in range(player): #檢查玩家5張牌是否相同花色
flush[i] = (card[i][0]//13 == card[i][1]//13 == card[i][2]//13 ==
card[i][3]//13 == card[i][4]//13)
應用實例：撲克牌梭哈遊戲 7/9
32
bool bool ... bool
player
flush[]

#建立straight串列，用來記錄玩家的撲克牌是否為順子
straight = [False for i in range(player)]
#檢查玩家5張牌是否連續
for i in range(player):
for j in range(10):
if (rank[i][j] == 0): continue
for k in range(1, 5): #繼續檢查後面4張
if (rank[i][j + k] == 0): break
if (k == 4):
straight[i] = True
應用實例：撲克牌梭哈遊戲 8/9
33
bool bool ... bool
player
straight[]

'''
建立count二維串列用來統計玩家撲克牌中之同點數牌情形
count[][2]==1 對子；count[][2]==2 兩對;count[][3]==1 三條；count[][4]==1 鐵支
'''
count = [[0 for i in range(5)] for j in range(player)]
for i in range(player):
for j in range(13):
count[i][rank[i][j]] += 1
#顯⽰每位玩家之手牌及梭哈牌型
for i in range(player):
print('第%d位玩家：' %(i + 1))
for j in range(5): #顯⽰玩家手牌內容
show_card(card[i][j])
print('n 梭哈牌型：', end = '')
show_hand(i) #顯⽰玩家手牌之梭哈牌型
應用實例：撲克牌梭哈遊戲 9/9
34

 colors串列中有256個顏色值，若要分割這個串列，使顯⽰由第2個顏色值開始，
間隔3個顏色值後再顯⽰下⼀個顏色值，直到最後，則下列何者正確?
A. colors[2::4]
B. colors[1::4]
C. colors[::3]
D. colors[1::3]
自我評量 1/7
35

 emp串列中有150名員工姓名，最後10名為臨時員工，若要顯⽰不含臨時員工
的員工姓名，則下列何者正確?
A. emp[0:-9]
B. emp[1:-10]
C. emp[:-10]
D. emp[:-9]
自我評量 2/7
36

 下列程式碼，執行後輸出值為何?
arr1 = [11, 22]
arr2 = [33, 44]
arr3 = arr1 + arr2
arr4 = arr3 * 2
print(arr4)
A. [[22, 44],[66, 88]]
B. [22, 44, 66, 88]
C. [[11, 22], [33, 44], [11, 22], [33, 44]]
D. [11, 22, 33, 44, 11, 22, 33, 44]
自我評量 3/7
37

 A為可儲存n筆整數的串列
A = [...,...,...,......]
p = A[0]
q = A[0]
for i in range(n):
if A[i] > p:
p = A[i]
if A[i] < q:
q = A[i]
程式碼運算後，下列何者錯誤
A. p是A串列資料中的最大值
B. q是A串列資料中的最小值
C. q < p
D. A[0] <= p
自我評量 4/7
38

 下列程式執行後，輸出為何?
arr = [y for y in range(10)]
sum = 0
for i in range(1, 9):
sum = sum – arr[i-1] + arr[i] + arr[i+1]
print(sum)
A. 44
B. 52
C. 54
D. 63
自我評量 5/7
39

 執行下列程式，若依序輸入整數0,1,2,3,4,5,6,7,8,9
arr = [0 for x in range(10)]
for i in range(10):
arr[(i + 2) % 10] = eval(input())
則arr串列內容為何
A. [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
B. [2, 0, 2, 0, 2, 0, 2, 0, 2, 0]
C. [9, 0, 1, 2, 3, 4, 5, 6, 7, 8]
D. [8, 9, 0, 1, 2, 3, 4, 5, 6, 7]
自我評量 6/7
40

 執行下列程式，輸出為何?
for i in range(1, 5):
A[i] = 2 + i * 4
B[i] = i * 5
C = 0
for i in range(1, 5):
if B[i] > A[i]:
C = C + (B[i] % A[i])
else:
C = 1
print(C)
A. 1
B. 4
C. 3
D. 333
自我評量 7/7
41