[2.3.1] 進制（specialized）

二進制整數：以 0b 或 0B 開頭

八進制整數：以 0O 或 0o 開頭

[2.3.3] 複數 with cmath imported

複數的虛部用j或J來表示

1
2
3
import cmath
a = 1 + 0.2j #define a complex number
print(a)

[2.4] 字符串

[2.4.2] 字符串拼接

1
2
3
4
5
#Simply put them together in one line
str = "null"'_null'     #It will be "null_null"

#Use the "+"
str = "null" + '_null'  #It will be "null_null"

[2.4.3] 字符串和數值轉換

α. str()和repr()的區別：

str()用於將值轉化為適於人閱讀的形式

repr()轉化為供解釋器讀取的形式（如果沒有等價的語法，則會發生SyntaxError 異常），適合開發和調試階段使用。

1
2
3
4
import datetime
today = datetime.date.today()
repr(today) #It will be 'datetime.date(2019,12,14)'
str(today)  #It will be '2019-12-14'

其二者相當於調用了對象的方法

1
2
3
today = datetime.date.today()
today.__repr__()       #Its result will be the same as repr(today)
today.__str__()        #Its result will be the same as str(today)

>:Experiment >

1
2
3
4
5
6
7
8
9
10
11
12
13
print("12345".__repr__())
'12345'
print("12345".__str__())
12345
print('12345'.__str__())
12345
print('12345'.__repr__())
'12345'
string = '123'
repr(string)
"'123'"
print(string.__repr__())
'123'
β. 字符串轉化為數值：
1
2
3
string.atoi(s,[base]) #將字符串變為數值，base為進制基數
string.atof(s)        #將字符串轉化為浮點數
int(s)                #字符直接轉數字

[2.4.5] 長字符串&原始字符串

使用三個單/雙引號包含的字符串（塊）形成一個長字符串（當不賦值給變量時可以作為註釋使用）。其依舊遵守字符串的拼接規則

1
2
3
s = """this is a \
long string"""" and here is a usually one"
#this will at last be """this is a long string and here is a usually one"""

值得注意的是，當需要在表達式中間換行的時候，使用“\”字符來轉義以實現。也因為“\”的轉義功能，當需要實現“\”字符的時候，寫作“\\”。 但是，也可以使用原字符串來避免這樣的轉義。

1
s = r"this 'is' a \'string\"

但是，使用原始字符串的時候，不能以“\”結尾，避免最後的引號被轉義而出現SyntaxError: EOL while scanning string literal的錯誤，同時，原始字符串中的引號需要被轉義，但是轉義反斜槓將成為字符串的一部分。

[2.4.7] 字節串(bytes)

1
2
3
4
5
6
7
8
#α using a single "b"lead the string to get bytes(only for the ASCII characters)
bBytes = b"this is a string contains on ASCII characters"

#β using the function bytes() to get a default UTF-8 bytes string
cBytes = bytes("this is a string contains on ASCII characters","ASCII")

#γ using method for string to get a default UTF-8 bytes string
dBytes = "this is a string contains on ASCII characters".encode('ASCII')

[2.α] 字符串和字節串的神奇操作

α. 可以使用 變量[頭下標:尾下標] 的形式來截取字符串或字節串

Index

1
2
3
4
str = "this is a sample string"
print(str[0:-1])  #this will be "this is a sample strin"
print(str[0])     #this will be "t"
print(str[2:])	  #this will be "is a sample string"
β. 連續輸出字符串中的某部分
1
2
str = "this is a sample string"
print(str[2:5] * 2)  #this will be "is is "

其中的索引還可以指定步長

1
print(str[2:5:2])  #this will be "i"

>:Specially > Python 字符串不能被改變。向一個索引位置賦值，比如str[0] = ‘m’會導致錯誤

γ. 判斷子串包含關係
1
print("asd" in "asdfg") #this will be True
θ. 刪除空白（字符串不改變）

lstrip : 從左開始刪除參數中所給的每一個匹配字符直到第一個無法匹配的字符

rstrip : 從右開始刪除參數中所給的每一個匹配字符直到第一個無法匹配的字符

strip：lstrip + rstrip

1
2
3
4
5
6
7
8
#escaping the ' ' in two ends when given no arguments
a = 'a aaacddd d'

#α escape all 'a' & 'd' in two ends
print(a.strip('ad'))  #this will be aaacddd

#β escape all 'a' & 'd' & ' ' in two ends
print(a.strip('a d')) #this will be c
σ. 查找與替換（字符串不改變）

使用 translate() 來定義字符翻譯映射表以實現一次替換所有

1
2
3
strg = 'aaggbbggyyggacd'
table = str.maketrans('aby','αβγ')
strg.translate(table) #this will be 'ααggββggγγggαcd'

使用 find() 來尋找子串在字符串中第一次出現的位置

1
2
strg = 'aaggbbggyyggacd'
strg.find('a') #this will be 0

對於字符串是否以指定子串開頭或結尾，使用 startswith()和 endswith() 來判斷

