0. Python 入門

前言

Python大數據分析最重要的四個模組

1.Python大數據分析最重要的四個模組
Python資料分析最重要的四個模組：pandas、numpy、scipy、matplotlib。

（1）pandas：是基於numpy的資料分析工具，能夠快速的處理結構化資料的大量資料結構和函數。
pandas模組應該是python用來進行一般日常的大數據分析，最重要的模組了。
因為pandas的DataFrame資料結構，可以快速的互通於所有的二維結構資料，包括『excel，csv，json，xml，mysql，任何的資料庫，網頁的表格資料，字典dict，二維串列list』
也就是pandas的DataFrame資料結構，可以與它們之間互相簡易的存取。
然後再根據DataFrame來進行想要的大數據分析，它提供內建的演算法與資料結構，能夠用一個指令，就可以進行二維資料的『排序，篩選，關鍵字查詢，任意區間範圍查詢，統計學計算，平均值，變異數，標準差，字串檢索，字串取代，欄位樞紐分析、小記、欄位加總，把二維資料任意方式圖形視覺化顯示』
而建立pandas的DataFrame資料結構，有兩種方式，可以用column的方式來輸入資料，也可以用row的方式來輸入資料。
所以pandas是大數據分析，非常實用的利器工具，是python資料分析的首選。

（2）Numpy： Numpy專門用來處理矩陣，它的運算效率比列表list串列更高效。
Numpy是Python進行專業的數值計算之重要模組，因為大多數提供科學計算的包都是用numPy的陣列作為構建基礎，因此在進行高等數學計算時，numpy就是大數據分析的最重要工具了，因為高等數學運算，都是以矩陣的方式來進行運算，例如人工智慧，機器學習，深度學習，類神經網路計算等。

（3）sscipy：是基於numpy的科學計算包，包括統計、線性代數等工具。

（4）matplotlib：是最流行的用於繪製資料圖表的 Python 庫
也可以結合pandas模組來繪圖。
 

執行python的四種方法（建議用Anaconda，或colaboratory）

範例2-1：輸出

輸入

範例2-2

註解符號

pyhon程式結尾不需要;

print在3.X被改為函式

範例2-3：print多個變數

範例2-4：print的分隔字元設定sep，與結束字元設定end

範例2-5：print的格式化輸出%s,%d,%f

pyhon變數不需要宣告

變數設定值可以多個變數一起設定

變數名稱不可設定成這些保留字

pyhon 3.x版本的變數支援中文名稱

pyhon 脫逸字元，跳脫字元

轉換資料型態函數

範例2-1：計算三位同學的平均分數

python的文字連接串接字元+

1.整數

2.浮點數

3.字串

4.變數的資料型態：type(變數)

5.印出變數的資料型態：type(變數)

範例2-2：

6.變數：

範例3-2：

7.算術運算子

8.變數遞增，遞減（再加上，再減去）

9.比較運算子

10.邏輯運算子

11.in與is運算子

範例2-3：

迴圈for loop有四種

for loop有四種：
(1)第一種：index迴圈
for i in range(1,10)

(2)第二種：讀取container容器的迴圈
for i in a
注意：a可以是四種container容器，或是文字string字串

(3)第三種：讀取container容器的迴圈，並給予編號
for k,v in enumerate(a)

(4)第四種：讀取dict容器迴圈的k,v
for k,v in a.items()
for k in a.keys()
for v in a.values()

1.for迴圈

1.for迴圈
(1).公式：
for 變數 in range(起始值,終止值,遞增減值):
要重複做的程式
#☎注意1：range的範圍為終止值的前一個值
#☎例如：range(1,10)，表示：1,2,3,4,5,6,7,8,9

範例4-1：印出10行恭喜發財

範例4-1：印出10行恭喜發財
for i in range(1,11,1):
print(i,'恭喜發財')
成果圖片：
程式碼內容

範例4-2：印出99乘法表

範例4-2：印出99乘法表
for i in range(1,10,1):
for j in range(1,10,1):
print(i,'x',j,'=',i*j)
成果圖片：
程式碼內容

(2).簡化寫法：只寫終止值（若是起始值=1，遞增1）

(2).簡化寫法：只寫終止值（若是起始值=1，遞增1）
for i in range(10):
for j in range(10):
print(i,'x',j,'=',i*j)

(3).三種控制迴圈的指令

(3).三種控制迴圈的指令
A.中斷迴圈（break)，
B.直接到下一輪迴圈(continue)，
C.若正常完成全部迴圈會執行else

範例4-3：99乘法表i*j，印到i=5就停止

範例4-3：99乘法表i*j，印到i=5就停止
for i in range(1,10):
if i==5:
break
for j in range(1,10):
print(i,'x',j,'=',i*j)
成果圖片：
程式碼內容

範例4-4：99乘法表i*j，到i=5就跳過

