记录我的 python 学习历程-Day07 基础数据类型进阶 / 数据类型之间的转换 / 基础数据类型总结 / 编码的进阶

时间:2023-03-08 16:33:37

基础数据类型

  • str(字符串)

    str:补充方法练习一遍就行

    • s.capitalize() 首字母大写,其余变小写

      s = 'dyLAn'
      print(s.capitalize()) # Dylan
    • s.swapcase() 大小写翻转

      s = 'dYLAN'
      print(s.swapcase()) # Dylan
    • s.title() 每个单词首字母大写(单词之间可以是特殊字符或者空格或者数字)

      s = 'dylan is good man'
      print(s.title()) # Dylan Is Good Man
    • s.center() 居中

      s = 'dylan'
      print(s.center(20)) # dylan (默认是空格填充)
      print(s.center(20, '@')) # @@@@@@@dylan@@@@@@@@
    • s.find() 通过元素找索引,如果有重复的,找到第一个就返回,找不到返回 ‘-1’

      s = 'dylan'
      print(s.find('a')) # 3
      print(s.find('b')) # -1
    • s.index() 通过元素找索引,如果有重复的,找到第一个就返回,找不到报错

      s = 'dylan'
      print(s.index('a')) # 3
      print(s.index('b')) # 报错
      # 报错如下:
      Traceback (most recent call last):
      File "/Users/yaoyaoba/Full_stack_22/day07/练习.py", line 8, in <module>
      print(s.index('b'))
      ValueError: substring not found
  • tuple(元组)

    元组中如果只有一个元素,并且没有逗号,那么它不是元组,它与该元素的数据类型一致。

    tu = (2, 3, 4)
    print(tu, type(tu)) # (2, 3, 4) <class 'tuple'>
    tu = (2)
    print(tu, type(tu)) # 2 <class 'int'>
    tu = ('Dylan')
    print(tu, type(tu)) # Dylan <class 'str'>
    tu = ([1, 2, 3])
    print(tu, type(tu)) # [1, 2, 3] <class 'list'>
    • tu.count() 统计某个元素在元组中出现的次数

      tu = (1, 2, 3, 3, 3, 2, 2, 3,)
      print(tu.count(3)) # 3
    • tu.index() 通过元素找索引,如果有重复的,找到第一个就返回

      tu = (1, 2, 3, 3, 3, 2, 2, 3,)
      print(tu.index(3)) # 2
  • list(列表)

    • li.count() 统计某个元素在列表中出现的次数

      li = ['q', 'w', 'e', 'w', 'e', 'r', 't', 'y']
      print(li.count('w')) # 2
    • li.index() 从列表中找出某个值第一个匹配项的索引位置(找不到会报错)

      li = ['Dylan', 'yaoyao', 'man', 'girl', 'man']
      print(li.index('Dylan')) # 0
      print(li.index('aa')) # 报错
    • li.sort() 在原位置对列表进行排序

      li = [3, 4, 2, 5, 7, 9, 8, 1]
      li.sort() # 它没有反回值,所以只能打印 li
      print(li) # [1, 2, 3, 4, 5, 7, 8, 9]
      li.sort(reverse=True) # 加个参数 就变成从大到小排序了.
      print(li) # [9, 8, 7, 5, 4, 3, 2, 1]
    • li.reverse() 将列表中的元素反转排序

      li = [3, 4, 2, 5, 7, 9, 8, 1]
      li.reverse() # 它没有反回值,所以只能打印 li
      print(li) # [1, 8, 9, 7, 5, 2, 4, 3]
    • 列表相加

      l1 = [3, 4, 2, 5, 7, 9, 8, 1]
      l2 = ['Dylan', 'yaoyao', 'man', 'girl', 'man']
      print(l1 + l2) # [3, 4, 2, 5, 7, 9, 8, 1, 'Dylan', 'yaoyao', 'man', 'girl', 'man']
    • 列表与数字相乘

      l1 = [3, 4, 2, 5, 7, 9, 8, 1]
      l2 = l1 * 3
      print(l2) # [3, 4, 2, 5, 7, 9, 8, 1, 3, 4, 2, 5, 7, 9, 8, 1, 3, 4, 2, 5, 7, 9, 8, 1]
    • 相关练习

      li = [3, 4, 2, 5, 7, 9, 8, 1]
      # 索引为奇数对应的元素删除(不能一个一个删除,此l1只是举个例子,里面的元素不定)。
      # 正常思路:
      # 先将整个列表的索引整出来。
      for index in range(len(li)):
      if index % 2 == 1:
      li.pop(index)
      print(li) # 会报错,因为超出了索引范围 # 最简单的方法
      li = [3, 4, 2, 5, 7, 9, 8, 1]
      del li[1: :2] # 通过切片删
      print(li) # [3, 2, 7, 8] # 倒着删
      for index in range(len(li)-1,-1,-1):
      if index % 2 == 1:
      li.pop(index)
      print(li) # [3, 2, 7, 8] # 思维置换
      li = [3, 4, 2, 5, 7, 9, 8, 1]
      new_li = []
      for index in range(len(li)):
      if index % 2 = 0:
      new_li.append(l1[index])
      l1 = new_li
      print(li) # [3, 2, 7, 8] # 总结:
      # 循环一个列表时,最好不要改变原列表的大小,这样会影响你的最终结果。
  • dict(字典)

    • dic.popitem() 3.5版本之前,popitem为随机删除,3.6之后为删除最后一个,有返回值

      dic = {'name': 'Dylan', 'age': 16}
      ret = dic.popitem()
      print(ret,dic) # ('age', 16) {'name': 'Dylan'}
    • dic.update() 更新或增加 (非常重要)

      # 直接增加键值对
      dic = {'name': 'Dylan', 'age': 16}
      dic.update(sex = '男', height = 178)
      print(dic) # {'name': 'Dylan', 'age': 16, 'sex': '男', 'height': 178} # 更新己有键值对
      dic = {'name': 'Dylan', 'age': 16}
      dic.update(age=33)
      print(dic) # {'name': 'Dylan', 'age': 33} # 元组拆包增加键值对 (面试会考)
      dic = {'name': 'Dylan', 'age': 16}
      dic.update([(1, 'a'), (2, 'b'), (3, 'c')])
      print(dic) # {'name': 'Dylan', 'age': 16, 1: 'a', 2: 'b', 3: 'c'} # 更新,有则覆盖,无则添加
      dic = {'name': 'Dylan', 'age': 16}
      dic1 = {'age': 33, 'sex': 'man'}
      dic.update(dic1)
      print(dic) # {'name': 'Dylan', 'age': 33, 'sex': 'man'}
    • dic.fromkeys() 键来自一个可迭代对象且值共用

      dic = dict.fromkeys('abc', 100)
      print(dic) # {'a': 100, 'b': 100, 'c': 100} 注意这里的值是共用的一个 id dic = dict.fromkeys([1, 2, 3], 'Dylan')
      print(dic) # {1: 'Dylan', 2: 'Dylan', 3: 'Dylan'} # 这有个坑,注意,面试题
      dic = dict.fromkeys([1, 2, 3], [])
      print(dic) # {1: [], 2: [], 3: []}
      dic[1].append(123) # 因为是共用的值,所以改变一个,其它的也都会变
      print(dic) # {1: [123], 2: [123], 3: [123]}
    • 练习题

      # 将字典中键含有'k'元素的键值对删除。
      dic = {'k1': 'Dylan', 'k2': 'xian', 'k3': '男', 'age': 14} # 入坑思路:
      dic = {'k1': 'Dylan', 'k2': 'xian', 'k3': '男', 'age': 14}
      for key in dic:
      if 'k' in key:
      dic.pop(key)
      print(dic) # 报错了
      # 注意:循环一个字典时,如果改变这个字典的大小,就会报错,这是坑。 # 换个思路,我们把循环出来带有'k'的键放到一个列表中,再用列表循环删字典里的键
      dic = {'k1': 'Dylan', 'k2': 'xian', 'k3': '男', 'age': 14}
      li = []
      for key in dic:
      if 'k' in key:
      li.append(key)
      for i in li:
      dic.pop(i)
      print(dic) # {'age': 14} # 再来个简单的
      dic = {'k1': 'Dylan', 'k2': 'xian', 'k3': '男', 'age': 14}
      for key in list(dic.keys()): # {'k1': 'Dylan', 'k2': 'xian', 'k3': '男', 'age': 14}
      if 'k' in key:
      dic.pop(key)
      print(dic) # {'age': 14}

