從零開始學Python on 跟著 Desolve 學程式

從零開始學Python (30) — 結語：少年啊，要忍耐，撐過熬過總算苦盡甘來

Thu, 15 Oct 2020 00:00:00 +0800

Day 30 結語：少年啊，要忍耐，撐過熬過總算苦盡甘來

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10247306

終於是最後一天了！！！
又來到了輕鬆聊的時間。
坦白說這次的30天過得並不輕鬆，
除了一些外務需要處理外，一開始也是從沒有存稿的狀態下開始的。
每天被進度追著打的感覺實在是很累XD！

寫這一系列文章的初衷，
最初是因為看到自己的學生們，
因為從LeetCode學演算法系列文章 找到了我，
但很多卻是想要轉職但對Python不熟的同學。
不，應該是說對於整個程式語言該從哪裡開始都不清楚。
通常這樣的狀況下，我們會從各種巨X電腦、O成電腦，
或各種線上學院開始先學基本的程式語言。
問題來了：
就算是同一家電腦甚至是資策會，
一來學費挺貴的，二來師資有所落差，風格也各有不一，
沒有人能保證自己一開始遇到的老師就是最適合自己的。

所以，建構一個基礎的系列文章教學，
內容不要像X者歸來那樣子又厚又重，
並且範例不要千篇一律讓讀者容易失去興趣，
是一件非常重要的事情。

如果拿這一系列文章和書籍相比，
讀者可能會發現，有很多東西是被筆者略過的：
例如我們沒有講到匿名函式(lambda function) ，
也沒有講到namedtuple ；
沒有講到pdf和xls的檔案處理，以及另一個數據分析的好用工具pandas ；
沒有講到OpenCV (可能比PIL更容易被用到，而且支援跨平台)；
沒有講到網路連線相關的模組 ；
也沒有講到多執行緒/多處理程序(multi-threading/multi-processing) 。

並不是它們不重要，而是筆者認為，
對於初學者而言，重點不是每一個都聽過摸過，
而是能先使用既有基本的東西，並且從它們當中，
組合出自己想要的程式。
在這個過程中，有遇到任何問題，
就去查資料、文件檔，或者向人請教提問，
將自己需要的知識不斷補足完善，這才是筆者希望看到的。

讓我們簡單回顧一下這三十天學了什麼，
以及再深入的話，可以再往哪個方向了解：
1. Python的安裝 ，除了本文提到的方式外，
另外還有Anaconda/pipenv等，
對於需要架構乾淨的多個執行環境而言蠻重要的，
同時也可以建構jupyter notebook，
使用iPython的以方格為單位的執行。

2. 變數、型態、運算子的部分，
其實還有很多跟位元運算有關的處理以及技巧，
如果在寫題目遇到跟bit相關的東西的時候會很常用；
字串也帶有許多好用的方法可以運用，
同時還有使用正規表達式(regular expression)來搜尋字串 的方法，
這個比較易學難精，有興趣可以再深入了解。

3. 進階的資料型態 ，記得我們的炸蝦嗎XD?
字典、串列、集合、元組的應用相當廣泛，
有一些東西和方法可能沒有詳列上去，
讀者可以遇到狀況時先查查有沒有可以用的對應內建方法呦！

4. 程式結構及語法 ，包含了if, for, while等，
應該算是最基礎的東西了，這當中應該唯有搭配Except的部分比較特殊，
再請多加留意。

5. 例外處理和遞迴 ，有關遞迴的處理速度和記憶體問題，
文章有更新一位在「程式人雜誌」社團的讀者提供的深入探討，
讀者可以再行參閱。

6. 模組與套件 ，關於其讀取的部分，其實有一些更細部的規則，
若想要建構比較嚴謹的大型程式的話，請再搜尋相關的文章。

7. 標準程式庫 ，其實還有很多很多很多XD，
建議讀者可以參照著Python的官方文件，
可以針對需求看有沒有自己需要的東西。

8. 物件與類別，
是所有物件導向程式語言(OOP, Object-Oriented Programming)
當中很重要的一環，當中的概念請務必好好理解清楚，
在使用時才不容易混淆。

9. 檔案讀寫，
除了一般文字檔、CSV、JSON外，
XML/YAML也是常用的格式；除此之外，了解HTML的格式，
將有利於有志朝網頁爬蟲相關技巧學習的讀者。
若以爬蟲而言，beautifulsoup, scrapy, request, selenium 可能是重要的關鍵字。

10. 日期時間、圖形處理、GUI介面等，
都算是Python內建好用的模組，尤其對於Tkinter而言，
也有很多其他的模組可以取代或者讓它變更好用。

11. 其他常用的資料結構相關模組 ，可以搭配著演算法學習，
效果會更好，最好搭配筆者的從LeetCode學演算法系列XD

12. 科學運算、繪圖及深度學習，
是走向AI/資料科學的敲門磚，後續還有更多更深入的東西可以玩的，
有興趣的讀者若想要走AI相關領域，
建議可以從吳恩達/李宏毅/林軒田等大師的機器學習課程開始，
如果想要先了解一點基礎簡單的深度學習框架，
閱讀莫煩Python的系列教學也不錯！

13. 其他沒有提到的如Python+Flask(前端)，
Python+SQLite/MongoDB/Redis(後端)等，
如果讀者扎扎實實地經過這三十天的練習，
應該會擁有進一步透過網路文章資源來學習這些的能力，
就再請大家針對需求去搜尋囉！

除此以外，每天的副標題 ，
其實都跟當天要講的內容有關聯性，
並不單純只是梗或者是歌詞而已，
若讀者可以有效地將文章內容和副標題連結上 ，
相信能更理解文章所要表達的內容。

最後，不免幫自己工商一下：
筆者目前除了從LeetCode學演算法的線上課程外，
也和幾位朋友成立一個團隊，名為Chill Cat(去憂貓) ，
當前正在鑽研AI輔助心理諮商 的部分；
同時我們也有經營有關AI智能化交易指標 的研究，
(可以是MetaTrader ，也可以是別的XD)
以及協助企業評估/導入AI或自動化 的可能。
歡迎有興趣合作或委託開發的諮商師、心理師，
以及公司行號和我聯絡。
來信請寄：bbsc.aiteam@gmail.com 。

平常的時候，若對於LeetCode解題感興趣，
還是可以在FB的Python Taiwan社團 ，
或我的Medium上看到我！
也可以來追蹤我的粉專：跟著Desolve學程式，
裡面會不定時分享一些程式相關的文章或資訊呦！

感謝大家的收看，那我們明年……
等一下，先不要，先不要XD
我再考慮看看啦XDDD!
就這樣，掰掰~

工商時間：

抽獎活動還在繼續累積人數(現在好像沒有人想抽XD)
在Python Taiwan的連結第100篇的文章 底下，
公開分享到你的臉書、按讚該篇文章、並留言告訴我說，
「你最喜歡這一整個系列的哪一篇？為什麼？」或
「除了從LeetCode學演算法系列以外，
你還想要看到關於什麼方向的文章？」
超過20則留言的話 (有完成以上步驟的才算)，我們就抽一組
「從Leetcode學演算法｜進階篇」+「從Leetcode學演算法｜面試篇」
課程的免費兌換券進行贈送！

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

容筆者工商一下，
「從Leetcode學演算法｜進階篇」 開放預購啦！
這次選了40道難度加深的LeetCode題目，
同樣也會細部解說對應的技巧及須要掌握的演算法！
同時這次購買進階篇的話，
額外還加贈**「從Leetcode學演算法｜面試篇」** ！
當中包含了面試準備須知分享 ，及訪談國內外不同經驗的工程師 ，
讓你不論是想走前端/後端/一般軟工 或者是想找國外的工作 ，
是初學想轉職 還是正在工作 ，都能夠從中得到收穫呦！
有興趣的朋友可以使用下面的早鳥優惠～
「從Leetcode學演算法｜進階篇」+「從Leetcode學演算法｜面試篇」 ：
https://bit.ly/leetcodeadv

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/leetcodeall

從零開始學Python (29) — 打包安裝PyInstaller：誰把誰的靈魂，裝進誰的身體

Wed, 14 Oct 2020 00:00:00 +0800

Day 29 打包安裝PyInstaller：誰把誰的靈魂，裝進誰的身體

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10247305

因為按照慣例，第三十天主要會講比較偏向結論性質的東西，
包含接下來可能的學習方向以及建議，
所以讓我們今天用PyInstaller來做技術方面的最後一章，
恭喜各位讀者，這系列如果都有扎實的跟上的話，
應該能對Python有一些基本的認識。

PyInstaller是一個用來打包安裝Python檔案的函式庫，
一般狀況下，使用pip可以輕鬆將其安裝：

1

pip install pyinstaller

為什麼我們會需要PyInstaller呢?
一般狀況下有幾個可能：

你不想直接讓別人看到程式碼(註：但會破解的還是做得到XD)
你在開發過程中用了一些函式庫，
這些函式庫並非內建的，從而別人要用你的.py檔執行的話，
會需要進行其它的pip install或準備工作。
這樣很麻煩很不方便，
你希望拿到的人最好可以滑鼠點兩下就可以執行才對XD

這時候使用PyInstaller就可以達成這樣的目的，
除了可以給定簡單的加密外(防君子的那種)，
它還可以將整個程式連同用到的函式庫一起打包成執行檔！

我們這邊使用前面的tkinter的範例，
讀者應該會用到的檔案就是fromzero.py和unicorn.ico，
還沒做過的同學，請參照Day 22的範例及Day 23的修改部分。

為了測試，
我們再手動加上一個其實我們沒有在這個範例使用的numpy，
請在fromzero.py中額外加入這行：
(因為它是額外pip安裝的，藉此我們可以觀察一下差異)

1

import numpy as np

PyInstaller的使用方式是直接在命令提示字元下指令，
使用pyinstaller -h可以查看help提示：

1
2


pyinstaller -h
...密密麻麻的一大堆XD

我們簡單介紹一下幾個常用的參數部分：
(前面和後面是相同的效果，只是使用縮寫)
-h, — help ：顯示help提示說明各參數用法
-F, — onefile ：打包成單一一個執行檔
-D, — onedir (預設) ：打包成一個資料夾，內含一個執行檔
-y, — noconfirm ：
— clean ：清空前面打包時產生的暫存檔案
-n NAME, — name NAME ：將NAME做為app名字並命名到執行檔
(預設會是主程式原先的主檔名 )
— add-data <SRC;DEST or SRC:DEST> ：
將非二進位檔案加到打包中，
SRC對應原先的檔案，DEST對應打包後放的相對資料夾位置
-p DIR, — paths DIR ：如果有額外需要import的函式庫時，
告訴pyinstaller可以去DIR這個位置搜尋
— key KEY ：用key來加密Python的bytecode
-w, — windowed, — noconsole ：在Windows執行時隱藏命令提示字元的視窗

那麼，我們先試試看最基本的打包：

1
2


C:\Users\Desolve\utils>pyinstaller --noconfirm fromzero.py
...底下會開始打包

在預設的狀況下，會產生幾個目錄：
pycache(主程式編譯的bytecode檔),
build(編譯過程中產生的檔案),
dist(最終執行所需要的執行檔及其他資料)
我們切換到dist\fromzero的資料夾以後，
應該可以看到fromzero.exe，以及其它的一些檔案及資料夾，
當中就包含了tk和numpy，
顯然pyinstaller自動幫我們評估將函式庫給包進來了！
那麼，在命令提示字元打fromzero.exe，
或者在資料夾中連點兩下就可以執行了……咦？

1
2
3
4
5
6


C:\Users\Desolve\utils\dist\fromzero>fromzero.exe
Traceback (most recent call last):
 File "fromzero.py", line 41, in <module>
 File "tkinter\__init__.py", line 2071, in wm_iconbitmap
_tkinter.TclError: bitmap "unicorn.ico" not defined
[12564] Failed to execute script fromzero

顯然我們的獨角獸並沒有被包進去，
由於前面我們讀取檔案時，是在和.py相同的資料夾，
所以我們可以將unicorn.ico複製到dist\fromzero的資料夾 ，
就可以正常執行了。
當然這顯然不是很理想，所以讓我們回到上一步，
處理一下圖片的部分。
我們先用以下的方式，將unicorn.ico轉成二進位制，
再存到一個.py檔做為變數img：
(註：參考自CSDN blog)
(如果是一般檔案，則可以使用 — add-data=’SRC;DEST’的方式即可)

1
2
3
4
5
6
7
8
9


>>> import base64　# base64可以將binary檔案轉成unicode格式
>>> icon = open('unicorn.ico', 'rb') # 使用binary的格式讀入icon
>>> b64str = base64.b64encode(icon.read()) # 轉成unicode格式
>>> icon.close()
>>> write = 'img = %s' % b64str # 放到名為img的變數
>>> f = open('icon.py', 'w+') # 寫到icon.py中
>>> f.write(write)
6097
>>> f.close()

此時資料夾中會多出一個icon.py，
裡面就是img=”……”的格式。
接著我們要修改我們的fromzero.py，
從讀取原本的icon，改成從icon.py取得變數：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


from icon import img # 從icon.py中取得img變數
import base64 # 同樣需要base64函式庫
# 主視窗生成
win = tk.Tk()
win.title('從零開始學Python：第二件X折？')
win.geometry('800x220')
win.resizable(False, False)
# 加上icon
ico = open('unicorn.ico', 'wb+')
ico.write(base64.b64decode(img)) # 寫一個icon出來
ico.close()
win.iconbitmap('unicorn.ico') # 將icon嵌上視窗
os.remove('unicorn.ico') # 把剛剛用完的檔案刪掉

我們在重新下一次指令：

1

C:\Users\Desolve\utils>pyinstaller fromzero.py -F -y -w

這時候應該同樣可以在dist資料夾看到fromzero.exe，
且由於我們下了-w，所以執行時後面不會出現命令提示字元了！

如果要進行簡單加密的話，
pyinstaller預設是使用tinyaes：

1

pip install tinyaes

安裝後，打包時額外加上 — key=”(16個字元的字串)”即可，
少掉的字元會補0。
例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


C:\Users\Desolve\utils>pyinstaller fromzero.py -F -y -w --key="XDDD3096"
61 INFO: PyInstaller: 4.0
62 INFO: Python: 3.8.5
62 INFO: Platform: Windows-7-6.1.7601-SP1
64 INFO: wrote C:\Users\Desolve\utils\fromzero.spec
66 INFO: UPX is not available.
68 INFO: Extending PYTHONPATH with paths
['C:\\Users\\Desolve\\utils', 'C:\\Users\\Desolve\\utils']
77 INFO: Will encrypt Python bytecode with key: 00000000XDDD3096
77 INFO: checking Analysis
...(以下省略)

如果你覺得這樣子還不夠放心，
可以再透過obfuscator或PyArmor之類的軟體，
將主程式進行混淆以後再打包，
效果會更好呦XD！

最後要留意一點，
如果想要編譯出能在32位元的電腦運行的程式，
則需要使用32位元版本的Python才可以。

那麼，我們就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/leetcodeall

從零開始學Python (28) — 深度學習Keras：如果你能預知這條路的陷阱，我想你依然錯得很過癮

Tue, 13 Oct 2020 00:00:00 +0800

Day 28 深度學習Keras：如果你能預知這條路的陷阱，我想你依然錯得很過癮

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10247304

接下來讓我們來聊聊Python在深度學習的部分。
事實上很多iT邦幫忙的神人們在AI & Data組應該都有介紹到深度學習，
可能是使用Tensorflow, PyTorch或Keras。
本篇的重點不是要一篇打各路大神們的三十篇，
而是要簡單介紹一下AI及深度學習的概念，
給大家做一個入門，後續要再深入的話，就可以再去參考更多其它的學習資源。

那麼，我們先聊聊什麼是AI。
人工智慧(Artificial Intelligence)，
過往是源自於一些根本的假設以及傳說所揉合而成。
人類對於機器人有一些想像，想像我們可以做出人造人，
這樣的機器人具備自我思考的能力，因而可以透過不斷的思考和選擇達到進化；
同時加上了中古時期對於鍊金術的想像：將意識賦予至無生命的物質當中。

綜合以上，因而我們對於一個AI的想法，
大體上不外乎是以「它會思考」這個角度來出發。
那麼，怎麼樣才算是會思考呢？
有一位電腦科學家圖靈(Alan Mathison Turing)，
提出了一個著名的測試方式：圖靈測試。

圖靈測試簡單來說，就是讓一個人(A)，
分別去跟兩個不同的對象(B、C)交談，
過程中只透過文字，
A不會看到B、C的模樣或聽到聲音；
最終交談完畢以後，
由A來判斷B、C是否有實質的不同，或者說誰更像是人。
如果有一個機器比另一個人讓A更覺得它像人的話，
即通過圖靈測試。

這樣子的測試後來衍生出很多很有趣的例子，
例如有個名為Eliza的聊天機器人，
會將對方講出來的句子分析其主詞及關連性，
針對當中的關鍵字詞來回答；
或者它也會做一些重組，再拿你講過的話來回答你XD！
而這種模式和人互動下，反而很多人會以為Eliza懂他/她，
殊不知完全掉入了程式設計師的陷阱XD

扯遠了，讓我們拉回來談AI。
我們近幾十年在拿AI這個詞來描述事物時，
其概念和範圍其實也是不斷在變動的。

以比較之前的看法來說，AI通常會被當做是：
使用確定的規則判斷，使得機器得以按照這個規則去運作，
從而在某些方面表現出像是人類在做思考判斷一樣。

比如電腦遊戲中玩家操縱的角色跟NPC對話時，
NPC會依照它的「人設」(也就是遊戲開發者原先對其的設定)，
以及當前的一些條件狀況，對玩家做出回應。
當然，我們可以很輕易地看出這是寫好的規則判斷，
原因就是這個NPC可能講沒幾句話就重複循環，
或者是一直要你去打10隻母雞回來交任務XD

再比方說過往的圍棋或象棋軟體，
甚至打敗過西洋棋棋王的電腦「深藍」，
也都脫離不開使用寫好的規則來計算下一步的範疇，
這樣子的AI，我們將其稱為rule-based AI。
按規則走的優點是，
當事情是確定的，且符合過往能歸納的範疇，
那麼機器處理的能力就會非常好。
缺點當然就是一旦遇上沒有被界定的情況，
那機器就會不知道該怎麼辦了XD!

AI在經歷過幾次興起以及幾次寒冬以後，
得益於GPU性能的提升，能加速大量的平行化運算的矩陣運算的原因，
深度學習(Deep Learning)在近年來興起了。
深度學習所建立的AI，和以往以規則為出發的AI不同，
它主要是透過所謂的人工神經網路(Artificial Neural Network, ANN)，
在建立起一個結構以後，透過不斷地輸入資料，
輸出結果，檢查結果與正確答案的差距，再對神經網路各自的權重(weight)做修正，
最終讓每次的輸入所得到的輸出結果，能接近正確答案。

舉例來說：
假設讀者的面前有一棵樹，
rule-based的做法會是：
「這邊有樹枝，這邊有樹葉，中間有枝幹連接，
它們的顏色在XX~OO之間，所以這是一棵樹」

深度學習的做法則是：
「反正這就是一棵樹就對了！不知道？沒關係，
我多帶你看幾個：A這個是樹，B這個不是樹，
……好，那你這樣應該可以分辨樹了對吧？」

深度學習在神經網路的類型的這塊，
相對比較像人類的小孩子在學習一樣，
透過不斷的歸納，最終小孩子在心裡面產生一套分辨方式，
這個分辨方式可能說得出來，可能說不出來，
但最終他/她就是會講得出「這是一棵樹，這是車車」這樣子的分類。

上面提到的深度學習的方式，
在具體到人工神經網路上狀態又是怎麼樣的呢？
比較粗略的來說，
人工神經網路是由神經元(neurons)彼此以突觸連接而成的，
不同的突觸，傳遞相同的訊號時會產生不同的強弱變化，
通常我們稱之為權重(weights)。
如同剛剛所說的，
我們會透過檢查正確答案和目前機器輸出的答案的差距，
來修正權重，最常見的方式，
就是使用反向傳播(backpropagation, BP) ，
加上梯度下降法(gradient descent)或其他算法 ，
來盡力收斂和正確答案的差距。
這個改善神經網路的過程我們通常稱之為模型訓練(model training)

那麼，接下來談談Keras。
Keras原本是一個用於快速開發深度神經網路的框架，
立基於各項比較常見的框架之上，
例如TensorFlow(Google Brain團隊所開發), Theano, PlaidML等。
但近年來最主要的支援是放到了TensorFlow上面，
同時TensorFlow也主動將Keras的函式庫納入到其中，
我們接下來的範例會基於TensorFlow上的Keras來操作。

如果在自己的電腦上想安裝TensorFlow/Keras的話，
可以參考官網：
https://www.tensorflow.org/install/pip?hl=zh_tw
請留意，如果是要用到gpu的話，
你必須要安裝的是tensorflow-gpu。

由於不是每個人的家裡的GPU都很精良，
所以下面我們主要會介紹如何跟著TensorFlow上的官網提供的colab範例來做。
下面我們會一步步帶各位走過最基本的範例：Fashion MNIST的分類，
請從Basic classification: Classify images of clothing
找到Run in Google Colab 並將其打開。

在Colab的網頁中，
當看到”[ ]”的格子時，
代表一組可以執行的程式碼，
滑鼠移動到上面，會顯現播放鍵，
只要按下去就會執行一次。
執行完後顯示的數字代表它已經被執行過了，
且是第幾個被執行的格子。

首先我們看到前導的部分：
我們要使用到的一般會有tensorflow本身以及keras，
所以要進行import，同時，前面我們提過的numpy以及matplolib也都會用到，
讓我們一起導進來。

1
2
3


# TensorFlow and tf.keras
import tensorflow as tf
from tensorflow import keras

1
2
3


# Helper libraries
import numpy as np
import matplotlib.pyplot as plt

1

print(tf.__version__) # 印出當前tensorflow的版本，目前是2.3.0

再來，我們要匯入一組資料集(dataset)。
資料集一般是指針對特定目標或種類收集整理而成的資料，
一些比較代表性的資料集如Cifar-10, MNIST, ImageNet等，
依照使用的狀況不同，有些會被拿來當成基本教學範例，
有些則是會被拿來當成評估訓練方法好不好的標準。
以Fashion MNIST來說，
就是一個在MNIST(手寫0~9的圖形資料集)被用到太無聊的狀況下，
可能打算換換口味才換過來的資料集XD。

Fashion MNIST當中有7萬張灰階圖，
內容是10種不同的服飾，如鞋子、包包、衣服、褲子等。
以這個範例來說，我們的目的，
就是訓練出一個能夠良好地辨認出一張圖片是哪個種類的服飾的模型。

我們要將Fashion MNIST下載後，分為用來訓練的資料，以及用來測試用的資料 ：
為什麼要分呢？因為如果全部都拿來訓練的話，
那麼在測試這個訓練結果時，我們怎麼知道說，
這個模型(model)回答的好，是因為它真的懂了，
還是是因為背熟考古題呢XD？
畢竟我們是希望它找出一個自己能夠辨別的標準，
而不是背答案。

這邊的label(標籤)，指的是該張圖片，是屬於這個資料集的第幾類，
這樣到時候訓練時才能夠知道模型有沒有找錯。

1

fashion_mnist = keras.datasets.fashion_mnist

1

(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

在這個資料集中，我們標記為0的是T-shirt/top，
1的是Trouser, 以此類推，將每個類別的名稱記錄下來。

1
2


class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

接著檢查一下剛剛拿到的資料：

1
2
3
4
5


train_images.shape # (60000, 28, 28) -> 60000張，每張像素是28x28
len(train_labels) # 60000 -> 對應的標籤當然就也是60000張
train_labels # array([9, 0, 0, ..., 3, 0, 5], dtype=uint8) -> 0~9的種類，共10種
test_images.shape # (10000, 28, 28) -> 10000張用來做為測試的圖像
len(test_labels) # 10000 -> 對應的標籤當然是10000

接著我們來預先處理一下資料，
使用plt.imshow()可以將進行圖像繪製，
我們就拿train_images[0]這張來看看：

1
2
3
4
5


plt.figure()
plt.imshow(train_images[0])
plt.colorbar() # 用來顯示灰階影像(0-255)
plt.grid(False)
plt.show()

通常我們要處理資料時，
我們要將其標準化到01的範圍，
這樣子才不會因為不同的資料的尺度(scale)不同，
影響到模型的訓練或它們對於結果影響的比例。
由於灰階影像的值是0255，所以我們可以選擇全數除以255.0來等比例縮小，
接著再取前25張圖來檢查處理過的資料是否正常仍可顯示：

1
2


train_images = train_images / 255.0
test_images = test_images / 255.0

1
2
3
4
5
6
7
8
9


plt.figure(figsize=(10,10))
for i in range(25):
 plt.subplot(5,5,i+1) # 5*5的排列方式
 plt.xticks([])
 plt.yticks([])
 plt.grid(False)
 plt.imshow(train_images[i], cmap=plt.cm.binary) # 範圍0~1時要選binary
 plt.xlabel(class_names[train_labels[i]]) # 在x軸的位置顯現分類名
plt.show()

接下來是模型的部分。
要訓練模型之前，首先我們要先將模型的神經網路建構起來，
通常狀態下神經網路是以層(layer)為單位，
層與層彼此之間進行連接，多個層最終構成一個神經網路。
Sequential: 代表前面的往後面的承接
Flatten: 代表將輸入的東西攤平成一維(28*28=784)
Dense: Dense layer又稱全連接層，也就是像握手一樣，
上一層的每個神經元和這層的神經元的每一個組合都有連接到
activation: 激勵函式(activation function)，簡單來說，
就是一個讓整個神經連接呈現不是線性的狀態。
因為若是一個模型可以用很簡單的公式或者線性可表達的函數算出來，
這樣子的狀態不是深度學習所要的，因為如果一般的方式可以算的話，
深度學習並沒有比較具備優勢。
(其它目的還有避免過擬合或節省部分計算的考量，我們暫且不深入探討)

1
2
3
4
5
6


# 最後一層是10個神經元，目的就是剛好分成10類
model = keras.Sequential([
 keras.layers.Flatten(input_shape=(28, 28)),
 keras.layers.Dense(128, activation='relu'),
 keras.layers.Dense(10)
])

完成一個模型後，我們要進行compile的動作，
將其它附帶的條件給加上。
Loss function(損失函數)：用來評估說模型現在給出的答案和正確答案的差距的函式，
這個可以有很多種類，這裡用的是用來衡量分類的SparseCategoricalentropy。
Optimizer(優化器)：我們在修正時，不會直接將Loss給出來的差直接處理掉，
而是會有一個評估要往哪個方向修正多少的方法做為基準。
(因為這個點完全相等並不能代表另一個會表現好)
除了adam以外，sgd, adagrad等都是常見的優化器。
Metrics(指標)：在訓練的過程中我們會想看的中途狀況，
accuracy是計算每次有正確被分類的圖片的比例。

1
2


model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])

接下來就要開始訓練啦!
Keras中是使用model.fit指令，意思是這個模型要盡力去符合實際的正確標準。
epochs是代表以前面60000張圖片做為一整組的話，
我們想要讓同一個組讓機器訓練過幾次。
指令下了以後就會在下方看到進度條跑動，
以這次訓練來說，
目前訓練的準確度在最後一次是0.9100，也就是91%。

1

model.fit(train_images, train_labels, epochs=10)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


Epoch 1/10
1875/1875 [==============================] - 4s 2ms/step - loss: 0.5019 - accuracy: 0.8236
Epoch 2/10
1875/1875 [==============================] - 4s 2ms/step - loss: 0.3788 - accuracy: 0.8633
Epoch 3/10
1875/1875 [==============================] - 4s 2ms/step - loss: 0.3425 - accuracy: 0.8743
Epoch 4/10
1875/1875 [==============================] - 4s 2ms/step - loss: 0.3169 - accuracy: 0.8840
Epoch 5/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.2985 - accuracy: 0.8910
Epoch 6/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.2821 - accuracy: 0.8957
Epoch 7/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.2713 - accuracy: 0.8996
Epoch 8/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.2594 - accuracy: 0.9035
Epoch 9/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.2499 - accuracy: 0.9067
Epoch 10/10
1875/1875 [==============================] - 3s 2ms/step - loss: 0.2429 - accuracy: 0.9100
<tensorflow.python.keras.callbacks.History at 0x7f88189846a0>

但只會做考古題不算真本事，我們還得看看，
這個模型測試沒看過的圖片時，準確度會是怎麼樣：
我們將最終使用test的圖片來檢驗的動作稱之為evaluate(評定)。

1
2


test_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)
print('\nTest accuracy:', test_acc)

1
2


# 結果是88.3%左右
313/313 - 0s - loss: 0.3400 - accuracy: 0.8827

1

Test accuracy: 0.8827000260353088

訓練好的模型，當然不應該只拿來檢查準確度，
也要可以用來檢視新的圖片：
一般狀況下，我們會使用一個softmax層來處理。
softmax層能將一群輸入的值，按照一個分配方式壓縮，
最終所有值都在0~1之間，且加總起來會剛好等於1，
我們就拿這個輸出來做為判斷某個輸入的圖是什麼種類的機率有多少。

1
2
3
4
5
6


# 連接softmax層
probability_model = tf.keras.Sequential([model, tf.keras.layers.Softmax()])
# 用predict方法來進行推論(inference)
predictions = probability_model.predict(test_images)
# 每一個predictions的元素當中包含了預測這個圖分別是種類0~9的機率值
predictions[0]

1
2
3
4
5
6
7
8
9


array([2.3251364e-07, 1.5796850e-08, 5.2541566e-07, 9.3214476e-09,
 7.9444156e-08, 1.8098523e-03, 5.7661474e-08, 8.4252998e-02,
 1.4421660e-07, 9.1393608e-01], dtype=float32)
# 我們要取機率最高的當做是我們判斷它是哪一種類型
# 使用np.argmax，其結果看起來跟實際上的答案一致，代表有答對XD
np.argmax(predictions[0])
9
test_labels[0]
9

下面colab的範例也提供了兩個函式來提供視覺化的判斷，
在此就不一一解釋：

我們可以看到模型也是有答錯的時候XD：

後面還有畫一整群圖片檢驗的對照圖，就請讀者自行參閱。

最後，範例有提到說，因為前面的示範是一次放入10000張下去做predict，
如果今天有一張單張的28x28灰階圖片，
其實同樣可以拿來做predict呦！
唯一的不同，就只是你要將這”一張”圖片，擴展成”一組”圖片，
而這一組裡面就只有一張圖片的格式。

1
2
3
4
5
6


img = test_images[1] # 拿第二張
print(img.shape) # (28, 28)
img = (np.expand_dims(img,0)) # 擴展一個維度，讓它變成"一組"
print(img.shape) # (1, 28, 28)
predictions_single = probability_model.predict(img) # 現在可以predict了
print(predictions_single)

1
2


[[5.1490115e-05 9.7672521e-14 9.9936408e-01 2.5379993e-12 1.0796214e-04
 6.6310263e-10 4.7655238e-04 2.3014628e-11 2.8894394e-08 5.6684479e-12]]

最終結果順利預測出該圖片是Pullover(套頭衫)。

雖然從上到下講得相當長，
但其實只是很粗淺的示範了一下最基礎的範例而已，
深度學習除了圖像分類以外，
從圖片到文字，再到聲音，各種應用可以說是包山包海；
更不用說還有不同的模型建立方式與架構，
今天的介紹連冰山一角都稱不上XD
若讀者有更深入的興趣的話，可能就要從更基本的機器學習部分出發了！

除此以外，若要自己進行深度學習的訓練的話，
架構一個環境還是很有必要的，
就再請讀者閱讀一下其他大大們的教學呦！

那麼，我們就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (27) — 科學繪圖Matplotlib：畫著你，畫不出你的骨骼

Mon, 12 Oct 2020 00:00:00 +0800

Day 27 科學繪圖Matplotlib：畫著你，畫不出你的骨骼

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10247303