範例4-4：99乘法表i*j，到i=5就跳過，直接顯示下一輪
for i in range(1,10):
if i==5:
continue
for j in range(1,10):
print(i,'x',j,'=',i*j)
成果圖片：
成果圖片：
程式碼內容

(5).範例4-6：使用for讀取串列/數組list的所有元素

(5).範例4-6：使用for讀取串列list的所有元素
#☎注意：for s in a（s不是編號，而是元素）
a = ['tom','mike','peter']
#方法1：沒有編號，直接印出元素
for s in a:
print(s)
#方法2：印出（編號，元素），編號由0開始
for i in range(0,len(a)):
print(i,a[i])
#方法3：印出（編號，元素），編號由1開始
for i,item in enumeratea,start=1):
print(i,item)
成果圖片：
程式碼內容

(7).範例4-8：用for產生串列/數組list

(7).範例4-8：用for產生串列list
A.特色：生成式(comprehension)可以依照規則產生資料，然後把資料儲存在『串列，字典，集合』內

B.方法1：傳統for迴圈內用append新增值
#☎注意：串列的新增元素，必須用a.append(元素)
#☎注意：不可以用a[編號] = 值來新增
#新增元素到串列list方法一：[.....]（a.append('tom'))
a=[]
for i in range(0,6):
a.append(i**2)
print(a)

C.方法2：在[]內用for迴圈來新增值
公式：[運算式 for 元素 in 可迭代物件]
#新增元素到串列list方法二：[i*2 for in in range(11)]
a = [i**2 for i in range(1,6)]
print(a)


D.方法3：在[]內用for迴圈來新增值，再加上if判斷
公式：[運算式 for 元素 in 可迭代物件 if 判斷式]
#把1～100的偶數新增到list串列裡面
a = [i for i in range(1,11) if i%2==0]
print(a)
成果圖片：
程式碼內容

範例4-9：製作99乘法表串列

範例4-9：製作99乘法表串列，但是每個元素都是一個tuple，
例如(2,3)
☎注意：tuple可以是『字典(dict)，或集合(set)，或串列(List)』的元素。但是list串列無法成為別人的元素。
a = [(i,j) for i in range(1,10) for j in range(1,10)]
print(a)
成果圖片：
程式碼內容

(10).while迴圈

(10).while迴圈
A.公式：
i=起始值
while i<終止值:
運算程式
i=i+1（或是i=i-1）

#☎注意：在python的i=i+1不能夠寫成i++

範例4-14：計算1到10的總和

範例4-14：計算1到10的總和
i=1
sum = 0
while i<11:
sum += i
i = i+1
print(sum)
#☎注意：在python的i=i+1不能夠寫成i++
成果圖片：
程式碼內容

範例4-15：輸入n，計算1到n的平方合

範例4-15：輸入n，計算1到n的平方合（1**2+2**2+3**2+...n**2)
n = int(input('輸入n = '))
sum = 0
for i in range(1,n+1):
sum += i**2
print(sum)
成果圖片：
程式碼內容

範例4-16：列出1到100，不被2也不被3整除數字

範例4-16：列出1到100，不被2也不被3整除的數字
for i in range(1,101):
if((i%2)!=0 and (i%3)!=0):
print(i)
成果圖片：
成果圖片：
程式碼內容

範例4-19：丟骰子，丟出6遊戲結束

範例4-19：丟骰子，直到丟出6，才顯示遊戲結束
#☎注意：隨機亂數的函數是random.randint(1,n)
#☎注意：而且使用亂數函數，必須用import random
#☎注意：常用的python亂數函數
（1）取出1～6的亂數：n1 = random.randint(1,6)
（2）取出某串列陣列的第n個亂數元素：n1 = random.choice(串列)

import random
while True:
num = random.randint(1,6)
if num ==6:
print('丟到6，遊戲結束')
break
成果圖片：
程式碼內容

範例4-20：猜數字，猜1～99的數

範例4-20：猜數字，猜1～99的數，若是不對，則會提示猜小了，猜大了，猜中了
import random
ans = random.randint(1,99)
print(ans)
gus = 0
while gus != ans:
gus = int(input('請猜一個數字？'))
if gus > ans:
print('猜大了')
elif gus == ans:
print('猜中了')
elif gus < ans:
print('猜小了')
成果圖片：
程式碼內容

python資料的四種儲存容器Containers

python資料的四種儲存容器Containers：
1.python資料的儲存容器有四種：序對tuple元組，串列(list)，字典(dict)，集合(set)

一.功用，用途：
(1).串列(list)：list串列，就類似Array陣列，a=[1,2,3]
(2).集合(set)：可以用來做數學的『交集，聯集』計算，a={1,2,3,4}
(3).字典(dict)：可以透過『文字』來存取資料（不需要用編號），a={'b1':'john','b2':'tom','b3':'jane'}
(4).序對tuple元組：
_A).tuple類似list串列（差異就是tuple={..}，list=[...]）。
_B).tuple可以是『字典(dict)，或集合(set)，或串列(List)』的元素。但是list串列無法成為別人的元素。


