今日主要内容

• 基础数据类型补充
• 循环删除问题
• 二次编码

一、基础数据类型补充

（一）int

1. int.bit_length()
   • 计算整型对应的二进制位数

   a = 10
   print(a.bit_length())  # 4

（二）str

• str.capitalize()	首字母大写，其余小写
  str.title()	每个用特殊字符隔开的首字母大写
  str.index()	计算元素索引位置
  str.find()	计算元素索引位置
  str.center()	将字符串居中
  str.format()	格式化输出
  str.swapcase()	大小写转换

1. str.capitalize()
   • 将字串首字母大写，其余全部变为小写

   s = "hello WORLD"
   s1 = s.capitalize()
   print(s1)  # Hello world

2. str.title()
   • 将每个用特殊字符、中文、空格隔开的英文单词首字母大写

   s = "hello world"
   s1 = s.title()
   print(s1)  # Hello World

3. str.index(n)
   • 计算元素n的索引位置，若n不在字符串中，会报错
   • 默认计算第一个出现该元素n的索引位置
   • 也可指定在范围内查询

   s = "hello world"
   num = s.index("l")
   print(num)  # 2
   
   num1 = s.index("l", 5, 10)  # 9

4. str.find()
   • 计算元素n的索引位置，若n不在字符串中，返回-1
   • 默认计算第一个出现该元素n的索引位置
   • 也可指定在范围内查询

   s = "hello world"
   num = s.find("l")
   print(num)  # 2
   
   num1 = s.find("l", 5, 8)  # -1

5. str.center()
   • 输入一个长度，使字符串在这个长度内居中
   • 可填入第二个参数，居中后空白部分用它来填充

   s = "DNF"
   s1 = s.center(15, "*")
   print(s1)  # ******DNF******

6. str.format()
   • 格式化输出
   • 按照位置格式化

   s1 = "name:{} age:{} sex:{}"
   print(s1.format("ZXD", 23, "man"))
   # name:ZXD age:23 sex:man

   • 按照索引格式化

   s1 = "name:{2} age:{0} sex:{1}"
   print(s1.format(23, "man", "ZXD"))
   # name:ZXD age:23 sex:man

   • 按照关键字格式化

   s1 = "name:{name} age:{age} sex:{sex}"
   print(s1.format(sex="man", age=23, name="ZXD"))
   # name:ZXD age:23 sex:man
   

7. str.swapcase()
   • 将字符串大小写互换

   s = "hello WORLD"
   s1 = s.swapcase()
   print(s1)  # HELLO world
   

（三）list

• list.reverse()	将列表反向排列
  list.sort()	将列表排序

1. list.reverse()
   • 将列表反向排列

   lst = [1, 2, 3, 4, 5]
   lst.reverse()
   print(lst)  # [5, 4, 3, 2, 1]
   

2. list.sort()
   • 将列表升序排序
   • 可填入关键字参数降序排序：reverse = True

   lst = [2, 5, 1, 3, 8]
   lst.sort()
   print(lst)  # [1, 2, 3, 5, 8]
   
   lst.sort(reverse = True)
   print(lst)  # [8, 5, 3, 2, 1]
   

• 面试题：

  lst = [1, 2, [3]]
  lst1 = lst * 2
  lst1[2].append(4)
  print(lst1)  # [1, 2, [3, 4], 1, 2, [3, 4]]
  

  • 列表在使用乘法时，将列表所有元素乘以倍数放到一个新列表中，所以相同元素的内存地址相同，元素共用

（四）dict

1. dict.fromkeys()
   • 批量创建字典，第一个元素迭代成为key，第二个元素为所有key共用的value
   • 两个坑：
     • 第一个坑，fromkeys方法是创建字典，而不是在字典中修改或添加

     dic = {}
     dic.fromkeys("abc", 123)
     print(dic)  # {}
     
     dic = dic.fromkeys("abc", 123)
     print(dic)  # {'a': 123, 'b': 123, 'c': 123}
     

     • 第二个坑，fromkeys的第二个参数是共用的，若是可变类型数据修改，则字典中u所有value全被修改

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

2. 字典定义
   • dic = {}
   • dic = dict()
   • dic = dict(key=value)
   • dic = dict([(key,value)])

   dic1 = dict(k1=1)
   print(dic1)  # {'k1': 1}
   
   dic2 = dict([("k1", 1)])
   print(dic2)  # {'k1': 1}
   

（五）类型转换

1. 转换为bool
   • 所有的空、零转换为布尔类型都是False
   • 所有的非空、非零转换为布尔类型都是True

   print(bool())  # False
   print(bool(0))  # False
   print(bool([]))  # False
   print(bool(""))  # False
   print(bool({}))  # False
   print(bool(()))  # False
   print(bool(set()))  # False
   

