Python_Note03

Object

Python 中所有東西都是物件 (object) ，意味著 Python 裡的資料 (data) 都是物件。物件都有 id 號碼、型態 (type) 及數值 (value) ，分別可用以下三個內建函數取得。

• id()
• type()
• print()

id() 取得物件的 id 號碼，其為整數值。 type() 得到 'type' 類別的物件。 print() 印出物件的數值，或是印出物件的字串 (string) 表達形式，並無回傳值 (return value) 。

—物件的值可為可變的 (mutable) 或不可變的(immutable) ，通常這是說複合資料型態 (compound data type) 的元素 (element) 是否可以替換，例如序對 (tuple) 及字串是不可變的，而串列 (list) 或字典 (dictionary) 是可變的，稍後討論。

—當物件不再使用時，直譯器會自動垃圾收集 (garbage collection) ，釋放記憶體空間。

Variable

Python 中自行定義的識別字 (identifier) ，若將物件的字面常數 (literal) 或定義形式指派給變數  (variable)，該變數便具有物件的控制權。其型別是動態的，會根據指定時的物件來決定型別。— 且變數單純只是物件的名稱，並不會和記憶體綁在一起。也就是說，和記憶體綁在一起的是物件，並不是物件名稱。所以變數可以更換型態，亦即同一個變數名稱可以任意指稱裝載任何型態的容器(物件參照)。在Python Shell中直接輸入變數名稱可看到變數的再現型態。

變數命名

• 以底線或英文字母開頭字符
• 以底線,英文字母和數字為後續字符
• 不可與關鍵字(保留字)相同

變數好比容器，且不必在意變數的size(容器的大小), 因為細節早被隱藏，由Python負責處理。

Assignment operator：=

等號 = 是賦值運算 (assignment operator)的運算子, 代表把右邊給予左邊, 跟一般在數學上的意

義”相等”是完全不同的。

Reference

 Python在實作上採取了參照 (reference)物件的作法，每個資料(物件)必須得有一個空間(容器)來保存它，而在許多程式語言中，變數就是容器的名字，但在Python中，變數只是一張標籤，此標籤指出了真正容器之所在，因而參照了該容器裡面保存的物件。

再者，不同物件會有不同id，而不同變數可以參照同一個物件，即會有相同id，也可能不圖參數參照不同物件，但其值是相同的(例如複製物件給新的變數)。

• is : 判斷兩個物件的id是否相同
• == :判斷兩個物件的value是否相同

Data Type

Python 內建許多有用的資料型態 (data type) 

三種數值型態 (numeric types)	整數 (integer) 浮點數 (floating-point number) 複數 (complex number)
六種序列型態 (sequence types)	字串 (string) 字節 (byte) 字節陣列 (byte array) 串列 (list) 序對 (tuple) 範圍 (range)
集合型態 (set types)	集合 (set) 原封集合 (frozenset)
字典型態 (dictionary type)	字典(dict)

資料型態分成可變的 (mutable)與不可變的 (immutable)，指的是變數所參照的物件本身可否改變。

不可變資料型態：整數, 浮點數, 字串，下面範例說明整數為不可變，所以當變數參照新的物件整數6時，並非是舊的物件整數5改變其值，而是建立一個新的物件整數6，而舊的物件整數5會被回收。

可變資料型態：串列、字典，下面範例為list型態，list可以修改其值或尺寸。

可變的 (mutable)與不可變的 (immutable)的差異

• 可變的資料型態，變數指定時會產生新的 id
• 部分不可變的資料型態，變數指定時會對應相同的 id (float會產生不同id)

Numeric type

內建的數字型態 (numeric type)有三種

• int 整數：3
• float 浮點數：3.14
• complex 複數：3 + 4 j

實數運算式

All numeric types (except complex) support the following operations, sorted by ascending priority (all numeric operations have a higher priority than comparison operations):

