常见数据类型及其转换

合集 - python(99)

1.python基础之注释2023-06-272.python语言学习路线（基础）2023-06-263.python源码结构2023-06-264.python发展史及python应用场景2023-06-265.变量2023-06-286.bug及debug2023-06-29

7.常见数据类型及其转换2023-06-30

8.字符串格式化2023-06-309.转义符2023-06-3010.字符串在货币、日期、精度的处理2023-07-0111.字符编解码2023-07-0112.字符编解码及其相互转换2023-07-0113.内置函数-help-帮助文档2023-07-0114.内置函数print-输出2023-07-0315.内置函数input2023-07-0316.运算符2023-07-0417.int的缓存策略（特别容易混）2023-07-0418.判断语句2023-07-0419.random模块2023-07-0420.判断语句+ random的应用-剪刀石头布游戏2023-07-0421.三元运算符（if else的简写）2023-07-0422.循环语句-while2023-07-0523.循环语句-while-练习题2023-07-0524.循环语句for循环2023-07-0525.循环语句 + else2023-07-0526.字符串类str2023-07-0627.正则在字符串中的简单应用2023-07-0628.列表（List）2023-07-0729.列表list的sort方法的坑2023-07-0730.列表综合应用-8个教室随机分配到3个教室2023-07-0831.元组2023-07-0832.自动组包 & 自动解包2023-07-0833.字典2023-07-0834.集合2023-07-0835.公共操作2023-07-0836.公共操作-推导式（集合、列表、字典）2023-07-0837.函数定义、调用、闭包2023-07-0838.拆包和交换变量值2023-07-0939.函数的变量作用域、返回值、参数2023-07-0940.函数递归2023-07-0941.匿名函数（lambda表达式）012023-07-0942.内置函数abs2023-07-0943.内置函数round2023-07-0944.内置函数abs022023-07-0945.高阶函数2023-07-0946.内置高阶函数map2023-07-0947.内置高阶函数reduce2023-07-0948.内置函数reduce2023-07-0949.学生管理系统-函数&循环&运算符综合练习2023-07-0950.文件操作之语法2023-07-1051.文件操作2-最佳实践2023-07-1152.文件操作之seek2023-07-1153.文件及文件夹操作2023-07-1154.面向对象基本概念2023-07-1255.面向对象之类、对象的定义2023-07-1256.添加和获取对象属性2023-07-1257.面向对象之魔法方法2023-07-1258.魔法函数 __repr__() 和 __str__()的区别2023-07-1259.魔法方法__len__2023-07-1260.魔法方法之__getitem__(self, key)、__setitem__(self, key, value) 和 __delitem__(self, key) 2023-07-1261.魔法方法之__iter__(self) && __next__(self)2023-07-1762.TypeError: iter() returned non-iterator of type 'MyIterable'2023-07-1763.魔法方法之__contains__()2023-07-1764.魔法方法之__call__2023-07-1765.魔法方法之__getattr__(), __setattr__(), 和 __delattr__2023-07-1866.__eq__(), __lt__(), 和 __gt__() 2023-07-1867.案例：烤地瓜2023-07-1868.案例：给房子置办家具2023-07-1969.继承2023-07-1970.继承之子类复用父类的属性、方法2023-07-1971.继承的分类2023-07-1972.MRO2023-07-1973.继承之子类重写父类同名属性和方法2023-07-1974.⼦类调⽤⽗类的同名⽅法和属性2023-07-1975.私有属性&&方法的定义&访问限制2023-07-1976.setter&getter方法访问私有属性2023-07-2077.__mro__属性2023-07-2078.python 面向对象3大特征详解2023-07-2079. 类属性和实例属性2023-07-2180.类属性和实例属性最佳实践2023-07-2181.类方法2023-07-2182.静态方法2023-07-2183.异常基础2023-07-2184.多组异常处理基础2023-07-2285.多组异常处理2023-07-2286.使用Python内置的错误信息2023-07-2287.捕获所有异常2023-07-2288.手动抛异常（raise）2023-07-2289.try-except-else-finally2023-07-2290.断言assert在异常中应用2023-07-2291.自定义异常类2023-07-2292.模块2023-07-2393.常见的5种模块导入2023-07-2394.模块的定位顺序2023-07-2395.__all__变量限制、明确导入范围2023-07-2396.包2023-07-2397.时间模块datetime2023-07-2398.多任务编程之并发、并行概念2023-07-2399.进程实现多任务（进程概念、单进程、多进程执行多任务）2023-07-23

