# 基礎(chǔ)字符串連接
name = "Alice"
age = 30
message = "Name: " + name + ", Age: " + str(age)
print(message)  # "Name: Alice, Age: 30"

# 隱式連接技巧
long_text = ("This is an implicit "
             "string concatenation "
             "technique")

# 低效做法（O(n2)時(shí)間復(fù)雜度）
result = ""
for i in range(10000):
    result += str(i)  # 每次迭代創(chuàng)建新字符串

# 基礎(chǔ)列表連接
words = ["Python", "is", "awesome"]
sentence = " ".join(words)  # "Python is awesome"

# 帶條件過濾的連接
names = ["Alice", None, "Bob", ""]
valid_names = "|".join(filter(None, names))  # "Alice|Bob"

# 自定義分隔符
ip = "192.168.1.1"
octets = ip.split(".")
hex_ip = ":".join(f"{int(o):02X}" for o in octets)  # "C0:A8:01:01"

import os

# 大型目錄結(jié)構(gòu)連接
def get_directory_tree(path):
    """生成目錄樹字符串"""
    return "\n".join(
        f"{root[len(path):]}/" + f if f else ""
        for root, dirs, files in os.walk(path)
        for f in files
    )

# 惰性求值連接
big_data = (str(x) for x in range(1000000))
result = "".join(big_data)  # 僅占用線性內(nèi)存

from io import StringIO

def process_logs(log_files):
    """高效合并大型日志文件"""
    output = StringIO()
    
    for file_path in log_files:
        with open(file_path, "r") as f:
            # 直接寫入內(nèi)存緩沖區(qū)
            output.write(f.read())
            
            # 添加文件分隔標(biāo)記
            output.write("\n" + "=" * 80 + "\n")
    
    # 最終獲取完整字符串
    return output.getvalue()

# 使用示例
logs = ["system.log", "app.log", "network.log"]
combined_log = process_logs(logs)

# 表達(dá)式內(nèi)嵌
user = {"name": "Alice", "score": 95.5}
report = f"{user['name']} scored {user['score']} points (Rating: {'A+' if user['score'] > 90 else 'A'})"

# 格式控制
import math
print(f"π ≈ {math.pi:.5f}")  # "π ≈ 3.14159"

# 多行對齊
name = "Bob"
address = "123 Main St"
print(f"""
    Name:   {name:>10}
    Address:{address:>10}
""")

# 模板化批量生成
template = "Name: {name} | Age: {age} | Score: {score:.2f}"

users = [
    {"name": "Alice", "age": 28, "score": 95.5},
    {"name": "Bob", "age": 32, "score": 88.3},
    {"name": "Charlie", "age": 25, "score": 91.8}
]

# 批量格式化
reports = "\n".join(template.format_map(user) for user in users)
print(reports)
"""
Name: Alice | Age: 28 | Score: 95.50
Name: Bob | Age: 32 | Score: 88.30
Name: Charlie | Age: 25 | Score: 91.80
"""

import os

# 安全跨平臺路徑連接
base = "/var/log"
subdir = "app"
filename = "system.log"

full_path = os.path.join(base, subdir, filename)
print(full_path)  # "/var/log/app/system.log"

# 環(huán)境變量處理
home = os.environ.get("HOME", "/tmp")
log_dir = os.path.join(home, "logs")

from pathlib import Path

# 路徑對象連接
base = Path("/var/log")
config_file = base / "app" / "config.yaml"

# 鏈?zhǔn)讲僮?
content = (Path.home() / "data" / "2024").with_suffix(".csv").read_text()

# 批量處理
csv_dir = Path("data/csv")
all_files = "\n".join(str(p) for p in csv_dir.glob("*.csv"))

def build_http_request(headers, body=""):
    """高效構(gòu)建HTTP請求報(bào)文"""
    lines = ["POST /api HTTP/1.1"]
    
    # 添加標(biāo)頭
    lines.extend(f"{k}: {v}" for k, v in headers.items())
    
    # 添加內(nèi)容長度
    if body:
        lines.append(f"Content-Length: {len(body)}")
    
    # 添加空行分隔
    lines.append("")
    
    # 組合請求
    return "\r\n".join(lines) + body

# 使用示例
headers = {
    "Host": "api.example.com",
    "Content-Type": "application/json"
}
body = '{"key": "value"}'
request = build_http_request(headers, body)

