Python - 型態大哉問

發表於 更新於 分類於 Disqus： 文章字數： 5.5k 所需閱讀時間 ≈ 10 分鐘

這篇文章用來紀錄 Python 裡面的型態。

不管是怎樣的程式語言，內建型態通常都會有整數、浮點數、布林、字串、陣列等等。這些可以說是每個程式語言都一定需要的型態。

型態

在開始講型態之前，要知道一件事情，在 Python 中，萬物都是物件！，在 Python 寫下一個數字，這個數字在 Python 中就是一個物件，它是有屬性、函式等這些功能，這個感覺在後面就會慢慢體會到了。

從內建型態開始講起

整數型態

Python 的整數，不同於 Java 這語言，有區分短整數、長整數。通常以 Java 來看的話：

1
2
int a = 10;
long b = 20;

會分為 int 型態及 long 型態，差別就在於能容納的位數不同。

但以 Python 來看的話：

1
2
a = 10
b = 20000000000000000000000000000000000000

這個在 Python 想產生多大的位數，基本上是無限制，取決於你的主機內存。因此在 Python 中，整數型態就叫 int。

那如果在程式中寫二進位、八進位、十六進位的數字呢？

在二進位中需要在數字前加入 0b 或 0B：

1
2
3
4
a = 0b1010
# a = 10
b = 0B1010
# b = 10

在八進位需要在數字前加入 0o 或 0O

1
2
3
4
a = 0o12
# a = 10
b = 0O12
# b = 10

在十六進位需要在數字前加入 0x 或 0X

1
2
3
4
a = 0xA
# a = 10
b = 0XA
# b = 10

在 Python 中如果要知道寫在程式中的數字是甚麼型態要怎麼做？

1
2
3
4
5
type(10)
# <class 'int'>
a = 10
type(a)
# <class 'int'>

使用 type 函式，將數字或變數放進去，就可以知道是 int 類別的實例，也呼應一開始說的任何型態在 Python 都是物件。

浮點數型態

這個顧名思義就是數學上小數的意思。在 Python 中稱為 float 型態，例如：

1
2
a = 3.14
b = 1.414

布林型態

布林，如果有學過邏輯學都知道，只有兩種值，True、False，在 Python 中稱為 bool 型態。而在電腦中因為只看得懂 0 或 1，因此事實上程式在運行時，布林型態會自動轉成 1 或 0，也就是 True 代表 1，False 代表 0。

例如：

1
2
a = True
b = False

在 Python 中記得 T 跟 F 皆為大寫。

字串型態

