---
# System prepended metadata

title: 東山高中程式研究社 教學講義-Python-大補帖

---

# 東山程式研究社 教學講義 - Python篇
||RE:從零開始的python生活||
###### 本篇內容僅止於理論層面，實際的應用要自己多練習才行，練習非常的重要，光聽理論不練習等於是白學了，當然，所謂練習不一定是要去zerojudge之類的刷題，自己找點專案來做也是一個不錯的方法
###### 事前聲明:本篇多數內容源於作者本人的經驗，不保證完全正確，如有錯誤，敬請提出
## 基本概念 - 各種的數
> 寫程式的時候會有各種的'數'，對於他們要有清楚的概念才能順利做開發喔
### 1.常數
> 程式中的常數就跟數學裡的常數一樣，就是`1`, `2`, `3`, `4`, `5`等數字
### 2.變數
> 程式中的變數對應到數學中最接近的就是`x`，本質上是以一個名字代表一個數字，小學高年級教的"設x為ooo的數量"就是類似變數的概念
### 3.函數
> 程式中的函數概念就類似數學中的`f(x)`，用`f`代表對於`x`的一連串操作
## 基本素養 - 命名
### 0.為什麼要學基本素養
> 子曰 : 「弟子入則孝，出則弟，謹而信，汎愛眾，而親仁。 行有餘力，則以學文」
> 意思是青年人在家要講求孝道，出外要友愛兄長，行為謹慎而說話信實，普遍關懷他人，並接近有仁德的人，做好這些事之後有餘力，再努力學習書本上的知識
> 做開發也是一樣的道理，要先有寫程式的基本素養，再去學習實際應用上的語法
### 1.變數命名
> 變數命名是一個很大的學問，想要學好程式語言的第一步就是學會怎麼給變數取個適當的名字
> (1) 變數的名稱是給人看得，因此最重要的就是要看的懂且容易理解，`a`, `b`, `c`, `d`就是看不懂的名稱，因此不是個好命名||~~如果說是和其他人一起開發的話這樣的命名一定會被揍~~||，不過有時候做個測試懶得想名字的話也是可以用啦
> (2) 變數為了讓人理解他的意思，因此經常會連接好幾個單字，這個時候就有各種做法了，假如要設定一個由`eat`和`apple`合起來的變數，那麼通常會用`EatApple`, `eatApple`, `eat_apple`等命名方式
> (3) 變數的名稱其實沒有強求要用英文，但平常也不會有人用中文去給變數命名
### 2.函數命名
> 函數命名其實跟變數命名大差不差，只不過通常函數跟變數會用兩種不同的命名風格，才不容易搞混
### 3.檔案命名
> 在開發專案時，通常會有一個主程式和其他的副程式，這個時候，主程式通常會叫做`main.py`(就算是其他語言也還是會用`main`)
> 其他的副程式通常會根據其功能來命名，切記，**不要用中文幫檔案命名**
## 基本素養 - coding style
> coding style是寫出漂亮的程式前最重要的一個素養，沒有好的coding style的話，不只整體不好看，更是會讓其他人在讀的時候很煩躁
### 1.基本的coding style
> (1) 在運算符號和變數的前後都要加上`space`，`,`的後面也要加上一個`space`
> (2) 當程式的長度拉長後，就會慢慢分成一區一區的，這個時候區與區之間通常會留一行空白，以方便區分
> (3) 注意，coding style有很多種流派，每一個人都不太一樣，重點在於不要讓人看得很煩躁
> ### 不好的coding style(擠成一坨，讓人看得很煩躁)
> ```python=1
> number1=1
> number2=5
> for i in range(10): #重複跑下面那一行10次
>   number1=((number2+5)-(3+2/number1))/3-2
> print(number,end=' ')
> ```
> ### 好的coding style(運算子之間適度分開，增加可讀性)
> ```python=1
> number1 = 1
> number2 = 5
> for i in range(10): #重複跑下面那一行10次
>   number1 = ((number2+5) - (3+2 / number1))/3 - 2
> print(number, end=' ') #一般來說=前後會加空格，但是用在屬性時就是例外
> ```
## 基本素養 - 註解
> 在做多人開發時，因為是大家一起合作，因此要看的懂別人寫的程式，以及要讓別人看得懂自己寫的程式，因此需要註解
> 寫註解的時候要盡量讓人能夠清楚明白該段程式在做什麼
> ```python=1
> w = float(input()) #把輸入的資料強制轉換成數字
> h = float(input())
> ans = w / h ** 2 #不寫註解的話就要花時間才知道這是在算bmi
> print(ans)
> ```
## 基本語法 - 變數(variable)
### 1.設定變數
> python設定變數不像C/C++那麼麻煩，只要`a = xxx`就行了
> 命名規則就跟其他語言一樣，不能和函數重複名稱、不能用數字開頭、不能有空格、不能用`+ - * /`等有意義的符號等等
### 2.變數的值
> 變數的值要改變的話，就跟設定時一樣，使用`=`
> 改變變數的數值時也可以用`a += 1`，意思是`a = a + 1`，也可以替換成`- * /`等運算子
> ```python=1
> num = 10
> num += 1
> print(num)
> ```
> ### 選項
> ```
> (A) 9
> (B) 10
> (C) 11
> ```
> 答案:||C||
> 
## 基本語法 - 基本運算子
> 基本運算子簡單來講就是`+ - * /`這些，通常會跟變數一起用
### 1. +
> 非常的簡單，就是數學上的`+`
> ```python=1
> num = 10 + 1
> print(num)
> ```
> ### 選項
> ```
> (A) 9
> (B) 10
> (C) 11
> ```
> 答案:||C||
### 2. -
> 跟`+`差不多，就是數學上的`-`
> ```python=1
> num = 10 - 1
> print(num)
> ```
> ### 選項
> ```
> (A) 9
> (B) 10
> (C) 11
> ```
> 答案:||A||
### 3. *
> 反正就是乘
> ```python=1
> num = 10 * 2
> print(num)
> ```
> ### 選項
> ```
> (A) 5
> (B) 20
> (C) 100
> ```
> 答案:||B||
### 4. /
> 除以
> ```python=1
> num = 10 / 3
> print(num)
> ```
> ### 選項
> ```
> (A) 1
> (B) 3
> (C) 3.0
> (D) 3.33333
> ```
> 答案:||D||
### 5. //
> 也是除以，只不過小數無條件捨去
> ```python=1
> num = 10 // 3
> print(num)
> ```
> ### 選項
> ```
> (A) 1
> (B) 3
> (C) 3.0
> (D) 3.33333
> ```
> 答案:||B||
### 6. %
> 也是除以，不過是餘數
> ```python=1
> num = 10 % 3
> print(num)
> ```
> ### 選項
> ```
> (A) 1
> (B) 3
> (C) 3.0
> (D) 3.33333
> ```
> 答案:||A||
### 7. **
> 是次方
> ```python=1
> num = 10 ** 2
> print(num)
> ```
> ### 選項
> ```
> (A) 5
> (B) 20
> (C) 100
> ```
> 答案:||C||
## 基本語法 - I/O
### 1.print()
> 最基本的`print()`中要傳入一個`object`，以下以`"hello world"`為例
> ```python=1
> print("hello world")
> ```
> ### output
> ```
> hello world
> ```
> `print()`中總共可以傳入至少一個物件+四個屬性，分別是`object`, `sep`, `end`, `file`, `flush`，屬性如果不寫的話就是用預設值
> `object`是輸出的內容，也就是物件，是`print()`最重要的部分，多於一個的話要用`','`分隔
> `sep`是兩個或以上`obejct`之間的間隔，預設是空格
> `end`是本次輸出的結尾，預設是`\n`，也就是換行
> `file`是本次輸出夾帶的檔案，預設是`None`
> `flush`不常用到，我也不會用，總之預設是`False`
> ```python=1
> print("hello world", "python")
> print("hello world", "python", sep=',')
> print("hello world", "python", sep=',', end='!')
> ```
> ### output
> ```
> (A) hello world python
>     hello world,python
>     hello world,python!
>     
> (B) hello world python
>     hello,world,python
>     hello world!python,
> ```
> 答案:||A||