收起

常见的9种数据类型

1. 整型（int）

2. 浮点型（float）

3. 布尔型（bool）

4. 复数类型（complex）

5. 字符串（str）

6. 列表（list）

7. 元组（tuple）

8. 集合（set）

9. 字典（dict）

示例：

'''
常用数据类型
'''

# 1. 整形,int表示一个类，是所有整型的类
num_int = 88
print(type(num_int))  # <class 'int'>
print(int, type(int))  # <class 'int'> <class 'type'>

# 2. 浮点型，float表示一个类，代表所有浮点数的类
num_float = 66.6666
print(type(num_float))  # <class 'float'>
print(float, type(float))  # <class 'float'> <class 'type'>

# 3. 字符串,str表示字符串类
first_str = '程序猿'
print(type(first_str))  # <class 'str'>
print(str, type(str))  # <class 'str'> <class 'type'>

# 4. 列表,list表示一个类，代表所有的列表的类
first_list = [88, num_float, first_str]
print(first_list)  # [88, 66.6666, '程序猿']
print(type(first_list))  # <class 'list'>
print(list, type(list))  # <class 'list'> <class 'type'>

# 5. 元组
first_tuple = (99, num_float, first_str, first_list)
print(first_tuple)  # (99, 66.6666, '程序猿', [88, 66.6666, '程序猿'])
print(type(first_tuple))  # <class 'tuple'>
print(tuple, type(tuple))  # <class 'tuple'> <class 'type'>

# 6. 集合
'''
哈希是一种用于快速查找和比较的数据结构，因此它要求键或元素必须是可哈希的。
作为字典的键或集合的元素必须是可哈希的。
把不能哈希的列表、元组放入集合会报如下错误：
first_set = {35, num_float, first_str, first_list, first_tuple}
Traceback (most recent call last):
  File "F:\allen_class\python\base\006数据类型.py", line 28, in <module>
    first_set = {35, num_float, first_str, first_list, first_tuple}
                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
TypeError: unhashable type: 'list'
'''
first_set = {35, num_float, first_str}
print(first_set)  # {'程序猿', 66.6666, 35},说明无序
print(type(first_set))  # <class 'set'>
print(set, type(set))  # <class 'set'> <class 'type'>

# 7. 字典，dict就代表字典类
first_dict = {'name': 'Allen', 'age': 18}
print(first_dict)  # {'name': 'Allen', 'age': 18}
print(type(first_dict))  # <class 'dict'>
print(dict, type(dict))  # <class 'dict'> <class 'type'>

# 8. 布尔，bool就代表bool类
first_bool = True
print(first_bool)  # True
print(type(first_bool))  # <class 'bool'>
print(bool, type(bool))  # <class 'bool'> <class 'type'>

# 9. 复数类型，complex就代表复合类complex
first_complex = 3 + 4j
print(first_complex)  # (3+4j)
print(type(first_complex))  # <class 'complex'>
print(complex, type(complex))  # <class 'complex'> <class 'type'>

数据类型转换

说明

就是利用int()、float()、bool() 、str() 、complex() 、list() 、tuple() 、set() 、eval()等函数对其进行处理。

 与字符串之间的转换图：

 示例：

'''
常用数据类型转换
'''

# 1. 整形与浮点型的转换
num_int = 0
print(float(num_int), type(float(num_int)))  # 0.0 <class 'float'>
# 1. 整型与字符串的转换
print(str(num_int), type(str(num_int)))  # 0 <class 'str'>
# 1. 整型与布尔类型的转换 如果整数为 0，则转换结果为 False；如果整数为非零，则转换结果为 True。
print(bool(num_int), type(bool(num_int)))  # False <class 'bool'>