在 Python 中如果要表示字串，可以用單引號 (’ ') 或雙引號 (" ")，來包括文字，一般來說 Python 慣例中，習慣以單引號作為表示字串之用，雙引號則是拿來輔助用的！

例如：

1
2
name = 'Kenny'
dog = "Kenny's dog"

假設在字串中，我們需要表達單引號的話，我們就可以把雙引號括在外面，單引號當作文字的一部分，如此以來就不會像其他語言需要一些輔助。

另外像在 Java 中，如果要表達 **\** 這個符號，通常會需要以下操作：

1
System.out.println("C:\\hello");

也就是需要特別在 **\ 前面再多加一個 \**。

而在 Python 中：

1
print('C:\hello')

Python 看到 **\ 會自動視為 \\**，也就是幫你自動進行轉換的工作了～

當然還是會有例外的時候：

1
2
print("C:\todo")
# C:    odo

這個的話 Python 會將 **\t 視為一個 Tab 的空白，因此在這邊就需要像 Java 一樣，在前面多加一個 \**。

那基本上常用的有以下：

\n：表達換行。

\t：表達一個 Tab。

\'：當要表達單引號的時候。

\"：當要表達雙引號的時候。

Python 字串特別的地方還有，一般的單引號或雙引號沒辦法表示多行字串，需要使用 **‘’'**，來包括文字：

1
2
3
4
5
'''
Kenny's blog is great!
Penguin Coco is a online judge system.
    Oh my godness!
'''

這個縮排跟換行都會保留下來，而不是只有純文字的部份保留下來～

集合型態

這部份就比較多跟雜，在 Python 中常見的有陣列 (List)、集合 (Set)、字典 (Dict)、元組 (Turple)

這邊簡單講解用法，實際上裡面的內容足夠開幾篇文慢慢描述～

陣列 (list)

中文翻譯有很多種，基本上最大的不同在於說，Python 的 List 型態是沒有限制長度的，也就是說一個 List 可以包含 0~ 無數個元素。

通常以我的經驗，List 最常拿來收集資料，或是需要有序的結構，有序的意思也就是說，List 是一個一個累加起來的，每個元素都有屬於它的索引值，根據它的索引值去拿取該元素的值。

Python 使用這些集合型態可以說是非常的方便，以 Java 來看對應的建立方式：

1
2
3
4
List<Integer> numbers = new ArrayList<>(); 
numbers.add(1);
numbers.add(2);
numbers.add(3);

要先宣告一個 List 型態的變數，然後由 ArrayList 這個類別去 Implements List Interface。

當然還有更簡潔的寫法：

1
List<Integer> numbers = Arrays.asList(1, 2, 3);

但是 Python 只需要：

1
numbers = [1, 2, 3]

這就是為什麼 Python 的開發者總是強調 Python 簡潔易於使用的一大原因，的確非常方便！

再來如果要建立空陣列，只需這樣：

1
numbers = []

List 加入元素：

1
2
numbers = [1, 2, 3]
numbers.append(4)

List 取得元素：

1
2
3
4
5
6
7
numbers = [1, 2, 3]
numbers[0]
# 1
numbers[1]
# 2
numbers[2]
# 3

基本上與大多數語言相同，索引值從 0 開始。

List 刪除元素：

1
2
3
4
5
numbers = [1, 2, 3]
numbers.remove(1)
# numbers = [2, 3]
del numbers[0]
# numbers = [3]

remove 的話是填入刪除元素的值，del 的話是填入索引值。

List 加入多個元素：

1
2
3
numbers = [1, 2, 3]
numbers.extend([20, 21, 22])
# numbers = [1, 2, 3, 20, 21, 22]

可以想成將其他 list 的元素全部加進來的感覺～

取得 List 的長度：

1
2
3
numbers = [1, 2, 3]
len(numbers)
# 3

檢測該元素有沒有在 List 裡面：

1
2
3
4
5
numbers = [1, 2, 3]
1 in numbers
# True
5 in numbers
# False

再來與 Java 更大的不同的是，Python 的 List 可以包含不同型態的元素，可以裡面有字串、數字、布林型態等都可以。

例如：

1
mixed = [1, 'kenny', True]

最後其實也可以用 **list ()** 的方式來產生 list 型態：

1
2
list('Kenny很帥')
# ['K', 'e', 'n', 'n', 'y', '很', '帥']

這個會自動將字串每個字元拆解出來並加入到一個 list 裡面。

集合 (set)

這個，以數學角度來看的話，就是一個集合裡面不應該要有重複的元素，而是唯一的。而這個特性也是程式中會不會使用 Set 的原因，通常像是收集資料過程，希望不要收集到重複的資訊，那我們可以建立一個 Set 型態去蒐集資料，避免有重複的問題，因為就算你加入重複的資料，Python 這邊會自動過濾重複的元素，如果重複了就不會加進去。也就是你可以省去過濾的步驟！

建立方式基本上有兩種：

1
2
3
4
5
animals = {'dog', 'cat', 'bird'}
languages = set()
languages.add('Java')
languages.add('Python')
languages.add('Golang')

特別注意，相較於陣列，Set 型態如果要建利空 Set 並不能直接使用 **{}，因為這會當作字典 (dict) 型態，因此只能使用 set ()** 的方式來建立空集合。

集合刪除元素：

1
2
3
animals = {'dog', 'cat', 'bird'}
animals.remove('dog')
# animals = {'cat', 'bird'}

那因為集合裡面的元素並不是有序的，所以就無法使用 del 來刪除特定索引值的元素。

取得集合元素的個數：

1
2
3
animals = {'dog', 'cat', 'bird'}
len(animals)
# 3

也可以使用上面 List () 類似的範例：

1
2
set("Kenny's blog is great")
# {"'", ' ', 's', 'o', 'a', 'b', 'l', 'i', 'r', 'y', 't', 'n', 'e', 'g', 'K'}

是不是發現重複的元素就不會重複加入了呢～

就是這麼簡單～

字典 (dict)

翻譯為字典，顧名思義就很像是我們查一個英文單字是甚麼中文意思的感覺，特別注意的就是，一個鍵只會對應一個值。

建立字典型態：

1
2
3
4
5
user_info = {
    'Kenny': 123,
    'Nicole': 456
}
user_info = dict{'Kenny': 123, 'Nicole': 456}

這代表在 user_info 這個字典裏面，有兩個鍵，分別是 Kenny、Nicole，個別有其對應的值。當然要注意的是同一個字典鍵不能重複，但是值可以重複。

取得 dict 裡面的值：

1
2
3
4
5
6
7
8
user_info = {
    'Kenny': 123,
    'Nicole': 456
}
user_info['Kenny']
# 123
user_info['Nicole']
# 456

修改 dict 裡面某個鍵對應的值：

1
2
3
4
5
user_info = {
    'Kenny': 123,
    'Nicole': 456
}
user_info['Kenny'] = 789

刪除 dict 裡面的鍵值：

1
2
3
4
5
user_info = {
    'Kenny': 123,
    'Nicole': 456
}
del user_info['Kenny']

那如果要測試鍵有沒有在字典裏面，可以使用 in 來進行操作。

1
2
3
4
5
6
user_info = {
    'Kenny': 123,
    'Nicole': 456
}
'Kenny' in user_info
# True

取得字典裏面所有的鍵、所有的值、所有的鍵值配對：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
user_info = {
    'Kenny': 123,
    'Nicole': 456
}
user_info.keys()
# dict_keys(['Kenny', 'Nicole'])
list(user_info.keys())
# ['Kenny', 'Nicole']
user_info.values()
# dict_values([123, 456])
list(user_info.values())
# [123, 456]
user_info.items()
# dict_items([('Kenny', 123), ('Nicole', 456)])
list(user_info.items())
# [('Kenny', 123), ('Nicole', 456)]

那回傳的物件，Python 內部是用 list 去包裹的，只是型態不是顯示 list。那基本上我們可以用 list () 在去包裹，就可以取得 list 型態的相關物件。

比較特別是 items () 回傳的結構類似於下一個要講的 Tuple 一樣。

元組 (tuple)

這個理解方式我覺得就是想成是 list 的翻版，只是有一些不同之處：

  1. 用 **()** 包括
  2. 無法改變裡面的元素內容

建立 tuple：

1
2
3
4
5
6
7
8
a = 1,
# (1,)
b = 1, 2, 3
# (1, 2, 3)
c = (1, 2, 3, 4)
# (1, 2, 3, 4)
d = ()
# () 空turple

注意 Python 中並沒有 tuple () 的方式可以建立 turple 喔！

這個我覺得在使用的時機可以是在當你定義一些明確的資料，而且是不允許去修改的話就很適合使用 tuple，而且 tuple 占用的記憶體空間較小。

最後帶來兩種語言如果要實現兩個數字互換的功能的差別在哪：

Java 版本：

1
2
3
4
5
6
int x = 1;
int y = 2;
int temp = y;
y = x;
x = temp
System.out.println("x: " + x + ", " + "y: " + y);

Python 版本：

1
2
3
4
x = 1
y = 2
x, y = y, x
print('x:', x, ',', 'y:', y)

恩… 實際上 Python 的版本就是利用 tuple 的特性來進行互換值的動作！

總結

這個是一個 Python 的教學系列，也算是我的程式語言筆記系列。因為寫過太多語言，頭腦有時候會有混亂的狀態，例如靜態語言跟動態語言語法可以說是天差地別，有時候靜態語言寫久了要換到動態語言還真的不習慣，反之也是，最近因為碩士課程的關係，要重新擁抱 Python，因此也希望做個紀錄，所以文章內容也會有靜態語言跟動態語言的比較，我通常都會拿 Java 來比較，畢竟差異性真的滿多的，之後也會多一些 Python 的資料分析套件介紹。

當然這種東西很多人都寫過了，我也只是將我的經驗以及前人的東西做個整理而已。

在這邊我特別推崇我喜歡的程式語言大師，因為不得不說學校教的程式語言的深度真的是太淺了，很多時候都是靠網路上自學或是去買書的～

  1. https://openhome.cc/Gossip/Python/

    這個人很厲害，我也買過他出的 Java、Python 的書，非常推薦給大家。

  2. https://docs.python.org/3/

    這個不用說了，就是 Python 官方的文件，不得不說官方文件的東西還是要學習去看，更何況官方有出中文版的，沒理由不去看，官方畢竟才是權威，但是缺點就是可能不夠仔細，這也是為什麼很多人會出程式語言教學，也就是希望更詳細的去整理程式語言的相關細節～