Python - 型態大哉問

這篇文章用來紀錄 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 官方的文件,不得不說官方文件的東西還是要學習去看,更何況官方有出中文版的,沒理由不去看,官方畢竟才是權威,但是缺點就是可能不夠仔細,這也是為什麼很多人會出程式語言教學,也就是希望更詳細的去整理程式語言的相關細節~

最後最後!請聽我一言!

如果你還沒有註冊 Like Coin,你可以在文章最下方看到 Like 的按鈕,點下去後即可申請帳號,透過申請帳號後可以幫我的文章按下 Like,而 Like 最多可以點五次,而你不用付出任何一塊錢,就能給我寫這篇文章的最大的回饋!