Python-型態大哉問

陳冠億 Kenny

Published in

企鵝也懂程式設計

12 min readSep 24, 2019

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

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

型態

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

從內建型態開始講起

整數型態

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

int a = 10;
long b = 20;

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

但以Python來看的話：

a = 10
b = 20000000000000000000000000000000000000

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

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

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

a = 0b1010
# a = 10
b = 0B1010
# b = 10

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

a = 0o12
# a = 10
b = 0O12
# b = 10

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

a = 0xA
# a = 10
b = 0XA
# b = 10

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

type(10)
# <class 'int'>
a = 10
type(a)
# <class 'int'>

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

浮點數型態

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

a = 3.14
b = 1.414

布林型態

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

例如：

a = True
b = False

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

字串型態

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

例如：

name = 'Kenny'
dog = "Kenny's dog"

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

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

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

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

而在Python中：

print('C:\hello')

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

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

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

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

那基本上常用的有以下：

\n：表達換行。

\t：表達一個Tab。

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

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

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

'''
 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來看對應的建立方式：

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

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

當然還有更簡潔的寫法：

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

但是Python只需要：

numbers = [1, 2, 3]

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

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

numbers = []

List加入元素：

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

List取得元素：

numbers = [1, 2, 3]
numbers[0]
# 1
numbers[1]
# 2
numbers[2]
# 3

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

List刪除元素：

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

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

List加入多個元素：

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

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

取得List的長度：

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

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

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

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

例如：

mixed = [1, 'kenny', True]

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

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

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

集合(set)

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

建立方式基本上有兩種：

animals = {'dog', 'cat', 'bird'}
languages = set()
languages.add('Java')
languages.add('Python')
languages.add('Golang')

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

集合刪除元素：

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

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

取得集合元素的個數：

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

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

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

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

就是這麼簡單～

字典(dict)

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

建立字典型態：

user_info = {
     'Kenny': 123,
     'Nicole': 456
 }
user_info = dict{'Kenny': 123, 'Nicole': 456}

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

取得dict裡面的值：

user_info = {
     'Kenny': 123,
     'Nicole': 456
 }
user_info['Kenny']
# 123
user_info['Nicole']
# 456

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

user_info = {
     'Kenny': 123,
     'Nicole': 456
 }
user_info['Kenny'] = 789

刪除dict裡面的鍵值：

user_info = {
     'Kenny': 123,
     'Nicole': 456
 }
del user_info['Kenny']

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

user_info = {
     'Kenny': 123,
     'Nicole': 456
 }
'Kenny' in user_info
# True

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

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()回傳的結構類似於下一個要講的Turple一樣。

元組(turple)

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

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

建立turple：

a = 1,
# (1,)
b = 1, 2, 3
# (1, 2, 3)
c = (1, 2, 3, 4)
# (1, 2, 3, 4)
d = ()
# () 空turple

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

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

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

Java版本：

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

Python版本：

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

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

總結

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

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

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