[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?)