Python数字类型转换为字符串类型的多种实现方式

age = 28
print("Your age is: " + age)  # ❌ 这将引发TypeError!

age = 28
print("Your age is: " + str(age))  # ✅ 输出: Your age is: 28

import json
data = {"price": 19.99, "quantity": 5}
# JSON要求所有键值对都必须是字符串或其他JSON兼容类型
json_str = json.dumps(data)
print(json_str)  # 输出: {"price": 19.99, "quantity": 5}

revenue = 1234567.89
formatted = f"${revenue:,.2f}"  # 添加美元符号、千位分隔符和两位小数
print(formatted)  # 输出: $1,234,567.89 💰

num = 12345
# 检查数字是否包含特定数字序列
if "23" in str(num):
    print("Found sequence!")  # ✅ 会输出

# 整数转字符串
int_num = 42
str_int = str(int_num)
print(f"类型: {type(str_int)}, 值: '{str_int}'")
# 输出: 类型: <class 'str'>, 值: '42'

# 浮点数转字符串
float_num = 3.1415926535
str_float = str(float_num)
print(f"浮点数转换结果: '{str_float}'")
# 输出: 浮点数转换结果: '3.1415926535'

# 布尔值转字符串
bool_val = True
str_bool = str(bool_val)
print(f"布尔值转换: '{str_bool}'")  # 输出: 布尔值转换: 'True'

# 注意：浮点数精度问题可能导致意外结果
print(str(0.1 + 0.2))  # 输出: '0.30000000000000004' 😱

print(str(None))    # 输出: 'None'
print(str(True))    # 输出: 'True'
print(str(False))   # 输出: 'False'

def generate_welcome(username, login_count):
    """生成用户欢迎消息"""
    # 使用str()确保数字被正确转换
    return f"欢迎回来, {username}! 这是您第{str(login_count)}次登录。"

# 测试函数
print(generate_welcome("Alice", 5))
# 输出: 欢迎回来, Alice! 这是您第5次登录。

num = 10
print(str(num))  # 输出: 10
print(repr(num)) # 输出: 10 (对于简单数字相同)

text = "Hello\nWorld"
print(str(text))  # 输出: Hello
                  #        World
print(repr(text)) # 输出: 'Hello\nWorld' (显示转义字符)

price = 19.99
quantity = 3
total = price * quantity

# 基本用法
print("单价: $%.2f, 数量: %d, 总价: $%.2f" % (price, quantity, total))
# 输出: 单价: $19.99, 数量: 3, 总价: $59.97

# 指定宽度和对齐
print("|%-10s|%10s|" % ("左对齐", "右对齐"))
# 输出: |左对齐      |      右对齐|

name = "Alice"
score = 95.678

# 基本位置参数
print("姓名: {}, 分数: {:.2f}".format(name, score))
# 输出: 姓名: Alice, 分数: 95.68

# 命名参数（更清晰）
print("姓名: {n}, 分数: {s:.2f}".format(n=name, s=score))
# 输出: 姓名: Alice, 分数: 95.68

# 索引参数（控制顺序）
print("分数: {1:.1f}, 姓名: {0}".format(name, score))
# 输出: 分数: 95.7, 姓名: Alice

population = 123456789
print("人口: {:,}".format(population))  # 输出: 人口: 123,456,789 🌍

ratio = 0.753
print("比例: {:.1%}".format(ratio))  # 输出: 比例: 75.3%

num = 255
print("十进制: {0:d}, 十六进制: {0:x}, 二进制: {0:b}".format(num))
# 输出: 十进制: 255, 十六进制: ff, 二进制: 11111111

print("|{:^10}|{:<10}|{:>10}|".format("居中", "左对齐", "右对齐"))
# 输出: |   居中   |左对齐    |     右对齐|

user = "Bob"
visits = 15
revenue = 249.99

# 基本用法
print(f"用户: {user}, 访问次数: {visits}, 总消费: ${revenue:.2f}")
# 输出: 用户: Bob, 访问次数: 15, 总消费: $249.99