def build_websocket_frame(payload, opcode=0x1):
    """構(gòu)建Websocket數(shù)據(jù)幀"""
    # 幀頭
    header = bytearray()
    header.append(0x80 | opcode)  # FIN + opcode
    
    # 載荷長度處理
    payload_len = len(payload)
    if payload_len <= 125:
        header.append(payload_len)
    elif payload_len <= 65535:
        header.append(126)
        header.extend(payload_len.to_bytes(2, 'big'))
    else:
        header.append(127)
        header.extend(payload_len.to_bytes(8, 'big'))
    
    # 組合數(shù)據(jù)幀
    return header + payload

# 使用示例
data = "Python WebSocket".encode('utf-8')
frame = build_websocket_frame(data)

import logging

class BufferedLogHandler(logging.Handler):
    """緩沖區(qū)日志處理器"""
    def __init__(self, capacity=1000):
        super().__init__()
        self.buffer = []
        self.capacity = capacity
        
    def emit(self, record):
        log_entry = self.format(record)
        self.buffer.append(log_entry)
        
        # 達(dá)到閾值時(shí)批量寫入
        if len(self.buffer) >= self.capacity:
            self.flush()
    
    def flush(self):
        if not self.buffer:
            return
            
        # 批量連接寫入
        with open("app.log", "a") as f:
            f.write("\n".join(self.buffer) + "\n")
        self.buffer = []

# 配置
logger = logging.getLogger("app")
logger.addHandler(BufferedLogHandler(capacity=500))
logger.setLevel(logging.INFO)

from datetime import datetime

class StructuredFormatter(logging.Formatter):
    """結(jié)構(gòu)化日志格式化器"""
    def format(self, record):
        timestamp = datetime.utcnow().isoformat()
        return "|".join([
            timestamp,
            record.levelname,
            record.name,
            record.getMessage()
        ])

# 使用示例
formatter = StructuredFormatter()
handler = logging.StreamHandler()
handler.setFormatter(formatter)

logger = logging.getLogger("app")
logger.addHandler(handler)
logger.info("System started")
# 輸出: "2024-05-01T12:34:56.789|INFO|app|System started"

def optimized_concatenation():
    """通過字節(jié)碼優(yōu)化提升性能"""
    # CPython在函數(shù)內(nèi)部優(yōu)化簡單的+連接
    s = "Data: "
    s += "A" * 1000
    s += "B" * 1000
    return s

# 性能對比測試
import dis
dis.dis(optimized_concatenation)  # 查看優(yōu)化的字節(jié)碼

import array

def high_performance_join(items):
    """高性能固定寬度數(shù)據(jù)連接"""
    # 預(yù)分配數(shù)組
    buf = array.array('u', ' ' * (len(items) * 15))
    
    # 直接操作緩沖區(qū)
    offset = 0
    for item in items:
        item_str = str(item)
        length = len(item_str)
        buf[offset:offset+length] = array.array('u', item_str)
        offset += length + 1  # +1 for separator
        buf[offset-1] = '|'  # 設(shè)置分隔符
    
    # 轉(zhuǎn)換為字符串
    return buf.tounicode().rstrip('|')

# 10萬次操作速度比join快2倍

# 先轉(zhuǎn)為本地變量再連接
count = 1000
message = f"Processing {count} records"

# 錯(cuò)誤做法
for item in big_list:
    log.write(str(item) + "\n")

# 正確做法
log.write("\n".join(str(item) for item in big_list))

# 低效
data = [1, "text", 3.14]
result = "".join(map(str, data))

# 高效（類型分發(fā)）
def to_str(x):
    if isinstance(x, float):
        return f"{x:.2f}"
    return str(x)

result = "".join(to_str(x) for x in data)

# 分塊處理大型數(shù)據(jù)集
CHUNK_SIZE = 10000
output = []
for i in range(0, len(huge_list), CHUNK_SIZE):
    chunk = huge_list[i:i+CHUNK_SIZE]
    output.append(",".join(chunk))

# 最終結(jié)果
final_result = "\n".join(output)

import re
# 預(yù)編譯正則
INT_PATTERN = re.compile(r"\d+")
text = "id123 nameAlice score95"

# 高效提取與連接
parts = INT_PATTERN.findall(text)
ids = "_".join(parts)  # "123_95"

import cProfile

def test_join_performance():
    data = [str(i) for i in range(1000000)]
    "".join(data)

if __name__ == "__main__":
    cProfile.run("test_join_performance()", sort="cumulative")