https://www.python.org/shell/（建議用這個）

https://repl.it/languages/python3

https://www.onlinegdb.com/online_python_compiler

https://www.tutorialspoint.com/execute_python_online.php

給初學者用python編輯器MU（要下載安裝）

micro:bit單晶片的python編輯器MU（要下載安裝）

micro:bit單晶片的線上python編輯器

到Anacond官網下載安裝

2.執行python的三種方法

陽春python下載點

python官網

vscode下載點

vscode官網

python簡介

AI人工智慧興起，未來AI的發展將徹底改變這個世界。而Python正是人工智慧領域最熱門的程式語言。學習Python，就是掌握人工智慧的能力。
Python語法簡單好寫，背後社群強大，所以在數據分析領域本就佔有一席之地，現在部分流行的開源軟體和套件，也都是以Python作為主要實作語言。
現在因為AI的盛行，促進深度學習的風靡，Python作為大部分深度學習套件選用的程式語言，Python也榮登2017年最受學界、業界，以及開源軟體界中最受歡迎的程式語言第一名。

比較圖：各種程式語言2012～2018年的興衰趨勢：python，javascript，java，c#，php，c++


比較圖：TIOBE Index for December 2022（程式語言使用度與受歡迎程度）：



各種深度學習(deep learning)框架：



可以發現世界前10大的深度學習框架中，有7種都可以結合python來開發
知名的機器學習框架，例如谷歌的TensorFlow 、Facebook的PyTorch， 麻省理工學院MIT的Julia. （其中谷歌推出 python for TensorFlow 及 Swift for TensorFlow兩種語言）

安裝步驟

1.安裝步驟影片教學

2.安裝步驟文字教學

特別注意1：要打勾Add Python 3.74 to PATH，然後點“Install Now”即可完成安裝

特別注意2：在Advanced Options：要打勾：for all the users

print("你好，歡迎光臨")

1+1

print("你好，歡迎光臨")

1+1

print("你好，歡迎光臨")

1+1

在cmd模式，執行dos終端機指令

先到工作目錄：cd ch1

執行.py程式：python test1.py

2.執行python的三種方法

2.Anaconda下載點

Anacond官網

範例1-1：輸出

輸入

範例1-2

註解符號

pyhon程式結尾不需要;

print在3.X被改為函式

範例1-3：print多個變數

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

範例1-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：

python的缩排格式

python的缩排格式：
(1)c#,javascript,php的縮排格式：
利用{.....}

(2)python的縮排格式：
利用:以及tab（或是4個空白鍵）
例如：
if(a>b):
c='大於'

1.雙向選擇

1.雙向選擇
if a>=60:
print('及格')
else：
print('不及格')

注意1：用:取得c++的{}
注意2：這個程式的缩排格式必須固定

第3章

主目錄

範例5-1:判斷數字奇數，或偶數

範例5-1:判斷數字奇數，或偶數
a = int(input('輸入a = '))
if a%2==0:
print('偶數')
else:
print('奇數')
成果圖片：
程式碼內容

第3章

主目錄

2.多向選擇

2.多向選擇
a = int(input('輸入a = '))
if a>=85:
print('優等')
elif a>=70 and a<85:
print('中等')
else:
print('不及格')

第3章

主目錄

範例5-2:判斷a，b數字誰大

範例5-2:判斷a，b數字誰大
a = int(input('輸入a = '))
b = int(input('輸入b = '))
if a>b:
print(a,'>',b)
elif a==b:
print(a,'=',b)
else:
print(a,'<',b)
成果圖片：
程式碼內容

第3章

主目錄

3.範例5-3：運算子in的判斷

3.運算子in的判斷
範例5-3：判斷tuple是否包含某元素
name = input('輸入姓名（tom,mike,jane)')
a = ('tom','mike','jane')
if name in a:
print(name,'在班級成員a裡面')
else:
print(name,'不在班級成員a裡面')
成果圖片：
程式碼內容

第3章

主目錄

(2).範例5-4：判斷串列/數組list是否包含某元素

(2).範例5-4：判斷串列/數組list是否包含某元素
name = input('輸入英文字母')
a=list('edgttgsaogq')
if name in a:
print(name,'在list a裡面')
else:
print(name,'不在list a裡面')
成果圖片：
程式碼內容

第3章

主目錄

(3).範例5-5：判斷字典dict是否包含某元素

(3).範例5-5：判斷字典dict是否包含某元素
#☎注意：字典dict的判斷查詢只能查鍵keys（不是查值values)

a = {'tom':'湯姆','mike':'麥克','peter':'彼德'}
name = input('輸入姓名（tom, mike,pteer）')
if name in a:
print(name,'在姓名dict裡面')
else:
print(name,'不在姓名dict裡面')
成果圖片：
程式碼內容

第3章

主目錄

(4).範例5-6：判斷集合set是否包含某元素