# 表达式支持
print(f"下次访问编号: {visits + 1}")
# 输出: 下次访问编号: 16

# 调用函数
print(f"用户名大写: {user.upper()}")
# 输出: 用户名大写: BOB

details = f"""
用户: {user}
访问次数: {visits}
消费评级: {"高" if revenue > 200 else "普通"}
"""
print(details)

x = 10
y = 20
print(f"{x=}, {y=}, {x+y=}")  
# 输出: x=10, y=20, x+y=30 (自动显示变量名和值)

from datetime import datetime
now = datetime.now()
print(f"当前时间: {now:%Y-%m-%d %H:%M:%S}")
# 输出示例: 当前时间: 2023-10-05 14:30:45

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price
    
    def __format__(self, format_spec):
        if format_spec == "detail":
            return f"{self.name} (${self.price:.2f})"
        return f"{self.name}"

prod = Product("Laptop", 1299.99)
print(f"产品: {prod:detail}")  # 输出: 产品: Laptop ($1299.99)

import timeit

# 测试环境准备
setup = "num = 12345.6789"

# 测试str()
str_time = timeit.timeit('str(num)', setup=setup, number=1000000)

# 测试%格式化
percent_time = timeit.timeit('"%.2f" % num', setup=setup, number=1000000)

# 测试str.format()
format_time = timeit.timeit('" {:.2f}".format(num)', setup=setup, number=1000000)

# 测试f-string
fstring_time = timeit.timeit('f"{num:.2f}"', setup=setup, number=1000000)

print(f"str()      : {str_time:.6f} 秒")
print(f"%格式化    : {percent_time:.6f} 秒")
print(f"str.format: {format_time:.6f} 秒")
print(f"f-string   : {fstring_time:.6f} 秒")

str()      : 0.085234 秒
%格式化    : 0.187652 秒
str.format: 0.213456 秒
f-string   : 0.078912 秒

decimal_num = 255

# 二进制 (前缀0b)
binary_str = bin(decimal_num)
print(f"二进制: {binary_str}")  # 输出: 0b11111111
# 去掉前缀
print(f"无前缀二进制: {binary_str[2:]}")  # 输出: 11111111

# 八进制 (前缀0o)
octal_str = oct(decimal_num)
print(f"八进制: {octal_str}")  # 输出: 0o377

# 十六进制 (前缀0x)
hex_str = hex(decimal_num)
print(f"十六进制: {hex_str}")  # 输出: 0xff

# 使用格式化获取无前缀结果
print(f"格式化二进制: {decimal_num:b}")  # 输出: 11111111
print(f"格式化十六进制: {decimal_num:x}") # 输出: ff
print(f"大写十六进制: {decimal_num:X}")  # 输出: FF

# 将八进制权限转换为可读形式
def format_permissions(perm_octal):
    return f"{perm_octal:o} ({perm_octal:03o})"

print(format_permissions(0o755))  # 输出: 755 (755)
print(format_permissions(0o644))  # 输出: 644 (644)

# 科学计数法
large_num = 1234567890.0
print(f"科学计数法: {large_num:.2e}")  # 输出: 1.23e+09

small_num = 0.000000123
print(f"科学计数法: {small_num:.2e}")  # 输出: 1.23e-07

# 工程表示法（指数是3的倍数）
print(f"工程表示: {large_num:.2g}")   # 输出: 1.2e+09
print(f"工程表示: {large_num:.2n}")   # 依赖区域设置，可能不同

from math import pi, e

print(f"π: {pi:.15f}")   # 高精度π: 3.141592653589793
print(f"e: {e:.5e}")     # 科学计数法e: 2.71828e+00

# 自定义科学计数法格式
def sci_notation(num, decimal_places=2):
    """自定义科学计数法格式化"""
    fmt = f"{{:.{decimal_places}e}}"
    return fmt.format(num).replace('e', '×10^')

