数据类型的补充与编码进阶

数据类型的补充与编码进阶

• str 字符串

  • capitalize 首字母大写，其余变小写

    s1 = 'taiBAi'
    print(s1.capitalize())
    # Taibai
    

  • swapcase 大小写翻转

    s1 = 'taiBAi'
    print(s1.swapcase())
    # TAIbaI
    

  • title 每个单词的首字母大写

    msg= 'taibai say3hi'
    print(msg.title()) 
    # Taibai Say3Hi
    

  • center 居中

    s1 = 'barry'
    print(s1.center(20))
    print(s1.center(20,'*'))
    
    #       barry        
    # *******barry********
    

  • find 与 index:

    s1 = 'barry'
    find :通过元素找索引，找到第一个就返回，找不到 返回-1
    index:通过元素找索引，找到第一个就返回，找不到 报错
    print(s1.find('a'))
    # 1
    print(s1.find('r'))
    # 2
    print(s1.find('o'))
    # -1
    print(s1.index('r'))
    # 2
    print(s1.index('o'))
    # 报错 substring not found
    

• 元组

  • tuple 特殊性

    元组中如果只有一个元素，并且没有逗号，那么他不是元组，他与该元素的数据类型一致。
    tu1 = (2,3,4)   	 # 类型是tuple
    tu1 = (2)       	 # 类型是int
    tu1 = ('太白')  	    # 类型是str
    tu1 = ([1,2,3]) 	 # 类型是list
    tu1 = (1,)            # 类型是tuple 
    print(tu1,type(tu1))
    

  • count 计数

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

  • index 获取该元素的索引位置

    tu = ('太白', '日天', '太白')
    print(tu.index('太白'))
    # 0
    

• 列表list

  • count 计数

    l1 = ['太白', '123', '女神', '大壮',"太白"]
    num = l1.count("太白")
    print(num)
    # 2
    

  • index

    l1 = ['太白', '123', '女神', '大壮',"太白"]
    num = l1.index("女神")
    print(num)
    # 2
    

  • sort 排序，默认从小到大排序

    l1 = [5, 4, 3, 7, 8, 6, 1, 9]
    l1.sort()
    print(l1)
    # [1, 3, 4, 5, 6, 7, 8, 9]
    
    l1 = [5, 4, 3, 7, 8, 6, 1, 9]
    l1.sort(reverse = True)
    print(l1)
    # [9, 8, 7, 6, 5, 4, 3, 1]
    

  • reverse 反转

    l1 = [5, 4, 3, 7, 8, 6, 1, 9]
    l1.reverse()
    print(l1)
    # [9, 1, 6, 8, 7, 3, 4, 5]
    

  • 列表可以相加

    v1 = [5, 4, 3, 7]
    v2 = [4, 5, 6]
    print(v1 + v2)
    # [5, 4, 3, 7, 4, 5, 6]
    

  • 列表与数字相乘

    v2 = [4, 5, 6]
    print(v2 * 3)
    # [4, 5, 6, 4, 5, 6, 4, 5, 6]
    

  • 练习题

    有列表l1, lis = [11, 22, 33, 44, 55]，请把索引为奇数对应的元素删除
    方式一（直接删除）
    lis = [11, 22, 33, 44, 55]
    del lis[1::2]
    print(lis)
    
    方式二（倒序删除）
    lis = [11, 22, 33, 44, 55]
    for i in range(len(lis)-1,-1,-1):
        if i % 2 == 1:
           lis.pop(i)
    print(lis)
    
    方式三（思维置换）
    lis1= []
    for i in range(len(lis)):
        if i % 2 == 0:
            lis1.append(lis[i])
    lis = lis1
    print(lis)
    
    
    总结：循环一个列表的时，最好不要改变列表的大小，这样会影响你的最终的结果
    