### 2.input()
> 輸入就非常的簡單，就是`input()`，其中可以傳入內容，但就只是在輸入時印出來，通常用於給使用者指示

## 基本語法 - type(類型)
> 可以使用`type()`去取得變數的類型
> 可以使用`type_name()`去強制轉換格式(不要真的打`type_name(xxx)`那裡是要填自己要的type的)，但是通常只用在`int`, `float`, `str`之間(有沒有其他的我不知道)，其他type的話會因為格式問題跳出`TypeError`
> 實際上python的type遠不止以下這些，有些模組甚至會有自己的特殊的type，例如`discord.py`有一種獨立的type叫做`<class 'discord.message.Message'>`
### 1.int
> `int`是整數，全名是integer，和在C/C++的上限2^31^-1不同，python的`int`沒有上限(查資料查到的，實際我也沒有測到他的上限)，如果把數值換成`int`的話，會無條件捨去到整數
> 或許有點用處的小知識 : 如果把文字的`'123'`轉換成`int`的話，它會確確實實的變成數字的`123`
> ```python=1
> print(int(1.9))
> ```
> ### 選項
> ```
> (A) 1
> (B) 1.9
> (C) 2
> ```
> 答案:||A||
### 2.float
> `float`是浮點數，也就是有小數點的數，在C/C++中浮點數有`float`和`double`，但是在python只有`float`
> 或許有點用處的小知識 : 如果說把整數轉變成`float`的話，數字後面會多一個`.0`
> 或許有點用處的小知識 : python的無限大是`float`
> ```python=1
> num = float(1)
> print(num)
> ```
> ### 選項
> ```
> (A) 1
> (B) 1.0
> (C) 1.0000 
> ```
> 答案:||B||
### 3.str
> `str`是字串，全名是string，以`" "`或`' '`括起來，不像C/C++分成`char`跟`String`，python就只有`str`，值得注意的是`str`有需多性質跟`list`是通用的，但也有只屬於`str`本身的性質，後面會詳細講，||因為真的超級多，這裡寫不下||
> ```python=1
> print("hello,world".split) #split可以把str從指定的地方分開，這裡次從,的地方分開
> print("abcd"[0]) #str也可以有list的索引值的概念
> print("abcd".upper()) #upper可以把所有字母變大寫
> print("ABCD".lower()) #lower可以把所有字母變小寫
> ```
> ### output
> ```
> ['hello','world']
> 'a'
> ABCD
> abcd
> ```
### 3.1.f-string
> 屬於`str`的變種，本質上是一種`str`，特別的是可以用`{variable}`插入變數，寫法就是在`""`前面加一個`f`
> ```python=1
> number = 10
> print(f"number is {number}") #f-string
> print("number is {number}")  #str
> ```
> ### output
> ```
> number is 10 
> number is {number}
> ```
### 4.list
> `list`有很多種名稱，陣列、清單、串列之類的通通都是`list`，它就是一串的清單，處存很多的資料，其中，以索引值(`index`)來提取資料(第一項是`0`)，以中括弧`[]`括起來，其中的資料被稱為元素(`element`)
> `list`的部分後面還會單獨拿出來仔細講，因為很重要，這裡只是簡單帶過
> ```python=1
> List = [1,2,3,4,4,4]
> print(List[0])
> del List[0] #del可以刪除list中指定位置的資料，這裡是刪掉list的第一項
> print(List)
> List.remove(4) #remove可以刪除list中所有指定的資料，這裡是刪掉所有的4
> print(List)
> ```
> ### output
> ```
> 1
> [2,3,4,4,4]
> [2,3]
> ```
### 5.tuple
> `tuple`跟`list`非常相似，差別在於`tuple`不可改變，且讀取速度比較快
> ```python=1
> t = (1,2,3)
> print(t[0])
> ```
> ### output
> ```
> 1
> ```
### 6.dict
> 全名dictionary，也很類似`list`，差別在於`dict`的索引由使用者自訂，前後以大括弧`{}`括起來
> ```python=1
> diction = {
>   "apple":"banana",
>   "melon":"mango"
> }
> print(diction["apple"]) #叫出diction裡面引索是"apple"的內容
> ```
> ### output
> ```
> 'banana'
> ```
### 7.bool
> 全名boolean，就是`True`跟`False`
> 有點用的小知識 : 除了`0`以外，其他的文字數字一蓋會被判定為`True`，只有`0`是`False`
> ```python=1
> print(type(True)) 
> ```
> ### output
> ```
> <class 'bool'>
> ```
### 8.range
>一般用在`for`迴圈||~~其實我根本就沒有在其他地方用過，這裡會講單純只是因為後面要提到了~~||，後面會有三個值，分別是最小值、最大值和差，並會形成一個數列
>```python=1
>r = range(0,5,2) #r = [0,2,4]
>print(r[0], r[1], r[2], sep='\n')
>```
>### output
>```
>0
>2
>4
>```
### 9.其他
> 以上只是舉了一些我有想到的type，實際上python還有很多各式各樣的類型，剩下的自己去發現吧(雖然就算不會那些type也不會怎樣)
## 基本語法 - 特殊字元
> 一律以`\`開頭，如果說真的要打反斜線的話，要打兩個`\`
> 通常用於輸出的時候
> 1.`\n`是換行，就是很單純的在輸出的時候換行
> 2.`\t`是`tab`，在輸出的時候印出一個縮排(通常是四個空格，有時候是兩個)
> 3.`\b`是倒退字元，作用跟鍵盤上的`backspace`一樣，就是往後退一格
> 4.`\0`是空字元，用於`str`的結尾
> 5.`\r`在輸出的時候會跳回當前那一行最前面，後面輸出的東西會把先前的覆蓋掉
> ```python=1
> text = "abc\ndef\tghi\bjkl\r12"
> print(text)
> ```
> ### output
> ```
> abc
> 12f     ghjkl
> ```

## 基本語法 - if elif else(條件判斷)
### 1.運算子
> 運算子有很多種，也都有各自的用途，基本上分成邏輯運算子、比較運算子、算數運算子，在這一部份主要使用邏輯運算子跟比較運算子，算數運算子主要用於變數的操作，也就是數學上常用的`+ - * /`等
>   運算子的大重點 : 使用邏輯運算子跟比較運算子時，會有一個`bool`的回傳值，`if`之所以常常直接接判斷式就是後面運算子回傳的`True` `False`
>   條件判斷的大重點 : 要告訴電腦`if`, `elif`, `else`成立時要執行那些動作，因此使用縮排來標示其內容
> ### (1)邏輯運算子
> > 常見的有`and`, `or`, `not`，用於判斷兩邊的值
> > ```python=1
> > a = True and True
> > b = True and False
> > c = True and not False
> > d = True or False
> > print(a, b, c, d) 
> > ```
> > ### 選項
> > ```
> > (A) True False True True
> > (B) True True False False
> > (C) False True True False
> > (D) False False False True
> > ```
> > 答案:||A||
> ### (2)比較運算子
> > 常見的有`==`, `>=`, `<=`, `!=`, `>`, `<`，用於判斷兩邊的數值
> > ```python=1
> > a = 1 == 1
> > b = 1 >= 2
> > c = 1 <= 2
> > d = 1 != 1
> > e = 2 > 1
> > f = 2 < 1
> > print(a, b, c, d, e, f, sep=',') 
> > ```
> > ### 選項
> > ```
> > (A) True,False,True,True,True,False
> > (B) True,False,True,False,True,False
> > (C) False,False,True,True,False,True
> > (D) 1 == 1,1 >= 2,1 <= 2,1 != 1,2 > 1,2 < 1
> > ```
> > 答案:||B||
### 2.if
> `if`就跟英文的意思一樣，就是如果，`if`後面如果是`True`那麼就會執行接下來的動作，`False`則不執行，前面的那些運算子就是用來接在`if`後面，去判斷條件成不成立
> ```python=1
> a = 1
> if a == 1:
>   print("good")
>   
> if a == 2:
>   print("bad")
> ```
> ### 選項
> ```
> (A) good
> (B) bad
> ```
> 答案:||A||
### 3.elif else
> `elif`是在前面的`if`不成立時，才會執行的判斷式，`else`是前面的所有判斷式都不成立時，就會直接執行裡面的內容
> ```python=1
> a = 1
> if a == 2:
>   print("good")
>   
> elif a == 3:
>   print("bad")
>   
> else:
>   print("so so")
> ```
> ### 選項
> ```
> (A) good
> (B) bad
> (C) so so
> ```
> 答案:||C||
## 基本語法 - loop(迴圈)
> 迴圈是一個重複執行的結構，根據使用者的設定進行重複
> 迴圈的大重點-1 : `break`，當任何迴圈遇到`break`的時候就會馬上跳出迴圈
> 迴圈的大重點-2 : `continue`，當迴圈遇到`continue`時，會直接無視本次循環剩餘的部分，直接進到下一個循環
> 迴圈的大重點-3 : 迴圈是讓內部的區塊重複執行，因此必須讓電腦知道哪些部分是在迴圈內部，所以要縮排(按`tab`)
> 
### 1.for
> `for`迴圈基本上是讓變數沿著某物件的索引值跑，直到跑完或是遇到`break`
> `in`後面如果是`list`的話就會從第一項跑到最後一項，`str`則是從第一個字元跑到最後一個，`range`的話就會是沿著生成的數列去跑，初學的話最常用的是`for i in range(n):`
> ```python=1
> for i in range(5): #讓i沿著range(5)跑
>   print(i, end=',')
>   
> print('\b') #最後會多一個, 用\b把它刪掉
> ```
> ### 選項
> ```
> (A) 1,2,3,4,5
> (B) 0,1,2,3,4
> ```
> 答案:||B||
### 補充:多重迴圈
> 多重迴圈簡單講就是好幾個迴圈包在一起，經常跟多維陣列一起用，直接看例子比較快
> 運行的順序會是`i=0`，然後`j`從`0`跑到`n`，接著`i=1`，循環至`i=n`
> ```python=1
> for i in range(2):
>   for j in range(2): #注意這裡不要打for i in range，一定要i以外的東西，不然迴圈會出問題
>     print(f"{i}, {j}", end='|')
>   print()
> ```
> ### output
> ```
> 0, 0|0, 1|0, 2|
> 1, 0|1, 1|1, 2|
> 2, 0|2, 1|2, 2|
> ```
### 2.while
> `while`迴圈是只要後面跟的值是`True`且中途沒有遇到`break`就會持續運行的迴圈
> ```python=1
> times = 0
> run = True
> while run:
>   times += 1
>   if times == 10:
>     run = False #run變成false後，下一個循環就不會開始，因為while後面的值不再是true
>     
> print(times)
> ```
> ### 選項
> ```
> (A) 9
> (B) 10
> (C) 11
> ```
> 答案:||B||
## 基本語法 - list(更詳細的)
> `list`最簡單的概念在前面type的章節已經提過，這裡主要講應用方面
### 1.一維陣列
> 最簡單的`list`就是常見的`a = [0, 1, 2]`這種的，通常稱為一維陣列，常常會用火車、櫃子之類的東西去形容，總之就是一連串的資料，且使用索引值代表資料的位置
>
> | 0 | 1 | 2 | 3 | ... |
> | - | - | - | - | --- |
> 
> 通常會搭配for迴圈去讀取資料
> ```python=1
> l = [0, 1, 2, 3]
> for i in l:
>   print(i, end=' ')
> ```
> ### 選項
> ```
> (A) 0 1 2 3
> (B) 1 2 3 4
> ```
> 答案:||A||
### 2.延伸:二維陣列
> 簡單講就是`list`的各項元素仍然是`list`，可以把他畫成一個`n * m`的平面
> 舉個常見的例子，平常看到的圖片就是一個二維陣列，也就是平面||雖然說定義上來說圖片其實算是三維陣列，不過他的概念是二維的||，像是數學的矩陣一樣，經常用`i, j`代表其位置，也可以理解成一種座標，大致上會像下面那樣
>
> | | | |
> | - | - | - |
> | 0,0 | 0,1 | 0,2 |
> | 1,0 | 1,1 | 1,2 |
> | 2,0 | 2,1 | 2,2 |
> ```python=1
> l = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]
> #l = 
> #[0, 1, 2]
> #[3, 4, 5]
> #[6, 7, 8]
> for i in l:
>   for j in i:
>     print(j, end=' ')
>   print()
> ```
> ### output
> ```
> 0 1 2
> 3 4 5
> 6 7 8
> ```
## 基本語法 - str(更詳細的)
> 前面大致提過了`str`的事情，這裡會更詳細的講
> 在C/C++中，有兩種字串，一種就是普通的`string`，另外一種則是`char`的陣列，就結論來說是一樣的東西，至於python的`str`則是有著部份`list`性質的格式
> 類似於`list`的部分主要是索引值(index)，一個`str`可以畫成下面的樣子，使用方法參照前面`list`的部分
> | 0 | 1 | 2 | 3 | 4 | 
> | - | - | - | - | - |
> | A | P | P | L | E |
>
> 除此之外，`str`也有一些專屬的性質，舉個簡單的例子`str.split()`可以將`str`從指定的字元切開，變成一個`list`
> ```python=1
> s = "hello, world"
> l = s.split(',')
> print(l)
> ```
> ### output
> ```
> ['hello', ' world']
> ```
> 應用上還有一個很重要的性質，`str`是可以直接疊加的，也就是`"a" + "b" = "ab"`等式成立，實際使用時經常會搭配`int`一起用，形成`"1" + "2" = "12"`的情況，再將`"12"`轉成`int`，就可以將數字直接用相加，不用`1 * 10 + 2`
> 一定要注意的地方 : 如果說想要把`str`轉成`int`，一定要確保他每一個字元都是數字，不然會跳`TypeError`
> ```python=1
> s1 = "10"
> s2 = "20"
> s3 = s1 + s2
> print(int(s3) - 1)
> ```
> ### output
> ```
> 1019
> ```
## 基本語法 - import
> `import`是python在做專案時最重要的東西，簡單來說，`import`就是裝外掛，從外部引進函式庫，然後在程式中運行，類似C/C++的`include`
> `import`主要分成兩類，一個是引入模組(module)，另外一個是引入其他檔案(實際上這兩個是一樣的東西，只是分開來比較好講)
### 1.引入模組
> python在下載的時候就會有一些內建的模組，例如`random`, `time`, `math`...
> 如果要用其他的第三方模組(非官方)就需要另外下載，通常是用一個名為`pip`的套件(其實還有很多雜七雜八的下載方式，但這裡就不提了)
> ``` python=1
> import random as rand  #引入random後，將後面要使用時的名稱設定成rand
> 
> r = rand.randint(1,10) #r會是1~10的隨機數字
> print(r)
> ```
> ### output
> ```
> 5
> ```

### 2.引入檔案
> 引入檔案其實跟引入模組是一樣的概念，差別在於模組存在系統的資料夾裡面，檔案就是根據使用者的設定
> 引入檔案實際上是從檔案中引入函數，使用者可以在其他檔案自訂一些函數，然後引入到程式中使用，至於怎麼自訂函數後面會說
> ```python=1
> from function import * #星號代表引入所有該檔案中的函數，注意檔案名稱後面不用打.py
> 
> number = 1
> number = function.plus(number,10) #這裡的plus函數就是在function.py裡面設定的
> print(number)
> ```
> ### output
> ```
> 11
> ```
## 基本素養 - 錯誤訊息(Error message)
> 在開發的時候，難免會有一些地方打錯之類的，這個時候系統就會跳出錯誤訊息，但是python的錯誤訊息寫得不明不白，因此就需要了解各種`Error`是怎麼發生的，在debug的時候才不會一頭霧水
### 1.錯誤類型
> 以下舉一些常見的錯誤類型(那個中文名稱是我亂翻的，一般都是講英文的)
> `SyntaxError`是語法錯誤，通常是函數的使用方法搞錯
> `IndexError`是索引值錯誤，如果要求的索引值超出`list`的範圍的話就會跳出來
> `ValueError`是值錯誤，最常發生在把文字轉成數字的時候
> `ModuleNotFoundError`是模組錯誤，在`import`不存在的模組時出現
> `ZeroDivisionError`是除零錯誤，在某數被除以`0`時出現
> `TypeError`是類型錯誤，最簡單的就是強制把`int`和`str`接在一起時出現
> `NameError`是名稱錯誤，大多數情況是呼叫了不存在的變數
> `ImportError`是引入錯誤，在`import`時呼叫了不存在的函數時出現
### 2.錯誤訊息
> 了解了各式錯誤類型後，就要學會怎麼看錯誤訊息，最基本的就是直接看錯誤訊息的最後幾行，他會跟你說什麼錯誤、錯在哪一行，知道錯在哪後，就去程式碼裡面找到那一行，然後修改，這就是最基本的debug
## 進擊的語法 - module應用
> 好用的module除了要會`import`以外，還要知道如何使用
> 以下列舉一些常用的內建module
### 1.random
> `random`是python內建的module，用於取隨機值，以下列舉一些常用的`random`的函數
>  `random.randint(a, b)`可以取一個`n`, `a <= n <= b`
>  `random.randrange(a, b, c)`可以從`range(a, b, c)`中隨機取一個值
>  `random.choice(seq)`通常`seq`會接`list`，讓它從中隨機取一個`element`
### 2.time
> `time`是python內建的module，用於做時間相關的工作
> `time.gmtime()`取得從Unix Time(經度0^o^的`1970/1/1 00:00`)開始到當下經過的時間(秒數)
> `time.localtime()`類似`gmtime`，但是變成取當地時間
> `time.sleep(sec)`讓程式暫停`sec`的秒數
### 3.math
> `math`是python內建的module，用於數學相關工作
> `math.ceil(x)`將`x`向上取整||~~反向高斯符號~~||
> `math.comb(n, m)`計算數學的`C n取m`
> `math.fabs(x)`回傳`x`的絕對值
> `math.factorial(x)`回傳`x!`
> `math.log(x)`回傳log~e~x
> `math.log2(x)`回傳log~2~x
> `math.log10(x)`回傳log~10~x
## 進擊的語法 - def(自訂函數)
> 有時候寫程式的時候會遇到不斷重複的部分，這個時候就可以用`def`去將其設定為一個函數，這樣一來，使用的時候就會方便很多，下面的例子兩邊的輸出結果一模一樣，但是使用`def`的話看起來就會簡潔很多，如果要使用更多次的話也會比較方便
> ### 不使用def
> ```python=1
> x = [1, 2, 3]
> save = x[0]
> del x[0]
> x.append(save)
>
> y = [4, 5, 6]
> save = y[0]
> del y[0]
> y.append(save)
>
> print(x)
> print(y)
> ```
> ### 使用def
> ```python=1
> def operate(L):
>    save = L[0]
>    del  L[0]
>    L.append(save)
>    return L
>
> x = [1, 2, 3]
> y = [4, 5, 6]
> x = operate(x)
> y = operate(y)
> print(x)
> print(y)
> ```
## 進擊的語法 - try/except(除錯用)
> 當程式在運行的時候，如果碰到`Error`就會直接結束，這個時候就要用到`try`和`except`了，他可以在出現`Error`時執行特定指令，並且繼續執行後面的程式
> ```python=1
> try:
>   a = "abcd"
>   b = int(a)
>   print(b)
>   
> except ValueError as err: #當try的範圍內出現錯誤且類型是ValueError時，執行except裡面的內容，如果不是的話，就會跟平常一樣跳出Error訊息
>   print(err) #印出錯誤訊息
>   
> print("keep running")
> ```
> ### output
> ```
> invalid literal for int() with base 10: 'abcd'
> keep running
> ```
## 進擊的語法 - class(物件類型)
> ### 補充 : 物件導向程式設計(object-oriented programming, OOP)
> >傳統的程式設計主要為直接向電腦發出指令去運作，物件導向程式設計則以物件為基本，每個物件都可以接收、處理、傳遞資料給其他物件，概念類似多個機器之間互向連接，形成一個工廠
> >常見的物件導向程式設計有python, C++, objective-C, C#, java script, java, PHP等 
>
> `class`可以創建一種類別的物件，藉由創建出來的類別再去創建物件，一個物件可以有各種參數與功能
> ```python=1
> class sample: #創建名為sample的物件類型
>   def __init__(self, num1, num2): #設定這個物件所要的參數 這裡分別是num1和num2 self就是物件本身
>     self.num1 = num1
>     self.num2 = num2
>     
>   def plus(self): #創建物件的功能
>     return self.num1 + self.num2
>     
>   def minus(self):
>     return self.num1 - self.num2
>     
> samp = sample(10,20) #創建名為samp的物件 類型是sample 參數分別是10 20
> result1 = samp.plus() #使用物件的功能
> result2 = samp.minus()
> print(result1, result2)
> ```