Python基础指南之转义字符与原始字符串的妙用详解

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

# 构建多行文本
message = '尊敬的客户：\n您的订单已发货。\n预计3-5个工作日到达。\n\n祝您购物愉快！'
print(message)

# \n在字符串中的实际长度
text = 'a\nb'
print(len(text))   # 3（a、\n、b三个字符）
print(list(text))  # ['a', '\n', 'b']

# 在字符串字面量中直接换行（隐式连接）
text = ('第一行\n'
        '第二行\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风格

# 读取时Python会自动转换（默认newline=None）
with open('test.txt', 'r', encoding='utf-8') as f:
    content = f.read()
    # \r\n 已被自动转换为 \n
    print(repr(content))  # '行1\n行2\n行3\n'

# splitlines() 能统一处理各种换行符
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广州')

# 问题：当内容长度不同时，制表符对齐可能错乱
print('姓名\t\t年龄\t城市')
print('Alexander\t25\t北京')     # 长名字会推远下一列
print('Bob\t\t23\t上海')         # 短名字需要两个\t
# 这就体现了\t的局限性——它按固定制表位跳转，不是动态对齐

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

# 或者用\t配合str.expandtabs()来调整制表宽度
text = '姓名\t年龄\t城市\nAlexander\t25\t北京'
print(text.expandtabs(16))  # 将制表符扩展为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'

# 反斜杠的数量加倍规则
print('\\\\')   # 输出：\\（两个反斜杠）
print('\\\\\\\\')  # 输出：\\\\（四个反斜杠）

# 不合法的转义序列——Python 3.12+会报警告
# print('\d')  # DeprecationWarning: invalid escape sequence '\d'
# 但输出仍然是 \d（反斜杠+字母d）

# 合法的转义序列会被转义
print('\n')   # 换行
print('\t')   # 制表符

# 方式一：用不同类型的引号包裹字符串
print("他说：'Python很有趣'")     # 双引号包裹，内部单引号
print('他说："Python很有趣"')     # 单引号包裹，内部双引号

# 方式二：用反斜杠转义同类型引号
print('他说：\'Python很有趣\'')    # 转义单引号
print("他说：\"Python很有趣\"")    # 转义双引号

# 方式三：用三引号包裹（内部可以包含任意引号）
print('''他说："It's beautiful!"''')
print("""她说："It's wonderful!" """)

# 哪种方式最好？
# 推荐顺序：换引号 > 转义 > 三引号
# 对于简单情况，换引号是最简洁的

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

# 经典场景：控制台覆盖打印（进度条基础）
print('加载中\r完成！')  # 在同一行，"加载中"被"完成！"覆盖
# 实际可能看到：完成！（"加载中"被覆盖了）

# 但是要注意：如果后面的内容比前面的短，会有残留
print('加载中请稍候\r完成')
# 输出：完成中请稍候（"完成"只覆盖了前两个字符！）

import time

# 简单的进度显示
for i in range(101):
    bar = '█' * (i // 2) + '-' * (50 - i // 2)
    print(f'\r进度：|{bar}| {i}%', end='', flush=True)
    time.sleep(0.03)
print()  # 最后换行

# spinner 旋转加载动画
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把光标移到l前面，然后空格覆盖了一个字符

# 实际效果因终端而异
# 有些终端只会移动光标不删除字符，有些会真的删除

# \b 的一个实用技巧：模拟打字效果
import time

text = 'Python编程很有趣'
for i, ch in enumerate(text):
    if i > 0:
        print('\b', end='', flush=True)  # 删除前一个打字效果标记
    print(ch + '_', end='', flush=True)
    time.sleep(0.1)
print('\b ')  # 清除最后的_

# \f（Form Feed）：在文本文件中可能显示为特殊符号
# 在打印机中会触发换页
print('第一页内容\f第二页内容')

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

# 在现代开发中这两个基本用不到
# 如果你需要分页控制，通常用HTML/CSS或PDF生成库

# Python中\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后面的内容

# 常见用途：二进制数据处理
data = b'\x00\x01\x02\xFF'
print(data)          # b'\x00\x01\x02\xff'

# 在网络协议、文件格式中常见
# 但普通文本处理不需要操心\0

# 八进制转义（必须正好3位八进制数字）
print('\101')    # A（八进制101 = 十进制65 = ASCII 'A'）
print('\102')    # B
print('\012')    # 换行符（八进制12 = 十进制10）
print('\000')    # 空字符

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

# 用八进制做同样的输出
for i in range(65, 91):
    print(f'\\{i:03o}', end='  ')
print()
# \101  \102  \103  \104  \105  ...

# 十六进制转义（用\x加上两个十六进制数字）
print('\x41')    # A（十六进制41 = 十进制65 = ASCII 'A'）
print('\x42')    # B
print('\x0A')    # 换行符（十六进制A = 十进制10）
print('\xFF')    # ÿ（ASCII 255）

# 实用的十六进制字符
print('\x20')    # 空格
print('\x09')    # 制表符（Tab）
print('\x0D')    # 回车
print('\x0D\x0A') # Windows换行（CR+LF）

# 在二进制数据和文本之间的转换中常用
def show_hex(text):
    """显示字符串中每个字符的十六进制值"""
    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位十六进制数字，表示BMP（基本多语言平面）中的字符
print('中')    # 中
print('国')    # 国
print('A')    # A（英文也可以用Unicode表示）
print('é')    # é（带重音的e）

# 常用中文Unicode范围
# 中日韩统一表意文字：一 - 鿿
print('中国人')  # 中国人

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

# \U 后接8位十六进制数字，可以表示所有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 的区别
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

# 这也是一种"可读的"特殊字符表达方式
print('\N{LEFT CURLY BRACKET}')  # {
print('\N{RIGHT CURLY BRACKET}') # }

# 普通字符串 vs 原始字符串
print('hello\nworld')     # hello（换行）world
print(r'hello\nworld')    # hello\nworld（\n原样输出）

# 查看实际内容
normal = '\n'
raw = r'\n'
print(len(normal))   # 1（只有一个换行字符）
print(len(raw))      # 2（反斜杠和字母n两个字符）
print(list(normal))  # ['\n']
print(list(raw))     # ['\\', 'n']

# Windows文件路径——转义字符的噩梦
# 错误写法（\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

# 实际开发中的路径处理
import os

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

# 或者用pathlib（更现代的方式）
from pathlib import Path
base = Path(r'D:\MYITEM\ITEM\claude\文章系列\python编程')
target = base / '子目录' / 'test.txt'
print(target)

import re

text = '我的电话是13812345678，公司电话是010-12345678'

# 不用原始字符串——双重转义，读起来很痛苦
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']

# 更复杂的正则例子
# 匹配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. 正则引擎解析：\\ → 匹配一个字面反斜杠

# ❌ 错误：不能以反斜杠结尾
# path = r'C:\Users\new\'  # SyntaxError

# 为什么？因为引号前的反斜杠会被解释为引号转义
# r'\' 中的 \' 仍然被视为转义的单引号

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

# ✅ 解决方法二：正斜杠结尾
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!'

# 手动构建可读版本
def show_escapes(text):
    """将字符串中的转义字符显示为可读的形式"""
    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):
    """模拟文件下载进度条——综合运用\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):
    """生成环境变量配置文件——注意密码中可能包含特殊字符"""
    # 密码中的特殊字符需要正确处理
    def escape_env_value(value):
        """对环境变量值中的特殊字符进行转义"""
        # 如果包含空格或特殊字符，加双引号
        if any(c in value for c in ' \t\n\r\f\v#='):
            # 双引号内的双引号需要转义
            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（处理字符串中的转义）
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会自动处理转义，不需要手动操作

def clean_text(text):
    """清洗文本中的控制字符——数据预处理常见需求"""
    import re

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

    # 将多个连续空格合并为一个
    cleaned = re.sub(r' +', ' ', cleaned)

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

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

    return cleaned

# 模拟一段脏数据（从PDF复制出来常有的情况）
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):
    """统一换行符为Unix风格（\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):
    """将段落分割为句子——正确处理各种标点和换行"""
    # 先统一空白字符
    paragraph = re.sub(r'\s+', ' ', paragraph).strip()

    # 按句末标点分割（保留标点）
    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是一门优秀的语言！它简洁易学。你想学吗？我们开始吧。'
