解析哈囉世界

在約維安計畫：R 語言起步走我們透過 print("Hello, World!") 來確認 R 語言的開發環境及執行環境是否已經安裝妥當，在這一段哈囉世界的程式碼中，其實就能體會我們引用 Greg Martin 對於 R 語言核心精神的詮釋：對資料結構應用函數。

The way R works is pretty straightforward, you apply functions to objects.

Greg Martin

print 是函數的名稱，print() 則表示要應用該函數的功能，而 “Hello, World!“ 則是一個被稱呼為文字（Character）的向量資料結構；換言之，哈囉世界可以表達為：對 “Hello, World!“ 這個文字向量應用了 print() 函數。

print("Hello, World!")

什麼是函數

函數是構成所有程式語言的基本要素，一個函數是一段「被命名」的程式碼，這段程式碼可以用於執行某個特定任務，可能是數值的運算或者文字的處理，當使用者想要應用（使用、呼叫）某一個函數之前，必須先確定在欲產生作用的範疇中該函數已經被定義或者被載入。簡而言之，在哈囉世界的程式碼中，之所以能夠對字串 “Hello, World!“ 應用 print() 函數，是因為 print() 函數屬於 R 語言的內建函數，在 R 語言啟動的當下就會被載入供我們使用。

函數的來源

R 語言使用者除了能夠應用內建函數以外，還可以從其他兩個管道取得所需要的函數：

1. 套件（Packages）。

2. 自行定義。

自行定義函數需要考慮五個組成要件：

1. 函數名稱。

2. 輸入。

3. 參數。

4. 函數主體。

5. 輸出。

看似抽象，不過想想平日購買珍珠鮮奶茶的流程，就像是函數的運作一般：

1. 函數名稱：購買珍珠鮮奶茶。

2. 輸入：中杯 35 元；大杯 50 元。

3. 參數：甜度（無糖、微糖、半糖、少糖、全糖）與冰塊（去冰、少冰、全冰）。

4. 函數主體：點餐、貼標籤、加珍珠、加冰塊、倒茶、加鮮奶一直到封口。

5. 輸出：珍珠鮮奶茶。

function_name <- function(INPUTS, PARAMETERS){
    # body of the function
    # ...
    # ...sequence of statements
    return(OUTPUTS)
}

首先要給函數取個名字（function_name），利用保留字 function 告訴 R 語言這是一個函數，接著在小括號中放入想好的輸入（INPUTS）與參數（PARAMETERS），然後在大括號內縮排撰寫我們主要的程式（body of the function），最後是將輸出（OUTPUTS）放在 return() 裡頭。# 是用來標記註解的符號，有 # 標記的該行敘述將不會被 R 語言執行，這讓寫程式的人能夠用口語來描述這段程式的目的是什麼，如果將哈囉世界改寫為函數形式，每次只需要輸入函數名稱並加上小括號 hello_world()，就可以獲得 “Hello, World!“ 這個文字向量為輸出。

hello_world <- function(){
    return("Hello, World!")
}
print(hello_world())

輸入與參數的差別

function_name <- function(INPUTS, PARAMETERS){
    # body of the function
    # ...
    # ...sequence of statements
    return(OUTPUTS)
}

在 R 語言中輸入會設計為「無」或者「必要」，參數則會給予預設值，例如 Sys.Date() 函數或 getwd() 都是無需輸入的函數，函數名稱後的小括號留空白。

print(Sys.Date())
print(getwd())

例如 sort() 函數具有 decreasing 參數，預設值給定為 FALSE。所以在沒有傳入的狀況下，其實就是採用 decreasing = FALSE 的參數設定，假使不想採用預設值，就能指定參數 decreasing = TRUE。

primes <- c(11, 5, 7, 2, 3)
print(sort(primes))
print(sort(primes, decreasing = TRUE))

更動結果的機制

使用「函數」可以讓應用的對象物件造成更動，更動方式是以「回傳值」型態輸出更動後的結果，延續前述 sort() 函數的例子，sort(primes) 是以回傳值輸出排序後的向量，如果沒有將回傳值更新原本命名的向量，排序的更動並不會被保留。

primes <- c(11, 5, 7, 2, 3)
print(sort(primes))
sort(primes) # Apply sort function to primes
print(primes) # primes is not sorted 
primes <- sort(primes) # Update primes with function output
print(primes) # primes is sorted

作用域

在約維安計畫：R 語言的流程控制我們提到了程式區塊（Code blocks）的觀念，不論是條件判斷或者迴圈，都仰賴一對大括號（A curly-brace pair）建立出程式區塊，並以此作為敘述的附屬。在自行定義函數時也同樣以程式區塊建構出函數主體，不過更特別的是，附屬於 function 保留字的程式區塊具有一個稱為作用域（或稱範疇 Scope）的觀念，在附屬於函數下的程式區塊被稱為 Local scope，函數以外的部分則稱為 Global scope。在 Local scope 中我們可以運用 INPUTS、PARAMETERS 來進行運算並宣告新的物件，但是這都侷限於 Local scope 之中，一但在 Global scope 意圖運用前述的這些物件，都會遭遇到錯誤，意即在 Global scope 中這些物件「沒有作用」，這也是作用域一詞的由來。例如在 Global scope 中試圖印出任何在 Local scope 中可以運用的物件都會遭遇錯誤。

is_factor <- function(a, b){
  modulo <- a %% b
  out <- modulo == 0
  return(out)
}

print(is_factor(4, 2))
print(a)
## Error in print(a) : object 'a' not found
print(b)
## Error in print(b) : object 'b' not found
print(modulo)
## Error in print(modulo) : object 'modulo' not found
print(out)
## Error in print(out) : object 'out' not found

return() 的作用

初次學習自行定義函數多半都不甚暸解 return() 作用，原因是先前太過頻繁地使用 print() 函數將文字處理、數值計算或者資料結構操作的結果顯示出來，導致在自行定義函數時不習慣去使用 return()。事實上，return() 具有兩個作用，第一個跟字面上意義相同的將函數結果「輸出」，假如在自行定義函數時只有將運算結果用 print() 函數顯示出來，該函數就不具備能將結果儲存在物件中的能力，變成只能夠在使用時顯示結果，卻不能將結果儲存起來。第一個特性在 R 語言中可能比較難感受到，原因是 R 語言為了幫助使用者，會預設將函數主體區塊中的最後一行物件輸出，例如下列自行定義函數並沒有指定將判斷因數的結果輸出，依然能得到預期結果。

is_factor <- function(a, b){
  modulo <- a %% b
  out <- modulo == 0
}

function_output <- is_factor(4, 2)
print(function_output)

第二個是終止程式區塊的執行，在函數程式區塊中寫在 return() 之後的所有內容在使用函數的時候都不會有任何作用。

is_factor <- function(a, b){
  modulo <- a %% b
  return(modulo)
  out <- modulo == 0 # will not be returned
  print(out) # # will not be printed
}

function_output <- is_factor(4, 2)
print(function_output)

輸入與輸出的對應關係

自行定義函數的重點在於規劃輸入與輸出的對應關係，如同在數學課中學過的「函數映射關係」，只要釐清了自行定義函數針對輸入與輸出的設計機制，剩下的任務就僅是將程式區塊的函數主體完成而已。

從輸入開始，函數可以接受沒有輸入與參數的設計，在小括號中留空即可。

hello_world <- function(){
  return("Hello, World!")
}
print(hello_world())

函數當然可以接受有輸入與參數的設計，好的函數設計會在參數給予合適的預設值。

hello_someone <- function(someone = "World"){
  out <- sprintf("Hello, %s!", someone)
  return(out)
}

print(hello_someone())
print(hello_someone(someone="Function"))

設計接受多個輸入值的函數時，因為 R 語言的向量、元素運算（Element-wise）特性，直接使用合適的資料結構容納多個輸入資料即可。

square_multiple_integers <- function(x){
  return(x**2)
}

print(square_multiple_integers(c(2, 3)))
print(square_multiple_integers(c(2, 3, 5)))

多個輸出的處理同樣是採用適當的資料結構儲存，像是用 list 儲存兩個向量的相加與相減。

add_subtract_vectors <- function(a, b){
  out <- list(
    "add" = a + b,
    "subtract" = a - b
  )
  return(out)
}

function_output_as_list = add_subtract_vectors(3, 4)
print(function_output_as_list)

在認識了函數的各種眉眉角角之後，第三十週約維安計畫：R 語言自行定義函數來到尾聲，希望您也和我一樣期待下一篇文章。

對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Leave a comment

約維安計畫學員專區

Read more

函數是 R 語言的核心，若是想成為擅長寫作 R 語言的資料分析師，必須對函數有一定程度的掌握。事實上早在這個章節之前我們就開始大量使用函數了，不管是建立向量時使用的 c() 函數、建立清單時使用的 list() 函數或者是檢查類型的 class() 函數，都是常用的函數。

對初學者來說，對照輸出格式與內容符合所預期的輸入與參數，是使用函數時的良好行為行為。接著我們彙整一些常用的 R 語言系統功能函數（Utility functions）、數值向量函數（Numeric functions）、文字向量函數（Character functions）與描述統計函數。

系統功能函數

系統功能函數可以幫助使用者將 R 語言與電腦系統連結，常用的有：

• print()

• rm()

• help()

• sessionInfo()

• Sys.getlocale()

• getwd()

• setwd()

print() 函數可以將物件的顯示內容印出在 Console。

hello_world <- "Hello, World!"
print(hello_world)

rm() 函數能夠將完成賦值的物件自環境中刪除，這個函數命名來自 remove 的縮寫。

hello_world <- "Hello, World!"
rm(hello_world)
tryCatch(
    {
        print(hello_world)
    }, error = function(e) {
        print("Object removed.")
    }
)

help() 函數可以查詢內建資料以及函數的說明文件。

help(iris)  # help on built-in dataset, ?iris works too
help(rm)    # help on built-in function, ?rm works too

sessionInfo() 函數會顯示 R 語言的版本以及作業系統相關資訊。

sessionInfo()

Sys.getlocale() 函數顯示電腦的地區以及語系資訊。

Sys.getlocale()

getwd() 函數顯示 R 語言的工作目錄，這個函數命名來自 working directory 的縮寫。

getwd()

setwd() 函數能夠設定 R 語言的工作目錄，Windows 使用者要特別注意路徑斜線要使用正斜線 /（而非 Windows 作業系統使用的反斜線 \），並且避免在路徑設定上出現空格與非英文的文字。

setwd("/Users/YOURUSERNAME/Desktop")   # Set MacOS Desktop as working directory
setwd("C:/Users/YOURUSERNAME/Desktop") # Set Windows Desktop as working director, USE / instead of \

數值向量函數

數值向量函數可以針對數值向量做處理或運算，常用的有：

• abs()

• sqrt()

• ceiling()

• floor()

• round()

• exp()

• log()

• log10()

abs() 函數能夠將輸入數值向量元素都轉換為絕對值，這個函數命名來自 absolute 的縮寫。

a_vector <- -5:-1
print(a_vector)
print(abs(a_vector))

sqrt() 函數能夠將輸入數值向量元素都開平方，這個函數命名來自 square root 的縮寫。

a_vector <- c(1, 4, 9, 16, 25)
print(a_vector)
print(sqrt(a_vector))

ceiling() 函數能夠將輸入數值向量元素都無條件進位。

a_vector <- 1:10
sqrt_a_vector <- sqrt(a_vector)
print(sqrt_a_vector)
print(ceiling(sqrt_a_vector))

floor() 函數能夠將輸入數值向量元素都無條件捨去。

a_vector <- 1:10
sqrt_a_vector <- sqrt(a_vector)
print(sqrt_a_vector)
print(floor(sqrt_a_vector))

round() 函數能夠調整數值向量元素小數位，以 5 作為基準，並靠攏數線上的偶數（Rounding off a 5, go to the even digit）。

a_vector <- c(-1.5, -0.5, 0.5, 1.5, 2.5, 3.5)
print(round(a_vector))

exp() 函數能夠將輸入數值向量元素調整為以自然對數函數之底數 e 的指數，其中 e 接近 2.718282。

a_vector <- 1:5
print(exp(a_vector))

log() 函數能夠將輸入數值向量元素取以 e 為底數的對數。

a_vector <- exp(1:5)
print(log(a_vector))

log10() 函數能夠將輸入數值向量元素取以 10 為底數的對數。

bases <- rep(10, 5)
exps <- 1:5
a_vector <- bases**exps
print(log10(a_vector))

文字向量函數

文字向量函數可以針對文字向量做處理，常用的有：

• toupper()

• tolower()

• substr()

• grep()

• sub()

• strsplit()

• paste()

• paste0()

• trimws()

toupper() 函數能夠將輸入文字向量元素全部轉換為大寫。

skywalkers <- c("Anakin Skywalker", "Luke Skywalker")
print(toupper(skywalkers))

tolower() 函數能夠將輸入文字向量元素全部轉換為小寫。

skywalkers <- c("Anakin Skywalker", "Luke Skywalker")
print(tolower(skywalkers))

substr() 函數能夠將輸入文字向量元素擷取部分，使用的時候搭配兩個參數， start 參數指定要從哪一個字元位置開始擷取， stop 參數指定要擷取到哪一個字元位置。

luke_skywalker <- "Luke Skywalker"
nchar_luke_skywalker <- nchar(luke_skywalker)
print(substr(luke_skywalker, start = 1, stop = 4))
print(substr(luke_skywalker, start = 6, stop = nchar_luke_skywalker))

grep() 函數能夠在文字向量中搜尋指定樣式並將符合所在索引值回傳，使用 pattern 參數指定樣式，如果搜尋後沒有符合樣式的，則會回傳 integer(0)。

starwars <- c("Luke Skywalker", "Princess Leia Organa", "Anakin Skywalker", "Darth Vader")
print(grep(starwars, pattern = "Skywalker"))
print(grep(starwars, pattern = "Leia"))
print(grep(starwars, pattern = "Vader"))
print(grep(starwars, pattern = "Yoda"))

sub() 函數能夠在文字向量中搜尋到指定樣式指定替換為其他內容，使用 pattern 參數指定樣式，使用 replacement 參數指定要替換的文字，以這個範例來說明，我們將 "Anakin" 替換為 "Luke" 。

anakin_skywalker <- "Anakin Skywalker"
luke_skywalker <- sub(anakin_skywalker, pattern = "Anakin", replacement = "Luke")
print(luke_skywalker)

strsplit() 函數能夠將一個文字向量切割成清單，使用 split 參數可以指定要根據什麼分割符號來進行文字的切割，值得注意的是這個函數的輸出是以清單的資料結構儲存。

skywalkers <- c("Anakin Skywalker", "Luke Skywalker")
print(strsplit(skywalkers, split = " "))
skywalkers <- c("Skywalker, Anakin", "Skywalker, Luke")
print(strsplit(skywalkers, split = ", "))

paste() 函數能夠將多個文字向量連結起來為一個文字向量，使用 sep 參數可以指定連結起來以後要使用什麼分隔符號，預設是以一個空格來連結。

luke <- "Luke"
skywalker <- "Skywalker"
print(paste(luke, skywalker))

paste0() 函數與 paste() 函數作用相同，只是改為預設以空字串連結。

sky <- "Sky"
walker <- "walker"
print(paste0(sky, walker))

trimws() 函數能夠將文字向量中多餘空格刪除數，所謂的多餘空格指的是出現在文字左邊的空格（leading blanks）或出現在文字右邊的空格（trailing blanks），至於出現在文字之間的空格，由於多數語言句子的組成都習慣以空格區隔單字，並不算是多餘空格（像是 Luke Skywalker 名字與姓氏之間存在的空格）。加入 which = "left" 參數可以指定刪除左邊多餘空格、 which = "right" 參數可以指定刪除右邊多餘空格，預設 which = "both" 即刪除左邊與右邊多餘空格。

luke <- "   Luke Skywalker   "
print(trimws(luke))
print(trimws(luke, which = "left"))
print(trimws(luke, which = "right"))

描述統計函數

描述統計函數可以針對數值向量做摘要，常用的有：

• mean()

• sd()

• median()

• range()

• sum()

• max()

• min()

mean() 函數能夠將輸入數值向量平均值回傳。

a_vector <- 1:100
print(mean(a_vector))

sd() 函數能夠將輸入數值向量標準差回傳，R 語言中的 sd() 函數定義為樣本標準差，在計算公式中分母使用的是 n — 1

a_vector <- 1:100
print(sd(a_vector))

median() 函數能夠將輸入數值向量中位數回傳。

a_vector <- 1:100
print(median(a_vector))

range() 函數能夠將輸入數值向量中最小值與最大值回傳。

a_vector <- 1:100
print(range(a_vector))

sum() 函數能夠將輸入數值向量中所有數值加總回傳。

a_vector <- 1:100
print(sum(a_vector))

max() 函數能夠將輸入數值向量中最大值回傳。

a_vector <- 1:100
print(max(a_vector))

min() 函數能夠將輸入數值向量中最小值回傳。

a_vector <- 1:100
print(min(a_vector))

描述統計函數都有一個共同的參數 na.rm 能夠將遺漏值向量 NA 排除，如果輸入帶有遺漏值向量，必須要指定 na.rm = TRUE 才能夠回傳答案（ na.rm 預設為 FALSE 。）

a_vector <- 1:100
a_vector <- c(a_vector, NA) # combine a NA
print(min(a_vector))
print(min(a_vector, na.rm = TRUE))

在認識 R 語言常見的系統功能函數、數值向量函數、文字向量函數與描述統計函數之後，本篇文章來到尾聲，希望您也和我一樣期待下一篇文章。

對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Leave a comment

計畫學員專區

Read more

什麼是流程控制

多數程式語言都會從程式碼的第一列開始按照列（Row-wise）的順序往下讀取並且執行，但是在某些情況下，我們會希望能在某些程式碼可以依照需求不執行、執行或者執行多次，這時就可以透過流程控制的機制來滿足這些情況。

流程控制指的是在程式執行時，能夠依賴條件來決定程式區塊（Code blocks）中的指令、敘述或者函數呼叫的執行次數，在條件為邏輯向量 FALSE 的時候，程式區塊中的程式碼執行次數為 0（不執行）；在條件為邏輯向量 TRUE 的時候，程式區塊中的程式碼執行次數大於等於 1。具體來說，流程控制是一種機制，這個機制能讓一段指令在某些情況下不被執行、在某些情況下被執行一次或者在某些情況下被重複執行，R 語言實現流程控制有三種方式：

1. 條件判斷。

2. 迴圈。

3. 例外處理。

其中，條件判斷能夠使用 if-else if-else 敘述與邏輯向量完成；迴圈則有兩種選擇，一是使用 while 迴圈與邏輯向量，二是使用 for 迴圈與資料結構；例外處理能夠使用 tryCatch() 函數完成。