python資料的儲存容器特色：
python資料的儲存容器有四種：序對tuple，串列(list)，字典(dict)，集合(set)
(1).tuple特色：依序存儲資料，可以依照順序取出資料，但不能夠更改，是不可變的物件。
(2).串列(list)特色：可依序存儲資料，可以依照順序取出資料，也能夠更改。
(3).字典(dict)特色：儲存的資料為『鍵vs值』(key vs value)對應的資料。
(4).集合(set)特色：可儲存沒有次序性的資料。（若要搜尋某資料是否存在，而不根據鍵vs值的方式搜尋，就可以用集合set。

範例5-0：四種容器：list,set,dict,tuple

#範例5-0：四種容器
#(1).串列(list)：list串列，就類似Array陣列，a=[1,2,3]
a = [1,2,3]
print('list=',a)
print('list[0]=',a[0])

#(2).集合(set)：可以用來做數學的『交集，聯集』計算，a={1,2,3,4}
b = {1,2,3,4}
c = {3,4,5}
print('b & c=',b & c)
print('b or c=', b | c)

#(3).字典(dict)：可以透過『文字』來存取資料（不需要用編號），a={'b1':'john','b2':'tom','b3':'jane'}
a={'b1':'john','b2':'tom','b3':'jane'}
print(a['b1'])

#(4).tuple類似list串列，a = ('tom','mike','peter')
a = (1,2,3)
print('a[0]=', a[0])
成果圖片：
程式碼內容

範例5-1：list的基本操作（建立，新增，修改，刪除，查詢）

#第5章.串列/數組/列表(list)：基本操作（建立，新增，修改，刪除，查詢）
#(1).建立list：
a1 = ["john","tom","mike","jolin"]

#--------------
#(2).簡單查詢：取出第1位同學姓名：a[0]
#重點：串列的編號 = 實際數-1
print(a1[0])

#查詢第4位同學姓名：
print(a1[3])

#--------------
#(3).第1種新增：附加到最後：a.append(元素)
a1.append("marry")
print(a1)

#錯誤寫法：
print()
b1 = a1.append('jane')
print(b1)

#--------------
#(4).第2種新增：在某個編號位置index新增：a1.insert(編號位置,元素)
a1.insert(1,"peter")
print(a1)

#--------------
#(5).修改：把mike，改成Bob（a1[0] = '新值')
a1[3] = "Bob"
print(a1)

#--------------
#(6).第1種刪除：刪除某個編號index：a1.pop(編號)
a1.pop(0)
print(a1)

#--------------
#(7).第2種刪除：a1.pop()
#若是沒有指定編號，則刪除最後一個
a1.pop()
print(a1)

#--------------
#(8).第3種刪除：a1.remove(人名)
a1.remove("Bob")
print(a1)

#-------------- #(9).第4種刪除：刪除第1個元素：del a1[編號]
del a1[0]
print(a1)


成果圖片：
程式碼內容

範例5-2：list的四種查詢

#範例5-2：串列的四種查詢
b1 = ["john","tom","mike","jolin","marry"]

#------------------------
#(1).練習：顯示串tom的編號index：a.index(元素)
print(b1.index("tom"))

#練習：然後根據編號，刪除tom
b1.pop(b1.index("tom"))
print(b1)

#------------------------------
#(2).計算串列(list)長度函數：len(tuple)
#練習：查看目標群，還有幾人
print("敵方人數=", len(b1))
print()

#---------------------------
#(3).查詢jjohn是否在串列list內：
#☎方法：if txt in a

if "john" in b1:
print("還存在")
else:
print("不存在")

#-----------------------------------
#比較，計數迴圈 vs 串列迴圈
#（1）計數迴圈：for i in range(1,11,1)
print()
for i in range(1,11,1):
print("恭喜發財")

#（2）串列for迴圈:：for 元素 in 串列
print()
for item in b1:
print(item)


成果圖片：
程式碼內容

範例5-3：list的簡單排序

#範例5-3：串列的排序
#1.把元素排序
#觀念：list串列的特點，可以排序
#正向排序：a.sort()
#逆向排序：a.sort(reverse=True)


a1 = ["tom","mike","john","peter","marry"]
a1.sort()
print(a1)

a1.sort(reverse=True)
print(a1)


成果圖片：
程式碼內容

範例5-4：list的index編號

#範例5-4：串列/數組/列表，list的index編號
#https://www.w3schools.com/python/python_lists_access.asp
#https://www.w3school.com.cn/python/python_lists.asp
#建立list，6位同學
a1 = ["tom","john","marry","mike","jolin","peter"]