今天我們要來介紹的是Matplotlib，
對於Python來說，是一套非常常用於科學繪圖的繪圖程式庫，
同時也相當良好地支援了NumPy的陣列，
此外，通常狀況下，只要設定恰當，
也可以很順利地在一些帶有視窗運作的Python執行環境，
如IPython, Jupyter Notebook, colab等直接內嵌繪製圖片，
可以說是相當的方便！
由於最初的目的是提供如同Matlab軟體的繪圖方式，
所以常用Matlab的人可能會覺得很多東西似曾相識XD

要使用matplotlib時，官方有提供pylab ，
將matplotlib的pyplot和numpy合併在一起，
但還是建議numpy歸numpy，pyplot歸pyplot 。

同樣的，如果電腦還沒有matplotlib套件的話，
請先使用pip install進行安裝。

1

pip install matplotlib

接下來讓我們來介紹一些基本的功能。
首先，我們要先將numpy和matplotlib的pyplot給import進來：

1
2


import numpy as np
import matplotlib.pyplot as plt

記得上一篇我們做過一個隨積分布的陣列嗎？
如果我們想將其使用直方圖(Histogram)來表現出點的分布數量的話，
可以使用plt.hist()，將陣列輸入給plt；
同時，plt在繪製以後，要經過plt.show()的方法才會顯示出來。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


>>> mu, sigma = 0, 0.1
>>> s = np.random.normal(mu, sigma, 1000)
>>> plt.hist(s) # 繪製直方圖，預設分成10組
(array([ 10., 32., 91., 164., 238., 216., 147., 71., 25., 6.]), array([-0.
30285466, -0.2403016 , -0.17774855, -0.1151955 , -0.05264245,
 0.0099106 , 0.07246365, 0.1350167 , 0.19756975, 0.2601228 ,
 0.32267585]), <BarContainer object of 10 artists>)
>>> plt.show()
# 在直譯器的話可以按Ctrl+C回來或按X關掉plt視窗
>>> plt.hist(s, 30) # 第二個參數為30, 代表將值的範圍切分成30等份(預設則為10)
(array([ 1., 4., 5., 8., 9., 15., 19., 25., 47., 46., 49., 69., 71.,
 79., 88., 87., 76., 53., 55., 55., 37., 40., 16., 15., 9., 9.,
 7., 4., 1., 1.]), array([-0.30285466, -0.28200364, -0.26115262, -0.24
03016 , -0.21945059,
 -0.19859957, -0.17774855, -0.15689754, -0.13604652, -0.1151955 ,
 -0.09434449, -0.07349347, -0.05264245, -0.03179144, -0.01094042,
 0.0099106 , 0.03076161, 0.05161263, 0.07246365, 0.09331467,
 0.11416568, 0.1350167 , 0.15586772, 0.17671873, 0.19756975,
 0.21842077, 0.23927178, 0.2601228 , 0.28097382, 0.30182483,
 0.32267585]), <BarContainer object of 30 artists>)
>>> plt.show()

應該可以看到接近如下的圖(前面是分10組，後面是分30組)：

我們在繪圖時，如果一般使用畫線按座標的話，
通常是以plt.plot(x, y, linewidth)的型式，
此時就要剛好每個x的元素都對應到y的元素：

1
2
3
4
5


>>> x = np.arange(1, 9, 2)
>>> y = 2 * x
>>> plt.plot(x, y, linewidth=1.5) # 這樣應該是y=2x的樣子
[<matplotlib.lines.Line2D object at 0x000000000BCCB220>]
>>> plt.show()

請留意一點，由於Python的陣列預設從0開始，所以當我們只給一段座標時，
會被當成y座標，且x會從0開始起算，以整數遞增：

1
2
3
4


>>> plt.plot([1,2,3,4])
>>> plt.show()
>>> plt.plot([1,2,3,4], [1,2,3,4]) # 留意X座標的變化!
>>> plt.show()

以plt.plot的方式繪圖時，畫上去的圖被稱為figure，
figure的軸則是axes，可以用add_subplot(1,1,1)方法取用到，
如果同時放多張子圖的話(1,1,1)代表第一張。
(這不是很好解釋，如果一次只畫一張圖的話就不管它啦！)
我們可以在繪製完圖以後再做額外的事情：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


>>> fig = plt.figure()
>>> ax = fig.add_subplot(1,1,1)
>>> ax.plot([1,2,3,4], [1,2,3,4])
[<matplotlib.lines.Line2D object at 0x000000000B540B80>]
>>> ax.set_title('Title') # 表題
Text(0.5, 1.0, 'Title')
>>> ax.set_xlabel("label: x") # X軸文字
Text(0.5, 0, 'label: x')
>>> ax.set_ylabel("label: y") # Y軸文字
Text(0, 0.5, 'label: y')
>>> fig.suptitle('Sup Title', fontsize=20, fontweight='bold') #
Text(0.5, 0.98, 'Sup Title')

在plt.plot輸入陣列後加上一個格式字串可以用來代表畫線的樣式，
指定linewidth可以修改畫線的粗細。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# r代表紅色，x代表用'x'來表示點，且不畫線
>>> plt.plot([1,2,3,4], [3,5,15,18], 'rx')
[<matplotlib.lines.Line2D object at 0x000000000B856C10>]
# b代表藍色，'.'代表用單個小點表示一個點，'--'表示用虛線(dashed line)來畫線
>>> plt.plot([1,2,3,4], [3,9,1,6], 'b.--')
[<matplotlib.lines.Line2D object at 0x000000000B866310>]
# g代表綠色，o代表實心圓，linewidth表示粗度修為3
>>> plt.plot([1,2,3,4], [1,4,9,16], 'go-', linewidth=3)
[<matplotlib.lines.Line2D object at 0x000000000B856F40>]
>>> plt.legend(('red', 'blue', 'green'), loc='upper left') # 畫圖例及決定位置
<matplotlib.legend.Legend object at 0x000000000B757730>
>>> plt.grid(True) # 畫出網格
>>> plt.show()

其結果應如下所示：

在處理過後可畫線的圖以後，如果我們的資料是零散的點，
不需要畫線的話，我們可以用散點圖(scatter)來進行繪製：

1
2
3
4
5
6
7


>>> np.random.random(5)
array([0.22612501, 0.34256502, 0.21559228, 0.17675453, 0.1082928 ])
>>> x = np.random.random(500)
>>> y = np.random.random(500)
>>> plt.scatter(x, y)　# 其實用plt.plot(x, y, 'o')也可以啦！
<matplotlib.collections.PathCollection object at 0x000000000B566580>
>>> plt.show()

如果要繪製3D的圖的話，要利用plt.axes()，
將其projection設為’3d’。
同時由於有三維座標，所以要使用ax.scatter3D(x, y, z, color)。

1
2
3
4
5
6


>>> z = np.random.normal(0, 0.2, 500)
>>> fig = plt.figure()
>>> ax = plt.axes(projection='3d')
>>> ax.scatter3D(x, y, z, color='blue')
<mpl_toolkits.mplot3d.art3d.Path3DCollection object at 0x000000000C00A1F0>
>>> plt.show()

最後我們會得到一個3D散點圖，其介面是可以按滑鼠左鍵拖曳旋轉的呦！
讀者可以自己嘗試看看～

其他其實還有相當多的內容，有興趣的話可以看看官方文件的說明。
像是各種不同種類的圖形、標記方式、標籤等等，
如果使用者想更進一步的話，可以試試看找一些如繪製股票線形的教學範例，
跟著操作看看，相信會更有收穫！

那麼，我們就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (26) — 科學運算NumPy：人間用多少滄桑，換多少人的瘋狂

Sun, 11 Oct 2020 00:00:00 +0800

Day 26 科學運算NumPy：人間用多少滄桑，換多少人的瘋狂

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10247302

我們今天要來介紹一下NumPy。
一般來說，讀者可能常常會聽到有些人說Python的執行效率相對比較低，
這是真的，因為動態語言會比妥善先編譯過的語言執行速度還慢，
因而我們會看到在像是LeetCode的答案繳交時，
用C/C++/Java可能是執行5 ms(毫秒)的時間，
用Python寫相同邏輯的答案可能要30~100ms。
既然這樣，為什麼現在Python會成為機器學習或AI發展的主流語言呢？
原因就是Python有很多方便的程式庫，
尤其科學運算方面，有不少經過最佳化以及妥善編譯後的程式庫，
使用起來的效率相當的好，NumPy就是其中一個。

通常狀況下NumPy會搭配到後面的Matplotlib及Keras(TensorFlow)，
用來輸入大量的矩陣及陣列，可以迅速進行運算。

如果讀者沒有使用其他如Anaconda的方式安裝的話，
要安裝numpy最簡單的方式就是使用pip。

1
2
3
4


# 一般安裝指令
pip install numpy
# 如果發生安裝不起來的狀況，可以嘗試看看使用--user
pip install --user

我們先來介紹NumPy的最基本單位：陣列。
在Python中我們一般使用串列，也有陣列的模組，但一般不會用。
NumPy的陣列叫做ndarray，
它是一系列的相同資料型態的元素組成的，和串列不同，
串列可以這個放字串，另一個放int，但ndarray不允許這麼做喲!
nd是n-dimension(n維)的意思，
Numpy會將維度稱為rank。
單維的陣列就像一個row一樣；
二維的話就像Excel的表格有row/column；
三維就會像一個立方體(但不一定要正立方體)！

ndarray這麼設定是因為，
當我們在計算資料時，會用到一些矩陣運算或一些其他的科學運算方式，
在這當中會容易同時處理到多個資料，
因此使用比較方整的格式及固定資料型態，
可以讓配置每個元素的記憶體大小比較固定，
同時也便於取用和運算。
(所以會比list和Tuple等效率來得好)

接下來我們簡單介紹一下numpy的幾個基本指令：
np.array()：產生一個ndarray
ndim ：維度數 (rank)
shape ：每個維度的元素個數 (以Tuple型式呈現)
size ：總個數

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


>>> import numpy as np # 大家習慣的縮寫方式
>>> a = np.array([1, 5, 3, -1]) # 一維陣列
>>> a
array([1, 5, 3, -1])
>>> a.ndim # rank
1
>>> a.size # 陣列的元素總個數
4
>>> a.shape # 回傳每個rank有幾個值
(4,)
>>> b = np.array([[1, 3, 2, 4], [5, 4, 3]]) # 長度要符合阿大大！
<stdin>:1: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray
>>> b = np.array([[1, 3, 2, 4], [5, 4, 3, 3]]) # 正確的二維陣列
>>> b.ndim, b.size, b.shape # 所以我們會看到一個二維陣列，總數8個，2個rows，4個columns
(2, 8, (2, 4))

再來我們介紹另一個產生陣列的方式arange()：
arange基本上很像range()的用法，
舉例來說：
np.arange(10) -> 生成一個一維陣列，元素從09
np.arange(5, 10) -> 生成一個一維陣列，元素從59
np.arange(5, 11, 2) -> 生成一個一維陣列，元素為5, 7, 9
此外，還有比較特別的是，它可以接受帶小數點的輸入。

1
2


>>> np.arange(2, 8.8, 1.3)
array([2. , 3.3, 4.6, 5.9, 7.2, 8.5])

除此以外，也可以用以下幾個來初始化陣列：
zeros() -> 建立全是0的陣列

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


>>> import numpy as np
>>> np.zeros((3))
array([0., 0., 0.])
>>> np.zeros((3,)) # 因為傳入是Tuple，所以多寫一個逗號主要是提醒不要把外面的括號省略
array([0., 0., 0.])
>>> np.zeros((1, 5))
array([[0., 0., 0., 0., 0.]])
>>> np.zeros((3, 4))
array([[0., 0., 0., 0.],
 [0., 0., 0., 0.],
 [0., 0., 0., 0.]])

ones() -> 建立全是1的陣列
(範例就不浪費大家字數了，意思一樣)

random.random() -> 從0.0~1.0的隨機值來建立一個陣列(每個元素都是獨立的隨機值)

1
2
3
4
5


>>> np.random.random((2,6))
array([[0.01287523, 0.53233704, 0.79855996, 0.74661588, 0.53556373,
 0.01158943],
 [0.69197322, 0.90871892, 0.24175071, 0.73861581, 0.90259941,
 0.74164385]])

np.random這個系列底下其實也有很多常用的東西，
比如說如果我們想要一個最常見的常態分布的陣列，
我們可以使用random.normal()，
用法是np.random.normal(平均值, 標準差, size) ：

1
2
3
4
5
6
7


>>> mu, sigma = 0, 0.2
>>> c = np.random.normal(mu, sigma, (2, 8))
>>> c
array([[ 0.00521883, -0.04220576, 0.00590997, -0.06231083, 0.07088372,
 0.16073115, 0.30269475, -0.02136197],
 [-0.2599142 , -0.03247713, -0.00156353, -0.43750613, -0.01930995,
 -0.00546659, 0.18611712, 0.12076204]])

後續怎麼畫出來呢？讓我們留待到下一篇再告訴大家吧XD！

在介紹完初始化陣列後，
我們來講一個numpy的特異功能：reshape() 。
reshape顧名思義，就是將陣列重新捏成你想要的形狀。
比如假設我們做了一個一維的陣列，其size為9。

1
2
3
4


>>> s = np.random.normal(mu, sigma, 9)
>>> s
array([ 0.04298177, -0.14931128, 0.01522315, 0.10384426, 0.06392715,
 -0.02892813, 0.22175294, 0.06630997, -0.09279769])

使用reshape的方式，就是直接指定維度形狀，
只要reshape前後的size算起來是一致即可。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


>>> s.reshape(3, 3) # reshape完後若沒有回頭存起來，並不會修改到s呦!
array([[ 0.04298177, -0.14931128, 0.01522315],
 [ 0.10384426, 0.06392715, -0.02892813],
 [ 0.22175294, 0.06630997, -0.09279769]])
>>> s.reshape(1, 9)
array([[ 0.04298177, -0.14931128, 0.01522315, 0.10384426, 0.06392715,
 -0.02892813, 0.22175294, 0.06630997, -0.09279769]])
>>> s.reshape(9, 1)
array([[ 0.04298177],
 [-0.14931128],
 [ 0.01522315],
 [ 0.10384426],
 [ 0.06392715],
 [-0.02892813],
 [ 0.22175294],
 [ 0.06630997],
 [-0.09279769]])
>>> s.shape = (3, 3) # 直接對shape使用Tuple指定也可以呦！
>>> s
array([[ 0.04298177, -0.14931128, 0.01522315],
 [ 0.10384426, 0.06392715, -0.02892813],
 [ 0.22175294, 0.06630997, -0.09279769]])

在取得單一或範圍元素的時候，
陣列基本上跟串列蠻像的：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


>>> d = np.arange(24)
>>> d
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
 17, 18, 19, 20, 21, 22, 23])
>>> d[7]
7
>>> d[-1]
23
>>> d[10:18]
array([10, 11, 12, 13, 14, 15, 16, 17])
>>> d[10:18:2]
array([10, 12, 14, 16])

但如果是多維陣列的話，則必須要用逗號分隔不同的維度：
(Python的串列則是用中括號分隔)

1
2
3
4


>>> d.shape = 3,2,4
>>> d
array([[[ 0, 1, 2, 3],
 [ 4, 5, 6, 7]],

1
2


 [[ 8, 9, 10, 11],
 [12, 13, 14, 15]],

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


 [[16, 17, 18, 19],
 [20, 21, 22, 23]]])
>>> d[1]
array([[ 8, 9, 10, 11],
 [12, 13, 14, 15]])
>>> d[1:,1, 3]
array([15, 23])
>>> d[1:,1, 3:]
array([[15],
 [23]])
>>> d[1, 1]
array([12, 13, 14, 15])
>>> d[1, 1, 2:]
array([14, 15])

另一個功能是可以將值給定到陣列指定的範圍：

1
2
3
4


>>> d[1, 1, 2:] = 99999 # 將指定範圍的值全數換成99999
>>> d
array([[[ 0, 1, 2, 3],
 [ 4, 5, 6, 7]],

1
2


 [[ 8, 9, 10, 11],
 [ 12, 13, 99999, 99999]],

1
2


 [[ 16, 17, 18, 19],
 [ 20, 21, 22, 23]]])

在陣列計算時，我們使用陣列對數字加減乘除時，
可以將其一口氣全部作相同的事情：

1
2
3


>>> d + 1
array([[[ 1, 2, 3, 4],
 [ 5, 6, 7, 8]],

1
2


 [[ 9, 10, 11, 12],
 [ 13, 14, 100000, 100000]],

1
2
3
4
5


 [[ 17, 18, 19, 20],
 [ 21, 22, 23, 24]]])
>>> d * 3 + 2
array([[[ 2, 5, 8, 11],
 [ 14, 17, 20, 23]],

1
2


 [[ 26, 29, 32, 35],
 [ 38, 41, 299999, 299999]],

1
2
3
4
5


 [[ 50, 53, 56, 59],
 [ 62, 65, 68, 71]]])
>>> d / 3 + 2
array([[[2.00000000e+00, 2.33333333e+00, 2.66666667e+00, 3.00000000e+00],
 [3.33333333e+00, 3.66666667e+00, 4.00000000e+00, 4.33333333e+00]],

1
2


 [[4.66666667e+00, 5.00000000e+00, 5.33333333e+00, 5.66666667e+00],
 [6.00000000e+00, 6.33333333e+00, 3.33350000e+04, 3.33350000e+04]],

1
2


 [[7.33333333e+00, 7.66666667e+00, 8.00000000e+00, 8.33333333e+00],
 [8.66666667e+00, 9.00000000e+00, 9.33333333e+00, 9.66666667e+00]]])

除此以外，常用的矩陣運算numpy也都有所支援，
舉例來說，假設想要算兩個二維矩陣的相乘(內積)，
可以使用np.dot(x, y)或x.dot(y)：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


>>> x = np.arange(1, 5)
>>> x.shape=2,2
>>> y = np.arange(5, 9)
>>> y.shape=2,2
>>> x
array([[1, 2],
 [3, 4]])
>>> y
array([[5, 6],
 [7, 8]])
>>> x.dot(y)
array([[19, 22],
 [43, 50]])
>>> np.dot(x,y) # 跟x.dot(y)意思是一樣的
array([[19, 22],
 [43, 50]])

(註：如果是算外積的話，則要用outer())

如果是想要對應的位置兩兩相乘，則要用np.multiply()：

1
2
3


>>> np.multiply(x, y)
array([[ 5, 12],
 [21, 32]])

以上簡單介紹了一下numpy的用法，
當然只是蠻簡略的部分，
如果有更多對於詳細函式需求理解的部分，可以直接參考看看numpy的官方文件：
https://numpy.org/doc

那麼，我們就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (25) — 二元搜尋法模組bisect：我走回從前你往未來飛，遇見對的人錯過交叉點

Sat, 10 Oct 2020 00:00:00 +0800

Day 25 二元搜尋法模組bisect：我走回從前你往未來飛，遇見對的人錯過交叉點

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10247301

接下來，我們來談談二元搜尋法模組bisect。
在談bisect模組之前，我們先來談談二元搜尋法(binary search) 。

二元搜尋法的原則是，
當有一串排列好的陣列/串列時，
我們可以透過每次去掉一半來迅速找到目標。
為什麼可以做到這點呢？
假定我們有一個串列lt，其長度為n，
由於是已經排列好的(由小排到大)，
我們想要找到一個值target在lt中是否存在，
存在時所在的位置及不存在時應該插入的位置；

所以當我們取l=0, r=n-1的中間位置mid=(l+r)//2時，會有幾個可能：
lt[mid] > target =>
代表target在mid左邊的位置，所以要搜尋的範圍就會變成0~mid-1
lt[mid] == target => ** 代表target在mid位置上，可以直接回傳結果**
lt[mid] < target => ** 代表target在mid右邊的位置，**
所以要搜尋的範圍就會變成mid+1~r

因此，在尚未找到目標的狀況下，每次所需搜尋的範圍都會折半，
這也就是為什麼會被稱為二元或二分搜尋法的原因。

二元搜尋法的進一步實作是蠻基本的題目，
如果要嘗試不使用模組來處理的話，
可以參照
[Day 7] 從LeetCode學演算法 — 0035. Search Insert Position (Easy)。

在其他狀況下，如果題目重點不是考二元搜尋法，
或者在日常使用的話，則可以考慮使用bisect模組。

在使用bisect模組對某個list進行處理前，
需留意bisect已經預設這個list是排序過的狀態了 ！
類似前一篇提到的heapq，
如果必要的話，請先對list進行一般排序的動作。
bisect的常見用法如下：(import bisect)
bisect_left/bisect_right/bisect：
取得應該插入的位置 ，當中left/right則代表如果碰到相同的值，
會當成要插入在所有相同的值的左邊或右邊 (不給定則預設為右邊 )
insort_left/insort_right/insort：
取得對應的bisect回傳index後，使用這個index來進行插入的動作。
上述所有函式的參數都是(串列名a, 要插入的值x, lo=0, hi=len(a))，
沒有特別指定的話就會當作使用整個串列考慮插入的問題。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


>>> import bisect
>>> lt = [1,3,3,3,5,8,9]
>>> bisect.bisect_left(lt, 3) # 同值的最左邊
1
>>> bisect.bisect_right(lt, 3) # 同值的最右邊
4
>>> bisect.bisect(lt, 3) # 預設相當於right
4
>>> bisect.insort(lt, 3) # 實際插入
>>> lt
[1, 3, 3, 3, 3, 5, 8, 9]

順帶一提，使用bisect查找的速度，
扣除掉重覆值找到最左邊/最右邊外，
其時間複雜度為O(logN) 。(log這邊是以2為底的)

讀者可能會問：
「什麼是複雜度呢？」
簡單來說，複雜度就是用來評估程式作一件事情，
其所需的時間/空間和輸入的資料大小(通常會用N表示)之間，
大致的量級關係。
以list來說，我們使用index()函式取得某個值的所在位置的話，
其時間會是線性的(linear)，
也就是和list的長度成正比，我們會寫作O(N)。
對比起bisect而言，顯然有利用排序這點，
和沒有利用到這點會有根本性的差距，因為一個一個找，
和每次折半找，誰比較省時間就顯而易見了！

建議讀者有時間的話，
可以再進一步去查找一下關於基礎的複雜度分析，
因為有關程式複雜度分析，對於不論是實務上判斷不同方法之間的優劣，
或是面試的時候，回答考官你的解法的時候，
通常也都要回答關於時間複雜度及空間複雜度的問題，
所以有空的話可以先為自己打個底。

那麼，我們就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (24) — 資料結構模組heapq：除了前幾名以外，在座的各位都是垃圾

Fri, 09 Oct 2020 00:00:00 +0800

Day 24 資料結構模組heapq：除了前幾名以外，在座的各位都是垃圾

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10247299

昨天的題目，請參見下面的解法：
https://ithelp.ithome.com.tw/articles/10213277

接下來我們要來談談一個也算是蠻重要的資料結構：
堆積(heap)，以及在Python中對應的模組heapq 。

什麼是heap呢?
Heap是一種特別的完全二元樹。
這時候讀者又會問了：
那什麼是完全二元樹？
簡單來說，就是一棵二元樹直到最後一層之前，
由左往右都是填滿節點的狀態，中途沒有空缺，
唯有最後一層的右側會缺節點而已。

那麼，heap是怎麼個特別法呢？
當取一棵完全二元樹中的任何一個節點，
對應父(母)節點的值永遠小於等於子節點的值 (就是越上面越小)，
我們就會將其稱為最小堆積(min heap) ；
反之，如果父(母)節點的值永遠大於等於子節點的值 ，
我們就會稱為最大堆積(max heap) 。
如果上面兩個狀況都不符合的話就不是堆積囉！

也因此我們會得到一個特性：
最大堆積的最大的節點値 永遠會在根節點 ；
最小堆積的最小的節點値 永遠會在根節點 。

Python中的heapq的部分呢？
它是使用串列來實作出heap的資料結構的，
且是一個最小堆積 。
由於本篇以初學為導向，我們就不討論heap在二元樹上，
怎麼去處理新增/修改/刪除等操作了，
把焦點著重擺在heapq提供的可行操作上！

首先，Python可以將list輸入給heapq來排成heap的形狀，
透過heapq.heapify()函式 ：

1
2
3
4
5
6
7


>>> import heapq
>>> lt = [2,7,4,1,8,1]
>>> heapq.heapify(lt) # 直接將lt排成heap的形狀
# 在這個狀態下heap[k] <= heap[2*k+1] 且 heap[k] <= heap[2*k+2]
# 上面的k對於0或正整數均滿足(只要index存在)
>>> lt # 已經完成了，但並不是排序，所以看起來不會由小到大是正常的
[1, 1, 2, 7, 8, 4]

此外，由於現在lt已經是一個heap了，
要插入新的值或要處理其他操作的話，
要使用heapq提供的函式來處理，
常用的操作如下：
heapify (將一個list轉為heap)
heappush/heappop/heappushpop (放入/取出/先放入後取出)
nlargest/nsmallest (取前n大/前n小的元素)

當中我們只要只使用這些操作來處理，
就可以保證每次做取出(heappop)的時候，其値都會是最小的！
在這邊請留意幾點：

當使用append或者del (也就是用list的方式來動到lt)時，
會影響heap的狀態，若要復原只能重新heapify
由於這個heap是min heap，
所以nsmallest(取前n小元素)速度會比較快 ，較有效率，
nlargest(取前n大元素)是較沒有效率的，
官方會建議要這樣取不如直接先排序。
對於2來說，其實也有解法，
就是當需要用到max heap時，
我們手動將每個元素加上一個負號代入 ，
如此一來就可以將min heap當max heap來用啦！

我們拿LeetCode的1046題來當例子：
https://leetcode.com/problems/last-stone-weight/
題目大意是，
有一堆石頭，石頭重量均為正整數(阿不然是會有負的嗎？)。
每次我們拿最重的兩個石頭x, y(x <= y)相撞，
結果會有兩種：

x == y 的時候，兩顆石頭都會毀掉消失
x != y 的時候，只會剩下一顆石頭，重量為y — x
撞到最後，最多只會剩下1顆石頭，請問石頭的重量是多少？
(沒有石頭的話答案就視為0)

依照這個題目，我們會發現，
只要我們能建立一個max heap，
一切都會變得很輕鬆！
為什麼呢？
因為每次我們要拿兩個最重的相撞，
也就是每一輪要從heap當中取出兩個最大的值，
相減過後還有剩的，再放入heap中，
直到heap空掉，或者只剩1個值為止。

因此，我們可以如前面所提到的那樣，
先將石頭的重量加上負號並生成一個list，
再用heapq來對其處理。
我們直接來上程式碼，請對照註解來了解整個思路。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


class Solution:
 def lastStoneWeight(self, stones: List[int]) -> int:
 import heapq
 h = [-x for x in stones] # list comprehension
 heapq.heapify(h) # 生成最小堆積
 while len(h) > 1: # 堆積內還有超過1顆的石頭
 y = heapq.heappop(h) # 取第一顆，重量應該是-y
 x = heapq.heappop(h) # 取第二顆，重量應該是-x
 if y != x: # 兩顆沒有一起毀掉
 # 差值應該是-y+x，但為了放入heap中，要再加上一個負號
 heapq.heappush(h, y - x) # 再放入heap中
 if len(h) == 0: # 全部石頭都毀掉了，回傳0
 return 0
 else:
 return -h[0] # 回傳剩下的石頭的值，別忘了要負負得正

除了上述的需求外，
heap類型也適用於限縮個數的狀況。
比如說今天想要找一個班級的最強的前5名，
我們可以讓heap在個數尚未達到5個時使用heappush() ；
而達到5個後呢？就使用heappushpop() ，
先放入值，再將最弱的取出來丟掉。
所以當碰到”除了前5名以外，在座的各位都是垃圾”類型 的情況，
特別適合使用heap來進行操作，可以有效降低需要保留的元素個數。

那麼，我們就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (23) — 資料結構模組deque：旁人來來去去像行雲流水

Thu, 08 Oct 2020 00:00:00 +0800

Day 23 資料結構模組deque：旁人來來去去像行雲流水

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10247295

先來解一下上次的練習吧！

我們唯一需要動的應該只有calculate的函式，
當 p1 < p2 時，將兩個值交換即可。
別忘了交換應該要連同Entry裡面的值都一起換(price1/price2)。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


### calculate函式用來接受按鈕事件，取得商品價格及折扣方式，計算後輸出
def calculate():
 # 每次要計算時，都讓按鈕顯示計算哪一個折扣法
 btnstr.set('計算' + radiostr.get() + '中')
 # 用try...except...的方式來避免掉輸入的不是數字
 try:
 choice = radiostr.get() # radiobutton的選擇項
 p1 = int(price1.get())
 p2 = int(price2.get())
 if p1 <= 0 or p2 <= 0: # 如果輸入<=0的數字也當成例外處理
 raise Exception()
 if p1 < p2:
 p1, p2 = p2, p1
 price1.set(str(p1))
 price2.set(str(p2))
...(下面沒有變動XD)

我們今天要來談談deque的應用，
我們前面已經在第十一篇的部分提到過deque的用法，這篇主要要來補充deque作為queue時的常見狀況。

一般我們提到兩種資料結構：
queue(佇列)或stack(堆疊)的概念，
其實就是先進先出(FIFO, First-In-First-Out)或
先進後出(First-In-Last-Out)的區別。

queue就好像排隊一樣，當然是先排的先被服務到(除非有人插隊XD)；
stack則像是一疊文件一樣，假設你都拿最上面的，
當老闆又往上放新的文件(工作)給你的時候，
你再拿就會拿到最新放上去的囉！
這兩者在不同的程式語言有時候會有不同的稱呼和變形，
但本質是不變的。

那麼，什麼狀況下我們寫程式會容易用到queue(deque)呢?
最常見的狀況是遇到一個Tree(樹)的問題的時候！
那，什麼是樹呢？
好問題！這個問題應該要用比較長的篇幅解釋，
所以請讀者參閱拙作從LeetCode學演算法的第十四篇，
下面我們再繼續。

不囉嗦，我們直接上一道題目作為範例吧！
上面的連結應該已經介紹過二元樹了，
最簡單來說，一棵二元樹就是由根節點(root)，
及左子樹(left tree)/右子樹(right tree)所構成。
每個節點上有可能連結左右節點，
也可能沒有連接，稱為NIL，在Python為None。
如果我們今天想要按照一層一層順序來走遍整個樹，
並分層記錄的話，該怎麼做呢？
這個問題通常被稱為Level-order Traversal。(層序遍歷)
讀者可以前往LeetCode的題目看更詳細的描述。
https://leetcode.com/problems/binary-tree-level-order-traversal/
我們可以先走第一層，再走第二層，以此類推，
那麼這中間走完第一層時，怎麼知道第二層有哪些節點呢？
按順序的話，我們應該將第一層的每個節點的左節點/右節點，
放入到一個可以按照放入的順序處理的資料結構，
接著再從這個資料結構裡一個一個拿出來(這時候是第二層了!)，
找每一個的左右節點，再放進去……
咦？這個資料結構不就是queue嗎XD？

我們在解題和寫程式的時候，
可以先把要怎麼做大略寫出來，
再根據這個概念和做法，寫出具體的程式。

以這個問題來說，
題目應該會給出這個二元樹的根節點root，
接著要做的事情就如上面說的一樣，但我們需要一些細部的東西：

開一個res(result)作為存放答案用的串列。
我們先檢查root是否存在，有些題目壞壞的會給None，
如果不存在就直接回傳空的答案給它!
將root放入我們檢查的資料結構(因為它是第一層)，我們先叫它q吧!
開始一個迴圈，當q裡面還有節點時，代表還要繼續。
我們先記下q裡面的個數(命名為cnt)，後面放進去q的都是下一層的節點。
接著先設定一個level變數，用以記錄這層的節點值們。
在裡面再開一個迴圈，這次直接指定跑cnt次，
這樣所有這層的節點都會被我們取出來。
內層迴圈中，每次從q取出一個節點(popleft)，
將節點值(.value)append到level中，
檢查左節點，如果不是None的話就將節點放到q裡。
檢查右節點，做相同的事情XD
內層迴圈結束後，這時候我們拿到一整層的節點值，
我們應該要將其append到res這個結果裡。
最後全部處理完後，可以將res回傳。

