常见数据类型及其转换

常见的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)'