Operation	Result	Full documentation
x + y	sum of x and y
x - y	difference of x and y
x * y	product of x and y
x / y	quotient of x and y
x // y	floored quotient of x and y
x % y	remainder of x / y
-x	x negated
+x	x unchanged
abs(x)	absolute value or magnitude of x	abs()
int(x)	x converted to integer	int()
float(x)	x converted to floating point	float()
complex(re, im)	a complex number with real part re, imaginary partim. im defaults to zero.	complex()
c.conjugate()	conjugate of the complex number c
divmod(x, y)	the pair (x // y, x % y)	divmod()
pow(x, y)	x to the power y	pow()
x ** y	x to the power y

複數運算
c.real 取實部
c.imag取虛部

範例：
In[2]: c = 3 + 4j
In[3]: c
Out[3]: (3+4j)
In[4]: c.real
Out[4]: 3.0
In[5]: c.imag
Out[5]: 4.0

Sequence type

內建序列型態 (sequence type)有六種，同樣有可變與不可變之分，依不同情況來使用。

—str	字串 (string) ，不可變 (immutable)
—bytes	字節 (byte) ，不可變(immutable)
—bytearray	字節陣列 (byte array) ，可變 (mutable)
—list	串列 (list) ，可變(mutable)
—tuple	序對 (tuple) ，不可變(immutable)
—range	內建函數 range() 回傳的物件 (object) ，常用於for迴圈 (for loop)

Common Sequence Operations

The operations in the following table are supported by most sequence types, both mutable and immutable. The collections.abc.SequenceABC is provided to make it easier to correctly implement these operations on custom sequence types.

This table lists the sequence operations sorted in ascending priority. In the table, s and t are sequences of the same type, n, i, j and k are integers and x is an arbitrary object that meets any type and value restrictions imposed by s.

The in and not in operations have the same priorities as the comparison operations. The + (concatenation) and * (repetition) operations have the same priority as the corresponding numeric operations.

序列型態 (list, tuple, range)具有以下幾種運算式。

Operation	Result
x in s	True if an item of s is equal to x, else False
x not in s	False if an item of s is equal to x, else True
s + t	the concatenation of s and t
s * n or n * s	equivalent to adding s to itself n times
s[i]	ith item of s, origin 0
s[i:j]	slice of s from i to j
s[i:j:k]	slice of s from i to j with step k
len(s)	length of s
min(s)	smallest item of s
max(s)	largest item of s
s.index(x[, i[, j]])	index of the first occurrence of x in s (at or after index i and before index j)
s.count(x)	total number of occurrences of x in s

Mutable Sequence Types
可變的序列型態 (list)還具有以下運算式。

Operation	Result
s[i] = x	item i of s is replaced by x
s[i:j] = t	slice of s from i to j is replaced by the contents of the iterable t
del s[i:j]	same as s[i:j] = []
s[i:j:k] = t	the elements of s[i:j:k] are replaced by those of t
del s[i:j:k]	removes the elements of s[i:j:k] from the list
s.append(x)	appends x to the end of the sequence (same ass[len(s):len(s)] = [x])
s.clear()	removes all items from s (same as del s[:])
s.copy()	creates a shallow copy of s (same as s[:])
s.extend(t) or s += t	extends s with the contents of t (for the most part the same as s[len(s):len(s)] = t)
s *= n	updates s with its contents repeated n times
s.insert(i, x)	inserts x into s at the index given by i (same ass[i:i] = [x])
s.pop([i])	retrieves the item at i and also removes it from s
s.remove(x)	remove the first item from s where s[i] == x
s.reverse()	reverses the items of s in place

Lists

• 串列 (list)是最實用也最常用的群集
• list為mutable
• 可以收集不同資料型態的元素
• list中的元素允許是list
• list的元素是有序的(誰前誰後有關係)
• list的特徵是中括號[ ]，使用索引位置(index)可以存取元素

範例:

In[6]: list = [1,2,3.14,5 + 6j,[7,'hello']]

In[7]: list

Out[7]: [1, 2, 3.14, (5+6j), [7, 'hello']]

In[8]: list[2]    #顯示list的第三個元素(index由0開始算)

Out[8]: 3.14


應用1
list.index(a,b,c)
a :要找的元素
b:找尋的起始index
c:找尋截止的index


應用2
nums1為一串列，
nums2 = nums1，則nums2 與nums1對應同一個物件。
且修改nums2也會修改到nums1，
須改用list.copy()，nums2 = nums1.copy()
即複製一個新的物件給nums2去參照。

應用3

list.sort(reverse=True)       #大到小排序

In[10]: list = [4,2,1,10,3]

In[11]: list

Out[11]: [4, 2, 1, 10, 3]

In[12]: list.sort()

In[13]: list

Out[13]: [1, 2, 3, 4, 10]

In[14]: list.sort(reverse=True)    #大到小排序

In[15]: list

Out[15]: [10, 4, 3, 2, 1]

list可以配合enumerate()函數使用，參考   Python_enumerate()

Tuple

• 序對(tuple)可以收集不同資料型態的元素
• tuple中的元素允許是tuple
• tuple的元素是有序的(誰前誰後有關係)
• tuple的特徵是小括號(), 使用索引位置(index)可以存取元素
• 與list類似，最大的不同tuple是一種唯讀且不可變更的資料結構，不可取代tuple中的任意一個元素，因為它是唯讀不可變更的

應用1
In[16]: nums = 1,2,3,4,5
In[17]: nums
Out[17]: (1, 2, 3, 4, 5) #會自動儲存為tuple結構

Ranges

class range(start, stop[, step])
The range type represents an immutable sequence of numbers and is commonly used for looping a specific number of times in for loops
常用在for迴圈，且參數只能是整數

範例：

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]
>>> list(range(0, 10, 3))
[0, 3, 6, 9]
>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> list(range(0))
[]
>>> list(range(1, 0))
[]

for迴圈的使用方式：
In[20]: for i in range(10):
...     print(i)
...  
Out:
0
1
2
3
4
5
6
7
8
9

Set

• 內建的集合型態 (set types) 共有兩種

1. set: 集合，可變 (mutable)
2. frozenset : 原封集合，建立後不可新增或刪除元素 (element) ，為不可變 (immutable)