好啦!經過上面的步驟，有沒有發現我們其實已經把程式寫完了呢？
只要按著順序對照，應該可以順利寫出答案。

那麼，我們就來看看實際的做法：

1
2
3
4
5
6


# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None

1

from collections import deque

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


class Solution:
 def levelOrder(self, root: TreeNode) -> List[List[int]]:
 res = [] # result，用以記錄結果
 if not root: return res # 我們有提過，if not可以用來檢查東西是不是空的
 q = deque([root]) # deque的初始化，要以list的形式放入
 while q: # 當q還有節點(同樣這相當於檢查是不是空的)
 cnt = len(q) # deque支援len的操作(取長度)
 level = [] # 記錄每層的節點值
 for _ in range(cnt): # _沒有特別意思，通常是當沒有要在迴圈內用到時可以使用
 n = q.popleft() # popleft等於從deque的左邊取出，也就是queue的用法
 level.append(n.val) # 取值
 if n.left: q.append(n.left) # 將左節點放入q
 if n.right: q.append(n.right) # 將右節點放入q
 res.append(level) # 每層完成後，要將一整層的節點值list放到res中

 return res # 回傳，結束！

應該不算太難(吧)…?
請務必要看完樹的那篇定義再來看這篇喲！
總言之，deque作為queue使用時，主要會用popleft()跟append()來操作，
同時它會適合按先後順序放入及取出的情況。

練習題目的話，
讀者可以再嘗試看看LeetCode的另一題：
101. Symmetric Tree

那麼，我們就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (22) — 圖形化使用者介面Tkinter：直到現在，我還默默的等待

Wed, 07 Oct 2020 00:00:00 +0800

Day 22 圖形化使用者介面Tkinter：直到現在，我還默默的等待

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10247294

上次的練習我們就不驗收了，相信大家應該可以做得好的XD!
今天我們來聊聊Python的圖形化使用者介面。
如果讀者手上有一些Python的入門書，
相信在這個單元之前，常常會看到一個烏龜的範例(Turtle模組)，
那就是一種會顯示圖形化的介面其中一種。
通常我們會將有圖形化的互動介面稱為GUI(Graphical User Interface)介面，
在Python當中如果算上其他的GUI介面的話，
其實相當多種，最常見的有Tkinter/PyQT/WxPython/Kivy 等，
如果就一般人而言，沒有特殊需求的話，
使用內建的Tkinter模組作為開頭應該就很足夠囉！

每個tkinter的主體會先由tkinter.Tk()的物件生成，
通常讀者們應該會看到大部分的範例會將tkinter縮寫成tk ，
並將生成的物件命名為window或win (代表這個視窗介面)，
後續的操作也都跟其息息相關。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


>>> import tkinter as tk
>>> win = tk.Tk() # 如果使用直譯器的話，在這行Enter後就會先看到一個視窗了！
>>> win.title('從零開始學Python：第二件X折？') # 更改視窗的標題
''
>>> win.geometry('800x400') # 修改視窗大小(寬x高)
''
>>> win.resizable(False, False) # 如果不想讓使用者能調整視窗大小的話就均設為False
''
>>> win.iconbitmap('unicorn.ico') # 更改左上角的icon圖示
''
>>> win.mainloop() # 在一般python xxx.py的執行方式中，呼叫mainloop()才算正式啟動

(註：下面的操作我們都先在直譯器中嘗試，請先不要下mainloop()以免無法再輸入指令)
我們在上面的示範中使用了一個icon檔，是一隻打瞌睡的獨角獸：
https://www.flaticon.com/free-icon/unicorn_3468081
但下載下來的時候是png檔，而使用圖示只會接受icon bitmap 的格式，
使用者可以利用上一篇教的PIL來進行轉換：

1
2
3


>>> from PIL import Image
>>> img = Image.open('unicorn.png')
>>> img.save('unicorn.ico')

或者，也可以用另一個iconphoto()方法 ，
它可以接受一些其他類型的圖片(png可以，但jpg不行)

1

>>> win.iconphoto(True, tk.PhotoImage(file='./unicorn.png'))

接下來讓我們介紹Frame。Frame可以想成是一個區塊 ，
用來切分視窗以方便進行排版，
舉例來說，如果我們想要在上面塞一個寬度800，高度為100的Frame：

1
2
3


# bg可以用顏色名稱，或者使用'#FF0000'的RGB形式來給定
>>> fm = tk.Frame(win, bg='violet', width=800, height=100)
>>> fm.pack() # 設定Frame的排版方法，這行完成後才會在視窗上顯現

(註：排版方法有pack(), grid(), place()三種 ，
若讀者有興趣可再自行深入研究。)

再來是按鈕Button 的部分，值得注意的是，
我們可以運用textvariable的參數來給定tk.StringVar變數 ，
用來讓我們可以動態調整按鈕上的字的變化。

1
2
3
4
5
6
7
8


