跳至主要内容

8 篇文章 含有標籤「Web Backend」

檢視所有標籤

如何在 Windows 打造 Python 開發環境設定基礎入門教學

· 閱讀時間約 13 分鐘

如何設定開發環境應該是每個初學程式設計者的痛(即便是老手有時也會覺得苦惱),尤其當你需要在終端機(terminal)輸入指令(command)來操控你的指令時(好吧,若你完全只走圖形化介面,習慣 GUI 操作就另當別論,但若你有志於往程式設計領域發展,建議還是熟悉一下指令碼)。

要在 LinuxMac OS 這種屬於類 Unix 系統(指各種 Unix 的衍生系統,而 Unix 指的是一種電腦作業系統,具有多工、多使用者的特色,是許多作業系統的父親)上打造 Python 開發環境相對容易,但當你使用 Windows 作業系統並希望在終端機下指令操作或開發應用程式時,往往受限於環境而產生許多困難和誤踩地雷。因此,接下來本文將教大家如何在 Windows 打造屬於自己的 Python 開發環境(包含一般 Winodows 安裝和使用虛擬機在 Windows 環境下建立 Linux/Ubuntu 作業系統,開發 Python 程式一般建議使用 Linux/Ubuntu 環境避免環境設定除錯困擾)!

開始建置 Python 開發環境

所謂工欲善其事,必先利其器,在開始之前我們必須先建置相關的開發環境,讓自己從麻瓜(不會寫程式的人)變成擁有程式魔力的魔法師。以下介紹我們在接下來開發 Python Web 應用程式所需要安裝的開發環境工具(強烈建議使用 Virtual Box 虛擬機搭配 Linux/Ubuntu 環境,若你真的很想使用 Windows 環境就繼續往下看吧!)。

  1. Microsoft VSCode 編輯器 Microsoft VSCode 是 Microsoft 推出的編輯器(非整合開發環境 IDE),夾帶著 Microsoft 過去打造 Visual studio 整合開發環境的豐富經驗,相比 Sublime Text 和其他編輯器,VSCode 的優勢在於開源且活躍的開發社群、內建 debugger 框架、原生 Git 整合、套件整合容易等特性。綜合以上幾點,對於初學者來說 VSCode 是一個蠻適合入門的開發環境。它的安裝方式也十分簡易,在官網下載後按照指示安裝完成即可,下載完成後可以打開看看。

    title: 如何在 Windows 打造 Python 開發環境設定

    我們可以點選左邊 icon 欄的第五個(長得像正方形拼圖),安裝 Python 語法和格式檢查的相關套件幫助除錯(搜尋 Python),選擇 Python 並點選 install 安裝:

    title: 如何在 Windows 打造 Python 開發環境設定

    你也可以於檔案(file)-> 開啟(open)打開你在電腦中已經準備好的專案資料夾,同時也可以在資料夾中新增檔案,我們之後的程式也會希望在建立好的專案資料夾中進行開發。這邊我們建立一個 hello.py 的檔案並印出 hello 訊息。

    print('hello python')
  2. 終端機環境(iTterm/內建 terminal) terminal(終端機)是我們下指令的地方,許多時候我們進行程式開發時不會使用 GUI 圖形化介面而是使用下指令方式請電腦做相對應的行為(記得寫程式就是下指令請電腦做事情!)。在 Linux 和 Mac 裡面都有內建的 terminal 的應用程式,以下為 MacOS 的 iTerm2 終端機下指令示意圖(iTerm2 中 $ 為提示字元,不用輸入):

    title: 如何在 Windows 打造 Python 開發環境設定

    使用 Windows 讀者可以使用 Cmder 這個軟體當做終端機環境。

    title: 如何在 Windows 打造 Python 開發環境設定

    比起 Winodws 內建的命令列 CMD,cmder 更貼近 Unix 的命令列指令碼:

    title: 如何在 Windows 打造 Python 開發環境設定

    首先到 Cmder 官網先安裝 Cmder Full 版本(含 git),安裝完成後解壓縮資料夾到桌面,執行裡面的 cmder.exe 檔案即可。

    title: 如何在 Windows 打造 Python 開發環境設定

    Cmder 預設是 λ,如果不習慣可以改成 Mac / Linux 環境下的 $,具體流程請參考這份文件

    title: 如何在 Windows 打造 Python 開發環境設定

    對於有志於從事程式開發相關工作的讀者建議可以多熟悉指令碼的輸入,更多指令碼可以參考鳥哥撰寫的 Linux 基本指令介紹Linux 學習資源

    以下是常用指令
    # 移動到桌面
    cd \Users\XXXX\Desktop
    # 列出資料夾下檔案
    ls
    # 刪除檔案
    rm 檔名
    # 複製檔案
    cp 檔名
  3. Git 版本控制系統/註冊 GitHub 帳戶 Git 是一種分散式版本控制系統,可以讓我們可以更方便地管理我們的程式碼。在網路上有非常多優秀的 Git 教學文件(連猴子都能懂的Git入門指南寫給大家的 Git 教學初心者 Git 上手攻略)。安裝 Git 方式是到官網下載軟體,依照指示安裝(若您使用 Cmder 的完整安裝 Download Full 的版本就不用安裝 git,因為已經幫你安裝好了)。

    title: 如何在 Windows 打造 Python 開發環境設定

    互動式語法學習:

    title: 如何在 Windows 打造 Python 開發環境設定

    在介紹完 git 之後我們來了解一下 GitHub。GitHub 是一個可以存放 git 程式碼專案的平台,透過 GitHub 我們可以接觸到最新的開放原始碼資訊,也可以將我們的程式碼開源出來。

    title: 如何在 Windows 打造 Python 開發環境設定

    從 GitHub 上複製程式碼

    # 複製一份到本地端
    $ git clone https://github.com/happycoderorg/python101.git
    # 移動到資料夾
    $ cd python101

    常見 Git 指令:

    # 初始化專案
    $ git init
    # 查看狀態
    $ git status
    # 檢查差異
    $ git diff
    # 將變更檔案放入暫存區
    $ git add index.py
    # 使用 commit -m 提交變更
    $ git -a -m 'init commit'
    # 查看歷史
    $ git log
    # 放棄已經 commit 的檔案重回暫存區
    $ git reset HEAD index.py
    # 放棄檔案變更
    $ git checkout index.py
  4. Anaconda Python3 版本 Anaconda 是一個 all-in-one 的 Python 開發環境,對於初學者來說是個十分合適的開發環境包。Anaconda 具備了幾項特點:

    • 便於安裝許多流行的科學、數學、工程、資料分析的 Python 模組
    • 免費並支援跨平台:Linux、Windows、Mac
    • 內建 Spyder 編輯器和 Jupyter Notebook 環境
    • 方便建立不同的虛擬開發環境

    安裝流程也十分簡單,進入 Anaconda 首頁,選擇對應作業系統(這邊使用 Windows)和是屬於 64 還是 32 位元: title: 如何在 Windows 打造 Python 開發環境設定

    Windows10 可以在系統看到位元資訊; title: 如何在 Windows 打造 Python 開發環境設定

    Windows7 可以在控制台->系統與安全->系統觀看作業系統位元資訊: title: 如何在 Windows 打造 Python 開發環境設定

    選擇對應 Python 版本下載(這裡選擇 Python3 以上版本),我們使用 Graphical Installer(圖像介面安裝方式),接著在下載完成時按照預設的安裝方式完成安裝; title: 如何在 Windows 打造 Python 開發環境設定

    記得安裝時要注意建議在安裝 anaconda 時勾選把環境變數加入(path environment variable),這樣在使用 cmder 時使用 conda 相關指令才不會出現錯誤,若一開始沒有勾選的話建議解除安裝後再重新安裝 anaconda 勾選加入環境變數。

    title: 如何在 Windows 打造 Python 開發環境設定

    若是完整安裝成功,可以打開 Cmder 終端機輸入,若是顯示 Python 3.6.0 :: Anaconda 4.3.0 (x86_64) 版本號即安裝成功(若沒成功可能要檢查一下是不是環境變數路徑的問題):

    $ python -V
    Python 3.6.0 :: Anaconda 4.3.0 (x86_64)

    接著要建立我們專案虛擬環境,這樣在安裝操作套件時比較不容易被污染到 root 全域的環境(因為你可能會有很多專案,專案使用的套件不盡相同,正式上線時只要把相關套件資訊透過 pip freeze > requirements.txt 存起來,然後在正式上線的伺服器安裝 pip install -r requirements.txt 即可),啟動後會出現(套件名稱)的提示字元:

    顯示目前虛擬環境列表
    conda info -e
    創建虛擬環境
    conda create -n 套件名稱 python=3.6
    進入虛擬環境(若是非 Windows cmder 環境加 source 於開頭) ,成功後提示字元變成:(套件名稱)$
    activate 虛擬環境名稱
    離開虛擬環境(若是非 Windows cmder 環境加 source 於開頭)
    deactivate

建立虛擬環境(virtual environment)

接著我們正式來建立一個 Python 的專案,打開終端機移動到桌面,建立專案資料夾(在輸入指令時可以使用 tab 自動補完指令)

# 移動到桌面
cd \Users\XXXX\Desktop
# 建立資料夾
mkdir python_examples
# 移動到資料夾
cd python_examples

建立獨立虛擬環境,並進入虛擬環境:

# 創立虛擬環境
conda create -n python_examples_venv python
# 啟動虛擬環境
activate python_examples_venv

成功進入虛擬環境後(會出現小括號 python_examples_venv)代表已經進入虛擬環境,即可以在裡面執行 Python 程式並安裝相關套件於該虛擬環境下:

# 安裝 django web 框架套件
pip install django
# 執行 python 檔案
python hello.py

事實上,在 Python3 中還有另外兩種建立虛擬開發環境的方式,包括使用 Python 內建工具:

# 使用 Python3 內建工具建立名為 example_venv 的虛擬開發環境
python -m venv example_venv

使用 virtualenv,和 anaconda 不同的是 virtualenv 會在建立虛擬環境的專案資料夾下建立一個資料夾裡面放虛擬環境的東西:

# 先安裝 virtualenv
pip install virtualenv
# 使用 virtualenv 產生一個名為 example_venv 的
virtualenv example_venv
# 移動到 example_venv 的外面資料夾,執行進入虛擬環境
example_venv\Scripts\activate
# 安裝 django web 框架套件到虛擬環境中(只會安裝在該虛擬環境中)
pip install django

整合在一起:在 Windows 撰寫你的第一個 Python 程式

確認安裝好以下工具後,我們就可以開始撰寫你的第一個 Python 程式

  1. 安裝 Microsoft VSCode
  2. 安裝 Cmder
  3. 安裝 Anaconda(記得勾選加入環境變數)
  4. 安裝 virtualenv (在終端機使用:pip install virtualenv 安裝)
  5. 在桌面創建一個 python_example 資料夾,打開 Microsoft VSCode 後開啟該專案資料夾,創建一個 hello.py 的檔案並在裡面打上 print('hello python!!')
  6. 打開 cmder 終端機 cd 移動到 hello.py 所在資料夾
  7. 執行 python hello.py,恭喜你完成第一個 Python 程式!