#1.search:1st item （index = num -1)
print(a1[0])
#1.search:2nd item
print(a1[1])

#2.Negative Index
#2.search:last item
print(a1[-1])

#2.search:2nd last item
print(a1[-2])

#3.範圍編號: Range of Indexes
#印：第3位，到，第5位
#重點：（index = num -1)
#編號是：第2號，到，第4+1號（最後一個號碼的前一號）
print(a1[2:5])

#4.範圍編號：從開始印到某位，from the beginning to....
#印出：第1位，到，第5位
#編號：第0號，到，第4+1號（最後一個號碼的前一號）
print(a1[:5])

#注意，尾數：不會印出
#注意，只會印出到，前1號

#5.範圍編號：從某位印到最後
#印出：第3位，到，最後
#編號：第2號，到，最後（不寫，就是最後）
print(a1[2:])

#6.範圍編號：從最後4位，到，最後1位的前1位
#注意，尾數：不會印出
print(a1[-4:-1])

#7.判別是否某元素(jolin)，在串列裡面
n1 = "jolin"
if n1 in a1:
print(n1, "是本班同學")
else:
print(n1,"不是本班同學")


成果圖片：
程式碼內容

範例5-3：串列(list)：類似傳統的陣列

7.#範例5-3：串列(list)：類似傳統的陣列
#(1).建立方法：
a = ['tom','mike','peter']

#(2).取出其中元素：a[0]
a = ['tom','mike','peter']
print('(2)', a[0])

#(3).計算串列(list)長度函數：len(tuple)
a=['tom','mike','peter']
b=len(a)
print('(3)',b)

#(4).修改串列(list)的某個元素：a[1] = '新值'
a=['tom','mike','peter']
a[1] = 'jane'
print('(4)',a)

#(5).顯示串列(list)的某個元素的編號index：a.index(元素)
a=['tom','mike','peter']
b = a.index('peter')
print('(5)',b)

#(6).新增一個元素到串列(list)的最後：a.append(元素)
a=['tom','mike','peter']
a.append('marry')
print('(6)',a)

#錯誤寫法：
b = a.append('marry')
print(b)

#(7).新增一個元素到串列(list)的某個位置：a.insert(位置,元素)
a=['tom','mike','peter']
a.insert(1,'marry')
print('(7)',a)

#(8).刪除第幾個元素：del a[編號]
a=['tom','mike','peter']
del a[1]
print('(8)',a)

#(9).刪除第幾個元素：a.pop(編號)
a=['tom','mike','peter']
a.pop(1)
print('(9)',a)
a.pop() #若是沒有指定編號，則刪除最後一個
print(a)

#(10).讀取串列裡面的每個元素：for 元素 in 串列
a=['tom','mike','peter']
for 元素 in a:
print(元素)

#(11).排序：a.sort()
a=['tom','mike','peter']
a.sort()
print('(11)',a)

#(11).把串列元素排序sorted(a)，反向排reversed(a)
a=['tom','mike','peter','yellow']
print('(11)','原始值=',a)
b = [i for i in reversed(a)]
print('反向=',b)
c = [i for i in sorted(a)]
print('排序=',c)
d = [i for i in reversed(sorted(a))]
print('反向排序=',d)

#(12).串列可以包含各種型態的資料
a=['a001','mike',90,85,65.5]
print('(12)',a)

#(13).連接兩個串列：+
a=['tom','mike','peter']
b=['張三','李四','王五']
print('(13)',a+b)

#(14).把字串或tuple轉換成list串列函數：list()
a='tom'
print('(14)',list(a))

#(15).將字串分割成串列（傳統的陣列）：字串.split('分隔字')
a='張三，李四，王五，趙六'
list_a = a.split('，')
print('(15)',list_a)

#(16).取出串列list的部分元素：a[開始:結束:間隔]
a=list('abcdefg')
print('(16)',a)
print(a[:]) #印出串列的每一個元素
print(a[1:]) #印出編號1位置後的每一個元素
print(a[:3]) #印出元素，直到編號3的前一個位置
print(a[2:5]) #印出編號2元素，直到編號5的前一個位置
print(a[0:7:2]) #印出編號0元素，直到編號7的前一個位置，間隔2
print(a[::-1]) #反轉字串，顛倒字串

#(17).拷貝複製串列，有三種方法：copy，[:]，=
#A.特色：listb=lista，這兩個串列指向同一個記憶體物件，若修改其中一個元素，另外一個也會跟著修改
#B.特色：listb=lista.copy()
#或是 listb=lista[:]
#這兩個串列是不同的記憶體物件，若修改其中一個元素，另外一個不會受到影響
a=['tom','mike','peter']
b = a.copy()
b[0] = 'bbb'
print('(17)',a)
print(b)
#################
c = a[:]
c[0] = 'ccc'
print(a)
print(c)
#################
d = a
d[0] = 'ddd'
print(a)
print(d)
成果圖片：
成果圖片：
程式碼內容