(4).範例5-6：判斷集合set是否包含某元素
a = set('tommikepeter')
name = input('輸入因為字母？')
if name in a:
print(name ,'在英文字母set裡面')
else:
print(name ,'不在英文字母set裡面')
成果圖片：
程式碼內容

第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()

第4章

主目錄

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章

主目錄

範例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)
成果圖片：
程式碼內容

第4章

主目錄

(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章

主目錄

範例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-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)
成果圖片：
成果圖片：
程式碼內容

第4章

主目錄

(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)
成果圖片：
程式碼內容

第4章

主目錄

(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章

主目錄

範例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)
成果圖片：
程式碼內容

第4章

主目錄

(10).while迴圈

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

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

第4章

主目錄

範例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章

主目錄

範例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章

主目錄

範例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章

主目錄

範例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章

主目錄

範例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('猜小了')
成果圖片：
程式碼內容

第4章

主目錄

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章

主目錄

範例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章

主目錄

範例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章

主目錄

範例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章

主目錄

範例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章

主目錄

範例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章

主目錄

範例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-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)
成果圖片：
程式碼內容

第5章

主目錄

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.四種容器：範例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])
成果圖片：
程式碼內容

第6章

主目錄

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章

主目錄

範例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章

主目錄

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

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

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

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

第6章

主目錄

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。

第7章

主目錄

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])
成果圖片：
程式碼內容

第7章

主目錄

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章

主目錄

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

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

第7章

主目錄

範例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)
成果圖片：
程式碼內容

第7章

主目錄

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])
成果圖片：
程式碼內容

第8章

主目錄

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))
成果圖片：
程式碼內容

第8章

主目錄

1.不傳回值的函數：

1.不傳回值的函數：
(1).公式：
def 函數名稱(參數1,參數2):
函數內容

範例9-1：計算1+2+3..+n總和函數

範例9-1：呼叫計算1+2+3..+n的總和的函數
#☎注意：計算1～10，但是在range裡面要寫成for i in range(1,11)
def sum(n):
sum = 0
for i in range(1,n+1):
sum += i
print(sum)

sum(10)
成果圖片：
程式碼內容

第9章

主目錄

2.有傳回值的函數：

2.有傳回值的函數：
(1).公式：
def 函數名稱(參數1,參數2):
函數內容
return 變數

範例9-2：呼叫計算四方形面積函數

範例9-2：呼叫計算四方形面積的函數
def area(a,b):
s = a*b
return s

result = area(25,35)
print(result)
成果圖片：
程式碼內容

第9章

主目錄

3.全域變數，區域變數

3.全域變數，區域變數
全域變數：在最外層的變數，例如result
區域變數：在函數內層的變數，例如s

4.如何使用全域變數：global

4.在函數內的區域，如何使用全域變數：global
def test():
global var1
var1 = 10
print('inside=',var1)-

var1 = 5
print('before=',var1)
test()
print('after=',var1)

第9章

主目錄

6.範例9-4：如何接收多個函數回傳值

6.範例9-4：如何接收多個函數回傳值
範例9-3：已知半徑，要接受傳回的圓周長，圓面積
def circle(r):
a1 = 2 * 3.14 * r
a2 = 3.14 * r * r
return (a1,a2)

r = float(input('輸入半徑='))
b1,b2 = circle(r)
print('圓周長=',b1,'，圓面積=', b2)
成果圖片：
程式碼內容

第9章

主目錄

14.範例9-13：兩種內建排序函數：sort和sorted

14.範例9-13：Python提供兩種內建排序的函數：sort()和sorted()
(1).公式：
sort是容器的函數：sort(cmp=None, key=None, reverse=False)
sorted是python的內建函數：sorted(iterable, cmp=None, key=None, reverse=False)

■iterable：可疊代對象。
■cmp：比較的函數，這個具有兩個參數，參數的值都是從可疊代對象中取出，

此函數必須遵守的規則為，大於則返回1，小於則返回-1，等於則返回0。
■key：主要是用來進行比較的元素，只有一個參數，具體的函數的參數就是取自於可疊代對象中，指定可疊代對象中的一個元素來進行排序。
■reverse：排序規則，reverse = True 降序 ， reverse = False 升序（默認）。

(2).特色比較：
這兩個function都可以用來排序一個list
差別在於
sorted()會回傳一個排序好新的list
sort()會直接修改原始的list並排序完成

(3).範例:
a = [2, 4, 3, 5, 1]
sorted(a)
結果：[1, 2, 3, 4, 5]
print(a)
結果：[2, 4, 3, 5, 1]
a.sort()
print(a)
結果：[1, 2, 3, 4, 5]

(4).結論：
如果原始的list不需要保留下來的話，可以使用sort()來排序
如果要保留原本的list，就用sorted()來產生一個排序好的新list

(5).注意：sorted()應用性比較廣
sort()只能用在list上排序，
而sorted()可用來排序任何的iterable(string, 字典dict, tuple...)
成果圖片：
程式碼內容