print(sci_notation(123456789))  # 输出: 1.23×10^+08

def to_base(n, base, chars="0123456789abcdefghijklmnopqrstuvwxyz"):
    """将数字转换为任意进制字符串"""
    if n == 0:
        return chars[0]
    
    digits = []
    while n:
        n, r = divmod(n, base)
        digits.append(chars[r])
    
    return ''.join(digits[::-1])

# 测试
print(to_base(255, 16))       # 输出: ff (十六进制)
print(to_base(255, 62))       # 输出: 43 (使用0-9a-zA-Z)
print(to_base(12345, 64))     # Base64风格

import locale

# 设置区域为德语（使用逗号作为小数点，点作为千位分隔符）
locale.setlocale(locale.LC_ALL, 'de_DE.UTF-8')

revenue = 1234567.89
formatted = locale.format_string("%.2f", revenue, grouping=True)
print(f"德式格式: {formatted}")  # 输出: 1.234.567,89

# 重置区域
locale.setlocale(locale.LC_ALL, '')

print(str(0.1 + 0.2))  # 输出: '0.30000000000000004' 😱

print(f"{0.1 + 0.2:.1f}")  # 输出: 0.3

from decimal import Decimal
print(str(Decimal('0.1') + Decimal('0.2')))  # 输出: '0.3'

# 错误示例
user_input = "10.5"
int_value = int(user_input)  # ValueError: invalid literal for int() with base 10: '10.5'

def safe_float(s):
    try:
        return float(s)
    except (ValueError, TypeError):
        return 0.0

print(safe_float("10.5"))  # 输出: 10.5
print(safe_float("N/A"))   # 输出: 0.0

if user_input.replace('.', '', 1).isdigit():
    num = float(user_input)

import locale
locale.setlocale(locale.LC_ALL, 'fr_FR.UTF-8')
print(f"{1234567.89:n}")  # 在法国区域可能输出 1 234 567,89

print(f"{1234567.89:,.2f}")  # 始终使用逗号作为千位分隔符

def format_currency(amount):
    """统一使用美元格式，不依赖区域设置"""
    return f"${amount:,.2f}"

# 低效示例
result = ""
for i in range(100000):
    result += str(i) + ","  # 字符串拼接在循环中效率低下

result = ",".join(str(i) for i in range(100000))

# 低效
for i in range(1000):
    print("Value: " + str(i))

# 高效
for i in range(1000):
    print(f"Value: {i}")  # f-string自动处理转换

# 危险示例！
user_input = "{exploit.__init__.__globals__[sys].os.system('rm -rf /')}"
print(f"Hello {user_input}")  # 可能执行恶意代码

# 安全做法
print("Hello {}".format(user_input))

# 在某些环境可能出错
print("€" + str(19.99))  # 欧元符号与数字拼接

euro = "\u20AC"  # Unicode欧元符号
print(f"{euro}{19.99:.2f}")

print(str(-0.0))    # 输出: -0.0
print(str(float('nan')))  # 输出: nan

def safe_str(num):
    if isinstance(num, float):
        if num != num:  # 检测NaN
            return "NaN"
        if num == float('inf'):
            return "Infinity"
        if num == float('-inf'):
            return "-Infinity"
    return str(num)

def format_financial(value, currency="USD", decimals=2):
    """格式化财务数值"""
    if currency == "USD":
        symbol = "$"
        # 美式格式：千位分隔符为逗号，小数点为点
        return f"{symbol}{value:,.{decimals}f}"
    elif currency == "EUR":
        symbol = "€"
        # 欧元格式：千位分隔符为空格，小数点为逗号
        # 注意：这里简化处理，实际应使用locale
        return f"{symbol}{value:,.{decimals}f}".replace(",", " ").replace(".", ",")
    else:
        return f"{value:,.{decimals}f} {currency}"