範例5-5：查詢元素是否在串列list內

#範例5-5：查詢元素是否在串列list內：
#☎方法1：一般一維串列：if txt in a
a=['tom','mike','peter','yellow']
def find_tuple(txt,a):
if txt in a:
return txt + '存在list內'
else:
return txt + '不存在list內'

s = input('請輸入查詢姓名？')
res = find_tuple(s,a)
print(res)

#☎方法2：一般一維串列：a.index(txt)
#[1,2,3].index(2) # => 1
#[1,2,3].index(4) # => ValueError

a=['tom','mike','peter','yellow']
s = input('請輸入查詢姓名？')
try:
res = a.index(s)
print(s+'找到了，在編號為'+str(res)+'的位置')
except ValueError:
print(s+'找不到')

#☎方法3：一般一維串列：[x+'找到了' for i,x in enumerate(a) if s==x]
a=['tom','mike','peter','yellow']
s = input('請輸入查詢姓名？')
#查詢方法1：
print([x+'找到了' for i,x in enumerate(a) if s==x])

#☎方法4：一般一維串列：for i,x in enumerate(a) if s==x
a=['tom','mike','peter','yellow']
s = input('請輸入查詢姓名？')

#查詢元素方法：
b = ['姓名為'+x for i,x in enumerate(a) if s==x]
if b==[]:
print('找不到')
else:
print(b)
成果圖片：
程式碼內容

python資料的四種儲存容器Containers

python資料的四種儲存容器Containers：
1.python資料的儲存容器有四種：序對tuple元組，串列(list)，字典(dict)，集合(set)

一.功用，用途：
(1).串列(list)：list串列，就類似Array陣列，a=[1,2,3]
(2).集合(set)：可以用來做數學的『交集，聯集』計算，a={1,2,3,4}
(3).字典(dict)：可以透過『文字』來存取資料（不需要用編號），a={'b1':'john','b2':'tom','b3':'jane'}
(4).序對tuple元組：
_A).tuple類似list串列（差異就是tuple={..}，list=[...]）。
_B).tuple可以是『字典(dict)，或集合(set)，或串列(List)』的元素。但是list串列無法成為別人的元素。


python資料的儲存容器特色：
python資料的儲存容器有四種：序對tuple，串列(list)，字典(dict)，集合(set)
(1).tuple特色：依序存儲資料，可以依照順序取出資料，但不能夠更改，是不可變的物件。
(2).串列(list)特色：可依序存儲資料，可以依照順序取出資料，也能夠更改。
(3).字典(dict)特色：儲存的資料為『鍵vs值』(key vs value)對應的資料。
(4).集合(set)特色：可儲存沒有次序性的資料。（若要搜尋某資料是否存在，而不根據鍵vs值的方式搜尋，就可以用集合set。

6.四種容器：範例6-0

#範例6-1：四種容器
#(1).串列(list)：list串列，就類似Array陣列，a=[1,2,3]
a = [1,2,3]
print('list=',a)
print('list[0]=',a[0])


#(2).集合(set)：可以用來做數學的『交集，聯集』計算，a={1,2,3,4}
b = {1,2,3,4}
c = {3,4,5}
print('b & c=',b & c)
print('b or c=', b | c)


#(3).字典(dict)：可以透過『文字』來存取資料（不需要用編號），a={'b1':'john','b2':'tom','b3':'jane'}
a={'b1':'john','b2':'tom','b3':'jane'}
print(a['b1'])


#(4).tuple類似list串列，a = ('tom','mike','peter')
a = (1,2,3)
print('a[0]=', a[0])
成果圖片：
程式碼內容

9.範例6-2：集合(set)：以{..}儲存的變數

9.範例6-2：集合(set)：以{..}儲存的變數
#(1).建立方法：兩種方法
#方法一：a = {1,2,3,4}
#方法二：b = set((1,2,'a','b'))


a = {1,2,3,4}
print('(1)',a)
b = set((1,2,'a','b'))
print(b)
c = set('today')
print(c)


#(2).空集合
#☎注意：空集合必須用a=set()
#不可以用a={}
#例如：
a=set()


#(3).新增一筆資料:a.add(元素)
a = set((1,2,'a','b'))
a.add('tom')
print('(3)',a)


#(4).刪除一筆資料:a.remove(元素)
a = set((1,2,'a','b'))
a.remove('b')
print('(4)',a)


#(5).把串列元素排序sorted(a)，反向排reversed(a)
#☎注意：都無效：sorted(a)，reversed(a)
a={'tom','mike','peter','yellow'}
print('(5).原始值=',a)
#b = {i for i in reversed(a)}
#print('反向=',b)
c = {i for i in sorted(a)}
print('排序=',c)
d = {i for i in reversed(sorted(a))}
print('反向排序=',d)