第9章

主目錄

範例9-13：一般排序

(6).範例9-13：一般排序
s = [190,170,200,185]
print('原始=',s)
sorted(s)
print('sorted=',s)
ss = sorted(s)
print('ss = sorted(s)=',ss)
s.sort()
print('s.sort()=',s)
成果圖片：
程式碼內容

第9章

主目錄

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

(2).範例9-20：查詢元素是否在串列list內，
一般一維串列：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)
成果圖片：
程式碼內容

第9章

主目錄

範例9-21：一維串列：a.index(txt)

範例9-21：一般一維串列：a.index(txt)
[1,2,3].index(2) # => 1
[1,2,3].index(4) # => ValueError

a=['tom','mike','peter','yellow']
name = input('請輸入查詢姓名？')
try:
res = a.index(name)
print(name+'找到了，在編號為'+str(res)+'的位置')
except ValueError:
print(name+'找不到')
成果圖片：
程式碼內容

第9章

主目錄

Try-catch

1.Try-catch
(1).語法：
try:
# 你要執行的程式
except <錯誤類型>:
# 發生錯誤時要執行的程式

範例10-1：要輸入數字，但是卻輸入字母，出現錯誤

(2).範例10-1：要輸入數字，但是卻輸入字母，出現錯誤
範例：exp10-1.py：
try:
a = int(input('請輸入數字='))
except:
print('出現錯誤')
程式碼內容

知道錯誤原因（ValueError）就可以指定錯誤種類

(3).若是知道出現錯誤的原因是（ValueError）就可以指定錯誤種類，否則都不知道，就用except
語法：
try:
a = int(input('請輸入數字='))
except ValueError:
print('出現資料型態錯誤')
程式碼內容

範例10-2：除到0，則錯誤型態是ZeroDivisionError

(4).範例-2：若是除法，除到0，則錯誤的型態是（ZeroDivisionError）
範例9-2：
try:
a = 3/0
except ZeroDivisionError:
print('除法除到0')
程式碼內容

範例10-3：不知道錯誤原因用except

(5).範例10-3：：出現錯誤的原因有太多種了，若是根本不知道錯誤原因的寫法，乾脆就用except就好了

try:
a = 9/0
except Exception as e:
print('不明錯誤，原因=',e)
程式碼內容

範例10-4：完整寫法：try-except-else-finally

(6).範例10-4：完整寫法：try-except-else-finally
A.語法：
try:
....
except:
....
else:
...
finally:
...
B.範例：exp09_05.py：寫一個函數除法divide(a,b)
def divide(a,b):
try:
num = a/b
except Exception as e:
print(a,'/',b,'=','出現錯誤，原因=',e)
else:
print(a,'/',b,'=',num)

divide(5,3)
divide(5,0)
divide(5,'abc')
程式碼內容

1.範例11-1：模組module

1.範例11-1：模組module
(1).觀念：一個python檔案，就是一個模組，可以被另外一個python程式給引進來使用。

(2).使用系統模組
(A).使用亂數（顯示剪刀石頭布）
import random
a = ['剪刀','石頭','布']
b = random.choice(a)
print(b)

(B).開新檔guess.py，建立函數mypalm()
import random
def mypalm():
a = ['剪刀','石頭','布']
b = random.choice(a)
return b

存檔guess.py

(3).開啟新的檔案guess2.py，然後匯入guess.py的全部模組
import guess
res = guess.mypalm()
print(res)

(4).開啟新的檔案guess3.py，然後匯入guess.py的某個模組
只匯入需要的特定模組
☎注意：import模組不要加()：import mypalm
☎注意：但是宣告為模組變數，要有()，gs()

from guess import mypalm
res = mypalm()
print(res)

(5).使用別名匯入模組
☎特別注意：要有()，gs()
from guess import mypalm as gs
res = gs()
print(res)
guess.py程式碼內容
exp11-1.py程式碼內容

2.套件packages

2.套件packages
(1).特色：在一個python資料夾下有很多的*.py檔，若再加上__init__.py，這個資料夾就形成一個套件

(2).例如：
資料夾名稱：game
檔案1：dice.py
檔案2：poker.py
檔案3：__init__.py


這個時候，套件形成，套件名稱= game

(3).套件的用途：可以由目錄名稱（套件名稱）來引用該目錄下所有的py檔案裡面的模組來使用
例如：from game import dice,poker

範例11-2：丟骰子,撲克牌

(4).範例11-2：丟骰子,撲克牌(使用套件packages法)
A.在test1裡面建立一個資料夾：game
B.（在test1/game目錄內）檔案1：dice.py
import random
def show():
a = ['1點','2點','3點','4點','5點','6點']
b = random.choice(a)
return b

C.（在test1/game目錄內）檔案2：poker.py
import random
def show():
a = ['1','2','3','4','5','6','7','8','9','10','11','12','13']
b = ['黑桃','梅花','紅心','方塊']
c = random.choice(b)+random.choice(a)
return c