什麼是區塊

區塊（Code blocks）指的是將一系列相關的敘述集合在一起的程式碼結構，在 R 語言中，區塊使用一對大括號（A curly-brace pair）將敘述包裝在裡面形成區塊。在前述三種類型的流程控制中，都會利用區塊將敘述依附給條件判斷、迴圈與例外處理，如此一來就能夠在某些情況下讓區塊中的程式不被執行、執行僅一次或執行特定次數。

function_name <- function() {
  # code block attached to a function
}
if (CONDITION) {
  # code block attached to an if statement
}
while (CONDITION) {
  # code block attached to a while loop
}
for (element in data_structure) {
  # code block attached to a for loop
}

條件判斷

條件判斷是依邏輯向量為假 FALSE 或真 TRUE 時，來決定是否執行一段位於某區塊內的程式，透過 if-else if-else 敘述可以根據指定條件是否成立，決定後續要執行的程式，也可以組合多個 if-else if-else 敘述進行更複雜的條件判斷。

我們使用保留字 if 搭配一個條件形成邏輯向量，就能夠建立一個 if 敘述，if 敘述能夠讓區塊的執行與否依賴條件的邏輯向量，如果條件為 TRUE 則執行依附大括號內的程式區塊；若條件為 FALSE 則不執行依附大括號內的程式區塊。

if (CONDITION) {
  # code block attached to an if statement
}

CONDITION 可以透過關係運算符或者邏輯運算符生成，例如判斷輸入整數是否為正。僅有在輸入為正數時會執行依附大括號內的程式區塊，因此輸入零或負數時函數的輸出皆為 NULL。

is_positive <- function(x) {
  if (x > 0) {
    return("Positive.")
  }
}
print(is_positive(1))
print(is_positive(0))
print(is_positive(-1))

我們使用保留字 if 與 else if 搭配各自的條件建立一個 if-else if 敘述，如果 if 後面的條件為 TRUE 則執行依附其大括號內的程式區塊；若 if 後面的條件為 FALSE 則跳過該區塊改為檢視 else if 後面的條件，如果是 TRUE 就執行依附其大括號內的程式區塊；若 else if 後面的條件為 False 則跳過該區塊。

if (CONDITION) {
  # code block attached to if statement
} else if (CONDITION) {
  # code block attached to else if statement
}

CONDITION 可以透過關係運算符或者邏輯運算符生成，例如判斷輸入整數是否為正。這時輸入零或負數時函數的輸出皆為 “Nonpositive“。

is_positive <- function(x) {
  if (x > 0) {
    return("Positive.")
  } else {
    return("Nonpositive.")
  }
}
print(is_positive(1))
print(is_positive(0))
print(is_positive(-1))

我們使用保留字 if 、else 搭配一個條件建立一個 if-else 敘述，如果 if 後面的條件為 TRUE 則執行依附其大括號內的程式區塊；若 if 後面的條件為 FALSE 則跳過該區塊改為執行依附 else 大括號內的程式區塊。

if (CONDITION) {
  # code block attached to if statement
} else {
  # code block attached to else statement
}

CONDITION 可以透過關係運算符或者邏輯運算符生成，例如判斷輸入整數是否為正。

is_positive <- function(x) {
  if (x > 0) {
    return("Positive.")
  } else {
    return("Nonpositive.")
  }
}
print(is_positive(1))
print(is_positive(0))
print(is_positive(-1))

在前面的例子中，我們可以看到同樣一個「判斷輸入整數是否為正」的函數，可以用不同的條件判斷敘述來實作，那麼在應用情境上，該如何區別與採用？簡單來說，我們可以藉由判斷 CONDITION 是否互斥（Mutually exclusive）來決定。這個說法是依據 if 敘述、if-else if 與 if-else 敘述的主要差別，由於 if-else if 與 if-else 敘述的條件判斷是有先後順序的，當前面 if 敘述得到了邏輯 TRUE，意味著後續的 else if 或 else 敘述就無關緊要了。簡單來說，假如條件彼此之間是互斥的，條件判斷怎麼寫大概都沒有問題；但反過來說，假如條件彼此之間是「非互斥」的話，判斷的順序以及 if 敘述、if-else if 與 if-else 敘述就會需要謹慎地選擇。舉例來說，我們依據 https://en.wikipedia.org/wiki/Body_mass_index 寫作一個函數 get_bmi_desc() 可以根據輸入的 BMI 數值，給予過輕、正常、過重或肥胖的文字輸出，將四個條件寫成互斥的格式：

1. 過輕：BMI < 18.5。

2. 正常：BMI >= 18.5 and BMI < 25。

3. 過重：BMI >= 25 and BMI < 30。

4. 肥胖：BMI >= 30。

在條件互斥的狀況下，怎麼寫大概都沒有問題。

get_bmi_desc <- function(bmi) {
  if (bmi < 18.5){
    bmi_desc <- "過輕"
  } else if (bmi >= 30) {
    bmi_desc <- "肥胖"
  } else if (bmi >= 25 & bmi < 30) {
    bmi_desc <- "過重"
  } else if (bmi >= 18.5 & bmi < 25) {
    bmi_desc <- "正常"
  } 
  return(bmi_desc)
}   
print(get_bmi_desc(17))
print(get_bmi_desc(23))
print(get_bmi_desc(29))
print(get_bmi_desc(31))

但這不表示條件判斷就必須將條件都寫成互斥才可以，在適當順序與敘述安排下，即使非互斥也能達到正確判斷結果。

get_bmi_desc <- function(bmi) {
  if (bmi >= 30){
    bmi_desc <- "肥胖"
  } else if (bmi >= 25) {
    bmi_desc <- "過重"
  } else if (bmi >= 18.5) {
    bmi_desc <- "正常"
  } else {
    bmi_desc <- "過輕"
  } 
  return(bmi_desc)
}   
print(get_bmi_desc(17))
print(get_bmi_desc(23))
print(get_bmi_desc(29))
print(get_bmi_desc(31))

迴圈

迴圈是常見的流程控制之一，這是一種在區塊中只出現一次、但卻可能被連續執行多次的程式碼結構，區塊中的程式碼會執行特定的次數、執行到特定條件成立時結束或者走訪資料結構中的所有內容，迴圈能夠用開始、結束與間隔三個要素描述。

• start：迴圈的開始。

• stop：迴圈的結束。

• step：迴圈從起始前往終止的方法。

我們可以使用保留字 while 與條件建立一個 while 迴圈區塊，當條件為 TRUE 重複執行依附其大括號內的程式區塊。

i = 0 # start
while (CONDITION) { # stop
  # code block attached to while statement
  i <- i + step
} 

CONDITION 可以透過關係運算符或者邏輯運算符生成，例如印出前 n 個奇數。

print_first_n_odds <- function(n) {
  i <- 1
  odds <- c() # empty vector
  while (length(odds) < n) {
    print(i)
    odds <- c(odds, i)
    i <- i + 2
  }
}
print_first_n_odds(5)

我們可以使用保留字 for 與資料結構建立一個 for 迴圈區塊，依附其大括號內的程式區塊會重複執行，直到一維資料結構的所有元素都被走訪完畢。

for (element in data_structure) { # start/stop/step
  # code block attached to for statement
}

一維資料結構被宣告完成的當下，迴圈的三要素就已經描述完畢。

• start 一維資料結構的第一項元素。

• stop 一維資料結構的最後一項元素。

• step 一維資料結構的逗號區隔。

例如印出前 n 個奇數。

print_first_n_odds <- function(n) {
  vector_to_be_iterated <- seq(from = 1, by = 2, length.out = n)
  for (i in vector_to_be_iterated) {
    print(i)
  }
}
print_first_n_odds(5)

在前面的例子中，我們可以看到同樣一個「印出前 n 個奇數」的函數，可以用不同的迴圈類型來實作，那麼在應用情境上，該如何區別與採用？簡單來說，我們可以藉由判斷區塊程式「重複執行的次數是否已知」來決定，已知重複執行次數的情境可以用任意迴圈，未知重複執行次數的情境僅能採用 while 迴圈。這個說法是依據 while 迴圈與 for 迴圈的主要差別，while 在重複執行區塊程式的時候，會在 CONDITION 為 FALSE 的時候終止；而 for 在重複執行區塊程式的時候，會在一維資料結構中的元素用罄時候終止。這表示 while 迴圈根據一個為邏輯向量的物件決定重複執行程式區塊是否終止；for 迴圈則根據一個已知元素數量的資料結構決定重複執行程式區塊是否終止。

舉例來說，寫作一段「猜猜猜數字」程式就是一個「未知重複執行次數」的情況，沒有辦法在一開始就得知需要猜多少次才能結束。

random_integer <- sample.int(100, size = 1)
users_guess <- readline()
number_of_guess <- 1
while (as.integer(users_guess) != random_integer) {
  if (as.integer(users_guess) < random_integer) {
    print("Too small, guess larger!")
  } else if (as.integer(users_guess) > random_integer) {
    print("Too large, guess smaller!")
  }
  users_guess <- readline()
  number_of_guess <- number_of_guess + 1
}
sprintf("Correct! You guessed %s times for the answer %s!", number_of_guess, random_integer)

在 R 語言中所謂的一維資料結構是任意長度的向量（vector）、清單（list），這些一維資料結構都能夠直接放置在 for 迴圈中使用。

print_all_elements <- function(x) {
  for (element in x) {
    print(element)
  }
}
primes_vector <- c(2, 3, 5, 7, 11)
primes_list <- list(2, 3, 5, 7, 11)
print_all_elements(primes_vector)
print_all_elements(primes_list)

但矩陣（matrix）與資料框（data.frame）是具有列（rows）與欄（columns）的資料結構，要特別留意是希望走訪列或者欄。

primes_matrix <- matrix(c(1:5, c(2, 3, 5, 7, 11)), ncol = 2)
primes_dataframe = data.frame(primes_matrix)
# Iterating over a matrix's rows
for (i in 1:nrow(primes_matrix)) {
  print(primes_matrix[i, ])
}
# Iterating over a matrix's columns
for (j in 1:ncol(primes_matrix)) {
  print(primes_matrix[, j])
}
# Iterating over a data.frame's rows
for (i in 1:nrow(primes_dataframe)) {
  print(primes_dataframe[i, ])
}
# Iterating over a data.frame's columns
for (j in 1:ncol(primes_dataframe)) {
  print(primes_dataframe[, j])
}

將流程控制的兩個技巧條件判斷與迴圈合併使用會讓我們的程式撰寫更有彈性，保留字 break 能夠讓我們於走訪的過程中在條件為 TRUE 的時候終止迴圈，舉例來說當走訪到非數值的時候終止迴圈。

primes <- list(2, 3, "5", 7, 11)
for (p in primes) {
  if (!is.numeric(p)) {
      break
  }
  print(p)
}

保留字 next 能夠讓我們於走訪的過程中在條件為 TRUE 的時候略過該元素但是繼續完成迴圈，舉例來說當走訪到非整數的時候略過。

primes <- list(2, 3, "5", 7, 11)
for (p in primes) {
  if (!is.numeric(p)) {
      next
  }
  print(p)
}

例外處理

例外處理指的是針對程式區塊執行時所出現的例外（Exceptions）進行對應的處置，在執行程式區塊時遭遇的例外往往是由於錯誤而引發，包含無效的物件名稱、檔案不存在或型別不正確等，例外處理就是在程式區塊遭遇例外時能夠移交控制權的一種機制。簡單來說，例外處理就像是另一種類型的條件判斷，只不過條件判斷倚賴條件的布林值決定哪個程式區塊要被執行，而例外處理則是依賴程式區塊是否產生了錯誤來決定哪個程式區塊要被執行。我們可以使用函數 tryCatch() 處理例外。