#(6).集合的運算：交集(&)，聯集(|)，差集(-)，互斥(^)
a = set('tiger')
b = set('bear')
print('(6)',a|b) #聯集(|)
print(a&b) #交集(&)
print(a-b) #差集(-)：元素存在a，但是不存在b
print(a^b) #互斥(^)：元素存在a但是不存在b，或元素存在b但是不存在a
print(a)





#(7).二維集合
#A.錯誤的二維集合寫法
#stu = {{'tom',190},{'mike',170},{'jane',200},{'peter',185}}


#B.二維集合寫法
stu = {('tom',190),('mike',170),('jane',200),('peter',185)}
#或是
stu = [('tom',190),('mike',170),('jane',200),('peter',185)]


#C.如何把二維串列，轉換成二維集合
#方法
#(i).先把內部的串列list用map()轉成tuple
#(ii).然後用set()再轉換成集合
#(ii).外面用list()轉換
#範例：
t=[[1, 7], [3, 7], [1, 7], [5, 8], [3, 7]]
t = list(set(map(tuple,t)))
print('(7)',t)
#結果：[(3, 7), (5, 8), (1, 7)]
#集合set裡面重複的，會自動刪除
#>>> t=[[1, 7], [3, 7], [1, 7], [5, 8], [3, 7]]
#>>> t = list(set(map(tuple,t)))
#>>> t
#[(3, 7), (5, 8), (1, 7)]
成果圖片：
程式碼內容

範例6-3：顯示一個對聯的文字集合（刪除標點符號）

#範例6-3：顯示一個對聯的文字集合（刪除標點符號）
a=" 天增歲月人增壽，春滿乾坤福滿門。 "
a.strip()
b = set(a)
b.remove('，')
b.remove('。')
b.remove(' ')
print(b)
成果圖片：
程式碼內容

範例6-4：顯比較兩段詩詞的共同字有哪些

(8).範例6-4：顯比較兩段詩詞的共同字有哪些？
#☎注意：若是要做集合的交集聯集差集，就必須把串列list或tuple轉成set
a="君問歸期未有期，巴山夜雨漲秋池。何當共翦西窗燭，卻話巴山夜雨時。"
b="雲想衣裳花想容，春風拂檻露華濃。若非群玉山頭見，會向瑤台月下逢。"
a = set(a)
a.remove('，')
a.remove('。')

b = set(b)
b.remove('，')
b.remove('。')

print(a&b) #使用交集，顯示交集的集合set
成果圖片：
程式碼內容

範例6-5：已知全班同學中數學及格名單，英文及格名單

(9).範例6-5：已知全班同學中數學及格名單，英文及格名單。
全班同學：張三，李四，王五，趙六，林七，陳八，孫九
數學及格：張三，李四，林七，陳八
英文及格：張三，李四，王五，陳八，孫九

請計算A.數學不及格名單，B.英文不及格名單，
C.英文與數學同時及格名單。
D.英文及格，但是數學不及格名單。

#☎注意：若是要做集合的交集聯集差集，就必須把串列list或tuple轉成set
#☎注意：set裡面的元素，一般都是用tuple()，或是list[]
全班同學 = set(('張三','李四','王五','趙六','林七','陳八','孫九'))
數學及格 = set(('張三','李四','林七','陳八'))
英文及格 = set(('張三','李四','王五','陳八','孫九'))
print('數學不及格=',全班同學-數學及格)
print('英文不及格=',全班同學-英文及格)
print('數學英文都及格=',數學及格 & 英文及格)
print('英文及格，但是數學不及格=',英文及格 - 數學及格)
成果圖片：
程式碼內容

python資料的四種儲存容器Containers

python資料的四種儲存容器Containers：
1.python資料的儲存容器有四種：序對tuple元組，串列(list)，字典(dict)，集合(set)

一.功用，用途：
(1).串列(list)：list串列，就類似Array陣列，a=[1,2,3]
(2).集合(set)：可以用來做數學的『交集，聯集』計算，a={1,2,3,4}
(3).字典(dict)：可以透過『文字』來存取資料（不需要用編號），a={'b1':'john','b2':'tom','b3':'jane'}
(4).序對tuple元組：
_A).tuple類似list串列（差異就是tuple={..}，list=[...]）。
_B).tuple可以是『字典(dict)，或集合(set)，或串列(List)』的元素。但是list串列無法成為別人的元素。


python資料的儲存容器特色：
python資料的儲存容器有四種：序對tuple，串列(list)，字典(dict)，集合(set)
(1).tuple特色：依序存儲資料，可以依照順序取出資料，但不能夠更改，是不可變的物件。
(2).串列(list)特色：可依序存儲資料，可以依照順序取出資料，也能夠更改。
(3).字典(dict)特色：儲存的資料為『鍵vs值』(key vs value)對應的資料。
(4).集合(set)特色：可儲存沒有次序性的資料。（若要搜尋某資料是否存在，而不根據鍵vs值的方式搜尋，就可以用集合set。

