python基础学习day7 进阶

基础数据类型的补充；编码的进阶

• 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'
  

​