1、基本数值转换:
2、字符串转换:
3、序列转换:
- list(): 转可变列表
- tuple(): 转不可变元组
4、字典转换:
"""
Python数据类型转换详解
目的:展示Python中常见的数据类型转换方法和注意事项
"""
def numeric_conversion():
print("1. 数值类型转换")
print("-" * 50)
# 1.1 整数转换
print("1.1 转换为整数(int):")
print("-" * 30)
# 浮点数转整数:直接截断小数部分,不会四舍五入
print(f"float -> int: {int(3.14)} ← 直接截断")
print(f"float -> int: {int(-3.14)} ← 负数也是截断")
# 字符串转整数:必须是有效的数字字符串
print(f"str -> int: {int('123')} ← 普通数字字符串")
print(f"str -> int: {int('0b1111', 2)} ← 二进制字符串")
print(f"str -> int: {int('0o77', 8)} ← 八进制字符串")
print(f"str -> int: {int('0xff', 16)} ← 十六进制字符串")
# 布尔值转整数
print(f"bool -> int: True = {int(True)}, False = {int(False)}")
def float_conversion():
print("\n2. 浮点数转换")
print("-" * 50)
# 2.1 转换为浮点数(float)
print("2.1 转换为浮点数:")
print("-" * 30)
# 整数转浮点数
print(f"int -> float: {float(123)} ← 添加小数点")
# 字符串转浮点数
print(f"str -> float: {float('3.14')} ← 普通浮点数字符串")
print(f"str -> float: {float('3.14e-2')} ← 科学计数法字符串")
# 布尔值转浮点数
print(f"bool -> float: True = {float(True)}, False = {float(False)}")
def string_conversion():
print("\n3. 字符串转换")
print("-" * 50)
# 3.1 转换为字符串(str)
print("3.1 转换为字符串:")
print("-" * 30)
# 几乎所有类型都可以转换为字符串
num = 123
pi = 3.14
boolean = True
lst = [1, 2, 3]
tup = (4, 5, 6)
st = {7, 8, 9}
dic = {"a": 1, "b": 2}
# 使用str()函数转换
print(f"int -> str: {str(num)} ← 整数转字符串")
print(f"float -> str: {str(pi)} ← 浮点数转字符串")
print(f"bool -> str: {str(boolean)} ← 布尔值转字符串")
print(f"list -> str: {str(lst)} ← 列表转字符串")
print(f"tuple -> str: {str(tup)} ← 元组转字符串")
print(f"set -> str: {str(st)} ← 集合转字符串")
print(f"dict -> str: {str(dic)} ← 字典转字符串")
def list_conversion():
print("\n4. 列表转换")
print("-" * 50)
# 4.1 转换为列表(list)
print("4.1 转换为列表:")
print("-" * 30)
# 字符串转列表:每个字符成为一个元素
text = "Python"
print(f"str -> list: {list(text)} ← 字符串转列表")
# 元组转列表
tup = (1, 2, 3)
print(f"tuple -> list: {list(tup)} ← 元组转列表")
# 集合转列表
st = {4, 5, 6}
print(f"set -> list: {list(st)} ← 集合转列表")
# 字典转列表:获取所有键
dic = {"a": 1, "b": 2}
print(f"dict -> list: {list(dic)} ← 字典转列表(获取键)")
def tuple_set_conversion():
print("\n5. 元组和集合转换")
print("-" * 50)
# 5.1 转换为元组(tuple)
print("5.1 转换为元组:")
print("-" * 30)
# 列表转元组
lst = [1, 2, 3]
print(f"list -> tuple: {tuple(lst)} ← 列表转元组")
# 字符串转元组
text = "Python"
print(f"str -> tuple: {tuple(text)} ← 字符串转元组")
# 5.2 转换为集合(set)
print("\n5.2 转换为集合:")
print("-" * 30)
# 列表转集合:自动去重
lst = [1, 2, 2, 3, 3, 3]
print(f"list -> set: {set(lst)} ← 列表转集合(去重)")
# 字符串转集合:字符去重
text = "hello"
print(f"str -> set: {set(text)} ← 字符串转集合(去重)")
def dict_conversion():
print("\n6. 字典转换")
print("-" * 50)
# 6.1 转换为字典(dict)
print("6.1 转换为字典:")
print("-" * 30)
# 二元组列表转字典
pairs = [("a", 1), ("b", 2)]
print(f"list -> dict: {dict(pairs)} ← 二元组列表转字典")
# 关键字参数转字典
print(
f"keywords -> dict: {dict(a=1, b=2)} ← 关键字参数转字典"
) # 关键字参数转字典,a=1,b=2,将a,b作为键,1,2作为值,转换成字典
# 两个列表转字典(使用zip)
keys = ["a", "b", "c"]
values = [1, 2, 3]
print(
f"zip -> dict: {dict(zip(keys, values))} ← 两个列表转字典"
) # 两个列表转字典,zip函数将两个列表合并成一个二元组列表
def type_checking():
print("\n7. 类型检查技巧")
print("-" * 50)
# 7.1 类型检查方法
print("7.1 检查数据类型:")
print("-" * 30)
value = "123"
print(f"变量值: {value}")
print(f"type(): {type(value)} ← 获取类型")
print(
f"isinstance(): {isinstance(value, str)} ← 检查是否是字符串"
) # 检查变量value是否是字符串类型
# 7.2 类型转换异常处理
print("\n7.2 安全的类型转换:")
print("-" * 30)
def safe_int_convert(value):
try:
return (
int(value),
True,
) # 将变量value转换为整数,如果转换成功,返回True,否则返回False
except (ValueError, TypeError):
return None, False # 如果转换失败,返回None,False
tests = ["123", "12.34", "abc", None]
for test in tests:
result, success = safe_int_convert(test)
print(f"转换 {test}: {'成功 = ' + str(result) if success else '失败'}")
def conversion_tips():
print("\n8. 转换技巧总结")
print("-" * 50)
print("1) 数值转换:")
print(" - int():截断小数部分")
print(" - float():添加小数点")
print(" - round():四舍五入")
print("\n2) 字符串转换:")
print(" - str():几乎可转换所有类型")
print(" - f-string:格式化转换")
print("\n3) 容器类型转换:")
print(" - list():转换为可变序列")
print(" - tuple():转换为不可变序列")
print(" - set():转换并去重")
print("\n4) 注意事项:")
print(" - 总是检查输入类型")
print(" - 使用异常处理保护转换")
print(" - 注意数据精度和范围")
if __name__ == "__main__":
numeric_conversion()
float_conversion()
string_conversion()
list_conversion()
tuple_set_conversion()
dict_conversion()
type_checking()
conversion_tips()
1. 数值类型转换
--------------------------------------------------
1.1 转换为整数(int):
------------------------------
float -> int: 3 ← 直接截断
float -> int: -3 ← 负数也是截断
str -> int: 123 ← 普通数字字符串
str -> int: 15 ← 二进制字符串
str -> int: 63 ← 八进制字符串
str -> int: 255 ← 十六进制字符串
bool -> int: True = 1, False = 0
2. 浮点数转换
--------------------------------------------------
2.1 转换为浮点数:
------------------------------
int -> float: 123.0 ← 添加小数点
str -> float: 3.14 ← 普通浮点数字符串
str -> float: 0.0314 ← 科学计数法字符串
bool -> float: True = 1.0, False = 0.0
3. 字符串转换
--------------------------------------------------
3.1 转换为字符串:
------------------------------
int -> str: 123 ← 整数转字符串
float -> str: 3.14 ← 浮点数转字符串
bool -> str: True ← 布尔值转字符串
list -> str: [1, 2, 3] ← 列表转字符串
tuple -> str: (4, 5, 6) ← 元组转字符串
set -> str: {8, 9, 7} ← 集合转字符串
dict -> str: {'a': 1, 'b': 2} ← 字典转字符串
4. 列表转换
--------------------------------------------------
4.1 转换为列表:
------------------------------
str -> list: ['P', 'y', 't', 'h', 'o', 'n'] ← 字符串转列表
tuple -> list: [1, 2, 3] ← 元组转列表
set -> list: [4, 5, 6] ← 集合转列表
dict -> list: ['a', 'b'] ← 字典转列表(获取键)
5. 元组和集合转换
--------------------------------------------------
5.1 转换为元组:
------------------------------
list -> tuple: (1, 2, 3) ← 列表转元组
str -> tuple: ('P', 'y', 't', 'h', 'o', 'n') ← 字符串转元组
5.2 转换为集合:
------------------------------
list -> set: {1, 2, 3} ← 列表转集合(去重)
str -> set: {'l', 'o', 'e', 'h'} ← 字符串转集合(去重)
6. 字典转换
--------------------------------------------------
6.1 转换为字典:
------------------------------
list -> dict: {'a': 1, 'b': 2} ← 二元组列表转字典
keywords -> dict: {'a': 1, 'b': 2} ← 关键字参数转字典
zip -> dict: {'a': 1, 'b': 2, 'c': 3} ← 两个列表转字典
7. 类型检查技巧
--------------------------------------------------
7.1 检查数据类型:
------------------------------
变量值: 123
type(): <class 'str'> ← 获取类型
isinstance(): True ← 检查是否是字符串
7.2 安全的类型转换:
------------------------------
转换 123: 成功 = 123
转换 12.34: 失败
转换 abc: 失败
转换 None: 失败
8. 转换技巧总结
--------------------------------------------------
1) 数值转换:
- int():截断小数部分
- float():添加小数点
- round():四舍五入
2) 字符串转换:
- str():几乎可转换所有类型
- f-string:格式化转换
3) 容器类型转换:
- list():转换为可变序列
- tuple():转换为不可变序列
- set():转换并去重
4) 注意事项:
- 总是检查输入类型
- 使用异常处理保护转换
- 注意数据精度和范围