# 测试
print(format_financial(1234567.89, "USD"))  # 输出: $1,234,567.89
print(format_financial(1234567.89, "EUR"))  # 输出: €1 234 567,89

def to_csv_row(data):
    """将数据列表转换为CSV行"""
    def escape(value):
        # 处理需要引号包围的情况
        str_val = str(value)
        if ',' in str_val or '"' in str_val or '\n' in str_val:
            return f'"{str_val.replace("\"", "\"\"")}"'
        return str_val
    
    return ",".join(escape(item) for item in data)

# 测试
row = ["Product A", 19.99, 100, "Special, \"Limited\" Edition"]
print(to_csv_row(row))
# 输出: Product A,19.99,100,"Special, ""Limited"" Edition"

from datetime import datetime, timedelta

def generate_api_response(user_id, request_time):
    """生成API响应消息"""
    # 计算请求处理时间
    process_time = (datetime.now() - request_time).total_seconds()
    
    # 构建响应
    response = (
        f"API响应\n"
        f"用户ID: {user_id}\n"
        f"时间戳: {datetime.now():%Y-%m-%d %H:%M:%S}\n"
        f"处理耗时: {process_time:.3f}秒\n"
        f"状态: 成功"
    )
    return response

# 测试
start = datetime.now()
# 模拟处理延迟
import time; time.sleep(0.025)
print(generate_api_response(12345, start))

API响应
用户ID: 12345
时间戳: 2023-10-05 15:30:45
处理耗时: 0.025秒
状态: 成功

import matplotlib.pyplot as plt
import numpy as np

# 生成示例数据
x = np.linspace(0, 10, 100)
y = np.sin(x) * 1000000

# 创建图表
plt.figure(figsize=(10, 6))
plt.plot(x, y)

# 自定义y轴标签格式
def format_scientific(value, _):
    """科学计数法格式化函数"""
    return f"{value/1e6:.1f}M"  # 百万单位

plt.gca().yaxis.set_major_formatter(
    plt.FuncFormatter(format_scientific)
)

plt.title("正弦波振幅（百万单位）")
plt.xlabel("时间")
plt.ylabel("振幅")
plt.grid(True)
# plt.show()  # 实际使用时取消注释

import logging
from datetime import datetime

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

def process_order(order_id, amount):
    """处理订单并记录日志"""
    start_time = datetime.now()
    
    try:
        # 模拟处理
        if amount <= 0:
            raise ValueError("无效金额")
        
        # 处理逻辑...
        processing_time = (datetime.now() - start_time).total_seconds()
        
        # 格式化日志消息
        log_msg = (
            f"订单处理完成 | ID: {order_id} | "
            f"金额: ${amount:.2f} | "
            f"耗时: {processing_time*1000:.1f}ms"
        )
        logging.info(log_msg)
        return True
        
    except Exception as e:
        logging.error(
            f"订单处理失败 | ID: {order_id} | "
            f"错误: {str(e)}"
        )
        return False

# 测试
process_order(1001, 199.99)
process_order(1002, -10)

2023-10-05 15:45:30,123 - INFO - 订单处理完成 | ID: 1001 | 金额: $199.99 | 耗时: 5.2ms
2023-10-05 15:45:30,128 - ERROR - 订单处理失败 | ID: 1002 | 错误: 无效金额

def transform_data(raw_data):
    """转换原始数据为规范格式"""
    transformed = []
    
    for record in raw_data:
        try:
            # 转换数值字段
            transformed_record = {
                "id": int(record["id"]),
                "name": record["name"].strip(),
                "price": float(record["price"]),
                "quantity": int(record["quantity"]),
                "active": record["active"].lower() == "true",
                # 添加时间戳（当前时间）
                "timestamp": datetime.now().isoformat()
            }
            transformed.append(transformed_record)
        except (ValueError, KeyError) as e:
            logging.error(f"数据转换失败: {e}, 记录: {record}")
    
    return transformed