D.（在test1/game目錄內）建立檔案3：__init__.py


E.（在test1目錄內）建立檔案4：exp11-2.py
☎注意：公式：from 套件名稱 import 模組名稱1,模組名稱2
☎注意：公式：from 目錄名稱 import 檔案名稱1,檔案名稱2
from game import dice, poker
print('你的骰子是 ',dice.show())
print('你的撲克牌是 ',poker.show())
dice.py程式碼內容
poker.py程式碼內容
exp11-2.py程式碼內容

範例11-3：開出樂透6個數字

(5).範例11-3：開出樂透6個數字（產生1~48其中的6個數字，不可以重複），將結果小到大排序
☎思路：因為不可以重複，所以必須有一個48個元素的串列num48，開出一個就刪除num48
☎單一程式：
import random
numlotto =[]
num48 = [i for i in range(48)]
print(num48)
for i in range(6):
#n1 = random.randint(1,48)
n1 = random.choice(num48)
numlotto.append(n1)
num48.remove(n1)
print(numlotto)
print(num48)
exp11-3.py程式碼內容

(6).範例11-4：把exp11-3拆解成兩個檔案
☎A).第一個模組:分拆成一個專門產出樂透數字的檔案模組：lotto.py
import random
def show(Num_total,Num_lotto):
a_lotto = []
a_total = [i for i in range(Num_total)]
#print(num48)
for i in range(Num_lotto):
#n1 = random.randint(1,Num_total)
n1 = random.choice(a_total)
a_lotto.append(n1)
a_total.remove(n1)
return a_lotto

☎B).主要檔案：exp11-4.py
import lotto_module
prize = lotto_module.show(48, 6)
print(prize)
lotto.py程式碼內容
exp11-4.py程式碼內容

1.資料夾模組:os

1.功能：刪除資料夾（檔案），儲存資料夾（檔案），修改資料夾（檔案），查詢資料夾（檔案）

2.模組：os
(1).常用指令：
#重點1：os模組
#（1）os模組：是一種與作業系統相關的模組，提供數十種與作業系統溝通的函式，常用於檔案的複製、修改、查詢等

#重點2：OS模組，常用指令：
#☎ import os
#☎ 到指定目錄：os.chdir("目錄"）
#☎ 回傳目前資料夾名稱：os.getcwd(）

#☎ 顯示子目錄與檔案清單的指令，有2個方法：
#☎ （1）!ls
#☎ （2）os.listdir(）

#☎ 判別目前是資料夾嗎？：os.path.isdir("目錄"）
#☎ 判別目前是檔案嗎？：os.path.isfile("目錄"）
#☎ 回傳目前檔案大小：os.path.getsize("目錄"）
#☎ 建立資料夾名稱：os.mkdir("目錄",dir_fd=None）
#☎ 刪除資料夾名稱：os.rmdir("目錄",dir_fd=None）
#☎ 刪除檔案名稱：os.remove("目錄",dir_fd=None）
#☎ 顯示目錄與檔案名稱：os.path.join("目錄","檔案名稱")

範例12-1:建立目錄,刪除目錄,顯示檔案

(2).範例12-1.py
import os
#顯示目前目錄
a1 = os.getcwd()
print('目前目錄=',a1)
#到c:\\目錄
os.chdir('c:\\')
a1 = os.getcwd()
print('目前目錄=',a1)
#顯示所有目錄與檔案
a2= os.listdir(a1)
print('所有目錄與檔案=',a2)
#只顯示目錄
for i in a2:
if os.path.isdir(i)==True:
print('這個是目錄=',i)
elif os.path.isfile(i)==True:
print('這個是檔案=',i)
print('檔案大小=',os.path.getsize(i))
#建立一個目錄
os.mkdir('test')
#刪除一個目錄
os.rmdir("test")
成果圖片：
程式碼內容

範例12-2:把該目錄下方的資料夾以串列顯示

(3).範例12-2.py
目的：類似上個範例，用一行的for迴圈，把該目錄下方的資料夾以串列顯示
import os
#到c:\\目錄
os.chdir('c:\\')
a1 = os.getcwd()
print('目前目錄=',a1)
#顯示所有目錄與檔案
a2= os.listdir(a1)
#只顯示目錄
print('這個是目錄=',[i for i in a2 if os.path.isdir(i)==True])
print('這個是檔案=',[i for i in a2 if os.path.isfile(i)==True])
成果圖片：
程式碼內容

範例12-3:到某個目錄查詢指定檔案名稱

2.模組：glob
(1).常用指令：
import glob
#☎到某個目錄查詢指定檔案名稱：os.glob.glob(指定檔名）

