Python杂记-类型转换

#整数到浮点数
int_num = 10
float_num = float(int_num)

#浮点数到整数
float_num = 10.6
int_num = int(float_num)  # 小数部分将被截断

#字符串到整数
str_num = "123"
int_num = int(str_num)

#字符串到浮点数
str_float = "123.45"
float_num = float(str_float)

#整数到字符串
int_num = 456
str_num = str(int_num)

#浮点数到字符串
float_num = 78.90
str_num = str(float_num)

#布尔值到整数
bool_value = True
int_value = int(bool_value)  # True 转换为 1

#列表到元组
list_items = [1, 2, 3]
tuple_items = tuple(list_items)

#元组到列表
tuple_items = (4, 5, 6)
list_items = list(tuple_items)

#集合到列表
set_items = {7, 8, 9}
list_items = list(set_items)

#列表到集合
list_items = [10, 11, 12, 10]
set_items = set(list_items)  # 集合中不允许重复元素

#字典到列表
dict_items = {'a': 1, 'b': 2}
list_items = list(dict_items.items())

#列表到字典
list_items = [('x', 1), ('y', 2)]
dict_items = dict(list_items)

#字典到集合
dict_items = {'a': 1, 'b': 2}
set_items = set(dict_items.keys())

#字符串到字典
import ast
str_dict = "{'key1': 'value1', 'key2': 'value2'}"
dict_obj = ast.literal_eval(str_dict)
#或者如果字符串是JSON格式
import json
json_str = '{"key1": "value1", "key2": "value2"}'
dict_obj = json.loads(json_str)

#列表转换为字符串
my_list = [1, 2, 3]
my_str = str(my_list)  # "[1, 2, 3]"

#字符串转换为列表
my_str = "a,b,c"
my_list = my_str.split(',')  # ['a', 'b', 'c']

#字符串转换为列表
my_str = "hello"
my_list = [char for char in my_str]  # ['h', 'e', 'l', 'l', 'o']

#字典到集合（仅键）
my_dict = {'a': 1, 'b': 2}
my_set = set(my_dict.keys())

#字典到集合（仅值）
my_dict = {'a': 1, 'b': 2}
my_set = set(my_dict.values())

#字典到集合（键值对）
my_dict = {'a': 1, 'b': 2}
my_set = set(my_dict.items())

#字典到JSON字符串（美化格式）
import json
my_dict = {'a': 1, 'b': 2}
my_json_pretty = json.dumps(my_dict, indent=4)

#JSON字符串到字典（忽略null）
import json
json_str = '{"a": 1, "b": null}'
my_dict = json.loads(json_str)  # null会被转换为None

#列表到集合（去重）
my_list = [1, 2, 2, 3, 3]
my_set = set(my_list)  # 去除重复元素

#集合到列表（排序）
my_set = {3, 1, 2}
my_list = sorted(list(my_set))  # 排序后的列表

#浮点数到二进制字符串
my_float = 3.5
my_binary_str = format(my_float, '.8f')  # 格式化为8位精度的二进制字符串

#二进制字符串到浮点数
my_binary_str = '011.1'
my_float = float.fromhex(my_binary_str)  # 假设二进制字符串是十六进制表示

#整数到二进制字符串
my_int = 10
my_binary_str = bin(my_int)[2:]  # 去掉前缀'0b'

#二进制字符串到整数
my_binary_str = '1010'
my_int = int(my_binary_str, 2)  # 指定基数为2
 
#十六进制字符串到整数
my_hex_str = 'A'
my_int = int(my_hex_str, 16)  # 指定基数为16

#整数到十六进制字符串
my_int = 10
my_hex_str = hex(my_int)[2:]  # 去掉前缀'0x'

#布尔值到字符串
my_bool = True
my_str = str(my_bool)  # "True" 或 "False"

#字符串到布尔值
my_str = 'True'
my_bool = my_str == 'True'  # 根据需要进行适当的逻辑判断

#列表到字符串（特定分隔符）
my_list = ['a', 'b', 'c']
my_str = ':'.join(my_list)  # 使用':'作为分隔符

#字符串到列表（特定分隔符）
my_str = 'a:b:c'
my_list = my_str.split(':')  # 使用':'作为分隔符

#元组到字符串
my_tuple = (1, 2, 3)
my_str = str(my_tuple)  # "(1, 2, 3)"

#字符串到元组
my_str = '1,2,3'
my_tuple = tuple(map(int, my_str.split(',')))

#字典到字符串（键值对排序）
my_dict = {'b': 2, 'a': 1}
my_str = str(sorted(my_dict.items()))  # 将键值对排序

#字典到字符串（格式化输出）
my_dict = {'a': 1, 'b': 2}
my_str = ' '.join(f"{k}={v}" for k, v in my_dict.items())   # "a=1 b=2"

#字符串到日期
from datetime import datetime
date_str = "2024-07-02"
my_date = datetime.strptime(date_str, "%Y-%m-%d")

#日期到字符串
my_date = datetime(2024, 7, 2)
date_str = my_date.strftime("%Y-%m-%d")

#时间戳到日期
import time
timestamp = time.time()
my_date = datetime.fromtimestamp(timestamp)

#日期到时间戳
my_date = datetime(2024, 7, 2)
timestamp = int(my_date.timestamp())

#复数到字符串
my_complex = 1 + 2j
my_str = str(my_complex)

#字符串到复数
my_str = "1+2j"
my_complex = complex(my_str)

#列表到集合（保持列表顺序）
from collections import OrderedDict
my_list = [1, 2, 2, 3, 3]
my_ordered_set = list(OrderedDict.fromkeys(my_list))

#集合到列表（保持集合元素的插入顺序）
my_set = {3, 1, 2}
my_list = list(my_set)  # 从Python 3.7开始，集合保持插入顺序my_set = {3, 1, 2}
my_list = list(my_set)  # 从Python 3.7开始，集合保持插入顺序

#列表到字节串
my_list = list('hello')
my_bytes = bytes(my_list)

#字节串到列表
my_bytes = b'hello'
my_list = list(my_bytes)

#列表到字节串（编码）
my_list = ['h', 'e', 'l', 'l', 'o']
my_bytes = ''.join(my_list).encode('utf-8')

#字节串到列表（解码）
my_bytes = b'hello'
my_list = my_bytes.decode('utf-8')

#字典到字节串（序列化）
import json
my_dict = {'key1': 'value1', 'key2': 'value2'}
my_bytes = json.dumps(my_dict).encode('utf-8')

#字节串到字典（反序列化）
import json
my_bytes = b'{"key1": "value1", "key2": "value2"}'
my_dict = json.loads(my_bytes.decode('utf-8'))


#列表到文件路径
my_list = ['usr', 'bin', 'python']
my_path = os.path.join(*my_list)  # 使用os.path.join来创建跨平台的文件路径

#文件路径到列表
import os
my_path = '/usr/bin/python'
my_list = os.path.split(my_path)  # 分割路径为头部和尾部

#字典到文件（写入）
with open('data.json', 'w') as f:
    json.dump(my_dict, f)


#文件到字典（读取）
with open('data.json', 'r') as f:
    my_dict = json.load(f)


#异常信息到字符串
try:
    1 / 0
except Exception as e:
    my_str = str(e)

https://blog.youkuaiyun.com/zhangzx36/article/details/140191833