2. tuple与list互换
   • tu = tuple(list)
   • lst = list(tuple)

   l = [1, 2, 3]
   tu = tuple(l)
   print(tu)  # (1, 2, 3)  # 转换为元组
   
   lst = list(tu)
   print(lst)  # [1, 2, 3]  # 转换为列表
   

3. set与list互换
   • lst = set(list)
   • st = list(set)

   l = [1, 2, 3]
   st = set(l)
   print(st)  # {1, 2, 3}  # 转换为集合
   
   lst = list(st)
   print(lst)  # [1, 2, 3]  # 转换为列表
   

4. set与tuple互换
   • tuple(set)
   • list(tuple)

   t = (1, 2, 3)
   st = set(t)
   print(st)  # {1, 2, 3}  # 转换为集合
   
   tu = tuple(st)
   print(tu)  # (1, 2, 3)  # 转换为元组
   

5. int和str互换
   • int(str)
   • str(int)

   i = 123
   s = str(i)
   print(s)  # 123  # 转换为字符串
   
   i = int(s)
   print(i)  # 123  # 转换为整型
   

6. str和list互换
   • s = str.join(list)
   • lst = str.split()

   lst = ["a", "b", "c"]
   s = "_".join(lst)
   print(s)  # a_b_c
   
   lst = s.split("_")
   print(lst)  # ['a', 'b', 'c']
   

（六）基础数据类型总结

二、循环删除问题

（一）列表

• 尝试一下利用循环列表删除元素，清空列表

  lst = [1, 2, 3, 4, 5]
  for el in lst:
    lst.remove(el)
  print(lst)  # [2, 4]
  

  • 发现列表并没有被清空，这是为什么呢？

1. 原理：
   • for循环时，有一个元素指针记录当前循环位置，每循环一次指针就指向下一个位置，同时列表中的元素被删除会向前补位，这样就造成了一个位置差，导致元素删不干净

   

2. 解决方法：
   • 方法一：for循环元素个数次，每次都删除第一个元素

   lst = [1, 2, 3, 4, 5]
   for i in range(len(lst)):
    lst.pop(0)
   print(lst)  # []
   

   • 方法二：复制一个副本，循环副本删除原列表

   lst = [1, 2, 3, 4, 5]
   lst1 = lst.copy()
   for el in lst1:
    lst.remove(el)
   print(lst)  # []
   

（二）字典

• 尝试一下利用循环字典删除键值对，清空字典

  dic = {"k1": 1, "k2": 2, "k3": 3}
  for i in dic:
    dic.pop(i)
  print(dic)
  # RuntimeError: dictionary changed size during iteration
  

  • 报错：迭代期间字典长度改变
• 解决方法：
  • 复制一个副本，循环副本删除原字典

  dic = {"k1": 1, "k2": 2, "k3": 3}
  dic1 = dic.copy()
  for k in dic1:
    dic.pop(k)
  print(dic)  # {}
  

（三）集合

• 尝试一下利用循环集合删除元素，清空集合

  st = {1, 2, 3, 4, 5}
  for el in st:
    st.remove(el)
  print(st)
  # RuntimeError: Set changed size during iteration
  

  • 报错：迭代期间集合改变长度
• 解决方法：
  • 复制一个副本，循环副本删除原集合

  st = {1, 2, 3, 4, 5}
  st1 = st.copy()
  for el in st1:
    st.remove(el)
  print(st)  # set()
  

三、二次编码

（一）编码回顾

1. ascii码
   • 只包含英文、数字、特殊符号
   • 每个字符：一个字节，8位
2. gbk：国标码
   • 包含中文、英文、数字、特殊符号
   • 英文：一个字节，8位
   • 中文：两个字节，16位
3. unicode：万国码
   • 每个字符：四个字节，32位
4. utf-8：可变长度编码
   • 英文：一个字节，8位
   • 欧洲文字：两个字节，16位
   • 中文：三个字节，24位

（二）编码与解码

• Python3内存中使用的就是uncode
• 硬盘中存储时选择的编码方式
  • gbk
  • utf-8
• 用什么编码就要用什么解码

1. 编码
   • 格式：数据.encode(编码)

   s = "你好啊"
   se = s.encode("utf-8")
   print(se)  # b'\xe4\xbd\xa0\xe5\xa5\xbd\xe5\x95\x8a'
   

2. 解码
   • 格式：编码后的数据.decode(编码)

   s = b'\xe4\xbd\xa0\xe5\xa5\xbd\xe5\x95\x8a'
   se = s.decode("utf-8")
   print(se)  # 你好啊
   

3. 用处：
   • 存储：文件操作
   • 传输：网络编程

原文地址：https://www.cnblogs.com/tianlangdada/p/11531441.html