for i, sent in enumerate(split_paragraph_to_sentences(text), 1):
    print(f'句子{i}: {sent}')

# 原始字符串中，反斜杠+引号仍然被解释为引号转义
print(r'he\'llo')   # he\'llo（这个反斜杠被保留了？）
# 实际上 r'he\'llo' 创建的是字符串 he\'llo
# 但 r'hello\' 会报错——因为最后的\'被解释为转义引号

# 具体行为：
# r"hello\" → SyntaxError（反斜杠后的引号被转义，字符串没有结束）
# r"hello\\" → hello\\（两个反斜杠保留）

# 查看原始字符串内部
print(len(r'\''))    # 2（反斜杠和单引号两个字符）
print(len(r'\"'))    # 2（反斜杠和双引号两个字符）
print(r'\'')          # \'
print(r'\"')          # \"

# 原始字符串在内存中和普通字符串存储方式完全一样
# 区别只在于源代码中的字面量写法

# 这两个字符串在内存中完全相同
s1 = 'hello\nworld'
s2 = '''
hello
world
'''.strip()
print(s1 == s2)  # True

# 这两个也完全相同
s3 = r'C:\Users\test'
s4 = 'C:\\Users\\test'
print(s3 == s4)  # True

# 原始字符串只是改变了源代码的写法
# 并不改变字符串本身的内容
print(type(r'hello'))  # <class 'str'>
print(type('hello'))   # <class 'str'>
# 两者类型完全相同