>>> def calculate():
... btnstr.set('計算中...')
...
>>> btnstr = tk.StringVar() # 初始化tk的字串變數
>>> btnstr.set('按我計算')
>>> btn = tk.Button(win, bg='violet', fg='white', textvariable=btnstr, font=('微
軟正黑體', 20), command=calculate)
>>> btn.pack()

在上面的例子中，我們初始化了一個btnstr的變數，
並且將其在開一個Button變數時，作為文字變數(StringVar)給定進去；
同時，當按鈕被按下時，calculate這個函式將被呼叫，
從而將按鈕上的字進行改變。
tk的變數有StringVar, IntVar, DoubleVar 等三種，
其使用方式是set()用以設定變數，get()用以取得變數內容 。

如果我們單純想要顯示文字，不想被使用者修改的話，
應該要使用文字標籤(Label) ；
如果是要被輸入的文字方塊的話，
則可以使用文字輸入欄(Entry) ；
想要使用單選的選項的話，
則可以使用單選按鈕(Radiobutton) ；
想要跳出提示方塊的話，
就要使用對話框(Messagebox) 。

由於這當中嘗試一些排版和顏色太過複雜，
我們直接上最後的程式碼給讀者，
請一段一段沿著往下讀，
每一段可以先貼到直譯器上跑，
可以看到對應的元件生成的樣貌，
這樣會更為清楚每一段在作什麼呦！

1
2


import tkinter as tk
import tkinter.messagebox as msg # messagebox要另行匯入，否則會出錯。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


### calculate函式用來接受按鈕事件，取得商品價格及折扣方式，計算後輸出
def calculate():
 # 每次要計算時，都讓按鈕顯示計算哪一個折扣法
 btnstr.set('計算' + radiostr.get() + '中')
 # 用try...except...的方式來避免掉輸入的不是數字
 try:
 choice = radiostr.get() # radiobutton的選擇項
 p1 = int(price1.get())
 p2 = int(price2.get())
 if p1 <= 0 or p2 <= 0: # 如果輸入<=0的數字也當成例外處理
 raise Exception()
 if choice == '一': # 買二件88折
 p = 0.88 * (p1 + p2)
 elif choice == '二': # 第二件6折
 p = p1 + p2 * 0.6
 else: # 第二件半價
 p = p1 + p2 * 0.5
 total.set(str(int(p))) # 顯示總額
 except:
 # 例外處理：先全部歸0，再跳提示視窗
 price1.set('0')
 price2.set('0')
 total.set('0')
 msg.showerror('輸入錯誤!', '請輸入正確的數字!')
 btnstr.set('算選項' + radiostr.get())

1
2
3
4


### select會在選中了某個折扣的時候被呼叫，此時會再呼叫calculate快速計算比較方便
def select():
 btnstr.set('算選項' + radiostr.get())
 calculate()

1
2
3
4
5
6


#### 主視窗生成
win = tk.Tk()
win.title('從零開始學Python：第二件X折？')
win.geometry('800x220')
win.resizable(False, False)
win.iconbitmap('unicorn.ico')

1
2
3
4


### Frame fm_cal: 放計算按鈕、"總額"文字label、總額金額顯示label
fm_cal = tk.Frame(win, bg='skyblue', width=800, height=100)
# fill表示沒填滿的部分是否填滿，BOTH表示xy方向都填滿，讀者可以試試看去掉的差別
fm_cal.pack(fill=tk.BOTH)

1
2
3
4
5


btnstr = tk.StringVar() # 初始化tk的字串變數
btnstr.set('按我計算')
btn = tk.Button(fm_cal, bg='#71C973', fg='white', textvariable=btnstr, font=('微軟正黑體', 20), command=calculate, pady=10) # pad是指兩個元件之間空出多少距離
# side代表排版對齊時跟上個元件從哪個方向開始對齊
btn.pack(side=tk.LEFT, padx=10, pady=10) # padx/pady分別就是x方向跟y方向

1
2
3
4


lbl_text = tk.Label(fm_cal, bg='#F95E62', fg='white',
 text='總額：', font=('微軟正黑體', 20),
 padx=10, pady=10)
lbl_text.pack(side=tk.LEFT, padx=108)

1
2
3
4
5
6


total = tk.StringVar() # 初始化tk的字串變數
total.set('0')
lbl_total = tk.Label(fm_cal, bg='#F95E62', fg='white',
 text='0', textvariable=total, font=('微軟正黑體', 20),
 padx=10, pady=10)
lbl_total.pack(side=tk.LEFT, padx=57, pady=10)

1
2
3


### Frame fm_lbl: 放標籤及Radiobutton(折數)
fm_lbl = tk.Frame(win, bg='#FF9955', width=800, height=150)
fm_lbl.pack(side=tk.TOP, fill=tk.BOTH)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


lbl1 = tk.Label(fm_lbl, bg='#F95E62', fg='white',
 text='第一件價格', font=('微軟正黑體', 20),
 padx=10, pady=10)
lbl1.pack(side=tk.LEFT, padx=10, pady=10)
lbl_plus = tk.Label(fm_lbl, bg='#FF9955', fg='black',
 text='及', font=('微軟正黑體', 20),
 padx=10, pady=10)
lbl_plus.pack(side=tk.LEFT, padx=10)
lbl2 = tk.Label(fm_lbl, bg='#F95E62', fg='white',
 text='第二件價格', font=('微軟正黑體', 20),
 padx=10, pady=10)
lbl2.pack(side=tk.LEFT, padx=10)
lbl_plus2 = tk.Label(fm_lbl, bg='#FF9955', fg='black',
 text='及', font=('微軟正黑體', 20),
 padx=10, pady=10)
lbl_plus2.pack(side=tk.LEFT, padx=10)
lbl_coupon = tk.Label(fm_lbl, bg='#F95E62', fg='white',
 text='折扣', font=('微軟正黑體', 20),
 padx=10, pady=10)
lbl_coupon.pack(side=tk.LEFT, padx=10)

1
2
3


### Frame fm_rad: 放Radiobutton(框一組自己對齊)
fm_rad = tk.Frame(fm_lbl, bg='#FF9955', width=150, height=150, padx=30)
fm_rad.pack(side=tk.LEFT, fill=tk.BOTH)

1
2
3
4
5
6
7
8
9


# StringVar的初始化值在第二個參數，第一個要填None
radiostr = tk.StringVar(None, '一')
# command會對應到選取時呼叫的函式，同時當選擇到它，value的值會放入variable的變數
r1 = tk.Radiobutton(fm_rad, bg='#FF9955', text='買兩件88折', variable=radiostr, value='一', command=select)
r1.pack(anchor=tk.W) # 另一個對齊方式，由上而下，但上下之間是靠左對齊
r2 = tk.Radiobutton(fm_rad, bg='#FF9955', text='第二件6折', variable=radiostr, value='二', command=select)
r2.pack(anchor=tk.W)
r3 = tk.Radiobutton(fm_rad, bg='#FF9955', text='第二件半價', variable=radiostr, value='三', command=select)
r3.pack(anchor=tk.W)

1
2
3


### Frame fm_ent: 放entry(輸入兩件商品分別的價格)
fm_ent = tk.Frame(win, width=800, height=200)
fm_ent.pack(side=tk.TOP, fill=tk.BOTH)

1
2
3
4


# ent1對應到price1
price1 = tk.StringVar(None, '0')
ent1 = tk.Entry(fm_ent, width=20, justify='center', textvariable=price1)
ent1.pack(side=tk.LEFT, padx=17, pady=7, fill=tk.Y)

1
2
3
4
5


# 為了排版增加的空白label
lbl_empty = tk.Label(fm_ent,
 text='　', font=('微軟正黑體', 20),
 padx=20)
lbl_empty.pack(side=tk.LEFT)

1
2
3
4


# ent1對應到price2
price2 = tk.StringVar(None, '0')
ent2 = tk.Entry(fm_ent, width=20, justify='center', textvariable=price2)
ent2.pack(side=tk.LEFT, padx=17, pady=7, fill=tk.Y)

1
2


# 開始整個主程式
win.mainloop()

最後的成果大概像這樣子：

輸入錯誤時的對話框：

這當中其實還有很多沒有講到的東西和元件，
像是Listbox/Scrollbar等。
但實在太多可以用的了，所以我們就先不管啦!
有興趣的讀者可以再行深入玩玩看其他的元件呦XD!

那麼今天也來一點簡單的練習吧！

我們知道其實這個程式可能存在一些漏洞，
最顯眼的應該就是在屈X氏的第二件O折這種事情，
第二件一般都應該要取價低者計算才對。
請想辦法修改上面的程式，使得當使用者有正常輸入數字，
碰到上述狀況時，主動將價格排列正確，
並同樣計算出正確的結果。
(Optional，可以不做)事實上，
tkinter也有人撰寫可以在GUI界面拉出整個排版的程式，
請有興趣的讀者在GitHub(https://github.com/)上進行搜尋，
(例如”tkinter gui”)
並找到一個適合你使用的介面，嘗試操作看看。

那麼，我們就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (21) — 基本圖形處理Pillow：花下是誰對影成雙

Tue, 06 Oct 2020 00:00:00 +0800

Day 21 基本圖形處理Pillow：花下是誰對影成雙

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。https://ithelp.ithome.com.tw/articles/10247292

我們先來解昨天的練習吧！

我們整理一下三種解的寫法，並且分別改名成cs1, cs2, cs3，
那麼計算時要注意的有：

為了確保有在運行，我們多加一個print()，可以自行拿掉。
cs2記得要給起始的字典，當然也可以直接在(n, dic)這邊給入也行。
記得下globals=globals()。

1

import timeit

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


def cs1(n):
 if n == 1 or n == 2:
 return n
 return cs1(n-1) + cs1(n-2)

def cs2(n, dic):
 if n in dic:
 return dic[n]
 dic[n] = cs2(n-1, dic) + cs2(n-2, dic)
 return dic[n]

1

# dic = {1 : 1, 2 : 2} # 這個應該要放到setup裡

1
2
3
4
5
6


import functools
@functools.lru_cache(maxsize=None)
def cs3(n):
 if n == 1 or n == 2:
 return n
 return cs3(n-1) + cs3(n-2)

1
2
3
4
5


print(timeit.timeit('print(cs1(35))', globals=globals(), number=10))
print()
print(timeit.timeit('print(cs2(35, dic))', setup='dic = {1 : 1, 2 : 2}', globals=globals(), number=10))
print()
print(timeit.timeit('print(cs3(35))', setup='import functools', globals=globals(), number=10))

接下來我們來講基本的影像處理。
PIL(Python Imaging Library)是一套影像處理的模組，
可以做到一些常見的影像處理和操作，
比如裁切、平移、旋轉、縮放，
調整亮度、色調，套用濾鏡等等，
雖然是沒有專業的Photoshop(免費的有GIMP)等軟體厲害，
但勝在可以在Python中用程式的方式來處理。
但原本的PIL早在Python 2.7後就斷更了，
但後來有一群好心人在這個基礎上開了一個新的版本，
並命名為Pillow，除了支援Python 3.x的版本外，
也加入了一些特性，所以我們這裡只需要安裝Pillow就行啦！
由於不是內建函式庫，請利用安裝Python時，
所附帶pip套件管理程式來安裝Pillow：

1

pip install Pillow

我們下面使用從pixabay取得的免費圖片，
進行接下來的操作(請下載後將圖片放置執行程式的位置)：

1
2
3
4
5


>>> from PIL import Image
>>> img = Image.open('flower.jpg') # 讀檔
>>> img.format, img.size, img.mode # 圖片格式，寬高，RGB彩色
('JPEG', (1920, 1280), 'RGB')
>>> img.show() # 會將圖片顯示在螢幕上

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


>>> img_rotate = img.rotate(180) # 將圖片順時針轉180度
>>> img_rotate.show() # 再顯示，應該會看到倒過來的花瓶
# 要裁切請用crop, 並且必須傳入Tuple，4個數分別代表左上(x1, y1)/右下(x2, y2)
# 在一般程式的圖形處理中，原點(0, 0)在左上角
# 往右代表x增加，往下代表y增加，留意和一般座標的定法不同！
>>> img_crop = img_rotate.crop((960, 50, 1920, 1080))
>>> img_crop.show() # 將旁邊的空白修掉了一點，再來看看結果
# 按照決定的寬高來縮放調整圖片大小，同樣需要以Tuple表示
>>> img_resize = img_crop.resize((240, 250))
>>> img_crop.save('crop.jpg')
>>> img_res = img_resize.rotate(180) # 再轉過來
>>> img_res.save('res.bmp') # 存到檔案，格式依照副檔名決定。
# 將img_res的內容貼到img_rotate上，並合成一張(當然還是要save過後才能看到改變)
>>> img_rotate.paste(img_res, (0, 0))
>>> img_rotate.show()
>>> img_rotate.save('combination.png')

最後的結果應該如下：

上面我們簡單的使用了幾個屬性和方法：
format/size/mode(顯示格式/大小/色彩模式)
show/rotate/crop/paste/save(顯示圖片/旋轉/裁切/貼上/存檔)
其他還有像是filter(濾鏡，在ImageFilter模組裡)可以作一些基本的特效，
讀者有興趣可以再查找相關的方法嘗試。

接下來，我們再來看看其他有趣的功能。
假設今天我們想要製作簡單的長輩圖，
(以原來的flower.jpg為例，其寬高為1920及1280)
那我們需要Pillow裡面關於繪圖的模組來進行操作，
該模組名為ImageDraw，
可以用來處理繪製各種常見圖形，以及文字的方法。
同時，由於一般的文字字型會有不能處理中文的問題，
我們這邊會直接引入truetype的中文字型，
讀者可以從C:\Windows\Fonts選擇一個喜歡的字型，
並將其複製到你所使用的資料夾以利操作。
我們下面會以複製”微軟正黑體”為例，
複製到資料夾後會看到三個變形的字體，
分別是msjh.ttc, msjhl.ttc, msjhbd.ttc，
我們接下來選擇當中的msjhbd.ttc(粗體字型)進行操作。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


>>> from PIL import Image, ImageDraw, ImageFont
# 如果要用空白畫布來繪製，可以用Image.new("RGB", (400,300))的形式建立。
>>> img = Image.open('flower.jpg')
# copy可以用來複製一個Image物件，先備份一下，不行就拿它來蓋掉img
>>> backup_img = img.copy()
>>> backup_img.show()
# 建立一個Draw物件，接下來draw所有的操作都會影響到img上面。
>>> draw = ImageDraw.Draw(img)
>>> font = ImageFont.truetype('./msjhbd.ttc', 100) # 給定字型及大小
>>> text = '霹靂卡霹靂拉拉 波波力那貝貝魯多'
>>> draw.text( (960, 320), text, font=font) # 好像太大了?
>>> img.show()
>>> font = ImageFont.truetype('./msjhbd.ttc', 50) # 改一下大小
>>> draw.text( (960, 320), text, font=font) # 再畫一次(應該會重複)
>>> img.show()
>>> img = backup_img.copy() # 洗掉吧！
>>> draw = ImageDraw.Draw(img) # 蓋回來會影響到draw跟img的連結，所以要重置
>>> draw.ink = 0xff0000 # 我們可以更改要使用的顏色(0x代表16進位)
>>> draw.text( (960, 320), text, font=font)
>>> img.show() # 看起來應該是藍色
# 也可以使用fill參數代入，順序是RGBA，也就是紅、綠、藍、透明度(alpha)
>>> draw.text( (1060, 960), '認同請分享', font=font, fill=(255,0,0,128))
>>> img.show()
# 正式來囉！關於顏色的選擇可以使用如htmlcolorcodes等網站來取得色碼
>>> img = backup_img.copy()
>>> draw = ImageDraw.Draw(img)
>>> font = ImageFont.truetype('./msjhbd.ttc', 60)
>>> draw.ink=0xF39C12
# draw.text()可以多行
>>> text = '請常唸\n\n　　霹靂卡霹靂拉拉\n　　波波力那貝貝魯多\n\n唸時\n須心無雜念 專注 便可心想事成'
>>> draw.text( (1000, 300), text, font=font)
>>> font = ImageFont.truetype('./msjhbd.ttc', 70)
>>> draw.text( (1520, 960), '認同請分享', font=font, fill=(165, 105, 189, 0))
>>> img.show()
>>> img.save('elder.jpg') # 送給長輩吧XD！

結果應該會像這樣：

除了文字以外，當然也可以畫一些像是點、線、矩形、橢圓等幾何圖形，
讀者可以再參照Pillow的ImageDraw模組的說明文件。

今天的練習的部分，
請嘗試運用今天提到的部分，
幫筆者設計一個宣傳長輩圖XD!
例如：
「請常唸
從LeetCode學演算法基礎打底進階扎實面試通靈
選購全套享優惠居家旅行通過面試必備良藥
認同請分享」
歡迎貼到留言區讓大家看看你的設計XD!

那麼，我們就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (20) — 時間量測與效率檢驗：你的時間也不是你的時間

Mon, 05 Oct 2020 00:00:00 +0800

Day 20 時間量測與效率檢驗：你的時間也不是你的時間

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10247284

我們先來解一下昨天的練習吧！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


>>> from datetime import date, datetime, time ,timedelta
>>> now = date(2020, 10, 1)
>>> mem = [date(2021,8,14), date(2021,2,14), date(2021,3,14), date(2020,10,3), d
ate(2021,11,3)]
>>> diff = sorted([d - now for d in mem]) # 你沒看錯，是可以排序的~
>>> diff
[datetime.timedelta(days=2), datetime.timedelta(days=136), datetime.timedelta(da
ys=164), datetime.timedelta(days=317), datetime.timedelta(days=398)]
>>> for d in diff:
... print(str(d)) # 這樣顯示也可以啦！但好像可以簡單一點XD
...
2 days, 0:00:00
136 days, 0:00:00
164 days, 0:00:00
317 days, 0:00:00
398 days, 0:00:00

1
2
3
4


>>> days = [d.days for d in diff] # deltatime也可以單取其中的單位
>>>
>>> days
[2, 136, 164, 317, 398]

糟糕，這篇文貼出來的時間點第一個重要日子已經過了，
只好希望小亦有記得阿啾的生日了XD

上一篇我們提到了可以利用time.time()來計算，
但如果要取平均的話，可能要自己寫迴圏來處理，
但寫迴圏這件事情從根本上就有些破壞原本的結構，
那麼該怎麼作比較好呢？
我們可以利用timeit這個模組。
當我們想簡單計算某個指令的耗時的時候，
我們可以先用直接在命令提示字元裡下指令的方法，
比方說：

1
2


C:\Users\Desolve\utils>python -m timeit "'-'.join(str(n) for n in range(100))" # 今晚，我想來點字串組合套餐
10000 loops, best of 5: 23 usec per loop

“python -m” 可以讓我們得以呼叫一些標準函式庫的方法並輸入一些參數，
以本例來說，就是呼叫timeit，
然後要求它測試將0~99轉成字串並用”-”連接起來的耗時。
我們可以看到在沒有預設的狀況下，它跑了10000次，
並且取到最快的5次平均，結果平均速度是23微秒。
這個相當於我們在直譯器或.py檔中使用timeit.timeit()，
其方法為：
timeit.timeit(stmt, setup, timer, number) ，
stmt: 被量測的程式碼
setup: 開始前可能有一些前置的設定要做的話就放在這裡
timer: 請忽視，這是預設的timer
number: stmt執行的次數

1
2
3
4
5
6
7
8
9


>>> import timeit
>>> timeit.timeit("'-'.join(str(n) for n in range(100))")
... # 然後你就會發現卡住了，因為在這裡預設的次數是1000000次(一百萬次)
# 連續按Ctrl+C以中斷上面的執行
>>> timeit.timeit("'-'.join(str(n) for n in range(100))", number=10000)
0.24359135900000695
# 需要多行的話，請使用分號分隔不同行
>>> timeit.timeit(stmt='x=3;y=5;res=x*y')
0.04275195899998607

如果想要重複timeit的測量，可以使用timeit.repeat()：

1
2
3
4
5


# 相當於做timeit.timeit() 7遍
>>> timeit.repeat(stmt='x=3;y=5;res=x*y', number=10000, repeat=7)
[0.0004259219999767083, 0.0004217530000687475, 0.0004227150000133406, 0.00042143
199993915914, 0.00043714699995689443, 0.0004217530000687475, 0.00044612800002141
74]

如果是要測試一整個函式，我們是可以將整段都塞進字串裡沒錯，
但看起來太醜了XD!
那麼，怎麼樣在不動到原有的程式碼的狀況下新增進行測試呢？

我們可以使用類似如下的方式：

1

import timeit

1
2
3
4
5
6
7
8


def f():
 import os
 for path, dirs, files in os.walk('.'):
 print(path)
 for f in files:
 print(os.path.join(path, f))
 for d in dirs:
 print(os.path.join(path, d))

1
2
3
4


# 下面這三行的做的事情是一樣的
print(timeit.timeit(f, number=5))
# print(timeit.timeit('f()', setup='from __main__ import f', number=5))
# print(timeit.timeit('f()', globals=globals(), number=5))

其結果如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


C:\Users\Desolve\utils>python fromzero
.
.\bookstore.json
.\check.py
.\fromzero.py
.\poem.txt
.\schedule.py
.\__init__.py
.\csv
.\json
.\__pycache__
.\csv
.\csv\student.csv
.\csv\student_dic.csv
.\json
.\json\classA.json
.\__pycache__
.\__pycache__\check.cpython-38.pyc
.\__pycache__\schedule.cpython-38.pyc
.\__pycache__\__init__.cpython-38.pyc
...(會再重複4次)
0.008256415

stmt也可以直接傳入函數名稱，這時候後面就不用加括號了，
因為是當成一個函數物件；
如果當成一個字串來傳進去的話，
就必須要在setup的時後告訴它主程式 有這個東西，
這樣Python才認得到呦！
(也就是__main__)
或者，也可以使用globals=globals()，
直接將所有的程式碼當成全域來用，也可以達到相同的效果。

昨天到今天這兩篇，應該可以幫助讀者對於時間相關的方法有初步的認識。
事實上要再深究的話，執行時間還會受到一些額外的影響，
比如Python的gc(資源回收處理)，執行程式時電腦其他程式占用CPU資源的影響等，
但這比較深入一些，我們就不在這裡細究了XD！
(註：timeit預設會把gc關掉，如果要測打開的狀況，
可以在setup放入’gc.enable()’。)

最後我們也來做個練習吧！

還記得先前我們講遞迴嗎(第九篇)？
我們後面有做過練習，在第十篇有解答。
我們比較過沒有做好的遞迴的一個解答，
跟有記錄前面答案的遞迴，且提供了二個解答；
請比較這三種在做n=35 的時候的計算時速度的差異。
(注意：只做n=35 即可，不用算1~35，此外number取10次 就好。)

那麼，我們就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (19) — 日期與時間：你知不知道，我等到花兒也謝了

Sun, 04 Oct 2020 00:00:00 +0800

Day 19 日期與時間：你知不知道，我等到花兒也謝了

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10247281

接下來我們要聊到日期與時間的處理相關模組：
datetime跟time。
請想像一下，在人生當中，是不是常常有要算日子和時間的時候？
不論是算退伍還有多少天；
算紀念日520天是什麼時候；
算紀念日1000天是什麼時候；
算紀念日2000天是什麼時候……XD
我們可以利用Python的datetime模組來幫忙計算時間日期與時間差，
這樣子就不會在被問今天是什麼日子的時候答不出來了(吧)！

datetime 當中就有date物件 和time物件 ，
接下來的示範還是屬於datetime模組的範疇，
請大家不要跟後面的time模組 搞混歐！
我們先來看看操作日期的date 物件的用法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


>>> from datetime import date
>>> doubleten = date(2020, 10, 10) # 順序是年/月/日
>>> doubleten.year, doubleten.month, doubleten.day
(2020, 10, 10)
# 用isoformat()和str()都可以轉成用"-"連接的字串
>>> doubleten.isoformat(), str(doubleten)
('2020-10-10', '2020-10-10')
>>> today = date.today() # today()會取到今天
>>> str(today) # isoformat格式會補0
'2020-10-01'
# 2020-10-01是星期四，weekday的記法是0(星期一)~6(星期日)
# isoweekday的記法則是1(星期一)~7(星期日)
>>> today.weekday(), today.isoweekday()
(3, 4)
# strftime可用來格式化想要的顯示樣態和目標
>>> doubleten.strftime('%Y--%m--%d, WeekDay: %a')
'2020--10--10, WeekDay: Sat'

關於strftime以及後面常見的格式，
大體上會跟一般通用的表示法相同，
例如%Y代表年，%m代表月，%d代表日，%a則代表星期幾的縮寫；
其他還有%H(小時)、%M(分)、%S(秒)等等，
可以參考strftime() 和 strptime() Format Codes。

datetime中的time物件操作方式也很類似：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


>>> from datetime import time
>>> time() # datetime的time.time()預設是從0開始
datetime.time(0, 0)
>>> now = time()
>>> now.isoformat()
'00:00:00'
>>> now = time(0,0,0,38) # 最小單位到微秒(百萬分之一秒，也就是10e-6)
>>> now.microsecond # 取微秒
38
>>> now = time(hour=19, second=50)
>>> str(now)
'19:00:50'
>>> now.strftime('%H-%M') # 同樣可以適用strftime
'19-00'

或者，兩者都要的話，
可以直接使用datetime.datetime物件！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


>>> from datetime import datetime
>>> datetime.today() # 現在的時間，計到微秒
datetime.datetime(2020, 10, 1, 17, 37, 7, 490703)
>>> datetime.utcnow() # UTC標準時間(所以台灣是+8，看出來了嗎？)
datetime.datetime(2020, 10, 1, 9, 37, 43, 823644)
# str這邊和isoformat就會有點不一樣了，isoformat會用"T"來分隔。
>>> str(datetime.now())
'2020-10-01 17:39:03.953659'
>>> datetime.now().isoformat()
'2020-10-01T17:39:23.671787'

讀者可能會問：
「不對阿，說好的算紀念日呢？」
要計算日期差距相關的處理，
我們要用到datetime的另一個物件：
timedelta 。
timedelta的建立很簡單，就是timedelta(時間差)。
下面我們假設小亦向阿啾在今年的情人節2/14告白並成功了 ，
接下來我們先來算一下到現在(10/1)為止 ，
他們已經經過了幾天，到後面的紀念日又還有多久呢？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


>>> from datetime import date, datetime, time ,timedelta
>>> valentine = date(2020, 2, 14)
>>> today = date.today()
>>> romanticlen = today - valentine # date相減會變成timedelta
# 算一算交往時間吧！
>>> romanticlen
datetime.timedelta(days=230)
# 小亦要記得的幾個紀念日
>>> remember = [100, 200, 520, 1000, 2000]
# 注意timedelta也可以用乘上數字來和定點日期相加減計算，相當有彈性
>>> memorialday = [valentine + timedelta(days=i) for i in remember]
>>> memorialday # 咦？這時間怎麼好像有的已經過了？
[datetime.date(2020, 5, 24), datetime.date(2020, 9, 1), datetime.date(2021, 7, 1
8), datetime.date(2022, 11, 10), datetime.date(2025, 8, 6)]
>>> diff = [i - today for i in memorialday] # 來減看看！
>>> diff # 小亦你很糟糕歐，有兩個紀念日已經過了！阿啾會哭哭呦XD
[datetime.timedelta(days=-130), datetime.timedelta(days=-30), datetime.timedelta
(days=290), datetime.timedelta(days=770), datetime.timedelta(days=1770)]

講完了datetime，我們現在來講time 模組。
time模組比較簡單一點點，基本上最常用到的就是time.time()。
time.time()會給出Unix標準時間 ，
也就是以1970年1月1號起算到目前為止帶小數點的總秒數(不用背，不會考XD)。
如果使用localtime()的話，則會換算成現在所在時區的時間。

1
2
3
4
5
6


>>> import time
>>> time.time()
1601547391.7189288
>>> time.localtime() # 筆者電腦目前是2020年10月1日下午6點16分
time.struct_time(tm_year=2020, tm_mon=10, tm_mday=1, tm_hour=18, tm_min=16, tm_s
ec=34, tm_wday=3, tm_yday=275, tm_isdst=0)

上面範例中的struct_time是time的另一個物件，
作用是可以用來給定一個指定的時間方便處理。
我們也可以使用time.ctime()或time.strftime(格式化字串, 時間)，
將其轉換成易讀的字串。

1
2
3
4
5


>>> now = time.localtime()
>>> time.ctime()
'Thu Oct 1 18:22:46 2020'
>>> time.strftime('現在是%A, %Y年%m月%d日的%H時%M分%S秒', now)
'現在是Thursday, 2020年10月01日的18時22分35秒'

不同的國家語系，給出來的縮寫等會不同，
如果要再精細轉換的話，可以使用local進行setlocale()的操作，
有興趣的話，可以再進一步研究一下用法。

但最常被簡單用到的方式還是time.time()跟time.sleep()了 !
通常狀況下，我們會在跑完一段想測量的程式以後，
使用time.time()的差值 來計算時間。
time.sleep()則可以讓程式暫時停止執行指定的秒數 ，
待時間到才繼續運作。
我們拿前面的os的程式來修改一下測試這兩個方法，
會發現多次測試下，扣掉10秒以後，(因為10秒是我們睡掉的XD)
耗時其實差距蠻大的。
要取得一個比較良好的數據，
就可能要用迴圏來多測幾次，再取平均值。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


import os, time
start = time.time()
for path, dirs, files in os.walk('.'):
 print(path)
 for f in files:
 print(os.path.join(path, f))

 for d in dirs:
 print(os.path.join(path, d))
time.sleep(10) # 睡10秒鐘(可以給小數)
end = time.time()

1

print("總耗時：%f" % (end - start))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


C:\Users\Desolve\utils>python fromzero.py
.
.\bookstore.json
.\check.py
.\fromzero.py
.\poem.txt
.\schedule.py
.\__init__.py
.\csv
.\json
.\__pycache__
.\csv
.\csv\student.csv
.\csv\student_dic.csv
.\json
.\json\classA.json
.\__pycache__
.\__pycache__\check.cpython-38.pyc
.\__pycache__\schedule.cpython-38.pyc
.\__pycache__\__init__.cpython-38.pyc
總耗時：10.003572

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


C:\Users\Desolve\utils>python fromzero.py
.
.\bookstore.json
.\check.py
.\fromzero.py
.\poem.txt
.\schedule.py
.\__init__.py
.\csv
.\json
.\__pycache__
.\csv
.\csv\student.csv
.\csv\student_dic.csv
.\json
.\json\classA.json
.\__pycache__
.\__pycache__\check.cpython-38.pyc
.\__pycache__\schedule.cpython-38.pyc
.\__pycache__\__init__.cpython-38.pyc
總耗時：10.002572

最後我們來做個練習吧！

承前面小亦和阿啾的狀況需要補救，
請幫其重新列出接下來到明年(2021)幾個重要的節日的時間，
計算距離2020–10–01的天數，並排序將其從近排到遠 ，
這樣小亦才不會漏掉。(1000天或2000天什麼的先不用算)
[七夕(2021–08–14)、情人節(2021–02–14)、白色情人節(2021–03–14)、阿啾生日(2020–10–03)、阿啾生日(2021–10–03)]
(什麼？你說為什麼有兩個生日？生日當然要每個生日都要過阿，
會問這個問題的讀者請檢討一下自己是不是憑實力單身阿XD?)

那麼，我們就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (18) — 系統模組：走路的不是強尼，是你心中的OS

Sat, 03 Oct 2020 00:00:00 +0800

Day 18 系統模組：走路的不是強尼，是你心中的OS

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。https://ithelp.ithome.com.tw/articles/10246454

我們先來看看昨天的練習吧！

一般來說，我們可以先打開來觀察，
將其複製到JSON Online Editor上看看右邊的tree長什麼樣子，
這樣會有助於後面思考操作方式。

請下載下來並放到你自己執行的目錄(筆者命名為bookstore.json)
用以下的讀取方式，將json檔載入到bs裡：

1
2
3


import json
with open('bookstore.json', 'r', encoding="utf-8") as f:
 bs = json.load(f)

bs是一個串列(因為在這個json裡面是以array的型式儲存的)
我們可以用以下的方式(或者你要去用地址找也可以)

1
2


# 記得list comprehension嗎?
taipei = [i for i in bs if '臺北市' in i['cityName']]

taipei中特色書店點閱數超過2000的店家是哪幾家呢？請列出其名字。

1
2
3


# 我們要的是名字，所以要取'name'，判斷標準則是用hitRate。
>>> [i['name'] for i in taipei if i['hitRate'] > 2000]
['茉莉二手書店(臺大店)', '信誼小太陽親子書房(臺北重慶店)', '田園城市生活風格書店', '亞典藝術書店', '古原軒書店']

請留意到，這個練習是相對比較輕鬆的，
因為當中所用到的元素都沒有缺漏的部分，
所以不會產生任何錯誤；
但實務狀況上，常常會有一些資料是短少的，
這時候就要先做過資料的前處理(preprocessing)以後，
將缺漏的部分去除，或者補上適當的值，才能讓資料得以正常使用。
在資料清理(data cleaning)這部分，Python常用的有pandas跟numpy，
以後我們有機會再來介紹。

我們今天要來講的是系統模組(os)。
OS是Operating System(作業系統)的縮寫，
主要作用是提供你所使用的作業系統的一些功能，
例如檔案的路徑檢查、列出檔案列表、
檔案複製/移動/改名/刪除等。
下面的示範，我們是基於使用者在以下的資料夾環境操作的：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


C:\Users\Desolve\utils>tree /f
列出資料夾 PATH
磁碟區序號為 D6BD-47D7
C:.
│ bookstore.json
│ check.py
│ fromzero.py
│ poem.txt
│ schedule.py
│ __init__.py
│
├─csv
│ student.csv
│ student_dic.csv
│
├─json
│ classA.json
│
└─__pycache__
 check.cpython-38.pyc
 schedule.cpython-38.pyc
 __init__.cpython-38.pyc

要使用os，最重要的就是先import啦!
請留意一件事情，
在Unix系列的系統裡面，路徑分隔資料夾或檔案是使用”/”來處理的 ，
Windows系列的系統中，則是使用”\”，兩者剛好相反 。
如果我們想看某個檔案或目錄是否存在於特定位置 ，
我們可以使用os.path.exists() ，可以是相對路徑或絕對路徑 。
相對路徑是從現在的資料夾為基準出發，來看到到目標位置要怎麼移動；
絕對路徑則是從Unix的根目錄或Windows的C槽D槽之類的起始點出發；
所以以相對路徑來起頭的，前面會有一個”./”或”.”開頭 ，
用來表示從現在所在位置起算(一個點代表現在所在位置，兩個點代表上一層)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


>>> import os
>>> os.path.exists('check.py')
True
>>> os.path.exists('poem.txt')
True
>>> os.path.exists('.\json\classA.json')
True
>>> os.path.exists('./json/classA.json') # 實際上用linux的寫法給Python去認也行得通，Python會明白含義
True
>>> os.path.exists('./json/classB.json') # 不存在就回傳False
False
>>> os.path.exists('C:\Users\Desolve\utils\json\classA.json') # 用絕對路徑時避免不必要的麻煩，請多加一個"\"將可能造成的轉義去除
 File "<stdin>", line 1
SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in position 2-3: truncated \UXXXXXXXX escape
>>> os.path.exists('C:\\Users\\Desolve\\utils\\json\\classA.json')
True

再來是分開來的檢查這個路徑是否是檔案/資料夾的方法：
os.path.isfile()及os.path.isdir() 。

1
2
3
4
5
6
7
8


>>> os.path.isfile('./json/classA.json') # 存在，且是檔案
True
>>> os.path.isfile('./json/classB.json') # 不存在則回傳False
False
>>> os.path.isdir('./json/classA.json') # 是檔案，不是資料夾
False
>>> os.path.isdir('./json') # 是資料夾
True

那麼如果想要複製或移動檔案呢？這就要用到另一個模組shutil 了：

1
2
3
4
5


>>> import shutil
>>> shutil.copy('poem.txt', 'poem2.txt') # 前面是來源，後面是目的地
'poem2.txt'
>>> shutil.move('poem2.txt', 'poem3.txt') # 移動檔案並更名
'poem3.txt'

要修改名字的話，則可以使用os.rename() ：

1

>>> os.rename('./json/poem3.txt', 'poem3.txt') # 也可以做為移動檔案用

要新增/刪除資料夾的話，可以使用os.mkdir()/os.rmdir() ，
刪除檔案則使用os.remove() ：
(有沒有覺得跟Unix系統的shell script很像呢XD?)

1
2
3
4
5
6
7
8


>>> os.mkdir('poems') # 開一個新的資料夾
>>> os.rename('poem3.txt', './poems/poem3.txt') # 將poem3.txt移入
>>> os.rmdir('poems') # 將poems資料夾刪除...咦?
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
OSError: [WinError 145] 目錄不是空的。: 'poems'
>>> os.remove('poems/poem3.txt')　# 只能先將檔案移除
>>> os.rmdir('poems') # 再移除資料夾

讀者可能會問：
「我怎麼會知道要先刪除哪些檔案？」
問的好！我們可以使用os.listdir()先列出資料夾的所有檔案及資料夾 ：
(注意，只會列出第一層的，再往下的子資料夾就不會展開囉！)

1
2
3
4


>>> os.listdir()
['bookstore.json', 'check.py', 'csv', 'fromzero.py', 'json', 'poem.txt', 'schedule.py', '__init__.py', '__pycache__']
>>> os.listdir('csv')
['student.csv', 'student_dic.csv']

最後，是我們的終極必殺武器：os.walk() 。
os.walk()就像一個偏執的用路人一樣，
它就是要將整個資料夾，連同子資料夾都走過一遍才會罷休。
走完之後，所有的內容會以(dirpath, dirnames, filenames)的形式回傳，
我們可以使用for … in …的方式取得，
請看範例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


for root, dirs, files in os.walk('.'):　# os.walk必須要給一個起始點
 print(root)
 for f in files:
 print(os.path.join(root, f)) # os.path.join()可用來處理路徑和檔案的結合
# 結果如下
.
.\bookstore.json
.\check.py
.\fromzero.py
.\poem.txt
.\schedule.py
.\__init__.py
.\csv
.\csv\student.csv
.\csv\student_dic.csv
.\json
.\json\classA.json
.\__pycache__
.\__pycache__\check.cpython-38.pyc
.\__pycache__\schedule.cpython-38.pyc
.\__pycache__\__init__.cpython-38.pyc

如果想要刪除掉某個目錄以下的所有檔案及資料夾，
可以參考Python的Document提供的範例：
請特別留意慎用以下操作，
底下的動作可是真的會將目標資料夾全刪光的！！！
尤其是Unix系列的系統，
如果給的top起始點是”/”(根目錄)而非”./”(當前目錄)，
則會將整個檔案系統都砍光光呦！！！

1
2
3
4
5


for root, dirs, files in os.walk(top, topdown=False):
 for name in files:
 os.remove(os.path.join(root, name))
 for name in dirs:
 os.rmdir(os.path.join(root, name))

今天我們介紹了os中跟檔案系統相關操作有關的方法，
其他當然也有很多不錯的相關模組，
例如剛剛有提到的shutil ，或是pathlib ，
有興趣的讀者可再行挖掘。

那麼，我們就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/leetcodeall

從零開始學Python (17) — 檔案讀寫：妳出現在我詩的每一頁(下)

Fri, 02 Oct 2020 00:00:00 +0800

Day 17 檔案讀寫：妳出現在我詩的每一頁(下)

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10246077

上一回我們介紹了CSV的格式以及使用方法，
事實上很多檔案如果是以Excel能表達的狀態下，
CSV應該可以應付絕大多數的需求了！
但對於許多程式開發，或較為複雜的資料，
使用CSV就會稍嫌力有未逮，
因為CSV並不能夠簡單分出比較大量的層級。

舉例來說，如果我們現在有一組資料，
內含了一個學校的兩個班級，
那可能會長這樣：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


how_school = {
 "校長": "How哥",
 "工友": "林阿嘉",
 "class": {
 "A": {
 "teacher": "蔡阿嘎",
 "students": {
 "阿明": {"數學":55, "英文":70, "物理":55},
 "HowHow": {"數學":80, "英文":60, "物理":40}
 }
 },
 "B": {
 "teacher": "二伯",
 "students": {
 "小美": {"數學":90, "英文":88, "物理":100},
 "蔡哥": {"數學":50, "英文":50, "物理":40}
 }
 }
 }
}

像這樣子的東西，就很難使用csv簡單表現出來了！
所以我們一般會使用JSON來處理這樣子的結構。
JSON是JavaScript Object Notation的縮寫，
顧名思義，本來是用在JavaScript的格式。

後來大家發現實在是很好用，
所以也被拿來在很多地方做為資料交換用的格式。
當然，如果要人從頭刻出來，可能中間會有一些沒寫好的地方容易出錯，
這時候我們需要一個用來檢查格式的工具，
讀者可以搜尋 ’JSON online editor’ ，選擇自己用得順手的來嘗試編寫，
以下我們就拿在 https://jsoneditoronline.org/ 上操作做為範例：
進入時，幾個簡單的操作就看中間的部分：

左邊預設是code(原始的json碼)，右邊預設是tree(JSON Object長的樣子)；
我們可以寫好左邊以後，按一下**”Copy>”** 將其複製到右邊產生tree，
如果失敗的話，這個編輯器就會給你有關哪一行出錯的提示。
(反過來先產生tree再讓它翻成code也可以呦！)

預設裡應該會給出一段json碼如下，這是用來提示基本關於JSON的用法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


"array": [
 1,
 2,
 3
 ],
 "boolean": true,
 "color": "gold",
 "null": null,
 "number": 123,
 "object": {
 "a": "b",
 "c": "d"
 },

首先留意到，每個單位一般都會以一個字串做為它的名字，
和Python不同，字串請全數用**雙引號(“”)**來括住，單引號在這裡是行不通的！
JSON常用的格式有以下幾個：
array(陣列) ：跟Python的串列基本相似，
除了前面有一個它的名字(可自行命名)，
後面使用中括號框住，以**”,”** 逗號分隔。
boolean(布林值) ：可以放在值的地方，使用true/false (注意是全小寫!)。
color(色彩) ：用文字來表示色彩的話，有些編輯器 可以幫你解讀出來XD。
null(空) ：相當於Python的None，表示沒有東西存在。
number(數字) ：在JSON中數字可以是整數或小數。
object(物件) ：使用大括號框起，裡面的每一段跟字典相似，
使用key:value 的型態放入，
可以多層(但是key必須要是字串 )。

那麼，一段Python中的資料結構，要怎麼轉換成JSON呢？
我們可以import json，並使用dumps() 方法來處理：
(如果是從檔案的話要用dump()方法)

1
2
3


import json
how_json = json.dumps(how_school)
print(how_json)

結果如下……咦？這什麼鬼東西？！

1
2
3
4


C:\Users\Desolve>python fromzero.py
{"\u6821\u9577": "How\u54e5", "\u5de5\u53cb": "\u6797\u963f\u5609", "class": {"A": {"teacher": "\u8521\u963f\u560e", "students": {"\u963f\u660e": {"\u6578\u5b78": 55, "\u82f1\u6587": 70, "\u7269\u7406
": 55}, "HowHow": {"\u6578\u5b78": 80, "\u82f1\u6587": 60, "\u7269\u7406": 40}}}, "B": {"teacher": "\u4e8c\u4f2f", "students": {"\u5c0f\u7f8e": {"\u6578\u5b78": 90, "\u82f1\u6587": 88, "\u7269\u7406":
 100}, "\u8521\u54e5": {"\u6578\u5b78": 50, "\u82f1\u6587": 50, "\u7269\u7406": 40}}}}}

Python提供的json模組在進行dump/dumps方法時，
預設所有輸進來的內容全都是ASCII Code，
所以當超出這個範圍，例如我們輸入的中文，
實質上應該要用UTF-8來表達才對。
所以我們改一下它的參數即可：

1
2
3


import json
how_json = json.dumps(how_school, ensure_ascii=False) # 我沒有要全ASCII，給我改回來XD
print(how_json)

執行結果如下：

1
2
3


C:\Users\Desolve>python fromzero.py
{"校長": "How哥", "工友": "林阿嘉", "class": {"A": {"teacher": "蔡阿嘎", "students": {"阿明": {"數學": 55, "英文": 70, "物理": 55}, "HowHow": {"數學": 80, "英文": 60, "物理": 40}}}, "B": {"teacher": "
二伯", "students": {"小美": {"數學": 90, "英文": 88, "物理": 100}, "蔡哥": {"數學": 50, "英文": 50, "物理": 40}}}}}

剛剛是將一個Python的資料結構轉成JSON字串，
那我們想要從JSON字串轉回Python的結構的話，
可以使用loads方法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


>>> how2 = json.loads(how_json) # 接續前面的how_json
>>> how2
{'校長': 'How哥', '工友': '林阿嘉', 'class': {'A': {'teacher': '蔡阿嘎', 'students': {'阿明': {'數學': 55, '英文': 70, '物理': 55}, 'HowHow': {'數學': 80, '英文': 60, '物理': 40}}}, 'B': {'teacher': '
二伯', 'students': {'小美': {'數學': 90, '英文': 88, '物理': 100}, '蔡哥': {'數學': 50, '英文': 50, '物理': 40}}}}}
>>> how2['校長']
'How哥'
>>> how2['工友']
'林阿嘉'
>>> how2['class']['A']
{'teacher': '蔡阿嘎', 'students': {'阿明': {'數學': 55, '英文': 70, '物理': 55}, 'HowHow': {'數學': 80, '英文': 60, '物理': 40}}}
>>>

我們可以從上面的範例看到，
在使用json時，轉換出來的Python結構，
基本上可以當成是字典，裡面有可能含有串列的部分，
操作起來不會有任何額外的問題，所以這點才對於Python相當重要，
因為直接讀進來一個檔案，就可以做為字典使用是非常方便的一件事情！

同樣我們再來嘗試一下寫到檔案和讀出來：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


# 寫入到json，使用json.dump()
>>> classA = how2['class']['A']
>>> with open('classA.json', 'w') as f:
... json.dump(classA, f)
...
>>> classA = how2['class']['A']
>>> with open('classA.json', 'w') as f:
... json.dump(classA, f, ensure_ascii=False)
...
# 從json讀出，使用json.load()
>>> with open('classA.json', 'r') as f:
... reclassA = json.load(f)
...
>>> reclassA
{'teacher': '蔡阿嘎', 'students': {'阿明': {'數學': 55, '英文': 70, '物理': 55}, 'HowHow': {'數學': 80, '英文': 60, '物理': 40}}}

最後，提醒讀者留意一件事情：
json當中的每個object必須要是獨一無二的，也就是不可以重名！
其實這點對照一下Python的字典應該就清楚了，
因為Python的字典的key也必須要是獨特的。
那，如果重名會怎樣呢？
一般狀況下，最後面出現的會蓋掉前面的：

1
2
3


>>> repeated_json = '{"數學": 80, "數學": 50, "數學": 30}'
>>> json.loads(repeated_json) # 越考越爛阿QQ
{'數學': 30}

當然，json還有不少其他的應用，
有興趣的讀者可以再閱讀相關文件學習：
https://docs.python.org/3/library/json.html?highlight=json#command-line-options

那麼，我們來做個練習：

政府資料開放平臺上有提供不少的免費取用的資料，
請將 https://data.gov.tw/dataset/6224 的JSON格式檔案下載下來。
請用上面示範的方式將其打開並存成一個Python的資料結構，
命名為bs，這中間可能會遇到讀取的問題，
是JSON檔文字編碼的錯誤，
請在打開檔案時額外給入encoding=”utf-8" 的參數。
bs是一個什麼？(字串？串列？字典？)
請利用前面所學，將所有位在’臺北市’的書店資訊存成一個串列，
名為taipei。
taipei中特色書店點閱數超過2000的店家是哪幾家呢？請列出其名字。

那我們就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (16) — 檔案讀寫：妳出現在我詩的每一頁(中)

Thu, 01 Oct 2020 00:00:00 +0800

Day 16 檔案讀寫：妳出現在我詩的每一頁(中)

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10245278

上一回我們簡單介紹了如何讀一般的文字檔案，
那如果格式比較特別呢？
通常狀況下，會需要特別格式的原因，
是因為它代表了一段「資料」，
也就是說，讀取不同格式的檔案，
基本上就是在透過大家約定好的格式方法，
將資料從檔案中按規則讀出來。

以Python來說，最常見被拿來儲存的格式有CSV, XML, YAML, JSON等，
接下來的兩篇文章中，讓我們來分別介紹CSV和JSON吧！

CSV

CSV是相當淺顯易懂的格式，
如果讀者有在用Excel時，存檔時就會看到有CSV的選項。
一般而言，一個CSV檔案中，
每一個**row(列)的不同單位常以逗號分隔，
(也有用tab鍵的，相當於’\t’)
而column(行)**的計算則是以換行符號為準。
(Unix/Mac系統使用’\n’，Windows系統則用’\r\n’)
註：中國和台灣在指稱列跟行時是剛好相反的，容易搞混。
如果沒有特別需求的話，直接使用row/column來對應稱呼橫向/直向就好。

還記得我們之前的三個同學的成績嗎？

1
2
3


ming = Student('阿明', {'數學':55, '英文':70, '物理':55})
mei = Student('小美', {'數學':90, '英文':88, '物理':100})
howhow = Student('HowHow', {'數學':80, '英文':60, '物理':40})

如果今天我們要使用csv的方式將這個成績記錄起來，
我們可能會考慮寫成這樣：

1
2
3
4


姓名, 數學, 英文, 物理
阿明, 55, 70, 55
小美, 90, 88, 100
HowHow, 80, 60, 40

那麼，我們怎麼存放到csv中呢？
Python中有內建一個csv 的模組，
我們可以用其writer的writerow()或writerows()來處理：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


import csv
with open('student.csv', 'w', newline='') as f:
 csvw = csv.writer(f, delimiter=' ') # delimiter預設是','，可以自己更改
 csvw.writerow(['姓名', '數學', '英文', '物理']) # 一次寫一個row
 students = [
 ['阿明', 55, 70, 55],
 ['小美', 90, 88, 100],
 ['HowHow', 80, 60, 40]
 ]
 csvw.writerows(students) # 一次寫多個rows

(delimiter是指分隔符號)
特別留意，在使用csv來處理時，開啟檔案請務必設置參數, newline=’’，
以避免掉作業系統對於換行的處理不同的問題。
(全部交由csv writer來處理就好!)
其結果應該如下：

接著我們嘗試將其讀回來，
這時候就要改成用csv的reader，
reader的部分比較簡單，我們可以用for…in…的方式來按row取出：

1
2
3
4


import csv
with open('student.csv', 'r') as f:
 csvr = csv.reader(f, delimiter=' ') #
 student_from_file = [row for row in csvr]

1

print(student_from_file)

讀出來的結果如下。

1
2


C:\Users\Desolve>python fromzero.py
[['姓名', '數學', '英文', '物理'], ['阿明', '55', '70', '55'], ['小美', '90', '88', '100'], ['HowHow', '80', '60', '40']]

那麼，如果是要處理字典呢？
我們可以使用DictWriter/DictReader 。
假定我們已經有一段關於三名學生的字典：
{‘姓名’:’阿明’, ‘數學’:55, ‘英文’:70, ‘物理’:55}
{‘姓名’:’小美’, ‘數學’:90, ‘英文’:88, ‘物理’:100}
{‘姓名’:’HowHow’,’數學’:80, ‘英文’:60, ‘物理’:40}
我們可以用如下的方式來寫入：

1

import csv

1
2
3
4
5
6
7


with open('student_dic.csv', 'w', newline='') as f:
 field = ['姓名', '數學', '英文', '物理'] # 第一個row做為欄位名稱
 csvw = csv.DictWriter(f, delimiter=' ', fieldnames=field)
 csvw.writeheader()
 csvw.writerow({'姓名':'阿明', '數學':55, '英文':70, '物理':55})
 csvw.writerow({'姓名':'小美', '數學':90, '英文':88, '物理':100})
 csvw.writerow({'姓名':'HowHow','數學':80, '英文':60, '物理':40})

1
2
3
4
5


with open('student_dic.csv', 'r') as f:
 # DictReader將第一個row當做欄位名稱，所以就省略了
 csvr = csv.DictReader(f, delimiter=' ')
 student = [row for row in csvr]
 print(student)

讀出來應該如下：

1
2


C:\Users\Desolve>python fromzero.py
[{'姓名': '阿明', '數學': '55', '英文': '70', '物理': '55'}, {'姓名': '小美', '數學': '90', '英文': '88', '物理': '100'}, {'姓名': 'HowHow', '數學': '80', '英文': '60', '物理': '40'}]

上面敘述的所有範例，在讀寫未知的檔案時，
我們都無法保證是否csv能夠正常運作，
所以最好還是用一下try…except的方法，
對於csv模組傳出的錯誤，
可以使用try …**except csv.Error as e:**來接取。

還吃得消嗎？加油！
那我們下一篇再來談談JSON囉！
明天見～

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (15) — 檔案讀寫：妳出現在我詩的每一頁(上)

Wed, 30 Sep 2020 00:00:00 +0800

Day 15 檔案讀寫：妳出現在我詩的每一頁(上)

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10245133

先來解答昨天的問題吧！

按部就班仔細寫完應該就沒問題啦！
下面有省略掉前面的一部分東西，讀者也可以自行選擇保留。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


class Student():
 cp_cnt = 0 # 這個變數是屬於整個Student類別的
 def __init__(self, name, score):
 self.name = name
 self.score = score

 def __eq__(self, b):
 # 為了方便讀者檢查是否有問題
 print('self = %d, b = %d' % (self.score['數學'] * 2 + self.score['英文'] * 5, b.score['數學'] * 2 + b.score['英文'] * 5))
 return self.score['數學'] * 2 + self.score['英文'] * 5 == b.score['數學'] * 2 + b.score['英文'] * 5

 def __gt__(self, b):
 return self.score['數學'] * 2 + self.score['英文'] * 5 > b.score['數學'] * 2 + b.score['英文'] * 5

 def readMyName(self):
 print('聽清楚了，我的名字是' + self.name + '!!!')

 def compare(self, b):
 Student.cp_cnt += 1
 # 同樣，印出diff方便檢查正確性，讀者可自行註解掉。
 diff = sum(self.score.values()) - sum(b.score.values())
 print('diff = %d' % diff)
 # 有冒號的式子如果底下程式碼只有一行，也可以選擇直接和判斷式寫成同一行
 if diff > 0: print(self.name + '贏了！')
 elif diff == 0: print('什麼？竟然平手？！')
 else: print('可...可惡，難道，這就是' + b.name + '真正的實力嗎？')
 print('已比較 %d 次!\n' % Student.cp_cnt)

 def compareE(self, b):
 Student.cp_cnt += 1
 if self > b: print(self.name + ' > ' + b.name)
 elif self == b: print(self.name + ' == ' + b.name)
 else: print(self.name + ' < ' + b.name)
 print('已比較 %d 次!\n' % Student.cp_cnt)

 @classmethod
 def getCpCount(cls):
 print('目前的比較次數：%d' % cls.cp_cnt) # 別忘了print也可以用format類型的形式

1
2


print('開始之前')
Student.getCpCount() # 開始前先看看是不是0

1
2
3
4
5
6


ming = Student('阿明', {'數學':55, '英文':70, '物理':55})
ming.readMyName()
mei = Student('小美', {'數學':90, '英文':88, '物理':100})
mei.readMyName()
howhow = Student('HowHow', {'數學':80, '英文':60, '物理':40})
howhow.readMyName()

1
2
3
4
5
6
7


print('\n來PK吧! 先比總分，再比加權分!\n')
ming.compare(howhow)
ming.compareE(howhow)
ming.compare(mei)
ming.compareE(mei)
mei.compare(howhow)
mei.compareE(howhow)

結果應該如下：

1
2
3
4
5
6


C:\Users\Desolve>python fromzero.py
開始之前
目前的比較次數：0
聽清楚了，我的名字是阿明!!!
聽清楚了，我的名字是小美!!!
聽清楚了，我的名字是HowHow!!!

1

來PK吧! 先比總分，再比加權分!

1
2
3


diff = 0
什麼？竟然平手？！
已比較 1 次!

1
2
3


self = 460, b = 460
阿明 == HowHow
已比較 2 次!

1
2
3


diff = -98
可...可惡，難道，這就是小美真正的實力嗎？
已比較 3 次!

1
2
3


self = 460, b = 620
阿明 < 小美
已比較 4 次!

1
2
3


diff = 98
小美贏了！
已比較 5 次!

1
2


小美 > HowHow
已比較 6 次!

今天我們來談談資料的讀寫。
對Python來說，一旦程式結束，
或退出Python直譯器，前面做過的事情，
產生的變數等都會被清理一空，消失不見。
為什麼呢？程式執行途中，所有的變數等東西要存放在記憶體中，
在離開時，空間自然要還回去才不會浪費嘛！

那麼，如果我們想保留中途取得的結果該怎麼辦呢？
可以選擇存放到檔案中，或者是資料庫裡，
我們先簡單介紹一些檔案存取的方法。

對Python來說，要讀寫一個檔案前，
要先打開它(開啟舊檔嘛XD！)。

1
2
3
4


# 方法一
file = open(name, mode)
... (使用file來處理檔案)
file.close() # 用完要關閉檔案

1
2
3
4


# 方法二
with open(name, mode) as file:
 ...(使用file來處理檔案)
# 離開這個with的區塊以後，file自動關閉。

open會找尋name的檔案，並以mode的模式開啟，
開啟成功的話，會回傳一個檔案物件，我們用file的名字來接取它。
mode模式是一個字串，通常狀況下會有1~2個字母，其代表涵義如下：
第一個字母：
‘r’ -> 讀取(read)
‘w’ -> 寫入(write)(但不給r預設還是會可讀)
‘x’ -> 新增檔案(exclusive creation)，如果檔案已存在則回傳錯誤
‘a’ -> 在結尾處寫入(append)
第二個字母：
‘b’ -> 用二進位的方式來處理
(預設則是當成文字來處理)
‘+’號： -> 更新(updating) (可讀可寫)
通常會用’r+’，代表可讀可寫。

我們先來看看怎麼樣將七里香的片段寫進詩裡：

1
2
3
4


>>> f = open('poem.txt', 'w')
>>> f.write('院子落葉\n跟我的思念厚厚一疊') # write結束時會回傳寫入的字數(byte數)
14
>>> f.close() # 要先close()以後，才會真的寫入完畢！

讀者可以在python執行的位置或者執行.py檔的位置，
找到一個poem.txt，其內容如下：

讀者如果多加嘗試的話，可以發現如果再次讀檔寫檔，
前面的內容會被全數覆蓋 ！
除了用了write()以外，print()也可以拿來輸出到檔案，
其方法如下：

1
2
3


>>> f = open('poem.txt', 'w')
>>> print('院子落葉\n跟我的思念厚厚一疊', file=f, sep='', end='')
>>> f.close() # 要先close()以後，才會真的寫入完畢！

我們將print()的目標指向到檔案去，
所以它就不會把字串印在命令列；
同時，由於print()預設會有sep(分隔符號)和end(結束符號) ，
sep預設會是一個空格，end預設會是換行 ，
所以我們要自行將其設定為空字串，避免寫進去的東西不如預期。

另一方面，如果字串很大，不適合直接一口氣處理完，
也可以考慮使用slice的方法分段處理。
(自己決定每段要寫入多少字元，搭配迴圏操作)

由於檔案讀取使用**’x’**的話會有機會產生錯誤，
在其他很多狀況下也有產生錯誤的可能，
一般我們在使用檔案處理的相關函式時，
會用try…except…來將其包含進來。

1
2
3
4
5
6
7


>>> try:
... f = open('poem.txt', 'x')
... f.write('窗外的麻雀')
... except FileExistsError: # 想直接全包也行啦XD!
... print('檔案已存在!')
...
檔案已存在!

接下來是讀取檔案的部分：
讀檔就比寫入還要更在意一次讀的內容了，
Python提供了三個用來讀取的函式：
read(), readline(), readlines() 。
read()的本質和write()接近，就是有什麼讀什麼，
就算今天是全本小說也照讀不誤，所以特別要留意這點！
當不確定自己要讀的檔案大小時，千萬不要直接一口氣讀全部啊！

1
2
3
4
5
6


>>> f = open('poem.txt', 'r')
>>> poem = f.read()
>>> print(poem)
院子落葉
跟我的思念厚厚一疊
>>> f.close()

read()也可以傳入字數來限制每次要讀幾個字元：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


>>> f = open('poem.txt', 'r')
>>> poem = ''
>>> while True:
... next = f.read(3) # 每次只讀3個字
... if not next: # 讀到結尾時，會產生空字串給next
... break
... poem += next
...
>>> print(poem)
院子落葉
跟我的思念厚厚一疊
>>> f.close()

讀者也可以自行嘗試在迴圈中印看看next。

接下來是readline()，
readline()每次會以行為單位將檔案讀出來：
為了更明確表現整個狀況，我們先將poem.txt更改如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


>>> f.close()
>>> f = open('poem.txt', 'r')
>>> cnt = 0
>>> poem = ''
>>> while True:
... cnt += 1
... line = f.readline()
... if not line: break
... print('Line %d: %s' % (cnt, line), end='')
... poem += line
...
Line 1: 院子落葉
Line 2: 跟我的思念厚厚一疊
Line 3:
Line 4: 幾句誓言
Line 5: 也無法將我的熱情冷卻
Line 6: >>> f.close()
>>>

我們可以看到在readline()時，換行的符號是被算進去的，
就算尾端只有幾個空白字元 ，照樣也會被算做一行。

readlines()則又再友善一點，
會按行將讀出來的每一行為單位組成list。

1
2
3
4


>>> f = open('poem.txt', 'r')
>>> lines = f.readlines()
>>> lines
['院子落葉\n', '跟我的思念厚厚一疊\n', '\n', '幾句誓言\n', '也無法將我的熱情冷卻\n', ' ']

今天我們已經介紹了基礎的讀寫檔案，
下一篇我們再來介紹比較進一步地使用模組來讀一些常見的檔案格式。

那我們就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (14) — 物件與類別：我們不一樣，每個人都有不同的際遇(下)

Tue, 29 Sep 2020 00:00:00 +0800

Day 14 物件與類別：我們不一樣，每個人都有不同的際遇(下)

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10244886/

前面兩篇我們從什麼是類別和物件的基本介紹起，
講到如何初始化及設定屬性、方法，以及如何運用繼承。

這篇我們首先要談的是，
什麼時候該用類別/物件，什麼時候又該用模組呢？

其實答案很簡單：
看怎麼用比較方便，就怎麼用XD！

讀者可能會覺得這是廢話，先別著急，讓筆者解釋一下。
在程式的世界裡，當我們遇上問題時，
大部分的狀況下都不會只有一種解法 。
不同的解法，會有不同的優劣性，
扣除掉一些根本效率的不同，剩下的就只是取捨問題。
所以當碰到多個可行的選項，在考慮用哪一個方法時，
請先問問自己以下的問題：

題目(或現實的目標)是否有限制，導致某些方法其實不能用？
這當中，哪些是前面寫起來比較簡單，後面維護(或擴充)比較麻煩的？
哪些是前面寫起來比較複雜，後面卻可以節省力氣的？
承2，在大前提的目標下，這個架構有需要考慮到後面的問題嗎？

以上三個問題會影響實務上的選擇，
所以你可以基於節省空間考量而選方法A，
或基於節省時間而選方法B，亦或是為了架構比較好選方法C，
不會有絕對的對錯，只是看考量而已。

扯遠了，回過頭來看物件/類別及模組的抉擇。
通常模組會比物件/類別還要精簡，因為不會牽扯到太多額外的東西；
但模組在一個程式中import時，只會產生同一個東西，而類別可以產生多個不同的物件。
當你的程式都是一些工具型函式，屬於那種呼叫完就會經過一番處理再輸出，
但不會需要產生多個不同的物件來處理事情的話，
以模組的型式處理會相當簡單。

舉例來說，一個學校只會有一個校長，校長可能有一些事情是他的權責範圍，
假設我們只鎖定一間學校，那校長能做的事情應該就可以直接以一個模組來囊括，
因為同一間學校總不會出現第二位校長嘛！所以我們可以用模組來定義所有校長的業務。
但學生就不行了，我們會有阿明，小美，HowHow跟其他路人甲乙丙丁，
所以學生就適合建立一個Student的類別來生成多個物件。
另一點是阿明和小美雖然都是學生，但它們會有屬性的差異，
這種有相同性質但屬性質不同的，最適合使用類別與物件來處理了！

另一方面，模組是不行繼承的 ，如果你有繼承的需求的話，
類別與物件就是唯一的選擇。

最後一點，如果可以用簡單的方式如字典、串列甚至一般函式來處理的話，
不一定非得要模組或類別/物件不可 。

接著我們來談談類別方法 及類別屬性 。
類別方法是指會影響整個類別的方法，類別屬性則是指整個類別所共有的屬性。
舉例來說，如果我們想要知道今天我們總共加入了幾個Student類別的物件，
我們可以這麼寫：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


class Student():
 cnt = 0 # 這個變數是屬於整個Student類別的
 def __init__(self, name, score):
 Student.cnt += 1 # 每次新開一個Student的物件，計數器就會+1
 self.name = name
 self.score = score

 def readMyName(self):
 print('聽清楚了，我的名字是' + self.name + '!!!')

 def compare(self, b):
 diff = sum(self.score.values()) - sum(b.score.values())
 # 有冒號的式子如果底下程式碼只有一行，也可以選擇直接和判斷式寫成同一行
 if diff > 0: print(self.name + '贏了！')
 elif diff == 0: print('什麼？竟然平手？！')
 else: print('可...可惡，難道，這就是' + b.name + '真正的實力嗎？')

 @classmethod
 def getCount(cls):
 print('目前的學生總數：%d' % cls.cnt) # 別忘了print也可以用format類型的形式

1
2


print('開始之前')
Student.getCount()

1
2
3


ming = Student('阿明', {'數學':55, '英文':70, '物理':55})
ming.readMyName()
Student.getCount()

1
2
3


mei = Student('小美', {'數學':90, '英文':88, '物理':100})
mei.readMyName()
Student.getCount()

1
2
3


howhow = Student('HowHow', {'數學':80, '英文':60, '物理':40})
howhow.readMyName()
Student.getCount()

結果應該像這樣：

1
2
3
4
5
6
7
8
9


C:\Users\Desolve>python fromzero.py
開始之前
目前的學生總數：0
聽清楚了，我的名字是阿明!!!
目前的學生總數：1
聽清楚了，我的名字是小美!!!
目前的學生總數：2
聽清楚了，我的名字是HowHow!!!
目前的學生總數：3

對於類別方法，我們會在前面加上**”@classmethod”，
同時由於”class”** 已經是Python的保留字(用來定義類別)，
所以在使用時Python是給定**”cls”** ，用來指稱這個類別。
不過直接使用**Student.cnt**也可以，意思是一樣的。
所以請留意類別方法/屬性和物件方法/屬性的差異，
前者是屬於整個類別，後者是會依照產生的物件來操作。
可以看到即便在開始之前，
我們還沒加入任何Student，類別屬性就已經存在了。

還有一種比較特別的方法叫靜態方法 。
使用”@staticmethod”來開頭，不需要self或cls參數，
通常用以處理可以固定不變，不受其他屬性影響的東西。
例如：

1
2
3
4
5
6


class Desolve():
 @staticmethod
 def ads():
 print('無情工商時間!')
 print('從LeetCode學演算法是一系列非常好的課程!')
 print('https://bit.ly/leetcodeall')

1

Desolve.ads()

同樣，無須Desolve類別產生物件，這個方法就能被使用(甚至也沒有用到其他屬性)。

一個類別也可以繼承不只一個類別，例如假設我們有A, B兩個類別，
想用一個C類別同時繼承它們：

1
2


class C(A, B):
 ...

這麼一來，C就會同時擁有A跟B的屬性和方法。
那麼，如果相衝突(比方說重名)怎麼辦？

1
2
3
4
5


class A():
 def __init__(self):
 self.name = 'A'
 print('A')
 print('Name = ' + self.name)

1
2
3
4
5


class B():
 def __init__(self):
 self.name = 'B'
 print('B')
 print('Name = ' + self.name)

1
2
3
4


class C(A, B):
 pass

test = C()

輸出應該會如下：

1
2
3


C:\Users\Desolve>python fromzero.py
A
Name = A

簡單來說，當A跟B有相同的方法時，
呼叫方法會呼叫哪一個，端看你把誰寫前面，寫越前面的優先程度越大 。
(讀者可以自行將C(A, B)改成C(B, A)看看結果)
其他還有一些更深入的變化，我們就不在這個系列討論了，
有興趣的讀者可以再深入研究繼承多個類別的變化。

最後，我們來談談特殊的方法：
當我們在Python內使用那些 ==, !=, >=, <=, >, <……等比較運算子時，
其實是依靠Python有對這些東西做定義，才知道如何去做比較；
但是對於我們自己生成的類別來說，想要比較兩個相同類別的物件，
可能就需要我們自己定義了。
例如說假設有一個類別叫nmod3()，會紀錄數字並判斷餘數是否相等：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


class nmod3():
 def __init__(self, num):
 self.num = num

 def __eq__(self, n2): # 定義 "=="這個運算子為是否除以3的餘數相同
 return self.num % 3 == n2.num % 3

a = nmod3(11) # 除以3餘2
b = nmod3(18) # 除以3餘0
c = nmod3(17) # 除以3餘2

1
2
3


print(a == b)
print(a == c)
print(b == c)

可以被特別定義的除了比較運算子以外，還有之前我們提到過的算術運算子等。
這裡稍微列出一些提供參考：

1
2
3
4
5
6
7
8
9


# 這些都是兩個物件相比，我們假定後面的物件叫b。
__eq__ => self == b
__ne__ => self != b
__lt__ => self < b
__gt__ => self > b
__add__ => self + b
__mul__ => self * b # 原來字串的乘法是這麼弄出來的XD
__len__ => len(self) # 可以定義什麼是你的物件的"長度"
...(其他有需要再Google即可XD)

那我們一樣來練習一下題目吧！

請參照之前的Student類別，
假設今天有一個科系要求是(數學 * 2 + 英文 * 5)的加權分數採計，
定義__gt__(也就是>), __eq__(也就是==)，
用上面的採計方式及重新定義的比較運算子來寫成新的A.compareE(B)函式，
假設：
A的加權分高於B -> A的名字 + ‘ > ‘ + B的名字
A的加權分等於B -> A的名字 + ‘ == ‘ + B的名字
A的加權分小於B -> A的名字 + ‘ < ‘ + B的名字
並分別讓阿明和HowHow比較、
阿明和小美比較、小美和HowHow比較，輸出結果。
(請保留之前compare的函式及呼叫的比較，我們兩種都要比呦!)
承上，請使用類別方法和屬性，在每次進行比較時就將總比較次數+1，
並print出來，這邊的「比較」是指compare()及compareE()都算。

辛苦啦！那我們就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (13) — 物件與類別：我們不一樣，每個人都有不同的際遇(中)

Mon, 28 Sep 2020 00:00:00 +0800

Day 13 物件與類別：我們不一樣，每個人都有不同的際遇(中)

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。https://ithelp.ithome.com.tw/articles/10244495

先來解答昨天的問題吧！

我們可以修改上一篇的範例，並且新增一個compare方法，
由於比較的時候，我們利用self就可以取得現在的物件，
那麼從外面傳入的，我們直接將其稱為b，
要比較的就會是self.score的分數總和，和b.score的分數總和的關係。
這邊繼續介紹好用的小函式：
由於前面我們講過字典，要取所有的值的部分
(因為沒有加權嘛，就不用管科目了XD)，
是用.values()，那要加總在一起，
我們可以用for … in …的方式一個一個加起來，
或者，我們可以使用sum()函式，
它可以把一個可以算值的一組資料給加總起來。
於是一切就簡單啦！剩下的就是依照結果輸出。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


class Student():
 def __init__(self, name, score):
 self.name = name
 self.score = score

 def readMyName(self):
 print('聽清楚了，我的名字是' + self.name + '!!!')

 def compare(self, b):
 diff = sum(self.score.values()) - sum(b.score.values())
 # 有冒號的式子如果底下程式碼只有一行，也可以選擇直接和判斷式寫成同一行
 if diff > 0: print(self.name + '贏了！')
 elif diff == 0: print('什麼？竟然平手？！')
 else: print('可...可惡，難道，這就是' + b.name + '真正的實力嗎？')

ming = Student('阿明', {'數學':55, '英文':70, '物理':55})
mei = Student('小美', {'數學':90, '英文':88, '物理':100})
howhow = Student('HowHow', {'數學':80, '英文':60, '物理':40})
print(ming.name)
print(mei.name)
print(how.name)
print('\n阿明 vs HowHow')
ming.compare(how)
print('\n阿明 vs 小美')
ming.compare(mei)
print('\n小美 vs HowHow')
mei.compare(how)

我們今天繼續來講物件與類別。
上一篇我們介紹了一個基本的類別是怎麼被做出來的，
也提到了初始化的函式，設定它們的屬性等做法。
在實際運用上，我們會遇到一個問題：
今天遇到更細項的屬性時，我們是否要將其設定到現有的類別呢？
如果這麼做的話，有時候會導致通用性不夠的問題。

例如：
對於一輛車子來說，它是Tesla的話，有可能會有自動駕駛功能，
但如果它是一般的車子的話，自動駕駛顯然不是一個正常會有的功能。
所以當我們有一個名為Car的類別時，
我們想要定義一個Tesla的Car，應該為其增設一個Tesla的類別，
而非直接在Car新增自動駕駛的功能。

但Tesla應該還是擁有Car的基本特性，所以我們可以利用這點，
避免掉重新設定一個全新的類別。這就是我們要介紹的方法：繼承。
在繼承的概念裡，
原先Car的類別被稱為「父類別」、「超類別」或「基礎類別」，
(parent/super/base class)
而要做出來的Tesla被稱為「子類別」或「衍生類別」
(subclass/derived class)
定義子類別的話，只要在子類別的括號內加入父類別的名稱即可：

1
2
3


class Car():
 def whoami(self):
 print('I\'m a Car!')

1
2


class Tesla(Car):
 pass

1
2
3
4


car = Car()
tla = Tesla()
car.whoami()
tla.whoami()

讀者會發現，在Tesla中儘管尚未定義whoami()，
結果仍然會輸出，而輸出的結果其實是按照Car的whoami()來執行的：

1
2
3


C:\Users\Desolve>python fromzero.py
I'm a Car!
I'm a Car!

因為我們已經從Car這邊繼承過來了其屬性和方法，
所以Tesla也會有whoami的方法。
我們當然也可以把whoami做一下改變，並新增一些我們需要的東西：

1
2
3


class Car():
 def whoami(self):
 print('I\'m a Car!')

1
2
3
4
5
6
7
8
9


class Tesla(Car):
 def __init__(self):
 self.pilotmode = 1 # ON: 1, OFF: 0
 def whoami(self):
 print('I\'m a Tesla, not a trash car!')
 def autopilot_switch(self):
 self.pilotmode ^= 1 # ^是取XOR(互斥或)，所以會在0和1之間切換
 if self.pilotmode == 0: print('Auto-pilot mode switch off!')
 else: print('Auto-pilot mode switch on!')

1
2
3
4
5
6


car = Car()
tla = Tesla()
car.whoami()
tla.whoami()
tla.autopilot_switch()
tla.autopilot_switch()

上面的示範中，我們為Tesla新增一個屬性，
用來表示自動駕駛模式是否開啟，
並提供一個切換開關的方法。但這是Tesla的東西，
所以Car並不會有autopilot_switch()，
讀者可以嘗試使用car.autopilot_switch()看看，應該會出現錯誤。

同時留意我們也重寫了一次whoami，
這個將父類別有的函式，重新給予定義的做法，
稱為override(覆寫/覆載) 。
整個執行的結果會如下所示：

1
2
3
4
5


C:\Users\Desolve>python fromzero.py
I'm a Car!
I'm a Tesla, not a trash car!
Auto-pilot mode switch off!
Auto-pilot mode switch on!

讀者可能會問：
「那如果我們想要覆寫父類別的方法，
又想用到原先的內容，那該怎麼做呢？」
這時候，我們就需要使用super()來取得父類別的東西了！
舉例來說，假設我們對每一輛車都會給它自己一個名字，
在whoami時，會先喊出自己的名字，我們可以修改上面的內容變成這樣：

1
2
3
4
5
6


class Car():
 def __init__(self, name):
 self.name = name
 def whoami(self):
 print('My name is ' + self.name)
 print('I\'m a Car!')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class Tesla(Car):
 def __init__(self, name, mode):
 super().__init__(name) # 使用super來對name初始化，看起來稍微多此一舉，但可以保證對於name處理的一致性，之後如果要額外針對Car這個父類別修改時，就可以一起同時影響到Tesla這邊
 self.pilotmode = mode
 def whoami(self):
 super().whoami() # 先喊名字跟喊自己是輛車
 print('Also, I\'m a Tesla, not a trash car!') # 這兩行再做只有Tesla會做的事情
 print('Auto-pilot mode: ' + str(self.pilotmode))
 def autopilot_switch(self):
 self.pilotmode ^= 1
 if self.pilotmode == 0: print('Auto-pilot mode switch off!\n')
 else: print('Auto-pilot mode switch on!\n')

1
2
3
4
5
6
7
8


car = Car('CC')
tla = Tesla('TT', 0)
car.whoami()
print()
tla.whoami()
tla.autopilot_switch()
tla.whoami()
tla.autopilot_switch()

其執行結果應該像這樣：

1
2
3


C:\Users\Desolve>python fromzero.py
My name is CC
I'm a Car!

1
2
3
4
5


My name is TT
I'm a Car!
Also, I'm a Tesla, not a trash car!
Auto-pilot mode: 0
Auto-pilot mode switch on!

1
2
3
4
5


My name is TT
I'm a Car!
Also, I'm a Tesla, not a trash car!
Auto-pilot mode: 1
Auto-pilot mode switch off!

辛苦啦！在接下來的篇幅中，我們會再談談類別方法及靜態方法，
還有討論一下什麼時候該用類別/物件，什麼時候又該用模組的問題。

那我們就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (12) — 物件與類別：我們不一樣，每個人都有不同的際遇(上)

Sun, 27 Sep 2020 00:00:00 +0800

Day 12 物件與類別：我們不一樣，每個人都有不同的際遇(上)

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10244018

先來解答昨天的問題吧！

給定兩個字串s跟t，已經知道t的組成，
是將s的字母打亂以後進行重組，再隨機加上一個字母。
請用前面所學，找出被加上的那個字母。

以這題來說，我們可以採用內建的方式來處理，
或者使用上一篇提到的Counter()。
首先，讓我們再額外教一對有用的方法：ord()跟chr()。

一般狀況下，程式語言中有時候會提到char(字元)這個單位，
字元的單位就是單一一個英文字母或符號，
是用8個二進位來組成，有定義的有128個不同的字元。
這種字元的表達方是我們稱之為ASCII Code (阿斯奇扣德)。
更詳細的介紹可以看 https://zh.wikipedia.org/wiki/ASCII 。

我們只需要知道，ASCI Code上面65~~90是A~~Z，而97~~122是a~~z。
而要如何在數字和對應的字元做轉換呢？
在Python中會使用ord() ，也就是order，
將一個字元轉成對應的ASCII Code；
而使用chr() ，則可以將一個數字轉為對應的字元。

利用這點，我們可以取一個長度為26的list，
把a放到list的index 0，b放到list的index 1…，z放到list的index 25。
什麼？你不記得哪個數字對應的ASCII Code？
我們只需要拿ord(‘a’)為基準去相減就好囉！
因此，我們要做的事情就是將s的東西全部當做減1次，
t的東西全部當做加1次，最後因為t只比s多一個字元而已，
留下來計數是1的那個就會是答案囉！

如果先減後加的話，只要我們找到即將由0轉1的時候的那個字元，
就是我們要的答案囉！

1
2
3
4
5
6
7


# 變數後面加冒號，再加資料型態，可以提示輸入的資料型態。
# 但實質上Python並不會強制檢查是否正確。
# "->" 後面接的則是回傳的資料型態
def findTheDifference(s: str, t: str) -> str:
 cnt = [0] * 26
 for c in s:
 cnt[ord(c) - ord('a')] -= 1

1
2
3


 for c in t:
 if cnt[ord(c) - ord('a')] == 0: return c
 cnt[ord(c) - ord('a')] += 1

第二種方法，我們可以直接使用Counter()。

1
2
3
4
5
6


def findTheDifference(self, s: str, t: str) -> str:
 from collections import Counter
 cnt_s = Counter(s)
 cnt_t = Counter(t)
 # most_common(1)[0]取到了唯一的一組，再一個[0]取到key的部分
 return (cnt_t - cnt_s).most_common(1)[0][0]

接下來今天我們要講很多程式語言都有的重要的東西：物件。
我們先前講過函式，就是透過自己組合一些程式碼，
做成自己想要的一組功能。
事實上，以Python的角度來說，任何東西都是一種物件，
物件不只有自己的函式(方法) ，還有一些屬於它的變數(屬性) 。

舉例來說：
如果有一個人叫阿明，另一個人叫小美，
他們都是同一個高中同一班的學生，
所以要考試時，阿明要考數學跟英文，小美也要考數學跟英文。
如果我們要記錄阿明跟小美的成績的話，按照先前所學的，
讀者可能會做類似如下的變數設定：

1
2
3
4


ming_score_math = 55
ming_score_english = 70
mei_score_math = 90
mei_score_english = 88

這麼做有以下幾個缺點：

字很長XD
每個變數都要重新再命名一次，如果今天要40個同學都這樣的話，
寫變數命名就累死了！
所以為了加以簡化，我們可以用物件的概念來處理這個問題。
在創造一個物件(object)之前，我們要先定義類別(class) 。
什麼是類別呢？
我們要考慮處理的目標，其共通性是什麼？
比方說阿明是學生，小美也是學生，
阿明會有考試的成績，小美也是，同時，阿明和小美都會上課。
那麼我們就會可以定義一個類別稱為Student
(一般類別習慣會使用第一個字大寫)。

最基礎的類別定義如下：

1
2


class Student():
 pass # pass表示暫時不做任何事情，但將來必須要將其填補好。

如果要從一個定義產生物件，其用法如下：

1
2


ming = Student() # 阿明是個學生
mei = Student() # 小美是個學生，但和阿明不一樣

上面的ming和mei都是分別都是一個物件，其類別為Student。
以最初始的定義來說，它什麼事情都不會做，接下來我們來加入一些屬性：

1
2
3


class Student():
 def __init__(self, name):
 self.name = name

在一個物件被初始化的時候，最先會呼叫其中的__init__()函式。
它最前面必須要是self開頭，self的概念是指這個物件本體 ，
我們可以透過self.xxx 的方式來取得或修改物件的其他屬性或方法。
注意到除了self以外，我們還增加一個name，
代表當我們呼叫Student()時，其第一個位置傳入的將會是name。
而self.name = name 則代表我們要在開始時，
將從外面傳入進來的name的值，
存放進這個物件本體的name的值。

所以我們現在在來修改一下剛剛產生物件的方式：

1
2
3
4
5


ming = Student('阿明') # 阿明是個學生
mei = Student('小美') # 小美是個學生，但和阿明不一樣
# 要使用'.'來取得各自的名字
print(ming.name)
print(mei.name)

除了屬性以外，我們還可以為類別新增一些方法，
其方式基本和前面函式定義的方法一致，只是要加上self。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


class Student():
 def __init__(self, name):
 self.name = name

 # 可以利用self取得自己這個類別裡面的變數
 def readMyName(self):
 print('聽清楚了，我的名字是' + self.name + '!!!')

ming = Student('阿明')
mei = Student('小美')
print(ming.name)
print(mei.name)
ming.readMyName()
mei.readMyName()

由於物件概念比較需要仔細釐清，我們就分成兩篇來細講，
請務必仔細完成今天的練習呦！

那我們來練習一下題目吧！

在上述的例子當中，請為類別新增一個字典，名稱為score，
將該字典用來儲存{‘科目’:’分數’}的各科成績，並修改__init__()的函式，
在產生阿明及小美時，同時輸入各科成績，
如未輸入則預設為0分(也就是缺考)。
阿明的成績分別為：數學55/英文70/物理55
小美的成績分別為：數學90/英文88/物理100
承上題，請新增一名Student，其name為’HowHow’，
數學成績為80，英文成績為60，物理成績為40。
請為Student新增一個方法，讓兩個Student可以互相比較，
名稱為compare()。
例如A.compare(B)，假設：
A的總分高於B -> A的名字 + ‘贏了！’
A的總分等於B -> ‘什麼？竟然平手？！’
A的總分小於B -> ‘可…可惡，難道，這就是’ + B的名字 + ‘真正的實力嗎？’

並分別讓阿明和HowHow比較、阿明和小美比較、小美和HowHow比較，
輸出結果。

辛苦啦！我們明天見！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (11) — 標準程式庫：你的機車不機車，載我瀏覽世界景色

Sat, 26 Sep 2020 00:00:00 +0800

Day 11 標準程式庫：你的機車不機車，載我瀏覽世界景色

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10243343

先來解答昨天的問題吧！

我們可以使用randint(1, 100)，
或者使用int(1 + random() * 100)來取得亂數值。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


from random import randint
ans, guess = randint(1, 100), 0
l, r = 1, 100
while ans != guess:
 try:
 guess = int(input('\n請在' + str(l) + '到' + str(r) + '之間猜一個數:'))
 except: # 加入continue，直接跳過後面的範圍處理，回到迴圈的開頭
 print('請輸入正常的數字，不要加其他字母或符號呦！')
 continue
 if guess < l or guess > r: # 超出範圍的部分同樣也要跳過(當然，也可以用elif和下面的判斷連起來)
 print('請輸入正確範圍內的數字！')
 continue
 if guess < ans:
 print('您猜的數字比答案還要小，請再猜大一點~')
 l = guess + 1
 elif guess > ans:
 print('您猜的數字比答案還要大，請再猜小一點~')
 r = guess - 1
print('恭喜你猜出答案啦！')

為了要避開，我們可以先生成一個串列，
範圍為1~100並且去除掉avoid_lt的值。

1
2
3
4


from random import choice
avoid_lt = [4, 14, 44, 94]
ans_lt = [i for i in range(1, 101) if i not in avoid_lt] # 在列表生成式中使用if來處理要跳過的值
ans, guess = choice(ans_lt), 0

在上一篇我們用了一些匯入的模組及套件以後，
今天我們再花一點時間進一步來介紹Python的標準程式庫！
在Python當中有很多已經做好的函式，只需要匯入就可以使用囉！
在實作一些功能前，有時候不妨先查一下是否有適用的函式可用。

但有一點很重要的要先提到：
請不要造一輛車子以後只拿輪子，這會很沒效率。
為什麼呢？
因為當我們造一輛車子的時候會耗費大量的時間，
但如果我們只是要一個輪子的話，
我們應該去尋找專門製作輪子的方式，而非造車拔輪。
所以讀者在使用函式的時候，都要盡量去留意當前自己的目標是什麼，
避免耗費過多時間讓Python在不必要的部分計算。

首先我們來介紹defaultdict() 。
先前我們介紹過字典，假設我們現在有一個字典名為dic，
當我們使用dic[key]時，如果這個key並不在字典裡，
會發生什麼事情呢？
答案是：會產生錯誤！

1
2
3
4
5


>>> dic = {}
>>> dic['XD']
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
KeyError: 'XD'

為了處理這個問題，我們有幾種方式：

每次檢查if key in dic ，存在的話，再做其他的事情。
如果我們有一些預設的狀況的話，例如要存放key出現的次數，那可以使用get() 。
get()的第一個參數放入要找的key，第二個位置放入預設的value值，
如果這個key不存在於字典，就使用後面給定的value做為結果；
如果存在的話，當然就用對應到的value。

1
2


>>> dic.get('XD', 0)
0

defaultdict()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


>>> from collections import defaultdict
>>> cnt = defaultdict(int)
>>> cnt[3]
0
>>> cnt['XD']
0
>>> cnt['a']=1
>>> cnt.get('a')
1
>>> cnt.get('XD')
0

在defaultdict中，當key沒有被指定value時，
就會採用初始化時預設給進去的東西：
寫int代表預設值為0、寫list代表預設為空串列、寫dict表預設為空字典…
以此類推。
省略參數的時候，會被設定為None ，也就是什麼都沒有的意思，
但這麼一來，就又會回到一般字典對於不存在的key會報錯的狀況。
給進去的東西還有其他的用法，有興趣的讀者也可以再深入研究。

接著我們來看看Counter() 。
顧名思義，Counter()基本上就是用來計算什麼東西出現幾次 用的，
它是屬於collections裡面的一部分，
我們直接來看範例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


>>> from collections import Counter
>>> scores = [35,70,10,20,35,70,70]
>>> score_counter = Counter(scores) # 將list代入，即可產生一個Counter型態的東西
>>> score_counter
Counter({70: 3, 35: 2, 10: 1, 20: 1}) # 為當中的元素計數
>>> names = ['James', 'Michael', 'Ted', 'James', 'Leo']
>>> Counter(names) # str也可以使用
Counter({'James': 2, 'Michael': 1, 'Ted': 1, 'Leo': 1})
>>> score_counter.most_common() # most_common()會按由大到小的出現次數來排序
[(70, 3), (35, 2), (10, 1), (20, 1)]
>>> score_counter.most_common(2) # 代入的值代表要取幾個數
[(70, 3), (35, 2)]

除了範例提到的基本以外，兩個Counter之間可以做加、減，
結果就是將對應的key出現的次數加總及相減。
(相減時小於等於0的部分會去掉)
使用&和|則會像set一樣取得交集和聯集。

前面包含了dict及defaultdict的部分，
都有一個特點：它不一定 按照原先順序排列。
那麼如果你真的很在意一開始的順序呢？
我們可以使用**OrderedDict()**來處理。

1
2
3
4
5
6
7
8
9


>>> scores = OrderedDict([('James', 80), ('Andy', 70), ('Curry', 100)]) # 每組要用tuple處理
>>> scores
OrderedDict([('James', 80), ('Andy', 70), ('Curry', 100)]) # 按進去的順序，取出也會相同
>>> for s in scores:
... print(s)
...
James
Andy
Curry

當我們在練習LeetCode寫題目時，
常常會需要使用到stack(堆疊)或queue(佇列)這兩種資料結構，
前者通常使用list即可，後者則一般會使用deque 。
(理論上念做deck，但我都習慣念de-queue)

deque 是一個雙向的序列，
可以從開頭或結尾傳入或取出資料。
我們直接來看範例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


>>> from collections import deque
>>> s = 'abcde'
>>> deque(s) # 直接將字換成deque
deque(['a', 'b', 'c', 'd', 'e'])
>>> d = deque(s)
>>> scores
>>> d.popleft() # 從左邊取出
'a'
>>> d.popleft()
'b'
>>> d.pop() # 從右邊取出
'e'
>>> d.append('XDFES')
>>> d
deque(['c', 'd', 'XDFES'])
>>> d.appendleft('YES')
>>> d
deque(['YES', 'c', 'd', 'XDFES'])

由於從右邊處理才是一般常見狀態，
所以無論是append或pop，
在往左時都會加上一個left，
藉以區分兩者差別。

如果對於資料結構、演算法、LeetCode有興趣的話，
也歡迎看看去年的鐵人賽發文，或者查筆者的Medium系列文章!

以上只不過是Python內建函式庫的冰山一角而已XD
有興趣的讀者，可以再自己找看看有什麼你需要的東西~

那我們來練習一下題目吧！

給定兩個字串s跟t，已經知道t的組成，
是將s的字母打亂以後進行重組，再隨機加上一個字母。
請用前面所學，找出被加上的那個字母。

辛苦啦！我們明天見！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (10) — 模組與套件：借一段往日旋律，宛轉悠揚

Fri, 25 Sep 2020 00:00:00 +0800

Day 10 模組與套件：借一段往日旋律，宛轉悠揚

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10242602

先來解答昨天的問題吧！

假定有一個樓梯，你從第0階要爬到第n階，
每次你只能選擇爬1階或者爬2階，這樣稱做一步。
請寫出一個函式名為cs ，給定n的値以後(n > 0)，
計算出從第0階爬到第n階的方法共有幾種不同的變化？

上一篇提到了遞迴的關鍵點，首要在於將目標不斷簡化，
那麼我們該怎麼思考這題的簡化呢？
想想看，爬到第n階之前，應該要先爬到哪一階呢？
應該是n-1或n-2階吧？因為一次只能走一步和走兩步。
也就是說，假設我們知道cs(n-1)跟cs(n-2)，
我們就能知道cs(n)，因為它們兩個狀況只要分別走1步或2步，
就可以到達第n階，
而且cs(n-1)跟cs(n-2)彼此之間並沒有重複的走法。
所以cs(n) = cs(n-1) + cs(n-2)，
接下來的問題是，在什麼狀況下該停下來？
顯然，在n = 1及n = 2時，
cs(1)和cs(2)的值已經確定是1跟2了，
所以我們每次在遞迴時，只要碰到n=1或n=2時，就應該回傳n的值即可。

1
2
3
4


def cs(n):
 if n == 1 or n == 2:
 return n # 請留意一件事情，函式在使用return回傳以後，不論它當下是否處在迴圏或者是否往下還有東西未完成，都會直接離開函式並回傳值歐！
 return cs(n-1) + cs(n-2)

1
2
3


# 測試計算從cs(1)到cs(100)
for i in range(1, 101):
 print(cs(i))

這麼做其實有一個缺點：
比方說我們算cs(10)的時候，會拆分成cs(9)跟cs(8)，
而接下來會是：
cs(9) -> cs(8) + cs(7) -> cs(7) + cs(6) + cs(6) + cs(5) -> …
cs(8) -> cs(7) + cs(6) -> cs(6) + cs(5) + cs(5) + cs(4) -> …
在化簡的過程中，因為Python並不知道我們有重複的東西，
所以它並不會主動去幫我們把相同的cs(x)給結合在一起，
所以最終就會相當耗時。
(讀者可以執行)

那該怎麼改善呢？
這裡提供兩個方法。
方法一：將用過的答案先記下來(可以使用list或dict)

1
2
3
4
5
6
7


def cs(n, dic):
 # n在裡面就直接回傳(因為已經算過了!)
 if n in dic:
 return dic[n]
 # 先將n的結果算完再回傳，別忘了放到字典裡！
 dic[n] = cs(n-1, dic) + cs(n-2, dic)
 return dic[n]

1
2
3


dic = {1 : 1, 2 : 2} # 預設cs(1), cs(2)的結果
for i in range(1, 101):
 print(cs(i, dic))

方法二：lru_cache
lru_cahce是一個工具，
它可以記住函式已經計算過的內容，並存放起來。
在maxsize=None的時候，我們就不會限制它最多可以記幾個，
因此利用這個性質，它會幫我們自主處理重複計算的部分。

1
2
3
4
5
6


import functools
@functools.lru_cache(maxsize=None) # 用@開頭的稱為裝飾器，有興趣的讀者可再深入了解。
def cs(n):
 if n == 1 or n == 2:
 return n
 return cs(n-1) + cs(n-2)

1
2


for i in range(1, 101):
 print(cs(i))

那麼該如何做出迭代解呢？
由於cs(n)只跟cs(n-1)和cs(n-2)有關，
我們完全可以從cs(3)開始，一路往上加到結束。
1+2=3, 2+3=5, 3+5=8, …以此類推。
當我們要算cs(n)時，表示我們需要經過n-2次的計算，
因此，我們只要利用兩個變數反覆交替並取代，
最終即可得到答案。

1
2
3
4
5
6
7
8


def cs(n):
 if n == 1 or n == 2: return n
 s1, s2 = 1, 2
 for i in range(n - 2):
 # Python的賦值是會一起看開始前的值來計算
 # 所以不會因為s1的值變s2了, s2新的值就變成s2+s2
 s1, s2 = s2, s1 + s2
 return s2

1
2


for i in range(1, 101):
 print(cs(i))

註：請留意當我們在使用字典或list時，其做為參數時是整包一起給，
但當傳一般的int時，傳入的值則當成另一個本地端的變數看待。

1
2
3
4
5


r = 33
def t1(r):
 print(r)
 r = 2
 print(r) # 改完變2

1
2
3
4


def t2(lt):
 print(lt)
 lt[0] = 100
 print(lt)

1
2
3


print('t1')
t1(r)
print(r) # 改完以後外面r的值還是33

1
2
3
4


print('\nt2')
lt = [555]
t2(lt)
print(lt) # 改完後lt內的值已經成為100了!

1
2
3
4


t2
[555]
[100]
[100]

今天我們講點比較輕鬆的東西：模組和套件
如同前面我們所提過的，因為重複做相同的事情太麻煩了，
所以使用函式來將要重複做的事情寫在一起，可以反復呼叫。
那麼，如果你知道有些你需要做的事情，
已經有別人寫過了，用現成的當然會比自己寫還要快很多囉！

我們前面已經用過幾次import(匯入)了，
它的根本其實就是從你自己寫的程式，或者別人寫的程式(或函式庫)，
把前人的智慧來個拾人牙慧一下XD!
import的寫法大體有如下的變化：

1
2
3
4


import module # 直接將整個檔案納入(不用加.py)
from module import function # 只匯入function的部分
import module as xx # xx是自己選的名字，用來在這個程式中全程替代原先的module名
from module import function as oo # 這時候用oo就相當於跟function一樣

舉例來說，在Python中有一個內建模組叫random，random中的random()，
可以隨機生成一個0~1之間的小數亂數(包含0但不包含1)，
我們可以先import random，再呼叫random的random()函式來得到亂數；
或者，我們可以從random中取得random()函式，同時將其取一個別名。
(要為模組取別名也行，取別名的好處是可以比較簡短，且可以避免碰到名稱衝突的問題)

1
2
3
4
5
6


>>> import random
>>> random.random()
0.8076966930768202
>>> from random import random as rd
>>> rd()
0.23723453093568025

如果是Python內建的模組，那麼不論你的主要的程式.py檔放在哪都沒問題；
但如果你想要匯入的是別的檔案，那麼要將這些檔案放在同一個目錄 下，
才能夠正常匯入。

如果我們要更嚴謹一點的話，就要使用套件的形式。
假設我們有一批寫好的檔案，他們都是這個主程式可能會用到的工具，
我們可能會開一個名為utils(工具箱)的資料夾，
裝入所有的檔案，比方說假設有check.py, schedule.py這兩個檔案。
除此以外，還要裝入一個至少是空白的檔案，必須取名為__init__.py。
(前後都有兩個底線)

所以我們的資料夾結構會變成這樣：

1
2
3
4
5


| — fromzero.py
| — utils
 | — __init__.py
 | — check.py
 | — schedule.py

那我們來示範一下運作的模式：

1
2
3
4


# fromzero.py
from utils import check, schedule # 透過套件的模式來匯入
print("Check a lucky number: ", check.getLucky())
print("Check daily routine: ", schedule.get())

1
2
3
4


# utils/check.py
def getLucky():
 from random import random
 return int(random() * 7 + 1) # 取1~7之間的亂數

1
2
3


# utils/schedule.py
def get():
 return "You have a meeting today!" # 就只是回傳一段str而已

那我們一樣來練習題目吧！

上次我們的猜數字遊戲本來是固定的數字，
已知現在可以使用從random模組中的函式取得亂數法，
(詳見Python Document https://docs.python.org/3/library/random.html)
請利用random.randint(a,b)或random.random()，
將前面的題目中要猜的數字改成隨機的1~100(含)之間的整數。
承上題，1~100當中有一些數假設有我們想避開，
不想被成為要猜的數字的話，
若給定該串列avoid_lt = [4, 14, 44, 94]，
請參照上面的說明，使用random.choice(seq)來處理。
(random.choice()方法可以從一個序列型態的東西seq中隨機取出一個值)
(序列是有順序的元素的集合統稱，比如list, tuple, range)
提示：可以先新增一個數列並去處掉不要的元素再做random.choice()

辛苦啦！我們明天見！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (9) — 例外處理、遞迴：誰用三生浮世的煙火，換你一次長憶的交錯

Thu, 24 Sep 2020 00:00:00 +0800

Day 09 例外處理、遞迴：誰用三生浮世的煙火，換你一次長憶的交錯

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10242043

先來解答昨天的問題吧！

為了表現出串列表達式的用法，
這邊我們就先不將range的部分和取偶數合併，
不然使用range(2, 11, 2)就行了。
連同2的寫法如下：

1
2
3
4
5
6
7
8
9


lt1 = []
for i in range(1, 11): # 記得每層都是用縮排表示
 if i % 2 == 0:
 for j in range(1, 11):
 if j % 2 == 0:
 lt1.append(i * j)
print(lt1)
lt2 = [i * j for i in range(1, 11) if i % 2 == 0 for j in range(1, 11) if j % 2 == 0] # 我們可以用不只一層的for來處理列表生成式
print(lt2)

執行結果參考如下：

1
2
3


C:\Users\Desolve>python fromzero.py
[4, 8, 12, 16, 20, 8, 16, 24, 32, 40, 12, 24, 36, 48, 60, 16, 32, 48, 64, 80, 20, 40, 60, 80, 100]
[4, 8, 12, 16, 20, 8, 16, 24, 32, 40, 12, 24, 36, 48, 60, 16, 32, 48, 64, 80, 20, 40, 60, 80, 100]

以現有給出來的內容，我們可以寫成類似以下的小遊戲：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


ans, guess = 37, 0
l, r = 1, 100
while ans != guess: # 猜對就離開，猜錯則繼續
 guess = int(input('請在' + str(l) + '到' + str(r) + '之間猜一個數:'))
 if guess < ans:
 print('您猜的數字比答案還要小，請再猜大一點~')
 l = guess + 1 # 範圍會被限縮到比剛剛猜的數字還要大做為左邊界
 elif guess > ans:
 print('您猜的數字比答案還要大，請再猜小一點~')
 r = guess - 1
print('恭喜你猜出答案啦！')

請留意，這只是按照我們現在已經學到的部分來撰寫的，
以這個解法來說的話就包含了以下幾個明顯的bug
(程式臭蟲，指程式碼中有一些問題導致運行會當掉或是輸出結果有問題，
可能是輸入錯誤，也有可能是程式的邏輯本身出的問題)：

輸入非數字的時候會因為無法轉換成整數而使程式當掉。
輸入數字可以限縮範圍，但我們並沒有真的限制使用者只能輸入這個範圍內的數字。
請參照執行結果，應該能理解上面兩點所造成的問題。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


C:\Users\Desolve>python fromzero.py
請在1到100之間猜一個數:90
您猜的數字比答案還要大，請再猜小一點~
請在1到89之間猜一個數:10
您猜的數字比答案還要小，請再猜大一點~
請在11到89之間猜一個數:-5
您猜的數字比答案還要小，請再猜大一點~
請在-4到89之間猜一個數:88
您猜的數字比答案還要大，請再猜小一點~
請在-4到87之間猜一個數:34
您猜的數字比答案還要小，請再猜大一點~
請在35到87之間猜一個數:37
恭喜你猜出答案啦！

1
2
3
4
5
6


C:\Users\Desolve>python fromzero.py
請在1到100之間猜一個數:67u
Traceback (most recent call last):
 File "fromzero.py", line 4, in <module>
 guess = int(input('請在' + str(l) + '到' + str(r) + '之間猜一個數:'))
ValueError: invalid literal for int() with base 10: '67u'

1
2
3
4
5
6


C:\Users\Desolve>python fromzero.py
請在1到100之間猜一個數:st
Traceback (most recent call last):
 File "fromzero.py", line 4, in <module>
 guess = int(input('請在' + str(l) + '到' + str(r) + '之間猜一個數:'))
ValueError: invalid literal for int() with base 10: 'st'

接下來我們來講今天的第一個主題：
如昨天的第三題來說，我們會發現使用者永遠可以超乎你的想像。
這時候你希望得到可以轉成1~100的字串，並且能夠處理掉輸入錯誤的問題的話，
該怎麼辦呢？

如果你能將使用者輸入的每一種內容都分門別類，
當然可以用if…elif…else的形式來進行解決，
如果沒有想要分那麼精細呢？
我們可以使用Python的錯誤處理機制try…except…。
基本語法如下：

1
2
3
4


try:
 有可能發生例外的程式碼
except:
 發生例外時，執行這個區塊的程式碼處理

讓我們改一下前面的程式碼看看：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


ans, guess = 37, 0
l, r = 1, 100
while ans != guess:
 try:
 guess = int(input('\n請在' + str(l) + '到' + str(r) + '之間猜一個數:'))
 except: # 加入continue，直接跳過後面的範圍處理，回到迴圈的開頭
 print('請輸入正常的數字，不要加其他字母或符號呦！')
 continue
 if guess < l or guess > r: # 超出範圍的部分同樣也要跳過(當然，也可以用elif和下面的判斷連起來)
 print('請輸入正確範圍內的數字！')
 continue
 if guess < ans:
 print('您猜的數字比答案還要小，請再猜大一點~')
 l = guess + 1
 elif guess > ans:
 print('您猜的數字比答案還要大，請再猜小一點~')
 r = guess - 1
print('恭喜你猜出答案啦！')

在上面的程式中，當我們用try包住input那行以後，
一旦我們輸入了不是數字的東西，原本Python會報錯並結束程式，
此時就會改成來到except處來執行對應的程式碼。
(如果沒輸入錯誤，except的部分就會被忽略)

事實上，不同的例外在Python當中會有不同的錯誤類型，
如果你想要分開精細地處理不同類型的例外的話，
就要寫成如下型式：

1
2
3
4
5
6
7
8


try:
 有可能發生例外的程式碼
except 例外1 as 命名1:
 處理例外1的種類所造成的例外的程式碼(發生什麼事情可以從命名1的變數印出)
except 例外2 as 命名2:
 ...
except 例外3 as 命名3:
 ...

當一個例外發生時會依序由上到下檢查符合哪一個種類的例外，
先滿足條件的獨佔(可以想成類似if…elif的檢查方式)
例外的類別有像是UppercaseException, IndexError, ValueError等等，
他們的共同的大類別都是Exception。

你也可以使用raise Exception(傳入值)來主動將例外丟出。
(如果你有做好處理的準備的話)
同時，它可以帶著給定的訊息，有助於我們判斷到底是怎麼一回事。

1
2
3
4
5
6


>>> try:
... raise Exception('讚讚')
... except Exception as exc:
... print(exc)
...
讚讚

接下來我們要來講一個日後各位一定碰得到也很常用的方法：遞迴(Recursion) 。
什麼是遞迴呢？
遞迴就是當一個函式在使用時，中途不斷呼叫自己，
藉以達到某些目的或完成某些問題。
通常狀況下，
寫得正常的遞迴應該會不斷在過程中將要計算的問題進行簡化，
最終只剩下我們要的東西，同時沒有再繼續呼叫函式。
聽起來……超級無敵抽象的阿！！！
沒關係，讓我們看看實際的範例。
還記得那個白目的小男孩高斯嗎？
假設我們不會公式，希望使用Python來幫我們手算1~100，
按現有前面學過的東西，你可能會這樣寫：

1
2
3
4
5
6
7


# 別命名成sum()，它是Python已經有的東西，可以用來計算一個串列的所有值加總
# 預設算到100
def cal(end=100):
 res = 0 # res意思是result, 你要命名成ans也可以，看自己習慣
 for i in range(1, end + 1): # range的範圍記得是頭算尾不算，所以要加1
 res += i
 return res

1

print(cal())

如果你不會range的話可能就真的要一個一個加了！
那麼，從遞迴的角度是怎麼看待這件事情的呢？
答案是一個一個處理 。
既然cal(100)是1加到100，那麼cal(99)就是1加到99；
因此，cal(100)就相當於100加上cal(99)囉！
以此類推，我們可以得到cal(end)會等於end + cal(end — 1)。

於是，我們可以將函式按照這個概念重寫成下面的樣子：

1
2
3


# 好像哪裡怪怪的？
def cal(end):
 return end + cal(end - 1)

有沒有覺得哪邊怪怪的？
我們忘記一件事情，就是當碰到cal(1)的時候，
它本身應該要直接等於1才對，
不然按照這樣呼叫下去，cal輸入的值會變成0, -1, -2, -3, … ，
但不會停下來XD！
那我們再改寫一下：

1
2


def cal(end):
 return end + cal(end - 1) if end != 1 else 1

說明一下，上面的式子前面還沒有講過，但應該不難理解，
這是屬於Python的三元運算子，使用if跟else，
也就是說，當end != 1時，這行會回傳前面那段”end + cal(end — 1)” ，
否則，就回傳1 (也就是當end為1時，直接回傳1就對了！)。

實際在呼叫函式的時候，例如將100代入，
我們會先呼叫cal(100)，發現cal(100)要算100+cal(99)；
Python會將100先記錄下來，先去算cal(99)，
也就是等算出cal(99)後，再回過頭來加上100；
cal(99)又會被拆成99+cal(98)，以此類推。

由於函式執行時實際上需要記憶體空間，這種還沒得到結果的函式，
往下又呼叫了東西的話，就會再疊上下一段的函式，
也就是在電腦的記憶體中會有地方放cal(100), cal(99), cal(98)… ，
一路堆疊上去，這樣子的結構被我們稱之為呼叫堆疊(call stack) 。

所以假設一個函式還沒完成，
就又在裡面呼叫另一個函式(可能是自己或別人)的話，
call stack就會越疊越高，從而占用大量記憶體。

因此，一般來說程式語言都會限制call stack最大的堆疊的函式數量，
以Python來說，可以用以下的方式來檢查call stack的限制：

1
2
3


>>> import sys # import我們會在後面進行介紹
>>> print(sys.getrecursionlimit())
1000

所以如果我們將剛剛的cal改成1000的話，這個程式就廢了XD!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


C:\Users\Desolve>python fromzero.py
Traceback (most recent call last):
 File "fromzero.py", line 4, in <module>
 print(cal(1000))
 File "fromzero.py", line 2, in cal
 return end + cal(end - 1) if end != 1 else 1
 File "fromzero.py", line 2, in cal
 return end + cal(end - 1) if end != 1 else 1
 File "fromzero.py", line 2, in cal
 return end + cal(end - 1) if end != 1 else 1
 [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded in comparison

我們總結一下建立一個遞迴函式的條件：

我們可以將一個要計算的東西拆小，不管是拆成一部分已知一部分未知 ，
或是拆成數塊比較小的部分 都可以。
在越拆分越小的時候，要至少有一個狀態是可以直接得到結果的 (比如剛剛的cal(1)=1)，
因而，讓所有的區塊最後都能變成已知，從而可以計算出結果 。

讀者可能會有一些疑惑：
看起來遞迴好像就簡單一點，但是沒有迴圏快阿！
而且迴圏也不會有限制call stack的層數的問題，為什麼不用迴圏呢？

好問題！
我們現在示範的只是很簡單的範例，
事實上在絕大多數狀況下，可以用遞迴的問題，用迴圏也寫得出來，
這邊通常會稱使用迴圏寫出來的解法為迭代解(iterative solution)。

問題是……
越難的題目，通常遞迴解就會很常比迭代解還要容易思考，
而迭代解有時候會需要用到比較複雜的推導，才能夠寫出來！

所以如果未來讀者在學了Python以後，
可能還學了一些別的進階的應用，當面試的時候被考到白板題，
在沒有特別的狀況下，請盡量先確定給出自己遞迴解，
有信心的話，再更進一步去嘗試迭代解，會比較穩妥。

補充：
感謝FB 程式人雜誌 社團的網友** Cheng-En Chuang**留言補充如下，
想更深入了解遞迴的運作的話，請參考他的解說及提供的參考資料：
「有點雞蛋裡挑骨頭，
但遞迴在Python裡面有深度限制是因為沒做tail-call optimization。
在其他有做tail-call optimization的語言裡面就不會有深度限制，
另外在某些語言裡面recursion也不一定比iteration慢。
甚至在Python裡面也可以用decorator達到tail-call效果：
https://towardsdatascience.com/python-stack-frames-and-tail-call-optimization-4d0ea55b0542」

那我們一樣來練習題目吧！

假定有一個樓梯，你從第0階要爬到第n階，
每次你只能選擇爬1階或者爬2階，這樣稱做一步。
請寫出一個函式名為cs，給定n的値以後(n > 0)，
計算出從第0階爬到第n階的方法共有幾種不同的變化？
例：
cs(1) = 1 (1)
cs(2) = 2 (1+1, 2)
cs(3) = 3 (1+2, 2+1, 1+1+1)
cs(4) = 5 (1+1+2, 2+2, 1+2+1, 2+1+1, 1+1+1+1)
請分別給出遞迴解和迭代解。

對初學者來說，可能不是那麼容意思考，請務必好好觀察函式之間的關係。

辛苦啦！我們明天見！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (8) — 程式結構與流程語法：如果對手太弱太簡單，那不是很爽嗎?(下)

Wed, 23 Sep 2020 00:00:00 +0800

Day 08 程式結構與流程語法：如果對手太弱太簡單，那不是很爽嗎?(下)

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10241349

在上一篇文章中我們講了if…elif…else, while, for, 以及range，
我們也提到了像range()這樣子的方法，是用來生成一個可迭代的Python物件。
而只要可迭代的話，我們通常就可以將其轉成一個list，如上一篇文章那樣。
不管是if, while, for等，都可以使用多層的架構，
對於while跟for來說，其處理方式也是類似多層if的概念，
同時外層內層的東西不同也是可以的。
例如：

1
2
3
4
5
6
7


while xxx:
 ooo
 rrr
 while yyy:
 uuu
 vvv
 www

這個雙重迴圏，執行的順序應該是：
xxx成立時，進入迴圏->ooo->rrr->
yyy成立時，進入迴圏->uuu->vvv->
內層迴圏完成一次，重新檢查yyy，若成立則繼續運行，
否則就會執行完www後，回到xxx檢查。
(所以說內層的執行完，才會輪到外層)

今天我們要介紹一個在Python中很好用且常用的東西，
它也用到了for…in…的方法，名字叫做list comprehension ，
可以用來快速簡單地生成list，
中文目前沒有統一的叫法，
可以叫成串列生成式/串列表達式/串列解析式 都行。
其基本形式像這樣：
[算式 for 單項 in 迭代項目]

舉例來說，假設我們要一個從0~9的串列，我們可以這樣寫：

1
2
3
4


>>> list(range(9))
[0, 1, 2, 3, 4, 5, 6, 7, 8]
>>> [i for i in range(9)]
[0, 1, 2, 3, 4, 5, 6, 7, 8]

串列生成式的意義在於每次從迭代的項目當中取出一個單項，
接下來將這個單項透過算式進行加工處理，才放到list當中。
所以除了基本的方法以外，我們也可以用if條件式來進行過濾，只要在後面加上if條件式即可。

1
2


>>> [2 * i for i in range(9) if i % 2 == 0] # 取0~8當中能整除2的數，每個都先乘以2再加到list
[0, 4, 8, 12, 16]

另一方面，我們也可以利用多重的for in來製造出雙層的list，
或者組合性質的東西。
我們前面提到過list裡面的element也可以是list，
如果我們今天要表達一組4 * 3的格子，格子裡面一開始只放零的話，
可以寫成：

1
2


>>> [[0 for i in range(3)] for j in range(4)] # 一層一層看就會理解等於[0, 0, 0]重複4次
[[0, 0, 0], [0, 0, 0], [0, 0, 0], [0, 0, 0]]

如果我想要把所有的座標(從(0, 0)起算)的組合寫到一個list呢?

1
2
3


>>> combo = [(row, col) for row in range(4) for col in range(3)] # 留意4跟3的順序
>>> combo
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2), (3, 0), (3, 1), (3, 2)]

(註：像這樣子在存取每一個格子都需要指定兩層index的串列，
我們稱之為二維串列，代表它有兩個維度。)

字典和集合也有生成式，其概念和列表生成式一致，
只是字典的話就會是{key:value for 單項 in 迭代項}
(必須給出key跟value的部分)
集合的話除了外面是大括號 外，和列表生成式一致。

接下來我們要來談一個程式語言很重要的東西：函式(function)
還記得前面我們有做過計算圓面積的練習對吧？
計算圓面積明明是一個不會改變的公式，
但我們還是要反覆改動代入值，這樣顯得有點麻煩。
為了不要浪費時間在做相同的事情上，
我們可以將寫好的一段程式碼(比如剛剛講的算面積)，定義成函式，
就像數學的函式那樣，公式已經寫好了，只差將要算的東西代入進去就好。

一個函式的程式架構一般如下：

1
2
3
4
5


def 函式名(變數1, 變數2, 變數3, ...):
 xxx
 yyy
 ...
 return ooo

def代表define(定義) ，後面接你的命名，
括號內是放入你需要從呼叫函式的對象那邊得到的變數(或者稱為參數)，
也可以都不放，表示你不需要從外界傳入；
接著就在這個函式內按照一般程式碼的流程來撰寫，
最終如果這個函式需要回報一些訊息的時候，則需要進行return(回傳) 。

我們拿圓面積計算為例：

1
2
3


def area(r):
 pi = 3.14
 return 3.14 * r ** 2 # 會將計算完的結果輸出到呼叫它的地方

由於Python是腳本式語言，
一個函式必需要先被定義或引入後，
才能夠被使用，所以我們必須在使用(或稱呼叫)函式前，
先將它定義完，在下一行開始才能夠使用它。

1
2
3
4
5
6
7


# area(1) 不能放在這邊，因為我們還沒有定義area函式!
def area(r):
 pi = 3.14
 return 3.14 * r ** 2

print('半徑長為1的圓，其面積為：' + str(area(1)))
print('半徑長為3的圓，其面積為：' + str(area(3)))

執行結果如下：

1
2
3


C:\Users\Desolve>python fromzero.py
半徑長為1的圓，其面積為：3.14
半徑長為3的圓，其面積為：28.26

假設我們今天不滿足圓周率pi只用3.14的話，
除了用math模組的pi外(引入模組這部分之後再講)，
那麼就必須將pi也一併設定為可以拿進來用的變數。
但是一般來說，像pi這類型的常數，
我們會希望**「不特別講的話就按照預設的來」，** 這時候我們可以利用在給入的變數的後面加上等號及一個值 ，
一旦這個變數沒有被指定，就會使用預設值 。
此外，很多時候乍看之下，我們會容易不曉得一個函式中，
每一個位置先後要代入什麼才是對的順序，
為此，Python提供我們可以指定變數名稱的方式，
只要輸入時有帶上變數名稱，即便順序和原先函式定義給的順序不一樣，
Python依舊可以正確地幫我們對應上。

1
2


def area(r, pi=3.14):
 return pi * r ** 2

1
2
3


print('半徑長為1的圓，其面積為：' + str(area(1, 3.14159))) # 指定圓周率
print('半徑長為3的圓，其面積為：' + str(area(3))) # 不指定圓周率，使用預設值3.14
print('半徑長為3的圓，其面積為：' + str(area(pi=3.141, r=3))) # 順序會被自動對上

結果如下：

1
2
3
4


C:\Users\Desolve>python fromzero.py
半徑長為1的圓，其面積為：3.14159
半徑長為3的圓，其面積為：28.26
半徑長為3的圓，其面積為：28.269

同樣的，在函式內部也可以定義函式，
一樣的概念，要有定義過的才能被呼叫使用，
同時，可以接受參數，但也可以直接用其外層得到的變數。

1
2
3
4
5
6
7
8
9


def printAll(r, pi=3.14):
 def area():
 return pi * r ** 2
 def perimeter():
 return 2 * pi * r
 # 下面{}的用法是所謂的format，可以將多個變數按照順序放置到{}中
 print('半徑 = {}的圓，其面積 = {}，周長 = {}'.format(r, area(), perimeter()))

printAll(3, 3.14159)

執行結果如下：

1
2


C:\Users\Desolve>python fromzero.py
半徑 = 3的圓，其面積 = 28.27431，周長 = 18.849539999999998

我們前面已經提過，
變數就像是將一個標籤(變數名稱)貼在一個裝有東西(資料)的箱子。
那麼，你家的急救箱和我家的急救箱 ，
雖然名字都是急救箱，但應該是指不一樣的東西。

在Python或其他程式語言中也一樣，
一個名稱，有屬於它存在的適用範圍，我們稱之為命名空間。
如果在最外面(也就是沒有在函式中)命名一個變數的時候，
任何人應該都看得到這個變數的存在，並且可以自由使用它，
我們稱之為全域變數 。

那麼在函式內呢？
如果今天在公共的地方有一個急救箱，你又自己去買了一個急救箱回來，
那麼在命名時，
你在你家稱呼的急救箱，自然是你自己買的那個，而非公共的。
(稱為區域(local)變數 )
除非你都用公共的，那麼自然你指的還是那個公共的急救箱
(函式內可以取得全域變數 )
如果打定主意要用全域變數，且有要進行修改的話，
請在函式內使用global 這個關鍵字。

1

fak = 'global' # First-Aid Kit

1
2


def home1():
 print(fak) # 直接取得全域的變數，不做修改

1
2
3
4
5
6
7
8


def home2():
 fak = 'h2' # 定義一個local的變數，所以修改到的變數跟全域的fak無關
 print(fak)

def home3():
 global fak # 告訴Python現在要用的就是全域的那個fak
 fak = 'h3'
 print(fak)

1
2
3
4
5
6


print('Before:')
print(fak)
print('\nhome1:')
home1()
print('After home1:')
print(fak)

1
2
3
4


print('\nhome2:')
home2()
print('After home2:')
print(fak)

1
2
3
4


print('\nhome3:')
home3()
print('After home3:')
print(fak)

所以我們可以看到這三者之間的差異，
一個只印出全域變數，一個只使用區域變數，第三個則是不但使用了全域變數且修改了它。

1
2
3


C:\Users\Desolve>python fromzero.py
Before:
global

1
2
3
4


home1:
global
After home1:
global

1
2
3
4


home2:
h2
After home2:
global

1
2
3
4


home3:
h3
After home3:
h3

註：其實還有更細節的部分，但講太多恐怕對初學者容易造成混淆，
我們還是先講這兩種就好，其他的在碰到狀況，或有興趣的話，
再請讀者搜尋變數範圍的部分。

那麼我們來做個練習吧！

請使用兩個迴圏，將1~10之間的偶數兩兩相乘並放到一個空的list中。
(所以這個list應該會有
2 * 2, 2 * 4, 2 * 6, 2 * 8, 2 * 10, 4 * 2, 4 * 4, …, 10 * 10)
請改用列表生成式來完成1的問題。
請用while, if else等，寫出一個猜數字的遊戲，遊戲的答案為37，
請在開始時提示使用者猜1~100範圍中的數字，
並依據使用者的答案，逐步將範圍縮小，直到猜中答案，
則印出恭喜訊息並離開迴圏。
(先不考慮使用者會亂輸入的問題，
並且要告訴使用者這次猜的比答案大還是小)

那就明天見啦！

2023/08/29: 感謝iT邦幫忙的Sean勘誤周長和面積呼叫順序顛倒的問題~

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (7) — 程式結構與流程語法：如果對手太弱太簡單，那不是很爽嗎?(上)

Tue, 22 Sep 2020 00:00:00 +0800

Day 07 程式結構與流程語法：如果對手太弱太簡單，那不是很爽嗎?(上)

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10240601

先來解答昨天的問題吧！

李嚴的是炸鳳尾蝦，劉昴星的是雲龍炸蝦，
如同上一篇所提到的，字典的value是可以是list的！
按照步驟，前三個問題要取liu-lee, lee-liu, lee & liu，
後面將set加進新的key後再替代回原本shrimp[‘炸鳳尾蝦’]。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


>>> shrimp = {'炸鳳尾蝦':['蝦子','核果','油'],'雲龍炸蝦':['蝦子','核果','油','豆皮','醬汁']}
>>> lee = set(shrimp['炸鳳尾蝦'])
>>> liu = set(shrimp['雲龍炸蝦'])
>>> lee # 所以我說那個醬汁呢？
{'核果', '油', '蝦子'}
>>> liu
{'醬汁', '蝦子', '豆皮', '核果', '油'}
>>> liu-lee
{'豆皮', '醬汁'}
>>> lee-liu　# 李嚴沒有多用到的東西
set()
>>> lee & liu # 都用到的材料
{'核果', '油', '蝦子'}
>>> lee.add('蘋果', '洋蔥','醬汁') # set不能夠一次add多個key，除了一個一個加以外，也可以用update()方法。(lee.update(['蘋果', '洋蔥','醬汁']))
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: add() takes exactly one argument (3 given)
>>> lee.add('蘋果')
>>> lee.add('洋蔥')
>>> lee.add('醬汁')
>>> lee
{'洋蔥', '醬汁', '蝦子', '蘋果', '核果', '油'}
>>> lee-liu
{'洋蔥', '蘋果'}
>>> shrimp['炸鳳尾蝦'] = list(lee)
>>> shrimp
{'炸鳳尾蝦': ['洋蔥', '醬汁', '蝦子', '蘋果', '核果', '油'], '雲龍炸蝦': ['蝦子', '核果', '油', '豆皮', '醬汁']}

按照題目要求一個一個來就可以了，請留意index的初始値是0這點呦！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


>>> lt = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> lt1 = lt[::2]
>>> lt2 = lt[1::2]
>>> lt1, lt2
([1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
>>> lt1.extend(lt2)
>>> lt1
[1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
>>> del lt1[7]
>>> lt1
[1, 3, 5, 7, 9, 2, 4, 8, 10]
>>> del lt1[1]
>>> lt1
[1, 5, 7, 9, 2, 4, 8, 10]
>>> lt1.sort()
>>> lt1
[1, 2, 4, 5, 7, 8, 9, 10]

接下來，讓我們來介紹今天的主題：程式結構與流程語法。
在這篇文章中，我們要來介紹一些超級無敵常用的東西，
常用到基本上天天會遇到的那種。

首先是程式結構。
我們應該在前幾篇文章中有提到過，
在Python中當需要執行的東西比較多時，
我們是可以將一整段寫在一個.py檔案裡，
再用python xxx.py 的方式去執行，對吧！
在之後的程式裡，如果程式碼比較多比較複雜，
建議讀者先將程式規劃好打在檔案內，再進行執行，
可以避免打錯造成的一些麻煩。

先來談談註解，註解通常使用**「#」的符號，
基本上意味著一行程式碼在這個符號後面的任何東西都不會有影響。
(且只影響該行)
(但是擺在字串內的話就不會有註解的效果，會被當成普通的字元)
通常狀況下，在文字編輯器內將想註解的行框起來，再按Ctrl+/**，
編輯器會自動幫助你將這幾行都註解起來。
如果要多行註解的話，也可以在行的最前面使用’’’ (三個單引號)，
註解結束的位置同樣放置’’’。
(但這種註解一般被視為在為函式(後面會提到)打說明文件用的文字，
稱之為文件字串(docstring)，
沒特別需求的話，Ctrl+/即可)

1
2
3
4
5
6
7


'''
a = 10
b = 5
print(a * b)
print("一起從零開始學Python，我知道10 * 5 = " + str(a * b))
# 雖然這行有「#」，但實際起作用是外層造成的
'''

如果你有一整行很長的運算或文字，
想要做換行的話，請在換行之前的行尾放上「\」 ，
Python會將這樣延續下去的行都當成同一行解讀。
如果在直譯器的狀態下也適用，
這時候直譯器會顯示「…」，代表這行還沒輸入完。

1
2
3
4
5


>>> 3+5+7+\
... +11+18+\
... 23\
... +10
77

接下來就是所有程式基本上都有的方法：如果(if)
「如果…我就…」這種思維邏輯是日常中很常用到的概念，
Python中也不例外，我們常常需要很多判斷來決定下一步要怎麼走。
語法結構如下：

1
2
3
4
5
6
7


if 陳述式1:
 要做的事情1(可以不只一行)
elif 陳述式2:
 要做的事情2(可以不只一行)
...
else:
 要做的事情n(可以不只一行)

上面的意思是說，當陳述式1的結果是真(True)的的時候，
就做「要做的事情1」，
否則如果(elif, 也就是else if的意思)陳述式2是真的的時候，
就做「要做的事情2」，
可以一直接續，前面的陳述式(statement)一旦先碰到一組是真的時候，
做完要做的事情就離開了，
並不會繼續往下看 。
一直到最後一個else的時候，前面的都不成立，就做「要做的事情n」 。
這個結構底下，你可以選擇使用if, if…elif…else, if…else, if…elif都可以。
(只要順序是if最先，elif其次，else擺最後 即可)

其他語言在框「要做的事情」時，
通常會使用大括號{}來表達開頭和結尾，
這點在Python中有很大的不同！
Python中會在陳述式後面加上一個冒號:來做為分界，
接下來的式子執行到哪裡，並不使用大括號，
而是看縮排的程式碼到哪一行。
(一般縮排是用4個空格 ，盡量不要使用tab或2個空格)
還記得上一篇問題中的炸蝦嗎？

1
2
3
4
5
6
7


lee = {'核果', '油', '蝦子'}
if '醬汁' not in lee: # 李嚴並沒有做醬汁，所以這個陳述式會是真
 print('李嚴')
 print('沒醬汁')
else:
 print('有醬汁')
print('所以我說那個醬汁呢？') # 這個print並不在else的範圍內！

我們執行上面的程式碼的結果應該會得到：

1
2
3


李嚴
沒醬汁
所以我說那個醬汁呢？

因為最後一行並沒有縮排，所以不會算在else的範圍內，
依舊會被print出來。
在判斷的時候，除了剛剛示範的in，
可以使用其他的比較運算子及布林運算子來計算真假。
比較運算子 有：==(相等，因為一個等號是將右邊的東西指定給左邊), !=(不等於),
<(小於), >(大於), <=(小於等於), >=(大於等於), in…(前者在後者的範圍內)
布林運算子 常用的有：and(且), or(或), not(否定)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


>>> x=24
>>> x>3
True
>>> x<21
False
>>> 12<x<100 # 相當於12 < x and x < 100
True
>>> x == 24
True
>>> lt = [1, 3, 24, 10, 33]
>>> x in lt and not x < 23 # and/or的優先順序比較低，會等左右計算完成才處理，not會將結果反轉
True

如果有很多重的判斷的話，
我們也可以將其寫成不同層來處理，
怎麼判斷不同層的方式，一樣是看縮排來決定。

1
2
3
4
5
6
7
8


x = 24
if x % 2 == 0:
 if x % 3 == 0:
 print('6的倍數')
 else:
 print('2的倍數')
else:
 print('不是2的倍數')

執行完應該會print出’6的倍數’，讀者也可以自行嘗試做出不同的多層if結構。

接著要補充一個很重要的點：
Python在處理判斷時，也可以將單純的資料型態做為判斷的依據，
這時候主要在考慮的，就是這個資料型態是否有存放東西，或者它是0 。
包含False, None(代表沒有東西), 0, 0.0, ‘’(空字串), [], (), {}, set()等，
在做為True/False的判斷中，都會被視為False。

所以例如要判斷一個list是否為空，我們可以這樣寫：

1
2
3
4
5
6
7


>>> lt = []
>>> if lt:
... print('lt is not empty')
... else:
... print('lt is empty')
...
lt is empty

接下來我們來談談迴圈。
迴圈在Python裡面有兩種：while跟for。
while的語法結構如下。

1
2
3
4
5


while 陳述式:
 xxx
 yyy
 zzz
...

while很簡單，只要這個陳述式是真的 ，就會將下面的程式碼區塊執行一次 ，
做完以後呢？回到while這行，重新判斷一次 ，
如果還是成立，就再做一次；
一直到陳述式不成立，或者我們呼叫一些其他的東西強行跳出，才會離開。
可以用來跳離迴圈的方式名為break ，顧名思義就是強行中止現在所在的迴圈 ，
不繼續往下執行 。
另外有一個功能叫continue ，目的是跳過這次的迴圈 (只跳過這次歐！)，
回到while這行 ，依照陳述式的結果決定要不要再繼續執行。

我們下面使用input()方法來示範，它能顯示提示字樣，並接受使用者輸入一段字串存放，
讀者可以自行試試看，是否除非你選擇專家模式，否則完全無法離開迴圈。

1
2
3
4
5
6
7
8
9


while True: # 使用while True須謹慎，一定要留下可以離開的方法！
 mode = input('請問你要選擇什麼模式？1. 簡單模式 2. 困難模式 3. 專家模式 [輸入1, 2, 3] ')
 if mode == '3':
 print('\n選擇專家模式的難關 帶著我的夥伴 還有我的不平凡')
 break
 elif mode == '1' or mode == '2': # 簡單來說，其他模式都不給過XD
 print('不選難一點的嗎？再給你選一次！\n')
 continue # 所以在這邊會直接回到迴圈開始處，因而不會印出下一行
 print('請輸入正確的選項！\n')

1

print('恭喜你選擇專家模式，加油！')

1
2
3


C:\Users\Desolve>python fromzero.py
請問你要選擇什麼模式？1. 簡單模式 2. 困難模式 3. 專家模式 [輸入1, 2, 3] 5545
請輸入正確的選項！

1
2


請問你要選擇什麼模式？1. 簡單模式 2. 困難模式 3. 專家模式 [輸入1, 2, 3] 1
不選難一點的嗎？再給你選一次！

1
2


請問你要選擇什麼模式？1. 簡單模式 2. 困難模式 3. 專家模式 [輸入1, 2, 3] 2
不選難一點的嗎？再給你選一次！

1

請問你要選擇什麼模式？1. 簡單模式 2. 困難模式 3. 專家模式 [輸入1, 2, 3] 3

1
2


選擇專家模式的難關 帶著我的夥伴 還有我的不平凡
恭喜你選擇專家模式，加油！

在Python中，迴圈還有一個特別的用法，就是可以加else。

1
2
3
4


while 陳述式:
 xxx
else:
 ooo

當while正常的結束，沒有被break跳出的話，
離開後就會出來找else的區塊執行。
(讀者可將其想成if else的感覺，
正常離開迴圈就是陳述式結果為false的狀況，所以要走else路線)
反之，當迴圈是被break強行離開時，就不會走到else去了！
舉例來說，我們也可以將上面改成：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


mode = ''
while mode != '3': # 使用者選專家模式才能離開！
 mode = input('請問你要選擇什麼模式？1. 簡單模式 2. 困難模式 3. 專家模式 [輸入1, 2, 3] ')
 if mode == '3':
 print('\n選擇專家模式的難關 帶著我的夥伴 還有我的不平凡')
 elif mode == '1' or mode == '2': # 簡單來說，其他模式都不給過XD
 print('不選難一點的嗎？再給你選一次！\n')
 else:
 print('不想玩就算了！\n') # 不想玩的，後續就不繼續給提示
 break
else: # 正常離開，表示mode輸入了'3'
 print('恭喜你選擇專家模式，加油！')

1
2
3


C:\Users\Desolve>python fromzero.py
請問你要選擇什麼模式？1. 簡單模式 2. 困難模式 3. 專家模式 [輸入1, 2, 3] 1
不選難一點的嗎？再給你選一次！

1
2


請問你要選擇什麼模式？1. 簡單模式 2. 困難模式 3. 專家模式 [輸入1, 2, 3] 2
不選難一點的嗎？再給你選一次！

1

請問你要選擇什麼模式？1. 簡單模式 2. 困難模式 3. 專家模式 [輸入1, 2, 3] 3

1
2


選擇專家模式的難關 帶著我的夥伴 還有我的不平凡
恭喜你選擇專家模式，加油！

1
2
3


C:\Users\Desolve>python fromzero.py
請問你要選擇什麼模式？1. 簡單模式 2. 困難模式 3. 專家模式 [輸入1, 2, 3] 8
不想玩就算了！

通常狀況下，我們會將迴圏的過程每一次的執行稱為一次迭代(iteration) 。
有些資料型態可以適合每次從裡面取出一個單位出來，
例如str, list, set, dict, tuple…等，
這時候我們會說這些是可迭代的Python物件。

對於可迭代的東西，我們有另一個for迴圏的模式可以輕鬆處理。
for迴圏的語法結構如下：

1
2


for xxx in ooo:
 (對xxx做事情，比如印出來)

舉例來說，我們可以從一個list中一個一個取出當中的element，
並將其印出。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


>>> lt = [1, -5, 3, 2, 4, 10, 100]
>>> for num in lt:
... print(num)
...
1
-5
3
2
4
10
100
>>> index = 0 # 也可以用index的方式一個一個拿，不要忘記將index每次加1
>>> while index < len(lt):
... print(lt[index])
... index += 1
...
1
-5
3
2
4
10
100

如上篇文章提到的，字典的items()也會產生可迭代的物件，
我們可以按順序用name和ingre(ingredient)來對應它。

1
2
3
4
5
6


>>> shrimp = {'炸鳳尾蝦':['蝦子','核果','油'],'雲龍炸蝦':['蝦子','核果','油','豆皮','醬汁']}
>>> for name, ingre in shrimp.items():
... print(name, ingre)
...
炸鳳尾蝦 ['蝦子', '核果', '油']
雲龍炸蝦 ['蝦子', '核果', '油', '豆皮', '醬汁']

另一方面，break, continue, else在for迴圏的用法和while迴圏的用法是一模一樣的，
讀者可以自行嘗試寫寫看。

提到了for，就不得不提另一個很常用的產生迭代的方式：range()。
range()的用法跟slice很像，都是(start, stop, step)；
這當中，start不給的話會從0開始，step預設則是1，
而stop由於不像list有確定的長度，所以是必需要給出的數字。
(同樣請留意stop的位置是不算在內的，這點跟slice相同 )
例如：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


>>> range(7) # 只給一個數字的話是表示stop，所以相當於range(0, 7)
range(0, 7)
>>> list(range(7)) # 可以將其產生為list
[0, 1, 2, 3, 4, 5, 6]
>>> list(range(1, 5))
[1, 2, 3, 4]
>>> list(range(1, 5, -1)) # step走-1並沒有符合的數字
[]
>>> list(range(1, 5, 2))
[1, 3]
>>> list(range(10, -88, -10))
[10, 0, -10, -20, -30, -40, -50, -60, -70, -80]

因此，如果我們想要從list中從頭每次相隔2，印出其值，就可以寫成這樣：

1
2
3
4
5
6
7
8


>>> lt = [1, -5, 3, 2, 4, 10, 100]
>>> for i in range(0, len(lt), 2): # 從index 0開始，每次間隔2，直到len(lt)-1 (因為stop的位置不算)
... print(lt[i])
...
1
3
4
100

辛苦啦！今天的內容也相當的多，
同樣請練習一下，可別偷懶呦！
那就明天見啦！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (6) — 串列(list)、Tuple(元組)、字典(dict)、集合(set)：我的字典裡沒有放棄，因為我還沒有寫進去(下)

Mon, 21 Sep 2020 00:00:00 +0800

Day 06 串列(list)、Tuple(元組)、字典(dict)、集合(set)：我的字典裡沒有放棄，因為我還沒有寫進去(下)

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10240088/

接下來我們要介紹另外兩個資料型態：字典(dict)與集合(set)。
首先是字典：
字典跟串列有點類似的部分，
但是它的表示方式是一個鍵(key)對一個值(value)，
就好像函式一樣，一個字典裡面不會出現重覆的key，
但有可能不同key對應的value剛好一樣；
這樣一來，我們就可以用key去查找其對應的value。
需要注意的是，串列是有一個固定的順序排列的，
但字典並不會有固定排序(也就是說一般我們不在意排的順序)。

key和value可以是各種不同的型態如str, int, float, bool等等，
但是key必須要是hashable的資料型態(像list就不是hashable)，
value做為被對應的對象，則沒有這種限制。

字典的建立方式，可以用dict()方法，也可以用大括號{}，
當中每個key和value的對應使用冒號:來分隔，
而每組key:value之間，使用逗號來分開。
同時，要取得某個key對應的value值，
就像list是用index來取得對應位置的値，字典則使用dict[key]來取得。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


>>> dic0 = dict()
>>> dic0
{}
>>> dic = {'xd': 1, '放棄': False, [1,5,9]: 3} # list是unhashable，不能作為key
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
>>> dic = {'xd': 1, '放棄': False, 3.33: 3} # 這樣就沒問題啦！
>>> dic
{'xd': 1, '放棄': False, 3.33: 3}
>>> dic['XD'] # 在程式語言的世界裡，通常大小寫是當作不一樣的呦！
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
KeyError: 'XD'
>>> dic['xd'] # 取值
1
>>> dic['放棄']
False
>>> dic[3.33]
3

上篇提到list()可以拿來轉換，dict()也有類似的特異功能，
只要內容是剛好每一組都是兩項的就可以了！
(串列/tuple/剛好兩個字元的字串…)
我們看一下範例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


>>> lol = [('易大師','我的劍，就是你的劍。'),('犽宿','死亡如風，常伴吾身。'),('阿祈爾','蘇瑞瑪！你的王已經歸來了！')]
>>> diclol = dict(lol)
>>> diclol
{'易大師': '我的劍，就是你的劍。', '犽宿': '死亡如風，常伴吾身。', '阿祈爾': '蘇瑞瑪！你的王已經歸來了！'}
>>> tul = (['a','b'],['c','d'],['e','f'],['g','h']) # 裡外兩層不管是tuple或list都沒有問題！
>>> dictul = dict(tul)
>>> dictul
{'a': 'b', 'c': 'd', 'e': 'f', 'g': 'h'}
>>> chs = ['ab','cd','13'] # 兩個字元的字串會被拆開用(但超過兩個字元就不支援了)
>>> dicchs = dict(chs)
>>> dicchs
{'a': 'b', 'c': 'd', '1': '3'}

我們可以使用類似list的方式來對字典插入或修改某個key對應的value值，
如果該key已經存在在字典，則對應的value會被覆蓋，否則就產生一個新的對應。

1
2
3
4
5
6
7
8


>>> diclol['伊澤瑞爾'] = '是時候展現真正的技術了！' # 新增
>>> diclol
{'易大師': '我的劍，就是你的劍。', '犽宿': '死亡如風，常伴吾身。', '阿祈爾': '蘇瑞瑪！你的王已經歸來了！', '伊澤瑞爾': '是時候展現真正的技術了！'}
>>> dicchs
{'a': 'b', 'c': 'd', '1': '3'}
>>> dicchs['a']='XD' # 修改
>>> dicchs
{'a': 'XD', 'c': 'd', '1': '3'}

接下來是一些常見的dict操作方法，同樣請多加練習，
讀者可能會發現很多會跟list的操作概念相同，所以可以的話，請對照著比較一下。
dict1.update(dict2) -> 將dict2的內容複製後放到dict1(** key重覆時，dict2的value優先**)。
del dict1[‘key’] -> 將dict1的**’key’:’value’** 的對應從dict1中刪去**。
dict1.clear() -> ** 清空整個dict1的對應(也可以用dict1 = dict())。
‘XXX’ in dict1 -> 檢查dict1是否有’XXX’這個key。
dict1.keys() -> 給出整個dict1的** 所有key**(如果需要用list的形式表達，請用** list()將其框住)。
dict1.values() -> 同上，但給出的是所有value**。
dict1.items() -> 給出一個一個的** key:value對應**(每對都以tuple形式給出)。
dict2 = dict1.copy() -> 複製一份dict1的內容，生成一個dict2的字典。
(註：如果是用dict2 = dict1，只會讓兩者共用一個字典，修改會動到同一個呦！)

我們來看一下範例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


>>> diclol['國動'] = '社 社 社社社 社社 社會搖'
>>> diclol # 前面建立的字典
{'易大師': '我的劍，就是你的劍。', '犽宿': '死亡如風，常伴吾身。', '阿祈爾': '蘇瑞瑪！你的王已經歸來了！', '伊澤瑞爾': '是時候展現真正的技術了！', '國動': '社 社 社社社 社社 社會搖'}
>>> diclol['國動'] = '社 社 社社社 社社 社會搖'
>>> diclolfame = {'國動':'還敢下來阿冰鳥!', '統神':'他的手怎麼可以穿過我的叭叭啊！'}
>>> diclol.update(diclolfame) # 合併過去，重覆的會被覆蓋
>>> diclol
{'易大師': '我的劍，就是你的劍。', '犽宿': '死亡如風，常伴吾身。', '阿祈爾': '蘇瑞瑪！你的王已經歸來了！', '伊澤瑞爾': '是時候展現真正的技術了！', '國動': '還敢下來阿冰鳥!', '統神': '他的手怎麼可以穿
過我的叭叭啊！'}
>>> del diclol['統神'] # 刪除對應的鍵值對
>>> diclol
{'易大師': '我的劍，就是你的劍。', '犽宿': '死亡如風，常伴吾身。', '阿祈爾': '蘇瑞瑪！你的王已經歸來了！', '伊澤瑞爾': '是時候展現真正的技術了！', '國動': '還敢下來阿冰鳥!'}
>>> dicchs = {'a': 123, 'c': 428, '1': '3', 'eee': 11}
>>> dicchs
{'a': 123, 'c': 428, '1': '3', 'eee': 11}
>>> dicchs.clear() # 清空字典
>>> dicchs
{}
>>>
>>> '統神' in diclolfame
True
>>> '統神' in diclol # 我們剛剛刪除了，所以'統神'不會在diclol裡
False
>>> dicn = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> dicn
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> dicn.keys() # 取得key
dict_keys(['a', 'b', 'c', 'd'])
>>> list(dicn.keys()) # 如果需要list型式的話就外面加一層list()
['a', 'b', 'c', 'd']
>>> dicn.values()
dict_values([1, 2, 3, 4])
>>> dicn.items()
dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)])
>>> dico = dicn # 直接用等號，在字典相當於貼標籤在同一個身上
>>> dico['a'] = 'XD'
>>> dico
{'a': 'XD', 'b': 2, 'c': 3, 'd': 4}
>>> dicn # 結果原先的也一起被改到了！
{'a': 'XD', 'b': 2, 'c': 3, 'd': 4}
>>> dico = dicn.copy() # 使用copy()來處理
>>> dico['a'] = 1
>>> dico
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> dicn # 這樣dico和dicn就是兩個不一樣的字典囉！
{'a': 'XD', 'b': 2, 'c': 3, 'd': 4}

(註：在其他語言裡，通常把key:value對應的資料結構稱作hash或hash map)

接下來要講的是集合(set)。
集合不像字典，它的本身只有key而已，
每個key都必須不重覆 (就像數學學到的那樣)
要建立的方式，可以使用set()，或者使用大括號{}，
當中每個key之間使用逗號連接，要增加key則使用add()。
(同樣用大括號，集合沒有value對應的部份)
集合本身也是不講求排列順序的，這點和字典一樣。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


>>> st = set()
>> st # 因為空的大括號代表字典，所以要產生一個空集合只能使用set()，不能用{}
set()
>>> st.add(3)
>>> st
{3}
>>> st.add(3) # 重覆的增加相同的key不會對set造成影響
>>> st
{3}
>>> st.add('XD') # set中的key不一定要有相同的資料型態
>>> st
{'XD', 3}
>>> set('XDDDD') # 可以拿單一字串放入，會被拆開來看待(重覆的被刪去)
{'D', 'X'}
>>> set(['XDDDD','XD','XD','XDDD']) # list則會以元素為單位，此外，留意它並沒有順序。
{'XD', 'XDDDD', 'XDDD'}
>>> st1 = {'A', 'C', 'E'}
>>> st2 = {'B', 'C', 'A', 'D'}
>>> 'A' in st1 # 集合同樣也可以用in來檢查是否存在key
True
>>> 'e' in st1
False

既然是集合，可想而知就會有許多跟數學上集合對應的操作，
我們就直接來看範例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


>>> st1 & st2 # '&'(念作and, 代表'且'，也就是兩者皆有才算有)和intersection都是取交集
{'C', 'A'}
>>> st1.intersection(st2)
{'C', 'A'}
>>> st1 | st2 # '|'(念作or, 代表'或'，也就是兩者之一有就可以了)和union都是取聯集
{'A', 'D', 'E', 'C', 'B'}
>>> st1.union(st2)
{'A', 'D', 'E', 'C', 'B'}
>>> st1 - st2 # '-'和difference都是取差集，也就是取前者有，後者沒有
{'E'}
>>> st2 - st1
{'D', 'B'}
>>> st1.difference(st2)
{'E'}
>>> st1 ^ st2 # '^'(念作exclusive or, 代表'互斥或'，也就是只能其中一個有，另一個沒有的)和symmetric_difference(太長啦！不用記XD)都是取互斥或
{'B', 'D', 'E'}
>>> st1.symmetric_difference(st2)
{'B', 'D', 'E'}
>>> st1 <= st2 # '<='和issubset代表檢查前者是否是後者的子集
False
>>> st2 <= st1
False
>>> st1.issubset(st2)
False

其他還有一些，但有需要用到時再查對應功能即可。

最後一樣來做個練習吧！

眾所周知，李嚴和劉昴星曾經比過炸龍蝦，
請建立一個字典名為shrimp，當中
請使用兩者的作品的名字做為key ，
將其做的炸蝦所使用到的材料/內容列表list做為value ，
還未做完成的部分不算 。請參考原本對於兩人作品的描述如下：

李嚴的作品：「我的料理是炸鳳尾蝦 ，就是蝦子裹碎核果去炸的，將核果搗碎後裹在蝦肉上，油炸成為金黃色，不但要考慮核果跟蝦肉的比例，高低油溫的調節也需要高度的技術跟經驗的。鮮脆可口的核果外衣，經油炸之後，其香味立即倍增，堪稱人間第一美味，搭配特製醬汁來食用，味道更是妙不可言。跟醬汁巧妙的組合，這是這個炸蝦的精華所在。那個醬汁，那要先將蘋果，洋蔥等切成末之後，跟各種調味料以絕妙的比例互相調合。那個醬汁，再給我一分鐘我一定能完成的!」

劉昴星的作品：「炸的香酥的核果外衣，蝦肉(蝦子 )的甘甜，與順滑可口的醬汁搭配起來，真是太棒了……我在蝦肉和外衣之間，夾了豆皮封住醬汁，如此一來，就算在油鍋裡炸，醬汁也一定不會流出來。裹著一層豆皮雲的龍蝦，名字叫做小當家特製雲龍炸蝦 ！」

承1，請將兩人的材料從shrimp中取出，
分別放入兩個set中，並命名為’lee’跟’liu’。
請利用set的操作，回答以下問題：
劉昴星的作品中比李嚴的作品多用了什麼材料？
李嚴的作品中比劉昴星的作品多用了什麼材料？
兩人的作品都有用到什麼材料？
假定今天李嚴能做完醬汁的話，請將新增的材料(蘋果、洋蔥)以及內容(醬汁)，
加到lee這個set中，
接著請指出現在李嚴的作品中比劉昴星的作品多用了什麼材料？
並請將材料和內容更新回shrimp這個字典中的對應作品。
已知有一個列表lt = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]，
請利用slice及其他方法來達成以下要求：
a. 請生成一個lt1，其內容為lt的所有奇數
b. 請生成一個lt2，其內容為lt的所有偶數
c. 請將lt2的所有元素依序附加到lt1上
d. 請刪除lt1當中index 7和index 1的數
e. 請將lt1進行排序

辛苦了，這兩篇對於初學者來說應該很長，
但很基本，請多加嘗試練習，
後續使用到對應用法如果還是忘記的話，
可以再回頭看著對照。
那就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (5) — 串列(list)、Tuple(元組)、字典(dict)、集合(set)：我的字典裡沒有放棄，因為我還沒有寫進去(上)

Sun, 20 Sep 2020 00:00:00 +0800

Day 05 串列(list)、Tuple(元組)、字典(dict)、集合(set)：我的字典裡沒有放棄，因為我還沒有寫進去(上)

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。https://ithelp.ithome.com.tw/articles/10239342/

先來解答昨天的問題吧！

1. 答案如下：

1
2
3
4
5


>>> chs='abcdefghijklmnopqrstuvwxyz'
>>> print(chs[::-2]) # 從尾往頭，step為-2，不要忘記沒有寫的還是要補冒號！
zxvtrpnljhfdb
>>> print(chs[16]+chs[14]*2+' '+'有種果汁真好喝~') # 對吧XD
qoo 有種果汁真好喝~

2. 已經知道bin的前兩位表示是0b，那麼利用slice取第二位以後即可。

1
2
3
4


>>> bin(36)
'0b100100'
>>> print(bin(36)[2:])
100100

3. 只要按照順序就可以接起來囉！

1
2
3


>>> a, b, c = 'pen', 'apple', 'pine'
>>> print(a+c+b*2+a) # PPAP
penpineappleapplepen

接下來，讓我們介紹幾個比較進階的資料型態：
串列(list)、tuple(元組)、字典(dict)、集合(set)

首先是串列和tuple，
由於Tuple的稱呼(元組)翻法實在相對比較少人愛用，
因此習慣上tuple就直接叫做tuple就可以了。
你說到底要念做「禿波」(too-pull)還是「他波」(tub-pull)呢？
Guido自己講說他都隨便念沒有關系，
不過我是都念咖死口啦！

我們先講串列的部分，
所謂的串列，就是一連串的元素(單一的資料)放進一個表裡面的東西。
這個表可以沒有任何元素，也可以有很多個元素，其數量是可以被改變的。
要做出一個串列，可以使用list()，或者一組中括號[]來表示，
當然，也可以在當中用逗號分隔每個元素並在開始時直接置入：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


>>> lt = []
>>> llt = list()
>>> lt, llt # 兩個都是空的串列
([], [])
>>> lt = ['my', 'dict', 'doesn\'t', 'have', 'the', 'word', 'giving', 'up.', 9527, True]
# 一個串列裡的元素彼此不一定非得要是同樣的資料型態，這點跟C++/Java等不同
>>> print(lt)
['my', 'dict', "doesn't", 'have', 'the', 'word', 'giving', 'up.', 9527, True]
>>> ' '.join(lt) # 上一篇提到說使用join可以將串列連接，但必須要全都是字串
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: sequence item 8: expected str instance, int found
>>> ' '.join(lt[:-2]) # 串列同樣可以用slice，用法和字串的邏輯一樣，所以倒數2個被去掉後就能正常join了！
"my dict doesn't have the word giving up."
>>> (' '.join(lt[:-2])).split()　# 使用split可以將字串拆成串列
['my', 'dict', "doesn't", 'have', 'the', 'word', 'giving', 'up.']
>>> list('apple pen') # 直接對字串使用list()方法，會將每個字元拆開來變成一個串列
['a', 'p', 'p', 'l', 'e', ' ', 'p', 'e', 'n']
>>> lt[3] # 單獨給定索引值(index)，就會得到對應位置的資料(別忘了是從0開始呦！)
'have'
>>> lt[-2]
9527
>>> lt[0]
'my'
>>> lt[100] # 但是不論用正數表達或負數表達，超過的部分都不會繞一圈回來，而是會顯示錯誤
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> lt[::-1] # 同樣的，利用slice可以輕鬆做到將整個list反轉過來
[True, 9527, 'up.', 'giving', 'word', 'the', 'have', "doesn't", 'dict', 'my']
>>> lt[2] = '0800' # 指定index可以對list的對應的元素做更動
>>> lt
['my', 'dict', '0800', 'have', 'the', 'word', 'giving', 'up.', 9527, True]

接著，留意到串列中的元素既然沒有限定，那麼元素可以是另一個串列嗎?
當然可以！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


>>> lt3 = [[1, 2], [3, 4, 5], [6, 7, 9, 0], 'X', 'D'] # 有些元素是串列，有些只是單一的字元
>>> lt3[0], lt3[1], lt3[2][3], lt3[3], lt3[4] # 第二層的話就加括號和對應的index
([1, 2], [3, 4, 5], 0, 'X', 'D')
>>> lt3[4][1] # 當取得的是str時，按照規則取字串的字元，超出的話會顯示錯誤
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>> lt3[0][2] # 當取得的是list時，超出取得的list的範圍的index也會顯示錯誤
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
IndexError: list index out of range

接下來是串列常見的一些操作，請務必多加熟練，
我們先簡單敘述一下常見的操作：(以下請將lt開頭的東西當成是list)
lt.append(element) -> 將element接到lt的** 尾巴**。
lt.extend(lt2) -> 將lt2的所有elements** 依序接到lt的尾巴** (相當於** lt+=lt2**)。
lt.insert(index, element) -> 在index處插入element
(原本該位置及其後的元素都往後挪 )。
del lt[index] -> 將index處的element** 刪去**，其他element** 往前遞補**。
lt.remove(name) -> 從lt中** 搜尋符合name的element**，將其** 刪去**，
其他element往前遞補。
lt.index(name) -> 從lt中** 搜尋符合name的element**，並將其** 索引值回報**。
xx in lt -> 如果** xx這個元素在lt中的話則為True，否則為Flase。
lt.count(name) -> 計算name在lt 出現的次數**。
lt.join(sep) -> 使用join內的間隔** sep**，將lt的元素** 一個一個接起來**。
lt2 = sorted(lt) -> 將lt排序過後(按元素的順序** 由小到大**)，存放到lt2。
(lt不會受改變)
lt.sort() -> 將lt於原地排序。
len(lt) -> 取得lt的** 元素個數**。(想成取長度也行)
lt2 = lt.copy()
lt3 = list(lt) -> lt2~lt4都代表** 複製lt的所有元素並產生新的list**。
lt4 = lt[:]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40


>>> lt = [1, 3, 5]
>>> lt.append(15) # 附加一個元素到尾端
>>> lt
[1, 3, 5, 15]
>>> lt.extend([3,9, -1]) # 附加一組元素到尾端(如果這個用append的話，會將[3, 9, -1]直接當成單一元素放入)
>>> lt
[1, 3, 5, 15, 3, 9, -1]
>>> lt.insert(3, 2) # 先選位置，再給插入值
>>> lt
[1, 3, 5, 2, 15, 3, 9, -1]
>>> del lt[1] # 砍掉index位置的値，後面遞補
>>> lt
[1, 5, 2, 15, 3, 9, -1]
>>> lt.remove(3) # 砍掉對應的值的元素(找不到的話會出錯)
>>> lt
[1, 5, 2, 15, 9, -1]
>>> lt.index(9) # 找對應的値在串列的索引值
4
>>> 9 in lt # 在喊在
True
>>> 3 in lt # 不在喊不在
False
>>> lt.extend([-3, -1, 2, -1, -2])
>>> lt
[1, 5, 2, 15, 9, -1, -3, -1, 2, -1, -2]
>>> lt.count(-1) # 計算元素出現次數
3
>>> lt.count(-2)
1
>>> lt.count(2)
2
>>> lt.sort() # 原地排序
>>> lt
[-3, -2, -1, -1, -1, 1, 2, 2, 5, 9, 15]
>>> lt.extend([3, 9, -2])
>>> lt2 = sorted(lt) # 另行排序，排完放到lt2，lt不會被改變
>>> lt2
[-3, -2, -2, -1, -1, -1, 1, 2, 2, 3, 5, 9, 9, 15]
>>> len(lt2) # 取長
14

蠻多的對吧？
盡量不要死記硬背，嘗試多練習不同的操作變化看看呦！

接下來介紹tuple(元組)，
tuple可以說是固定版的串列，
一旦決定以後，它本身裡面的元素就無法被單獨修改了！
要使用tuple，我們會用小括號()，當中是空白或用逗號分隔的元素。
要留意的是，無論除非你直接將變數名稱整個指定成別的內容，
否則是無法用像tpl[1] = ‘edit’這樣的東西去修改的！
除此以外，我們也可以用多重指派的方式，
來讓每個元素接取到tuple或list的元素。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


>>> tpl = (1, 3, 'XD', '9', 123)
>>> tpl
(1, 3, 'XD', '9', 123)
>>> tpl[1]
3
>>> tpl[1] = 100
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> a, b, c, d, e = tpl # 對應五個元素，左右兩邊互相對到即可，這種方式也稱為tuple開箱(unpacking)
>>> a
1
>>> b
3
>>> c
'XD'
>>> d
'9'
>>> e
123

由於不能修改的特性，前面提到list的append/extend等方法tuple都沒有；
但是tuple有幾點好處：

占用空間較少
tuple的元素不會不小心被動到
除此之外，tuple後續也可以做為字典的輸入使用，
這點下一篇文章會提到。
其他還有一些特別的特性，之後有機會再提吧!

我們在下半段將介紹另外兩種資料型態：字典(dict)及集合(set)。

那就明天見啦！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (4) — 型態轉換及字串基礎：叫你印出來不是叫你開印表機阿！

Fri, 18 Sep 2020 00:00:00 +0800

Day 04 型態轉換及字串基礎：叫你印出來不是叫你開印表機阿！

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10238980

註：本文同步刊載在Medium，若習慣Medium的話亦可去那邊看呦！

我們先來解答一下昨天的問題。

讀者的變數名稱可以自己定義，只要答案正確即可。
(但定義的時候，盡量是能夠表達出這個變數是用來做什麼的會比較好)
第一題的內容很簡單，就是把東西放進去計算，然後print出來。
範例解如下：

1
2
3
4
5
6


>>> pi=3.14
>>> r=7.77
>>> print(2*pi*r) # 周長
48.7956
>>> print(pi*r**2) # 面積
189.57090599999998

請留意到，運算子之間有優先合併順序，這個可以Google一下會有詳盡的列表，
但簡單來說，就像小時候老師教先乘除後加減一樣，
以pi*r**2 這個式子來說，”**”這個運算子會先被優先納入計算，
所以r平方會先算完，再和左邊的pi相乘。

第二題呢？其實也只是加起來而已。

1
2
3
4
5
6
7
8


>>> pi=3.14
>>> r1=7.77
>>> r2=5.3
>>> r3=2.5
>>> print(2*pi*(r1+r2+r3))
97.7796
>>> print(pi*(r1**2+r2** 2+r3**2))
297.398506

很簡單吧！

接下來第三天的部分，我們要來談一下型態轉換及一些字串的操作。
我們昨天已經提到有一些基本常見的型態：
bool, int, float, str，
也許讀者有想到一個問題：
兩個不一樣的型態是怎麼互相轉換的呢？
比方說我們先前在除法的時候，兩個int相除，
是會產生float的(如果不使用整數除法)，
這個就是Python在這當中自動進行了型態轉換的部分。
有些時候，型態轉換則需要我們自己來操作，
比如int和float的互轉，只需要使用int()或float()即可。
我們來看一下int和float轉換的範例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


>>> float(1) # 從沒有小數點的int變成帶小數點的float
1.0
>>> int(1.0) # 很直觀XD
1
>>> int(1.6) # 咦? 不是2嗎？
1
>>> int(1.4)
1
>>> int(-1.1)
-1
>>> int(-2.1) # 所以是無條件捨棄
-2
>>> 1.5+1　# float和int相加
2.5
>>> 1+3.0 # 順序不影響
4.0

int轉換成float以後，就是多加.0在後面就對了！
float轉換成int的話，則是將小數點後面的東西全數捨棄 。
四則運算的話，int和float相遇最後結果會變成float，以求保留較多的資料。

那bool和int之間的關係呢？0會被當成偽，1會被當成真，
但是其他的數字(0以外的所有數字)也會被當成真呦！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


>>> bool(0)
False
>>> bool(1)
True
>>> bool(3)
True
>>> bool(-2)
True
>>> int(True)
1
>>> int(False)
0

int還有其他變化，
可以將其轉換成用二進位/八進位/十六進位來表達。
所謂的二進位就是每個位數只有0或1兩種數字，
超過就進一位。

舉例來說，十進位的7等於二進位的111，
因為111等於1 * 2² + 1 * 2¹ + 1 * 2⁰ = 4+2+1=7
(看不懂這段的，可以搜尋一下二進位，這邊不再贅述)
我們一般用X進位來表達數字時，稱這個X為「基數」。

在Python中如果數字用10以外的基數來表達時，
會額外做顯示上的處理：
二進位 -> 0b或0B (b代表binary)
八進位 -> 0o或0O (o代表octal)
十六進位 -> 0x或0X (x代表hexadecimal)
舉例來說：

1
2
3
4
5
6
7
8


>>> 0b10 # 2
2
>>> 0b111 # 4+2+1=7
7
>>> 0o11 # 8+1=9
9
>>> 0x1F # 16+15=31 (A~F分別代表16進位的10~15)
31

上面這些有點枯燥我明白，但請記下來，有些東西將來會用上的XD

再來談談字串(str)吧！
在Python中，一個字串的資料，是用兩個單引號或兩個雙引號括起來的，
當int, float, bool等型態要轉為str時，
Python只有做一件事情：把它們加進引號中。(真是偷懶XD)

1
2
3
4
5
6
7
8


>>> str(9)
'9'
>>> str(97.1)
'97.1'
>>> str(True)
'True'
>>> str(0o11) # 以其他基數表達的int，仍會先轉回10進位再處理
'9'

那反方向呢？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


>>> int('9')
9
>>> int('9.1') # python會跳出錯誤說：你騙我，它不是int！
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '9.1'
>>> float('9.1') # 這樣總符合了吧！
9.1
>>> bool('3')　# 因為是0以外的東西，所以會是True
True

講到這裡，讀者可能會有疑問：
「前面講過print可以將東西印出來，
那我如果要印出字串，但裡面含單引號或雙引號呢？」
問的好！
由於有些特殊字元如單引號，雙引號等會有被拿去用的困擾，
所以當遇到會有特殊含義的字元，
或者要將特定字元轉換用途時，我們可以使用一個反斜線()，
將原先的含義給轉換。
這邊請留意一下，在一般大多數的程式語言來說，
印出(print)通常代表把一些內容，輸出到螢幕上，
可能是程式的命令提示字元，或者別的東西，
但不是印表機！！！
請不要問為什麼我家沒有印表機筆者卻要你印出東西來的問題XD

比如我們想印出’We will rock you!’ (連同單引號)，
那麼，我們可以這樣子：

1
2


>>> print('\'We will rock you!\'') # 外層的單引號仍然是用來表達字串的開頭跟結尾，但內層的單引號被轉義回一般無特殊含義的單引號
'We will rock you!'

其他還有一些常用的轉義字元，但最常用的就是”\n”了，
可以用來做換行的效果！
舉例來說：

1
2
3


>>> print('天青色等煙雨 而我在等你\n炊煙裊裊升起 隔江千萬里')
天青色等煙雨 而我在等你
炊煙裊裊升起 隔江千萬里

你要多換幾行？那就多打幾個\n吧！
想同時印出多個字串的話，可以用逗號來連接，Python會幫忙在中間加空格。

1
2
3


>>> print('I\n','feel','good') # 即便換行，feel前面還是有一格空格
I
 feel good

再來談談Python中字串的一些常見的操作：
+結合、*複製、[]取字元、[start:end:step]切片、len()取長、split()分割、join()結合
以下是範例：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


>>> 'a'+'b'+'c' # 相加就是串在一起就對了！
'abc'
>>> 'apple'*2 # 乘上的正整數相當於重複的次數
'appleapple'
>>> a = 'apple'
>>> a[3] # 取第3位(從0起算)
'l'
>>> a[0:4:1] # 切片slice: 從0開始，到4結束，每次跳1單位
'appl'
>>> a[0:4:2] # 切片slice: 從0開始，到4結束，每次跳2單位
'ap'
>>> len(a) # 取長度
5
>>> len(a[0:4:1]) # 剛剛切出的長度是4
4
>>> b = 'An apple a day, keeps the doctor away.'
>>> b.split() # 用括號內的字串來分割，預設是空白字元(換行/空格/位移tab)
['An', 'apple', 'a', 'day,', 'keeps', 'the', 'doctor', 'away.']
>>> b.split(',') # 用逗號來分割(留意用來分割的東西會不見)
['An apple a day', ' keeps the doctor away.']
>>> b.split('.') # 因為.的右邊沒東西，所以會多一個空字串
['An apple a day, keeps the doctor away', '']
>>> c = b.split()
>>> c
['An', 'apple', 'a', 'day,', 'keeps', 'the', 'doctor', 'away.']
>>> d = '\n'.join(c) # '字串'.join(要被接起來的串列)
>>> d
'An\napple\na\nday,\nkeeps\nthe\ndoctor\naway.'
>>> print(d) # 印出來的時候就知道\n是拿來換行了！
An
apple
a
day,
keeps
the
doctor
away.

程式碼內的註解應該足夠清楚，除了有幾點需要補充說明。
首先留意到a[3]，在單獨中括號加上單一數字時，
代表從頭開始數到索引值(index)為3的地方，取出那個字元。
注意歐！這個算法中是從0開始數的！
也就是’apple’中的’a’是a[0]，請讀者務必記得從0開始！
就算沒有在異世界生活也一樣XD

接著看到**[start:end:step]的切片部分，
它代表著我們可以用定好的規則來取出字串的片段。
其中：
start表示開始的位置；
end表示結束的位置，但是不含end這個位置；
step代表每次移動多少單位。
比方說剛剛的a[0:4:1]，
就是從0開始，到4結束，每次移動1單位，但因為不包含4，
所以只會取到’appl’。
在step為正的情況下，start不寫的話，預設代表從0開始，
而step不寫的話，預設代表每次移動1單位；
所以a[0:4:1]也可以寫成a[:4:1]或者a[:4]** ，讀者可以嘗試看看。
同理，end不寫的話代表預設到結束(包含尾端)，
所以如**a[1:]就會是’pple’**。

此外，slice還有特異功能：當step是負數 的時候，
前面不寫則代表預設從字串尾往字串頭走，
所以如a[::-1]會是’elppa’，相當於將a反轉 ；
而a[4:1:-1]則是’elp’ 。

而當start或end是負數的時候，
Python會將負數視作從尾往頭起算，如-1代表倒數第1個字元。
例如a[-2:0:-1]會是’lpp’ 。

最後留意到split()作用過後，
會產生一個用中括號框起來，及逗號分隔的東西，
我們將其稱為list(串列，或稱列表) ，在接下來的文章中我們會介紹到它，
現在只需要知道，它就是一連串列出來的東西即可：
split會按照分割的字串將目標字串給切分開成列表；
join則會使用給定的字串將一個列表的所有東西按順序連接起來。

好的，最後我們來做個練習吧！

給定字串chs = ‘abcdefghijklmnopqrstuvwxyz’，請印出：
1.1. 從z起算往回頭走，每次step為-2的字串
1.2. 將索引值為16的字元，加上(索引值為14的字元重復2次)，
並用一個空格將前者和字串’有種果汁真好喝~’連接起來。
已知bin()的方法可以將一個int值用二進位表示並轉為字串，
請嘗試給出36的二進位字串，但須去除’0b’的部分。
給定a, b, c = ‘pen’, ‘apple’, ‘pine’ ，
(註：沒錯，你可以在一行同時生成多個變數，使用逗號隔開即可)
請用a, b, c組合出’penpineappleapplepen’。

那就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (1) — 緒論：寫在前面

Thu, 17 Sep 2020 00:00:00 +0800

Day 01 緒論：寫在前面

為了方便大家閱讀，這個系列也存成Medium的list囉！https://desolve.medium.com/list/python-6f7985967b68

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。https://ithelp.ithome.com.tw/articles/10237408

一年又過去啦！
不曉得各位過得如何呢？
在寫了從LeetCode學演算法系列文章後，
Medium上，
陸續也寫滿了百篇(現在是105篇)的LeetCode系列的教學文章，
也有出了兩門從LeetCode學演算法的教學課程。
但想轉職的學生依舊很多，卻常常不得其門而入，
從發問的同學來看，主要還是因為轉職時找不到一個好的入門途徑。

對一個想入門程式語言的人來說，也許會有很多弄不懂的問題：

我想學寫前端網頁，那我該從JavaScript開始嗎？
CSS要不要會？要不要先懂一些HTML5的語法？
我該用Vue, React, Angular還是什麼東西？
看了一個範例寫購物車，要碰到資料庫，我是不是該碰一些後端？

我想學後端，我該學什麼？
SQL?NoSQL?該用什麼程式？該安裝什麼套件？
我要做一個作品，呈現是不是要弄一個網頁？那我是不是該學一些前端？

我想寫手機程式，該選Android還是iOS的系統？
App層更下面的東西，我該知道嗎？要知道的多深？

我想寫一般程式，我該選Java/C++/C#/Python中的哪一個？
(僅舉例，沒被列到的別生氣XD)
怎樣應用？怎樣寫出視窗程式？

最後，為什麼每個上來都寫Hello World?

入門者最大的問題，就是選項很多，
但他/她不知道這些選項代表什麼，也不知道選擇以後，
該從哪邊開始起步。

這就是這個系列文章的目的，
筆者會嘗試以自己的觀點來表述，
在眾多程式語言中，Python這個選項的優缺點，
帶你學過一遍Python初學所需知道的東西並練習，
並且指一條Python可能的發展路線給你。

由於一個人的思慮總有疏漏的時候，
若文章中有不理解或者筆誤/不小心講錯的時候，
歡迎告訴筆者，筆者會再進行修改。

除此以外，以下是本系列文章的閱讀重點：
1. 只會列一到兩個選項給你
做一件事情的方法有很多種，學Python也是，
如果每個可能性都要列出來，對讀者來說太累了(對筆者也是XD)，
在一般狀況下，筆者會只列一至兩種操作/撰寫方式，
其他的變化或者選項，有興趣的讀者可以再自行深入研究。

2. 盡量用容易解釋的方式，整組打包
每一個函式都有它的用法，
筆者會盡量將其變得較易理解，
在避免太多定義的狀態下，
將能組在一起的函式形成一起的範例來解釋。

3. 練習範例及題目
文章中的練習範例，請務必自行打一遍並執行成功才算數(不是複製貼上！)
如果有練習的題目的話，會在隔天給出解答，
但希望讀者當天就嘗試自己做出來，再來看答案呦！

4. 前導知識及配備
雖然本文不預設讀者有學過程式語言，
但仍希望讀者能擁有一台可以上網的電腦，
以及起碼會下載軟體並安裝。
(恩…就是Next->Next->……->Finished/Done)

5. Python適合的讀者
如果你想當前端工程師 ->
Python+Flask可以做，但主流是JavaScript的系列框架，
請找Web前端相關語言的學習資源，本篇不適合你 。

如果你想當後端工程師 ->
Python+MongoDB或其他資料庫(NoSQL/SQL的都有)可以做 ，
其他常見的如Java, Golang, Node.js等也都可以做，
所以你可以先看你將來想要找哪些公司的職缺，
再看看他們要的是否為Python後端。

如果你想當韌體工程師 ->
通常這都是C/C++的工作，本篇不適合你 。

如果你想當App工程師 ->
通常這都是Kotlin/Swift的工作，最多加上比較偷懶的React Native，
或是用Unity3D之類的軟體撰寫，本篇不適合你 。

如果你想當網頁爬蟲工程師 ->
Python有相關的好用的模組 可以使用，
你可以從本篇開始入門基礎，同時可能需要會一些HTML的基礎。
(通常這會跟大數據/輿情分析有關)

如果你想當AI/機器學習/深度學習工程師 ->
雖然也有Java/C++的框架，
但目前最主流的就是Python 了！
你可以從本篇開始入門基礎，
接下來學習Tensorflow/Keras/PyTorch等深度學習框架，
本篇後面有篇幅的話，會再推薦一些適合的學習資源。

歡迎來到Python的世界，
接下來一個月就讓我們一起加油吧！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (2) — 語言起源及安裝使用：偉大的東西常常是無心插柳柳橙汁

Thu, 17 Sep 2020 00:00:00 +0800

Day 02 語言起源及安裝使用：偉大的東西常常是無心插柳柳橙汁

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。https://ithelp.ithome.com.tw/articles/10237509

第二天的文章，我們來介紹Python的起源和基礎安裝流程。

Python的創始人是吉多·范羅蘇姆(Guido van Rossum)，
在1989年聖誕節打發時間開發出來的。
後續經過一連串的發展，有興趣的可以Google一下，
我們只需要知道幾個最簡單的點：

主流版本有分Python 2.x和Python 3.x，
但Python 2.x系列目前已經不再維護，
所以如果沒有特別需求(例如使用先前別人用Python 2寫的程式)，
直接選擇最新的Python 3.x版本 即可。
Python的開發演進標準是根據PEP系列 (Python Enhancement Proposals)
一般而言，透過開發社群討論提議後，
納入PEP的S系列(Standards Track PEP)匯總，
最後再進行必要的修改/做出新功能並演進更新。
這中間有可能出現吵不出個結果的狀況，
這時候需要BDFL(仁慈的獨裁者) 來做最後裁決，
首位的仁慈的獨裁者即為Guido本人。
可想而知，這個壓力有點太大了XD
畢竟每次跳出來喊:
「你們不要打了，要打去練舞室打！」
也是很累的，還要擔心自己撞上砲口QQ
所以Guido後來在2018講說不幹啦！

接著我們來介紹一下怎麼安裝Python吧！

如果是Windows作業系統的話，請至
https://www.python.org/downloads/windows/
以撰寫當日來說最後一次的release為3.8.5
(Latest Python 3 Release — Python 3.8.5)

接著往下拉到底端，如果你的電腦是64位元就請選”x86–64"的選項，
否則請選”x86"的選項。
如果讀者使用Mac或Linux，就請依照各自對應的版本做下載。

下載完成後打開進行安裝，將”Add Python 3.8 to PATH”打勾後，
選擇”Customize installation”。

-> Next

-> 將Install for all users及Precompile standard library都打勾，
並將安裝路徑選擇一個你記得住的名字。
(一般會選在Program Files底下，讀者自訂也可)

-> 允許UAC給權限後，進行安裝

安裝完畢後(Close結束)，
我們應該要能在命令提示字元下找到Python，先打開命令提示字元：
(Win Key + R -> 輸入cmd後Enter)

(或者按開始，在搜尋列打cmd後按Enter鍵)

好啦，我知道這條很長XD

在命令提示字元打入”python -V”，正常的話，
應該會顯示我們剛剛安裝的版本。(3.8.5)

在這個模式下輸入”python”，
可以進入直譯器(REPL Read-Eval-Print-Loop，或稱Python Shell)，
輸入指令或運算會在運算的同時將結果輸出到螢幕上。
(但是一旦離開，所有記錄就會消失了)

輸入”python [檔名]”的話，會嘗試將該檔案做為python的程式碼執行，
通常我們會將副檔名命名為.py
假設我們在現在這個資料夾有一個fromzero.py如下：

那麼，在命令提示字元輸入”python fromzero.py”，
其結果如下：

讀者可以照著試打出來，中文想印出的部分可自己亂打沒關係XD
簡單解釋這當中發生什麼事情：
執行一段程式的順序是由第一行一路往下走到最後一行，
所以我們會先看到有一個a，一個b，分別被設定為10跟5，
然後被print(a * b)印出來，
也就是先將結果算出來，再輸出到螢幕上，於是得到50。
第四行則是將前面一串字印出來以後，串接上a和b相乘的結果，
str()的目的，則是將a和b算出來的數字轉換成字串，
這樣才能和前面的字串進行串接。

初學者可能還不太懂，沒關係，我們後面會再慢慢解釋XD

那就明天見啦！

註：
對一般人來說，可能命令提示字元並不是很友善，
因此，建議讀者可以另行安裝IDE來處理，
能夠得到更多方便的提示，操作也比較容易上手。
常見的如PyCharm 或VSCode 均可，安裝部分Google一下應該不會太困難，
這邊就不再贅述了。
或者，讀者想直接在線上作業也可以，
可以使用如 https://repl.it/ 之類的平台即可。

後續的文章中，將預設使用者是使用自己的文字編輯器，
如Notepad++/VSCode/PyCharm/Vim/Atom/ …等，
把程式碼完成後，使用**”python xxx.py”** 的形式來執行。

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode

從零開始學Python (3) — 變數、型態、運算子：你的除法不是你的除法

Thu, 17 Sep 2020 00:00:00 +0800

Day 03 變數、型態、運算子：你的除法不是你的除法

註：本篇文章同步刊載於iT邦幫忙，為鐵人賽之系列文章。
https://ithelp.ithome.com.tw/articles/10237877

從前從前，有個聰明的小男孩叫高斯，
有天老師有事情要忙，出了一道算術題給全班慢慢寫：
1+2+3+…+100 = ?
誰知道高斯馬上就將這個題目用簡單的乘法給迅速算出來了，
答案是(1+100) * 100 / 2 = 5050。

*這告訴我們，做人不要太白目XD *

以下我們使用上一篇文章的直譯器，來試看看Python的計算。
在Python中的四則運算，基本上跟我們所認知的四則運算大部分相同，
那麼，要在Python中計算上面的式子的話，也許你會想這樣寫：

1
2


>>> (1+100) * 100 / 2
5050.0

咦？為什麼多一個小數點呢？
事實上，Python中在計算加減乘除的時候，只有除法比較特別，
當使用單斜線的除法時，計算結果會預設帶有小數點，
這種「型態」和原先的整數不同，
在Python中整數稱作int，而帶小數點的數字則稱為float。
所以說，你的除法不是你的除法XD
要取得相除的整數，請使用雙斜線：

1
2


>>> (1+100) * 100 // 2
5050

留意如果這當中你使用了帶小數點的數字，即便使用雙斜線，仍然會得到float的結果。

1
2


>>> (1+100) * 100 // 2.0
5050.0

(註：和Python不同，其他如Java/C++等語言，單斜線反而是取整數)

一般Python常見運算方式，除了加減乘除和整數除法外，
還有幾個常見的如**% (取餘數運算子，如5 % 2會得到1)**
\ (取冪次，如a\b會得到a的b次方)
以及其他很多有的沒有的東西，以後我們有機會用到的時候再行介紹XD

剛剛提到了型態(type) ，在Python中每個資料都有其型態，
用來表明它是什麼種類的東西，我們可以使用type() 的方法，
簡單列出一些常見的型態：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


>>> type(10.0) # 浮點數
<class ‘float’>
>>> type(10) # 整數
<class ‘int’>
>>> type(‘25’) # 字串，可以用兩個單引號或兩個雙引號括住
<class ‘str’>
>>> type(True) # 布林值，只分成True(真)或False(偽)
<class ‘bool’>
>>> type(False)
<class ‘bool’>
>>> type(None) # None，代表什麼都沒有，通常發生在東西不存在時
<class ‘NoneType’>

回到我們的1加到100，
上面的公式我們知道，在國小的時候通常被稱為梯形公式 ：
(上底 + 下底) * 高 / 2
在1加到100中，由於下底和高相同，所以才會都是100，
那麼今天如果連續要算不同的梯形面積呢？每次重複寫好像有一點點麻煩，
這時候我們可以先將這三個不同的東西寫成「變數」。
所謂的變數就是會變的數(廢話)
讀者可以想像成一個箱子，這個箱子將用來存放資料，
並且為了知道我們在找哪個箱子，我們會為它貼上標籤並取名。

舉例來說：

1
2
3
4
5


>>> top = 1
>>> bottom = 100
>>> h = 100
>>> (top + bottom) * h // 2
5050

「變數名稱 = 值」的意義是將等號右邊的值(也可以是運算式)，
存放到貼有等號左邊標籤的箱子中。它並不是我們數學中的兩者相等
讀者可以嘗試，如果這時候將bottom改變的話，計算結果應該也會改變：

1
2
3
4
5
6
7
8


>>> bottom = 200
>>> (top + bottom) * h // 2
10050
>>> type(bottom) # type()的方法也可以拿來看變數
<class ‘int’>
>>> bottom = “XD” # 改動bottom的值並不會受限於原先的型態 (對了，井字號是註解，包含它及其身後的整行都不會被執行到喲！)
>>> print(bottom)
XD

請讀者留意，前面執行bottom=100時，
我們生成了一個名為bottom的變數，
後面執行到bottom=200時，則是生成另一個變數，
再將bottom這個標籤貼到上面去。
在Python中更動內容這件事情相對來說十分自由，
即便現在bottom是整數，
你仍然可以透過前面的賦值來改變成別的東西。(因為這是新的東西)
(如上面最後就改成字串了)

同時，當我們將兩個變數用等號相連時，
只相當於將標籤名稱貼到同一個箱子上。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


>>> a = 10
>>> b = a
>>> b # 直譯器中直接打變數名字，可以將其輸出到螢幕上
10
>>> id(a) # id()方法，可以將一個變數所存放在的記憶體(就是存箱子的空間)位置印出來
140733754578720
>>> id(b) # 看吧！兩個一模一樣
140733754578720
>>> a = 123 # a的標籤從…..720的位置拔掉，貼到存放有123的新箱子
>>> id(a)
140733754582496
>>> id(b) # b的標籤還在原地
140733754578720
>>> b # b不改變
10

講到這邊好像有點多吼？會不會難消化呢？
再加一點點就為今天做個收尾吧！
我們剛剛學到了變數、型態、及運算子，
假設你是班代，要幫系上同學訂書收錢，跟小明收300，跟小華收500……
這時候，你希望有一個變數能夠儲存收款的狀況。
對於第一筆款項也許你會這樣寫：

1
2
3
4


>>> total = 0
>>> total = total + 300
>>> total
300

但太麻煩了，你要寫兩次total，有沒有簡單一點的寫法呢？
有的，那就是「+=」。a += b的效果，等同於a = a + b。

1
2
3


>>> total += 500
>>> total
800

假定你收完了錢，廠商跟你說我們這次沒有特價了，
所以書錢變為兩倍(WTF?)：

1
2
3


>>> total *= 2 # 總共應收款項，只好再去討錢囉！a *= b 和 a = a * b相同
>>> total
1600

上面這類型的運算子稱之為指定運算子 ，
可以達到省略多寫一次第一個變數的目的，看起來比較簡潔。
+=, -=, \*=, /=, //= …… 讀者可以自行運用。
特別強調，a = a + b的意義，
是將a + b算完後，置入到貼有a標籤的箱子，
請不要將其當成一般數學意義的等號來看待。

我們來做個練習吧！

假設圓周率為3.14，一個圓的半徑是7.77
請用上面的所學及print()方法，
在直譯器中印出該圓的周長和面積。
(註：print()內可以放計算式子呦！)
承1，如果有另外兩個圓的半徑分別是5.3和2.5，
請計算出這三個圓的周長的和和總面積。

那就明天見囉！

工商時間：

期限嘛…就延長到滿人數吧XDD (不然也沒辦法哈哈)

「從Leetcode學演算法」全套(基礎/進階/面試篇)同捆優惠：
https://bit.ly/allleetcode