1
2
3
strg = 'aaggbbggyyggacd'
strg.endswith('gg')   #this will be False
strg.startswith('aa') #this will be True

[2.5.2] 字符串的輸出

使用print搭配轉換說明符輸出時

%r 是使用 repr() 將變量或表達式轉換為字符串

%s 是使用 str() 將變量或表達式轉換為字符串

1
2
3
strg = "asd"
print("%r %s" %(strg,strg)) #also pay attention to the usage of print
#the result will be 'asd' asd

[2.6.2] 算術運算符（specialized）

α. 使用 // 來達到整除的效果
1
2
3
4
c = 32
#digits will be promoted when using simply '/' to do the division
c / 3   #the result will be 10.666666666666666
c // 3  #this will be 10
β. 使用 ** 來實現乘方運算
1
2
3
c = 2
c **= 3
print(c) #this will be 8
γ. is

is 只有在兩個變量引用同一個對象時會返回 True，而 == 則是隻要值相同即為True

1
2
3
4
5
6
a = 3.14
b = 3.14

#When id(a) != id(b)
a is b #it will be False
a == b #it will be True

[3.2] 元組和列表

pre.α. 元組和列表的兩個區別

列表的元素可以被重新賦值，但元組相當於常量，不能賦值

列表的兩端使用方括號而元組的兩端使用圓括號

[3.2.3] 加法

1
2
3
4
5
6
7
tupleA = (1,'lemon',2)
tupleB = (2,'lemon',3)
listB = [2,'lemon',3]
listA = [1,'lemon',2]

print(listA + listB)   #this will be [1, 'lemon', 2, 2, 'lemon', 3]
print(tupleA + tupleB) #this will be (1, 'lemon', 2, 2, 'lemon', 3)

>:Specially > 將列表與元組直接相加會導致 TypeError: can only concatenate list (not “tuple”) to list 的錯誤

[3.2.4] 乘法

使用乘法可以將一個元素重複 n 次

1
2
print(tupleA + tupleB * 3) 
#this will be(1, 'lemon', 2, 2, 'lemon', 3, 2, 'lemon', 3, 2, 'lemon', 3)

[3.2.5] in

用 in 來判斷元素是否包括在元組或列表中

1
2
'lemon' in listA #this will be true
'lemon' in tupleA #this will be true

[3.2.6]長度、最大值與最小值

1
2
3
4
5
6
print(len(tupleA)) #this will be 3

#When compare the English characters, ASCII will be check sequentially
listWord = ['ab','ac','b']
print(min(listWord)) #this will be ab
print(max(listWord)) #this will be b

>:Specially > 直接比較類型不同的元素會引發 TypeError: ‘>’ not supported between instances of ‘str’ and ‘int’ 的錯誤

[3.2.7]序列的封包和解包

1
2
3
4
5
6
7
8
tupleA = 12,13,14,15,16  #this will automatically convert to a tuple
a,b,c,d,e = tupleA       #make the variables equals the elements in the tuple
print(a,b,c,d,e) 		 #this will be 12 13 14 15 16

#Unpacking partially is also allowed
tupleA = 12,13,14,15,16
f,g,h,*rest = tupleA
print(f,g,h,rest) #this will be 12 13 14 [15, 16]

[3.α] 列表的神奇操作

α. 元組轉換為列表（不可變到可變）

使用 list 函數來將元組區間等轉換成列表，但區間的步長起作用稍微有點神奇

1
2
3
4
5
6
7
8
9
tuple_A = ('Luomos',1,2,3)
list(tuple_A) #this will form a list

rangeA = (1,10)
print(list(rangeA)) #this will be [1,10]

rangeB = (1,10,3)
print(list(rangeB)) #this will be [1, 10, 3]
print(list(range(1,10,3))) #this will be [1, 4, 7]
β. 向列表追加

調用列表的 append 方法可以向列表最後追加元素，但是無論追加什麼，一次追加都只會形成一個嵌套元素

1
2
3
4
5
6
listA = ['Lumos']
listA.append('Lumos')
tupleA = ('Lumos','Maximum')
listA.append(tupleA)
listA.append(listA) #it appends itself :)
#Above will eventually form ['Lumos', 'Lumos', ('Lumos', 'Maximum'), [...]]

如果想要一次追加多個元素而不被嵌套，使用 extend

1
2
3
4
5
6
listA = ['Lumos']
listA.extend('Lumos')
tupleA = ('Lumos','Maximum')
listA.extend(tupleA)
listA.extend(listA) #it extends itself :)
#Above will eventually form ['Lumos', 'L', 'u', 'm', 'o', 's', 'Lumos', 'Maximum', 'Lumos', 'L', 'u', 'm', 'o', 's', 'Lumos', 'Maximum']

但是同時也可以發現，單個追加元素時元素會被拆開

γ. 刪除列表元素
ㄚ. 刪除列表中的元素切片（indexed）

使用 del 在刪除列表中的元素時可以依照索引刪除一個元素切片，其遵循所有一般切片的表示方式

