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

基础数据类型

• 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'xe6xb5xb7xe6xb4x8b'
  
  # bytes ----> str
  b = b'xe6xb5xb7xe6xb4x8b'
  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'xe4xb8xadxe5x9bxbd'

    # str ---> bytes
    s1 = '中国'
    b1 = s1.encode('utf-8')  # 编码
    print(b1,type(b1))  # b'xe4xb8xadxe5x9bxbd'
    #b1 = s1.encode('gbk')  # 编码  # b'xd6xd0xb9xfa' <class 'bytes'>
    
    # bytes---->str
    b1 = b'xe4xb8xadxe5x9bxbd'
    s2 = b1.decode('utf-8')  # 解码
    print(s2)
    

    # gbk ---> utf-8
    b1 = b'xd6xd0xb9xfa'
    s = b1.decode('gbk')
    # print(s)
    b2 = s.encode('utf-8')
    print(b2)  # b'xe4xb8xadxe5x9bxbd'