# 错误一：忘记转义反斜杠
# path = 'C:\new\test.txt'  # \n被转义为换行，\t被转义为制表符
# 解决：用r''或双反斜杠

# 错误二：原始字符串以反斜杠结尾
# path = r'C:\Users\test\'  # SyntaxError: EOL while scanning string literal
# 解决：见上文

# 错误三：在f-string中使用反斜杠
# f-string花括号内不能直接使用反斜杠
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'（显示转义序列）
# 在调试时用repr查看字符串的真实内容

# 错误五：\x转义中乱用
# print('\x')    # ValueError: invalid \x escape
print('\x41')     # A（必须跟两个十六进制数字）
# print('\x4G')  # ValueError: invalid \x escape（G不是有效的十六进制）

# 错误六：\u之后必须是4位十六进制
# print('\u4e2')  # SyntaxError（少了一位）
print('中')    # 中（正确）

# 技巧一：用repr()查看字符串的真实内容
def inspect_string(text):
    """检查字符串中的转义字符"""
    print(f'显示: {text}')
    print(f'repr: {repr(text)}')
    print(f'长度: {len(text)}')
    print(f'字符: {list(text)}')
    print(f'十六进制: {" ".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):
    """详细比较两个字符串"""
    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

# 原则一：文件路径——优先使用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'


# 原则二：正则表达式——始终用原始字符串
import re

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

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


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

# 不推荐
message = '第一行\n第二行\n第三行'


# 原则四：Unicode字符——能用直接字符就不用转义序列
# 如果字符可以直接输入，就不要用Unicode转义
print('你好')          # 直接输入
# print('你好')  # 不推荐，除非确实需要

# 但对于不可见字符或特殊符号，Unicode转义更清楚
print('\N{EM DASH}')    # —（破折号，比直接打字清楚）
print(' ')         # 不间断空格


# 原则五：\t对齐——不要依赖制表符做精确对齐
# 不推荐
print('姓名\t年龄\t城市')

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

# Python支持多个前缀组合使用
# 规则：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：原始字节串
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不能组合（格式化字节串不存在）
# print(fb'hello')  # SyntaxError