# 测试
raw = [
    {"id": "101", "name": "  Product A  ", "price": "19.99", "quantity": "5", "active": "True"},
    {"id": "102", "name": "Product B", "price": "invalid", "quantity": "3", "active": "false"}
]

print(transform_data(raw))

import timeit
import random

# 测试设置
setup = """
import random
numbers = [random.uniform(0, 1000) for _ in range(1000)]
"""

# 测试1: 简单整数转换
simple_int_test = """
for n in numbers:
    s = str(int(n))
"""

# 测试2: 带两位小数的浮点数转换
float_format_test = """
for n in numbers:
    s = f"{n:.2f}"
"""

# 测试3: 复杂格式化（货币+千位分隔符）
complex_format_test = """
for n in numbers:
    s = f"${n:,.2f}"
"""

# 运行测试
def run_test(code, number=1000):
    return timeit.timeit(code, setup=setup, number=number)

print("===== 性能基准测试 (1000次循环) =====")
print(f"简单整数转换: {run_test(simple_int_test):.4f} 秒")
print(f"浮点数格式化: {run_test(float_format_test):.4f} 秒")
print(f"复杂格式化  : {run_test(complex_format_test):.4f} 秒")

===== 性能基准测试 (1000次循环) =====
简单整数转换: 0.0452 秒
浮点数格式化: 0.0587 秒
复杂格式化  : 0.0721 秒

# 低效：不必要的转换
total = 0
for i in range(1000000):
    total += len(str(i))  # 实际只需数字长度

# 高效：直接计算位数
total = 0
for i in range(1000000):
    total += len(str(i))  # 仍然需要，但这是必要转换
    # 更高效方法（针对此特定问题）:
    # total += 1 if i < 10 else (2 if i < 100 else ...)

# 低效：O(n²)复杂度
result = ""
for i in range(10000):
    result += str(i) + ","

# 高效：O(n)复杂度
result = ",".join(str(i) for i in range(10000))

# 低效：每次循环都创建新格式字符串
for i in range(10000):
    print("Value: {:05d}".format(i))

# 高效：预编译格式字符串
fmt = "Value: {:05d}".format
for i in range(10000):
    print(fmt(i))

# 低效：列表推导式每次生成新字符串
data = [str(i) for i in range(1000000)]

# 高效：如果只是临时使用，考虑生成器表达式
data_gen = (str(i) for i in range(1000000))
# 仅在需要时转换特定元素

import sys

def memory_test():
    # 创建100万个数字
    numbers = list(range(1000000))
    
    # 方法1: 直接存储数字
    mem_nums = sys.getsizeof(numbers) + sum(sys.getsizeof(n) for n in numbers)
    
    # 方法2: 存储字符串
    str_list = [str(n) for n in numbers]
    mem_strs = sys.getsizeof(str_list) + sum(sys.getsizeof(s) for s in str_list)
    
    # 方法3: 使用生成器（不实际存储）
    str_gen = (str(n) for n in numbers)
    mem_gen = sys.getsizeof(str_gen)
    
    print(f"数字列表内存: {mem_nums/1024/1024:.2f} MB")
    print(f"字符串列表内存: {mem_strs/1024/1024:.2f} MB")
    print(f"生成器内存: {mem_gen/1024:.2f} KB")

memory_test()

数字列表内存: 8.79 MB
字符串列表内存: 45.78 MB
生成器内存: 0.08 KB

# 低效
response = "Items: " + str(len(items)) + "\n" + "\n".join(items)

# 高效（使用f-string和join）
response = f"Items: {len(items)}\n" + "\n".join(items)

# 低效：总是构建完整字符串
logging.debug("Processing item " + str(item_id) + " with value " + str(value))

# 高效：利用logging的延迟字符串格式化
logging.debug("Processing item %d with value %f", item_id, value)

# 低效：手动构建JSON
json_str = "{" + ",".join(f'"{k}":"{v}"' for k,v in data.items()) + "}"

# 高效：使用json模块
import json
json_str = json.dumps(data)