在 Windows 上安裝 Linux/Ubuntu

  1. 安裝 VirtualBox 對應版本虛擬機(這邊安裝 Windows 版本,若你是 Mac 想嘗試 Linux 也可以安裝 Mac 版本),下載完按照步驟安裝完成

    title: 如何在 Windows 打造 Python 開發環境設定

  2. 官網下載 Linux/Ubuntu 光碟映像檔案,請根據電腦位元架構選擇最新桌面穩定版本 16.04 LTS(for windows)

    title: 如何在 Windows 打造 Python 開發環境設定

  3. 建立 Linux Ubuntu 虛擬機,可以參考這篇 VirtualBox 虛擬機器安裝 Ubuntu 設定教學,設定一下名稱、作業系統類型和版本,欲分配給虛擬的記憶體大小(建議調整為大約實體記憶體的 1/3,舉例來說你有 30G 記憶體,可以分配 10G 給虛擬機)。接著選擇立即建立虛擬硬碟、VDI (VirtualBox 磁碟映像)、動態配置硬碟大小不會造成浪費(虛擬硬碟容量建議 30G 以上)。

    title: 如何在 Windows 打造 Python 開發環境設定

  4. 選擇建立好的虛擬機並選設定值按鈕,選擇存放位置選項,控制器中選擇虛擬 CD/DVD 檔案選擇剛剛從官網下載下來的檔案,確定後接著選擇虛擬機並啟動,接下來選擇安裝 Linux/Ubuntu,選擇立即安裝和預設值,需要一段時間安裝和設定(中間會有語言相關的選擇和密碼設定)

    title: 如何在 Windows 打造 Python 開發環境設定

  5. 啟動使用 Linux/Ubuntu,按照上面教學安裝 Microsoft VSCode 編輯器,安裝 Anaconda,建立第一個 Python 檔案、打開終端機(termical)安裝 ,執行 Python 程式

    title: 如何在 Windows 打造 Python 開發環境設定

網路上也有許多相關參考教學文章:VirtualBox 5.2安裝Ubuntu 16.04 相關教學VirtualBox 虛擬機器安裝 Ubuntu 設定教學

若是螢幕太小可以在上排選單中選擇:裝置->插入 Guest Additions CD 映像...->執行->重開虛擬機->可以調整大小

整合在一起:用 Linux 撰寫你的第一個 Python 程式

確認安裝好以下工具後,我們就可以開始撰寫你的第一個 Python 程式

  1. 進入虛擬機的 Linux/Ubuntu
  2. 安裝 Microsoft VSCode
  3. 安裝 Anaconda(記得勾選加入環境變數)
  4. 安裝 virtualenv (在終端機使用:pip install virtualenv 安裝)
  5. 在桌面創建一個 python_example 資料夾,打開 Microsoft VSCode 後開啟該專案資料夾,創建一個 hello.py 的檔案並在裡面打上 print('hello python!!')
  6. 打開 terminal 終端機 cd 移動到 hello.py 所在資料夾
  7. 執行 python hello.py,恭喜你完成第一個 Python 程式!

總結

如何設定開發環境應該是每個初學程式設計者的痛(強烈建議使用 Virtual Box 虛擬機搭配 Linux/Ubuntu 環境),以上介紹了如何在 Windows 打造 Python 開發環境設定,請讀者務必照著自己的電腦作業系統環境安裝一次,當然若你有志於往程式設計領域發展,也要熟悉一下指令碼操作。

參考文件

  1. VirtualBox 5.2安裝Ubuntu 16.04
  2. Create virtual environments for python with conda
  3. conda vs. pip vs. virtualenv
  4. Anacodna之conda VS Virtualenv VS Python 3 venv 对比使用教程,创建虚拟环境
  5. 命令列指令碼查詢

(image via githubusercontentwebsiteoptimizationytimgytimgostechnix

用 Python 自學程式設計:list、tuple、dict and set

· 閱讀時間約 6 分鐘

Python 自學程式設計:程式設計思維入門

Markdown 是一種輕量級的標記語言,最初為 John Gruber 所設計。Markdown 特色在於允許人們「使用易讀易寫的純文字格式編寫文件,然後轉換成有效的 HTML 文件」。簡而言之,Markdown 就是一種簡潔易懂的語法,讓我們可以專注在內容上,不用花時間思考外觀樣式,在透過轉換變成可以呈現在網頁上的 HTML 語法。目前在許多知名技術/開發者論壇或是開發者工具(例如:Github)、技術部落格工具都有支援 Markdown 語法。

什麼是 HTML?

在開始學習 Markdown 之前我們先來認識一下 HTML,畢竟 Markdown 最終還是要轉換成 HTML 這個網頁上內容結構的標準語法。HTML 中文稱作超文本標記語言(英文全名為 HyperText Markup Language,簡稱 HTML),是一種用於建立網頁的標準標記語言。

這樣講起來有點抽象,事實上我們每天在觀看瀏覽的網頁就是由一個個 HTML 所組成。所以我們可以透過瀏覽器的檢視原始碼功能去一窺目前網頁的 HTML 樣貌。

這邊我們使用 Google Chrome 瀏覽器當作範例,可以在畫面中點選右鍵 > 檢視原始碼(View Page Source):

就可以看到該網頁的 HTML 內容:

網頁來源:Wikipedia HTML 頁面

由於這個網頁已經有點複雜,因為它已經包含了 CSS 外觀樣式語法和 JavaScript 互動邏輯程式的部分,對於初學者來說比較難一眼理解。所以我們用一下範例來介紹 HTML 最基礎的部分:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta http-equiv="X-UA-Compatible" content="ie=edge">
<title>Document</title>
</head>
<body>
<h1>我是標題</h1>
<p>我是段落</p>
<a href="https://zh.wikipedia.org/zh-tw/Markdown">我是超連結</a>
<img src="https://upload.wikimedia.org/wikipedia/commons/thumb/8/84/HTML.svg/200px-HTML.svg.png" alt="">
</body>
</html>

若是使用瀏覽器打開這個 HTML 網頁會呈現:

HTML 標籤語法每個標籤皆有其意義且大部分成對出現,標籤元素內可以設定屬性值。網頁元素主要放置於 <body></body> 中,<head></head> 內主要放置 meta data 設定檔案和放置引入的外觀樣式檔案、程式邏輯等。元素內可以透過設定屬性值(attribute)來宣告元素功能,以下 href="https://zh.wikipedia.org/zh-tw/Markdown" 代表點擊該連結會到該 wikipedia 網址。

<!-- href 是屬性,決定連結點擊後目的地 -->
<a href="https://zh.wikipedia.org/zh-tw/Markdown">我是超連結</a>

<!-- src 是屬性,決定載入圖片位置-->
<img src="https://upload.wikimedia.org/wikipedia/commons/thumb/8/84/HTML.svg/200px-HTML.svg.png">

元素包裹內容在內,代表標題元素:

<h1>我是標題</h1>

Markdown 常見語法教學

一般 Markdwon 段落以空白行分隔。若是序列則內容需要內縮(一個 tab)。

標題

是一级標題
=======

# 一級標題
## 二级標題

其 HTML 元素為:

<h1>是一级標題</h1>
<h1>一級標題</h1>
<h2>二级標題</h2>

效果如下:

是一级標題

一級標題

二级標題

文字

_斜體_
**粗體**
`等寬字型Monospace`

其 HTML 元素為:

<em>斜體</em>
<strong>粗體</strong>
<code>等寬字型Monospace</code>

效果如下:

斜體 粗體 等寬字型Monospace

多行程式碼

其 HTML 元素為:

<pre>
<code>
<span>print('hello world')</span>
</code>
</pre>

效果如下:

print('hello world code :)')

水平線

---

其 HTML 元素為:

<hr>

效果如下:


無序列表

* 張三
* 李四
* 王二

其 HTML 元素為:

<ul>
<li>張三</li>
<li>李四</li>
<li>王二</li>
</ul>

效果如下:

  • 張三
  • 李四
  • 王二

有序列表

1. 不論
2. 三七
3. 二十一

有序列表,其 HTML 元素為:

<ol>
<li>不論</li>
<li>三七</li>
<li>二十一</li>
</ol>

效果如下:

  1. 不論
  2. 三七
  3. 二十一

巢狀有序列表

1. 不論
- 第一
- 第二
- 第三
2. 三七
1. 第一
2. 第二
3. 第三
3. 二十一

有序列表,其 HTML 元素為:

<ol>
<li>不論
<ul>
<li>第一</li>
<li>第二</li>
<li>第三</li>
</ul>
</li>
<li>三七
<ol>
<li>第一</li>
<li>第二</li>
<li>第三</li>
</ol>
</li>
<li>二十一</li>
</ol>

效果如下:

  1. 不論
    • 第一
    • 第二
    • 第三
  2. 三七
    1. 第一
    2. 第二
    3. 第三
  3. 二十一

超連結

[連結文字](連結網址)

其 HTML 元素為:

<a href="https://upload.wikimedia.org/wikipedia/commons/thumb/8/84/HTML.svg/200px-HTML.svg.png">連結文字</a>

效果如下:

連結文字

圖片

![文字屬性](Icon-pictures.png "文字標題")

其 HTML 元素為(少數沒有成對出現的元素標籤):

<img src="連結網址" alt="文字屬性" title="文字標題" />

效果如下:

圖片文字

注釋引用

> Markdown使用電郵用字元「>」來引用。

其 HTML 元素為:

<a href="連結網址">連結文字</a>

效果如下:

Markdown 使用電郵用字元「>」來引用。

表格

| Column 1 | Column 2 | Column 3 |
| -------- | -------- | -------- |
| Text | Text | Text |

其 HTML 元素為:

<table>
<thead>
<tr>
<th>Column 1</th>
<th>Column 2</th>
<th>Column 3</th>
</tr>
</thead>
<tbody>
<tr>
<td>Text</td>
<td>Text</td>
<td>Text</td>
</tr>
</tbody>
</table>

效果如下:

Column 1Column 2Column 3
TextTextText

總結

以上簡單介紹了:

  1. 什麼是 HTML?
  2. Markdown 常見語法教學

以上介紹了 HTML 和 Markdown 基礎語法的教學,透過 Markdown 這一種簡潔易懂的語法,我們可以更專注在內容創作上。對於一個自學程式設計新手而言,培養撰寫文章的習慣(例如:建立自己的技術部落格)是很重要的環節,不但可以累計自己經歷也可以強化記憶並幫助到需要的人。若是需要完整語法介紹可以參考markdown.tw,當然,只要多加練習就可以慢慢掌握 Markdown 語法的訣竅,進而喜歡這種簡潔的書寫方式。

參考文件

  1. Github Basic writing and formatting syntax
  2. markdown.tw
  3. markdown wiki

用 Python 自學程式設計:list、tuple、dict and set

· 閱讀時間約 5 分鐘

Python 自學程式設計:程式設計思維入門

在前一單元中我們了解了變數和 Python 世界物件的重要性,也介紹了簡單的資料型別,我們也有提到簡單資料型別(布林、整數、浮點數和字串)就像是原子一樣,而複雜資料型別就像是分子一樣,在這一單元中我們將更進一步了解 Python 複雜的資料型別以及如何操作它們。

串列 list 與元組 tuple

在程式語言中通常可以利用序列式方式去記錄資料,在 Python 中,我們使用 list 串列和 tuple 元組來儲存序列式資料。兩者最大的不同在於 tuple 是不可以改變的。

  1. 串列 list 串列是一連串順序性的元素組成,我們可以新增、讀取、刪除和修改串列,串列中可以有重複的元素。

    • 建立串列

    串列可以透過中括號或是使用 list 關鍵字來創建,裡面元素由逗號分隔

    my_list0 = []
    my_list1 = list()
    my_list2 = ['python', 'js', 'SQL']

    list('js')
    # ['j', 's']
    • 使用 index offset 和範圍來取得元素

    在電腦科學世界,index 通常是從 0 開始,-1 從結尾數回來:

    languages = ['python', 'js', 'go']
    languages[0] # python
    languages[1] # js
    languages[-1] # go

    範圍取值 [開始:結束(不含):間隔(default 1)]:

    languages = ['python', 'js', 'go']
    my_list2[0:1] # ['python']
    • append 元素到串列最後
    languages = ['python', 'js', 'go']
    languages.append('java')
    • extend 串連串列
    languages = ['python', 'js', 'go']

    languages.extend('c++') # ['python', 'js', 'go', 'c++']

    languages += ['ruby', 'c'] # ['python', 'js', 'go', 'c++', 'ruby', 'c']
    • insert 插入元素到位置上
    languages = ['python', 'js', 'go']
    languages.insert(0, 'java') # ['java', 'python', 'js', 'go']
    • del 刪除特定 index 值
    languages = ['python', 'js', 'go']

    del languages[-1] # ['python', 'js']

    • len() 元素長度
    len(['python', 'js', 'go']) # 3
    • in 檢查元素是否在串列
    'java' in ['python', 'js', 'go'] # False

    還有更多好用的方法,讀者可以進一步查詢使用: remove()index()count()join()、sort()、copy()

  2. 元組 tuple 元組可以視為不可改變的串列,使用方式如下:

    languages = python', 'js', 'go' # (python', 'js', 'go')
    tuple(['python', 'js', 'go'])

    元組比起串列好處:

    • 佔用空間較少
    • 可以當做字典的 key(因不可變)
    • 具名 tuple 可當做物件替代
    • 當做函式引數