6.四種容器：範例7-0

#範例7-0：四種容器
#(1).串列(list)：list串列，就類似Array陣列，a=[1,2,3]
a = [1,2,3]
print('list=',a)
print('list[0]=',a[0])

#(2).集合(set)：可以用來做數學的『交集，聯集』計算，a={1,2,3,4}
b = {1,2,3,4}
c = {3,4,5}
print('b & c=',b & c)
print('b or c=', b | c)

#(3).字典(dict)：可以透過『文字』來存取資料（不需要用編號），a={'b1':'john','b2':'tom','b3':'jane'}
a={'b1':'john','b2':'tom','b3':'jane'}
print(a['b1'])

#(4).tuple類似list串列，a = ('tom','mike','peter')
a = (1,2,3)
print('a[0]=', a[0])
成果圖片：
程式碼內容

8.範例7-6：字典(dict)：類似傳統的結構struct物件，類別物件

#範例7-6：字典(dict)：類似傳統的結構struct物件，類別物件
#(1).建立方法：
a = {'tom':'湯姆','mike':'麥克','peter':'彼德'}
print('(1)',a['tom'])
print(a['mike'])

#(2).取出字典dict的某個元素，若不存在，用get()顯示錯誤訊息：
a = {'tom':'湯姆','mike':'麥克','peter':'彼德'}
print('(2)',a.get('jane'))
print(a.get('jane','找不到這個人'))

#(3).新增/修改字典dict的一個元素：a['鍵'] = '值'
a = {'tom':'湯姆','mike':'麥克','peter':'彼德'}
a['jane'] = '珍妮'
print('(3)',a)
a['peter'] = '彼得'
print(a)
print(a.get('jane','找不到這個人'))

#(4).刪除字典dict的一個元素：del a['鍵']
a = {'tom':'湯姆','mike':'麥克','peter':'彼德'}
del a['tom']
print('(4)',a)

#(5).刪除字典dict的所有元素：a.clear()
a = {'tom':'湯姆','mike':'麥克','peter':'彼德'}
a.clear()
print('(5)',a)

#(6).把串列轉換成字典dict格式：a.clear()
a = [['tom','湯姆'],['mike','麥克'],['peter','彼德']]
b = dict(a)
print('(6)',b)

a = (['tom','湯姆'],['mike','麥克'],['peter','彼德'])
b = dict(a)
print(b)

#(7).合併兩個字典dict格式：a.update(b)
a = {'tom':'湯姆','mike':'麥克','peter':'彼德'}
b = {'marry':'瑪麗','brown':'布朗'}
a.update(b)
print('(7)',a)

#(8).拷貝複製字典dict，有兩種方法：copy，=
#A.特色：dict_2=dict_1，這兩個字典指向同一個記憶體物件，若修改其中一個元素，另外一個也會跟著修改
#B.特色：dict_2=dict_1.copy()
#這兩個字典是不同的記憶體物件，若修改其中一個元素，另外一個不會受到影響

a = {'tom':'湯姆','mike':'麥克','peter':'彼德'}
b = a.copy()
b['tom'] = '唐木'
print('(8)',a)
print(b)
#################
d = a
d['mike'] = '脈課'
print(a)
print(d)

#(9).讀取字典dict的鍵，值：for 鍵,值 in 字典
a = {'tom':'湯姆','mike':'麥克','peter':'彼德'}
#(A).讀取字典的所有值
for value in a.values():
print('(9)',value)

#(B).讀取字典的所有鍵
for key in a.keys():
print(key)

#(C).讀取字典的所有鍵＋值
for key,value in a.items():
print(key,'，',value)

#(10).把字典元素排序sorted(a)，反向排reversed(a)
a = {'tom':'湯姆','mike':'麥克','peter':'彼德'}
print('(10)','原始值=',a)
b = {k:v for k,v in sorted(a.items())}
print('排序=',b)

#(11).如何使用enumerate列舉方法來顯示字典dict
#方法：for i, (k, v) in enumerate(mydict.items())
#☎注意：enumerate(mydict.items())裡面的字典，必須要寫items()，不可以只有寫dict

#範例：
a = {'tom':'湯姆','mike':'麥克','peter':'彼德'}
#顯示第一維tuple元素
print('(11)',[x+'的姓名為'+y for i,(x,y) in enumerate(a.items())])
成果圖片：
成果圖片：
程式碼內容

範例7-8：製作英翻中字典（貓狗魚豬），若是沒有該字顯示找不到

