# 基本用法
print('第一行\(zhòng)n第二行\(zhòng)n第三行')
# 第一行
# 第二行
# 第三行

# 構(gòu)建多行文本
message = '尊敬的客戶：\n您的訂單已發(fā)貨。\n預(yù)計3-5個工作日到達(dá)。\n\n祝您購物愉快！'
print(message)

# \n在字符串中的實際長度
text = 'a\nb'
print(len(text))   # 3（a、\n、b三個字符）
print(list(text))  # ['a', '\n', 'b']

# 在字符串字面量中直接換行（隱式連接）
text = ('第一行\(zhòng)n'
        '第二行\(zhòng)n'
        '第三行')
print(text)

# 寫入文件時指定換行符
with open('test.txt', 'w', newline='', encoding='utf-8') as f:
    f.write('行1\r\n行2\r\n行3\r\n')  # Windows風(fēng)格

# 讀取時Python會自動轉(zhuǎn)換（默認(rèn)newline=None）
with open('test.txt', 'r', encoding='utf-8') as f:
    content = f.read()
    # \r\n 已被自動轉(zhuǎn)換為 \n
    print(repr(content))  # '行1\n行2\n行3\n'

# splitlines() 能統(tǒng)一處理各種換行符
text = '行1\n行2\r\n行3\r行4'
print(text.splitlines())  # ['行1', '行2', '行3', '行4']

# 基本用法：用\t對齊列
print('姓名\t年齡\t城市')
print('小明\t25\t北京')
print('小紅\t23\t上海')
print('小剛\t26\t廣州')

# 問題：當(dāng)內(nèi)容長度不同時，制表符對齊可能錯亂
print('姓名\t\t年齡\t城市')
print('Alexander\t25\t北京')     # 長名字會推遠(yuǎn)下一列
print('Bob\t\t23\t上海')         # 短名字需要兩個\t
# 這就體現(xiàn)了\t的局限性——它按固定制表位跳轉(zhuǎn)，不是動態(tài)對齊

# 更好的對齊方式
print(f'{"姓名":<12}{"年齡":<8}{"城市":<10}')
print(f'{"Alexander":<12}{25:<8}{"北京":<10}')
print(f'{"Bob":<12}{23:<8}{"上海":<10}')

# 或者用\t配合str.expandtabs()來調(diào)整制表寬度
text = '姓名\t年齡\t城市\(zhòng)nAlexander\t25\t北京'
print(text.expandtabs(16))  # 將制表符擴(kuò)展為16個字符寬度

# 輸出一個反斜杠
print('\\')     # 輸出：\

# Windows文件路徑中的反斜杠
# 錯誤寫法：
# path = 'C:\Users\new\test.txt'  # \n被解析為換行，\t被解析為制表符！

# 正確寫法一：雙反斜杠
path = 'C:\\Users\\new\\test.txt'
print(path)  # C:\Users\new\test.txt

# 正確寫法二：正斜杠（Python跨平臺推薦）
path = 'C:/Users/new/test.txt'

# 正確寫法三：原始字符串
path = r'C:\Users\new\test.txt'

# 反斜杠的數(shù)量加倍規(guī)則
print('\\\\')   # 輸出：\\（兩個反斜杠）
print('\\\\\\\\')  # 輸出：\\\\（四個反斜杠）

# 不合法的轉(zhuǎn)義序列——Python 3.12+會報警告
# print('\d')  # DeprecationWarning: invalid escape sequence '\d'
# 但輸出仍然是 \d（反斜杠+字母d）

# 合法的轉(zhuǎn)義序列會被轉(zhuǎn)義
print('\n')   # 換行
print('\t')   # 制表符

# 方式一：用不同類型的引號包裹字符串
print("他說：'Python很有趣'")     # 雙引號包裹，內(nèi)部單引號
print('他說："Python很有趣"')     # 單引號包裹，內(nèi)部雙引號