字典 dict 和集合 set

  1. dict 在其他程式語言可能稱 {'key':'value'} 字典為關聯式陣列或是雜湊表,其用獨一無二不可變的鍵(布林、整數、浮點數、字串和串列)去對應值,字典通常是可變的,可以新增刪除、修改鍵值。

    • 創建 dict
    languages = {
    'name': 'python',
    'version': '3.5'
    }

    dict([('name', 'python'), ('version', '3.5')])
    • 新增和取值
    languages = {}

    languages['name'] = 'python'

    print(languages['name']) # python
    • 合併
    languages = {
    'name': 'python',
    'version': '3.5'
    }

    languages2 = {
    'name': 'js',
    'version': '6'
    }

    languages.update(languages2)
    • keys() 取得所有鍵、values() 取得所有值、items() 取得所有鍵值對
    languages = {
    'name': 'python',
    'version': '3.5'
    }

    languages.keys() # ['name', 'version']
    languages.values() # ['python', '3.5']
    languages.items() # [('name', 'python'), ('version', '3.5')]
    • 使用 in 判斷 key 是否存在 dict
    languages = {
    'name': 'python',
    'version': '3.5'
    }

    'name' in languages # True
  2. set 類似小學時候學習的數學集合,可以想成就是留下鍵值的 dict。由於 set 存不重複值。當你只想知道值是否存在就是使用 set 的時機,例如使用 in 來判斷值是否存在。

    • 建立 set
    languages = set()

    languages = {'python', 'js', 'python', 'go'}
    # {'python', 'js', 'go'}
    • 轉換成 set
    set('python') # {'p', 'y', 't', 'h', 'o', 'n'}
    set(['python', 'js']) # {'python', 'js'}
    set(('python', 'js')) # {'python', 'js'}
    • 使用 intersection 取交集,union 取聯集,difference 取差集
    languages1 = {'js', 'python', 'go'}
    languages2 = {'python', 'go', 'java'}
    languages1.intersection(languages2) # {'python', 'go'}
    languages1.union(languages2) # {'js', 'python', 'java', 'go'}
    languages1.difference(languages2) # {'js'}

整合在一起

回想一下,我們可以使用 [] 建立 list 串列,用 , 來創立 tuple 元組,使用 來建立字典。雖然建立方式不盡相同,但相同的是你都可以透過中括號來存取內容值:

languages0 = ['python', 'js'] # languages0[0]
languages1 = ('python', 'js') # languages1[0]
languages2 = {
'name': 'python',
'version': '3.5'
} # languages2['name']

總結

以上就是程式設計思維入門簡介,透過了解什麼是程式設計思維和不同語言的特性,我們將對於自學程式設計有更正確的認識。接下來我們將透過 Python 介紹程式設計的內涵和不同的應用情境。當然,網路上也有許多學習資源可以當做參考。

