age = 28
print("Your age is: " + age)  # ? 這將引發(fā)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}"  # 添加美元符號、千位分隔符和兩位小數(shù)
print(formatted)  # 輸出: $1,234,567.89 ??

num = 12345
# 檢查數(shù)字是否包含特定數(shù)字序列
if "23" in str(num):
    print("Found sequence!")  # ? 會輸出

# 整數(shù)轉(zhuǎn)字符串
int_num = 42
str_int = str(int_num)
print(f"類型: {type(str_int)}, 值: '{str_int}'")
# 輸出: 類型: <class 'str'>, 值: '42'

# 浮點數(shù)轉(zhuǎn)字符串
float_num = 3.1415926535
str_float = str(float_num)
print(f"浮點數(shù)轉(zhuǎn)換結(jié)果: '{str_float}'")
# 輸出: 浮點數(shù)轉(zhuǎn)換結(jié)果: '3.1415926535'

# 布爾值轉(zhuǎn)字符串
bool_val = True
str_bool = str(bool_val)
print(f"布爾值轉(zhuǎn)換: '{str_bool}'")  # 輸出: 布爾值轉(zhuǎn)換: 'True'

# 注意：浮點數(shù)精度問題可能導(dǎo)致意外結(jié)果
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()確保數(shù)字被正確轉(zhuǎn)換
    return f"歡迎回來, {username}! 這是您第{str(login_count)}次登錄。"

# 測試函數(shù)
print(generate_welcome("Alice", 5))
# 輸出: 歡迎回來, Alice! 這是您第5次登錄。

num = 10
print(str(num))  # 輸出: 10
print(repr(num)) # 輸出: 10 (對于簡單數(shù)字相同)

text = "Hello\nWorld"
print(str(text))  # 輸出: Hello
                  #        World
print(repr(text)) # 輸出: 'Hello\nWorld' (顯示轉(zhuǎn)義字符)

price = 19.99
quantity = 3
total = price * quantity

# 基本用法
print("單價: $%.2f, 數(shù)量: %d, 總價: $%.2f" % (price, quantity, total))
# 輸出: 單價: $19.99, 數(shù)量: 3, 總價: $59.97

# 指定寬度和對齊
print("|%-10s|%10s|" % ("左對齊", "右對齊"))
# 輸出: |左對齊      |      右對齊|

name = "Alice"
score = 95.678

# 基本位置參數(shù)
print("姓名: {}, 分數(shù): {:.2f}".format(name, score))
# 輸出: 姓名: Alice, 分數(shù): 95.68

# 命名參數(shù)（更清晰）
print("姓名: {n}, 分數(shù): {s:.2f}".format(n=name, s=score))
# 輸出: 姓名: Alice, 分數(shù): 95.68

# 索引參數(shù)（控制順序）
print("分數(shù): {1:.1f}, 姓名: {0}".format(name, score))
# 輸出: 分數(shù): 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}, 訪問次數(shù): {visits}, 總消費: ${revenue:.2f}")
# 輸出: 用戶: Bob, 訪問次數(shù): 15, 總消費: $249.99

# 表達式支持
print(f"下次訪問編號: {visits + 1}")
# 輸出: 下次訪問編號: 16

# 調(diào)用函數(shù)
print(f"用戶名大寫: {user.upper()}")
# 輸出: 用戶名大寫: BOB

