基礎資料型別的補充；編碼的進階

• str

  • capitalize() 首字母（第一個單詞）大寫，其余變小寫

    s1 = 'I LIVE YOU'
    print(s1.capitalize())
    >>>I live you
    

  • title() 每個單詞的首字母大寫，(以特殊字符（非字母）隔開的即為一個單詞)

    s1 = 'I LIVE YOU'
    print(s1.title())
    >>>I Live You
    

  • swapcase() 大小寫反轉

    s1 = 'I love YOU'
    print(s1.swapcase())
    >>>i LOVE you
    

  • center() 居中，有1個必選引數：寬度，一個非必選引數：填充）

    s1 = 'I'
    print(s1.center(10,'%'))
    >>>%%%%I%%%%%
    

  • find() 通過元素找索引，找到第一個就回傳，找不到回傳-1，

    s1 = 'I love you'
    print(s1.find('o'))
    >>>3
    

  • index() 通過元素找索引，找到第一個就回傳，找不到就報錯，

• tuple

  • 特殊性：元祖中只有一個元素，并且沒有’，‘，則它不是元祖，它與括號中的資料型別一致

    tu0 = (1,2)
    print(tu0,type(tu0))
    >>>(1, 2) <class 'tuple'>
    
    tu1 = (1)
    print(tu1,type(tu1))
    >>>1 <class 'int'>
    
    tu2 = ([1])
    print(tu2,type(tu2))
    >>>[1] <class 'list'>
    
    tu3 = (1,)
    print(tu3,type(tu3))
    >>>(1, ) <class 'tuple'>
    

  • count() 計數

    tu = (1,2,3,3,3,3)
    print(tu.count())
    >>>4
    

  • index() 找索引

    tu = ['a','b','a']
    print(tu.index('a'))
    >>>0
    

• list

  • index() 通過元素找索引

    l1 = ['a','b','a']
    print(l1.index('a'))
    >>>0
    

  • sort() 默認從小到大排序，設定reverse引數則可從小到大

    l1 = [3,2,1,4]
    l1.sort()
    print(l1)
    >>>[1,2,3,4]
    
    l1.sort(reverse=True)
    print(l1)
    >>>[4,3,2,1]
    

  • reverse() 反轉

    l1 = [2,1,3,0]
    l1.reverse()
    print(l1)
    >>>[0,3,1,2]
    

  • 串列相加 (3.4以上版本)

    l1 = [1,2,3]
    l2 = [3,4,5]
    print(l1+l2)
    >>>[1, 2, 3, 3, 4, 5]
    

  • 串列與數字相乘 (3.4以上版本)

    l1 = [2,'a',[1,'b']]
    l2 = l1*3
    print(l2)
    >>>[2, 'a', [1, 'b'], 2, 'a', [1, 'b'], 2, 'a', [1, 'b']]
    

  • 串列的特殊性：正向回圈一個串列時如果洗掉某個元素，那么這個元素后面的所有元素都會向前進一位，它們的索引相比之前也會前進一位，因此，在回圈一個串列時的程序中，如果要改變串列的大小（增加值或者洗掉值），那么結果很可能會出錯或者報錯，

    l1 = [1,2,3,4,5,6]  #洗掉串列中索引位為偶數的元素，
    for i in range(0,len(l1),2):
    	l1.pop(i)
    print(l1)
    >>>IndexError: pop index out of range
    

    • 解決此問題有三種方式

      1.直接洗掉 （按照元素洗掉，按照索引洗掉，切片加步長

      #切片加步長
      l1 = [1,2,3,4,5,6]
      del l1[1::2]
      print(l1)
      

      2.倒敘洗掉

      l1 = [1,2,3,4,5,6]
      for i in range(len(l1)-1,-1,-2): 
      	l1.pop(i)   
      print(l1)
      >>>[1,3,5]
          
      #不能用以下代碼；請自測
      l1 = [1,2,3,4,5,6]
      for i in range(1,len(l1),2):
          l1.pop(-i)
      

      3.思維轉換

      l1 = [1,2,3,4,5,6]
      l2 = []
      for i in range(0,len(l1),2): 
      	l2.append(l1[i])
      l1 = l2
      print(l1)
      