(4).範例12-3.py
目的：到某個目錄查詢指定檔案名稱(*.jpg)：os.glob.glob(指定檔名）
import os, glob
os.chdir('c:\\')
folder1 = os.getcwd()
file1 = '*.jpg'
a1 = glob.glob(file1)
print(a1)
程式碼內容

範例12-4:顯示目前目錄下的完整路徑（目錄+檔案名稱）

(5).範例12-4.py
目的：顯示目前目錄下的完整路徑（目錄+檔案名稱）
#☎顯示目錄與檔案名稱：os.path.join(目錄名稱,檔案名稱)
#☎注意：如果用手動連接，會出現錯誤：print(d1+'\'+i)

import os
a1 = os.listdir()
#print(a1)
#目前目錄名稱
d1 = os.getcwd()
#每個檔案都顯示完整路徑
for i in a1:
#注意用手動連接，會出現錯誤：print(d1+'\'+i)
print(os.path.join(d1,i))
程式碼內容

範例12-5:更有效率的顯示目前目錄下的完整路徑

(6).範例12-5.py
目的：更有效率的顯示目前目錄下的完整路徑（目錄+檔案名稱）：os.walk

(path)
#☎快速的完整顯示目錄與檔案名稱：for root,dirs,files in os.walk(path)
#☎顯示目錄與檔案名稱：os.path.join(目錄名稱,檔案名稱)
#☎注意：如果用手動連接，會出現錯誤：print(d1+'\'+i)

import os
#目前目錄名稱
d1 = os.getcwd()
#快速吸收每個檔案都顯示完整路徑
for root,dirs,files in os.walk(d1):
for file in files:
#注意用手動連接，會出現錯誤：print(d1+'\'+i)
print(os.path.join(root, file))
程式碼內容

3.存取文字檔

3.存取文字檔
(1).常用指令
#☎開啟檔案：a1 = open(檔名,模式mode,文字子編碼)
a1 = open('exp11_01.py','rt',encoding='utf-8')
#☎模式mode種類：
r：只能讀取
w：可以寫入（會先刪除原先的檔案）
x：可以寫入（但是檔案不能已經存在，避免覆蓋）
a：可以寫入（把寫入資料，寫在檔案最後加入）
t：純文子檔
b：二進位檔
+：可以讀取，可以寫入
#☎讀取全部檔案：a1.read()
#☎讀取檔案裡面的一行：a1.readline()
#☎讀取檔案裡面的每一行，並把它們變成串列：a1.readlines()
#☎把字串寫入檔案：a1.write(字串)
#☎把字串寫入檔案：print(字串,file=檔案物件)
檔案物件 = open('exp11_01.py','rt',encoding='utf-8')

範例12-6:讀取exp12-1.py的所有內容

(1).範例12-6.py
目的：讀取exp12-1.py的所有內容
f1 = 'exp12-1.py'
a1 = open(f1,'rt',encoding='utf-8')
print(a1.read())
a1.close()
程式碼內容

範例12-7:使用迴圈，一行一行讀取exp12-1.py的所有內容

(2).範例12-7.py
目的：使用迴圈，一行一行讀取exp12-1.py的所有內容
f1 = 'exp11_01.py'
a1 = open(f1,'rt',encoding='utf-8')
for i in a1:
print(i)
a1.close()
程式碼內容

範例12-8:讀取目前目錄下所有檔案的文字內容

(3).範例12-8.py
目的：讀取目前目錄下所有檔案的文字內容
import os
a1 = os.listdir()
for i in a1:
if os.path.isfile(i)==True:
print('檔案名稱=',i)
f1 = open(i,'rt',encoding='utf-8')
print(f1.read())
f1.close()
程式碼內容

範例12-9:存入exp12-10.py，印出新年快樂

(4).範例12-9.py
目的：寫一個程式，存入exp12-10.py，印出『新年快樂』
f1 = 'exp12-10.py'
txt ="""
s1 = input('輸入您的姓名=')
print(s1,'新年快樂')
"""
#將程式寫入檔案內
a1 = open(f1,'wt',encoding='utf-8')
a1.write(txt)
a1.close()
程式碼內容

範例12-11：存入exp12-10.py，印出新年快樂,但是用try...except

(5).範例12-11.py
目的：寫一個程式，存入exp12-10.py，印出『新年快樂』,但是用try...except

測試寫入程式是否發生問題？
f1 = 'exp12-10.py'
txt ="""
s1 = input('輸入您的姓名=')
print(s1,'新年快樂')
"""
#將程式寫入檔案內
try:
a1 = open(f1,'twt',encoding='utf-8')
a1.write(txt)
a1.close()
except:
print('無法寫入檔案')
程式碼內容

1.日期時間函式庫

1.日期時間函式庫
(1).時間函式庫有三個：datetime，date，time模組
模組datetime：可以處理日期與時間函式庫，可以傳回目前的日期，時間
模組date：可以傳回目前的日期

範例13-1:模組datetime（顯示日期，時間

(2).範例13-1:模組datetime（顯示日期，時間）
公式：
from datetime import datetime
a1 = datetime.today()
y1 = a1.year
範例13-1.py
from datetime import datetime
a1 = datetime.today()
print('現在日期時間 =',a1)
y1 = a1.year
m1 = a1.month
d1 = a1.day
h1 = a1.hour
min1 = a1.minute
s1 = a1.second
print(y1,'年',m1,'月',d1,'日',h1,'時',min1,'分',s1,'秒')
程式碼內容

範例13-2:模組date（只能顯示日期）

(3).模組date（只能顯示日期）
公式：
from datetime import date
a1 = datetime.today()
y1 = a1.year

範例13-2.py
from datetime import date
a1 = date.today()
print('現在日期=',a1)
y1 = a1.year
m1 = a1.month
d1 = a1.day
print(y1,'年',m1,'月',d1,'日')
程式碼內容

範例13-3:模組timedelta（間隔日期，時間）

(4).模組timedelta（間隔日期，時間）
公式：
from datetime import datetime,timedelta
a1 = datetime.today()
delta2 = timedelta(days=5)
a2 = a1 + delta2

範例13-3.py
from datetime import datetime,timedelta
a1 = datetime.today()
print('今天是=',a1)
delta2 = timedelta(days=5)
a2 = a1 + delta2
print('5天後=',a2)
delta3 = timedelta(hours=3)
a3 = a1 +delta3
print('3小時後=',a3)
程式碼內容

範例13-4:傳回自1970年1月1日凌晨0：0：0開始至今的秒數

(5).模組time（時間）
公式：
import time
t1 = time.time()

功能：傳回自1970年1月1日凌晨0：0：0開始至今的秒數

範例13-4.py
import time
t1 = time.time()
print('1970年至今的秒數=',t1)
程式碼內容

範例13-5：計算呼叫某個函式所需要的時間

範例13-5.py
目的：計算呼叫某個函式所需要的時間
import time
def func():
[i for i in range(9999999)]
t1 = time.time()
func()
t2 = time.time()
print('函式執行時間 = ', t2-t1)
程式碼內容

2.可以迭代（iterate）的函式庫= itertools，函式enumerate，zip，filter，map，reduce

2.可以迭代（iterate）的函式庫
(1).種類：迭代模組或函式 = itertools，函式enumerate，zip，filter，map，reduce

(2).enumerate(a)是列舉函數（編號i，元素x）
☎功能：可以把每一個元素加上編號
☎配合list：list(enumerate(a)))
☎顯示一維串列：print((x for i,x in enumerate(a)))
☎顯示二維串列：print((x[0]+'姓名是'+x[1] for i,x in enumerate(a)))