# 2. 浮点型与整型的转换
num_float = 66.6666
print(int(num_float), type(int(num_float)))  # 66 <class 'int'>
# 2. 浮点型与字符串的转换
print(str(num_float), type(str(num_float)))  # 66.6666 <class 'str'>
# 2. 浮点型与布尔的转换,如果浮点数为 0.0，则转换结果为 False；如果浮点数为非零，则转换结果为 True。
print(bool(num_float), type(bool(num_float)))  # True <class 'bool'>

# 3. 字符串,str表示字符串类
first_str = '88'
# 3. 字符串转整型,必须是整型字符串，浮点都不行 first_str = '88'
print(int(first_str), type(int(first_str)))  # 88 <class 'int'>
# 3. 字符串转浮点型
print(float(first_str), type(float(first_str)))  # 88.0 <class 'float'>
# 3. 字符串转复数类型
print(complex(first_str), type(complex(first_str)))  # (88+0j) <class 'complex'>
# 3. 字符串转布尔 空字符串（s = "" ）会转换为False，非空字符串会转换为True
print(bool(first_str), type(bool(first_str)))  # True <class 'bool'>
# 3. 字符串在条件判断中的隐式转换
if first_str:  # 隐式的类型转换规则。例如，当在条件判断语句中使用字符串时，非空字符串会被视为True，空字符串会被视为False
    print("在条件判断语句种，字符串隐式转换布尔")
# 3. eval函数实现字符串转整型、列表、元组
print(type(eval('10')))  # <class 'int'>
print(type(eval('True')))  # <class 'bool'>
print(type(eval('88.88')))  # <class 'float'>
print(type(eval('[1,2,3]')))  # <class 'list'>
print(type(eval('(1,2,3)')))  # <class 'tuple'>
print(type(eval('{1,2,3}')))  # <class 'set'>
print(type(eval('{"name":"Allen","age":18}')))  # <class 'dict'>
print(type(eval('(3+4j)')))  # <class 'complex'>
print(type(eval('3+4j')))  # <class 'complex'>

# 4. 列表
first_list = [88, num_float, first_str]
# 4. 列表转字符串--使用join()函数
my_list = ['Hello', 'World', 'Python']
my_string = ' '.join(my_list)
print(my_string)  # 输出 "Hello World Python"

my_list = ['1', '2', '3']
my_string = '-'.join(my_list)
print(my_string)  # 输出 "1-2-3"
# 4. 列表转字符串--使用列表推导式和join()函数：
my_list = [1, 2, 3]
my_string = ', '.join(str(x) for x in my_list)  # 使用列表推导式可以在将列表元素连接到字符串之前进行额外的处理
print(my_string)  # 输出 "1, 2, 3"

my_list = ['apple', 'banana', 'orange']
my_string = ', '.join(item.upper() for item in my_list)  # 使用列表推导式可以在将列表元素连接到字符串之前进行额外的处理
print(my_string)  # 输出 "APPLE, BANANA, ORANGE"

# 4. 列表转字符串--使用str()和replace()函数：
my_list = ['Hello', 'World', 'Python']
my_string = str(my_list).replace("'", "")  # 使用str()函数将列表转换为字符串，然后使用replace()函数进行字符串替换
print(my_string)  # 输出 "[Hello, World, Python]"

my_list = [1, 2, 3]
my_string = str(my_list).replace(",", "-").replace("[", "").replace("]", "")
print(my_string)  # 输出 "1- 2- 3"

# 4. 列表转元组：使用tuple()函数
my_list = ['apple', 'banana', 'orange']
my_tuple = tuple(my_list)
print(my_tuple)  # 输出 ('apple', 'banana', 'orange')

# 4. 列表转集合：set()
my_list = ['apple', 'banana', 'banana', 'orange']
my_set = set(my_list)
# 集合是无序的，并且不允许重复的元素。通过将列表传递给set()函数，列表中的元素将被复制到新的集合中，并自动去除重复项。
print(my_set)  # 输出 {'apple', 'banana', 'orange'}  # 去重