• 集合型態的字面常數使大括弧{ }，其物件屬於複合資料型態 (compound data type) ，也就是說單一集合型態物件可以包含多個元素，但沒有重複的元素。
• set 的元素是無序的(誰前誰後沒關係)

範例:
In[18]: set = {1,1,2,2,3,3,3,4,4,4,4,5}
In[19]: set
Out[19]: {1, 2, 3, 4, 5}

Operation

其中，set有frozenset沒有的，

Dict

• 建立字典(dict)變數可利用大括弧{ }，裡頭以key : value 為配對的資料項目，若有多筆資料再以逗號 , 區隔開
• 與list, tuple不同，不以索引位置存取元素，改以key當作索引存取元素

範例:

>>> d1 ['a']

100

• 使 用字典須注意， key 必須是不可變的(immutable) 資料型態，如數字、字串 (string) 等， value 沒有限制
•  dict 的元素是無序的(誰前誰後沒關係)

Operation 

member['a'] = 100 #在member裡新增資料'a',其value:100

範例1：

In[36]: nums = [1,2,5,22]

In[37]: dict.fromkeys(nums)

Out[37]: {1: None, 2: None, 5: None, 22: None}

In[38]: dict.fromkeys(nums,'name')

Out[38]: {1: 'name', 2: 'name', 5: 'name', 22: 'name'}

利用key來替字典的value排序 (value of dict sorted by key )：

a = ['1   apple','3   cherry','5   grape','2   banana','4   durian','5   guava']

dict1 = {}   

for i in range(0,len(a)):

    x= a[i].split('   ')

    dict1[x[0]] = x[1]

print(dict1) 

for key in sorted(dict1):          #sorting of dict

    print("%s: %s" % (key, dict1[key]))

Out:{'2': 'banana', '4': 'durian', '1': 'apple', '3': 'cherry', '5': 'guava'}
1: apple
2: banana
3: cherry
4: durian
5: guava

可以看到dict1本身是沒有順序的，而且因為grape跟guava的key都是5，所以後者會將

前者的value洗掉，只剩下 5 : guava

String

• 字串 (string) 序列型態也是序列的一種。為immutabe。
• 字串 (string) 的特徵為引號，包含單引號、雙引號和三引號，再現時預設以單引號表示

Single quotes: 'allows embedded "double" quotes'Double quotes: "allows embedded 'single' quotes".Triple quoted: '''Three single quotes''', """Three double quotes"""

• 使用索引位置(index)可以存取元素
• 字串的元素是有序的(誰前誰後其順序是有關係)
• 字串頭尾的引號必須相同對稱

字串的方法會在Python_Note05詳細討論。

型態轉換

運算適中的自動型態轉換是由儲存範圍小的轉換到儲存範圍大的，若是相反過來，浮點數轉換為整數，可以利用內建函數 (function) int() 進行轉換

Convert list into set

list轉成set的語法  set(list)

範例：
In[21]: list = [1,2,3,4,5,1,2,3,4,5,11,12,13]
In[22]: s = set(list)
In[23]: s
Out[23]: {1, 2, 3, 4, 5, 11, 12, 13}    #重複項已刪除，且本身是無序的(範例只是剛好有排序)

Convert set into list
set轉成list的語法 list(set)

範例：
In[24]: set = {1,2,3,4,5,1,2,3,4,5,11,12,13}
In[25]: l = list(set)
In[26]: l
Out[26]: [1, 2, 3, 4, 5, 11, 12, 13]  #重複項已刪除，且不會由小到大排序(範例只是剛好有排序)

但是，倘若都照上面嘗試的話，應該會出現 TypeError: 'list' object is not callable 或是 TypeError: 'set' object is not callable，因為list被拿去當變數名稱了，所以無法呼叫list函數 (還不清楚為什麼)，所以請不要將list或set等資料型態的名稱當作變數名稱。

同理，如果想要將一個串列list中的重複物件刪除，可以使用  Lists =  list(set(Lists))，即可藉由set的特性而將重複物件刪除。

如果還想要將串列中的物件依序排列，可以使用 Lists =  sorted(list(set(Lists)))。

Boolean ---- and, or, not

• 邏輯運算 (Boolean operations)是針對真假值(布林值)的運算
• 布林型態只有兩種值: True 跟 False
• 布林語境(Boolean context) : 談論真假, 運算真假的情境
• 在布林語境中, 0和任何的空資料代表False, 其他代表True(通常True會 跟1連結), None在布林語境中也是False

Operation	Result
x or y	if x is false, then y, else x
x and y	if x is false, then x, else y
not x	if x is false, then True, else False

Comparisons

There are eight comparison operations in Python. They all have the same priority (which is higher than that of the Boolean operations). Comparisons can be chained arbitrarily; for example, x < y <= z is equivalent to x < y and y <= z, except that y is evaluated only once (but in both cases z is not evaluated at all when x < y is found to be false).

Python 3.x版已將cmp()比對這個函數刪除，詳細討論請參考Python_cmp() between 3.x vs 2.x。

Operation	Meaning
<	strictly less than
<=	less than or equal
>	strictly greater than
>=	greater than or equal
==	equal
!=	not equal
is	object identity
is not	negated object identity