範例13-6:顯示陣列

☎範例13-6.py
a=['tom','mike','peter','yellow']
#for顯示陣列
for i in a:
print(i)
#enumrate顯示陣列 enumerate
print([x for i,x in enumerate(a)])

#enumrate顯示陣列 enumerate
print(list(enumerate(a)))

b = (('tom','湯姆'),('mike','麥克'),('peter','彼德'))
#for顯示陣列
for i in b:
print(i)
for i in b:
print(i[0],',',i[1])
#enumrate顯示二維陣列 enumerate
print([x[0] for i,x in enumerate(b)])
程式碼內容

範例13-7:zip(a,b)是結合兩個可迭代物

(3).zip(a,b)是結合兩個可迭代物件
☎功能：結合兩個可迭代物件，對應結合成一個新的物件
☎必須配合list：list(zip(a, b)))

☎範例13-7.py
a = ['tom','mike','peter','yellow']
b = [95,85,66,75]
#結合兩個可迭代物件
c = zip(a, b)
print(list(c))
程式碼內容

範例13-8:模組itertools:給定起始值，遞增值，就可以產生無窮數列

(4).模組itertools
功能：給定起始值，遞增值，就可以產生無窮數列
☎範例13-8.py
import itertools
# itertools.count(起始值,遞增值)
nums = itertools.count(1,2)
#print(list(nums))
#結果： 1 3 5 7 9....

# itertools.cycle(資料列)
nums = [1,2,3]
newnums = itertools.cycle(nums)
#print(list(newnums))
#結果： 1 2 3 1 2 3 1 2 3....

# itertools.repeat(資料列,次數)
nums = [1,2,3]
newnums = itertools.repeat(nums,2)
#print(list(newnums))
#結果： [[1,2,3],[1,2,3],]....

# itertools.accumulate(資料列)
nums = [1,2,3,4,5,6]
newnums = itertools.accumulate(nums)
print(list(newnums))
#結果： [1, 3, 6, 10, 15, 21]

# itertools.chain(資料列)
newnums = itertools.chain('how','are you')
print(list(newnums))
#結果： ['h', 'o', 'w', 'a', 'r', 'e', ' ', 'y', 'o', 'u']

# itertools.combinations(資料列',取n個)
newnums = itertools.combinations('ABC',2)
print(list(newnums))
#結果： [('A', 'B'), ('A', 'C'), ('B', 'C')]