# 5. 元组
first_tuple = (99, num_float, first_str, first_list)
# 5. 元组转字符串，跟列表转字符串一样
my_tuple = ('H', 'e', 'l', 'l', 'o')
my_str = ''.join(my_tuple)
print(my_str)  # 输出 "Hello"

my_tuple = ('a', 'p', 'p', 'l', 'e')
my_str = '-'.join(my_tuple)
print(my_str)  # 输出 "a-p-p-l-e"

# 5. 元组转list：list()
my_tuple = ('apple', 'banana', 'orange')
my_list = list(my_tuple)
print(my_list)  # 输出 ['apple', 'banana', 'orange']

# 5. 元组转集合:set()
my_tuple = ('apple', 'banana', 'orange', 'apple')
my_set = set(my_tuple)
print(my_set)  # 输出 {'orange', 'apple', 'banana'} 去重

# 6. 集合
# 6. 集合转字符串：与元组、列表一样
my_set = {'apple', 'banana', 'orange'}
my_string = ', '.join(my_set)
print(my_string)  # 输出 "apple, banana, orange"

my_set = {'cat', 'dog', 'elephant'}
my_string = ' - '.join(my_set)
print(my_string)  # 输出 "cat - elephant - dog"

# 6. 集合转列表
my_set = {'apple', 'banana', 'orange'}
my_list = list(my_set)
print(my_list)  # 输出 ['apple', 'banana', 'orange']

my_set = {1, 2, 3, 4, 5}
my_list = list(my_set)
print(my_list)  # 输出 [1, 2, 3, 4, 5]

# 6. 集合转元组
my_set = {'apple', 'banana', 'orange'}
my_tuple = tuple(my_set)
print(my_tuple)  # 输出 ('apple', 'banana', 'orange')

my_set = {1, 2, 3, 4, 5}
my_tuple = tuple(my_set)
print(my_tuple)  # 输出 (1, 2, 3, 4, 5)

# 7. 字典
# 7. 字典转字符串：使用 str() 函数将字典转换为字符串
my_dict = {'name': 'John', 'age': 25, 'city': 'New York'}
my_string = str(my_dict)
print(my_string)  # 输出 "{'name': 'John', 'age': 25, 'city': 'New York'}"
# 7. 字典转字符串：使用 json.dumps() 函数将字典转换为 JSON 字符串：
import json

my_dict = {'name': 'John', 'age': 25, 'city': 'New York'}
my_string = json.dumps(my_dict)
print(my_string)  # 输出 '{"name": "John", "age": 25, "city": "New York"}'

# 7.1 json格式的字符串转字典：使用 json.loads() 函数可以将符合 JSON 格式的字符串转换为 Python 字典
import json

my_string = '{"name": "John", "age": 25, "city": "New York"}'
my_dict = json.loads(my_string)
print(my_dict)  # 输出 {'name': 'John', 'age': 25, 'city': 'New York'}
# 7.1 使用 eval() 函数将字符串转换为字典（不推荐）
# 使用 eval() 函数可以将字符串作为表达式进行求值，并将其转换为字典。但是，由于存在安全风险和潜在的副作用，不推荐使用该方法
my_string = "{'name': 'John', 'age': 25+7, 'city': 'New York'}"
my_dict = eval(my_string)
print(my_dict)  # 输出 {'name': 'John', 'age': 32, 'city': 'New York'}

# 8. 布尔
# 8. 布尔转整型
my_bool = True
my_int = int(my_bool)
print(my_int)  # 输出 1

my_bool = False
my_int = int(my_bool)
print(my_int)  # 输出 0
# 8. 布尔转浮点型
my_bool = True
my_float = float(my_bool)
print(my_float)  # 输出 1.0

my_bool = False
my_float = float(my_bool)
print(my_float)  # 输出 0.0
# 8. 布尔转字符串
print(str(my_bool))  # False

# 9. 复数类型
# 9. 复数无法直接转为整型
# 9. 复数转浮点型
my_complex = 3 + 4j
my_float = float(my_complex.real)
print(my_float)  # 输出 3.0
# 9. 复数转字符串
my_complex = 3 + 4j
my_string = str(my_complex)
print(my_string)  # 输出 '(3+4j)'