tryCatch(
  {#the "try" part },
  error = function(CONDITION) {
    message(CONDITION) # The original error message
    # Choose a return value in case of error
    return(NA)
  },
  warning = function(CONDITION) {
    message(CONDITION) # The original warning message
    # Choose a return value in case of warning
    return(NULL)
  },
  finally = function(CONDITION) {
    # Everything that should be executed at the end,
    # regardless of success, error, or warning.
  }
)

例如將輸入的兩數相除，在輸入兩數其中一者為文字時候會產生錯誤。

divide <- function(a, b) {
  return(a/b)
}

print(divide(55, '11'))

加入例外處理 tryCatch() 函數以及 error 參數處理輸入文字時會產生的錯誤。

divide <- function(a, b) {
  out <- tryCatch(
    {
     a/b
    },
    error = function(CONDITION) {
      message(CONDITION) # The original error message
      # Choose a return value in case of error
      return(NA)
    }
  )
}
print(divide(55, '11'))

例如將輸入轉換為數值，在輸入文字時候會產生警告、輸出 NA。

print(as.numeric("Hello, world!"))

加入例外處理 tryCatch() 函數以及 warning 參數處理輸入文字時會產生的警告、改為輸出 NULL。

as_numeric_try_catch <- function(x) {
  out <- tryCatch(
    {
      as.numeric(x)
    },
    warning = function(CONDITION) {
      message(CONDITION) # The original error message
      # Choose a return value in case of error
      return(NULL)
    }
  )
}
print(as_numeric_try_catch("Hello, world!"))

在暸解 R 語言條件判斷、迴圈與例外處理這三種流程控制的機制之後，本篇文章來到尾聲，希望您也和我一樣期待下一篇文章。

延伸閱讀

1. https://adv-r.hadley.nz/control-flow.html

2. https://adv-r.hadley.nz/conditions.html

對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Leave a comment

約維安計畫學員專區

Read more

我們在約維安計畫：建立基本資料單位「向量」中已經知道 R 語言的基本資料單位稱作向量（vector），透過結合基本資料單位，能夠組成其他的資料結構，這些資料結構包含彈性的容器：清單（list）、有階層資訊的向量：因素向量（factor）、現代化表格：資料框（data.frame）、二維向量：矩陣（matrix）與多維向量：陣列（array）。

彈性的容器：清單

我們目前熟悉的向量只能被宣告為單一類型，這是為了元素運算（Elementwise operation）而伴隨的侷限，然而在應用上很多不同類型的資料有被儲存在同一個物件中的需求，這時候我們就可以使用 list 資料結構儲存任何類別、長度的向量，使用 list() 函數建立彈性的容器：清單。

a_R_list <- list(
  c(FALSE, TRUE),
  c(55L, 66L, 56L, 5566L),
  c(55, 66, 56, 5566),
  c("Some", "random", "characters")
)
print(a_R_list)
print(class(a_R_list))

清單強大的收納能力用數個雙層中括號 [[]] 將各個向量依順序放入一個物件之中，這時候要選擇裡面的向量，就改使用雙層中括號 [[索引值]] ，在這個清單之中，我們儲存了四個不同類型的向量，依序是長度 2 的邏輯向量、長度 4 的整數向量、長度 4 的數值向量、長度 3 的文字向量，在清單中各個向量依然保有自己的類別。

print(class(a_R_list[[1]]))
print(class(a_R_list[[2]]))
print(class(a_R_list[[3]]))
print(class(a_R_list[[4]]))

建立清單的同時，如果我們有給予向量一個對應的鍵（Key），可以在選擇時改使用 [["key"]] 或 $key ，這時面對的是有命名的清單（Named list）。

a_R_list <- list(
  logicals = c(FALSE, TRUE),
  integers = c(55L, 66L, 56L, 5566L),
  numerics = c(55, 66, 56, 5566),
  characters = c("Some", "random", "characters")
)
# use [["key"]]
print(class(a_R_list[["logicals"]]))
print(class(a_R_list[["integers"]]))
print(class(a_R_list[["numerics"]]))
print(class(a_R_list[["characters"]]))
# use $key
print(class(a_R_list$logicals))
print(class(a_R_list$integers))
print(class(a_R_list$numerics))
print(class(a_R_list$characters))

有階層資訊的向量：因素向量

R 語言針對文字向量有一個額外的資料結構稱為因素向量，這是一種具有層級（Levels）資訊的向量，我們可以使用 factor() 函數將一般的文字向量轉換成因素向量。

four_seasons <- c("spring", "summer", "autumn", "winter")
print(class(four_seasons))
four_seasons_factor <- factor(four_seasons)
print(class(four_seasons_factor))
print(four_seasons_factor)

印出因素向量時會將層級的資訊輸出，預設的層級是以字母順序排列（由 A 排至 Z），而在轉換為因素向量的函數 factor() 之中利用 ordered 與 levels 參數可以依照使用者的偏好做排列。

four_seasons_factor <- factor(four_seasons, ordered = TRUE, levels = c("autumn", "spring", "winter", "summer"))
print(four_seasons_factor)

現代化表格：資料框

資料框是 R 語言用來處理表格式資料（tabular data）的資料結構，它的外觀具有列與欄兩個維度，具備列索引值與欄索引值來支援使用者，並容許每一個欄位（變數）具有自己的類別，使用 R 語言讀取外部地表格式資料也會以資料框的結構儲存，我們可以運用 data.frame() 函數創造資料框。

titles <- c("Batman Begins", "The Dark Knight", "The Dark Knight Rises")
release_years <- c(2005, 2008, 2012)
imdb_ratings <- c(8.2, 9.0, 8.4)
is_on_netflix <- c(TRUE, FALSE, TRUE)
batman_trilogy <- data.frame(title = titles, release_year = release_years, imdb_rating = imdb_ratings, is_on_netflix)
print(batman_trilogy)
print(class(batman_trilogy))

我們使用觀測值（observations）來稱呼資料框中水平方向的資料，使用變數（variables）來稱呼資料框中垂直方向的資料；資料框能夠以 [m, n] 兩個索引值來搭配選擇，其中 m 是資料框的觀測值個數， n 是資料框的變數個數，一個資料框的外觀可以簡潔地以 (m, n) 來描述，例如手動創建的資料框 batman_trilogy 外觀為 (3, 4)，透過 dim() 函數來暸解資料框的外觀。

print(dim(batman_trilogy))
print(batman_trilogy[1, ])  # data in the 1st row
print(batman_trilogy[, 1])  # data in the 1st column
print(batman_trilogy[1, 1]) # data at (1, 1)

資料框支援使用變數名稱來選擇，我們可以用 $variable_name、[["variable_name"]] 或者 [, "variable_name"] 這三種寫法。

print(batman_trilogy$title)
print(batman_trilogy[["title"]])
print(batman_trilogy[, "title"])

我們可以透過邏輯向量來對資料框進行篩選，要注意篩選是針對觀測值（水平方向），所以要將邏輯向量放在逗號前面，逗號後面留空（並沒有要選擇變數。）

print(batman_trilogy[batman_trilogy$is_on_netflix, ])

資料框能包含多種向量類別，可以透過 str() 函數（structure 的縮寫）檢視組成資料框的向量類型。

print(str(batman_trilogy))

資料科學家花費很多的時間與資料框周旋，常應用於探索資料框的函數以及進階的資料框操控技巧會在後續詳細探討。

二維向量：矩陣

矩陣與資料框相同是能夠儲存列（Row）與欄（Column）的資料結構，如果對於分辨行、列與欄這些中文字有障礙的話，我非常推薦用英文來記憶：Row 指的是水平方向資料，Column 指的是垂直方向資料。通用的習慣是先列後欄，假如我們現在要建立一個 (2, 3) 的矩陣，意思就是兩個水平方向搭配三個垂直方向的矩陣。使用 matrix() 函數並指定參數 nrow = 2 將向量轉換成一個 (2, 3) 的矩陣；往後如果聽到一個矩陣是 (m, n) 的外觀，我們心中就會知道，這個矩陣具有 m 個水平方向資料，n 個垂直方向資料。

a_R_matrix <- matrix(c(5, 6, 55, 66, 56, 5566), nrow = 2)
print(a_R_matrix)
print(class(a_R_matrix))

矩陣同樣能夠以 [] 搭配索引值選出裡面的變數，不過跟向量不同的是現在有兩個維度的索引值必須指定，所以要用 [m, n] 兩個索引值來搭配選擇。

print(a_R_matrix[2, 3]) # data at (2, 3)
print(a_R_matrix[2, ])  # data in the 2nd row
print(a_R_matrix[, 3])  # data in the 3rd column

我們也可以透過邏輯向量來對矩陣進行篩選。

print(a_R_matrix[a_R_matrix > 10])

多維向量：陣列

陣列是向量、矩陣的多維度版本，除了原有的水平方向資料（Row）與垂直方向資料（Column）我們可以再多指定 n 個維度，簡單來說，就是在一個陣列的物件之中，可以允許儲存多個矩陣。舉例來說我們就可以用陣列將 1 到 24 這 24 個數字儲存在 4 個 (2, 2) 的矩陣之中。

a_R_array <- array(1:24, dim = c(2, 3, 4))
print(a_R_array)
print(class(a_R_array))

因為有了三個維度，所以在使用索引值選擇時，就需要增加第三個維度的索引值。

print(a_R_array[1, 2, 3]) # data at (1, 2, 3)
print(a_R_array[1, , 3])  # data in the 1st row of the 3rd matrix
print(a_R_array[, 2, 1])  # data in the 2nd column of the 1st matrix

在初步暸解如何在 R 語言其他的資料結構之後，本篇文章來到尾聲，希望您也和我一樣期待下一篇文章。

延伸閱讀

1. https://adv-r.hadley.nz/vectors-chap.html

2. https://r4ds.had.co.nz/factors.html

對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Leave a comment

Read more

向量特性與操作方式

我們在約維安計畫：建立基本資料單位「向量」暸解了如何建立不同類型的向量，包含有：數值向量（numeric）、整數向量（integer）、文字向量（character）、邏輯向量（logical）、日期向量（Date）、日期時間向量（POSIXct POSIXt）與未定義值向量（NA/NULL/NaN/-Inf/Inf）。向量有許多的特性與操作方式值得我們留意及學習，包含有向量是單一類型的、向量可以判斷和轉換類型以及向量元素的讀取、更新和刪除等操作。

向量是單一類型的

向量只能被宣告為單一類型，舉例來說，如果我們使用 c() 函數將不同類型的向量合併，R 語言會依照向上轉型（Upcasting）規則，自動並且隱性地用其中一個更精確的類型去記錄合併後的向量類型。例如將邏輯向量與整數向量合併，會自動獲得整數向量的結果（因為邏輯 FALSE 與 TRUE 能夠分別用整數 0 與 1 包含）；或者將整數向量與數值向量合併，會自動獲得數值向量的結果（因為整數能夠用浮點數包含）。

favorite_integers <- c(FALSE, TRUE, 7L, 24L, 25L)
favorite_numbers <- c(7L, 24.0, 25.0)
print(class(favorite_integers))
print(class(favorite_numbers))

向量可以判斷類型

R 語言針對向量類型的判斷除了使用 class() 與 typeof() 函數能夠直截了當地告訴我們答案以外，也能夠使用一系列 is.向量類型() 函數判斷輸入的向量是否為某個指定的向量類型。除了判斷日期向量與日期時間向量要使用的是 inherits() 函數，其他都可以使用 is.向量類型() 系列函數判斷。

• is.numeric()：判斷是否為數值向量。

• is.integer()：判斷是否為整數向量。

• is.character()：判斷是否為文字向量。

• is.logical()：判斷是否為邏輯向量。

• inherits(x, what = "Date")：判斷是否為日期向量。

• inherits(x, what = "POSIXct")：判斷是否為日期時間向量。

• is.na()：判斷是否為遺漏值向量。

• is.null()：判斷是否為空值向量。

• is.nan()：判斷是否為非數值向量。

• is.infinite()：判斷是否為無限大數值向量。

# is.numeric()
print(is.numeric(7))
print(is.numeric("7"))

# is.integer()
print(is.integer(7L))
print(is.integer(7))

# is.character()
print(is.character("FALSE"))
print(is.character(FALSE))

# is.logical()
print(is.logical(FALSE))
print(is.logical("FALSE"))

# inherits()
sys_date <- Sys.Date()
sys_time <- Sys.time()
print(inherits(sys_date, what = "Date"))
print(inherits("1970-01-01", what = "Date"))
print(inherits(sys_time, what = "POSIXct"))
print(inherits("1970-01-01 00:00:00", what = "POSIXct"))

# is.na()
print(is.na(NA))
print(is.na("NA"))

# is.null()
print(is.null(NULL))
print(is.null("NULL"))

# is.nan()
print(is.nan(NaN))
print(is.nan("NaN"))

# is.infinite()
print(is.infinite(Inf))
print(is.infinite("Inf"))

向量可以轉換類型

R 語言針對向量類型的轉換夠使用一系列 as.向量類型() 函數轉換輸入的向量為某個指定的向量類型。

• as.numeric()：轉換為數值向量。

• as.integer()：轉換為整數向量。

• as.character()：轉換為文字向量。

• as.logical()：轉換為邏輯向量。

• as.Date()：轉換為日期向量。

• as.POSIXct()：轉換為日期時間向量。

• as.na()：轉換為遺漏值向量。

• as.null()：轉換為空值向量。

• as.nan()：轉換為非數值向量。

• as.infinite()：轉換為無限大數值向量。

使用 as.numeric() 函數轉換輸入為數值向量，輸入整數向量、邏輯向量、日期向量或日期時間向量都能順利轉換。

# as.numeric()
print(as.numeric(7L))
print(as.numeric(FALSE))
print(as.numeric(TRUE))
print(as.numeric(sys_date))
print(as.numeric(sys_time))

使用 as.integer() 函數轉換輸入為整數向量，輸入沒有小數位數（或小數位數為零）的數值向量、邏輯值向量、日期向量或日期時間向量都能順利轉換。

# as.integer()
print(as.integer(7.00))
print(as.integer(FALSE))
print(as.integer(TRUE))
print(as.integer(sys_date))
print(as.integer(sys_time))

使用 as.logical() 函數轉換輸入為邏輯向量，輸入數值或整數類型的 0 會轉換成為 FALSE，其他則一律轉換為 TRUE。輸入文字向量的 "FALSE"、"False" 或 "false" 會轉換為 FALSE，反之輸入文字向量的 "TRUE"、"True" 或 "true" 會轉換為 TRUE。

# as.logical()
print(as.logical(0))
print(as.logical(0L))
print(as.logical(1))
print(as.logical(1L))
print(as.logical(sys_date))
print(as.logical(sys_time))

使用 as.character() 函數轉換輸入為文字向量，輸入任意向量類型都能順利轉換。

# as.character()
print(as.character(7))
print(as.character(7L))
print(as.character(FALSE))
print(as.character(TRUE))
print(as.character(sys_date))
print(as.character(sys_time))

使用 as.Date() 函數轉換輸入為日期向量，我們可以輸入文字向量讓 R 語言轉換成日期向量。

使用 as.POSIXct() 函數轉換輸入為日期時間向量，我們可以輸入文字向量讓 R 語言轉換成日期時間向量，如果沒有指定參數 tz 會預設使用電腦的時區。

R 語言預設可以識別 %Y-%m-%d %H:%M:%S 或 %Y/%m/%d %H:%M:%S 這兩種日期時間的文字格式，如果是其他格式，必須要加入 format 參數告知被記錄的日期時間格式為何，函數才能順利轉換。常用的文字對應日期、日期時間格式有：

• %a：縮寫的星期幾，從 Sun 至 Sat。

• %A：全稱的星期幾，從 Sunday 至 Saturday。

• %b：縮寫的月份，從 Jan 至 Dec。

• %B：全稱的月份，從 January 至 December。

• %d：月份中的第幾天，從 01 至 31。

• %m：以兩位數字表示的月份，從 01 至 12。

• %Y：以四位數字表示的西元年份，從 0 至 9999。

• %H：以兩位數字表示的小時，從 00 至 23。

• %M：以兩位數字表示的分鐘，從 00 至 59。

• %S：以兩位數字表示的秒數，從 00 至 59。

# as.Date()
print(as.Date("1970-01-01"))
print(as.Date("1970/01/01"))
print(as.Date("01-01-1970", format = "%m-%d-%Y"))
print(as.Date("01/01/70", format = "%m/%d/%y"))

# as.POSIXct()
print(as.POSIXct("1970-01-01 00:00:00"))
print(as.POSIXct("01-01-1970 00:00:00", format = "%m-%d-%Y %H:%M:%S"))
print(as.POSIXct("1970-01-01 00:00:00", tz = "GMT"))

向量元素的讀取

對於長度超過 1 的向量我能夠使用三種技巧讀取其中的元素：

1. 索引（Indexing）。

2. 切割（Slicing）。

3. 邏輯篩選（Logical filtering）。

向量像是有格子的抽屜，每個格子上面都有一個索引值，方便 R 語言搜尋放在裡頭的資料，這個索引值從左邊由 1 起始計算。

# Indexing
four_seasons <- c("spring", "summer", "autumn", "winter")
print(four_seasons[1])
print(four_seasons[2])
print(four_seasons[3])
print(four_seasons[4])

當索引值是以 start:stop 建立的數值間距為 1 數值向量時，這樣的技巧就稱為切割（Slicing），意即取出一個向量中的某片段。

# Slicing
print(four_seasons[1:3])
print(four_seasons[2:4])

切割也能用 c() 函數結合多個索引值傳入，也可以接受負的索引值，表示採用負面表列方式讀取其中的元素。

# Slicing
print(four_seasons[c(1, 3)])
print(four_seasons[c(2, 4)])
print(four_seasons[c(-2, -4)])
print(four_seasons[c(-1, -3)])

除了使用索引或切割的技巧，亦可以對向量應用條件敘述（Conditional statement），進而產生邏輯向量作為對原向量篩選的依據，會保留判斷為 TRUE 位置的元素。

# Logical filtering
favorite_season <- four_seasons == "winter"
print(favorite_season)
print(four_seasons[favorite_season])

向量元素的更新和刪除

透過索引（Indexing）與 <- 來更新和刪除向量中的元素。

# Update
four_seasons[3] <- "fall"
print(four_seasons)

# Delete
three_seasons <- four_seasons[-3]
print(three_seasons)

在初步暸解如何在 R 語言操作基本資料單位「向量」之後，約維安計畫：操作基本資料單位「向量」來到尾聲，希望您也和我一樣期待下一篇文章。

延伸閱讀

1. https://www.rdocumentation.org/packages/base/versions/3.6.2/topics/strptime

2. https://r4ds.had.co.nz/vectors.html

3. https://adv-r.hadley.nz/vectors-chap.html

對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Leave a comment

Read more

基本資料單位

R 語言的基本資料單位（Building block）稱作向量（Vector），這一點與大多數廣泛用途程式語言（General-purposed programming languages）例如：C/C++ 語言、Java 語言或 Python 有明顯的差異。簡單來說，在 R 語言實踐「哈囉世界」print() 函數其中的 "Hello, World!" 對 R 語言來說就不是以純量（Scalar）來看待她，而是將其視作長度 1 的文字向量。

hello_world <- "Hello, World!"
print(hello_world)
print(class(hello_world))     # Check the class of hello_world
print(is.vector(hello_world)) # Check if hello_world is a vector or not
print(length(hello_world))    # Check the length of hello_world

以向量作為基本資料單位的設定體現了 R 語言作為一個以資料分析為主軸的程式語言理念，對她而言，任何運算都是元素操作（elementwise）。R 語言中的向量有著不同的類型，包含有：數值向量（numeric）、整數向量（integer）、文字向量（character）、邏輯向量（logical）、日期向量（Date）、日期時間向量（POSIXct POSIXt）與未定義值（NA/NULL/NaN/-Inf/Inf）。

如何建立向量

建立長度為 1 的向量非常簡單，只需要用 <- 將不同類型的資料指派給物件名稱即可，使用者不需要自己去猜測向量類型，而是使用函數 class() 或者 typeof() 讓 R 語言告訴我們該物件是什麼類型的向量，並且使用 length() 函數檢視向量長度。

hello_world <- "Hello, World!"
print(hello_world)
print(class(hello_world))  # Check the class of hello_world
print(typeof(hello_world)) # Check the type of hello_world
print(length(hello_world)) # Check the length of hello_world

建立數值向量

如果想要建立長度大於 1 的向量，最常使用的方法是利用 c() 函數（combine 的簡稱），在 c() 函數中可以將多筆資料以逗號分隔以一個物件名稱參照。

favorite_numbers <- c(7, 24, 25)
print(favorite_numbers)
print(class(favorite_numbers))  # Check the class of favorite_numbers
print(typeof(favorite_numbers)) # Check the type of favorite_numbers
print(length(favorite_numbers)) # Check the length of favorite_numbers

rep() 函數（replicate 的簡稱）可以生成包含重複資料的向量，其中 times 參數可以指定向量中要有幾個重複值。

lucky_sevens <- rep(7, times = 3)
print(lucky_sevens)
print(length(lucky_sevens)) # Check the length of lucky_sevens

建立長度大於 1 的數值向量除了如前述一般使用 c() 函數或者 rep() 函數，亦可以呼叫 seq() 函數（sequence 的簡稱）或 : 符號建立具有數列特性的數值向量。 seq() 函數可以生成等差數列，其中 from 參數指定數列的起始值，to 參數指定數列的終止值，by 參數指定數值的間距。

print(seq(from = 7, to = 63, by = 7))

如果單純是要生成數值間距為 1 的數值向量，用 : 符號更快捷。

print(1:20)

不論輸入數字帶有或不帶有小數點，R 語言預設都以數值向量（numeric）儲存。

favorite_numbers <- c(2.718, 3.14, 7, 24, 25)
print(favorite_numbers)
print(class(favorite_numbers))  # Check the class of favorite_numbers
print(typeof(favorite_numbers)) # Check the type of favorite_numbers

建立整數向量

輸入整數並加入大寫英文字母 L 作註記，R 語言就會改儲存為整數向量（integer）。

favorite_integers <- c(7L, 24L, 25L)
print(favorite_integers)
print(class(favorite_integers))  # Check the class of favorite_integers
print(typeof(favorite_integers)) # Check the type of favorite_integers

若在帶有必要小數位數的數字後加上大寫英文字母 L 註記 R 語言將忽略整數向量的註記改以數值向量儲存。

favorite_numbers <- c(2.718L, 3.14L)
print(favorite_numbers)
print(class(favorite_numbers))  # Check the class of favorite_numbers
print(typeof(favorite_numbers)) # Check the type of favorite_numbers

建立文字向量

在 R 語言中我們可以使用成雙的單引號 '' 或成對的雙引號 "" 來建立文字向量（character），多數的時候使用單引號或者雙引號不會有任何分別。

hellos <- c("Hello, World!", 'Hello, R!')
print(hellos)
print(class(hellos))  # Check the class of hellos
print(typeof(hellos)) # Check the type of hellos

但是在部分情境中，使用成雙的單引號或成對的雙引號標註文字向量是有差別的，像是在英文句子中經常出現的非成雙單引號（Apostrophe）以及用作嘲諷強調的空氣雙引號（air-quotes），當文字向量中的內容有出現這些元件時如果沒有特別關注，宣告的當下就會產生錯誤。

# Error: unexpected symbol
mcdonalds <- 'I'm lovin it'
shaq <- 'Shaquille O'Neal'
ross_geller_said <- "Let's put aside the fact that you "accidentally" pick up my grandmother's ring."

這時候我們可以使用跳脫字元反斜線 \ 來完成宣告或者使用不同樣式的引號。

mcdonalds <- 'I\'m lovin it'
shaq <- 'Shaquille O\'Neal'
ross_geller_said <- "Let's put aside the fact that you \"accidentally\" pick up my grandmother's ring."

建立邏輯向量

當我們進行判斷條件或者資料篩選的時候會需要仰賴邏輯向量（logical），邏輯向量只有 FALSE 與 TRUE 這兩個值，亦可以簡寫為 F 與 T

print(class(FALSE))
print(class(TRUE))
print(class(F))
print(class(T))

這裡特別提醒一個觀念，R 語言對於英文的大小寫是敏感的（case-sensitive），像是 TRUE 與 T 會被識別為邏輯向量，但是 True、true 或者 t 則會被視作物件以及函數名稱。

建立日期向量

在 R 語言中日期向量（Date）的外觀看起來跟文字向量並沒有什麼差別，但是當我們一但將它們放入 class() 函數中檢驗，就會發現並不是文字向量，接下來使用的 Sys.Date() 是不需要參數就會輸出電腦系統日期向量的函數。

sys_date <- Sys.Date() # system date vector
print(sys_date)        # looks like a character
print(class(sys_date))

R 語言預設以西元 1970 年 1 月 1 日作為 0，在這一天以後的每天都 +1 來記錄，而這一天以前的每天都 -1 來記錄。文字向量與日期向量兩者最大的分野，在於日期向量可以進行數值運算，而文字向量不行。

print(sys_date - 1)
print(sys_date + 1)

建立日期時間向量

在 R 語言中日期時間向量（POSIXct POSIXt）的外觀看起來跟文字向量同樣也沒有什麼差別，但是我們一但將它們放入 class() 函數中檢驗，就會發現並不是文字向量，接下來使用的 Sys.time() 函數是不需要參數就會輸出電腦系統日期時間向量的函數。

sys_time <- Sys.time() # system time vector
print(sys_time)        # looks like a character
print(class(sys_time))
print(typeof(sys_time))

R 語言預設以西元 1970 年 1 月 1 日格林尼治標準時間（Greenwich Mean Time，GMT）00 時 00 分 00 秒作為 0，在這個時間點以後的每秒都 +1 來記錄，這個時間點以前的每秒都 -1 來記錄。文字向量與日期時間向量兩者最大的分野，在於日期時間向量可以進行數值運算，而文字向量不行。

print(sys_time - 1)
print(sys_time + 1)

建立未定義值向量

R 語言有豐富的未定義值向量，用來表示一些特殊情境所需要的表示，有遺漏值向量 NA、空值向量 NULL、非數值向量 NaN 以及無限大數值向量 Inf。建立這些未定義值向量就像建立邏輯向量一般，直接輸入保留字即可。

print(NA)
print(NULL)
print(NaN)
print(Inf)
print(-Inf)

在初步暸解如何在 R 語言建立基本資料單位「向量」之後，約維安計畫：建立基本資料單位「向量」來到尾聲，希望您也和我一樣期待下一篇文章。

延伸閱讀

1. https://r4ds.had.co.nz/vectors.html

2. https://adv-r.hadley.nz/vectors-chap.html

對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Leave a comment

Read more

解析哈囉世界

在約維安計畫：R 語言起步走我們透過 print("Hello, World!") 來確認 R 語言的開發環境及執行環境是否已經安裝妥當，在這一段哈囉世界的程式碼中，其實就能體會我們在文章一開始引用 Greg Martin 對於 R 語言核心精神的詮釋：對資料結構應用函數。

The way R works is pretty straightforward, you apply functions to objects.

Greg Martin

print 是函數的名稱，print() 則表示要應用該函數的功能，而 “Hello, World!“ 則是一個被稱呼為文字（Character）的向量資料結構；換言之，哈囉世界可以表達為：對 “Hello, World!“ 這個文字向量應用了 print() 函數。

print("Hello, World!")
## [1] "Hello, World!"

什麼是函數

函數是構成所有程式語言的基本要素，一個函數是一段「被命名」的程式碼，這段程式碼可以用於執行某個特定任務，可能是數值的運算或者文字的處理，當使用者想要應用（使用、呼叫）某一個函數之前，必須先確定在欲產生作用的範疇中該函數已經被定義或者被載入。簡而言之，在哈囉世界的程式碼中，之所以能夠對字串 “Hello, World!“ 應用 print() 函數，是因為 print() 函數屬於 R 語言的內建函數，在 R 語言啟動的當下就會被載入供我們使用。

函數的來源

R 語言使用者除了能夠應用內建函數以外，還可以從其他兩個管道取得所需要的函數：

1. 套件（Packages）。

2. 自行定義。

僅有內建函數可以供我們直接使用，另外兩個管道的函數都必須在使用之前確定好在欲產生作用的範疇中已經被載入或者定義。使用套件中的函數之前，我們必須確認套件是否已經安裝、載入，使用自行定義的函數之前，則是必須確認該函數是否已經完成定義。載入套件的函數是 library()。

library("package_name")

function_name()

我們短期還沒有要使用套件中的函數，不過倒是馬上會有自行定義函數的需求，自行定義函數需要考慮五個組成要件：

1. 函數名稱。

2. 輸入。

3. 參數。

4. 函數主體。

5. 輸出。

看似抽象，不過想想平日購買珍珠鮮奶茶的流程，就像是函數的運作一般：

1. 函數名稱：購買珍珠鮮奶茶。

2. 輸入：中杯 35 元；大杯 50 元。

3. 參數：甜度（無糖、微糖、半糖、少糖、全糖）與冰塊（去冰、少冰、全冰）。

4. 函數主體：點餐、貼標籤、加珍珠、加冰塊、倒茶、加鮮奶一直到封口。

5. 輸出：珍珠鮮奶茶。

function_name <- function(INPUTS, PARAMETERS){
    # body of the function
    # ...
    # ...sequence of statements
    return(OUTPUTS)
}

# 是用來標記註解的符號，有 # 標記的該行敘述將不會被 R 語言執行，這讓寫程式的人能夠用口語來描述這段程式的目的是什麼，如果將哈囉世界改寫為函數形式，每次只需要輸入函數名稱並加上小括號 hello_world()，就可以獲得 “Hello, World!“ 這個文字向量為輸出。

hello_world <- function(){
    return("Hello, World!")
}
hello_world()
## [1] "Hello, World!"

建立物件

除了直接對 “Hello, World!“ 文字向量應用 print() 函數，更常見的作法是將資料賦值給物件（Objects），然後再對物件應用函數，完整的說法為 a_character 物件是文字向量這個資料結構的實例（Instance）。

a_character <- "Hello, World!"
a_character
## [1] "Hello, World!"

在為物件取名稱的時候，應該要謹記四個原則：

1. 命名的時候使用有意義的全小寫英文，採用蛇形命名法（Snake-case），不同單字之間以底線 _ 相隔；或者採用駝峰命名法（Camel-case），不同單字之間以大寫區隔。例如 a_character 或者 aCharacter

2. 使用 <- 而非 = 作為賦值運算符。

3. 不可以使用保留字做為物件的命名，這樣做將會產生直譯錯誤。

4. 不要使用內建函數做為物件的命名，這樣做將會覆蓋內建函數的功能。

其中 R 語言的保留字可以透過 help(reserved) 來查詢。

help(reserved)
## if else repeat while function for in next break
## TRUE FALSE NULL Inf NaN NA 
## NA_integer_ NA_real_ NA_complex_ NA_character_

什麼是資料結構

在電腦科學中資料結構是用來儲存、組織以及存取數據的機制，資料科學家日常工作中大幅仰賴資料結構作為輸入、清理、轉換、分析與輸出數據的平台。R 語言與其他程式語言（例如 Python）最大的差異在於她省略了「資料類別」這個層級，直接以「資料結構」作為最基本的單位，這點是一個很大的不同。

R 語言最基本的資料結構是向量（vector），由向量可以再組織、轉換為其他的資料結構，常用的六種基本資料結構有：

1. 向量（vector）。

2. 矩陣（matrix）二維向量。

3. 陣列（array）n 維向量。

4. 因素向量（factor）具有整數編碼的文字向量。

5. 清單（list）一維異質向量。

6. 資料框（data.frame）二維異質向量。

而向量作為最基本的單位，還可以再細分為七種不同類型：

1. 數值（numeric）。

2. 整數（integer）。

3. 文字（character）。

4. 邏輯（logical）。

5. 日期（date）。

6. 日期時間（POSIXct）。

7. 未定義值（NA/NULL/NaN/-Inf/Inf）。

由於常見對資料結構應用函數的時候，都是對建立完成的物件應用，而非直接對資料結構本身應用，這是因為程式設計通常在後續會有資料記錄與運算處理的需求，並不僅止與將其印出來而已。所以我們需要一個能夠將完成宣告的物件所儲存之資料結構告知使用者的內建函數，這個內建函數是 class() 或者 typeof()，作用是將被應用物件的資料結構回傳。

a_character <- "Hello, World!"
class(a_character)
## [1] "character"
typeof(a_character)
## [1] "character"

對資料結構應用函數的兩種語法

在 R 語言中對資料結構應用函數可以使用兩種語法：

1. function_name(object_name)

2. object_name PIPE OPERATOR function_name()

第一種是最為常見、也更為大眾接受的語法，函數名稱的小括號中輸入物件名稱。

a_character <- "Hello, World!"
print(a_character)
## [1] "Hello, World!"

第二種則是比較少見的語法，物件名稱後加入一個 PIPE OPERATOR 連結函數名稱的小括號。

a_character <- "Hello, World!"
a_character |> print()
## [1] "Hello, World!"

其中的 |> 就是所謂的 PIPE OPERATOR，在 R4.1 以後的版本是內建的運算符號，如果是在 R4.1 以前的版本，就要使用 magrittr 套件給予的 %>% 作為 PIPE OPERATOR

# install.packages("magrittr")
library("magrittr")

a_character <- "Hello, World!"
a_character %>% print()
## [1] "Hello, World!"

在初步認識 R 語言的函數與資料結構之後，約維安計畫：對資料結構應用函數來到尾聲，希望您也和我一樣期待下一篇文章。

延伸閱讀

1. https://adv-r.hadley.nz/functions.html

2. https://adv-r.hadley.nz/vectors-chap.html

3. https://r4ds.had.co.nz/pipes.html

對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Leave a comment

計畫學員專區

付費訂閱電子報的會員可以點選 nbgitpuller 連結將本篇文章完整的 Jupyter Notebook 複製到自己的 Jupyter Server：

nbgitpuller 連結

伺服器選項選擇預設的「Data science environment：學習 Python、R 與 Julia 的資料科學環境」就可以順利運作文章中的範例程式。

忘記了什麼是 Jupyter 星球嗎？複習一下約維安計畫：歡迎光臨 Jupyter 星球吧！

The way R works is pretty straightforward, you apply functions to objects.

Greg Martin

R 語言由紐西蘭奧克蘭大學的 Ross Ihaka 和 Robert Gentleman 所設計、R 核心團隊維護，是一個開源的統計程式語言，常用於開發統計和資料分析軟體系統，近年在 Hadley Wickham 與 RStudio 團隊所建構的應用套件 Tidyverse 生態系以及大數據、資料科學與人工智慧的熱潮加持，廣受統計學家和資料科學家的熱愛。

R 語言的受歡迎程度

截至 2022 年 1 月，R 語言在 TIOBE Index 排名第 12、在 IEEE Top Programming Languages 2021 調查排名第 7。

對比與 R 語言定位相同、以資料分析為主應用的程式語言：Matlab 在 TIOBE Index 排名第 16 、在 IEEE Top Programming Languages 排名第 12；Julia 在 TIOBE Index 排名第 28、在 IEEE Top Programming Languages 排名第 20；SAS 在 TIOBE Index 排名第 22、在 IEEE Top Programming Languages 排名第 30。

從這些專注資料分析為主應用的程式語言排名來看，未來 Analytic Programmer（擅長資料分析的程式設計師）或者 Programming Analyst（擅長程式設計的資料分析師）依然是炙手可熱的人才。

與商業授權的 Matlab 和 SAS 相較，R 語言是免費軟體授權（Free software license）；而與同為免費軟體授權的 Julia 相較，R 語言在現階段具備更廣大的使用者社群（以開發者貢獻的套件數來比較，截至 2022 年 1 月，Julia 目前有超過四千個套件、R 則有超過一萬八千個套件。R 以函數型程式設計（Functional programming）與資料分析作為設計理念核心，因此在她的視野中，所有的資料（文字、數值或邏輯等）都不是以純量存在，而是以向量存在，這樣的設計理念使得元素運算（Elementwise operation）對 R 語言使用者而言是理所當然的。稍微暸解了 R 語言的特性之後，展開學習旅程的第一站是 R 語言的哈囉世界！

R 語言的哈囉世界

「哈囉世界」是每種語言最基本也最簡單的程式，通常用作確認一個語言如何運作、編譯器、開發環境及執行環境是否已經安裝妥當。要順利運行 R 語言的哈囉世界以及未來的 R 語言資料科學應用，首先要確定在 Jupyter 星球的伺服器選項選擇了「Data science environment：學習 Python、R 與 Julia 的資料科學環境」。忘記了什麼是 Jupyter 星球嗎？複習一下約維安計畫：歡迎光臨 Jupyter 星球吧！

伺服器啟動之後來到 Jupyter 星球的首頁，在右方 Launcher 點選新增一個核心（Kernel）為 R 的 Jupyter Notebook。

並且在 Jupyter Notebook 的第一個儲存格中印出 R 的哈囉世界：

print("Hello, World!")

整合開發環境 RStudio 介面

也可以在 Jupyter 星球啟動 R 語言愛好者很喜歡的整合開發環境 RStudio。

整合開發環境 RStudio 介面會顯示三個區塊。

透過點選新增一個 R 程式碼檔案（R Script）將完整的四個區塊都顯示出來。

RStudio 介面主要的四個區塊與功能簡介：

1. 來源（Source）：位於左上角，編寫程式的區塊。

2. 命令列（Console）：位於左下角，執行程式且呈現輸出的區塊。

3. 環境與歷史：位於右上角，其中環境（Environment）會顯示出目前可以取用的值（Values）、資料（Data）與函數（Functions）；歷史（History）會顯示在命令列執行過哪些指令。

4. 檔案、圖形、套件、查詢與預覽器：位於右下角，其中檔案（Files）會顯示 R 語言所在的工作目錄（Working Directory）、圖形（Plots）則能瀏覽覺化圖形、套件（Packages）可以觀察套件安裝與載入現況、查詢（Help）能夠檢視使用者查詢的文件以及預覽器（Viewer）是預覽網頁的輸出結果。

離開 RStudio 的方式可以採用點擊視窗右上角的電源圖示離開或者在命令列輸入 q() 後按下 Enter，離開時若是環境中有資料存在會詢問是否要儲存工作空間，如果希望下一次啟動時保有目前環境中的物件，可以選擇儲存工作空間，但多數的 R 語言使用者不會儲存工作空間。

挑選 RStudio 佈景主題色彩

整合開發環境 RStudio 能夠做的設定非常多，通常初學者一開始最需要做的是挑選一個自己喜歡的 RStudio 佈景主題，透過點選工具列 Tools -> Global Options 就能夠在 Appearance 頁籤選擇一個偏愛的佈景主題色彩，長時間盯著電腦螢幕的使用者通常偏好使用深色背景減少刺眼感覺。

大功告成，在順利執行了 R 語言的哈囉世界以及選擇喜愛的 RStudio 佈景主題之後，第二十三週的約維安計畫：R 語言起步走來到尾聲，希望您也和我一樣期待下一篇文章。

對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Leave a comment

延伸閱讀

• https://www.tiobe.com/tiobe-index

• https://spectrum.ieee.org/top-programming-languages

約維安計畫即將迎來第三個里程碑專案！從第十二週到第二十一週，我們從 Python 起步走到了進階技巧，並且完成了三份基於主題的練習題，暸解如何在 Jupyter 星球學習並且練習 Python。

透過這個里程碑專案，正是讓我們複習一下這十週學習文章的好機會！

1. 約維安計畫：Python 起步走

2. 約維安計畫：Python 的資料型別

3. 約維安計畫：Python 的資料結構

4. 約維安計畫：Python 的流程控制

5. 約維安計畫：Python 的函數

6. 約維安計畫：Python 的類別

7. 約維安計畫：Python 的模組

8. 約維安計畫：Python 技巧

9. 約維安計畫：Python 資料結構與流程控制練習題

10. 約維安計畫：Python 函數、類別、模組與技巧練習題

里程碑專案

點擊第二十二週的資料夾連結：第二十二週的專案資料夾。

Read more

從第十二週到第十九週，我們從 Python 起步走到 Python 技巧，中級約維安已經具備了 Python 基礎的程式設計能力，本週約維安計畫安排與 Python 函數、類別、模組與技巧這四個主題相關的練習題。

忘記了什麼是 Python 函數、類別、模組與技巧嗎？不要緊，透過本週的練習題，正是讓我們複習一下這兩週學習文章的好機會！

1. 約維安計畫：Python 的函數。

2. 約維安計畫：Python 的類別。

3. 約維安計畫：Python 的模組。

4. 約維安計畫：Python 技巧。

練習題

點擊第二十一週的資料夾連結：

第二十一週的資料夾連結

點擊連結之後將會複製一份專案資料夾到 Jupyter 星球的首頁，開啟這個資料夾我們可以看到四個檔案：

• README.md

• exercises.ipynb

• sugges…

Read more

從第十二週到第十九週，我們從 Python 起步走到 Python 技巧，中級約維安已經具備了 Python 基礎的程式設計能力，本週約維安計畫安排與 Python 資料結構和流程控制這兩個主題相關的練習題。

忘記了什麼是 Python 資料結構和流程控制嗎？不要緊，透過本週的練習題，正是讓我們複習一下這兩週學習文章的好機會！

1. 約維安計畫：Python 的資料結構。

2. 約維安計畫：Python 的流程控制。

練習題

點擊第二十週的資料夾連結：

第二十週的資料夾連結

點擊連結之後將會複製一份專案資料夾到 Jupyter 星球的首頁，開啟這個資料夾我們可以看到三個檔案：

• README.md

• exercises.ipynb

• suggested_answers.ipynb

要順利運行 Python 的哈囉世界…

Read more

我們從約維安計畫：Python 的資料型別一直到約維安計畫：Python 的模組介紹並且討論了學習任何一個程式語言必要的主題：資料型別、資料結構、流程控制以及程式碼組織機制，本篇文章會簡介幾個 Python 使用者常會遭遇到的技巧，透過它們可以撰寫更簡潔且有效率的程式碼，為學習 Python 基礎程式設計能力階段畫下完美的句點，這些技巧包括：Comprehensions、生成器、具有生成器特性的內建函數以及讀取檔案。

Comprehensions

Comprehensions 目前還沒有一致的中文翻譯，常見的中文翻譯有解析式、生成式、建構以及理解，這種情況我比較傾向直接使用原本的英文名詞，Comprehensions 指的是依賴序列來建立資料結構的一種語法，在 Python 2 推出了 List comprehension，亦即透過序列來建立串列（list），在 Python 3 除了同樣有 List comprehension 之外，也新增了 Dictionary comprehension 以及 Set comprehension，亦即透過序列來建立字典（dict）以及集合（set）。

首先我們回顧傳統透過序列來建立串列的方式，在走訪這個序列之前先建立一個長度為零、空的串列，然後在走訪過程中一一將想要存放的元素透過串列的 append() 方法添加。

primes = [2, 3, 5, 7, 11]
squared_primes = []
for p in primes:
    squared_primes.append(p**2)
print(squared_primes)

如果是採取 List comprehension 的語法，我們可以透過所謂的 Python 一列程式（Python one-liner）將建立串列與走訪序列兩個步驟合而為一。

primes = [2, 3, 5, 7, 11]
squared_primes = [p**2 for p in primes] # list comprehension
print(squared_primes)

假使在走訪過程中有條件判斷的需求，傳統透過序列來建立串列的方式必須在迴圈的程式區塊下再新增一個 if 敘述的程式區塊，如此一來就會有兩層的縮排、兩個程式區塊。

primes = [2, 3, 5, 7, 11]
squared_odd_primes = []
for p in primes:
    if p % 2 == 1:
        squared_odd_primes.append(p**2)
print(squared_odd_primes)

若是採取 List comprehension 的寫法，可以進一步將建立串列、走訪序列以及條件判斷三個步驟合而為一。

primes = [2, 3, 5, 7, 11]
squared_odd_primes = [p**2 for p in primes if p % 2 == 1] # list comprehension
print(squared_odd_primes)

除了能容納 if 敘述，更可以延伸為 if-else 敘述，傳統透過序列來建立串列的方式必須在迴圈的程式區塊下再新增一個 if-else 敘述的程式區塊，如此一來就會有兩層的縮排、三個程式區塊。

primes = [2, 3, 5, 7, 11]
is_even_primes = []
for p in primes:
    if p % 2 == 0:
        is_even_primes.append(True)
    else:
        is_even_primes.append(False)
print(is_even_primes)

若是採取 List comprehension 的寫法，同樣可以進一步將建立串列、走訪序列以及條件判斷三個步驟合而為一。

primes = [2, 3, 5, 7, 11]
is_even_primes = [True if p % 2 == 0 else False for p in primes] # list comprehension
print(is_even_primes)

兩相對比之下，假設在走訪過程中有 if-else 敘述的設計，改寫為 List comprehension 可以將六列程式碼壓縮為一列，程式碼精簡的成果十分可觀。

同樣的寫法，也可以更改為 Set comprehension 與 Dict comprehension 以一列程式碼透過序列建立集合與字典。

primes = [2, 3, 5, 7, 11]
squared_primes = {p**2 for p in primes} # set comprehension
print(squared_primes)
print(type(squared_primes))
squared_primes = {p: p**2 for p in primes} # dict comprehension
print(squared_primes)
print(type(squared_primes))

到這裡，中級約維安可能會產生一個疑問：為什麼有 List、Set 與 Dictionary comprehensions，獨缺了 Tuple comprehension？於是將 Comprehension 的寫法改為了小括號嘗試看看。

primes = [2, 3, 5, 7, 11]
squared_primes = (p**2 for p in primes)
print(squared_primes)
print(type(squared_primes))

沒有 Tuple comprehension 的原因是這個寫法得到了稱為生成器（Generators）的類別，也是本篇文章會涵蓋的第二個技巧。

生成器

生成器（Generators）是與 Comprehensions 相似的觀念，都是透過序列來生成資料的機制，不同的地方在於 Comprehensions 所產出的資料結構中儲存的是「資料值」，生成器則是儲存「資料值的生成規則」，這樣子的「資料值生成規則」必須要經過實例化才能將資料值儲存到資料結構中，就如同自行定義好類別中的資料與函數之後，必須透過一個物件作為該類別的實例，才可以使用物件的屬性與方法。若是以料理來比喻，Comprehensions 的輸出是最後端上桌的菜餚，而生成器的輸出則是菜餚的食譜。

那麼該如何「實例化」生成器類別為資料結構的物件呢？我們可以指定用 list() 函數或 tuple() 函數等將生成器類別化作串列或 Tuple。

primes = [2, 3, 5, 7, 11]
squared_primes = (p**2 for p in primes)
print(list(squared_primes))  # instantiate as a list
squared_primes = (p**2 for p in primes)
print(tuple(squared_primes)) # instantiate as a tuple

生成器類別相較於 Comprehensions 具有儲存的效率優勢，關於這一點或許很抽象，但我們可以從它僅能夠被實例化一次的特性中觀察出這個優勢，嘗試第二次實例化生成器類別就會發現得到一個空的（長度為零）資料結構，表示「資料值生成規則」已經被刪除。

primes = [2, 3, 5, 7, 11]
squared_primes = (p**2 for p in primes)
print(list(squared_primes))  # instantiate as a list
print(tuple(squared_primes)) # empty tuple

具有生成器特性的內建函數

為什麼除了 Comprehensions 以外我們還要認識生成器這個技巧呢？在沒有空間或者時間的資源限制下，是否有必要多暸解這個不是太具體的觀念來混淆自己呢？其實，如果生成器類別並不是那麼常見，我自己認為這個技巧是可以暫時略過的，但是因為有不少方便且好用的內建函數輸出具備了生成器類別特性，認識生成器就變得不可或缺。具體來說有兩類的內建函數：迭代器函數（Iterator functions）與函數型函數（Functional functions），其中迭代器函數包含 enumerate() 函數以及 zip() 函數，函數型函數包含 map() 函數與 filter() 函數。

迭代器函數：

• enumerate() 函數，能夠讓迴圈同時走訪序列的「索引值」與「資料值」，回傳會是 enumerate 類別的實例。

• zip() 函數，能夠讓迴圈同時走訪多個序列的「資料值」，回傳會是 zip 類別的實例。

primes = [2, 3, 5, 7, 11]
odds = [1, 3, 5, 7, 9]
enum = enumerate(primes)
zipped = zip(primes, odds)
print(enum)
print(list(enum))
print(list(enum))   # empty list
print(zipped)
print(list(zipped))
print(list(zipped)) # empty list

函數型函數：

• map() 函數，逐次把序列中的「資料值」當作參數傳給輸入的函數，回傳會是 map 類別的實例。

• filter() 函數，逐次把序列中的「資料值」當作參數傳給輸入的函數，保留函數回傳值為 True 的輸出，回傳會是 filter 類別的實例。

def squared(x):
    return x**2
def is_odd(x):
    return x % 2 == 1
primes = [2, 3, 5, 7, 11]
mapped = map(squared, primes)
filtered = filter(is_odd, primes)
print(mapped)
print(list(mapped))
print(list(mapped))   # empty list
print(filtered)
print(list(filtered))
print(list(filtered)) # empty list

前述不論是 enumerate 類別的實例、zip 類別的實例、map 類別的實例或 filter 類別的實例，都是具有生成器特性的類別，意即都需要實例化才能夠成為有儲存資料值的資料結構。

使用函數型函數的時候，假如作為輸入的函數操作是簡單的邏輯，例如前述的 squared() 函數以及 is_odd() 函數，Python 使用者更習慣是將其寫作為 lambda 函數的結構， lambda 函數也稱為「匿名函數」，不同於使用 def 語法定義函數，可以在搭配函數型函數的情況下「同時」定義與使用。

primes = [2, 3, 5, 7, 11]
print(list(map(lambda x: x**2, primes)))
print(list(filter(lambda x: x % 2 == 1, primes)))

讀取檔案

面對副檔名為 txt、csv 或者 json 的純文字檔案，透過 Python 的 with 語法，程式會自動進行檔案相關資源的建立、清理與回收，在 with 語法架構下使用內建函數 open(file_path, “r“) 建立檔案物件，就可以讓使用者輕鬆地在有資源管理的前提下進行檔案的讀取，而不會有檔案被鎖定或者錯誤的情況。

副檔名為 txt 的純文字檔案，可以用檔案物件的 readlines() 方法將檔案內容一列一列（row-by-row）讀入成為串列中的元素。

with open("the_shawshank_redemption_summaries.txt", "r") as file:
    the_shawshank_redemption_summaries = file.readlines()
for e in the_shawshank_redemption_summaries:
    print(e)

副檔名為 csv 的純文字檔案，可以用標準模組 csv 的 DictReader 類別將 csv 檔案的每一列讀入成為一個以欄位名稱作為鍵（Keys）、觀測值內容作為值（Values）的字典。

import csv

with open("imdb_top_rated_movies.csv", "r") as file:
    csv_dict_reader = csv.DictReader(file)
    for row in csv_dict_reader:
        print(row)

副檔名為 json 的純文字檔案，可以用標準模組 json 的 load() 函數將 json 檔案讀入成為一個字典或者由字典所組合而成的串列。

import json

with open("imdb_top_rated_movies.json", "r") as file:
    list_of_dicts = json.load(file)
for row in list_of_dicts:
    print(row)

在認識了 Comprehensions、生成器、具有生成器特性的內建函數以及讀取檔案等技巧之後，約維安計畫：第十九週來到尾聲，希望您也和我一樣期待下一篇文章。

延伸閱讀

• https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions

• https://docs.python.org/3/library/csv.html

• https://docs.python.org/3/library/json.html

對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Leave a comment

計畫學員專區

付費訂閱電子報的會員可以點選 nbgitpuller 連結將本篇文章完整的 Jupyter Notebook 以及範例資料（the_shawshank_redemption_summaries.txt、imdb_top_rated_movies.csv、imdb_top_rated_movies.json）複製到自己的 Jupyter Server：

nbgitpuller 連結

伺服器選項選擇預設的「Data science environment：學習 Python、R 與 Julia 的資料科學環境」就可以順利運作文章中的範例程式。

約維安計畫：Python 的類別說明程式設計師因應不同目的以及應用場景，有組織程式碼的需求，希望可以簡潔且有效率地完成任務，Python 與大多數的程式語言相同，擁有其他組織程式碼的機制，具體而言有三個層次，由小而大依序為：

1. 函數（Functions）。

2. 類別（Classes）。

3. 模組（Modules）。

本篇文章要介紹組織程式碼機制的第三個層次：模組。

什麼是模組

模組是 Python 組織程式碼包容性最高的機制，當我們自行定義了為數眾多的函數與類別，下一步就可以使用模組來包裝這些程式碼，那麼模組究竟在實體上的形式為何？具體來說，模組就是副檔名為 .py 的檔案（Files）或資料夾（Folders），在裡頭記錄了自行定義的函數以及類別。一個名為 my_module.py 的檔案，就被稱為「my_module」模組，當檔案的數量也增多了的時候，就可以利用資料夾收納這些檔案，而一個名為 my_module 的資料夾，也同樣被稱為「my_module」模組。

如同函數有不同來源一般，模組同樣也有三個來源：

1. 標準模組。

2. 第三方模組。

3. 來自使用者的定義。

Python 程式語言引以為傲的一個特點是自帶電池哲學（Battery included philosophy），這個形容指的是極為豐富的標準模組，這個特點從標準模組的官方文件連結可見一斑：https://docs.python.org/3/library。

使用模組

如果想要使用標準模組中的功能，要透過 import 的指令定義，再透過句號（.）參照附屬其中的函數或者類別。

import module_name

module_name.function_name()       # use module's function
object = module_name.class_name() # use module's class

例如載入標準模組 random，然後使用附屬於其中的 randint() 函數。

import random

random.randint(0, 1)

使用模組的使用者並不會知道具體的形式是副檔名為 .py 的檔案或資料夾，如果想要暸解模組形式以及儲存在電腦中的路徑，可以檢視模組的 __file__ 屬性。

print(random.__file__)

假如有時候我們只需要取用模組中少部分的函數或類別，也可以「選擇性」地透過 from 搭配 import 來載入指定功能。

from module_name import function_name
from module_name import class_name

function_name()       # use module's function
object = class_name() # use module's class

例如指定載入標準模組 random 中的 randint() 函數。

from random import randint

randint(0, 1)

除了可以依照使用者的需求多寡決定要載入整個模組或僅載入部分功能，另外一個更好的判斷準則就是仿效模組的說明文件（Documentation）的做法。

使用第三方模組

第三方模組並不像標準模組會在安裝 Python 的時候就一併安裝，即便是資料科學普遍使用的 Anaconda 預先安裝了超過 7,500 個模組，也很有可能獨漏了想要使用的特定模組，因此載入之前必須要先確認模組是否已經安裝妥當，如果模組沒有安裝就嘗試載入，會遭遇到 ModuleNotFoundError。

try:
    import third_party_module
except ModuleNotFoundError:
    print("Module is not installed.")

安裝模組的方式是在命令列以 pip install 安裝，如果要更新已安裝的模組，只要加上參數 -U 即可。pip 是 Python 的模組管理系統，可以用來從 PyPI（Python Package Index）下載、安裝和管理模組，從 Python 3.4 起都會預先安裝 pip。

~$ pip install module_name
~$ pip install -U module_name

忘記了什麼是命令列嗎？複習一下約維安計畫：初嘗命令列的滋味吧！

例如安裝數值計算的第三方模組 numpy。

~$ pip install numpy
~$ pip install -U numpy

有的時候因為模組的名稱比較長，可以用 as 保留字命名縮寫方便使用，模組命名縮寫雖然可以依個人偏好取名，但是建議遵守說明文件中的縮寫，像是數值計算的第三方模組 numpy 在官方文件中縮寫為 np，所有人都會使用這個縮寫。

import numpy as np

np.random.randint(0, 2, size=5)

自行定義模組

將函數、類別撰寫在工作目錄（Working directory）中一個副檔名為 .py 的檔案中，若是函數與類別的數量眾多時，就可以用一個資料夾將這些檔案收納起來，不論是資料夾名稱或檔案名稱，都是模組的命名，若想要取得其中的函數與類別，就要載入模組之後依照資料夾、檔案、類別與函數的名稱用句號（.）參照取用。

例如在工作目錄中新增擁有下述樹狀結構的資料夾：

my_modules
- calculator.py
- stats.py

在 calculator.py 中寫入約維安計畫：Python 的類別中所自行定義的 SimpleCalculator 類別。

# calculator.py
class SimpleCalculator:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def __repr__(self):
        return "a: {}, b: {}".format(self.a, self.b)
    def add(self):
        return self.a + self.b

在 stats.py 中寫入自行定義的 mean 函數。

# stats.py
def mean(*args):
    return sum(args) / len(args)

以 import 指令載入模組之後依照資料夾、檔案、類別與函數的名稱用句號（.）參照取用。

import my_modules.calculator
import my_modules.stats

sc = my_modules.calculator.SimpleCalculator(5, 6)
print(sc.add())
print(my_modules.stats.mean(5, 6, 55, 66, 5566))

當然也能夠搭配 from 載入 my_modules 模組下的 calculator 模組與 stats 模組後再取用其中的類別與函數。

from my_modules import calculator
from my_modules import stats

sc = calculator.SimpleCalculator(5, 6)
print(sc.add())
print(stats.mean(5, 6, 55, 66, 5566))

如此一來，我們就能夠暸解未來在資料分析階段所使用的第三方模組，其具體的形式為何進而可以更熟練地使用了。在認識了模組之後，第十八週約維安計畫：Python 的模組來到尾聲，希望您也和我一樣期待下一篇文章。

延伸閱讀

• https://docs.python.org/3/library

• https://docs.python.org/3/installing/index.html

• https://pip.pypa.io/en/stable

• https://pypi.org

對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Leave a comment

計畫學員專區

付費訂閱電子報的會員可以點選 nbgitpuller 連結將本篇文章完整的 Jupyter Notebook 以及範例模組複製到自己的 Jupyter Server：

nbgitpuller 連結

伺服器選項選擇預設的「Data science environment：學習 Python、R 與 Julia 的資料科學環境」就可以順利運作文章中的範例程式。

我們在約維安計畫：Python 的函數認識了函數的觀念，函數是一段「被命名」的程式碼，這段程式碼可以用於執行某個特定任務，可能是數值的運算或者文字的處理。把某項能夠運作特定功能的程式碼「命名」的機制，稱之為組織程式碼，因應不同目的以及應用場景， 程式設計師有組織程式碼的需求，希望可以簡潔且有效率地完成任務，具體來說，就是提升程式碼的重複利用性（Reusability）。事實上，除了函數以外，Python 與大多數的程式語言相同，擁有其他組織程式碼的機制，具體而言有三個層次，由小而大依序為：

1. 函數（Functions）。

2. 類別（Classes）。

3. 模組（Modules）。

本篇文章要介紹組織程式碼機制的第二個層次：類別。

什麼是類別

把即將要執行的程式碼組織為函數，並依序使用這些函數來完成任務，這是一種以函數為主體的程式設計風格，這樣的技巧稱之為程序化程式設計（Procedural programming），也是我們至今以來習慣的寫作方式；然而另外有一種程式設計風格，是把即將要執行的程式碼組織為類別（Class），並視應用場景使用類別中的方法或資料來完成任務，這樣的技巧稱之為物件導向程式設計（Object-oriented programming, OOP）。具體而言，假如我們的程式碼所面對要解決的問題是非常明確且專一的，那麼使用程序化程式設計是很適當的，舉例來說，在購買刀具的時候，如果我們非常清楚是要用來削水果的，就會購買一把水果刀；反之如果程式碼所面對要解決的問題是比較廣泛且多元的，那麼使用物件導向程式設計就會更貼近，舉例來說，在購買刀具的時候只知道自己有使用刀具的需求，就會購買一個「刀具組」或者「萬能瑞士刀」，待需求發生時，再從其中取出對應的刀來使用。

常用的類別

在 Python 程式設計與資料分析的場景中，我們常用到的類別可以粗略分為三種：

1. 內建的資料型別：整數、浮點數、字串、布林與 NoneType。

2. 內建的資料結構：串列、tuple、字典與集合。

3. 第三方模組的資料結構：多維度陣列、Index、Series 與資料框。

簡而言之，類別是一種能夠讓程式設計師自行定義資料型別或資料結構的機制，提供可以把資料與函數包裝起來的架構，並在定義完善以後使用，具體的使用方式就是我們在一開始學習程式設計時所學會的「宣告物件」，完整的說法是：物件（Object）是類別（Class）的實例（Instance），類別之於物件的關係就像是藍圖之於產品、設計圖之於成品或原稿之於印刷品一般。

# skywalker object is the instance of str
skywalker = "Anakin Skywalker" 
print(type(skywalker))
# skywalkers object is the instance of list
skywalkers = ["Anakin Skywalker", "Luke Skywalker"]
print(type(skywalkers))

程式設計師能夠使用類別包裝資料與函數，包裝好的資料稱為物件的屬性（Attributes），包裝好的函數稱為物件的方法（Methods）。我們可以用內建函數 dir() 來檢視有哪些屬性或方法。

skywalker = "Luke Skywalker"
skywalkers = ["Anakin Skywalker", "Luke Skywalker"]
print(dir(skywalker))
print(dir(skywalkers))

函數與方法的使用

我們原本提到的程式設計與資料分析核心精神：對資料應用函數，是偏向程序化程式設計的說法，在暸解類別觀念之後，同樣的核心精神可以修改為物件導向的說法：使用物件的方法。

在 Python 中使用函數方式是在函數名稱後接上小括號，並在小括號中輸入物件名稱以及引數。

function_name(OBJECT, ARGUMENTS)

使用物件的方法是在物件名稱後接上句號（.）再接上方法名稱、小括號與引數。

OBJECT.method_name(ARGUMENTS)

例如 Python 有一個內建函數 sorted()，串列有一個方法 sort()，兩者都能夠排序一個串列，但是在使用的語法與意義上不同，使用內建函數 sorted() 排序串列是「對資料應用函數」的程序化程式設計說法，語法是 sorted(a_list_to_be_sorted)；使用串列方法 sort() 排序是「使用物件的方法」的物件導向程式設計說法，語法是 a_list_to_be_sorted.sort()。

primes_list = [11, 7, 5, 3, 2]
sorted(primes_list) # Apply sorted function to primes_list
print(primes_list)  # primes_list is not sorted
primes_list.sort()  # Call sort method of primes_list
print(primes_list)  # primes_list was sorted

值得注意的地方是，使用 sorted() 函數與串列的 sort() 方法分別表現了兩種物件更動的結果，sorted(primes_list) 以回傳值輸出排序後的串列，因此如果沒有將回傳值更新原本命名的串列，排序的更動並不會被保留。而 primes.sort() 則是直接將排序更動了，不需要更新原本命名的串列，也不會伴隨有回傳值。

自行定義類別

使用保留字 class 能夠自行定義類別，即便我們還沒有在類別設計任何資料或者函數（僅使用保留字 pass 讓自行定義類別的架構完整），但仍然可以生成一個「什麼事都做不了」的類別，值得注意的是自行定義的類別名稱我們習慣使用首字大寫的駝峰命名風格（Upper camel case）。

class ClassName:
    pass

例如自行定義一個簡單計算機類別 SimpleCalculator，在這個類別中只有一個說明文字。完成定義以後，我們宣告了物件 sc 作為 SimpleCalculator 類別的實例，並且利用內建函數 type() 與 dir() 檢視類別名稱以及被包裝的資料跟函數。

class SimpleCalculator:
    """
    This class creates a simple calculator that is unable to do anything.
    """
    pass

sc = SimpleCalculator()
print(type(sc))
print(dir(sc))

從檢視的結果我們可以發現自行定義類別附屬於 __main__ 之中，同時物件 sc 也具有 __doc__ 以及其他許多前後都具有兩個底線的屬性或方法，前後都具有兩個底線的命名我們稱之為 Python 的特殊命名，比較單純的理解方式為 Python 為具有特殊用途的功能所保留的命名，為了避免和使用者的命名衝突，用前後都具有兩個底線的特殊格式區隔開，未來如果看到這樣的命名，就知道是 Python 預設的功能。這時我們可以將物件 sc 的 __doc__ 屬性印出，會看到在自行定義類別中所寫下的說明文字。

print(sc.__doc__)

自行定義物件的方法

在自行定義類別的程式區塊中使用 def 保留字將函數與類別綁定，函數一但被歸屬在類別底下，成為實例之後就會改稱為物件的方法。

class ClassName:
    def method(self):
        # ...

這裡特別注意 self 參數，由於在自行定義類別的階段，就會設計類別實例化為物件之後的使用行為，因此在設計階段必須要給予物件一個代名詞，而 self 參數就是扮演物件的代名詞（事實上 self 參數可以任意地命名，但為了讓程式碼的可讀性增加，採用 self 做參數名稱是最佳的方式）。簡而言之，如果我們希望自行定義類別實例化為物件後可以這樣使用：

OBJECT.method(ARGUMENTS)

在自行定義類別的階段，就要加入 self 參數作為 OBJECT 的代名詞。例如自行定義的簡單計算機類別 SimpleCalculator，若是希望實例化物件 sc 可以這樣使用：

sc = SimpleCalculator()
sc.add(5, 6)

就必須要在設計階段納入 self 參數作為 sc 的代名詞。

class SimpleCalculator:
    def add(self, a, b):
        return a + b

sc = SimpleCalculator()
print(sc.add(5, 6))

自行定義物件的屬性

在自行定義類別的程式區塊中使用特殊函數 __init__() 將資料與類別綁定，資料一但被歸屬在類別底下，成為實例之後就會改稱為物件的屬性。

class ClassName:
    def __init__(self, attribute):
        # ...

這裡特別注意 __init__() 特殊函數，也常被稱為建構器（Constructor），這是在將類別實例化為物件的時候就會自動使用的函數，也因此我們可以在這個函數之下把資料都宣告妥當，由於還處於設計階段，同樣能透過 self 參數來作為物件的代名詞。簡而言之，如果我們希望自行定義類別實例化為物件後可以這樣使用：

OBJECT.attribute

在自行定義類別的階段，就要在 __init__() 函數下將資料與 self 綁定。例如自行定義的簡單計算機類別 SimpleCalculator，若是希望實例化物件 sc 可以這樣使用：

sc = SimpleCalculator(5, 6)
print(sc.a)
print(sc.b)

就必須要在 __init__() 函數下將參數宣告為 self 的資料。

class SimpleCalculator:
    def __init__(self, a, b):
        self.a = a
        self.b = b

sc = SimpleCalculator(5, 6)
print(sc.a)
print(sc.b)

在定義階段使用屬性或方法

若是在自行定義類別的階段中想要使用屬性，可以在自行定義類別的程式區塊中用 self.attribute 語法取用，例如將兩個屬性相加的 add() 方法可以這樣定義：

class SimpleCalculator:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def add(self):
        return self.a + self.b

sc = SimpleCalculator(5, 6)
print(sc.add())

若是在自行定義類別的階段中想要使用方法，可以在自行定義類別的程式區塊中用 self.method() 語法取用，例如將兩個屬性相加的 add() 方法能夠讓 add_and_square() 方法接續使用：

class SimpleCalculator:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def add(self):
        return self.a + self.b
    def add_and_square(self):
        return (self.add())**2

sc = SimpleCalculator(5, 6)
print(sc.add_and_square())

設計實例化後物件的顯示外觀

自行定義類別會具有一個名為 __repr__() 的特殊函數，它跟前面出現過的 __doc__ 屬性以及 __init__() 方法都屬於類別中預設作為某個功能的特殊命名，像是 __doc__ 屬性被保留給類別的說明文字，__init__() 方法被保留給類別實例化為物件時會自動使用的函數。而 __repr__() 函數的作用就是設計實例化後物件的顯示外觀，我們首先將前述沒有定義 __repr__() 的物件印出來檢視：

class SimpleCalculator:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def add(self):
        return self.a + self.b
    def add_and_square(self):
        return (self.add())**2

sc = SimpleCalculator(5, 6)
print(sc)

目前看到的是一個沒有註明該如何顯示物件外觀的狀態，因為在設計類別的過程中，並沒有在其中定義 __repr__() 函數。

接著將定義 __repr__() 函數加入到類別之中，再將有定義 __repr__() 函數後的類別實例化為物件印出來檢視：

class SimpleCalculator:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def __repr__(self):
        return "a: {}, b: {}".format(self.a, self.b)
    def add(self):
        return self.a + self.b
sc = SimpleCalculator(5, 6)
print(sc)

有無定義 __repr__() 函數差異一目瞭然。

封裝與繼承

前述我們透過自行定義類別能夠將資料與函數分別包裝成為類別的物件屬性（Attributes）以及類別的物件方法（Methods），這樣把函數實作細節包裝、隱藏起來的程式碼特性稱為封裝（Encapsulation）。

另外一種類別所具備的程式碼特性稱為繼承（Inheritance），這是用來讓先前定義好的類別得以延展功能的機制，透過繼承，新定義的類別可以完全沿襲所繼承類別的屬性與方法，這樣子可以有效解決程式碼的重複性問題，並且實踐軟體工程的 DRY(Don’t Repeat Yourself) 哲學。

只需要在新定義類別的名稱後在小括號內代入已定義完成的類別，即可像是「複製」一般把既有類別的所有功能在新定義類別中實現，由於這個機制使用了「繼承」這個動詞，所以常將已定義完成的類別稱為父母類別（ParentClass）、而將新定義類別稱為子女類別（ChildClass）。

class ChildClass(ParentClass):
    # ...

舉例來說，定義好的類別 SimpleCalculator 具有 __init__()、__repr__() 與 add() 這三個方法以及 a 與 b 兩個屬性；繼承了 SimpleCalculator 的 AnotherSimpleCalculator 類別在什麼事都不做的情況下（僅傳入一個 pass 保留字）就具備了三個方法以及兩個屬性：

class AnotherSimpleCalculator(SimpleCalculator):
    pass

another_sc = AnotherSimpleCalculator(5, 6)
print(another_sc)
print(another_sc.add())
print(another_sc.a)
print(another_sc.b)

如此一來在新定義的類別中添加方法，就可以引用繼承而來的方法以及屬性，達到功能延展並且不需要重新造輪的軟體工程 DRY(Don’t Repeat Yourself) 哲學。

在初步認識了類別之後，第十七週約維安計畫：Python 的函數來到尾聲，希望您也和我一樣期待下一篇文章。

延伸閱讀

• https://docs.python.org/3/tutorial/classes.html

對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Leave a comment

計畫學員專區

付費訂閱電子報的會員可以點選 nbgitpuller 連結將本篇文章完整的 Jupyter Notebook 複製到自己的 Jupyter Server：

nbgitpuller 連結

伺服器選項選擇預設的「Data science environment：學習 Python、R 與 Julia 的資料科學環境」就可以順利運作文章中的範例程式。

在約維安計畫：Python 起步走我們透過 print("Hello, World!") 來確認 Python 的開發環境及執行環境是否已經安裝妥當，在這一段哈囉世界的程式碼中，其實就能體驗程式設計與資料分析的一個核心精神：對資料應用函數。

print 是函數的名稱，print() 則表示要應用該函數的功能，而 “Hello, World!“ 則是一個被稱呼為字串（String）的資料型別；換言之，哈囉世界可以表達為：對 “Hello, World!“ 這個字串應用了 print 函數。

print("Hello, World!")

什麼是函數

函數是構成所有程式語言的基本要素，一個函數是一段「被命名」的程式碼，這段程式碼可以用於執行某個特定任務，可能是數值的運算或者文字的處理，當使用者想要應用（使用、呼叫）某一個函數之前，必須先確定在作用域中該函數已經被定義或者被載入。簡而言之，在哈囉世界的程式碼中，之所以能夠對字串 “Hello, World!“ 應用 print 函數，是因為 print 函數屬於 Python 的內建函數，在 Python 啟動的當下就會被載入供我們使用，內建函數多達 74 個，所有的內建函數與詳細介紹可以參考：https://docs.python.org/3/library/functions.html。

函數的兩種使用方式

在 Python 中最常見的函數使用方式是在函數名稱後接上小括號，並在小括號中輸入物件名稱（該物件所儲存的可能是某個資料型別或者資料結構）以及引數（如果函數有任何參數設計）。

function_name(OBJECT, ARGUMENTS)

由於 Python 屬於物件導向（Object-oriented）程式語言，第二種函數定義的形式是綁定於物件之上，這時候使用的方式就變成了在物件名稱後接上附屬符號（.）再接上函數名稱、小括號與引數（如果函數有任何參數設計），在第二種形式中，不只在使用上的語法相異，在稱呼上我們也不再用「函數」，而是改稱物件的「方法」。

OBJECT.method_name(ARGUMENTS)

例如 Python 有一個內建函數 sorted()，串列有一個方法 sort()，兩者都能夠排序一個串列，但是在使用的語法與意義上不同，使用內建函數 sorted() 排序串列是我們習慣且直觀的「對資料結構應用函數」，語法是 sorted(a_list_to_be_sorted)；使用串列方法 sort() 排序是目前較陌生的「使用綁定於資料結構的方法」，語法是 a_list_to_be_sorted.sort()。這篇文章中我們專注於自行定義的函數，自行定義物件的方法我們會在「類別」主題時談到。

primes_list = [11, 7, 5, 3, 2]
sorted(primes_list) # Apply sorted function to primes_list primes_list.sort()  # Call sort method of primes_list

參數與引數的差別

在排序串列的時候，我們可以選擇要「遞增地」排序或者「遞減地」排序，這可以透過傳入的引數（Arguments）調整函數的參數（Parameters），具體來說，函數在定義的階段需要使用的資料型別或資料結構稱為參數，在使用的階段需要指定給參數的資料型別或資料結構就稱為引數。

def function_name(parameter_1, parameter_2):
    # body of the function
    # ...
    # ...sequence of statements

function_name(argument_1, argument_2)

通常參數會給予預設值，例如 sorted() 函數與串列的 sort() 方法都具有 reverse 參數，預設值給定為 True。所以在沒有傳入引數的狀況下，其實就是採用 reverse=False 的參數設定，假使不想採用預設值，就能選擇以名稱（Named）參數來傳入引數。

primes_list = [11, 7, 5, 3, 2]
sorted(primes_list)
sorted(primes_list, reverse=True) # Named
primes_list.sort()
primes_list.sort(reverse=True) # Named

更動結果的機制

除了使用「函數」或「方法」的差異，另外值得注意之處在於函數與方法的使用都可能讓應用或所屬的物件造成更動，一種更動方式是以回傳值型態輸出更動後的結果；另一種更動方式是直接更動資料型別與資料結構而沒有輸出。這個差異能夠延續前述內建函數 sorted() 與串列方法 sort() 的例子，sorted(a_list_to_be_sorted) 是以回傳值輸出排序後的串列，因此如果沒有將回傳值更新原本命名的串列，排序的更動並不會被保留。

primes_list = [11, 7, 5, 3, 2]
sorted(primes_list) # Apply sorted function to primes_list print(primes_list)  # primes_list is not sorted 
primes_list = sorted(primes_list)  # Update primes_list with function output
print(primes_list)  # primes_list is sorted

而 a_list_to_be_sorted.sort() 則是直接將排序更動了，不需要更新原本命名的串列，也不會伴隨有回傳值。

primes_list = [11, 7, 5, 3, 2]
primes_list.sort()  # Call sort method of primes_list print(primes_list)  # primes_list is sorted

多數情況下函數與方法會在「以回傳值輸出」或「直接更動物件的狀態」擇一，少數情況下會有兩者兼具的情況，例如串列方法 pop() 能夠將串列末端的資料拋出為回傳值，並刪除串列末端的資料點。

primes_list = [11, 7, 5, 3, 2]
the_last_element = primes_list.pop()
print(primes_list)       # The last element was deleted print(the_last_element)  # The last element was returned

這意味著設計為「函數」或者「物件的方法」並不代表恰好對應「以回傳值輸出」或「直接更動物件狀態」，絕大多數的函數確實是以回傳值輸出，但物件的方法則可能有以回傳值輸出的設計、有直接更動物件狀態的設計甚至是用參數來決定要回傳值輸出或直接更動物件狀態。例如資料科學模組 Pandas 所創造的 DataFrame 類別的 drop 方法就是採用 inplace 參數來決定「以回傳值輸出」或「直接更動物件狀態」。

import pandas as pd

df = pd.DataFrame()
df["order"] = list(range(1, 6))
df["prime"] = [2, 3, 5, 7, 11]
df.drop(axis=1, labels="prime")
print(df) # Column is not dropped
df.drop(axis=1, labels="prime", inplace=True)
df # Column was dropped

函數的來源

Python 使用者除了能夠應用內建函數以外，還可以從其他三個管道取得數值計算、文字處理、資料結構或更多其他應用所需的函數：

1. 標準模組。

2. 第三方模組。

3. 自行定義。

僅有內建函數可以供我們直接使用，另外這三個管道的函數都必須在使用之前確定好在欲產生作用的範疇（作用域）中已經被載入或者定義。使用標準模組以及第三方模組中的函數之前，我們必須確認模組是否已經安裝載入，使用自行定義的函數之前，則是必須確認該函數是否已經完成定義。

載入模組的保留字是 import，使用模組的函數則需要在其名稱之前註明其模組名稱，例如引入標準模組 random，然後使用其中的 randint 函數隨機在 0 與 1 之間挑選整數。

import random 

print(type(random))
print(type(random.randint))
random_integer = random.randint(0, 1)
print(random_integer)

自行定義函數

Python 提供了三種「組織程式碼」的機制供使用者將未來想要重複使用的程式碼包裝成容易使用、容易擴充功能的形式，這三種機制會視應用規模由小到大區分為：

1. 自行定義函數。

2. 自行定義類別。

3. 自行定義模組。

在這篇文章中我們專注自行定義函數，也就是最小的組織程式碼機制，在自行定義函數時候需要考慮五個組成要件：

1. 函數名稱。

2. 輸入。

3. 參數。

4. 函數主體。

5. 輸出。

看似抽象，不過想想平日購買珍珠鮮奶茶的流程，就像是函數的運作一般：

1. 函數名稱：購買珍珠鮮奶茶。

2. 輸入：中杯 35 元；大杯 50 元。

3. 參數：甜度（無糖、微糖、半糖、少糖、全糖）與冰塊（去冰、少冰、全冰）。

4. 函數主體：點餐、貼標籤、加珍珠、加冰塊、倒茶、加鮮奶一直到封口。

5. 輸出：珍珠鮮奶茶。

def function_name(INPUTS, PARAMETERS):
    # body of the function
    # ...
    # ...sequence of statements
    return OUTPUTS

作用域

在約維安計畫：Python 的流程控制我們提到了程式區塊（Code blocks）的觀念，不論是條件判斷、迴圈或者例外處理，都仰賴縮排（Indentations）建立出程式區塊，並以此作為敘述的附屬。在自行定義函數時也同樣以程式區塊建構出函數主體，不過更特別的是，附屬於 def 敘述的程式區塊具有一個稱為作用域（或稱範疇 Scope）的觀念，在附屬於函數下的程式區塊被稱為 Local scope，函數以外的部分則稱為 Global scope。在 Local scope 中我們可以運用 INPUTS、PARAMETERS 來進行運算並宣告新的物件，但是這都侷限於 Local scope 之中，一但在 Global scope 意圖運用前述的這些物件，都會遭遇到 NameError，意即在 Global scope 中這些物件「沒有作用」，這也是作用域一詞的由來。例如在 Global scope 中試圖印出任何在 Local scope 中可以運用的物件都會遭遇 NameError。

def is_factor(a, b):
    modulo = a % b
    out = modulo == 0
    return out

print(is_factor(4, 2))
try:
    print(a)
    print(b)
    print(modulo)
    print(out)
except NameError:
    print("NameError occurred.")

return 的作用

初次學習自行定義函數多半都不甚暸解 return 保留字的作用，原因是先前太過頻繁地使用 print() 函數將文字處理、數值計算或者資料結構操作的結果顯示出來，導致在自行定義函數時不習慣去使用 return。事實上，return 保留字具有兩個作用，第一個跟字面上意義相同的將函數結果「輸出」，假如在自行定義函數時只有將運算結果用 print() 函數顯示出來，該函數就不具備能將結果儲存在物件中的能力，變成只能夠在使用時顯示結果，卻不能將結果儲存起來，例如想要將判斷因數的結果儲存起來，卻得到了 None。

def is_factor(a, b):
    modulo = a % b
    out = modulo == 0
    print(out)

function_output = is_factor(4, 2)
print(function_output)

第二個是終止程式區塊的執行，在函數程式區塊中寫在 return 之後的所有內容在使用函數的時候都不會有任何作用。

def is_factor(a, b):
    modulo = a % b
    out = modulo == 0
    return out
    print(out)    # will not be printed
    print(modulo) # will not be printed
    print(a)      # will not be printed
    print(b)      # will not be printed

function_output = is_factor(4, 2)
print(function_output)

輸入與輸出的對應關係

自行定義函數的重點在於規劃輸入與輸出的對應關係，如同在數學課中學過的「函數映射關係」，只要釐清了自行定義函數針對輸入與輸出的設計機制，剩下的任務就僅是將程式區塊的函數主體完成而已。

從輸入開始，函數可以接受沒有輸入與參數的設計，在小括號中留空即可。

def hello_world():
    return "Hello, World!"

print(hello_world())

函數當然可以接受有輸入與參數的設計，好的函數設計會在參數給予合適的預設值。

def hello_someone(someone="World"):
    return f"Hello, {someone}!"

print(hello_someone())
print(hello_someone(someone="Function"))

設計要接受多個輸入值的函數時，可以用資料結構容納多個輸入資料。

def square_multiple_integers(x):
    out = []
    for elem in x:
        out.append(elem**2)
    return out

print(square_multiple_integers([2, 3]))
print(square_multiple_integers([2, 3, 5]))

如果希望多個輸入值分別以參數傳入而資料結構，可以運用 Python 自行定義函數的特殊設計：彈性參數（Flexible arguments），在小括號中給予 *args 就能夠在 Local scope 中以 tuple 處理 args。

def square_multiple_integers(*args):
    print(type(args))
    out = []
    for elem in args:
        out.append(elem**2)
    return out

print(square_multiple_integers(2, 3))
print(square_multiple_integers(2, 3, 5))

再來是輸出，即便絕大多數的函數都具有回傳值，但也不代表函數非具備 return 不可，如果是這樣的情況我們會得到 None 為函數的回傳值。

def hello_world():
    out = "Hello, World!"

function_output = hello_world()
print(type(function_output))

多個輸出的處理預設是以 tuple 回傳，亦可以搭配 Python 的 Unpack 特性用多個物件去儲存。

def square_two_integers(a, b):
    out_a = a**2
    out_b = b**2
    return out_a, out_b

function_output_as_tuple = square_two_integers(3, 4)
func_out_a, func_out_b = square_two_integers(3, 4)
print(type(function_output_as_tuple))
print(func_out_a)
print(func_out_b)

多個輸出的處理相較輸入單純許多，就是採用適當的資料結構儲存。

def square_two_integers(a, b):
    out = {
        "a": a**2,
        "b": b**2
    }
    return out
function_output_as_dict = square_two_integers(3, 4)
print(function_output_as_dict)

在認識了函數的各種眉眉角角之後，第十六週約維安計畫：Python 的函數來到尾聲，希望您也和我一樣期待下一篇文章。

延伸閱讀

• https://docs.python.org/3/library/functions.html

計畫學員專區

約維安計畫學員可以點選 nbgitpuller 連結將本篇文章完整的 Jupyter Notebook 複製到自己的 JupyterHub 之中：

nbgitpuller 連結

伺服器選項選擇預設的「Data science environment：學習 Python、R 與 Julia 的資料科學環境」就可以順利運作文章中的範例程式。

對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Leave a comment

什麼是流程控制

多數程式語言都會從程式碼的第一列開始按照列（Row-wise）的順序往下讀取並且執行，但是在某些情況下，我們會希望能在某些程式碼可以依照需求不執行、執行或者執行多次，這時就可以透過流程控制的機制來滿足這些情況。

流程控制指的是在程式執行時，能夠依賴條件來決定程式區塊（Code blocks）中的指令、敘述或者函數呼叫的執行次數，在條件為布林 False 的時候，程式區塊中的程式碼執行次數為 0（不執行）；在條件為布林 True 的時候，程式區塊中的程式碼執行次數大於等於 1。具體來說，流程控制是一種機制，這個機制能讓一段指令在某些情況下不被執行、在某些情況下被執行一次或者在某些情況下被重複執行，Python 實現流程控制有三種方式：

1. 條件判斷。

2. 迴圈。

3. 例外處理。

其中，條件判斷能夠使用 if-elif-else 敘述與布林完成；迴圈則有兩種選擇，一是使用 while 敘述與布林，二是使用 for 敘述與可走訪物件（Iterables）；例外處理能夠使用 try-except 敘述與錯誤種類完成。

什麼是區塊

區塊（Code blocks）指的是將一系列相關的敘述集合在一起的程式碼結構，在多數的程式語言中，區塊使用一對大括號（A curly-brace pair）將敘述包裝在裡面形成區塊。但是，在 Python 中建立區塊跟多數的程式語言截然不同，Python 使用縮排（Indentations）而非一對大括號來將敘述包裝為區塊，在前述三種類型的流程控制中，都會利用區塊將敘述依附給條件判斷、迴圈與例外處理，如此一來就能夠在某些情況下讓區塊中的程式不被執行、執行僅一次或執行特定次數。

條件判斷

條件判斷是依指定變數或者運算的布林值為真或假時，來決定是否執行一段位於某區塊內的程式，透過 if-elif-else 敘述可以根據指定條件是否成立，決定後續要執行的程式，也可以組合多個 if-elif-else 敘述進行更複雜的條件判斷。

我們使用保留字 if 搭配一個條件（之後接一個冒號 :）就能夠建立一個 if 敘述，if 敘述能夠讓區塊的執行與否依賴條件的布林值，如果條件為 True 則執行依附其縮排下的程式區塊；若條件為 False 則不執行依附其縮排下的程式區塊。

if CONDITION:
    # code block attached to if statement

CONDITION 可以透過關係運算符或者邏輯運算符生成，例如判斷輸入整數是否為正。

def is_positive(x):
    if x >= 0:
        return f"{x} is positive."
    if x < 0:
        return f"{x} is negative."

print(is_positive(0))
print(is_positive(-1))

我們使用保留字 if 與 elif 搭配各自的條件建立一個 if-elif 敘述，如果 if 後面的條件為 True 則執行依附其縮排下的程式區塊；若 if 後面的條件為 False 則跳過該區塊改為檢視 elif 後面的條件，如果是 True 就執行依附其縮排下的程式區塊；若 elif 後面的條件為 False 則跳過該區塊，其中 elif 是 else if 的簡寫。

if CONDITION:
    # code block attached to if statement
elif CONDITION:
    # code block attached to elif statement

CONDITION 可以透過關係運算符或者邏輯運算符生成，例如判斷輸入整數是否為正。

def is_positive(x):
    if x >= 0:
        return f"{x} is positive."
    elif x < 0:
        return f"{x} is negative."

print(is_positive(0))
print(is_positive(-1))

我們使用保留字 if 、else 搭配一個條件建立一個 if-else 敘述，如果 if 後面的條件為 True 則執行依附其縮排下的程式區塊；若 if 後面的條件為 False 則跳過該區塊改為執行依附 else 縮排下的程式區塊。

if CONDITION:
    # code block attached to if statement
else:
    # code block attached to else statement

CONDITION 可以透過關係運算符或者邏輯運算符生成，例如判斷輸入整數是否為正。

def is_positive(x):
    if x >= 0:
        return f"{x} is positive."
    else:
        return f"{x} is negative."

print(is_positive(0))
print(is_positive(-1))

在前面的例子中，我們可以看到同樣一個「判斷輸入整數是否為正」的函數，可以用不同的條件判斷敘述來實作，那麼在應用情境上，該如何區別與採用？簡單來說，我們可以藉由判斷 CONDITION 是否互斥（Mutually exclusive）來決定。這個說法是依據 if 敘述、if-elif 與 if-else 敘述的主要差別，由於 if-elif 與 if-else 敘述的條件判斷是有先後順序的，當前面 if 敘述得到了布林值 True，意味著後續的 elif 或 else 敘述就無關緊要了。簡單來說，假如條件彼此之間是互斥的，條件判斷怎麼寫大概都沒有問題；但反過來說，假如條件彼此之間是「非互斥」的話，判斷的順序以及 if 敘述、if-elif 與 if-else 敘述就會需要謹慎地選擇。舉例來說，我們依據 https://en.wikipedia.org/wiki/Body_mass_index 寫作一個函數 get_bmi_desc() 可以根據輸入的 BMI 數值，給予過輕、正常、過重或肥胖的文字輸出，將四個條件寫成互斥的格式：

1. 過輕：BMI < 18.5。

2. 正常：BMI >= 18.5 and BMI < 25。

3. 過重：BMI >= 25 and BMI < 30。

4. 肥胖：BMI >= 30。

在條件互斥的狀況下，怎麼寫大概都沒有問題。

def get_bmi_desc(bmi):
    if bmi < 18.5:
        bmi_desc = "過輕"
    elif bmi >= 30:
        bmi_desc = "肥胖"
    elif bmi >= 25 and bmi < 30:
        bmi_desc = "過重"
    elif bmi >= 18.5 and bmi < 25:
        bmi_desc = "正常"
    return bmi_desc

print(get_bmi_desc(17))
print(get_bmi_desc(23))
print(get_bmi_desc(29))
print(get_bmi_desc(31))

但這不表示條件判斷就必須將條件都寫成互斥才可以，在適當順序與敘述安排下，即使非互斥也能達到正確判斷結果。

def get_bmi_desc(bmi):
    if bmi >= 30:
        bmi_desc = "肥胖"
    elif bmi >= 25:
        bmi_desc = "過重"
    elif bmi >= 18.5:
        bmi_desc = "正常"
    else:
        bmi_desc = "過輕"
    return bmi_desc

print(get_bmi_desc(17))
print(get_bmi_desc(23))
print(get_bmi_desc(29))
print(get_bmi_desc(31))

迴圈

迴圈是常見的流程控制之一，這是一種在區塊中只出現一次、但卻可能被連續執行多次的程式碼結構，區塊中的程式碼會執行特定的次數、執行到特定條件成立時結束或者走訪資料結構中的所有內容，與串列切割的語法概念相似，迴圈也能夠用開始、結束與間隔三個要素描述。

• start：迴圈的開始。

• stop：迴圈的結束。

• step：迴圈從起始前往終止的方法。

我們可以使用保留字 while 與條件建立一個 while 迴圈區塊，當條件為 True 重複執行依附其縮排下的程式區塊，描述迴圈的 step 常用複合運算符（Compound operators），例如 i += step 就等同於 i = i + step。

i = 0 # start
while CONDITION: # stop
    # code block attached to while statement
    i += step

CONDITION 可以透過關係運算符或者邏輯運算符生成，例如印出前 n 個奇數。

def print_first_n_odds(n):
    i = 1
    odds = []
    while len(odds) < n:
        print(i)
        odds.append(i)
        i += 2

print_first_n_odds(5)

我們可以使用保留字 for 與可走訪物件（Iterables）建立一個 for 迴圈區塊，依附其縮排下的程式區塊會重複執行，直到可走訪物件中的所有元素都被走訪完畢。

for i in ITERABLE: # start/stop/step
    # code block attached to for statement

可走訪物件被宣告完成的當下，迴圈的三要素就已經描述完畢。

• start 可迭代物件的第 0 項元素。

• stop 可迭代物件的最後一項（索引值 -1 的元素）。

• step 可迭代物件的逗號區隔。

ITERABLE 可以內建函數 range() 生成，例如印出前 n 個奇數。

help(range)
def print_first_n_odds(n):
    iterable = range(1, n*2, 2)
    for i in iterable:
        print(i)

print_first_n_odds(5)

在前面的例子中，我們可以看到同樣一個「印出前 n 個奇數」的函數，可以用不同的迴圈類型來實作，那麼在應用情境上，該如何區別與採用？簡單來說，我們可以藉由判斷區塊程式「重複執行的次數是否已知」來決定，已知重複執行次數的情境可以用任意迴圈，未知重複執行次數的情境僅能採用 while 迴圈。這個說法是依據 while 迴圈與 for 迴圈的主要差別，while 在重複執行區塊程式的時候，會在 CONDITION 為 False 的時候終止；而 for 在重複執行區塊程式的時候，會在可迭代物件中的元素用罄時候終止。這表示 while 迴圈根據一個型別為布林變數的物件決定重複執行程式區塊是否終止；for 迴圈則根據一個已知元素數量的可迭代物件決定重複執行程式區塊是否終止。舉例來說，內建函數 bin() 可以將十進位整數轉換為二進位文字，轉換方式是透過「輾轉相除法」將十進位整數持續以 2 相除，直到商數的部分為 0 或者 1，其中「輾轉相除法」就是一個「未知重複執行次數」的情況，沒有辦法在一開始就得知需要多少次的輾轉相除才能結束。

def int_to_bin_str(x):
    if x < 2:
        return str(x)
    binary_str = ""
    while x > 0:
        modulo = x % 2
        binary_str = str(modulo) + binary_str
        x //= 2
    return binary_str

print(int_to_bin_str(2))
print(int_to_bin_str(3))

在 Python 中所謂的可走訪物件（Iterables）是任意長度的資料結構（包含串列、Tuples、集合、字典）或者文字，這些可走訪物件都能夠直接放置在 for 迴圈中使用。

def print_iterable_elements(x):
    for e in x:
        print(e)

primes_list = [2, 3, 5, 7, 11]
primes_tuple = (2, 3, 5, 7, 11)
primes_set = {2, 3, 5, 7, 11}
primes_str = "2357"
print_iterable_elements(primes_list)
print_iterable_elements(primes_tuple)
print_iterable_elements(primes_set)
print_iterable_elements(primes_str)

但字典是具有鍵（keys）與資料（values）的資料結構，在走時要特別留意是希望走訪字典的鍵或者字典的值，透過字典的 keys() 、 values() 與 items() 方法分別可以取出鍵、資料或者兩者，其中 items() 方法會將標籤以及資料兩兩合併在一個 Tuple 中。

primes_dict = {
    "1st": 2,
    "2nd": 3,
    "3rd": 5,
    "4th": 7,
    "5th": 11
}
# Iterating a dict
for k in primes_dict.keys():
    print(k)
for v in primes_dict.values():
    print(v)
for k, v in primes_dict.items():
    print("{} is the {} prime.".format(v, k))

將流程控制的兩個技巧條件判斷與迴圈合併使用會讓我們的程式撰寫更有彈性，保留字 break 能夠讓我們在走訪的過程中在條件為 True 的時候終止迴圈，舉例來說當走訪到非整數的時候終止迴圈。

primes = [2, 3, "5", 7, 11]
for p in primes:
    if not isinstance(p, int):
        break
    print(p)

保留字 continue 能夠讓我們在走訪的過程中在條件為 True 的時候略過該元素但是繼續完成迴圈，舉例來說當走訪到非整數的時候略過。

primes = [2, 3, "5", 7, 11]
for p in primes:
    if not isinstance(p, int):
        continue
    print(p)

例外處理

例外處理指的是針對程式區塊執行時所出現的例外（Exceptions）進行對應的處置，在執行程式區塊時遭遇的例外往往是由於錯誤而引發，包含無效的物件名稱、檔案不存在或型別不正確等，錯誤會無條件停止 Python 程式，破壞程式執行正常的流程，例外處理就是在程式區塊遭遇例外時能夠移交控制權的一種機制。簡單來說，例外處理就像是另一種類型的條件判斷，只不過條件判斷倚賴條件的布林值決定哪個程式區塊要被執行，而例外處理則是依賴程式區塊是否產生了錯誤來決定哪個程式區塊要被執行。

我們可以使用保留字 try、except 與錯誤類別建立一個例外處理區塊，依附 try 保留字縮排下的程式區塊一但執行時遭遇到了錯誤，就會跳過該區塊改為執行依附 except 保留字縮排下的程式區塊。

try:
    # code block attached to try statement
except:
    # code block attached to except statement

例如將輸入的兩數相除，在輸入兩數其中一者為文字時候會產生型別錯誤（TypeError）而導致 Python 程式執行停止，也因此在呼叫 divide() 函數後的 print() 函數都沒有被執行。

def divide(a, b):
    return a / b

print(divide(55, '0'))
print("This message will not be printed.")
print("This message will also not be printed.")

加入例外處理，可以確保在呼叫 divide() 函數後的 print() 函數都會被執行。

def divide(a, b):
    try:
        return a / b
    except:
        return None

print(divide(55, '0'))
print("This message will be printed.")
print("This message will also be printed.")

若在保留字 except 之後加上錯誤類別可以依照產生的錯誤，回傳不同的對應輸出。

def divide(a, b):
    try:
        return a / b
    except TypeError:
        return "TypeError occurred."
    except ZeroDivisionError:
        return "ZeroDivisionError occured."

print(divide(55, '0'))
print(divide(55, 0))
print("This message will be printed.")
print("This message will also be printed.")

在認識了條件判斷、迴圈與例外處理這三種流程控制的機制之後，第十五週約維安計畫：Python 的流程控制來到尾聲，希望您也和我一樣期待下一篇文章。

計畫學員專區

約維安計畫學員可以點選 nbgitpuller 連結將本篇文章完整的 Jupyter Notebook 複製到自己的 JupyterHub 之中：

nbgitpuller 連結

伺服器選項選擇預設的「Data science environment：學習 Python、R 與 Julia 的資料科學環境」就可以順利運作文章中的範例程式。

延伸閱讀

1. https://docs.python.org/3/tutorial/errors.html

對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Leave a comment

什麼是資料結構

在約維安計畫：第十三週中我們已經知道 Python 的基本資料型別，包含整數、浮點數、文字、布林與未定義值，資料型別在程式設計中所扮演的角色就像是樂高、積木、模型或拼圖等遊戲中的基本單元零件，透過結合資料型別，可以堆疊出更進階的 Python 應用，接下來我們會從資料型別邁向結構（Structures）。在電腦科學中，資料結構是電腦儲存、組織以及存取資料的機制，在 Python 中我們可以透過四種基本資料結構來儲存、組織以及存取我們在約維安計畫：第十三週所認識的資料型別。

1. 串列 list

2. tuple

3. 字典 dict

4. 集合 set

以 type() 函數識別資料結構

和資料型別的應用場景相同，常見對資料結構應用函數或者呼叫資料結構本身的方法時候，都是對應完成宣告的物件應用，而非直接對應資料結構，這是因為程式設計通常在後續會有資料記錄與運算處理的需求，並不僅止與將其印出來而已。所以我們可以運用能夠將完成宣告的物件所儲存之資料結構告知使用者的內建函數 type()，作用是將被應用物件的類別回傳，在 Python 中物件（Objects）是類別（Classes）的實例（Instances），而類別有分為資料型別、資料結構、函數以及特殊類別（例如自行定義類別、產生器或迭代器等進階的 Python 類別）。

primes_list = [2, 3, 5, 7, 11]
primes_tuple = (2, 3, 5, 7, 11)
primes_dict = {
    "1st": 2,
    "2nd": 3,
    "3rd": 5,
    "4th": 7,
    "5th": 11
}
primes_set = {2, 3, 5, 7, 11}
print(type(primes_list))
print(type(primes_tuple))
print(type(primes_dict))
print(type(primes_set))
## <class 'list'>
## <class 'tuple'>
## <class 'dict'>
## <class 'set'>

函數的使用方式

在 Python 中使用函數有兩種機制，一是對資料型別或資料結構應用函數；二是呼叫綁定於資料型別或資料結構的方法，這時要注意，我們不再稱呼「函數」，而是改稱「方法」。

舉一個例子說明，Python 有一個內建函數 sorted()，串列有一個方法 sort()，兩者都能夠排序一個串列，但是在使用的語法與意義上不同，使用內建函數 sorted() 排序串列是我們習慣且直觀的「對資料結構應用函數」，語法是 sorted(a_list_to_be_sorted)；使用串列方法 sort() 排序是我們較為陌生的「呼叫綁定於資料結構的方法」，語法是 a_list_to_be_sorted.sort()。

primes_list = [11, 7, 5, 3, 2]
sorted(primes_list) # Apply sorted function to primes_list
primes_list.sort()  # Call sort method of primes_list

除了這兩種函數使用的機制差異，另外一個值得注意之處在於函數的應用以及方法的呼叫都可能有兩種讓應用或者綁定的資料型別與資料結構造成更動的機制，一是以回傳值型態輸出更動後的結果；二是直接更動資料型別與資料結構而沒有輸出。這個差異能夠延續前述內建函數 sorted() 與串列方法 sort() 的例子，sorted(a_list_to_be_sorted) 是以回傳值輸出排序後的串列，因此如果沒有將回傳值更新原本命名的串列，排序的更動並不會被保留。

primes_list = [11, 7, 5, 3, 2]
sorted(primes_list) # Apply sorted function to primes_list
print(primes_list)  # primes_list is not sorted
primes_list = sorted(primes_list)  # Update primes_list with function output
print(primes_list)  # primes_list is now sorted
## [11, 7, 5, 3, 2]
## [2, 3, 5, 7, 11]

而 a_list_to_be_sorted.sort() 則是直接將排序更動了，不需要更新原本命名的串列，也不會伴隨有回傳值。

primes_list = [11, 7, 5, 3, 2]
primes_list.sort()  # Call sort method of primes_list
print(primes_list)  # primes_list is sorted
## [2, 3, 5, 7, 11]

函數或者方法多數情況下會在「以回傳值輸出」或「直接更動物件狀態」中擇一，少數情況下也會有兩者兼具的情況，例如串列方法 pop() 能夠將串列末端的資料拋出為回傳值，並刪除串列末端的資料點。

primes_list = [11, 7, 5, 3, 2]
the_last_element = primes_list.pop()
print(primes_list)       # The last element was deleted
print(the_last_element)  # The last element was returned
## [11, 7, 5, 3]
## 2

串列

串列 list 是 Python 最基礎且最為常用的資料結構，可以容納不同的資料型別與資料結構，建立的時候使用中括號 [] 將希望儲存的資料型別與資料結構包括起來，並將希望存放的資料型別與資料結構以逗號分隔。

primes_list = [2, 3, 5, 7, 11]
print(type(primes_list))
## <class 'list'>

有時候我們也使用 Python 的內建函數 list() 來建立串列，例如常被用來生成數列的內建函數 range() 其輸出是一個可以被迭代的物件（Iterable），屬於 range 類別，如果直接應用不會被印出所有的數字，這時可以用 list() 函數將它轉換為 list 來觀察其中包含的數字。

integer_sequence = range(10)
print(integer_sequence)
print(list(integer_sequence))
## range(0, 10)
## [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

使用串列將多筆資料型別或結構儲存於一個物件之中，就像是在進行化零為整的工作，這表示 Python 必然也能夠讓我們進行逆向工程：化整為零，化整為零的專有名稱為子集（Subset），串列的子集操作技巧可以分為兩種：

1. 索引（Indexing）

2. 切割（Slicing）

利用內建函數 len() 可以先暸解我們想要取為子集的串列長度（亦即串列中所儲存的元素個數），進而再利用索引、切割的技法。

primes_list = [2, 3, 5, 7, 11]
len_primes_list = len(primes_list)
print(len_primes_list)
# 5

選擇串列中的資料我們使用中括號 [] 搭配索引值，值得注意的是索引值從左邊由 0 開始，而非由 1 開始。

# start from left at index 0
print(primes_list[0])
print(primes_list[1])
print(primes_list[2])
print(primes_list[3])
print(primes_list[len_primes_list - 1])
## 2
## 3
## 5
## 7
## 11

從右邊則由 -1 開始。

# start from right at index -1
print(primes_list[-1])
print(primes_list[-2])
print(primes_list[-3])
print(primes_list[-4])
print(primes_list[-len_primes_list])
## 11
## 7
## 5
## 3
## 2

利用 [start:stop:step] 語法對串列指定要切割出來的子集，其中 stop 不會出現在最後選擇出來的結果中，例如我們希望將位於 [0] 、 [1] 、 [2] 的資料另外切割為一個長度為 3 的串列，要使用 [0:3] 而非 [0:2]。

print(primes_list[0:3])
## [2, 3, 5]

使用切割的語法時， start 、 stop 與 step 這三個參數都有預設值， start 預設是 0， stop 預設為串列的長度， step 預設為 1，假如沒有指定就採預設值，像是切割出位於 [0] 、 [2] 與 [4] 這三個位置的資料可以簡單使用 [::2] 。

print(primes_list[::2])
## [2, 5, 11]

比較特別的 step 參數如果指定為 -1 可以將串列中的資料順序反轉（Reverse）。

print(primes_list[::-1])
## [11, 7, 5, 3, 2]

除了索引與切割，常用的串列操作還有新增、刪除與排序資料，新增可以使用串列的append() 方法將資料加入到串列末端，這個方法採用直接更動沒有輸出的機制。

primes_list = [2, 3, 5, 7, 11]
primes_list.append(13)
print(primes_list)  # 13 was appended to primes_list
## [2, 3, 5, 7, 11, 13]

刪除可以使用串列的 pop() 方法將串列末端的資料拋出，這個方法同時採用回傳值與直接更動的機制。

primes_list.pop()  # 13 is popped out and returned
print(primes_list) # 13 was deleted
## [2, 3, 5, 7, 11]

排序可以使用串列的 sort() 方法將串列的資料以遞增排序，亦可以指定參數 reverse=True 以遞減排序，這個方法採用直接更動沒有輸出的機制。

primes_list = [2, 3, 5, 7, 11]
primes_list.sort(reverse=True)
print(primes_list) # primes_list is now sorted with descending order
primes_list.sort()
print(primes_list) # primes_list is now sorted with ascending order
## [11, 7, 5, 3, 2]
## [2, 3, 5, 7, 11]

Tuples

tuple 是 Python 另一常用的資料結構，多數的特性都與串列相同，例如在索引與切割的部分與串列操作語法完全相同。在建立的時候使用小括號 () 將希望儲存的資訊包括起來，並將希望存放的資料型別與資料結構以逗號分隔。

primes_tuple = (2, 3, 5, 7, 11)
print(type(primes_tuple))
## <class 'tuple'>

tuple 與串列最大的差異在於 tuple 是不可變動（Immutable）的資料結構，不具備任何包含新增、刪除與排序資料的操作，這樣的特性讓 tuple 被設計在函數的彈性參數與預設多個回傳值之中。自行定義函數時如果希望參數為不定個數，例如一個能夠進行兩個數字、三個數字甚至 n 個數字相加的函數，彈性參數 *args 在函數作用域中其實就是一個 tuple。

def add_n_numbers(*args):
    print(type(args))
    return sum(args)

add_n_numbers(55, 66)
add_n_numbers(55, 66, 77)
## <class 'tuple'>
## 121
## <class 'tuple'>
## 198

自行定義函數時如果希望回傳值有多個，例如一個能夠將一個英文單字的全大寫、全小寫外型都回傳的函數，可以在 return 後以逗號區隔兩個回傳值，函數其實就是回傳一個 tuple。

def upper_lower_cases(x):
    upper_out = x.upper()
    lower_out = x.lower()
    return upper_out, lower_out

multiple_outputs = upper_lower_cases("Luke Skywalker")
print(type(multiple_outputs))
## <class 'tuple'>

字典

字典 dict 顧名思義就是 dictionary 的縮寫，這種資料結構除了儲存資料（Values）以外，還另外利用鍵（Keys）來對資料作索引，這樣的特性讓我們在選擇時可以使用資料的鍵，如此一來在面對長度很大的資料時，不需要耗時計算資料所在的位置。建立的時候使用大括號 {} 將希望儲存的資料包括起來，然後分別將「鍵」與「資料」以 Keys 及 Values 記錄。

primes_dict = {
    "1st": 2,
    "2nd": 3,
    "3rd": 5,
    "4th": 7,
    "5th": 11
}
print(type(primes_dict))
## <class 'dict'>

選擇字典中的資料我們使用中括號 [] 搭配鍵。

print(primes_dict["1st"])
print(primes_dict["2nd"])
print(primes_dict["3rd"])
print(primes_dict["4th"])
print(primes_dict["5th"])
## 2
## 3
## 5
## 7
## 11

新增可以直接宣告 dict_to_be_added["Key"] = Value。

primes_dict["6th"] = 13
print(primes_dict)
## {'1st': 2, '2nd': 3, '3rd': 5, '4th': 7, '5th': 11, '6th': 13}

刪除可以使用字典的 pop(Key, None) 方法將指定的「鍵」與「資料」組合拋出，假如找不到就拋出 None。

the_popped_value = primes_dict.pop("6th", None)
print(primes_dict)
## {'1st': 2, '2nd': 3, '3rd': 5, '4th': 7, '5th': 11}

使用字典的 keys() 、 values() 與 items() 方法，可以分別取出字典中的所有的鍵（Keys）、所有資料（Values）以及「鍵」與「資料」組合（Items）。

print(primes_dict.keys())
print(primes_dict.values())
print(primes_dict.items())
## dict_keys(['1st', '2nd', '3rd', '4th', '5th'])
## dict_values([2, 3, 5, 7, 11])
## dict_items([('1st', 2), ('2nd', 3), ('3rd', 5), ('4th', 7), ('5th', 11)])

集合

集合 set 是 Python 中用來處理「集合運算」的資料結構，在建立的時候使用大括號 {} 將希望儲存的資訊包括起來，並將希望存放的資料型別與資料結構以逗號分隔。

primes_set = {2, 3, 5, 7, 11}
print(type(primes_set))
## <class 'set'>

這個資料結構用來對應數學中的集合相關定理和操作，所以其中只儲存獨一的資料，若輸入多筆重複資料，則會記錄一筆獨一值，並且是一種「無序」的結構，儲存在其中的資料跟建立時的順序性沒有關聯，可能會在操作後更動順序，但這並無大礙，因為集合並不支援索引，無序這個特性也不會影響集合相關定理和操作。

基礎的集合操作有四個：

1. 交集（Intersection）

2. 聯集（Union）

3. 差集（Difference）

4. 對稱差集（Symmetric difference）

上述這四個基礎集合操作都能夠透過呼叫集合的方法實作，其中只有差集沒有交換律（如同減法或者除法一般），另外三者都具有交換律（如同加法或者乘法一般），這些方法都採用以回傳值輸出的機制。

primes_set = {2, 3, 5, 7, 11}
odds_set = {1, 3, 5, 7, 9}
print(primes_set.intersection(odds_set))
print(primes_set.union(odds_set))
print(primes_set.difference(odds_set))
print(odds_set.difference(primes_set))
print(primes_set.symmetric_difference(odds_set))
## {3, 5, 7}
## {1, 2, 3, 5, 7, 9, 11}
## {2, 11}
## {1, 9}
## {1, 2, 9, 11}

在認識了資料結構之後，約維安計畫：第十四週來到尾聲，希望您也和我一樣期待下一篇文章。

延伸閱讀

1. https://docs.python.org/3/tutorial/datastructures.html

對於這篇文章有什麼想法呢？喜歡😻、留言🙋‍♂️或者分享🙌

Leave a comment

解析哈囉世界

在約維安計畫：第十二週我們透過 print("Hello, World!") 來確認 Python 的開發環境及執行環境是否已經安裝妥當，在這一段哈囉世界的程式碼中，其實就能體驗程式設計與資料分析的一個核心精神：對資料應用函數。

print 是函數的名稱，print() 則表示要應用該函數的功能，而 “Hello, World!“ 則是一個被稱呼為字串（String）的資料型別；換言之，哈囉世界可以表達為：對 “Hello, World!“ 這個字串應用了 print 函數。

print("Hello, World!")
## Hello, World!

什麼是函數

函數是構成所有程式語言的基本要素，一個函數是一段「被命名」的程式碼，這段程式碼可以用於執行某個特定任務，可…

Read more

Python is an easy to learn, powerful programming language. It has efficient high-level data structures and a simple but effective approach to object-oriented programming. Python’s elegant syntax and dynamic typing, together with its interpreted nature, make it an ideal language for scripting and rapid application development in many areas on most platforms.

Python 是一種廣泛用途程式語言（General-purposed programming language），具有高階、直譯、與簡潔的特性，由荷蘭電腦科學家 Guido van Rossum 於 1991 年創造，目前由 Python 軟體基金會維護。Python 在資料科學、網站開發與系統自動化等應用領域中倍受熱愛，全球知名公司像 Pixar 用於電影製作、Twitch 用於系統建置以及 Spotify 用於推薦歌曲。在 NumPy、SciPy、Pandas、Matplotlib、Scikit-Learn、TensorFlow 與 PyTorch 等套件的強力加持下 Python 成為世界各地資料科學團隊的首選，團隊裡的資料科學家使用 Python 從資料中挖掘特徵尋找洞見（Insight）、資料工程師使用 Python 建構與部署機器學習與自動化系統，為企業獲取競爭優勢。

驚人的受歡迎程度

截至 2021 年 7 月，Python 在 TIOBE Index 排名第 3 位、在 2020 IEEE Top Programming Languages 調查排名第 1 位、在 StackOverflow Trends 以 16% 問題比率排名第 1 位；根據資料科學家社群 Kaggle 在 2020 年針對網站會員所發出的問卷，Python 在資料科學家日常頻繁使用語言中排名第一，對於技能組合涵蓋資料科學與軟體工程的約維安而言，學習 Python 的重要性不言可喻。

Python 風格指南

風格指南（Style guide）指的是一套規範程式語言在寫作時必須遵守的編排、格式和設計的準則，遵從風格指南能夠確保每一段程式碼都和其他不同人寫作的程式碼有高度一致性，被眾多使用者採用的 Python 風格指南是官方的 Python 改進提案（Python Enhancement Proposals, PEPs）第八項：https://www.python.org/dev/peps/pep-0008，約維安計畫也同樣遵循 Python 改進提案第八項，其中值得注意的幾個重點有：

• 縮排使用四個空格，不同於多數的程式語言使用一對大括號（A curly-brace pair）將敘述包裝形成程式區塊（Code blocks），Python 使用縮排（Indentations）將敘述包裝為程式區塊，因此這個風格顯得格外重要。

• 命名的時候使用全小寫英文，採用蛇形命名法（Snake case），不同單字之間以底線 _ 相隔。

• 不能使用保留字作物件的命名，會產生錯誤，Python 的保留字可以參考：https://docs.python.org/3/reference/lexical_analysis.html#keywords

• 使用單數名詞為資料型別（Data types）實例的物件命名，使用複數名詞為資料結構（Data structures）實例的物件命名，使用動詞為函數（Functions）或方法（Methods）命名，盡量讓名稱簡潔且具有意義。

• 不要使用內建函數作物件的命名，避免覆蓋內建函數的功能，Python 的內建函數可以參考：https://docs.python.org/3/library/functions.html。

# Good Python naming
taiwan_number_one = True
taiwan_number_1 = True

# Bad Python naming
taiwanNumberOne = True
Taiwan_Number_One = True
TaiwanNumberOne = True
twno1 = True
int = 87  # int() is a built-in function

Python 的哈囉世界

「哈囉世界」是每種語言最基本也最簡單的程式，通常用作確認一個語言如何運作、編譯器、開發環境及執行環境是否已經安裝妥當。要順利運行 Python 的哈囉世界以及未來的 Python 資料科學應用，首先要確定在 Jupyter 星球的伺服器選項選擇了「Data science environment：學習 Python、R 與 Julia 的資料科學環境」。

忘記了什麼是 Jupyter 星球嗎？複習一下約維安計畫：第零週吧！

伺服器啟動之後來到 Jupyter 星球的首頁，在右方 Launcher 點選新增一個核心（Kernel）為 Python 3 的 Jupyter Notebook。

並且在 Jupyter Notebook 的第一個儲存格中印出 Python 的哈囉世界：

print("Hello, World!")

除了 Python 的哈囉世界，我們也很鼓勵初學者花一點時間閱讀 Python 禪學（The Zen of Python），暸解設計以及愛好這個程式語言的人在解決問題或者面臨抉擇的時候，大都採用什麼樣的價值觀與思緒，我最喜歡的一句 Python 禪學是：

Now is better than never.

在 Jupyter Notebook 的第二個儲存格中印出 Python 禪學：

import this

大功告成，在順利執行了 Python 的哈囉世界以及 Python 禪學之後，約維安計畫：第十二週來到尾聲，希望您也和我一樣期待下一篇文章。

不知道各位閱讀完 Python 禪學之後最喜歡的是哪一句？請執行 import this 過後的中級約維安在這篇文章留言回覆🙋跟我們分享你最喜歡的一句 Python 禪學😻

Leave a comment

約維安計畫即將迎來第二個里程碑專案！從第六週到第十週，我們從本機端的學習環境到 SQL 的進階查詢，暸解如何在 Jupyter 星球學習並且練習 SQL。

忘記了什麼是 SQL 嗎？不要緊，透過這個里程碑專案，正是讓我們複習一下這五週學習文章的好機會！

1. 約維安計畫：第六週 | 本機端的學習環境。

2. 約維安計畫：第七週 | SQL 起步走。

3. 約維安計畫：第八週 | SQL 的基礎查詢。

4. 約維安計畫：第九週 | SQL 的中階查詢。

5. 約維安計畫：第十週 | SQL 的進階查詢。

里程碑專案

點擊第十一週的資料夾連結：第十一週的專案資料夾。

點擊連結之後將會複製一份專案資料夾到 Jupyter 星球的首頁，開啟這個資料夾我們可以看到五個檔案：

• README.md

• notebook.ipynb

• exercise…

Read more