1
2
listA = ['Here', 'I', 'am', 'Here', 'I', 'am', 'Here', 'I', 'am']
del listA[1:4:2] #This will form ['Here', 'am', 'I', 'am', 'Here', 'I', 'am']

>:Specially > 當沒有切片屬性而將列表名傳遞給 del 會使得整個列表變量被刪除，再次調用該變量將引發 NameError: name is not defined 的錯誤

當需要清空一個列表時，最好使用 clear 方法

1
2
listA = ['Here', 'I', 'am', 'Here', 'I', 'am', 'Here', 'I', 'am']
listA.clear() #This will form []
ㄛ. 刪除指定元素的第一處

使用 remove 方法可以刪除指定元素的除此出現，而其後續其餘元素順次前移一個位置

1
2
listA = ['Here', 'I', 'am', 'Here', 'I', 'am', 'Here', 'I', 'am']
listA.remove('am') #This will form ['Here', 'I', 'Here', 'I', 'am', 'Here', 'I', 'am']

>:Specially > 當指定的元素不存在時，將引發 ValueError: list.remove(x): x not in list 的錯誤

θ. 修改列表元素

列表的修改可以直接賦值，仍然遵循元素切片的一般表達方式，但是有兩個特殊點

ㄚ. 指定步長時元素個數必須可預測
1
2
listB = list(range(1,10))
listB[0:8:2]=[5,5,5,5] #This will form [5, 2, 5, 4, 5, 6, 5, 8, 9]

>:Specially > 元素個數不可預測時，將引發 ValueError: attempt to assign sequence of size * to extended slice of size * 的錯誤

ㄛ. 使用字符串直接賦值時字符串會被拆解
1
2
listB = list(range(1,10))
listB[0:2]='Hello' #This will form ['H', 'e', 'l', 'l', 'o', 3, 4, 5, 6, 7, 8, 9]

字符串被拆解後，將從切片起點填充直到字符串結束，而切片終點無效

δ. count/index/reverse/sort
1
2
3
4
5
6
7
8
9
10
listB = list(range(1,10))
listB.index(2) #This will be 1

listB.count(2) #This will be 1

listB.reverse() #This will form [9, 8, 7, 6, 5, 4, 3, 2, 1]

listA = ['Here', 'I', 'Here', 'I', 'am', 'Here', 'I', 'am']
listA.sort(key=len,reverse=True) #key is the same as cmp in qsort in C
#This will form ['Here', 'Here', 'Here', 'am', 'am', 'I', 'I', 'I']

[3.4] 字典

[3.4.2] 創建字典

字典的創建有多種等價寫法

1
2
3
4
dictA = {'A':1,'B':2}
dictA = dict([('A',1),('B',2)])
dictA = dict([['A',1],['B',2]])
dictA = dict(A = 1,B = 2)

除此之外，創建一個空字典也有多種寫法

1
2
dictB = dict()
dictB = {}

元組作為一種不可變類型的，也是可以用作key的

1
dictC = {(1,2):1,2:2,3:3}

一次創建多key但value一定的字典

1
2
3
4
dictD = fromkeys({'A','B'}) #dictD will be {'A':None,'B':None}
dictD = fromkeys(('A','B')) #dictD will be {'A':None,'B':None}

dictD = fromkeys(('A','B'),2) #dictD will be {'A':2,'B':2}

[3.4.3] 字典的基本操作

α. 刪除字典元素

使用 del 可以刪除指定元素

1
2
3
dictA = {'A':1,'B':2}
del dictA['A']
#dictA will be {'B':2} now

使用 clear 可以清空一個字典

1
2
3
dictA = {'A':1,'B':2}
dictA.clear()
#dictA will be {} now
β. 獲取字典元素

使用 get 方法以避免訪問不存在的key時拋出異常，以None取代之

1
2
3
dictA = {'A':1,'B':2}
dictA.get('A') #This will be 1
dictA.get('C') #This will be None
γ. 更新字典

使用 update 方法使用一個字典更新另一個字典（更新併合並）

1
2
3
4
dictA = {'A':1,'B':2}
dictB = {'A':2,'C':3}
dictA.update(dictB)
#dictA will be {'A':2,'B':2,'C':3}

使用 setdefault 方法來合併（不更新）

1
2
3
dictA = {'A':1,'B':2}
dictA.setdefault('A',2) #dictA will still be {'A':1,'B':2}
dictA.setdefault('C',3) #dictA will be {'A':1,'B':2,'C':3}
θ. 元素存在性判斷

使用 in/not in 來對key進行查詢，根據返回的結果進行判斷

1
2
3
dictA = {'A':1,'B':2}
print('A' in dictA) #This will be True
print('A' not in dictA) #This will be False
δ. 字典格式化輸出
1
2
3
dictA = {'A':1,'B':2}
template = '%(A)d,is not %(B)d'
print(template % dictA) #This will be 1 is not 2

[4.2.α] !Attentions

以下值等同於False

1
None 0 () "" [] {}

空語句使用pass實現

當斷言為False時會引發錯誤

for-in 循環中的變量不應該在循環內更改值(foreach?)