#範例7-8：製作英翻中字典（貓狗魚豬），若是沒有該字顯示找不到
#☎注意：若是要對應關係，就要用字典dict
a = {'cat':'貓','dog':'狗','fish':'魚','pig':'豬'}
print(a)
print(a.keys())
b = input('請輸入查詢的英文？')
print(a.get(b,'找不到這個字'))
成果圖片：
程式碼內容

範例7-12：輸入三位班上同學姓名，email，然後提供查詢

(10).範例7-12：輸入三位班上同學姓名，email，然後提供查詢
#☎注意：若是要對應關係，就要用字典dict
#☎注意：若是要搜尋資料表，就可以用字典dict
#☎注意：字典dict的新增元素方法： stu[a1] = b1
#☎注意：字典dict的查詢元素方法： stu.get(a1,'找不到')
stu = dict() # 空的字典
# 輸入三個新的同學資料
a1 = input('輸入同學姓名？')
b1 = input('輸入同學email？')
stu[a1] = b1
a1 = input('輸入同學姓名？')
b1 = input('輸入同學email？')
stu[a1] = b1
a1 = input('輸入同學姓名？')
b1 = input('輸入同學ema+il？')
stu[a1] = b1
print(stu)
# 查詢
a1 = input('輸入你要查詢的同學姓名？')
result = stu.get(a1,'找不到這個學生')
print(result)
成果圖片：
程式碼內容

python資料的四種儲存容器Containers

python資料的四種儲存容器Containers：
1.python資料的儲存容器有四種：序對tuple元組，串列(list)，字典(dict)，集合(set)

一.功用，用途：
(1).串列(list)：list串列，就類似Array陣列，a=[1,2,3]
(2).集合(set)：可以用來做數學的『交集，聯集』計算，a={1,2,3,4}
(3).字典(dict)：可以透過『文字』來存取資料（不需要用編號），a={'b1':'john','b2':'tom','b3':'jane'}
(4).序對tuple元組：
_A).tuple類似list串列（差異就是tuple={..}，list=[...]）。
_B).tuple可以是『字典(dict)，或集合(set)，或串列(List)』的元素。但是list串列無法成為別人的元素。


python資料的儲存容器特色：
python資料的儲存容器有四種：序對tuple，串列(list)，字典(dict)，集合(set)
(1).tuple特色：依序存儲資料，可以依照順序取出資料，但不能夠更改，是不可變的物件。
(2).串列(list)特色：可依序存儲資料，可以依照順序取出資料，也能夠更改。
(3).字典(dict)特色：儲存的資料為『鍵vs值』(key vs value)對應的資料。
(4).集合(set)特色：可儲存沒有次序性的資料。（若要搜尋某資料是否存在，而不根據鍵vs值的方式搜尋，就可以用集合set。

6.四種容器：範例8-0

#範例8-0：四種容器
#(1).串列(list)：list串列，就類似Array陣列，a=[1,2,3]
a = [1,2,3]
print('list=',a)
print('list[0]=',a[0])

#(2).集合(set)：可以用來做數學的『交集，聯集』計算，a={1,2,3,4}
b = {1,2,3,4}
c = {3,4,5}
print('b & c=',b & c)
print('b or c=', b | c)

#(3).字典(dict)：可以透過『文字』來存取資料（不需要用編號），a={'b1':'john','b2':'tom','b3':'jane'}
a={'b1':'john','b2':'tom','b3':'jane'}
print(a['b1'])

#(4).tuple類似list串列，a = ('tom','mike','peter')
a = (1,2,3)
print('a[0]=', a[0])
成果圖片：
程式碼內容

6.tuple：範例8-1

#範例8-1：tuple：
#(1).建立方法1：
a = 'tom','mike','peter'
#建立方法2：
a = ('tom','mike','peter')

#(2).取出其中元素：a[0]
a = ('tom','mike','peter')
print(a[0])

#(3).將tuple指定給多個變數：a,b,c = tuple
a,b,c = ('tom','mike','peter')
print(a)

#(4).將兩個tuple變數交換：a,b = b,a
a=('tom','mike')
b=(1,2,3)
print('交換前，a=',a,'b=',b)
a,b = b,a
print('交換後，a=',a,'b=',b)
print(a)

#(5).轉換tuple函數：tuple(串列)
a=('tom','mike','peter')
b=tuple(a)
print(b)

#(6).計算tuple長度函數：len(tuple)
a=('tom','mike','peter')
b=len(a)
print(b)

#(7).只有一個tuple元素，必須加上,：('tom',)
a=('tom',)
print(a)

#(8).把tuple元素排序sorted(a)，反向排reversed(a)
a=('tom','mike','peter','yellow')
print('原始值=',a)
b = [i for i in reversed(a)]
print('反向=',b)
c = [i for i in sorted(a)]
print('排序=',c)
d = [i for i in reversed(sorted(a))]
print('反向排序=',d)

#或是，反向排序
print(sorted(a, reverse=True))
成果圖片：
程式碼內容