# 方式二：用反斜杠轉(zhuǎn)義同類型引號
print('他說：\'Python很有趣\'')    # 轉(zhuǎn)義單引號
print("他說：\"Python很有趣\"")    # 轉(zhuǎn)義雙引號

# 方式三：用三引號包裹（內(nèi)部可以包含任意引號）
print('''他說："It's beautiful!"''')
print("""她說："It's wonderful!" """)

# 哪種方式最好？
# 推薦順序：換引號 > 轉(zhuǎn)義 > 三引號
# 對于簡單情況，換引號是最簡潔的

# \r 的基本效果（在print中演示）
import time

# 經(jīng)典場景：控制臺覆蓋打?。ㄟM(jìn)度條基礎(chǔ)）
print('加載中\(zhòng)r完成！')  # 在同一行，"加載中"被"完成！"覆蓋
# 實際可能看到：完成！（"加載中"被覆蓋了）

# 但是要注意：如果后面的內(nèi)容比前面的短，會有殘留
print('加載中請稍候\r完成')
# 輸出：完成中請稍候（"完成"只覆蓋了前兩個字符?。?

import time

# 簡單的進(jìn)度顯示
for i in range(101):
    bar = '█' * (i // 2) + '-' * (50 - i // 2)
    print(f'\r進(jìn)度：|{bar}| {i}%', end='', flush=True)
    time.sleep(0.03)
print()  # 最后換行

# spinner 旋轉(zhuǎn)加載動畫
spinner = ['|', '/', '-', '\\']
for i in range(20):
    print(f'\r加載中 {spinner[i % 4]}', end='', flush=True)
    time.sleep(0.1)
print('\r加載完成！       ')

# \b 的基本效果
print('hello\b\b world')  # 在終端中可能顯示: hel world
# 解釋：hello輸出后，兩個\b把光標(biāo)移到l前面，然后空格覆蓋了一個字符

# 實際效果因終端而異
# 有些終端只會移動光標(biāo)不刪除字符，有些會真的刪除

# \b 的一個實用技巧：模擬打字效果
import time

text = 'Python編程很有趣'
for i, ch in enumerate(text):
    if i > 0:
        print('\b', end='', flush=True)  # 刪除前一個打字效果標(biāo)記
    print(ch + '_', end='', flush=True)
    time.sleep(0.1)
print('\b ')  # 清除最后的_

# \f（Form Feed）：在文本文件中可能顯示為特殊符號
# 在打印機中會觸發(fā)換頁
print('第一頁內(nèi)容\f第二頁內(nèi)容')

# \v（Vertical Tab）：垂直方向的制表
print('行1\v行2\v行3')

# 在現(xiàn)代開發(fā)中這兩個基本用不到
# 如果你需要分頁控制，通常用HTML/CSS或PDF生成庫

# Python中\(zhòng)0是一個普通字符
text = 'hello\0world'
print(len(text))     # 11（\0算一個字符）
print(list(text))    # ['h', 'e', 'l', 'l', 'o', '\x00', 'w', 'o', 'r', 'l', 'd']
print('hello\0world')  # 在終端中可能不顯示\0后面的內(nèi)容

# 常見用途：二進(jìn)制數(shù)據(jù)處理
data = b'\x00\x01\x02\xFF'
print(data)          # b'\x00\x01\x02\xff'

# 在網(wǎng)絡(luò)協(xié)議、文件格式中常見
# 但普通文本處理不需要操心\0

# 八進(jìn)制轉(zhuǎn)義（必須正好3位八進(jìn)制數(shù)字）
print('\101')    # A（八進(jìn)制101 = 十進(jìn)制65 = ASCII 'A'）
print('\102')    # B
print('\012')    # 換行符（八進(jìn)制12 = 十進(jìn)制10）
print('\000')    # 空字符

# 字母表
for i in range(26):
    print(chr(ord('A') + i), end=' ')
print()

# 用八進(jìn)制做同樣的輸出
for i in range(65, 91):
    print(f'\\{i:03o}', end='  ')
print()
# \101  \102  \103  \104  \105  ...

# 十六進(jìn)制轉(zhuǎn)義（用\x加上兩個十六進(jìn)制數(shù)字）
print('\x41')    # A（十六進(jìn)制41 = 十進(jìn)制65 = ASCII 'A'）
print('\x42')    # B
print('\x0A')    # 換行符（十六進(jìn)制A = 十進(jìn)制10）
print('\xFF')    # ?（ASCII 255）

# 實用的十六進(jìn)制字符
print('\x20')    # 空格
print('\x09')    # 制表符（Tab）
print('\x0D')    # 回車
print('\x0D\x0A') # Windows換行（CR+LF）

# 在二進(jìn)制數(shù)據(jù)和文本之間的轉(zhuǎn)換中常用
def show_hex(text):
    """顯示字符串中每個字符的十六進(jìn)制值"""
    for ch in text:
        print(f'{ch!r:8} -> \\x{ord(ch):02X}')

show_hex('Hello')
# 'H'      -> \x48
# 'e'      -> \x65
# 'l'      -> \x6C
# 'l'      -> \x6C
# 'o'      -> \x6F

# \u 后接4位十六進(jìn)制數(shù)字，表示BMP（基本多語言平面）中的字符
print('中')    # 中
print('國')    # 國
print('A')    # A（英文也可以用Unicode表示）
print('é')    # é（帶重音的e）

# 常用中文Unicode范圍
# 中日韓統(tǒng)一表意文字：一 - ?
print('中國人')  # 中國人

# 希臘字母
print('αβγ')  # αβγ

# \U 后接8位十六進(jìn)制數(shù)字，可以表示所有Unicode字符
print('\U0001F600')  # ??（笑臉emoji）
print('\U0001F60E')  # ??（酷酷的笑臉）
print('\U0001F389')  # ??（慶祝）

# Emoji也有Unicode碼點
for code in ['1F600', '1F601', '1F602', '1F603', '1F604']:
    print(f'\\U{code:0>8} = {chr(int(code, 16))}')
# \U0001F600 = ??
# \U0001F601 = ??
# \U0001F602 = ??
# \U0001F603 = ??
# \U0001F604 = ??

# \u 和 \U 的區(qū)別
print('A')      # A（\u后必須4位）
print('\U00000041')  # A（\U后必須8位）
# print(' 0041')  # 錯誤！\u只能跟4位

# 使用Unicode名稱引用字符
import unicodedata

# \N{NAME} 語法
print('\N{COPYRIGHT SIGN}')      # ?
print('\N{REGISTERED SIGN}')     # ?
print('\N{EURO SIGN}')           # €
print('\N{SNOWMAN}')             # ?

# 查看字符的Unicode名稱
print(unicodedata.name('中'))    # CJK UNIFIED IDEOGRAPH-4E2D
print(unicodedata.name('??'))    # GRINNING FACE

# 這也是一種"可讀的"特殊字符表達(dá)方式
print('\N{LEFT CURLY BRACKET}')  # {
print('\N{RIGHT CURLY BRACKET}') # }

# 普通字符串 vs 原始字符串
print('hello\nworld')     # hello（換行）world
print(r'hello\nworld')    # hello\nworld（\n原樣輸出）

# 查看實際內(nèi)容
normal = '\n'
raw = r'\n'
print(len(normal))   # 1（只有一個換行字符）
print(len(raw))      # 2（反斜杠和字母n兩個字符）
print(list(normal))  # ['\n']
print(list(raw))     # ['\\', 'n']

# Windows文件路徑——轉(zhuǎn)義字符的噩夢
# 錯誤寫法（\n會被解析為換行，\t會被解析為制表符）
# path = 'C:\Users\new\test.txt'

# 解決方案一：使用原始字符串
path = r'C:\Users\new\test.txt'
print(path)  # C:\Users\new\test.txt

# 解決方案二：使用正斜杠（Python在所有平臺都接受）
path = 'C:/Users/new/test.txt'

# 解決方案三：雙反斜杠
path = 'C:\\Users\\new\\test.txt'

# 解決方案四：用os.path或pathlib處理
from pathlib import Path
path = Path('C:') / 'Users' / 'new' / 'test.txt'
print(path)  # C:\Users\new\test.txt

# 實際開發(fā)中的路徑處理
import os

folder = r'D:\MYITEM\ITEM\claude\文章系列\(zhòng)python編程'
file = 'test.txt'
full_path = os.path.join(folder, file)
print(full_path)

# 或者用pathlib（更現(xiàn)代的方式）
from pathlib import Path
base = Path(r'D:\MYITEM\ITEM\claude\文章系列\(zhòng)python編程')
target = base / '子目錄' / 'test.txt'
print(target)

import re

text = '我的電話是13812345678，公司電話是010-12345678'

# 不用原始字符串——雙重轉(zhuǎn)義，讀起來很痛苦
pattern = '\\d{3}-?\\d{8}|\\d{4}-?\\d{7,8}'
matches = re.findall(pattern, text)
print(matches)  # ['13812345678', '010-12345678']

# 使用原始字符串——清晰明了
pattern = r'\d{3}-?\d{8}|\d{4}-?\d{7,8}'
matches = re.findall(pattern, text)
print(matches)  # ['13812345678', '010-12345678']

# 更復(fù)雜的正則例子
# 匹配Python變量名
variable_pattern = r'^[a-zA-Z_][a-zA-Z0-9_]*$'
print(re.match(variable_pattern, '_private_var'))  # Match
print(re.match(variable_pattern, '2nd_var'))       # None

# 匹配URL
url_pattern = r'https?://(?:www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b'
print(re.match(url_pattern, 'https://www.example.com/path?q=value'))

# 正則中需要匹配反斜杠本身
# 匹配Windows路徑中的反斜杠
path_pattern = r'C:\\Users\\.+'  # 原始字符串中匹配一個反斜杠需要寫兩個\\
print(path_pattern)  # C:\\Users\\.+
# 這里r'\\'表示兩個反斜杠字符，正則引擎再將其解釋為匹配一個反斜杠

# 可以理解為"雙重處理"：
# 1. Python字符串解析：r'\\' → 兩個字符 \ 和 \
# 2. 正則引擎解析：\\ → 匹配一個字面反斜杠

# ? 錯誤：不能以反斜杠結(jié)尾
# path = r'C:\Users\new\'  # SyntaxError

# 為什么？因為引號前的反斜杠會被解釋為引號轉(zhuǎn)義
# r'\' 中的 \' 仍然被視為轉(zhuǎn)義的單引號

# ? 解決方法一：在末尾加一個空格再strip
path = r'C:\Users\new\ '.strip()
print(path)  # C:\Users\new\

# ? 解決方法二：正斜杠結(jié)尾
path = r'C:/Users/new/'

# ? 解決方法三：拼接
path = r'C:\Users\new' + '\\'
print(path)  # C:\Users\new\

# ? 實際上，路徑末尾一般不需要反斜杠
# 用os.path.join或pathlib自動處理
from pathlib import Path
folder = Path(r'C:\Users\new')
file_path = folder / 'test.txt'
print(file_path)  # C:\Users\new\test.txt

# 顯示字符串中實際的反斜杠序列
hidden_chars = 'hello\nworld\t!'
visible_version = repr(hidden_chars)
print(visible_version)  # 'hello\nworld\t!'

# 手動構(gòu)建可讀版本
def show_escapes(text):
    """將字符串中的轉(zhuǎn)義字符顯示為可讀的形式"""
    escape_map = {
        '\n': '\\n', '\r': '\\r', '\t': '\\t',
        '\b': '\\b', '\f': '\\f', '\v': '\\v',
        '\\': '\\\\', '\'': '\\\'', '\"': '\\"',
    }
    for char, escaped in escape_map.items():
        text = text.replace(char, escaped)
    return text

print(show_escapes('hello\nworld\t!'))  # hello\nworld\t!

import time
import sys

def download_progress(filename, total_size):
    """模擬文件下載進(jìn)度條——綜合運用\r和格式化"""
    bar_length = 40

    for downloaded in range(total_size + 1):
        percent = downloaded / total_size
        filled = int(bar_length * percent)
        bar = '█' * filled + '?' * (bar_length - filled)

        # \r回到行首，end=''不換行，flush=True立即刷新
        print(f'\r{filename} |{bar}| {percent:.1%}', end='', flush=True)
        time.sleep(0.02)

    print()  # 下載完成后換行

download_progress('python-3.12.exe', 100)

def animated_loading(duration=3):
    """動畫加載效果——綜合運用\r和Unicode字符"""
    frames = ['?', '?', '?', '?', '?', '?', '?', '?', '?', '?']
    end = time.time() + duration
    i = 0
    while time.time() < end:
        frame = frames[i % len(frames)]
        elapsed = duration - (end - time.time())
        print(f'\r{frame} 處理中... {elapsed:.1f}秒', end='', flush=True)
        time.sleep(0.1)
        i += 1
    print('\r? 處理完成！     ')

animated_loading(3)

# 生成.env配置文件
def generate_env_file(db_host, db_port, db_user, db_password, db_name):
    """生成環(huán)境變量配置文件——注意密碼中可能包含特殊字符"""
    # 密碼中的特殊字符需要正確處理
    def escape_env_value(value):
        """對環(huán)境變量值中的特殊字符進(jìn)行轉(zhuǎn)義"""
        # 如果包含空格或特殊字符，加雙引號
        if any(c in value for c in ' \t\n\r\f\v#='):
            # 雙引號內(nèi)的雙引號需要轉(zhuǎn)義
            value = value.replace('\\', '\\\\').replace('"', '\\"')
            return f'"{value}"'
        return value

    lines = [
        f'DB_HOST={escape_env_value(db_host)}',
        f'DB_PORT={db_port}',
        f'DB_USER={escape_env_value(db_user)}',
        f'DB_PASSWORD={escape_env_value(db_password)}',
        f'DB_NAME={escape_env_value(db_name)}',
    ]
    return '\n'.join(lines)

config = generate_env_file(
    'localhost', 5432, 'admin',
    'P@ss"word\\with\\slashes', 'my_database'
)
print(config)

# 生成JSON（處理字符串中的轉(zhuǎn)義）
import json

data = {
    'message': '他說："hello\nworld"',
    'path': 'C:\\Users\\test\\file.txt',
}
json_str = json.dumps(data, ensure_ascii=False, indent=2)
print(json_str)
# json.dumps會自動處理轉(zhuǎn)義，不需要手動操作

def clean_text(text):
    """清洗文本中的控制字符——數(shù)據(jù)預(yù)處理常見需求"""
    import re

    # 替換換行符和制表符為空格
    cleaned = text.replace('\n', ' ').replace('\r', ' ').replace('\t', ' ')

    # 將多個連續(xù)空格合并為一個
    cleaned = re.sub(r' +', ' ', cleaned)

    # 去除首尾空格
    cleaned = cleaned.strip()

    # 移除其他不可見控制字符（保留正常文本）
    cleaned = re.sub(r'[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]', '', cleaned)

    return cleaned

# 模擬一段臟數(shù)據(jù)（從PDF復(fù)制出來常有的情況）
dirty_text = 'Python編程語言\x00簡介：\r\nPython是一種\t\t高級編程語言。\n\n它簡潔易懂。\x0B'
print(repr(dirty_text))
print('---清洗后---')
print(clean_text(dirty_text))


def normalize_line_endings(text):
    """統(tǒng)一換行符為Unix風(fēng)格（\n）"""
    # Windows \r\n → \n
    text = text.replace('\r\n', '\n')
    # 老Mac \r → \n
    text = text.replace('\r', '\n')
    return text

mixed_endings = '行1\r\n行2\n行3\r行4'
print(repr(normalize_line_endings(mixed_endings)))
# '行1\n行2\n行3\n行4'

import re

def split_paragraph_to_sentences(paragraph):
    """將段落分割為句子——正確處理各種標(biāo)點和換行"""
    # 先統(tǒng)一空白字符
    paragraph = re.sub(r'\s+', ' ', paragraph).strip()

    # 按句末標(biāo)點分割（保留標(biāo)點）
    sentences = re.split(r'([。！？!?])', paragraph)
    result = []
    for i in range(0, len(sentences) - 1, 2):
        sent = sentences[i] + sentences[i + 1]
        result.append(sent.strip())
    if len(sentences) % 2 == 1 and sentences[-1].strip():
        result.append(sentences[-1].strip())
    return result

text = 'Python是一門優(yōu)秀的語言！它簡潔易學(xué)。你想學(xué)嗎？我們開始吧。'
for i, sent in enumerate(split_paragraph_to_sentences(text), 1):
    print(f'句子{i}: {sent}')

# 原始字符串中，反斜杠+引號仍然被解釋為引號轉(zhuǎn)義
print(r'he\'llo')   # he\'llo（這個反斜杠被保留了？）
# 實際上 r'he\'llo' 創(chuàng)建的是字符串 he\'llo
# 但 r'hello\' 會報錯——因為最后的\'被解釋為轉(zhuǎn)義引號

# 具體行為：
# r"hello\" → SyntaxError（反斜杠后的引號被轉(zhuǎn)義，字符串沒有結(jié)束）
# r"hello\\" → hello\\（兩個反斜杠保留）

# 查看原始字符串內(nèi)部
print(len(r'\''))    # 2（反斜杠和單引號兩個字符）
print(len(r'\"'))    # 2（反斜杠和雙引號兩個字符）
print(r'\'')          # \'
print(r'\"')          # \"

# 原始字符串在內(nèi)存中和普通字符串存儲方式完全一樣
# 區(qū)別只在于源代碼中的字面量寫法

# 這兩個字符串在內(nèi)存中完全相同
s1 = 'hello\nworld'
s2 = '''
hello
world
'''.strip()
print(s1 == s2)  # True

# 這兩個也完全相同
s3 = r'C:\Users\test'
s4 = 'C:\\Users\\test'
print(s3 == s4)  # True

# 原始字符串只是改變了源代碼的寫法
# 并不改變字符串本身的內(nèi)容
print(type(r'hello'))  # <class 'str'>
print(type('hello'))   # <class 'str'>
# 兩者類型完全相同

# 錯誤一：忘記轉(zhuǎn)義反斜杠
# path = 'C:\new\test.txt'  # \n被轉(zhuǎn)義為換行，\t被轉(zhuǎn)義為制表符
# 解決：用r''或雙反斜杠

# 錯誤二：原始字符串以反斜杠結(jié)尾
# path = r'C:\Users\test\'  # SyntaxError: EOL while scanning string literal
# 解決：見上文

# 錯誤三：在f-string中使用反斜杠
# f-string花括號內(nèi)不能直接使用反斜杠
value = 'hello\nworld'
# print(f'{value\n}')  # SyntaxError
# 解決：用變量
print(f'{value}')

# 錯誤四：混淆repr和str
text = 'a\nb'
print(text)      # a（換行）b
print(repr(text))  # 'a\nb'（顯示轉(zhuǎn)義序列）
# 在調(diào)試時用repr查看字符串的真實內(nèi)容

# 錯誤五：\x轉(zhuǎn)義中亂用
# print('\x')    # ValueError: invalid \x escape
print('\x41')     # A（必須跟兩個十六進(jìn)制數(shù)字）
# print('\x4G')  # ValueError: invalid \x escape（G不是有效的十六進(jìn)制）

# 錯誤六：\u之后必須是4位十六進(jìn)制
# print('\u4e2')  # SyntaxError（少了一位）
print('中')    # 中（正確）

# 技巧一：用repr()查看字符串的真實內(nèi)容
def inspect_string(text):
    """檢查字符串中的轉(zhuǎn)義字符"""
    print(f'顯示: {text}')
    print(f'repr: {repr(text)}')
    print(f'長度: {len(text)}')
    print(f'字符: {list(text)}')
    print(f'十六進(jìn)制: {" ".join(f"{ord(c):02x}" for c in text)}')
    print()

inspect_string('hello\nworld')
inspect_string(r'hello\nworld')
inspect_string('a\tb\tc')
inspect_string('路徑：C:\\test\\file.txt')

# 技巧二：比較兩個看起來一樣的字符串
def compare_strings(s1, s2):
    """詳細(xì)比較兩個字符串"""
    print(f's1 = {repr(s1)} (len={len(s1)})')
    print(f's2 = {repr(s2)} (len={len(s2)})')
    print(f's1 == s2: {s1 == s2}')
    if len(s1) != len(s2):
        print(f'長度不同: {len(s1)} vs {len(s2)}')
    for i, (c1, c2) in enumerate(zip(s1, s2)):
        if c1 != c2:
            print(f'  位置{i}: {repr(c1)} vs {repr(c2)}')
    print()

s1 = 'C:\\new\\test'
s2 = r'C:\new\test'
compare_strings(s1, s2)  # 相同

s3 = 'hello\nworld'
s4 = r'hello\nworld'
compare_strings(s3, s4)  # 不同！

# 技巧三：可視化不可見字符
def visualize_whitespace(text):
    """將空白字符可視化顯示"""
    result = ''
    for ch in text:
        if ch == '\n':
            result += '?\n'
        elif ch == '\r':
            result += '?'
        elif ch == '\t':
            result += '→\t'
        elif ch == ' ':
            result += '·'
        else:
            result += ch
    return result

sample = 'hello\tworld\nPython\rTest'
print(visualize_whitespace(sample))
# hello→  world?
# Python?Test

# 原則一：文件路徑——優(yōu)先使用pathlib，其次正斜杠，再次r-string
from pathlib import Path

# 最佳
path = Path('C:/Users/test/file.txt')

# 可以
path = r'C:\Users\test\file.txt'

# 避免
path = 'C:\\Users\\test\\file.txt'


# 原則二：正則表達(dá)式——始終用原始字符串
import re

# 推薦
pattern = r'\d{3}-\d{4}-\d{4}'

# 不推薦
pattern = '\\d{3}-\\d{4}-\\d{4}'


# 原則三：多行文本——用三重引號代替\n拼接
# 推薦
message = '''
第一行
第二行
第三行
'''.strip()

# 不推薦
message = '第一行\(zhòng)n第二行\(zhòng)n第三行'


# 原則四：Unicode字符——能用直接字符就不用轉(zhuǎn)義序列
# 如果字符可以直接輸入，就不要用Unicode轉(zhuǎn)義
print('你好')          # 直接輸入
# print('你好')  # 不推薦，除非確實需要

# 但對于不可見字符或特殊符號，Unicode轉(zhuǎn)義更清楚
print('\N{EM DASH}')    # —（破折號，比直接打字清楚）
print(' ')         # 不間斷空格


# 原則五：\t對齊——不要依賴制表符做精確對齊
# 不推薦
print('姓名\t年齡\t城市')

# 推薦
print(f'{"姓名":<12}{"年齡":<8}{"城市":<10}')

# Python支持多個前綴組合使用
# 規(guī)則：r/R、f/F可以組合（Python 3.6+），順序任意

# rf 或 fr：原始格式化字符串
name = 'new'
path = rf'C:\Users\{name}\test.txt'
print(path)  # C:\Users\new\test.txt

# 在rf-string中，反斜杠在花括號外是普通字符
value = 42
print(rf'值：{value}\n換行？')  # 值：42\n換行？

# rb：原始字節(jié)串
data = rb'C:\Users\test\x41'
print(data)  # b'C:\\Users\\test\\x41'
print(type(data))  # <class 'bytes'>

# br 和 rb 等價
data = br'hello\nworld'
print(data)  # b'hello\\nworld'

# f和b不能組合（格式化字節(jié)串不存在）
# print(fb'hello')  # SyntaxError