details = f"""
用戶: {user}
訪問次數(shù): {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"產(chǎn)品: {prod:detail}")  # 輸出: 產(chǎn)品: Laptop ($1299.99)

import timeit

# 測試環(huán)境準備
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

# 使用格式化獲取無前綴結(jié)果
print(f"格式化二進制: {decimal_num:b}")  # 輸出: 11111111
print(f"格式化十六進制: {decimal_num:x}") # 輸出: ff
print(f"大寫十六進制: {decimal_num:X}")  # 輸出: FF

# 將八進制權(quán)限轉(zhuǎn)換為可讀形式
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)

# 科學(xué)計數(shù)法
large_num = 1234567890.0
print(f"科學(xué)計數(shù)法: {large_num:.2e}")  # 輸出: 1.23e+09

small_num = 0.000000123
print(f"科學(xué)計數(shù)法: {small_num:.2e}")  # 輸出: 1.23e-07

# 工程表示法（指數(shù)是3的倍數(shù)）
print(f"工程表示: {large_num:.2g}")   # 輸出: 1.2e+09
print(f"工程表示: {large_num:.2n}")   # 依賴區(qū)域設(shè)置，可能不同

from math import pi, e

print(f"π: {pi:.15f}")   # 高精度π: 3.141592653589793
print(f"e: {e:.5e}")     # 科學(xué)計數(shù)法e: 2.71828e+00

# 自定義科學(xué)計數(shù)法格式
def sci_notation(num, decimal_places=2):
    """自定義科學(xué)計數(shù)法格式化"""
    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"):
    """將數(shù)字轉(zhuǎn)換為任意進制字符串"""
    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風(fēng)格

import locale

# 設(shè)置區(qū)域為德語（使用逗號作為小數(shù)點，點作為千位分隔符）
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

# 重置區(qū)域
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}")  # 在法國區(qū)域可能輸出 1 234 567,89

print(f"{1234567.89:,.2f}")  # 始終使用逗號作為千位分隔符

def format_currency(amount):
    """統(tǒng)一使用美元格式，不依賴區(qū)域設(shè)置"""
    return f"${amount:,.2f}"

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

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自動處理轉(zhuǎn)換

# 危險示例！
user_input = "{exploit.__init__.__globals__[sys].os.system('rm -rf /')}"
print(f"Hello {user_input}")  # 可能執(zhí)行惡意代碼

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

# 在某些環(huán)境可能出錯
print("€" + str(19.99))  # 歐元符號與數(shù)字拼接

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):
    """格式化財務(wù)數(shù)值"""
    if currency == "USD":
        symbol = "$"
        # 美式格式：千位分隔符為逗號，小數(shù)點為點
        return f"{symbol}{value:,.{decimals}f}"
    elif currency == "EUR":
        symbol = "€"
        # 歐元格式：千位分隔符為空格，小數(shù)點為逗號
        # 注意：這里簡化處理，實際應(yīng)使用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):
    """將數(shù)據(jù)列表轉(zhuǎn)換為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響應(yīng)消息"""
    # 計算請求處理時間
    process_time = (datetime.now() - request_time).total_seconds()
    
    # 構(gòu)建響應(yīng)
    response = (
        f"API響應(yīng)\n"
        f"用戶ID: {user_id}\n"
        f"時間戳: {datetime.now():%Y-%m-%d %H:%M:%S}\n"
        f"處理耗時: {process_time:.3f}秒\n"
        f"狀態(tài): 成功"
    )
    return response

# 測試
start = datetime.now()
# 模擬處理延遲
import time; time.sleep(0.025)
print(generate_api_response(12345, start))

API響應(yīng)
用戶ID: 12345
時間戳: 2023-10-05 15:30:45
處理耗時: 0.025秒
狀態(tài): 成功

import matplotlib.pyplot as plt
import numpy as np

# 生成示例數(shù)據(jù)
x = np.linspace(0, 10, 100)
y = np.sin(x) * 1000000

# 創(chuàng)建圖表
plt.figure(figsize=(10, 6))
plt.plot(x, y)

# 自定義y軸標簽格式
def format_scientific(value, _):
    """科學(xué)計數(shù)法格式化函數(shù)"""
    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):
    """轉(zhuǎn)換原始數(shù)據(jù)為規(guī)范格式"""
    transformed = []
    
    for record in raw_data:
        try:
            # 轉(zhuǎn)換數(shù)值字段
            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"數(shù)據(jù)轉(zhuǎn)換失敗: {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

# 測試設(shè)置
setup = """
import random
numbers = [random.uniform(0, 1000) for _ in range(1000)]
"""

# 測試1: 簡單整數(shù)轉(zhuǎn)換
simple_int_test = """
for n in numbers:
    s = str(int(n))
"""

# 測試2: 帶兩位小數(shù)的浮點數(shù)轉(zhuǎn)換
float_format_test = """
for n in numbers:
    s = f"{n:.2f}"
"""

# 測試3: 復(fù)雜格式化（貨幣+千位分隔符）
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次循環(huán)) =====")
print(f"簡單整數(shù)轉(zhuǎn)換: {run_test(simple_int_test):.4f} 秒")
print(f"浮點數(shù)格式化: {run_test(float_format_test):.4f} 秒")
print(f"復(fù)雜格式化  : {run_test(complex_format_test):.4f} 秒")

===== 性能基準測試 (1000次循環(huán)) =====
簡單整數(shù)轉(zhuǎn)換: 0.0452 秒
浮點數(shù)格式化: 0.0587 秒
復(fù)雜格式化  : 0.0721 秒

# 低效：不必要的轉(zhuǎn)換
total = 0
for i in range(1000000):
    total += len(str(i))  # 實際只需數(shù)字長度

# 高效：直接計算位數(shù)
total = 0
for i in range(1000000):
    total += len(str(i))  # 仍然需要，但這是必要轉(zhuǎn)換
    # 更高效方法（針對此特定問題）:
    # total += 1 if i < 10 else (2 if i < 100 else ...)

# 低效：O(n2)復(fù)雜度
result = ""
for i in range(10000):
    result += str(i) + ","

# 高效：O(n)復(fù)雜度
result = ",".join(str(i) for i in range(10000))

# 低效：每次循環(huán)都創(chuàng)建新格式字符串
for i in range(10000):
    print("Value: {:05d}".format(i))

# 高效：預(yù)編譯格式字符串
fmt = "Value: {:05d}".format
for i in range(10000):
    print(fmt(i))

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

# 高效：如果只是臨時使用，考慮生成器表達式
data_gen = (str(i) for i in range(1000000))
# 僅在需要時轉(zhuǎn)換特定元素

import sys

def memory_test():
    # 創(chuàng)建100萬個數(shù)字
    numbers = list(range(1000000))
    
    # 方法1: 直接存儲數(shù)字
    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"數(shù)字列表內(nèi)存: {mem_nums/1024/1024:.2f} MB")
    print(f"字符串列表內(nèi)存: {mem_strs/1024/1024:.2f} MB")
    print(f"生成器內(nèi)存: {mem_gen/1024:.2f} KB")

memory_test()

數(shù)字列表內(nèi)存: 8.79 MB
字符串列表內(nèi)存: 45.78 MB
生成器內(nèi)存: 0.08 KB

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

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

# 低效：總是構(gòu)建完整字符串
logging.debug("Processing item " + str(item_id) + " with value " + str(value))

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

# 低效：手動構(gòu)建JSON
json_str = "{" + ",".join(f'"{k}":"{v}"' for k,v in data.items()) + "}"

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