数据类型之间的转换

​ 目前学到的数据类型有:int / bool / str / list / tuple / dict / set ,这些数据类型之间都可以互相转换,而有些转换是非常重要的,有些则基本不用。

  • int / bool / str 三者间的转换

    # int ----> bool
    i = 100
    print(bool(i)) # True 非零即 True
    i1 = 0
    print(bool(i1)) # False 零即是 False # bool ----> int
    t = True
    print(int(t)) # 1 True = 1
    f = False
    print(int(f)) # 0 False = 0 # int ----> str
    i = 100
    print(str(i)) # '100' # str ----> int 全部由数字组成的字符串才可以转化成数字
    s = '90'
    print(int(s)) # 90 # str ----> bool
    s1 = 'Dylan'
    s2 = ''
    print(bool(s1)) # True 非空即 Treu
    print(bool(s2)) # False # bool ----> str # 没有什么实际意义
    t1 = True
    t2 = False
    print(str(t1)) # True
    print(str(t2)) # False
  • str / list 两者转换

    # str ----> list
    s = 'Dylan is good man'
    print(s.split()) # ['Dylan', 'is', 'good', 'man'] # list ----> str
    li = ['Dylan', 'is', 'good', 'man']
    print(' '.join(li)) # Dylan is good man
  • list / set 两者转换

    # list ----> set
    li = ['Dylan', 'is', 'good', 'man']
    print(set(li)) # {'is', 'Dylan', 'good', 'man'} # set ----> list
    set1 = {'is', 'Dylan', 'good', 'man'}
    print(list(set1)) # ['Dylan', 'good', 'man', 'is'] 注意转换过来的是无序的
  • str / bytes 两者转换

  • # str ----> bytes
    s = '海洋'
    print(s.encode('utf-8')) # b'\xe6\xb5\xb7\xe6\xb4\x8b' # bytes ----> str
    b = b'\xe6\xb5\xb7\xe6\xb4\x8b'
    print(b.decode('utf-8')) # 海洋
  • 所有数据都可以转化成bool值

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

基础数据类型总结

  • 按存储空间的占用区分(从低到高)

    数字
    字符串
    集合:无序,即无序存索引相关信息
    元组:有序,需要存索引相关信息,不可变
    列表:有序,需要存索引相关信息,可变,需要处理数据的增删改
    字典:有序,需要存key与value映射的相关信息,可变,需要处理数据的增删改(3.6之后有序)
  • 按存值个数区分

    标量/原子类型 数字,字符串
    容器类型 列表,元组,字典
  • 按可变不可变区分

    可变 列表,字典
    不可变 数字,字符串,元组,布尔值
  • 按访问顺序区分

    直接访问 数字
    顺序访问(序列类型) 字符串,列表,元组
    key值访问(映射类型) 字典

编码的进阶

  • 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
      s1 = '中国'
      b1 = s1.encode('utf-8') # 编码
      print(b1,type(b1)) # b'\xe4\xb8\xad\xe5\x9b\xbd'
      #b1 = s1.encode('gbk') # 编码 # 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'