# itertools.permutations(資料列',取n個)
newnums = itertools.permutations('ABC',2)
print(list(newnums))
#結果： [('A', 'B'), ('A', 'C'), ('B', 'C')]
程式碼內容

範例13-9:filter(過濾函數def或lambda,資料列)

(5).過濾模組filter
公式：filter(過濾函數def或lambda,資料列)
功能：
☎範例13-9.py
#顯示偶數
a = [1,2,3,4,5,6,7,8,9,10]
b = filter(lambda x:x%2==0, a)
print(list(b))

#顯示有'o'的元素
a = ['tom','girl','man','took']
b = filter(lambda x:x.find('o')>=0, a)
print(list(b))
程式碼內容

範例13-10:過濾模組map

(6).過濾模組map
公式：map(過濾函數def或lambda,資料列)
功能：
☎範例13-10.py
#顯示偶數
def getnum(x):
if x%2 ==0:
return x a = [1,2,3,4,5,6,7,8,9,10]
b = filter(getnum, a)
print(list(b))

#顯示有'o'的元素
def getstr(x):
if x.find('o')>=0:
return x
a = ['tom','girl','man','took']
b = filter(getstr, a)
print(list(b))
程式碼內容

範例13-11:操作每個元素模組reduce

(7).操作每個元素模組reduce
公式：reduce(過濾函數def或lambda,資料列)
功能：逐一操作每個元素
☎範例13-11.py
from functools import reduce
#計算總和
def getsum(x,y):
return x+y
a = [1,2,3,4,5]
b = reduce(getsum, a)
print(b)

#連接所有的元素
a = ['t','r','i','g','e','r']
b = reduce(lambda x,y:x+y, a)
print(b)
程式碼內容

範例13-12:套件collections-模組OderedDict：可將兩個串列，合併形成成一個字典dict

3.套件collections
import collections
(1).模組OderedDict 功能：將兩個串列，合併形成成一個字典dict
☎比較：合併串列建立字典的兩種方法
☎範例13-12.py
import collections
a1 = ['姓名','住址','性別','電話']
b1 = ['張三','台南市忠孝東路15好','男','0912751477']
#合併串列建立字典，方法一
d1 = collections.OrderedDict(zip(a1,b1))
print(d1)
print('姓名=',d1['姓名'])

#合併串列建立字典，方法二：zip()合併兩個串列，轉成dict()
c1 = zip(a1,b1)
d1 = dict(c1)
print(d1)
print('姓名=',d1['姓名'],'電話=',d1['電話'])
程式碼內容

範例13-13:模組deque：操作可迭代資料列，新增，刪除，反轉

(2).模組deque
功能：操作可迭代資料列，新增，刪除，反轉
☎範例13-13.py
from collections import deque
a1 = [1,2,3,4,5]
#建立deque物件
d1 = deque(a1)
#反轉資料列
d1.reverse()
print('反轉=',d1)
#新增到資料列右邊 append(元素)
d1.append('R')
print('右邊新增=',d1)
#新增到資料列左邊 appendleft(元素)
d1.appendleft('L')
print('左邊新增=',d1)
#刪除資料列右邊一個 pop()
d1.pop()
print('刪除右邊1個=',d1)
#刪除資料列左邊一個 pop()
d1.popleft()
print('刪除左邊1個=',d1)
#刪除某個元素 remove(元素)
d1.remove(3)
print('刪除某個元素3=',d1)
d1.append(2)
#計算某個元素2出現的次數 count(元素)
n1 = d1.count(2)
print('計算某個元素2出現的次數=',n1)
程式碼內容

例13-14:模組dCounter：可計算可迭代資料列相同元素的次

(3).模組dCounter
功能：計算可迭代資料列相同元素的次數
☎範例13-14.py
from collections import Counter
s = 'today is a good day'
a1 = list(s)
print(a1)
#建立counter物件（字典）
c1 = Counter(a1)
print(c1)
#顯示所有『鍵』
print(c1.keys())
#顯示所有『值』
print(c1.values())
#顯示所有『元素』
print(list(c1.elements()))
#顯示所有『鍵值（tuple）』
print(c1.most_common())
程式碼內容

1.不傳回值的函數：

1.不傳回值的函數：
(1).公式：
def 函數名稱(參數1,參數2):
函數內容

範例14-1：計算1+2+3..+n總和函數

範例14-1：呼叫計算1+2+3..+n的總和的函數
#☎注意：計算1～10，但是在range裡面要寫成for i in range(1,11)
def sum(n):
sum = 0
for i in range(1,n+1):
sum += i
print(sum)

sum(10)
成果圖片：
程式碼內容

第14章

主目錄

2.有傳回值的函數：

2.有傳回值的函數：
(1).公式：
def 函數名稱(參數1,參數2):
函數內容
return 變數

範例14-2：呼叫計算四方形面積函數