(image via mshcdn

延伸閱讀

  1. Python 官網
  2. JavaScript 程式設計新手村
  3. Python Web 程式設計入門實戰
  4. 非本科生,我想半路出家學寫程式,該如何開始?
  5. 自學程式設計學習資源懶人包

用 Python 自學程式設計:變數(variable)與資料型別(type)

· 閱讀時間約 7 分鐘

Python 自學程式設計:程式設計思維入門

在前一單元中我們了解了程式設計思維的概念和建立了 Python 的開發環境,在這一單元中我們將了解 Python 變數與資料型別以及如何操作字串。

電腦最初的用途就是一台超大台計算機

資料的儲存以及操作在程式設計中扮演非常重要的角色,因為最早的電腦程式就是一種大型的計算機(最早的電腦就稱為計算機),即便現在學校教授電腦科學概論往往都會把課程稱為計算機概論呢!在操作資料的過程中如何儲存資料就是非常重要的事情,一般而言資料儲存有分為暫時儲存的揮發性資料(儲存在記憶體中的變數資料)和持久性儲存的資料(例如:資料庫、檔案等),在這邊我們討論的是變數的資料。

在 Python 世界,所有東西都是物件

在 Python 世界中,所有東西都是物件,物件可以視為透明的箱子,裡面存了一些資料。物件會有自己的資料型別,決定它做什麼樣的操作。另外,又依據箱子內的值可否改變而分為不可變物件可變物件

在前面我們有提到資料可以儲存在記憶體中的變數,在 Python 中變數只是一種名稱,當給定值時不會將值複製,而是將名稱貼到給定的物件上(注意 Python 程式語言中的 = 是給定值,== 才是相等的意思)

談到資料,就不得不談一下資料型別(type),雖然在 Python 不用像 C 語言之類程式語言需要在變數前面定義資料型別(在 Python 中 class 類別和 type 類型幾乎代表同一件事情,class 類別則是定義物件的基礎),但物件的資料型別會影響資料操作,所以值得我們好好認識。在 Python 世界裡,可以分為以下幾種簡單資料型別(可以想像成化學課中的原子):

  1. bool 布林,分為 TrueFalse 通常用於條件判斷
  2. int 整數,例如: 10999999
  3. float 浮點數,係指有小數點的整數:1.2221.0e7 等同於 10 的 7 次方
  4. string 字串,一串文字字元

我們可以透過 type(物件) 去確認該物件的型別:

print(True)
print(101)
print(3.14)
print('happy coding')

另外一種是複雜資料型別(可以想像成是化學課中的分子),這個我們會在下一個單元做討論:

  1. list 串列,用於儲存一系列序列資料(可以儲存不同資料型別),類似於其他程式語言的陣列但更為強大
  2. tuple 元組,類似於 list 串列,但不同的是 tuple 給定元素後不能改變
  3. dict 字典,和串列很像但不在乎元素順序,而且不會使用 0,1,...等的序列 index 來選擇項目,反之我們必須宣告唯一的 key 鍵值來對應想儲存的 value 值
  4. set 集合,集合就像是被移除 value 值的字典,只有保留 key 鍵值,也就是說 set 的內容元素都必須是獨一無二的

物件又分可變和不可變物件

  1. 不可變物件(int, string, float, tuple),亦即若資料改變,會複製一份資料到新的記憶體空間然後資料更新,下面是一個簡單範例:

    i = 101 # 宣告一個變數將 i 便條紙貼到 101 物件
    j = 101 # 宣告一個變數將 j 便條紙貼到 101 物件
    print(id(101)) # 印出 101 物件 id,可以想成是記憶體位置
    print('i id:' + str(id(i))) # 印出 i 指向的 id,和 101 物件值相同
    print('j id:' + str(id(j))) # 印出 j 指向的 id,和 101 物件值相同
    print(i is j) # 因為兩者會貼到同一個物件所以會顯示相等,True
    j = j + 1 # 若資料改變,會複製一份資料到新的記憶體空間然後資料更新
    print('new i id:' + str(id(i))) # 印出一樣的 id
    print('new j id:' + str(id(j))) # 印出新的 id
    print(i is j) # 兩者指到不同的記憶體位置,False

    執行結果:

    140181136769920
    i id:140181136769920
    j id:140181136769920
    True
    new i id:140181136769920
    new j id:140181136769952
    False
  2. 可變物件(list, dict, set),亦即若資料改變則直接在指向的記憶體空間改變資料,下面是一個簡單範例:

    a = {} # 宣告一個變數指到一個空字典 dict
    b = a # 將 b 變數指到 a 同樣記憶體位置
    print(id(a)) # 印出 a 的 id
    print(a is b) # 兩者指到相同的記憶體位置,True
    a['a'] = 'python' # 改變 a 的鍵值
    print('id a:' + str(id(a))) # 印出 a id
    print('a:' + str(a)) # 印出內容值
    print('id b:' + str(id(b))) # 印出 b id,dict 為可變物件,印出 id 會和 a 一樣
    print('b:' + str(b)) # dict 為可變物件,印出內容值會和 a 一樣
    print(a is b) # 兩者指到相同的記憶體位置,True

    執行結果:

    140181112792336
    id a:140181112792336
    a:{'a': 'python'}
    True
    id b:140181112792336
    b:{'a': 'python'}
    True

另外,Python 支援強制轉換資料型別: 可以透過 int()、float()、str() 進行資料型別轉換

int(1.2)
float('1.3')
str('1')

字串操作好好玩

在程式設計的世界中,操作字串基本上是家常便飯,接著我們來談談在 Python 中如何進行字串的操作:

在 Python 中若要宣告字串,可以使用單引號或雙引號,會有兩種方式是因為讓開發者可以產生有 '" 內容的字串。

my_str = 'This is a "good" language!'

但要特別留意的是在 Python3 和 Python2 對於字串的支援不盡相同,在 Python 中支援 Unicode 標準。與其他程式語言不同的是 Python 字元是不可變的,不能直接改變字串,但可以將一部分字串複製到其他字串。

以下是常見字串操作方式:

  1. 宣告字串

    language = 'python'
  2. 串連字串 +

    language = 'python'
    word = 'I love'
    word + language
  3. 複製字串 *

    language = 'python'
    language * 3
  4. 選取字串 [開始:結束:間隔]

    language = 'python'
    language[0:1] # p
    language[0:-1] # pytho
    language[0:4:2] # ph
  5. len、split、join、replace 字串操作

    language = 'python'
    print(len(language)) # 印出字串長度 6
    print(language.split(3)) # 切割字串長度
    print(language.join(3)) # 切割字串長度
    print(language.replace(3)) # 切割字串長度

總結

以上我們介紹了在 Python 世界中物件是基本元素,也介紹了變數以及字串的操作,接下來我們將透過 Python 介紹程式設計的內涵和不同的應用情境以及複雜資料型別的使用。

(image via mshcdn

延伸閱讀

  1. Python 官網
  2. JavaScript 程式設計新手村
  3. Python Web 程式設計入門實戰
  4. 非本科生,我想半路出家學寫程式,該如何開始?
  5. 自學程式設計學習資源懶人包
  6. python可变和不可变对象

用 Python 自學程式設計:程式設計思維入門

· 閱讀時間約 14 分鐘

Python 自學程式設計:程式設計思維入門

最近幾年全球刮起了一股爭相學習電腦科學(Computer Science)和程式設計(Programming)的風氣,上至總統、首相下至升斗小民都爭相開始學寫程式。事實上,學寫程式最重要的是學習電腦科學背後思考方式和邏輯,學習如何透過科技解決生活上的問題。更進一步說,程式設計與其說是一種科學,更偏向一種藝術人文的創作與科學的混合體。以前畫家或是作家是拿紙筆創作,現在只要有一部電腦,連上網路,就可以透過敲打鍵盤將自己的創意付諸實踐。

有人說:程式設計 = 演算法 + 資料結構

這樣的說法不能說錯。事實上,具備良好資料結構和演算法素養的程式設計師往往可以寫出品質較好的程式碼,但大部分人看到演算法和資料結構就已經滿臉問號了,更別提曾經在學校被這兩門課程心靈受挫的學生們。所以對於初學者來說,更應該讓他了解,事實上學程式設計思維就是在學習解決問題的能力:

  1. 尋找並發現問題
  2. 釐清並定義問題
  3. 分解問題
  4. 尋找解決方法和資源
  5. 驗證問題和解決方式

唯有具備這樣解決問題的能力,才能稱得上真正學會程式設計思維。而這樣的思考方式的訓練是不管將來到哪裡,是否有從事程式設計相關工作都受用,這才是對於學習電腦科學與程式設計思維正確的認知。

寫程式就是下指令請電腦做事情

剛剛我們在上面提到程式設計思維中有一個部分是分解問題,事實上,寫程式在定義問題後,我們必須把問題切分,就像是食譜一樣,不管是再豐盛的料理或是滿漢全席,都有一個個步驟去完成。舉例來說,我們今天要創作一道蔥花蛋或菜脯蛋,我的步驟會是:

  1. 放點油
  2. 打蛋
  3. 如果喜歡蔥花可以加入蔥花,如果喜歡菜脯可以加入菜脯(程式術語:if...else 條件判斷)
  4. 放入少許鹽巴
  5. 中火快炒,翻五次面(程式術語:for 迴圈)
  6. 當看到蛋面呈現金黃色時可以起鍋,結束料理(程式術語:while 迴圈)
  7. 好吃的蔥花蛋或菜脯蛋上桌

再大程式切分後就變成一個個小程式和指令,將程式切分成一個個模組,再將它們都組裝起來就成我們的應用程式和系統。

第一次學寫程式,學哪一種語言好呢?

既然程式設計思維很重要,究竟第一次學寫程式,學哪一種語言好呢?

先講結論:Python 語法平易近人,學習曲線平緩,應用廣,可以很快做出一些解決生活上問題的應用,累積成就感,適合初學者。當然若你是國中小的學生,Scratch 之類的拖拉式圖象化程式語言或許是合適選擇,但成人一般對於這種玩具比較排斥些,認為不是真正在學寫程式。

一般而言除了區分高低階程式語言外,我們會把程式語言分為:

靜態語言:在程式語言中我們會使用變數(variable)儲存程式的值,在靜態語言中需要事先宣告變數型態(type),也宣告了它會在記憶體中佔有多少空間等資訊。電腦會透過這些資訊把程式編譯(compile)成低階的機器語言讓電腦可以執行。這樣的設計可以讓電腦執行起來更有效率,但對於開發者來說會比較繁瑣一些(例如:宣告字串變數要在變數前加 string 宣告),也由於類型被宣告後無法改變,所以被稱為靜態語言。常見的靜態語言包括:C/C++、Java、C#、Go、Swift 等)。

動態語言(又稱為 script language):相對於靜態語言,動態語言不會強制變數類型宣告,它不是使用編譯器而是使用直譯器(interpreter)來解譯。動態語言雖然開發和撰寫程式上效率較快,但執行速度往往比靜態語言慢(現在差距已經慢慢變小)。一般常見的動態語言包括:Python、JavaScript、PHP、Ruby 等)。

以下就來先簡單介紹常見程式語言和它的簡單語法範例(可以透過 repl.it 可以將程式碼貼在網頁上呈現所見即所得效果):

  1. Python 本系列文章的主角,Python 是一種物件導向、直譯式的跨平台動態程式語言,它包含了一組功能完備的標準庫和豐富套件生態系,可以輕鬆完成很多常見的任務(例如:物聯網應用開發、遊戲、讀寫檔案、自然語言處理、網路爬蟲、網站開發、機器學習等),因為它可以很輕易整合其他底層語言,所以又稱為膠水語言。它的語法簡單,與其它大多數程式設計語言使用大括弧不一樣,它使用縮進來定義語句塊。由於具備簡潔易學等特性,是許多開發者推薦 Python 為初學者第一個學習的程式語言。由於版本更迭,我們接下來討論的主要是以 Python3 為主。以下是使用 Python 印出最喜歡的語言:

    language = 'Python'
    print('My favorite Language is {}'.format(language))
  2. C 經典的傳統主力程式語言,適用於需要效能重視速度的應用,可以操作許多小細節,但學習門檻稍微高一些,執行前需要事先編譯完成:

    #include <stdio.h>
    int main(int atgc, char *argv[]) {
    string language = "C++";
    printf("My favorite Language is %s", language);
    return 0;
    }
  3. C++ 屬於 C 家族成員,具備物件導向特性,同樣是適用於需要效能重視速度和操作底層韌體、硬體的好選擇:

    #include <iostream>
    using namespace std;
    int main() {
    string language = "C++";
    cout << "My favorite Language is " << language;
    return(0);
    }
  4. Java 常見於企業系統和 Android 行動應用開發的 Java 是物件導向程式語言,由於跨平台開發等特性讓 Java 一直是市場蠻熱門的語言。

    public class CodeLanguage {
    public static void main(String[] args) {
    string language = "Java";
    System.out.format("My favorite Language is %s", language);
    }
    }
  5. C# 由微軟推出吸收了 C++/Java 等優點的物件導向程式語言,常見於開發微軟平台相關的應用程式。

    using System;
    namespace CodeLanguage {
    class CodeLanguage {
    static void Main() {
    string language = "C#";
    Console.WriteLine("My favorite Language is {}", language);
    }
    }
    }
  6. JavaScript 隨著版本演進和 Node.js 的推出後從玩具語言到可以挑大樑的程式語言,應用範圍遍及網頁前後端開發、遊戲開發、物聯網程式開發、手機程式開發等。是程式設計師社群平台 Github 和程式問答平台 StackOverflow 上最受歡迎的程式語言之一。且由於應用範圍廣泛,程式江湖更傳言:可以使用 JavaScript 編寫的程式,最終都會出現 JavaScript 版本。

    var language = 'JavaScript'
    console.log('My My favorite Language is ' + language);
  7. PHP 吸收了 C/Java/Perl 特點的網站開發主力語言,世界上有許多的網站都是使用 PHP 進行開發。

    <?php
    $language = 'PHP';
    echo 'My favorite Language is ' + language;
    ?>
  8. Ruby 常見於網頁 Web 開發,以 Ruby on Rails Web 開發框架聞名於程式設計社群。

    language = 'Ruby'
    puts 'My favorite Language is #{language}'
  9. Swift 由 Apple 推出的推出的程式語言,主要用於開發 iOS/Mac 系列產品,應用範圍也涉及到了伺服器端開發(Server)。

    let language = 'Swift'
    print("My favorite Language is ", language)

  10. Go 由 Google 推出的程式語言,適合用於平行化程式開發。

    package main
    import "fmt"

    func main() {
    language := 'Go'
    fmt.Printf("My favorite Language is %s", language)
    }

看完了眾多語言是不是發現其實 Python 語法還蠻可愛平易近人的呢?事實上,世界上沒有最好的程式語言,只有最適合的使用地方。接下來我們將透過 Python 學習程式設計思維。

Python 環境建置

在開始之前我們必須先建置相關的開發環境,讓自己從麻瓜(不會寫程式的人)變成擁有程式魔力的魔法師。

所謂工欲善其事,必先利其器,要開發好的應用程式必須先準備好開發環境才行。以下介紹我們在接下來開發 Python Flask Web 應用程式所需要安裝的開發環境工具(以下以 Mac OS 等 Unix-like 作業系統為示範,若是 Windows 使用者建議安裝 Virtualbox 並運行 Linux Ubuntu 作業系統,參考安裝文件):

  1. Microsoft VSCode 編輯器 Microsoft VSCode 是 Microsoft 推出的編輯器(非整合開發環境 IDE),夾帶著 Microsoft 過去打造 Visual studio 整合開發環境的豐富經驗,相比 Sublime Text 和其他編輯器,VSCode 的優勢在於開源且活躍的開發社群、內建 debugger 框架、原生 Git 整合、套件整合容易等特性。所以對於初學者來說 VSCode 是一個蠻適合入門的開發環境。它的安裝方式也十分簡易,在官網下載後按照指示安裝完成即可。

    Python Web Flask 實戰開發教學 - 簡介與環境建置

    我們可以安裝 Python 語法和格式檢查的相關 Python 套件幫助除錯:

    Python Web Flask 實戰開發教學 - 簡介與環境建置

  2. 終端機環境(iTterm/內建 terminal) terminal(終端機)是我們下指令的地方,許多時候我們進行程式開發時不會使用 GUI 的介面而是使用下指令方式請電腦做相對應的行為。在 Linux 和 Mac 裡面都有內建的 terminal 的應用程式,若你是 Mac 用戶想使用更便利的工具(分割視窗、熱鍵、搜尋、自動補完等)可以額外安裝 iterm2 做使用。若是不想使用 Virtualbox,使用 Windows 讀者可以使用 Cmder 這個軟體當做終端機環境。

    Python Web Flask 實戰開發教學 - 簡介與環境建置

    下指令($ 為提示字元,不用輸入):

    Python Web Flask 實戰開發教學 - 簡介與環境建置

    對於有志於從事程式開發相關工作的讀者建議可以多熟悉指令碼的輸入,更多指令碼可以參考鳥哥撰寫的 Linux 基本指令介紹Linux 學習資源

  3. Git 版本控制系統/註冊 GitHub 帳戶 Git 是一種分散式版本控制系統,可以讓我們可以更方便地管理我們的程式碼。在網路上有非常多優秀的 Git 教學文件(連猴子都能懂的Git入門指南寫給大家的 Git 教學初心者 Git 上手攻略)。安裝 Git 方式是到官網下載軟體,依照指示安裝。

    Python Web Flask 實戰開發教學 - 簡介與環境建置

    互動式語法學習:

    Python Web Flask 實戰開發教學 - 簡介與環境建置

    在介紹完 git 之後我們來了解一下 GitHub。GitHub 是一個可以存放 git 程式碼專案的平台,透過 GitHub 我們可以接觸到最新的開放原始碼資訊,也可以將我們的程式碼開源出來。

    Python Web Flask 實戰開發教學 - 簡介與環境建置

    從 GitHub 上複製程式碼

    Python Web Flask 實戰開發教學 - 簡介與環境建置

    # 複製一份到本地端
    $ git clone https://github.com/happycoderorg/flask101.git
    # 移動到資料夾
    $ cd flask101

    常見 Git 指令:

    # 初始化專案
    $ git init
    # 查看狀態
    $ git status
    # 檢查差異
    $ git diff
    # 將變更檔案放入暫存區
    $ git add index.py
    # 使用 commit -m 提交變更
    $ git -a -m 'init commit'
    # 查看歷史
    $ git log
    # 放棄已經 commit 的檔案重回暫存區
    $ git reset HEAD index.py
    # 放棄檔案變更
    $ git checkout index.py
  4. Anaconda Python3 版本 Anaconda 是一個 all-in-one 的 Python 開發環境,對於初學者來說是個十分合適的開發環境包。Anaconda 具備了幾項特點:

    • 便於安裝許多流行的科學、數學、工程、數據分析的 Python 模組
    • 開源和免費
    • 跨平台支持:Linux、Windows、Mac
    • 支持 Python 版本切換,方便建立不同的虛擬開發環境
    • 內建 Spyder 編輯器和 Jupyter Notebook 環境

    安裝流程也十分簡單,進入 Anaconda 首頁,選擇對應作業系統(這邊使用 Mac OS): Python Web Flask 實戰開發教學 - 簡介與環境建置

    選擇對應 Python 版本下載,我們使用 Graphical Installer(圖像介面安裝方式),接著在下載完成時按照預設的安裝方式完成安裝; Python Web Flask 實戰開發教學 - 簡介與環境建置

    若是完整安裝成功,可以打開終端機輸入,若是顯示 Python 3.6.0 :: Anaconda 4.3.0 (x86_64) 版本號即安裝成功:

    $ python -V
    Python 3.6.0 :: Anaconda 4.3.0 (x86_64)

    接著要建立我們專案虛擬環境,這樣在安裝操作套件時比較不容易被污染到 root 的環境,啟動後會出現(套件名稱)的提示字元:

    # 顯示目前虛擬環境列表
    $ conda info -e
    # 創建虛擬環境
    $ conda create -n 套件名稱 python=3.6
    # 進入虛擬環境(若是 Windows cmder 環境不用加 source) ,成功後提示字元變成:(套件名稱)$
    $ source activate 套件名稱
    # 離開虛擬環境(若是 Windows cmder 環境不用加 source)
    $ source deactivate

建立虛擬環境

在建立相關開發工具後我們正式來建立一個 Python 的專案:

打開終端機移動到桌面,建立專案資料夾

$ cd ~/Desktop
$ mkdir python_examples
$ cd python_examples

建立獨立虛擬環境,並進入虛擬環境:

$ conda create -n python_examples_venv python
$ source activate python_examples_venv

成功進入虛擬環境後

你的第一個 Python 程式

一般而言我們會使用編輯器或是整合開發環境(IDE)進行程式撰寫,然後在終端機下指令執行程式。當然你也可以在終端機上使用內建互動式介面或是 jupyter notebook 進行。以下是我們要介紹給大家的簡單範例,第一個是隨機印出不同的喜愛程式語言,第二個是使用第三方套件擷取政府公開資料。程式設計唯有動手實際操作和實踐才能學的好,希望讀者打開你的編輯器透過自己實作去熟悉 Python 程式撰寫:

隨機印出不同的喜愛程式語言:

  1. 引入 random 套件
  2. 定義 language 變數,並將儲存程式語言字串的串列(list)資料結構給定給變數
  3. 產生 1 到 2 之間的隨機整數
  4. 列印出最喜歡的程式語言字串(含根據隨機產生的 index 選取到的串列值)
import random

language = ['Python', 'JavaScript', 'Java']
rnd = random.randint(1, 2)
print('My favorite Language is' + language[rnd])

可以在終端機移動到檔案資料夾執行程式檔案,例如:

python favorite_language.py

使用第三方套件擷取政府公開資料:

  1. 引入 requests 套件
  2. 爬取政府公開 Wifi 熱點資料,將取得資料回應給定給 response 變數
  3. 將資料轉換成以 { "key": "value "} 形式的 json 格式
  4. 印出取得的資料
import requests

url = 'http://data.taipei/opendata/datalist/apiAccess?scope=resourceAquire&rid=b087af42-2c54-4dbf-86c8-427d788779e5'
response = requests.get(url)
data = response.json()
print(data)

總結

以上就是程式設計思維入門簡介,透過了解什麼是程式設計思維和不同語言的特性,我們將對於自學程式設計有更正確的認識。接下來我們將透過 Python 介紹程式設計的內涵和不同的應用情境。當然,網路上也有許多學習資源可以當做參考,若你需要先建立基本的電腦科學知識的話,可以參考哈佛大學的熱門公開課程 CS50

(image via mshcdn

延伸閱讀

  1. Python 官網
  2. JavaScript 程式設計新手村
  3. Python Web 程式設計入門實戰
  4. 非本科生,我想半路出家學寫程式,該如何開始?
  5. 自學程式設計學習資源懶人包
  6. CS50
  7. CS50 TV

Python Web Flask 實戰開發教學 - SQLAlchemy 與 ORM

· 閱讀時間約 8 分鐘

Python Web Flask 實戰開發教學

Web 開發涉及層面很廣,包含了前後端開發、資料庫優化、平行處理、負載平衡、高可用性、資訊安全、雲端伺服器部屬等議題,本系列文章將透過介紹 Python Web Flask 實戰開發來學習現代化網站開發的方方面面。上一篇我們完成了環境建置,這一單元我們將進入 MVC 架構的 Models 部分並學習如何使用 SQLAlchemy 建立和資料庫互動的 ORM 機制。

Python Web Flask 實戰開發教學

什麼是 MVC?

MVC 模式(Model–view–controller)是軟體工程中的一種軟體架構模式,把軟體系統分為三個基本部分:模型(Model)、視圖(View)和控制器(Controller)。

  • 控制器(Controller)- 對 Request/Response 進行處理並透過 Controller 把 Model 的資料串接到 View(Templates)。
  • 視圖(View) - 直接面對使用者的使用者介面設計。
  • 模型(Model) - 負責和資料庫互動,儲存資料。

使用 MVC 的好處在於可以用更高階的角度去思考整個程式架構提高程式可重用性和降低程式耦合性。 事實上 Django、Rails 和 ASP.NET MVC 等較成熟的 Web 框架也是參考 MVC 的架構去設計。

什麼是關聯式資料庫(RDB)?

Database 資料庫一個資料儲存的集合,方便我們去讀取新增刪除修改,而 Relational Database(關聯式資料庫)廣泛應用資料庫應用程式中,它把資料儲存在行列表格中,有可能不同資料表的內容會彼此依賴關聯。常見的關聯式資料庫,例如:MySQL、Postgres、Oracle、MSSSQL、SQLite,本文我們將使用 SQLite 這個輕量級的關聯式資料庫來當做範例教學。

什麼是 ORM?

ORM 指的是 Object Relational Mapping(物件關聯對應),是一種程式設計技術,用於實現物件導向程式語言裡不同類型系統的資料之間的轉換。一般而言物件導向是從軟體工程基本原則(例如:耦合、聚合、封裝)的基礎上發展起來的,然而關聯式資料庫則是從數學理論發展而來的,兩套理論存在顯著的區別。為了解決這個不符合的現象,物件關聯對映技術搬演著中介層的角色,讓開發可以使用物件方式來操作資料庫,而不用使用 SQL 語法,當然若是要使用複雜的操作,仍需要使用到 SQL 語法。

更多 SQL 語法學習:SQL語法教學- 1Keydata

Python Web Flask 實戰開發教學

Flask SQLAlchemy 使用設定

SQLAlchemy 是 Python 社群最廣泛使用的 ORM 套件。為了方便使用 ORM 來操作資料庫,我們使用 SQLAlchemy 的封裝 Flask SQLAlchemy 來進行 Models 的建立(當然你也可以單獨使用 SQLAlchemy)。以下是 SQLAlchemy 使用的簡單範例:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
# 設定資料庫位置,並建立 app
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:////tmp/test.db'
db = SQLAlchemy(app)
# 建立資料表欄位
from main import db

class Todo(db.Model):
# __table__name = 'user_table',若不寫則看 class name
# 設定 primary_key
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.String(80))

def __init__(self, content):
self.content = content

def __repr__(self):
return '<Todo %r>' % self.content
from flask_script import Manager, Server
from main import app
from models import Todo

# 設定你的 app
manager = Manager(app)
# 設定 python manage.py runserver 為啟動 server 指令
manager.add_command('runserver', Server())

# 設定 python manage.py shell 為啟動互動式指令 shell 的指令
@manager.shell
def make_shell_context():
return dict(app=app, Todo=Todo)

if __name__ == '__main__':
manager.run()

操作指令:

$ python manage.py shell
>>> db.create_all()

CRUD 操作設計

CRUD 是一般網路應用程式最常見的資料庫操作(create, read, update, delete),接著我們要使用 session 來操作我們的 CRUD 功能,首先先在終端機中輸入 $ python manage.py shell 後進行資料庫指令模擬操作(要注意的是 Flask SQLAlchemy 針對每個 request 會創建一個新的 session,若沒有 commit 的操作即被丟棄):

  1. 新增(Create) 新增一筆資料後將它加到 db.session 中,完成 commit:

    >>> todo = Todo(content='hacking')
    >>> db.session.add(todo)
    >>> db.session.commit()

2. 讀取(Read)
Model.query 是 db.session.query(Model) 的簡寫,所以我們可以使用以下方式讀取資料庫資料:

取得所有 todo 資料

todos = Todo.query.all() todos

限制 1 筆資料

todos = Todo.query.limit(1).all()

正向/逆向排序

todos = Todo.query.order_by(Todo.content).all() todos = Todo.query.order_by(Todo.content.desc()).all()

取得第一筆資料

todo = Todo.query.first()

取得 primary key=1 一筆資料

todo = Todo.query.get(1)


- 分頁(Pagination)

todos = Todo.query.paginate(1, 10)

總頁數

todos.pages

上/下一頁

todos.prev() todos.next()


- 條件查詢(Filter)

todo = Todo.query.filter_by(content='hacking').first()

todos = Todo.query.filter(Todo.id > 1).all()


3. 修改(Update)

```python
todo = Todo.query.filter_by(contant='hacking').update({
'content': 'reading'
})
db.session.commit()
  1. 刪除(Delete)

    >>> todo = Todo.query.filter_by(content='reading').first()
    >>> db.session.delete(todo)
    >>> db.session.commit()

資料庫關聯用法

在關聯式資料庫中,最重要的就是資料表之間的關聯,透過關聯的使用,可以讓我們取得我們想要的資料。舉例而言,一篇部落格文章通常會對應多則評論,所以若是建立好關係則可以透過文章去取得所有和這篇文章有關的評論。同理,一篇文章通常會有多個 tag,而一個 tag 通常對應多篇文章,所以是個多對多關係。

  • 一對多
# 建立資料表欄位
from main import db

class Todo(db.Model):
# __table__name = 'user_table',若不寫則看 class name
# 設定 primary_key
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.String(80))
user_id = db.Column(db.String(80), db.ForeignKey('user.id))

def __init__(self, content):
self.content = content

def __repr__(self):
return '<Todo %r>' % self.content

class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80))
todos = db.relationship(
'Todo',
backref='user', # ref 可以讓我們使用 Todo.user 進行對 User 操作
lazy='dynamic' # 有使用才載入,提昇效能
)

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

def __repr__(self):
return '<User %r>' % self.name

操作方式:

>>> user = User.query.get(1)
>>> new_todo = Todo('Booking')
>>> new_todo.user_id = user.id
>>> db.session.add(new_todo)
>>> db.session.commit()
>>> user.todos
  • 多對多
tags = db.Table('todo_tags',
db.Column('todo_id', db.Integer, db.ForeignKey('todo.id')),
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id'))
)

# 建立資料表欄位
from main import db

class Post(db.Model):
# __table__name = 'user_table',若不寫則看小寫 class name
# 設定 primary_key
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80))
content = db.Column(db.String(80))

def __init__(self, title, content):
self.title = title
self.content = content

def __repr__(self):
return '<Todo %r>' % self.content

class Tag(db.Model):
# __table__name = 'user_table',若不寫則看 class name
# 設定 primary_key
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80))

def __init__(self, title):
self.title = title

def __repr__(self):
return '<Tag %r>' % self.title

操作方式:

# 創建 3 個 todo
>>> todo_1 = Todo('Python')
>>> todo_2 = Todo('JS')
>>> todo_3 = Todo('R')

>>> tag_1 = Tag('coding')
>>> tag_1.tags = [todo_1, todo_2]
>>> db.session.add()
>>> db.session.commit()

Python Web Flask 實戰開發教學

Flask Migration(Alembic)使用

隨著網路應用程式的發展,我們的 models 會不斷變更,為了記錄所有有關 models 的改動,我們使用 Flask-Migrate 這個 extensions。所有 models 改動都會記錄在 migration 檔案中,就像是資料庫的 git 一樣方便版本控制。

安裝 Flask-Migrate

$ pip install Flask-Migrate

將 db 加入 Flask-Migrate 控制:

from flask_migrate import Migrate, MigrateCommand
from flask_script import Manager, Server
from main import app
from models import Todo

# 設定你的 app
manager = Manager(app)
# 設定 python manage.py db 來管理 models
manager.add_command('db', MigrateCommand)
# 設定 python manage.py runserver 為啟動 server 指令
manager.add_command('runserver', Server())

# 設定 python manage.py shell 為啟動互動式指令 shell 的指令
@manager.shell
def make_shell_context():
return dict(app=app, Todo=Todo)

if __name__ == '__main__':
manager.run()

使用 Flask-Migrate 操作 DB:

# 初始化
$ python manage.py db init
# 記錄 model 變化
$ python manage.py db migrate
# 更新同步到 db
$ python manage.py db upgrade
# 查詢指令
$ python manage.py db --help

總結

本文介紹了資料庫、關聯式資料庫、ORM 的概念,我們也實際使用了 Flask SQLAlchemy 和 Flask-Migrate 來操作我們的資料庫。在接下來章節中我們將持續介紹 Python Web Flask 實戰開發,並學習現代化網站開發的方方面面。

延伸閱讀

  1. Wiki MVC
  2. Python Web 程式設計入門實戰線上課程

(image via basicsofwebdevelopment

Python Web Flask 實戰開發教學 - 簡介與環境建置

· 閱讀時間約 10 分鐘

Python Web Flask 實戰開發教學 - 簡介與環境建置

Web 開發涉及層面很廣,包含了前後端開發、資料庫優化、平行處理、負載平衡、高可用性、資訊安全、雲端伺服器部屬等議題,本系列文章將透過介紹 Python Web Flask 實戰開發來學習現代化網站開發的方方面面。一開始先從簡介和環境建置開始吧!

什麼是 Python?

Python 是一種物件導向、直譯式的跨平台電腦程式語言,它包含了一組功能完備的標準庫和豐富套件生態系,可以輕鬆完成很多常見的任務(例如:讀寫檔案、自然語言處理、網路爬蟲、網站開發、機器學習等),因為它可以很輕易整合其他底層語言(例如:C/C++ 等),所以又稱為膠水語言。它的語法簡單,與其它大多數程式設計語言使用大括弧不一樣,它使用空白縮進來定義語句塊。由於具備簡潔易學等特性,許多開發者推薦 Python 為初學者第一個學習的程式語言。由於版本更迭,我們接下來討論的主要是以 Python3 為主,若電腦沒有安裝的話,你可以在官方網站下載,若你不是安裝 Anaconda 這個 all-in-one 版本的話(自帶許多套件和科學運算工具,也可以建立虛擬開發環境),記得要安裝 pipIPython

接下來我們將以 Anaconda 這個開發環境為主要講解環境。由於我們假定讀者已經有一些 Python 基礎,所以我們會跳過有關 Python 語法的基本較邵,若您對於 Python 入門基礎較不熟悉的話建議參考 Python 101 快速入門教學 ,此外我們也提供了 Python Web 程式設計入門實戰線上課程 可以參考。那就讓我們開始吧!

什麼是 Flask?

Python Web Flask 實戰開發教學 - 簡介與環境建置

Flask 是一個使用 Python 撰寫的輕量級 Web 應用程式框架,由於其輕量特性,也稱為 micro-framework(微框架)。Flask 核心十分簡單,主要是由 Werkzeug WSGI 工具箱Jinja2 模板引擎所組成,Flask 和 Django 不同的地方在於 Flask 給予開發者非常大的彈性(當然你也可以說是需要思考更多事情),可以選用不同的用的 extension 來增加其功能。相比之下,Django 雖然完善但技術選擇相對不彈性,不論是 ORM、表單驗證或是模版引擎都有自己的作法。事實上沒有最好的框架,只有合適的使用情境,Django 相比之下適合需要快速的開發大型的應用程式,和 Ruby 中的 Ruby on Rails 相似,而 Flask 則是相對輕量彈性,更像是 Ruby 界的 Sinatra。若讀者想先體驗看看 Flask 的程式狀況,以下是 Flask 簡易運行的程式,啟動測試伺服器後,可以在瀏覽器中(http://localhost:5000/)印出 Hello World!

from flask import Flask
app = Flask(__name__)

@app.route("/")
def hello():
return "Hello World!"

if __name__ == "__main__":
app.run()

Python Web 開發環境建置

所謂工欲善其事,必先利其器,要開發好的應用程式必須先準備好開發環境才行。以下介紹我們在接下來開發 Python Flask Web 應用程式所需要安裝的開發環境工具(以下以 Mac OS 等 Unix-like 作業系統為示範,若是 Windows 使用者建議安裝 Virtualbox 並運行 Linux Ubuntu 作業系統,參考安裝文件):

  1. Microsoft VSCode 編輯器 Microsoft VSCode 是 Microsoft 推出的編輯器(非整合開發環境 IDE),夾帶著 Microsoft 過去打造 Visual studio 整合開發環境的豐富經驗,相比 Sublime Text 和其他編輯器,VSCode 的優勢在於開源且活躍的開發社群、內建 debugger 框架、原生 Git 整合、套件整合容易等特性。所以對於初學者來說 VSCode 是一個蠻適合入門的開發環境。它的安裝方式也十分簡易,在官網下載後按照指示安裝完成即可。

    Python Web Flask 實戰開發教學 - 簡介與環境建置

    我們可以安裝 Python 語法和格式檢查的相關 Python 套件幫助除錯:

    Python Web Flask 實戰開發教學 - 簡介與環境建置

  2. 終端機環境(iTterm/內建 terminal) terminal(終端機)是我們下指令的地方,許多時候我們進行程式開發時不會使用 GUI 的介面而是使用下指令方式請電腦做相對應的行為。在 Linux 和 Mac 裡面都有內建的 terminal 的應用程式,若你是 Mac 用戶想使用更便利的工具(分割視窗、熱鍵、搜尋、自動補完等)可以額外安裝 iterm2 做使用。

    Python Web Flask 實戰開發教學 - 簡介與環境建置

    下指令($ 為提示字元,不用輸入):

    Python Web Flask 實戰開發教學 - 簡介與環境建置

    對於有志於從事程式開發相關工作的讀者建議可以多熟悉指令碼的輸入,更多指令碼可以參考鳥哥撰寫的 Linux 基本指令介紹Linux 學習資源

  3. Git 版本控制系統/註冊 GitHub 帳戶 Git 是一種分散式版本控制系統,可以讓我們可以更方便地管理我們的程式碼。在網路上有非常多優秀的 Git 教學文件(連猴子都能懂的Git入門指南寫給大家的 Git 教學初心者 Git 上手攻略)。安裝 Git 方式是到官網下載軟體,依照指示安裝。

    Python Web Flask 實戰開發教學 - 簡介與環境建置

    互動式語法學習:

    Python Web Flask 實戰開發教學 - 簡介與環境建置

    在介紹完 git 之後我們來了解一下 GitHub。GitHub 是一個可以存放 git 程式碼專案的平台,透過 GitHub 我們可以接觸到最新的開放原始碼資訊,也可以將我們的程式碼開源出來。

    Python Web Flask 實戰開發教學 - 簡介與環境建置

    從 GitHub 上複製程式碼

    Python Web Flask 實戰開發教學 - 簡介與環境建置

    # 複製一份到本地端
    $ git clone https://github.com/happycoderorg/flask101.git
    # 移動到資料夾
    $ cd flask101

    常見 Git 指令:

    # 初始化專案
    $ git init
    # 查看狀態
    $ git status
    # 檢查差異
    $ git diff
    # 將變更檔案放入暫存區
    $ git add index.py
    # 使用 commit -m 提交變更
    $ git -a -m 'init commit'
    # 查看歷史
    $ git log
    # 放棄已經 commit 的檔案重回暫存區
    $ git reset HEAD index.py
    # 放棄檔案變更
    $ git checkout index.py
  4. Anaconda Python3 版本 Anaconda 是一個 all-in-one 的 Python 開發環境,對於初學者來說是個十分合適的開發環境包。Anaconda 具備了幾項特點:

    • 便於安裝許多流行的科學、數學、工程、數據分析的 Python 模組
    • 開源和免費
    • 跨平台支持:Linux、Windows、Mac
    • 支持 Python 版本切換,方便建立不同的虛擬開發環境
    • 內建 Spyder 編輯器和 Jupyter Notebook 環境

    安裝流程也十分簡單,進入 Anaconda 首頁,選擇對應作業系統(這邊使用 Mac OS): Python Web Flask 實戰開發教學 - 簡介與環境建置

    選擇對應 Python 版本下載,我們使用 Graphical Installer(圖像介面安裝方式),接著在下載完成時按照預設的安裝方式完成安裝; Python Web Flask 實戰開發教學 - 簡介與環境建置

    若是完整安裝成功,可以打開終端機輸入,若是顯示 Python 3.6.0 :: Anaconda 4.3.0 (x86_64) 版本號即安裝成功:

    $ python -V
    Python 3.6.0 :: Anaconda 4.3.0 (x86_64)

    接著要建立我們專案虛擬環境,這樣在安裝操作套件時比較不容易被污染到 root 的環境,啟動後會出現(套件名稱)的提示字元:

    # 顯示目前虛擬環境列表
    $ conda info -e
    # 創建虛擬環境
    $ conda create -n 套件名稱 python=3.6
    # 進入虛擬環境(若是 Windows cmder 環境不用加 source) ,成功後提示字元變成:(套件名稱)$
    $ source activate 套件名稱
    # 離開虛擬環境(若是 Windows cmder 環境不用加 source)
    $ source deactivate

建立第一個 Flask 開發專案

使用 pip 管理 Python 模組

# 安裝模組
$ pip install 模組名
# 移除模組
$ pip uninstall 模組名
# 搜尋模組
$ pip search 模組名

通常開發專案時我們會將已安裝模組名稱和版本號存成一個列表,以便下次安裝使用:

$ pip freeze > requirements.txt

根據 requirements.txt 列表安裝模組:

$ pip install -r requirements.txt

建立虛擬環境

在了解 pip 套件管理工具後我們正式來建立一個 Flask 的專案:

建立專案資料夾

$ mkdir python-flask-todo-app
$ cd python-flask-todo-app

建立獨立虛擬環境

$ conda create -n python-flask-todo-app python=3.6
$ source activate python-flask-todo-app

安裝 Flask 模組

$ pip install flask

設定 Config 設定檔案

建立設定檔 config.py 檔案在專案資料夾的根目錄中:

class Config(object):
pass

class ProdConfig(Config):
pass

class DevConfig(Config):
DEBUG = True

建立一個 main.py 檔案初始化 Flask App 和使用其 API,若是一切正常在終端機執行 python main.py 會在瀏覽器網址列輸入 localhost:5000 後看到 Hello World 了!

from flask import Flask
from config import DevConfig

# 初始化 Flask 類別成為 instance
app = Flask(__name__)
app.config.from_object(DevConfig)

# 路由和處理函式配對
@app.route('/')
def index():
return 'Hello World!'

# 判斷自己執行非被當做引入的模組,因為 __name__ 這變數若被當做模組引入使用就不會是 __main__
if __name__ == '__main__':
app.run()

使用 Flask Script

Flask Script 是 Flask 常用的 extensions,可以讓我們使用指令列來操作 Flask 程式並在 shell 環境下操作 app context,使用方式如下:

安裝模組

$ pip install flask-script

建立 manage.py 於根目錄

from flask_script import Manager, Server
from main import app

# 設定你的 app
manager = Manager(app)
# 設定 python manage.py runserver 為啟動 server 指令
manager.add_command('runserver', Server())

# 設定 python manage.py shell 為啟動互動式指令 shell 的指令
@manager.shell
def make_shell_context():
return dict(app=app)

if __name__ == '__main__':
manager.run()

當執行 $ python manage.py runserver 即會執行測試伺服器,$ python manage.py shell 可以在對話指令列中中輸入 app 找到被引入的 <Flask 'main'>,可以讓我們在互動式指令對話框中測試操作使用。

總結

本文介紹了如何建置 Python Web 開發環境,我們也實際完成了我們第一個 Python Flask 程式。在接下來章節中我們將持續介紹 Python Web Flask 實戰開發,並學習現代化網站開發的方方面面。

延伸閱讀

  1. Wiki Flask (web framework)
  2. Python Web 程式設計入門實戰線上課程

(image via fedoramagazine

Python 101 快速入門教學

· 閱讀時間約 14 分鐘

Python 101 快速入門教學

Python Web 程式設計入門實戰課程準備上課囉!

Python 是一種物件導向、直譯式的跨平台電腦程式語言,它包含了一組功能完備的標準庫和豐富套件生態系,可以輕鬆完成很多常見的任務(例如:讀寫檔案、自然語言處理、網路爬蟲、網站開發、機器學習等),因為它可以很輕易整合其他底層語言,所以又稱為膠水語言。它的語法簡單,與其它大多數程式設計語言使用大括弧不一樣,它使用縮進來定義語句塊。由於具備簡潔易學等特性,許多開發者推薦 Python 為初學者第一個學習的程式語言。由於版本更迭,我們接下來討論的主要是以 Python3 為主,若電腦沒有安裝的話,你可以在官方網站下載,若你不是安裝 Anaconda 這個 all-in-one 版本的話(自帶許多套件和科學運算工具),記得要安裝 pipIPython

Python 設計風格

Python 主要設計的原則和特色就在於簡潔:應該會有一種明顯的作法(最好也只有一種),可以完成工作。

更多有關 Python 設計風格可以在終端機進入 python3 互動模式後輸入 import this

$ python3
Python 3.5.2 (default, Oct 11 2016, 05:00:16)
[GCC 4.2.1 Compatible Apple LLVM 7.0.2 (clang-700.1.81)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import this

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

空白格式

首先,我們要了解 Python 和其他語言最大的不同就是使用縮排來切分程式碼,這和其他語言使用 不同。

for i in [1, 2, 3]:
print(i)
for j in [1, 2, 3, 4]:
print(j + i)

print('finish')

不過初學者很容易在縮排遇到問題,若是出現以下訊息就可以檢視是否哪裡縮排有問題:

IndentationError: expected an indented block

模組

在 Python 生態系中有豐富的模組和工具。一般情況預設不會載入任何模組,但當你有特定開發需求可以使用第三方工具將模組匯入(import)。若是當模組名稱很長時通常我們會使用別名。

import re as regex

my_regex = regex.compile('[0-9]+', regex.I)

若是只是需要模組中的特定功能,也可以使用比較精準的引入方式 from import,引入到整個命名空間中,使用時前面就不用寫模組名(但要注意有可能覆寫):

from collections import defaultdict, Counter
lookup = defaultdict(int)
my_counter = Counter()

資料型別

在 Python 有以下幾種內建的資料型別,基本資料型別有 Number、String、Boolean

  1. 數字(Number)

    num1 = 3
    num2 = 2
    num3 = num1 / num2
  2. 字串(String) 字串使用上會使用單引號或雙引號成對包起(', ")

    str = 'data engineer'
    # 字串長度
    len(str)
    # 原始字元
    es_str = r'\t'
    # 2
    len(es_str)

    若是多行的情形:

    multi_line_str = """
    多行
    多行
    """
  3. 布林值(Boolean) 決定邏輯判斷,TrueFalse。注意在 Python 中布林值首字是大寫

    is_num_bigger_than_one = 1 < 2

    在 Python 中 None 地位類似於 null

    x = None
    print(x == None)

    以下為 Python 的 Falsy 值:

  • False

  • None

  • []

  • ""

  • set()

  • 0

  • 0.0

    可以搭配 and, or, not 使用

  1. 列表(List) 列表可以說是 Python 中最基礎的一種資料結構。所謂列表指的就是一群按照順序排序的元素(類似於其他程式語言的 array,但多一些額外功能)。

    list_num = [1, 2, 3]
    list = ['string', 1, [], list_num]
    list_length = len(list_num)
    num_sum = sum(list_num)

    print(list_length)
    print(num_sum)

    運用 [] 取值(index 從 0 開始):

    x = range(10) # [0, 1, 2, ..., 9]
    zero = x[0] # 0
    nine = x[-1] # 9
    x[0] = -1

    切割([起始 index, 結束 index 但不包含]):

    print(x[:3]) # [-1, 1, 2]
    print(x[3:]) # [3, 4, 5,..., 9]
    print(x[1:5]) # [1, 2, 3, 4]
    print(x[0:-1]) # [1, 2, ..., 8]
    print(x[-1:-1]) # [-1, 1, ..., 9]

    檢查元素是否在列表中(逐一檢查,效率較差):

    1 in [1, 2, 3] # True

    串接列表:

    x = [1, 2, 3]
    x.extend([4, 5, 6])
    x = [1, 2, 3]
    y = x + [4, 5, 6]
    x = [1, 2, 3]
    x.append(0) # [1, 2, 3, 0]

    賦值方式:

    x, y = [1, 2]
    _, y = [1, 2]
  2. 元組(Tuple) Tuple 類似於 List 的兄弟,比較大差別在於 Tuple 是 immutable,也就是說宣告後不能修改。列表使用 [],而元組使用 ()

    my_list = [1, 2]
    my_tuple = (1, 2)
    my_list[1] = 3

    try:
    my_tuple[1] = 4
    except TypeError:
    print('cannot modify a tuple')

    多重賦值

    x, y = 1, 2
    x, y = y, x # x == 2, y == 1
  3. 字典(Dictionary)

    字典類似 map,包含鍵值與對應的值,可以快速取出對應值:

    dict1 = {} # 建議寫法
    dirct2 = dict()
    grades = { 'Mark': 70, 'Jack': 40 }

    grades['Mark']

    給定值:

    grades['happycoderorg'] = 100
    len(grades) # 3

    使用事先檢驗鍵或是使用 get 方法:

    try:
    grade = grades['XD']
    except KeyError:
    print('no grade for XD')

    grades.get('XD', 40) # 若無則使用 default 值

    取出所有值:

    grades = { 'Mark': 70, 'Jack': 40 }
    grades.keys() # 所有鍵值組成的 list
    grades.values() # 所有值組成的 list
    grades.items() # 所有鍵值組成的 tuple of list [('Mark', 70)]

    defaultdict

    當你檢查一個不存在的鍵值時,會用零參數函式添加一個事先設定的新值,這是一種比較優雅的作法

    在介紹 defaultdict 之前先介紹一般作法

    # 例外處理
    word_counts = {}
    for word in document:
    try:
    word_counts[word] += 1
    except KeyError:
    word_counts[word] = 1
    # 使用 get
    word_counts = {}
    for word in document:
    previous = word_counts.get(word, 0)
    word_counts[word] = previous_count + 1

    defaultdict 作法(不用每次檢查鍵直視否存在)

    # 匯入 defaultdict
    from collections import defaultdict

    word_counts = defaultdict(int) # 會生成 0
    for word in document:
    word_counts[word] += 1

    也可以使用 list 或 dict 甚至是自己定義的函式來做為 defaultdict 的零參數函式:

    dd_list = defaultdict(list)
    dd_list[1].append(2) # { 1: [2] }

    dd_list = defaultdict(list)
    dd_list['Mark']['City'] = 'Bay Area' # { 'Mark': { 'City': 'Bay Area'} }

    dd_list = defaultdict(lambda: [0, 0])
    dd_pair[2][1] = 1

    Counter:可以把一系列值轉成類似 defaultdict(int) 的東西,裡面每個值都對應到相應的數量,主要會使用來建立直方圖

    from collections import Counter

    c = Counter([0, 1, 2, 0]) # { 0: 2, 1: 1, 2: 1 }
    word_counts = Counter(document)

    每個 Counter 實例都有個 most_common 的方法

    for word, count in word_counts.most_common(10):
    print(word, count)
  4. 集合(Set) 集合類似數學中的集合,裡面包含不重複的元素值

    s = set()
    s.add(1) # { 1 }
    s.add(2) # { 1, 2 }
    s.add(2) # { 1, 2 }
    len(s) # 2
    1 in s # True

    集合在判斷元素是否存在的效率相對較好,此外,對於判斷不重複值也很方便

    list_item = [1, 2, 3, 1, 2, 3]
    set_item = set(list_item) # {1, 2, 3}
    lsit(set_item) # [1, 2, 3]

解析式列表(comprehensive list)

在 Python 我們通常會需要把某個 list 轉換成另外一個 list,比如只挑選其中幾個元素,或是對期中某些元素進行轉換。

even_numbers = [x for x in range(5) if x % 2 == 0]
squares = [x for x in range(5) if x % 2 == 0]
even_squares = [x * x for x even_numbers]

# 不操作值的話
zeros = [0 for _ in even_numbers] # 和 even_numbers 長度一樣值都為 0 的串列

建立 set 和 dict

square_dict = { x : x * x for x in range(5) }
square_set = { x * x for x in [1, -1] } # { 1 }

pairs = [(x, y) for x in range(10) for y in range(10)] # (0, 0), (0, 1)
p = [(x, y) for x in range(3) for y in range( x + 1, 10)]

函式

函式(function)是重複使用的程式區塊,有輸入輸出。在 Python 中我們會使用 def 來定義函式:

def sum(x, y):
return x + y

Python 的函數和 JavaScript 一樣,屬於一級函式(first-class)。我們可以將函數指定給某個變數,然後把它傳給某個函數中,就像是平常把參數傳入函式一樣。

def apply_f(fun):
return fun(3, 2)

def sum(x, y):
return x + y

sum_fun = sum
num = apply_f(sum)
print(num) // 5

匿名函數使用方式(類似 ES6 arrow function 簡化寫法,前面是參數後面是操作):

y = apply_f(lambda x: x + 4)

函式參數預設值:

def my_print(message="default"):
print(message)

my_print("hello python")
my_print()

args 與 kwargs

若我們希望函式可以接受任意參數,我們可以使用 args(由無名稱參數組成的元組) 和 kwargs(由無名稱參數組成的字典):

def magic(*args, **kwargs):
print('unnamed args:', args)
print('keywords args:', kwargs)
magic(1, 2, key='word', key2='word2')

# unnamed args: (1, 2)
# keywords args: {'key': 'word', 'key2': 'word2'}

可以用來協助建立以函式當做參數的高階函式:

def double(f):
def g(*args, **kwargs):
return 2 * f(*args, **kwargs)
return g

def f2(x, y):
return x + y

g = doubler_correct(f2)
print(g(1, 2))

常見內建函式

除了自己可以建立函式外,Python 本身也提供許多好用的內建函式:

  • all:列表中所有元素為真

    all([True, 1, { 3 }]) # True
    all([True, 1, { }]) # False
    all([]) # True,沒有元素為假
  • any:列表中只要有任何元素為真

    any([True, 1, {}]) # True
    any([]) # False,沒有元素為真
  • enumerate:列舉

    我們常需要反覆取得列表中每個元素及其索引值

    # choice 1
    for i in range(len(documents)):
    document = documents[i]
    do_something(i, document)

    # choice 2
    i = 0
    for document in documents:
    do_something(i, document)
    i += 1

    使用 enumerate:

    for i, document in enumerate(documents):
    do_something(i, document)

    # 僅需要 index
    for i, _ in enumerate(documents): do_something(i)
  • zip:合併將多個 list 合併成 tuple of list

    list1 = ['a', 'b', 'c']
    list2 = [1, 2, 3]
    zip(list1, list2) # [('a', 1), ('b', 2)]

    zip(*[('a', 1), ('b', 2), ('c', 3)]) == zip(('a', 1), ('b', 2), ('c', 3)) # [('a', 'b', 'c'), ('1', '2', '3')]
    # * 可以參數拆分
    def add(a, b): return a + b
    add(1, 3) # 4
    add([1, 3]) # TypeError
    add(*[1, 3]) # 4
  • range:取得一序列

    range(0, 10) # 0, 1, 2, ... 9
  • random:生成隨機數字

    import random

    randoms = [random.random() for _ in range(4)] # 生成長度為 4 內涵值為 0 - 1 不含 0 的 list

    事實上,random 產生的是偽隨機數字,透過 seed 設定可以取得同樣值

    import random
    random.seed(10) # 把 seed 設為 10
    print(random.random()) # 0.5714025946899135
    random.seed(10) # 把 seed 設為 10
    print(random.random()) # 0.5714025946899135

    隨機產生範圍內數字:

    random.randrange(10)
    random.randrange(3, 6)

    針對列表隨機排列:

    num = range(10)
    random.shuffle(num)
    random.choice(['Mark', 'Bob', 'Jack'])

    隨機取樣不放回:

    nums = range(10)
    random.sample(nums, 3)

    隨機取樣放回:

    nums = range(10)
    random.choice(nums, 3)
  • sort:針對 list 進行排序(由小到大),會改變原來的 list。sorted 不會改變原來 list

    x = [4, 1, 2, 3]
    y = sorted(x) # [1, 2, 3, 4] 不會改變到 x
    x.sort() # x 變成 [1, 2, 3, 4]

    若想改成由大到小排序

    x = sorted([-4, 1, -2, 3, key=abs, reverse=True]) # [-4, 3, -3, 2] 絕對值由大到小

    若是在 key 指定一個函數,就會用這個函數結果去做排序

    wc = sorted(word_counts.items(), key=lambda (word, count): count, reverse=True) # 針對單字數量多到小排序
  • partial:使用函式工具創建另一個函式

    from functools import partial
    def exp(base, power):
    return base ** power
    two_to_the = partial(exp, 2)
    print_two_the(3)
  • map:

    def multiply(x, y):
    return x * y
    map(multiply, [1, 2], [1, 2]) # [1, 4]
  • filter:

    def is_even(x):
    return x % 2 == 0
    filter(is_even, [2, 5, 6]) # [2, 6]
  • reduce:

    def multiply(x, y):
    return x * y
    reduce(multiply, [1, 2, 3]) # 1 * 2 * 3

控制流程

  1. if...elif...else

    if 1 > 2:
    message = 'if onlt 1 were greater than two'
    elif 1 > 3:
    message = 'elif == else if'
    else:
    message = 'else'

    三元運算子:

    parity = 'even' if x % 2 == 0 else 'odd'
  2. for...in

    較複雜情況我們會搭配 continue 和 break 使用:

    for x in range(10): # 0...9 不含 10
    if x == 3:
    continue
    if x == 5:
    break
    print(x)
  3. while

    x = 0
    while x < 10:
    print('x is less than 10')
    x += 1

生成器(generator)與迭代操作

事實上,list 有個問題就是很容易變得很大。例如:range(1000000) 就會製造出一個包含一百萬的元素的 list。若是想要使用其中幾個元素,效能就會變得很差。此時使用生成器(generator)就是一個每次只生成所需數值的一種 lazy 作法。

使用函式和 yield

def lazy_range(n):
i = 0
while i < n:
yield i
i += i
for i in lazy_range(10):
do_something(i)

或是在小括號使用運算解析式

lazy_evens_below_20 = (i for i in lazy_range(20) if i % 2 == 0)

另外,每個 dict 都有一個叫做 items() 的方法

iteritems() # 可以一次生成一個鍵值對

裝飾器(decorator)

裝飾器本身是一個函式,主要是借助閉包力量產生一個可以修飾函式的函式:

@print_fun(title='title:')
def add(*tup):
return sum(tup)

# 以下兩者相同
add(1, 2, 3, 4)
add = print_fun(title='title:')(add)

# 裝飾器撰寫
def print_fun(title):
def decorator(func):
def modified_func(*args, **kwargs):
result = func(*args, ** kwargs)
print(title, result)
return modified_func
return decorator

正規表達式

與許多程式語言一樣,Python 同樣提供正規表達式的用法,可以方便擷取文字。

import re

print.all([
re.match('a', 'cat'),
re.search('a', 'cat')])

物件導向程式設計(OOP)

Python 也是物件導向程式語言:

class Set:
def __init__(self, values=None):
# 建構函數
s1 = Set()
s2 = Set([1, 2, 3])
self.dict = {}
if values is not None:
for value in values:
self.add(value)
def __repr__(self):
return "Set" + str(self.dict.keys())
def add(self, value):
self.dict[value] = True
def contains(self, value):
return value in self.dict
def remove(self, value):
del self.dict[value]
# 使用物件
s = Set([1, 2, 3])

s.add(4)

print(s.contains(4))

例外狀況

若是程式出現錯誤的話會送出 exception,若不妥善處理的話程式很有可能會掛掉,在 Python 中例外處理可以使用 try...except:

try:
print(1/0)
except ZeroDivisionError:
print('cannot divide by zero')

總結

本文快速介紹了 Python 的基礎概念,當讀者學會了 Python 後,事實上可以嘗試使用 Python 開發不同的網路應用程式或是資料科學,甚至是自然語言處理的應用。更多 Python 教學內容都在 Python Web 程式設計!

延伸閱讀

  1. 15 Essential Python Interview Questions
  2. 8 Essential Python Interview Questions*
  3. Python Interview Questions
  4. What are good Python interview questions?
  5. Top 40 Python Interview Questions & Answers
  6. Top Python Interview Questions And Answers
  7. Python Interview Questions
  8. 12步教你理解Python装饰器

(image via fedoramagazine