IT评测·应用市场-qidao123.com

标题: 04-数据类型转换 [打印本页]
作者: 曂沅仴駦    时间: 2023-2-19 02:47
标题: 04-数据类型转换
数据类型

Number - 强制类型转换(int float bool complex)

1. 强制把数据转换为整型 - int float bool 纯数字字符串
  1. # 强制把数据转换为整型 - int float bool 纯数字字符串
  2. var1 = 13
  3. var2 = 5.67
  4. var3  = True
  5. var4 = "123456"
  6. var5 = "123abc"
  7. var6 = 3+5j
  9. res = int(var2)     # 5 直接舍弃掉小数部分
  10. res = int(var3)     # True  => 1
  11. res = int(False)    # False => 0
  12. res = int(var4)
  13. # res = int(var5) error
  14. # res = int(var6) error
  15. print(res , type(res))
复制代码
2. float 强制把数据变成小数 - int float bool 纯数字字符串
  1. res = float(var1) # 13.0
  2. res = float(var3) # True  => 1.0
  3. res = float(False)# False => 0.0
  4. res = float(var4) # 123456.0
  5. print(res , type(res))
复制代码
13和13.0数值上相等,但是数据类型不同,所以不是一样的数据
3 . complex 强制把数据变成复数 - int float bool 纯数字字符串 complex
  1. res = complex(var1) # 添加0j 表达复数  13+0j
  2. res = complex(var2) # 5.67+0j
  3. res = complex(var3)  # True => 1+0j
  4. res = complex(False) # False => 0j
  5. res = complex(var4)  # 123456+0j
  6. print(res , type(res))
复制代码
4. bool 强制把数据变成布尔型 (布尔型为假的十种情况)
布尔型可以强转一切数据类型
0 0.0 False 0j "" [] {} (,) set() None
  1. # bool型为假
  2. """ 0 , 0.0 , False , 0j '' [] () set() {} None """
  3. res = bool(None)
  4. print(res , type(res))
  6. """None 代表空的,代表什么也没有,一般用于初始化变量"""
  7. a =None
  8. b =None
  10. """
  11. 默认转换成当前数据类型的一个值
  12. int() float() complex() bool()
  13. """
  14. res = bool()
  15. print(res , type(res))
复制代码
初始化变量时,不清楚用什么值,无脑写上None;None 代表空的,代表什么也没有,一般用于初始化变量
Number自动数据类型转换(int float complex bool)

低精度默认向高精度进行转换
bool -> int -> float -> complex
  1. # bool + int
  2. res = True + 100
  3. print(res ,type(res)) # 1 + 100 => 101
  5. # bool + float
  6. res = True  + 344.565 # 1.0 + 344.565 => 345.565
  7. print(res ,type(res))
  9. # bool + complex
  10. res = True + 7 - 90j  #  1 + 0j + 7 - 90j => 8 - 90j
  11. print(res ,type(res))
  13. # int + float
  14. res = 5 + 7.88 # 5.0 + 7.88 => 12.88   12.87999999,有精度上的损耗
  15. print(res ,type(res))
  17. # int + complex
  18. res = 5 + 6 + 8j # 5 + 0j   6 + 8j => 11 + 8j
  19. print(res ,type(res))
  21. # float + complex
  22. res = 5.66 + 9.1 -90j # 5.66 + 0j + 9.1 -90j => 14.76-90j
  23. print(res ,type(res))
复制代码
小数的精度损耗 (小数后面一般有时截取15~18位,但是不完全,存在精度损耗)
  1. """不要用小数作比较,比不准"""
  2. print(0.1 + 0.2 == 0.3)  //False
  3. print(5.1 + 5.9 == 11.0) //True
  4. 0.0999999999999999
复制代码
容器类型的强制转换(str list tuple set dict)

强制转换成字符串
  1. var1 = "我爱你"
  2. var2 = [1,2,3]
  3. var3 = (4,4,5)
  4. var4 = {"陈璐","上朝气","刘子涛","合理"}
  5. var5 = {"cl":"文质彬彬,斯文败类","szq":"学霸","lzt":"篮球少年","hl":"武大高手"}
  6. var6 = 90
  7. var7 = True
  10. # str 强制转换成字符串
  11. """所有的数据类型都可以转换, 在当前的数据类型两边套上引号"""
  12. res = str(var2)     # [1,2,3] 字符串类型的列表
  13. res = str(var3)     # '(4,4,5)'
  14. res = str(var4)     # '{}'
  15. res = str(var5)         
  16. res = str(var6)     # '90'
  17. res = str(var7)     # 'True'
  18. print(res ,type(res))
  19. # repr 不转义字符原型化输出字符串
  20. print(repr(res))
复制代码
强制转换成列表

如果是字符串:把字符串中的每个元素单独拿出来,作为列表中的新元素
如果是字典:只保留字典中的键
如果是其他容器数据:就是单纯的在原数据类型德两边换上[]括号
  1. res = list(var1)  #['我','爱','你']
  2. res = list(var3)
  3. res = list(var4)
  4. # 字典: 只获取字典得键,忽略掉值
  5. res = list(var5)
  6. # res = list(var6) error 只能是容器间的互转
  7. print(res ,type(res))
