【Python基礎教學】資料型態函數及方法（上）【part-8】
===
目錄（Table of Contents）
[TOC]
---
哈囉大家好，很感謝你點進本文章，我是一名高中生，是電腦社社團的社長，由於我並不是 Python 這方面非常精通的專家，所以若文章有些錯誤請見諒，也可向我指正錯誤。另外本文章的用意是作為電腦社社團的教材使用而編寫的。
接下來，讓我們進入正題。
當我們在 part 7 談完迴圈以後，其實大部分的簡易實作題型都能勉強應付了，不過我們現在所缺少的是「演算法」、「Python 內建函數及方法」的認知學習及實際應用，接下來會慢慢教給各位上述所言，首先，讓我們先從資料型態的函數及方法開始。
數字（Number）
---
Number 的資料型態被定義為不可變物件，這意味著如果改變 Number 的數值的話，Python 將會自動分配記憶體空間給新的數值。
Python 支援以下三種不同的數值型態：
* 整數（integer-簡寫為 int）：通常被稱為是整數，可以是正或負整數，**「不含小數點」**。 Python3 整數是沒有限制大小的，可以當作 Long 型態使用，所以 Python3 沒有 Python2 的 Long 型態。布林 (bool) 是整數型態的子型態（所以 bool 也是整數）。
* 浮點數（float）：浮點數由「整數部分」與「小數部分」組成，浮點數也可以使用科學計數法表示（2.5e2 = 2.5 x 102 = 250 -> 這是電腦中使用科學記號的方式）。
* 複數（complex）：複數由「實數部分」和「虛數部分」構成，可以用 a + bj，或者是complex(a,b) 表示，複數的實部 a 和虛部 b 都是浮點數。
我們可以使用電腦中常用的二進位（binary）、八進位（octal）、十六進位（hexadecimal -> 簡稱：hex）來表示整數：
```python=
>>> number = 0xA0F # 十六進位
>>> number
2575
>>> number=0o37 # 八進位
>>> number
31
>>> number = 0b1011 # 二進位
>>> number
11
```
二進位以「0b」作為開頭，後面輸入二進位數字；八進位以「0o（小寫O）」作為開頭，後面輸入八進位數字；十六進位以「0x」開頭，後面輸入十六進位數字。
:::success
這樣整理就懂！
二進位 -> 0b + 二進位數字（0、1），0b 把它想成二進位的英文為 binary，0 是觸發二進位數字的關鍵字。
八進位 -> 0o + 八進位數字（1、2、3、4、5、6、7），0o 八進位的英文是 octal。
十六進位 -> 0x + 十六進位數字（1、2、3、4、5、6、7、8、9、A、B、C、D、E、F），0x 十六進位的英文是 hexadecimal。
:::
### 如何導入模組？
---
很簡單，我們可以使用 import <函式庫> 指令來引入模組，如下所示：
`import math`
這樣便能引入數學相關的模組，就可以使用相關的函數了。
覺得名稱太長？用以下方式可以簡短：
`import math as m`
又或者是你只想要引入幾個方法或函數就好，可這樣做：
```python=
from math import ceil
print(ceil(1.2)) # 2
```
:::danger
必須注意：這樣子引入模組只有引入 ceil() 而已，並沒有引入整個 math 函式庫，所以要呼叫 math.ceil() 不須加上 math.，打上 ceil() 就好。
:::
可以引入多個：
```python=
from math import ceil, floor
print(floor(1.2)) # 1
```
接下來將列出以下幾個較為常用的數學函數：
| Number | 函數 | 描述 |
| -------- | -------- | -------- |
| 1 | abs(x) | 回傳數字的絕對值，如 abs(-1) 回傳 1。 |
| 2 | math.ceil(x) | 回傳無條件進位後的數字，如 math.ceil(4.1) 回傳 5。 |
| 3 | math.floor(x) | 回傳無條件捨取後的數字，如 math.floor(4.9) 回傳 4。 |
| 4 | math.fabs(x) | 回傳數字的絕對值（以浮點數方式回傳），如 math.fabs(-1) 回傳 1.0。 |
| 5 | max(x1, x2, x3, ...) | 回傳所有引數中的最大值，引數可為序列（如列表、元組）。 |
| 6 | min(x1, x2, x3, ...) | 回傳所有引數中的最小值，引數可為序列（如列表、元組）。 |
| 7 | pow(x, y) | x**y 運算後的值。 |
| 8 | sqrt(x) | 回傳數字的平方根（二次方根）。 |
以下是一個範例：
```python=
import math
# 範例數字
num1 = -4.7
num2 = 16
num3 = 5
# 1. abs(x)
absolute_value = abs(num1)
print(f"abs({num1}) = {absolute_value}")
# 2. math.ceil(x)
ceiling_value = math.ceil(num1)
print(f"math.ceil({num1}) = {ceiling_value}")
# 3. math.floor(x)
floor_value = math.floor(num1)
print(f"math.floor({num1}) = {floor_value}")
# 4. math.fabs(x)
fabs_value = math.fabs(num1)
print(f"math.fabs({num1}) = {fabs_value}")
# 5. max(x1, x2, x3, ...)
maximum_value = max(num1, num2, num3)
print(f"max({num1}, {num2}, {num3}) = {maximum_value}")
# 6. min(x1, x2, x3, ...)
minimum_value = min(num1, num2, num3)
print(f"min({num1}, {num2}, {num3}) = {minimum_value}")
# 7. pow(x, y)
power_value = pow(num3, 2)
print(f"pow({num3}, 2) = {power_value}")
# 8. sqrt(x)
sqrt_value = math.sqrt(num2)
print(f"sqrt({num2}) = {sqrt_value}")
```
註：f"math.ceil({num1})" 表示字串格式化，想了解請至下文。
輸出：
```python=
abs(-4.7) = 4.7
math.ceil(-4.7) = -4
math.floor(-4.7) = -5
math.fabs(-4.7) = 4.7
max(-4.7, 16, 5) = 16
min(-4.7, 16, 5) = -4.7
pow(5, 2) = 25
sqrt(16) = 4.0
```
### 隨機數函數（Random Functions）
---
隨機數函數模組的引入：
`import random`
以下是幾個我們在 Python 中較為常用的隨機數函數：
| Number | 函數 | 描述 |
| -------- | -------- | -------- |
| 1 | random.choice(seq) | 從序列的元素中隨機挑選一個元素，例如random.choice(range(10))，從 0 到 9 中隨機挑選一個整數。 |
| 2 | random.randrange ([start,] stop [,step]) | 從指定範圍內，以指定基數遞增的集合中取得一個隨機數，基數預設值為 1 |
| 3 | random.random() | 隨機產生下一個實數，它在 [0,1] 範圍內。注意：產生的內容包含小數。 |
| 4 | random.shuffle(lst) | 將列表的所有元素隨機排序。 |
| 5 | random.randint(start, stop) | 隨機產生整數。 |
以下是一個範例：
```python=
import random
# random.choice(seq)
colors = ['red', 'blue', 'green', 'yellow', 'black']
chosen_color = random.choice(colors)
print(f"隨機挑選的顏色: {chosen_color}")
# random.randrange([start,] stop [,step])
random_number = random.randrange(1, 20, 2)
print(f"從1到19之間(奇數)隨機選擇的數字: {random_number}")
# random.random()
random_float = random.random()
print(f"隨機生成的小數: {random_float}")
# random.shuffle(lst)
cards = ['Ace', 'King', 'Queen', 'Jack', '10']
random.shuffle(cards)
print(f"隨機排序後的撲克牌: {cards}")
# random.randint(start, stop)
random_integer = random.randint(1, 10)
print(f"隨機生成的整數: {random_integer}")
```
輸出（由於隨機性，所以生成的答案不同）：
```python=
隨機挑選的顏色: blue
從1到19之間(奇數)隨機選擇的數字: 19
隨機生成的小數: 0.0009559929219729035
隨機排序後的撲克牌: ['Ace', '10', 'Jack', 'Queen', 'King']
隨機生成的整數: 8
```
### 三角函數（Trigonometric Functions）
---
注意：三角函數需要引入 math 模組。
在高中階段我們只會學到 sin、cos、tan，以及弧度、角度的轉換，所以我們只列出以下幾種：
| Number | 函數 | 描述 |
| -------- | -------- | -------- |
| 1 | math.sin(x) | 回傳 x 的正弦值。 |
| 2 | math.cos(x) | 回傳 x 的餘弦值。 |
| 3 | math.tan(x) | 回傳 x 的正切值。|
| 4 | math.degrees(x) | 將弧度轉換成角度，如 degrees(math.pi/2)，回傳 90.0。 |
| 5 | math.radians(x) | 將角度轉換成弧度。 |
註：math.pi 為圓周率。
```python=
import math
# math.sin(x)
angle_radians = math.pi / 6 # 30度的弧度值
sin_value = math.sin(angle_radians)
print(f"sin30: {sin_value}")
# math.cos(x)
cos_value = math.cos(angle_radians)
print(f"cos30: {cos_value}")
# math.tan(x)
tan_value = math.tan(angle_radians)
print(f"tan30: {tan_value}")
# math.degrees(x)
angle_degrees = math.degrees(math.pi / 2)
print(f"π/2 弧度轉角度: {angle_degrees} 度")
# math.radians(x)
angle_in_degrees = 180
angle_in_radians = math.radians(angle_in_degrees)
print(f"180 度轉弧度: {angle_in_radians} 弧度")
```
輸出：
```python=
sin30: 0.49999999999999994
cos30: 0.8660254037844387
tan30: 0.5773502691896257
π/2 弧度轉角度: 90.0 度
180 度轉弧度: 3.141592653589793 弧度
```
字串（String）
---
由於字串在前面章節已經有大致上說明及講解，所以於本章節會簡單帶過。
字串是由兩個雙引號或兩個單引號所組成，引號裡面可存放字元，如下所示：
```python=
"雙引號是字串"
'單引號也是字串'
```
:::danger
***不過要注意的是，單雙引號必須成對，不能寫單引號加雙引號，否則程式會出錯。***
:::
我們可以透過以下方式擷取字串值：
```python=
>>> a = "Hello"
>>> a[0]
'H'
>>> a[0:3]
'Hel'
>>>a[-1]
'o'
```
### 跳脫字元（Escape Character）
---
[跳脫字元](https://zh.wikipedia.org/zh-tw/%E8%BD%AC%E4%B9%89%E5%AD%97%E7%AC%A6)又可稱為逸出字元、轉義字元（大陸說法），而在 Python 中，若要使用跳脫字元，我們會在前面加上一個反斜線「\」。
接下來我們將來認識幾個較為常用的跳脫字元：
「\\」，作用是顯示出「\」，程式碼範例如下所示：
```python=
>>> print("\\")
\
```
「\'」，作用是顯示出一個單引號「'」，程式碼範例如下所示：
```python=
>>> print('\'')
'
```
若要顯示出雙引號，就如單引號的範例一樣，各位可以自己試試看。
「\n」，作用為換行，程式碼範例如下所示：
```python=
>>> print("1\n")
1
>>>
```
可以看到當 1 顯示出來後，便又跳了一行。
補充：這個東西我們在前面講基本資料型態時講過，在字串前面加上一個 r（無論大小寫），都能夠使跳脫字元無效化，就是讓他現出原形，如下所示：
```python=
>>> print(r"\n")
\n
```
### 字串格式化-舊版（String-formating）
---
在 Python 中，字串格式化就如同我們在 C 語言中使用 printf() 一樣的語法，我們可以先看到下面的範例，以下是在 Python 中使用字串格式化的範例：
```python=
print ("我叫 %s 今年 %d 歲!" % ('阿堯', 17))
```
輸出結果：
```python=
我叫 阿堯 今年 17 歲！
```
在 Python 中，我們會使用「%」這個符號來格式化字串，比如說 %s 就是格式化成字串，s 就是 string 的意思。
好，到底什麼是格式化呢？簡單來說就是當我們使用 %s 這個符號時，後面對應的資料（因為 %s 是各式化成「字串」）就會跟 %s 做替換，這個概念有點像是變數的賦值，也就是說 %s = "阿堯"，然後印出的結果就會是 "阿堯" 囉。
那麼接下來以下是字串格式化符號的統整表格：
| 符號 | 敘述 |
| -------- | -------- |
| %c | 格式化成「字元」及「ASCII碼」 |
| %s | 格式化成「字串」 |
| %d | 格式化成「整數」 |
| %u | 格式化成「無號整數」 |
| %o | 格式化成「無號八進位數」 |
| %x | 格式化成「無號十六進位數」 |
| %X | 格式化成「無號十六進位數（大寫）」 |
| %f | 格式化成「浮點數，且可指定小數點位數」 |
| %e | 用科學記號格式化浮點數 |
| %E | 同上 |
以下是一個範例：
```python=
char = 'A'
string = "Hello, World!"
integer = 42
unsigned_integer = 255
octal = 0o123
hexadecimal = 0xABC
float_number = 3.1415926535
scientific = 123456.789
print("字元及ASCII碼: %c" % char)
print("字串: %s" % string)
print("整數: %d" % integer)
print("無號整數: %u" % unsigned_integer)
print("無號八進位數: %o" % octal)
print("無號十六進位數: %x" % hexadecimal)
print("無號十六進位數（大寫）: %X" % hexadecimal)
print("浮點數（預設小數位數）: %f" % float_number)
print("浮點數（指定小數位數）: %.2f" % float_number)
print("科學記號格式化浮點數: %e" % scientific)
print("科學記號格式化浮點數（大寫E）: %E" % scientific)
```
輸出：
```python=
字元及ASCII碼: A
字串: Hello, World!
整數: 42
無號整數: 255
無號八進位數: 123
無號十六進位數: abc
無號十六進位數（大寫）: ABC
浮點數（預設小數位數）: 3.141593
浮點數（指定小數位數）: 3.14
科學記號格式化浮點數: 1.234568e+05
科學記號格式化浮點數（大寫E）: 1.234568E+05
```
上述需要使用「%」來進行格式化的方式，都屬於舊版使用，不過無礙，因為這種格式化方式通用於 Python 2、3。
### 字串格式化-新版（f-string）
---
> f-string 是 Python 3.6 之後版本新增的，稱之為字面量格式化字串，是較新的格式化字串之語法。
> 實字（或稱字面量：literal）用來表達原始碼中一個固定值的表示法（notation），整數、浮點數以及字串等等都是實字。
範例如下圖所示：
`a = 1`
a 是變數，1 是實字。
回到 f-string，f-string 是一種比使用 `%` 符號還要簡單方便的字串格式化用法，那麼到現在我相信各位一定很疑惑到底為什麼需要格式化字串呢？
其實很簡單，若我們想要在字串裡面加入變數，像是這樣：「Your number is : 0」，然後寫個迴圈程式讓他從 0 慢慢疊加到 100，有點像是進度條的概念。若我們沒有格式化這種東西，那麼就很難去實現這個動作了，或者是說幾乎不可能。也因為有格式化的關係，所以讓字串變得更加靈活。
好，話題回來，以下是 f-string 的用法，在字串前面加上一個 f，在用一個大括號 {} 括起來：
```python=
>>> name = 'Handsome Boy'
>>> f'Hello! {name}' # 替換變數
'Hello Handsome Boy'
```
這種方法其實就不用特別去判斷是 %s 還是 %d，就會自動轉換資料型態了，是不是非常的方便好用呢？
> 在 Python 3.8 的版本中可以使用 = 符號來拼接運算表達式與結果：
```python=
>>> x = 1
>>> print(f'{x+1}') # Python 3.6
2
>>> x = 1
>>> print(f'{x+1=}') # Python 3.8
x+1=2
```
:::success
快速整理！
f-string 是 Python 3.6 之後的版本才有，使用方法：在字串前面加上小寫f，字串內部增加大括號 {}，裡面可以放運算式及變數。
:::
### .format()
---
> 「{}」和「format()」是 Python 3 所使用的「新式」格式化，操作方式為「格式化字串.format(資料)」，輸出結果會將資料插入格式化字串的位置，下面的例子，會將 world 和 oxxo 兩個字串，分別插入字串中的兩個 {}。
引用至：[文字與字串 ( 格式化 ) - Python 教學 | STEAM 教育學習網](https://steam.oxxostudio.tw/category/python/basic/format.html)
不過作者本人經過相關的查詢後，發現 .format() 其實早在 python 2.6 就已經有了，所以並不是 Python 3。
```python=
a = 'hello {}, I am {}'
b = a.format('world', 'oxxo')
print(b) # hello world, I am oxxo
```
範例出處：[文字與字串 ( 格式化 ) - Python 教學 | STEAM 教育學習網](https://steam.oxxostudio.tw/category/python/basic/format.html)
使用 .format 的方式其實就有點像是填空格的感覺，不過 .format() 框框裡面的東西並不一定只要填入字串這個資料型態，例如填入 Number、list、tuple 等也是可以的，印出來的結果也如我們預期。
另外在 a 變數這邊，裡面的字串值中的 {} 裡面可以填入數字，用來代表填入資料的「順序」，跟序列（列表、元組那些）一樣，索引（index）預設從 0 開始。
以下是一個範例：
```python=
a = 'hello {1}, I am {0}'
b = a.format('world', 'oxxo')
print(b) # hello oxxo, I am world (world 和 oxxo 互換了)
```
> {} 裡可以填入具名引數（Named Arguments），如果將上面程式裡的 {} 加入名稱，就會放入指定名稱的內容。
```python=
a = 'hello {m}, I am {n}'
b = a.format(m='world', n='oxxo')
print(b) # hello world, I am oxxo
```
可以從上述程式碼中看到：在變數 a 裡面字串中的 {} 裡面分別填入 m、n，之後在第二行的 b 變數之字串裡面輸入 m、n 對應的內容。這個概念其實就跟我們之前學的函數中，關鍵字參數是非常類似的，只不過這種用法被移到 .format 的用法上而已。
忘記什麼是關鍵字參數的同學，[傳送門點我](https://luketsengtw.wordpress.com/2024/03/09/python-%e5%9f%ba%e7%a4%8e%e6%95%99%e5%ad%b8-matchcase-%e5%87%bd%e6%95%b8-%e5%ad%97%e5%85%b8%e3%80%90part-6%e3%80%91/)。
:::success
快速整理！
.format() 可想像成是新式 f-string 的變化版，以下表格整理相異處。
| 屬性 | `f-string` | `.format()` |
| -------- | -------- | -------- |
| Python 版本 | Python 3.6 及以上 | Python 2.7 及以上 |
| 語法 | `f"Hello, {name}!"` | `"Hello, {}!".format(name)` |
| 可讀性 | 直觀、可讀性較佳 | 可讀性較差，尤其是有多個變數時 |
| 效能 | 通常較 `.format()` 快 | 相對較慢 |
| 巢狀結構 | 不支援 | 支援（巢狀：`"Hello, {}!".format("{}".format(name.upper()))`） |
| 擴充性 | 不能處理較複雜的字串 | 比起 `f-string` 可處理比較多事情 |
| 便利性 | 較方便 | 較為複雜，適合使用在複雜的字串處理 |
| 難易度 | 易上手 | 較難，但是可以控制較多字串處理 |
:::
### 進階 .format()
---
> {} 裡可以填入字典的引數，如果將上面程式裡的 {} 加入對應的引數，就會放入指定的字典內容。
```python=
a = 'hello {0[x][m]}, I am {0[y][m]}'
b = {'x': {'m':'world', 'n':'oxxo'}, 'y':{'m':'QQ', 'n':'YY'}}
c = a.format(b)
print(c) # hello world, I am QQ
```
看完以上範例的代碼後，不要慌張，接下來讓我替你解釋一下：
首先第一行，依舊是 .format 的那個標準格式，只是各位比較不清楚的是，為什麼要在 `[x][m]` 前面放一個 0 呢？而這個 0 其實是 .format 方法中引數列表的索引，簡單來說他所指的就是第一個引數，也就是 b。
所以 `{0[x][m]}` 的意思是：
1. 從 .format() 方法中的第一個引數 b 開始。
2. 在 b 引數中找到鍵 x 對應的字典。
3. 從字典中找到鍵 m 相對應的值，也就是 'world'。
接下來的 `{0[y][m]}` 依此類推，步驟都是一樣的。
> 新式的格式化字串和 % 定義略有不同，可以加入其他數值，來指定最小寬度、最大字元、對齊與精確度：
| 格式化數值 | 說明 |
| -------- | -------- |
| : | 開始需要加上冒號 |
| 不加東西、> | 靠右對齊 |
| < | 靠左對齊 |
| ^ | 置中對齊 |
| 填補字元 | 將不足最小寬度的空白，填滿指定字元 |
| 數字.數字 | 最小寬度.最大字元數，如果後方是 f (%f)，第二個數字表示小數點位數 |
> 資料的型態也由 % 改為「:」表示。
| 格式化字串 | 轉換型態 |
| -------- | -------- |
| :s | 字串 |
| :d | 十進制整數 |
| :x | 十六進制整數 |
| :o | 八進制整數 |
| :b | 二進制整數 |
| :f | 十進制浮點數 |
| :e | 指數浮點數 |
| :g | 十進制或指數浮點數 |
```python=
a = 'hello {}, I am {}'.format('world','oxxo')
b = 'hello {:10s}, I am {:10s}'.format('world','oxxo')
c = 'hello {:>10s}, I am {:>10s}'.format('world','oxxo')
d = 'hello {:-^10s}, I am {:+^10s}'.format('world','oxxo')
e = 'hello {:-^10.3s}, I am {:-^10s}'.format('world','oxxo')
f = 'hello {:-^10.3s}, I am {:^10.3f}'.format('world',123.456789)
print(a) # hello world, I am oxxo
print(b) # hello world , I am oxxo
print(c) # hello world, I am oxxo
print(d) # hello --world---, I am +++oxxo+++
print(e) # hello ---wor----, I am ---oxxo---
print(f) # hello ---wor----, I am 123.457
```
以上圖表範例來自：[文字與字串 ( 格式化 ) - Python 教學 | STEAM 教育學習網](https://steam.oxxostudio.tw/category/python/basic/format.html)
### .format() 範例解析
---
a 變數的部分我們就不再贅述了，相信各位比較有問題的地方應該是 b 變數的地方：
裡面為什麼要放一個 10 呢？這個 10 又代表著什麼意思？
10 其實是代表字串的字元寬度，在當我們使用 .format() 時，可以在格式化字串中指定字元寬度，而{:10s} 中，表示將字串的寬度設為 10 ，如果字串不足 10 個字元，則會用空格填補。
我們可以從輸出結果中看到："world , I am oxxo" 在 world 的部分，已經占掉了 5 個字元，而剩下的五個字元就再加上五個空格，等同於我們按五次空白鍵，去補充那剩下的 5 個字元。
接下來讓我們看 c 變數，使用了 > 符號，並且放在 10 前面，這代表說讓字串向右靠齊。可以從輸出結果中看到，world 的起始位置並不是在 hello + 空格開始，而是在最右邊、我們將字元寬度填滿的位置。
看到 d 變數，多了一個 ^ 符號，表示讓字串置中對齊，另外 ^ 符號的左邊還多加了 - 符號，代表除了字串 world 填滿的字元寬度之位置以外的空格，用 - 符號來代替。
簡單來說，多了一個 - 符號就是讓空格代替成 - 符號而已。
而變數 e 的部分，則是變動了 {:10.3} ，多了 0.3 出來，這代表只取引數中的字串 「3」 個字元，所以可以看到下面輸出結果只顯示 wor，便結束了。
變數 f 的後面，我們可以發現範例中將 s 換成 f，表示格式化成浮點數，同樣地，多了 0.3 表示只顯示小數點後三位，並且四捨五入。
那這個範例差不多就是這樣，至於大家想用什麼格式化的方式，取決於各位，我個人偏好使用 f-string，因為整體上看來還是這個方法較為便利，且不用特別去注意 %s、%f 什麼的。
### 字串常用方法（Methods）
---
| Number | 方法及描述 |
|------|--------------|
| 1 | **capitalize()**：將字串的第一個字元轉換為大寫 |
| 2 | **islower()**：如果字串中所有字元都是小寫，則回傳 True，否則回傳 False |
| 3 | **isupper()**：如果字串中所有字元都是大寫，則回傳 True，否則回傳 False |
| 4 | **isnumeric()**：如果字串中只包含數字字元，則回傳 True，否則回傳 False |
| 5 | **isspace()**：如果字串中只包含空白，則回傳 True，否則回傳 False |
| 6 | **join(seq)**：以指定字串作為分隔符，將 seq 中所有的元素（元素要是字串）合併為一個新的字串 |
| 7 | **len(str)**：回傳字串長度 |
| 8 | **lower()**：轉換字串中所有大寫字元為小寫 |
| 9 | **max(str)**：回傳字串 str 中最大的字母（ASCII碼） |
| 10 | **min(str)**：回傳字串 str 中最小的字母（ASCII碼） |
| 11 | **upper()**：轉換字串中所有小寫字元為大寫 |
總結
---
### 模組（Module）
---
兩種引入模組的方式：
`import <函式庫 or 模組名稱>`
or
`from <函式庫 or 模組名稱> import <物件>`
嫌模組名稱太長，可用 `as` 將模組名稱改名：
`import math as m`
以下是今日所學的相關模組：`import math`、`import random`
### 字串格式化（string-formating）
---
在 python 中共有三種字串格式化的方式：
* 百分比符號 `%`
* .format()
* f-string
用 `%` 是最原始的格式化方式，各方面的功能較其他兩種差。
f-string 為最新的格式化方式，主打快速方便使用的格式化方法。
.format() 介於 `%` 與 f-string 之間，最大特點是相容性極好，可同時有 `%` 跟 f-string 的性質，運算及操作起來會較為複雜一些，但優點是功能極多，適合用於處理複雜的字串。
好那本篇教學就到此為止～感謝您的觀看，以下是一些參考資料：
參考資料
===
[Python 3 數字(Number) | 菜鳥教程](https://www.runoob.com/python3/python3-number.html)
[Python 3 字串 | 菜鳥教程](https://www.runoob.com/python3/python3-string.html)
[文字與字串 ( 格式化 ) - Python 教學 | STEAM 教育學習網](https://steam.oxxostudio.tw/category/python/basic/format.html)
[菜鳥工程師 肉豬: 程式 什麼是實字 what is literal](https://matthung0807.blogspot.com/2021/05/what-is-literal-in-programming.html)
Sign in with Wallet
Connect another wallet