• 字典 dict

  • update 更新，有则覆盖，无责添加

    dic = {'name': '太白', 'age': 18}
    dic.update(hobby='运动', hight='175')
    print(dic)
    # {'name': '太白', 'age': 18, 'hobby': '运动', 'hight': '175'}
    
    dic = {'name': '太白', 'age': 18}
    dic.update(name='太白金星')
    print(dic)
    # {'name': '太白金星', 'age': 18}
    
    dic = {'name': '太白', 'age': 18}
    dic.update([(1, 'a'),(2, 'b'),(3, 'c'),(4, 'd')])  # 面试会考
    print(dic)
    # {'name': '太白', 'age': 18, 1: 'a', 2: 'b', 3: 'c', 4: 'd'}
    
    dic1 = {"name":"jin","age":18,"sex":"male"}
    dic2 = {"name":"alex","weight":75}
    dic1.update(dic2)  
    print(dic1)  
    # {'name': 'alex', 'age': 18, 'sex': 'male', 'weight': 75}
    

  • fromkeys 创建一个字典：字典的所有键来自一个可迭代对象，字典的值使用同一个值。

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

  • 练习题

    将字典中键含有'k'元素的键值对删除。
    dic = {'k1': '太白', 'k2': 'barry', 'k3': '白白', 'age': 18}
    方式一
    lis = []
    for key in dic.keys():
        if "k" in key:
            lis.append(key)
    for v in lis:
        dic.pop(v)
    print(dic)
    
    方式二
    for key in list(dic.keys()):
        if "k" in key:
            dic.pop(key)
    print(dic)
    
    总结：循环一个字典时，如果改变这个字典的大小，就会报错。
    

2数据类型之间的转换

• int ，str ，bool之间的转换

• str 与 list的转换

  # str ---> list
  s1 = 'alex 太白 武大'
  print(s1.split())  # ['alex', '太白', '武大']
  
  # list ---> str  # 前提 list 里面所有的元素必须是字符串类型才可以
  l1 = ['alex', '太白', '武大']
  print(' '.join(l1))  # 'alex 太白 武大'
  

• list 与 set 的转换

  # list ---> set
  s1 = [1, 2, 3]
  print(set(s1))
  
  # set ---> list
  set1 = {1, 2, 3, 3,}
  print(list(set1))  # [1, 2, 3]
  

• 数据类型转换成bool值为False

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

3.编码的进阶

• 编码

  • ASCII码：包含英文字母，数字，特殊字符与01010101对应关系

    • a 01000001 一个字符一个字节表示。

  • GBK：只包含本国文字（以及英文字母，数字，特殊字符）与0101010对应关系。

    • a 01000001 ascii码中的字符：一个字符一个字节表示。

    • 中 01001001 01000010 中文：一个字符两个字节表示。

  • Unicode：包含全世界所有的文字与二进制0101001的对应关系。

    • a 01000001 01000010 01000011 00000001

    • b 01000001 01000010 01100011 00000001

    • 中 01001001 01000010 01100011 00000001

  • UTF-8:包含全世界所有的文字与二进制0101001的对应关系（最少用8位一个字节表示一个字符）。

    • a 01000001 ascii码中的字符：一个字符一个字节表示。
    • To 01000001 01000010 (欧洲文字：葡萄牙，西班牙等)一个字符两个字节表示。
    • 中 01001001 01000010 01100011 亚洲文字；一个字符三个字节表示。

  • 不同的密码本之间能否互相识别？不能，会出现乱码或者报错

• 数据在内存中全部是以Unicode编码的，但是当你的数据用于网络传输或者存储到硬盘中，必须是以非Unicode编码（utf-8,gbk等等）。

  英文：
  str： 'hello '
  内存中的编码方式： Unicode
  表现形式： 'hello'
  bytes ：
  内存中的编码方式： 非Unicode
  表现形式：b'hello'
  
  中文：
  str：
  内存中的编码方式： Unicode
  表现形式：'中国'
  bytes ：
  内存中的编码方式： 非Unicode # Utf-8
  表现形式：b'\xe4\xb8\xad\xe5\x9b\xbd'
  

• str 与 bytes之间的转换

  # str ---> bytes\
  s1 = '中国'
  b1 = s1.encode('utf-8')  # 编码
  print(b1,type(b1))     # b'\xe4\xb8\xad\xe5\x9b\xbd'  <class 'bytes'>
  b1 = s1.encode('gbk')  # 编码  
  print(b1,type(b1))     # b'\xd6\xd0\xb9\xfa'  <class 'bytes'>
  
  # bytes---->str
  b1 = b'\xe4\xb8\xad\xe5\x9b\xbd'
  s2 = b1.decode('utf-8')  # 解码
  print(s2)
  

• 应用

  # gbk ---> utf-8
  b1 = b'\xd6\xd0\xb9\xfa'
  s = b1.decode('gbk')
  # print(s)
  b2 = s.encode('utf-8')
  print(b2)  # b'\xe4\xb8\xad\xe5\x9b\xbd'