复制代码
tuple 强制转换成元组

如果是字符串:把字符串中的每个元素单独拿出来,作为元组中的新元素
如果是字典:  只保留字典中的键
如果是其他容器数据:就是单纯的在原数据类型得两边换上()括号
  1. res = tuple(var1)
  2. res = tuple(var2)
  3. res = tuple(var4)
  4. res = tuple(var5)
  5. print(res ,type(res))
复制代码
set 强制转换成集合

如果是字符串:把字符串中的每个元素单独拿出来,作为集合中的新元素
如果是字典:  只保留字典中的键
如果是其他容器数据:就是单纯的在原数据类型得两边换上{}括号
  1. res = set(var1)
  2. res = set(var2)
  3. res = set(var5)
  4. print(res ,type(res))
复制代码
数据类型转换应用

过滤列表中的重复数据
  1. # 多滤掉列表中所有重复元素;
  2. lst = [1,222,3,3,3,44,88,999,77,88,1]
  3. res = set(lst)
  4. print(res)
  5. # 在把当前的集合转换成原来的列表类型
  6. res2 = list(res)
  7. print(res2)
复制代码
二级容器

嵌套列表,元组,集合,字典
集合中不能套集合,集合的值和字典的键都有要求
  1. # 二级列表
  2. lst = [1,2,3,[4,5,6]]
  3. # 二级元组
  4. tup = (1,2,(10,11))
  5. # 二级集合
  6. setvar = {1,2,("a","b")}  
  7. # 二级字典
  8. dic = {"a":1,"b":{"c":10}}
  9. print(dic["b"]["c"])
复制代码
多级容器
  1. # 四级容器
  2. container = [1,2,3,(4,5,6,{"a":1,"b":[11,"bingo"]})]
  3. # (4,5,6,{"a":1,"b":[11,"bingo"]})
  4. res1 = container[-1]
  5. print(res1)
  7. # {'a': 1, 'b': [11, 'bingo']}
  8. res2 = res1[-1]
  9. print(res2)
  11. # [11, 'bingo']
  12. res3 = res2["b"]
  13. print(res3)
  15. # bingo
  16. res4 = res3[-1]
  17. print(res4)
  19. # 一步简写
  20. res = container[-1][-1]["b"][-1]
  21. print(res)
  23. # 等长的二级容器
  24. """外面是容器,里面的元素也是容器,且元素个数相同"""
  25. lst = [(1,2,3),[4,5,6],{7,8,9}]
复制代码
dict 字典类型的强制转换

要求: 必须是等长的二级容器,并且里面的元素个数是2个;
外层是列表,元组,集合 , 里层是列表或者元组的等长二级容器 => 字典;
  1. # 1.外层是列表,里层是列表或者元组
  2. lst = [ ["a",1] , ("b",2) ]
  3. dic = dict(lst)
  4. print(dic , type(dic)) # {'a': 1, 'b': 2} <class 'dict'>
  6. # 2.外层是元组,里层是列表或者元组
  7. tup = ( ["a",1] , ("b",2) )
  8. dic = dict(lst)
  9. print(dic , type(dic))
  11. # 3.外层是集合,里层是元组
  12. setvar = { ("a",1) , ("b",2) }
  13. dic = dict(setvar)
  14. print(dic , type(dic))
  16. # 例外1:外层是列表/元组,里层放集合
  17. """可以实现,不推荐使用,因为达不到想要的目的,集合无序,不推荐使用"""
  18. lst = [ ["a",1] , {"b","250"} ]
  19. dic = dict(lst)
  20. print(dic)
  22. # 例外2:外层是列表/元组,里层放字符串
  23. """ 字符串长度只能是2位,有极大的局限性,不推荐使用"""
  24. lst = ["a1","b2"]
  25. # lst = ["a11","b22"] error
  26. # dic = dict(lst)
  27. # print(dic)
复制代码
判断类型  isinstance

使用方法1
isinstance(数据,类型)
如果该数据是这个类型,返回True 反之,返回False
类型: int float complex bool str list tuple set dict
使用方法2
isinstance(  数据, (类型1,类型2,类型3...)   )
如果该数据在所对应的类型元组当中,返回True,反之,返回False
  1. # 使用方法一
  2. n = 123
  3. res = isinstance(n , int)
  4. print(res)
  6. n = [1,2,3]
  7. res = isinstance(n , list)
  8. res = isinstance(n , tuple)
  9. print(res)
  11. # 使用方法二
  12. n = "1233"
  13. res = isinstance(n , (list , tuple ,set , str)  )
  14. print(res)
  17. n = {"a":1}
  18. res = isinstance(n , (list , tuple ,set , str)  )
  19. print(res)
复制代码
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 IT评测·应用市场-qidao123.com (https://dis.qidao123.com/) Powered by Discuz! X3.4