• dict

  • popitem 3.5版本之前，隨機洗掉，3.6版本之后，洗掉最后一個，有回傳值， 請自測，

  • update

    dic0 = {1:'i'}
    dic0.update(2='love',hobby='python')  #增加鍵值對
    print(dic0)
    >>>{1: 'i', 2: 'love', 'hobby': 'python'}
    
    dic0.update(1 = '太陽') #改鍵值對
    print(dic0)
    >>>{1: '太陽', 2: 'love', 'hobby': 'python'}
    
    dic1 = {}
    dic1.update([(1,'a'),(2,'b'),(3,'c')])
    print(dic1)
    >>>{1: 'a', 2: 'b', 3: 'c'}
    
    dic0.update(dic1)
    print(dic0)   #有則覆寫，無則增加
    >>>{1: 'a', 2: 'b', 'hobby': 'python', 3: 'c'}
    print(dic1)
    >>>{1: 'a', 2: 'b', 3: 'c'}
    

  • fromkeys() 第一個引數必須為可迭代物件，可迭代的物件共用第二個引數(id相同)，

    dic = dict.fromkeys('abc',1)     
    print(dic)
    >>>{'a': 1, 'b': 1, 'c': 1}
    
    dic = dict.fromkeys([1,2,3],[])
    print(dic)
    >>>{1: [], 2: [], 3: []}
    dic[1].append('a')
    print(dic)
    >>>{1: ['a'], 2: ['a'], 3: ['a']}
    

  • 小題試做：（回圈一個字典時，若果改變字典的大小則或報錯，）

    #將字典dic中的以‘k’開頭的鍵值對洗掉
    dic = {'k1':'a','k2':'b','k3':'c','a':'d'}
    l1 = []
    for key in dic:
        if key.startswith('k'):
            l1.append(key)
    for i in l1:
        dic.pop(i)
    print(dic)
    >>>{'a':'d'}
    
    
    #改進
    for key in list(dic.keys()):   #將其轉換為一個串列，若不加list則回報錯，
        if 'k' in key:
            dic.pop(key)
    print(dic)
    >>>{'a','d'}
    

• 資料之間型別的轉換：

  • int bool str 三者轉換

  • str list 兩者轉換

  • list set 兩者轉換

  • str bytes 兩者轉換

  • 所有資料都可以轉換成bool值：

    轉換成bool值為False的資料型別有：

    '',0,(),{},[],set(),None
    

• 基礎資料結構型別的總結

  • 按照儲存空間的占用分（從低到高）
    • int
    • str
    • set : 無序
    • tuple: 有序，不可變
    • list: 有序，可變
    • dict: 有序（3.6版本之后），可變

• 編碼的進階：

  • 不同的編碼方式之間不能相互識別

  • 資料在記憶體中全部是以Unicode編碼的，但是當資料用于網路傳輸或者存盤到硬碟中，必須是以非Unicode編碼（utf-8、gbk等）

  • python中的資料從記憶體（Unicode編碼）存盤到硬碟或進行網路傳輸時要經歷一個特殊的轉化程序,要轉化為一個非Unicode編碼型別的特殊資料才能進行傳輸或儲存至硬碟，即bytes型別(記憶體中的編碼方式：非Unicode) 記憶體中的資料（int,bool,list,dict,set,tuple）都不能直接轉換為bytes型別，是先自動轉換為字串（Unicode編碼）型別，再轉換為bytes型別，

    • bytes與str的操作方式大部分都是一樣的
    • bytes can only contain ASCII literal characters，手動將中文字串轉化為bytes型別會報錯，要經過特殊的轉化

    #str轉bytes:
    a = b'iloveyou'
    print(a,type(a))
    >>>b'iloveyou' <class 'bytes'>
    
    #將中文轉化為bytes型別：
    b = b'山就在那兒'
    print(b)
    >>>SyntaxError: bytes can only contain ASCII literal characters
    #正確方法為：
    
    c = '山就在那兒'
    b = c.encode('utf-8')
    print(b)   #or print(c.encode('utf-8'))    #一般指定utf-8的編碼形式，   (encode:編碼)
    >>>b'\xe5\xb1\xb1\xe5\xb0\xb1\xe5\x9c\xa8\xe9\x82\xa3\xe5\x84\xbf'
    

    • bytes可轉化為字串型別（Unicode）（decode，解碼），用什么編碼型別轉換為bytes資料型別的就用什么解碼，

      b = b'\xe5\xb1\xb1\xe5\xb0\xb1\xe5\x9c\xa8\xe9\x82\xa3\xe5\x84\xbf'
      c = b.decode('utf-8')    or print(b.decode('utf-8'))
      print(c)
      >>>山就在那兒
      
      #用什么編碼型別轉換為bytes資料型別的就用什么解碼，
      b = b'\xe5\xb1\xb1\xe5\xb0\xb1\xe5\x9c\xa8\xe9\x82\xa3\xe5\x84\xbf'
      c = b.decode('gbk')    
      print(c)
      >>>UnicodeDecodeError: 'gbk' codec can't decode byte 0xbf in position 14: incomplete multibyte sequence
      

• 小題試做：gbk轉換為utf-8

  #分析，所有的編碼都與Unicode有關（計算機記憶體中以Unicode編碼），因此可先將gbk轉換為Unicode編碼，再轉換為utf-8編碼，
  
  gbk = b'\xc9\xbd\xbe\xcd\xd4\xda\xc4\xc7\xb6\xf9'
  decode1 = gbk.decode('gbk')    #解碼為Unicode編碼的字串,可print(decode1)查看，
  print(decode1.encode('utf-8'))  #以utf-8編碼
  >>>b'\xe5\xb1\xb1\xe5\xb0\xb1\xe5\x9c\xa8\xe9\x82\xa3\xe5\x84\xbf'
  

?

標籤：Python

上一篇：推薦 10 個有趣的 Python 專案

下一篇：實體005：三數排序