1. 1. [2.3.1] 進位制(specialized)
  2. 2. [2.3.3] 複數 with cmath imported
  • [2.4] 字串
    1. 1. [2.4.2] 字串拼接
    2. 2. [2.4.3] 字串和數值轉換
      1. 2.1. α. str()和repr()的區別:
      2. 2.2. β. 字串轉化為數值:
    3. 3. [2.4.5] 長字串&原始字串
    4. 4. [2.4.7] 位元組串(bytes)
    5. 5. [2.α] 字串和位元組串的神奇操作
      1. 5.1. α. 可以使用 變數[頭下標:尾下標] 的形式來擷取字串或位元組串
      2. 5.2. β. 連續輸出字串中的某部分
      3. 5.3. γ. 判斷子串包含關係
      4. 5.4. θ. 刪除空白(字串不改變)
      5. 5.5. σ. 查詢與替換(字串不改變)
    6. 6. [2.5.2] 字串的輸出
    7. 7. [2.6.2] 算術運運算元(specialized)
      1. 7.1. α. 使用 // 來達到整除的效果
      2. 7.2. β. 使用 ** 來實現乘方運算
      3. 7.3. γ. is
  • [3.2] 元組和列表
    1. 0.1. pre.α. 元組和列表的兩個區別
  • 1. [3.2.3] 加法
  • 2. [3.2.4] 乘法
  • 3. [3.2.5] in
  • 4. [3.2.6]長度、最大值與最小值
  • 5. [3.2.7]序列的封包和解包
  • 6. [3.α] 列表的神奇操作
    1. 6.1. α. 元組轉換為列表(不可變到可變)
    2. 6.2. β. 向列表追加
    3. 6.3. γ. 刪除列表元素
      1. 6.3.1. ㄚ. 刪除列表中的元素切片(indexed)
      2. 6.3.2. ㄛ. 刪除指定元素的第一處
    4. 6.4. θ. 修改列表元素
      1. 6.4.1. ㄚ. 指定步長時元素個數必須可預測
      2. 6.4.2. ㄛ. 使用字串直接賦值時字串會被拆解
    5. 6.5. δ. count/index/reverse/sort
  • [3.4] 字典
    1. 1. [3.4.2] 建立字典
    2. 2. [3.4.3] 字典的基本操作
      1. 2.1. α. 刪除字典元素
      2. 2.2. β. 獲取字典元素
      3. 2.3. γ. 更新字典
      4. 2.4. θ. 元素存在性判斷
      5. 2.5. δ. 字典格式化輸出
    3. 3. [4.2.α] !Attentions
  • Python 筆記 for 《瘋狂Python講義》

    [2.3.1] 進位制(specialized)

    二進位制整數:以 0b0B 開頭

    八進位制整數:以 0O0o 開頭

    [2.3.3] 複數 with cmath imported

    複數的虛部用jJ來表示

    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](https://api.lemonprefect.cn/image/hdslb/archive/3c619857-d03d-417a-9041-efe9e9a17e40/1613214502444365/91a37ee08cd8d67650e7ee9dfcaa7f27b8dc8f91.png)
    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 : 從右開始刪除引數中所給的每一個匹配字元直到第一個無法匹配的字元

    striplstrip + 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?)