範例14-2：呼叫計算四方形面積的函數
def area(a,b):
s = a*b
return s

result = area(25,35)
print(result)
成果圖片：
程式碼內容

第14章

主目錄

3.全域變數，區域變數

3.全域變數，區域變數
全域變數：在最外層的變數，例如result
區域變數：在函數內層的變數，例如s

4.如何使用全域變數：global

4.在函數內的區域，如何使用全域變數：global
def test():
global var1
var1 = 10
print('inside=',var1)-

var1 = 5
print('before=',var1)
test()
print('after=',var1)

第14章

主目錄

6.範例14-4：如何接收多個函數回傳值

6.範例14-4：如何接收多個函數回傳值
範例14-3：已知半徑，要接受傳回的圓周長，圓面積
def circle(r):
a1 = 2 * 3.14 * r
a2 = 3.14 * r * r
return (a1,a2)

r = float(input('輸入半徑='))
b1,b2 = circle(r)
print('圓周長=',b1,'，圓面積=', b2)
成果圖片：
程式碼內容

第14章

主目錄

14.範例14-13：兩種內建排序函數：sort和sorted

14.範例14-13：Python提供兩種內建排序的函數：sort()和sorted()
(1).公式：
sort是容器的函數：sort(cmp=None, key=None, reverse=False)
sorted是python的內建函數：sorted(iterable, cmp=None, key=None, reverse=False)

■iterable：可疊代對象。
■cmp：比較的函數，這個具有兩個參數，參數的值都是從可疊代對象中取出，

此函數必須遵守的規則為，大於則返回1，小於則返回-1，等於則返回0。
■key：主要是用來進行比較的元素，只有一個參數，具體的函數的參數就是取自於可疊代對象中，指定可疊代對象中的一個元素來進行排序。
■reverse：排序規則，reverse = True 降序 ， reverse = False 升序（默認）。

(2).特色比較：
這兩個function都可以用來排序一個list
差別在於
sorted()會回傳一個排序好新的list
sort()會直接修改原始的list並排序完成

(3).範例:
a = [2, 4, 3, 5, 1]
sorted(a)
結果：[1, 2, 3, 4, 5]
print(a)
結果：[2, 4, 3, 5, 1]
a.sort()
print(a)
結果：[1, 2, 3, 4, 5]

(4).結論：
如果原始的list不需要保留下來的話，可以使用sort()來排序
如果要保留原本的list，就用sorted()來產生一個排序好的新list

(5).注意：sorted()應用性比較廣
sort()只能用在list上排序，
而sorted()可用來排序任何的iterable(string, 字典dict, tuple...)
成果圖片：
程式碼內容

第14章

主目錄

範例14-13：一般排序

(6).範例14-13：一般排序
s = [1140,170,200,185]
print('原始=',s)
sorted(s)
print('sorted=',s)
ss = sorted(s)
print('ss = sorted(s)=',ss)
s.sort()
print('s.sort()=',s)
成果圖片：
程式碼內容

第14章

主目錄

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

(2).範例14-20：查詢元素是否在串列list內，
一般一維串列：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)
成果圖片：
程式碼內容

第14章

主目錄

範例14-21：一維串列：a.index(txt)

範例14-21：一般一維串列：a.index(txt)
[1,2,3].index(2) # => 1
[1,2,3].index(4) # => ValueError

a=['tom','mike','peter','yellow']
name = input('請輸入查詢姓名？')
try:
res = a.index(name)
print(name+'找到了，在編號為'+str(res)+'的位置')
except ValueError:
print(name+'找不到')
成果圖片：
程式碼內容

第14章

主目錄

1.不傳回值的函數：

1.不傳回值的函數：
(1).公式：
def 函數名稱(參數1,參數2):
函數內容

範例15-1：計算1+2+3..+n總和函數

範例15-1：呼叫計算1+2+3..+n的總和的函數
#☎注意：計算1～10，但是在range裡面要寫成for i in range(1,11)
def sum(n):
sum = 0
for i in range(1,n+1):
sum += i
print(sum)

sum(10)
成果圖片：
程式碼內容

第15章

主目錄

2.有傳回值的函數：

2.有傳回值的函數：
(1).公式：
def 函數名稱(參數1,參數2):
函數內容
return 變數

1.不傳回值的函數：

1.不傳回值的函數：
(1).公式：
def 函數名稱(參數1,參數2):
函數內容

範例16-1：計算1+2+3..+n總和函數

範例16-1：呼叫計算1+2+3..+n的總和的函數
#☎注意：計算1～10，但是在range裡面要寫成for i in range(1,11)
def sum(n):
sum = 0
for i in range(1,n+1):
sum += i
print(sum)

sum(10)
成果圖片：
程式碼內容

第16章

主目錄

2.有傳回值的函數：

2.有傳回值的函數：
(1).公式：
def 函數名稱(參數1,參數2):
函數內容
return 變數