# 2. 資料型態與基本運算

###### tags: `Python`

- Python 教學 第二篇 資料型態與基本運算

::: info
以下程式碼無先後順序 無連貫性

推薦影片教學頻道：
- 英文 : [Tech With Tim](https://www.youtube.com/c/TechWithTim/featured)
- 中文 : [彭彭老師的程式教學](https://www.youtube.com/watch?v=wqRlKVRUV_k&list=PL-g0fdC5RMboYEyt6QS2iLb_1m7QcgfHk&index=1&t=24s)
:::

## 一、資料型態 Data-types：

||資料的種類||
|:-:|:-:|:-:|
|變數|整數|浮點數|
|字串|布林值|可變列表|
|固定列表|集合|字典|

### 1. 變數 variable

- 用來儲存資料的自訂名稱物件

#### （１）　變數的命名限制：

- 1. 小寫字母（a~z）
- 2. 大寫字母（A~Z)
- 3. 數字（0～9）
- 4. 底線（_）
- 5. 不能以數字作為開頭，如 92s

- 還有Python預設的關鍵字 Keywords 也不可被用來作為變數名稱

這些關鍵字我將會在 第五篇 -函數的使用 中逐一介紹

|||||||
|:------:|:------:|:--------:|:------:|:------:|:-------:|
| and | del | for | is | raise | assert |
| elif | from | lamba | return | break | else |
| global | not | try | while | def | finally |
| in | print | continue | exec | import | pass |
| class | except | if | or | yield | |
|||||||

#### （２）　以下是一些合法的命名：

1. x
2. y
3. a
4. a_b
5. a32
6. _fe1

::: info
以下宣告 / 定義 變數後 大家可以自己試試看使用type功能 / 函數：
- type(變數名稱) 可以取得變數所儲存的 資料 的 資料型態
- print(type(變數名稱)) 印出變數的資料型態
:::

### 2. 整數 int

- 不會有小數點，會將小數點後的數字無條件捨去

# 將整數10儲存到變數x當中
x = int(10)

# 由於10.9487被定義為整數int，小數無條件捨去，變為10，然後儲存到變數x，所以x依然會是 10
x = int(10.9487)
print(type(x)) #用type()函式/功能 取得 x 的資料型態並印出 => <class "int">

### 3. 浮點數 (小數) float

- 一定會有小數點，被宣告時如果使用float，就算是整數依然會視為浮點數

# 將整數10以浮點數型態儲存到變數x當中，x 等於 10.0
x = float(10)

# 由於10.9487為浮點數，儲存到變數 x 後，x 等於 10.9487
x = 10.9487

# 由於10.9487被定義為浮點數float，小數保留，儲存到變數x，所以 x 等於 10.9487
x = float(10.9487)
print(type(x)) #用type()函式/功能 取得 x 的資料型態並印出 => <class "float">

### 4. 字串 string：

- 由單 / 雙引號包裹住的任意字元 包括整數、浮點數，只要由單 / 雙引號包裹住，就是字串

#### （１）　字串基礎

# Hello World！ 英文字元、空格與驚嘆號 包裹在雙引號中 儲存到變數x
x = "Hello World！"
print(x) #印出 "Hello World！"

# 哈囉 世界！ 英文字元、空格與驚嘆號 包裹在單引號中 儲存到變數x
x = '哈囉 世界！'
print(x) #印出 "哈囉 世界！"

# 數字字串 浮點數字串也同理 皆用單 / 雙引號包裹
x = "1 2 4 5 9 8 10 88 92" #1 2 4 5 9 8 10 88 92 全都是字串 不是數字

# 將整數94轉換成字串型態 並儲存到變數x
x = str(94) #等於 x = "94"

# 浮點數同理
x = str(94.53) #等於 x = "94.53"
print(type(x)) #用type()函式/功能 取得 x 的資料型態並印出 => <class "str">

#### （２）　字串轉換符

在字串內使用特殊符號，如： 字串內使用單引號、雙引號、縮排、歸位、換行

"\\" # 單斜線 \
"\'" # 單引號 '
"\"" # 雙引號 "
"\t" # 縮排 => Tab 縮排 => 4個空格
"\r" # 歸位 => 等於方向鍵一直移到該行最前端 從最前端開始輸出 並且會覆蓋之前的輸出
"\n" # 換行 => 換行

#### （３）　格式化字串

將變數資料插入字串當中

name = "LeeFuuChang"
age = 17
x = "My name is {}, and I am {} years old".format(name, age) #照順序放入變數
# 則 x = "My name is Ivan, and I am 17 years old"

# 也可以給與位置名稱 並依照對應名稱放置變數
x = "My name is {Name}, and I am {myAge} years old".format(myAge=age, Name=name)
# x 一樣等於 "My name is Ivan, and I am 17 years old"

# 另外還有 f字串 可以直接相變數插入字串
x = f"My name is {name}, and I am {age} years old"
# x 也一樣等於 "My name is Ivan, and I am 17 years old"

### 5. 布林值 bool：

- True 和 整數 1 代表 是、正確

#True 的表示法
x = True
print(type(x)) #用type()函式/功能 取得 x 的資料型態並印出 => <class "bool">

#同時 整數 1 也可以用來代表True
int(1)

- False 和 整數 0 代表 否、不正確

#False 的表示法
x = False
print(type(x)) #用type()函式/功能 取得 x 的資料型態並印出 => <class "bool">

#同時 整數 0 和 None 也可以用來代表 False
int(0)
None

### 6. 可變列表 list：

- 有順序的 可變更的列表 List 在宣告後可以新增 / 刪減列表中的物件
- [ 物件 1 , 物件 2 , 物件 3 , 物件 4 , 物件5 ] => 列表
- [ 　0 　 ,　 1 　 ,　 2 　 ,　 3 　 ,　 4　 ] => 列表位置 第一個物件為0 第二個為1 以此類推

#第 N 個物件 的位置為 N-1

# a 是一個空的List
a = list() 

# a 是一個List 有五個物件 分別是True, 整數2, 字串3, 整數4, 字串5
a = [True,2,"3",4,"5"] 

# 同上 a 是一個List 有五個物件 分別是 True, int(2), str(3), float(4), str(5)
a = list([True,2,"3",4.0,"5"])

# a 是一個List 有五個物件 分別是 True, int(2), str(3), float(4), str(5)
a = [True,2,"3",4,"5"]

a.append("hehe") #在 a 列表的最後新增一個物件 "hehe"

a.remove(2) #移除列表中最前面的一個 int(2)

a.pop(3) #移除列表中第4個物件 如果沒有指定 => a.pop() 則會移除列表中最後一個物件

a.clear() #清空列表

del a[0] #移除列表中第1個物件 如果沒有指定 => del a 則會完全清除變數a 也就是a 不再是變數

### 7. 固定列表 tuple：

- 有順序的 不可變更的列表 Tuple 在宣告後不可改動列表中的物件

#### ！！！！！ Tuple 可合併 不可更動物件 不可新增物件 不可移除物件 ！！！！！

# 舉例來說
a = (1, 4, "9", "Hello", True, False)
# 則 a 除非被清除 否則永遠等於 (1, 4, "9", "Hello", True, False)
# 除非變數 a 被清除 否則 a[0] 永遠是 int(1)
# 除非變數 a 被清除 否則 a[1] 永遠是 int(4)
# 除非變數 a 被清除 否則 a[2] 永遠是 str(9)
# 除非變數 a 被清除 否則 a[3] 永遠是 "Hello"
# 除非變數 a 被清除 否則 a[4] 永遠是 True
# 除非變數 a 被清除 否則 a[5] 永遠是 False

### 8. 集合 set：

- 無順序的 不可變更的 物件不重複的列表 Set 在宣告後不可改動列表中的物件

#### ！！！！！ Set 內的物件 [ 不重複 ] [ 無順序 ] ！！！！！

#Set內的物件 [ 不重複 ] [ 無順序 ]

# 定義 a 為一個Set
a = {5,5,1,"he","she","it",False}
# 由於 Set的不重複性
# a 列表中的物件會只剩下 1, 5, "he", "she", "it", False
# 又因為 Set的無順序性 列表中物件的順序將被打亂
# 最後 a 會變成這樣 {False, 1, 'it', 5, 'she', 'he'} 且每次執行都不一樣
# 通常使用於將原先就存在的一個列表List 轉為Set 使其物件單一 / 打亂順序
a = [1,10,10, "hello", "gg",False]
a = set(a)

### 9. 字典 dict：

- 有順序的 可變更的 物件不重複的對照型列表 Dictionary 在宣告後不可改動列表中的物件
- 每個物件都有兩個值 分別為 key 和 value 一個key會對應一個value
- key 不可重複 value 可重複

#### ！！！！！ Dictionary 內的物件： [ 不重複 ]、[ 有順序 ]、[兩兩成對] ！！！！！

# 定義 a 為一個 Dictionary
a = {"key": "value", "key1": "value1", "key2":"value2", "key3":"value3"}
# a 的 物件有 
# "key": "value"
# "key1": "value1"
# "key2":"value2"
# "key3":"value3"

# 舉例
a = {"a":"apple", "b":"banana", "c":"cow", "d":9487}
# a["a"] 等於 "apple"
# a["b"] 等於 "banana"
# a["c"] 等於 "cow"
# a["d"] 等於 int(9487)

## 二、 數字 列表 字串 的運算

### 1. 運算子的種類

||運算子|作用|舉例|可用於|
|:-:|:-:|:-:|:-:|:-:|
|1.|+|相加|a+b|數字 and 字串 and 列表List|
|2.|-|相減|a-b|數字|
|3.|*|相乘|a*b|數字 and 字串 and 列表List|
|4.|/|相除|a/b|數字|
|5.|%|取餘數|10%3 得 1|數字|
|6.|**|次方|a**b a的b次方|數字|
|7.|//|取整數商|10//3 得 3|數字|
|8.|+=|加等於|a+=b 等於 a=a+b|數字 and 字串 and 列表List|
|9.|-=|減等於|a-=b 等於 a=a-b|數字|
|10.|*=|乘等於|a*=b 等於 a=a*b|數字 and 字串 and 列表List|
|11.|/=|除等於|a/=b 等於 a=a/b|數字|
|12.|==|等於|a == b|數字 and 字串 and List|
|12.|>|大於|a > b|數字|
|13.|<|小於|a < b|數字|
|14.|>=|大於等於|a >= b|數字|
|15.|<=|大於小於|a <= b|數字|

### 2. 數字運算

# 定義變數值
a = 10
b = 5

#數字運算舉例
c = a + b  # c=15
c = a - b  # c=5
c = a * b  # c=50
c = a / b  # c=2.0 => 整數型態變數經過除法運算後不論是否整除都會變成浮點數型態
c = a % b  # c=0 => 整除
c = a // b # c=2 => 雖是除法 但只取整數 所以當然是整數型態
c = a += b # c=15
c = a -= b # c=5
c = a *= b # c=50
c = a /= b # c=2.0
a > b      # True => a的確大於b 所以輸出布林值 True
a < b      # False => a並不小於b 所以輸出布林值 False
a >= b     # True => a的確符合大於或等於b 所以輸出布林值 True
a <= b     # False => a並不小於或等於b 所以輸出布林值 False

### 3. 字串運算

# 定義變數值
a = "Hello"
b = "World"
i = 4

#字串運算舉例
c = a + b  # c="HelloWorld" => 字串合併
c = a * i  # c="HelloHelloHelloHello" => 重複四次a
c = a += b # c="HelloWorld" => 字串合併
c = a *= i # c="HelloHelloHelloHello" => 重複四次a
a == b     # False => 兩個變數儲存的字串並不同 所以輸出布林值 False

### 4. 列表運算 (List)

# 定義變數值
a = ["hello", "world"]
b = ["JJJ", "5566"]
i = 3

#列表運算舉例
c = a + b  # c=["hello", "world", "JJJ", "5566"] => 列表合併
c = a * i  # c=["hello", "world","hello", "world","hello", "world"] => 重複三次
c = a += b # c=["hello", "world", "JJJ", "5566"] => 列表合併
c = a *= i # c=["hello", "world","hello", "world","hello", "world"] => 重複三次
a == b     # False => 兩個變數儲存的列表並不同 所以輸出布林值 False 

### [上一篇](https://hackmd.io/hR-7Aq8OSM26QJbSgIxGCw?view)

### [下一篇](https://hackmd.io/UGzZn3f6Sge-HI1EVx6MWg?view)