# 單引號和雙引號（完全等價(jià)）
single_quote = 'Hello, World!'
double_quote = "Hello, World!"

# 三引號（支持多行）
multi_line = """這是一個(gè)
多行字符串"""

# 原始字符串（不轉(zhuǎn)義特殊字符）
raw_string = r"C:\Users\Documents\file.txt"

# Unicode 字符串
chinese = "你好，世界！"
emoji = "?? Python ??"

print(f"單引號: {single_quote}")
print(f"多行: {repr(multi_line)}")
print(f"原始: {raw_string}")
print(f"中文: {chinese}")
print(f"表情: {emoji}")

name = "張三"
age = 25
height = 1.75

# 基本格式化
print("姓名: %s, 年齡: %d" % (name, age))
print("身高: %.2f 米" % height)

# 格式化字典
data = {"name": "李四", "score": 95.5}
print("學(xué)生: %(name)s, 成績: %(score).1f" % data)

# 對齊和填充
print("|%10s|" % "center")   # 右對齊，寬度10
print("|%-10s|" % "left")    # 左對齊，寬度10
print("|%010d|" % 42)        # 零填充，寬度10

# 基本使用
print("姓名: {}, 年齡: {}".format(name, age))
print("身高: {:.2f} 米".format(height))

# 位置參數(shù)
print("{0} 比 {1} 大，但 {1} 比 {0} 小".format(5, 3))

# 關(guān)鍵字參數(shù)
print("姓名: {name}, 年齡: {age}".format(name="王五", age=30))

# 混合使用
print("{0} 和 {name} 是朋友".format("張三", name="李四"))

# 高級格式化
total = 1234.5678
print("科學(xué)計(jì)數(shù)法: {:.2e}".format(total))
print("百分比: {:.2%}".format(0.85))
print("千位分隔符: {:,}".format(1234567))

# 對齊和填充
print("|{:>10}|".format("right"))    # 右對齊
print("|{:<10}|".format("left"))     # 左對齊
print("|{:^10}|".format("center"))  # 居中對齊
print("|{:*^10}|".format("center"))  # 居中對齊，*填充

# 基本使用（最簡潔）
print(f"姓名: {name}, 年齡: {age}")
print(f"身高: {height:.2f} 米")

# 表達(dá)式計(jì)算
radius = 5
print(f"圓的面積: {3.14159 * radius ** 2:.2f}")

# 函數(shù)調(diào)用
def get_score():
    return 95.5

print(f"成績: {get_score():.1f}分")

# 格式化選項(xiàng)
score = 85.6666
print(f"成績: {score:.1f}")          # 一位小數(shù)
print(f"成績: {score:.0f}")          # 整數(shù)
print(f"百分比: {score/100:.2%}")    # 百分比格式

# 對齊和寬度
for i in range(1, 6):
    print(f"第{i:>2}名: {f'學(xué)生{i}':<10} 成績: {95-i*2}")

# 日期時(shí)間格式化
from datetime import datetime
now = datetime.now()
print(f"當(dāng)前時(shí)間: {now:%Y-%m-%d %H:%M:%S}")
print(f"日期: {now:%Y年%m月%d日}")

# 調(diào)試輸出（Python 3.8+）
x = 10
y = 20
print(f"x = {x}, y = {y}, x+y = {x+y}")  # 傳統(tǒng)方式
print(f"{x=}, {y=}, {x+y=}")             # 更簡潔的調(diào)試語法

text = "Python Programming"

# 基本切片 [start:stop:step]
print(text[0:6])     # "Python"，從索引0到5
print(text[7:])      # "Programming"，從索引7到末尾
print(text[:6])      # "Python"，從開始到索引5
print(text[:])       # "Python Programming"，完整復(fù)制

# 負(fù)索引
print(text[-11:])    # "Programming"，最后11個(gè)字符
print(text[:-12])    # "Python"，除了最后12個(gè)字符

# 步長
print(text[::2])     # "Pto rgamn"，每隔一個(gè)字符
print(text[::-1])    # "gnimmargorP nohtyP"，反轉(zhuǎn)字符串

# 提取文件擴(kuò)展名
filename = "document.pdf"
extension = filename[-3:] if filename.endswith('pdf') else "其他"
print(f"文件擴(kuò)展名: {extension}")

# 提取郵箱域名
email = "user@example.com"
domain = email.split('@')[1] if '@' in email else ""
print(f"郵箱域名: {domain}")

# 反轉(zhuǎn)單詞
sentence = "Hello World Python"
reversed_words = ' '.join(word[::-1] for word in sentence.split())
print(f"反轉(zhuǎn)單詞: {reversed_words}")

# 提取數(shù)字
import re
text_with_numbers = "價(jià)格: ￥199.99，庫存: 50件"
numbers = re.findall(r'\d+\.?\d*', text_with_numbers)
print(f"提取的數(shù)字: {numbers}")

# 處理 CSV 數(shù)據(jù)
csv_line = "張三,25,北京,175.5"
parts = csv_line.split(',')
name, age, city, height = parts
print(f"姓名: {name}, 年齡: {age}, 城市: {city}, 身高: {height}")

# 1. 字符串旋轉(zhuǎn)
def rotate_string(s, n):
    """將字符串循環(huán)右移 n 位"""
    n = n % len(s)  # 處理 n 大于字符串長度的情況
    return s[-n:] + s[:-n]

text = "abcdef"
print(f"原始: {text}")
print(f"右移2位: {rotate_string(text, 2)}")  # "efabcd"
print(f"右移5位: {rotate_string(text, 5)}")  # "bcdefa"

# 2. 回文檢測
def is_palindrome(s):
    """檢測回文（忽略大小寫和非字母字符）"""
    cleaned = ''.join(c.lower() for c in s if c.isalnum())
    return cleaned == cleaned[::-1]

test_strings = ["racecar", "hello", "A man a plan a canal Panama"]
for s in test_strings:
    print(f"'{s}' 是回文: {is_palindrome(s)}")

# 3. 提取子串的所有位置
def find_all_occurrences(text, pattern):
    """找到所有子串出現(xiàn)的位置"""
    positions = []
    start = 0
    while True:
        pos = text.find(pattern, start)
        if pos == -1:
            break
        positions.append(pos)
        start = pos + 1
    return positions

text = "ababaab"
pattern = "aba"
positions = find_all_occurrences(text, pattern)
print(f"'{pattern}' 在 '{text}' 中的位置: {positions}")

text = "Python is awesome, Python is powerful"

# 查找
print(text.find("Python"))      # 0，第一次出現(xiàn)的位置
print(text.rfind("Python"))     # 21，最后一次出現(xiàn)的位置
print(text.find("Java"))        # -1，未找到

print(text.count("Python"))     # 2，出現(xiàn)次數(shù)
print(text.index("is"))         # 7，第一次出現(xiàn)位置
print(text.rindex("is"))        # 28，最后一次出現(xiàn)位置

# 替換
new_text = text.replace("Python", "Java")
print(new_text)

# 只替換一次
partial_replace = text.replace("Python", "Java", 1)
print(partial_replace)

# 大小寫轉(zhuǎn)換
text = "Python Programming"

print(text.upper())          # "PYTHON PROGRAMMING"
print(text.lower())          # "python programming"
print(text.title())          # "Python Programming"
print(text.capitalize())     # "Python programming"
print(text.swapcase())       # "pYTHON pROGRAMMING"

# 判斷大小寫
print(text.isupper())        # False
print(text.islower())        # False
print(text.istitle())        # True

# 實(shí)際應(yīng)用：用戶名規(guī)范化
def normalize_username(username):
    """規(guī)范化用戶名"""
    # 移除首尾空格，轉(zhuǎn)換為小寫
    username = username.strip().lower()
    # 替換空格為下劃線
    username = username.replace(" ", "_")
    return username

usernames = ["  John Doe  ", "Jane Smith", "BOB_JOHNSON"]
normalized = [normalize_username(name) for name in usernames]
print("規(guī)范化后的用戶名:", normalized)

# 分割字符串
text = "apple,banana,orange,grape"
fruits = text.split(",")
print(f"水果列表: {fruits}")

# 限制分割次數(shù)
limited_split = text.split(",", 2)
print(f"限制分割2次: {limited_split}")

# 從右邊分割
path = "/home/user/documents/file.txt"
parts = path.rsplit("/", 1)
print(f"路徑分割: {parts}")

# 按行分割
multiline = """第一行
第二行
第三行"""
lines = multiline.splitlines()
print(f"行列表: {lines}")

# 連接字符串
words = ["Hello", "World", "Python"]
sentence = " ".join(words)
print(f"連接結(jié)果: {sentence}")

# 實(shí)際應(yīng)用：路徑構(gòu)建
import os
directory = "home"
subdir = "user"
filename = "document.pdf"
full_path = os.path.join(directory, subdir, filename)
print(f"完整路徑: {full_path}")

# 去除空白字符
text = "   Python Programming   "

print(f"原始: '{text}'")
print(f"去除首尾: '{text.strip()}'")
print(f"去除左側(cè): '{text.lstrip()}'")
print(f"去除右側(cè): '{text.rstrip()}'")

# 去除指定字符
custom_text = "***Important***"
print(f"去除*號: '{custom_text.strip('*')}'")

# 實(shí)際應(yīng)用：清理用戶輸入
def clean_user_input(user_input):
    """清理用戶輸入"""
    # 去除首尾空白
    cleaned = user_input.strip()
    # 去除多余的內(nèi)部空白
    cleaned = ' '.join(cleaned.split())
    return cleaned

test_inputs = [
    "  hello   world  ",
    "\tPython\nProgramming\n",
    "   too   much   space   "
]

for inp in test_inputs:
    print(f"原始: '{inp}'")
    print(f"清理: '{clean_user_input(inp)}'")
    print("-" * 30)

# 判斷字符串性質(zhì)
test_strings = ["123", "abc", "ABC", "123abc", "", " ", "Python"]

for s in test_strings:
    print(f"字符串: '{s}'")
    print(f"  是否只包含數(shù)字: {s.isdigit()}")
    print(f"  是否只包含字母: {s.isalpha()}")
    print(f"  是否只包含字母和數(shù)字: {s.isalnum()}")
    print(f"  是否只包含空白: {s.isspace()}")
    print(f"  是否為空: {s == ''}")
    print(f"  是否可打印: {s.isprintable()}")
    print("-" * 20)

# 實(shí)際應(yīng)用：輸入驗(yàn)證
def validate_phone_number(phone):
    """驗(yàn)證手機(jī)號"""
    # 去除空格和連字符
    cleaned = phone.replace(" ", "").replace("-", "")
    
    # 檢查是否為11位數(shù)字
    if len(cleaned) == 11 and cleaned.isdigit():
        return True, cleaned
    return False, None

phone_numbers = ["138-1234-5678", "13812345678", "12345", "abc123"]
for phone in phone_numbers:
    valid, cleaned = validate_phone_number(phone)
    print(f"手機(jī)號 '{phone}' -> 有效: {valid}, 清理后: {cleaned}")

# 字符串編碼
text = "你好，世界！"

# 編碼為字節(jié)
utf8_bytes = text.encode('utf-8')
gbk_bytes = text.encode('gbk')

print(f"原始字符串: {text}")
print(f"UTF-8 編碼: {utf8_bytes}")
print(f"GBK 編碼: {gbk_bytes}")

# 從字節(jié)解碼
decoded_utf8 = utf8_bytes.decode('utf-8')
decoded_gbk = gbk_bytes.decode('gbk')

print(f"UTF-8 解碼: {decoded_utf8}")
print(f"GBK 解碼: {decoded_gbk}")

# Unicode 字符
unicode_text = "Hello 世界 ??"

# 查看字符的 Unicode 編碼
for char in unicode_text:
    print(f"字符: {char}, Unicode: U+{ord(char):04X}")

# 創(chuàng)建 Unicode 字符
char1 = chr(65)      # 'A'
char2 = chr(20320)  # '你'
char3 = chr(0x1F30D)  # '??'

print(f"字符: {char1}, {char2}, {char3}")

# Unicode 規(guī)范化
import unicodedata

# 組合字符
text1 = "café"      # 使用組合字符
text2 = "cafe\u0301"  # 使用基礎(chǔ)字符 + 組合重音

print(f"text1: {text1}, text2: {text2}")
print(f"相等: {text1 == text2}")  # False

# 規(guī)范化
normalized1 = unicodedata.normalize('NFC', text1)
normalized2 = unicodedata.normalize('NFC', text2)
print(f"規(guī)范化后相等: {normalized1 == normalized2}")  # True

# ?? 錯(cuò)誤：試圖修改字符串
text = "Hello"
# text[0] = "h"  # TypeError: 'str' object does not support item assignment

# ? 正確：創(chuàng)建新字符串
text = "Hello"
new_text = "h" + text[1:]
print(f"新字符串: {new_text}")

# 大量字符串拼接的性能問題
import time

# 低效方法（大量創(chuàng)建中間字符串）
def slow_concat(n):
    result = ""
    for i in range(n):
        result += str(i)
    return result

# 高效方法（使用列表）
def fast_concat(n):
    parts = []
    for i in range(n):
        parts.append(str(i))
    return "".join(parts)

# 測試性能（使用較小的 n 值）
n = 1000
start = time.time()
slow_result = slow_concat(n)
slow_time = time.time() - start

start = time.time()
fast_result = fast_concat(n)
fast_time = time.time() - start

print(f"慢速方法耗時(shí): {slow_time:.4f}秒")
print(f"快速方法耗時(shí): {fast_time:.4f}秒")
print(f"加速比: {slow_time/fast_time:.2f}倍")

# ?? 編碼錯(cuò)誤
try:
    text = "你好"
    encoded = text.encode('ascii')
except UnicodeEncodeError as e:
    print(f"編碼錯(cuò)誤: {e}")

# ? 錯(cuò)誤處理策略
text = "你好，世界！"

# 策略1：忽略無法編碼的字符
encoded_ignore = text.encode('ascii', errors='ignore')
print(f"忽略錯(cuò)誤: {encoded_ignore}")

# 策略2：替換為 ?
encoded_replace = text.encode('ascii', errors='replace')
print(f"替換錯(cuò)誤: {encoded_replace}")

# 策略3：使用 XML 實(shí)體
encoded_xml = text.encode('ascii', errors='xmlcharrefreplace')
print(f"XML 實(shí)體: {encoded_xml}")

# 解碼錯(cuò)誤處理
bytes_data = b'\xff\xfe'
try:
    decoded = bytes_data.decode('utf-8')
except UnicodeDecodeError as e:
    print(f"解碼錯(cuò)誤: {e}")
    # 使用錯(cuò)誤處理
    decoded = bytes_data.decode('utf-8', errors='replace')
    print(f"替換后: {decoded}")

# ?? 大小寫比較問題
usernames = ["Alice", "alice", "ALICE"]
target = "alice"

# 錯(cuò)誤的比較方式
matches = [name for name in usernames if name == target]
print(f"精確匹配: {matches}")  # 只匹配 "alice"

# ? 正確的比較方式（不區(qū)分大小寫）
matches_casefold = [name for name in usernames if name.casefold() == target.casefold()]
print(f"不區(qū)分大小寫: {matches_casefold}")  # 匹配所有變體

# 更好的方式：使用 casefold()（比 lower() 更強(qiáng)大）
text = "Stra?e"  # 德語中的 "ss"
print(f"lower(): {text.lower()}")
print(f"casefold(): {text.casefold()}")

# 比較前的規(guī)范化
def normalize_string(s):
    """字符串規(guī)范化"""
    return s.strip().casefold()

str1 = "  Hello World  "
str2 = "hello world"
print(f"規(guī)范化前相等: {str1 == str2}")
print(f"規(guī)范化后相等: {normalize_string(str1) == normalize_string(str2)}")

import re

# ?? 貪婪匹配問題
text = "<div>內(nèi)容1</div><div>內(nèi)容2</div>"
pattern_greedy = r"<div>.*</div>"
matches_greedy = re.findall(pattern_greedy, text)
print(f"貪婪匹配: {matches_greedy}")  # 匹配整個(gè)字符串

# ? 非貪婪匹配
pattern_non_greedy = r"<div>.*?</div>"
matches_non_greedy = re.findall(pattern_non_greedy, text)
print(f"非貪婪匹配: {matches_non_greedy}")  # 分別匹配每個(gè) div

# ?? 特殊字符轉(zhuǎn)義
special_text = "價(jià)格: $100.50 (含稅)"
pattern_wrong = "$100.50"  # $ 和 . 都是特殊字符
try:
    matches_wrong = re.findall(pattern_wrong, special_text)
except re.error as e:
    print(f"正則表達(dá)式錯(cuò)誤: {e}")

# ? 正確轉(zhuǎn)義
pattern_correct = r"\$100\.50"
matches_correct = re.findall(pattern_correct, special_text)
print(f"正確匹配: {matches_correct}")

# 使用 re.escape() 自動轉(zhuǎn)義
escaped_pattern = re.escape("$100.50")
print(f"自動轉(zhuǎn)義: {escaped_pattern}")

class LogAnalyzer:
    """簡單的日志分析器"""
    
    def __init__(self, log_content):
        self.log_content = log_content
        self.log_lines = log_content.splitlines()
    
    def count_errors(self):
        """統(tǒng)計(jì)錯(cuò)誤數(shù)量"""
        error_count = 0
        for line in self.log_lines:
            if "ERROR" in line.upper():
                error_count += 1
        return error_count
    
    def find_errors(self):
        """找出所有錯(cuò)誤行"""
        errors = []
        for i, line in enumerate(self.log_lines, 1):
            if "ERROR" in line.upper():
                errors.append((i, line.strip()))
        return errors
    
    def extract_timestamps(self):
        """提取時(shí)間戳"""
        import re
        timestamp_pattern = r'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
        timestamps = re.findall(timestamp_pattern, self.log_content)
        return timestamps
    
    def generate_summary(self):
        """生成日志摘要"""
        total_lines = len(self.log_lines)
        error_count = self.count_errors()
        timestamps = self.extract_timestamps()
        
        summary = f"""
日志摘要:
總條數(shù): {total_lines}
錯(cuò)誤數(shù): {error_count}
時(shí)間范圍: {timestamps[0] if timestamps else '無'} - {timestamps[-1] if timestamps else '無'}
錯(cuò)誤率: {(error_count/total_lines)*100:.1f}%
"""
        return summary

# 測試日志分析器
sample_log = """2024-01-01 10:00:01 INFO 系統(tǒng)啟動
2024-01-01 10:00:02 DEBUG 加載配置文件
2024-01-01 10:00:03 ERROR 數(shù)據(jù)庫連接失敗
2024-01-01 10:00:04 INFO 嘗試重新連接
2024-01-01 10:00:05 ERROR 連接超時(shí)
2024-01-01 10:00:06 WARNING 內(nèi)存使用率過高
2024-01-01 10:00:07 INFO 系統(tǒng)正常運(yùn)行"""

analyzer = LogAnalyzer(sample_log)
print(analyzer.generate_summary())
print("錯(cuò)誤詳情:")
for line_num, error in analyzer.find_errors():
    print(f"第{line_num}行: {error}")

class TextStatistics:
    """文本統(tǒng)計(jì)工具"""
    
    def __init__(self, text):
        self.text = text
        self.clean_text = self._clean_text()
    
    def _clean_text(self):
        """清理文本，去除標(biāo)點(diǎn)符號"""
        import re
        # 保留字母、數(shù)字、空格和中文
        cleaned = re.sub(r'[^\w\s\u4e00-\u9fff]', '', self.text)
        return cleaned
    
    def word_count(self):
        """統(tǒng)計(jì)詞數(shù)"""
        words = self.clean_text.split()
        return len(words)
    
    def character_count(self):
        """統(tǒng)計(jì)字符數(shù)（不含空格）"""
        return len(self.clean_text.replace(" ", ""))
    
    def sentence_count(self):
        """統(tǒng)計(jì)句子數(shù)"""
        import re
        sentences = re.split(r'[.!?。?。縘', self.text)
        # 過濾空句子
        sentences = [s.strip() for s in sentences if s.strip()]
        return len(sentences)
    
    def average_word_length(self):
        """平均詞長"""
        words = self.clean_text.split()
        if not words:
            return 0
        total_length = sum(len(word) for word in words)
        return total_length / len(words)
    
    def most_common_words(self, n=5):
        """最常見的詞"""
        from collections import Counter
        words = self.clean_text.lower().split()
        # 過濾掉太短的詞
        words = [word for word in words if len(word) > 2]
        counter = Counter(words)
        return counter.most_common(n)
    
    def readability_score(self):
        """簡單的可讀性評分"""
        words = self.word_count()
        sentences = self.sentence_count()
        characters = self.character_count()
        
        if sentences == 0 or words == 0:
            return 0
        
        # 平均句長
        avg_sentence_length = words / sentences
        # 平均詞長
        avg_word_length = characters / words
        
        # 簡單的可讀性分?jǐn)?shù)（分?jǐn)?shù)越低越容易閱讀）
        score = avg_sentence_length + avg_word_length * 10
        return round(score, 2)
    
    def generate_report(self):
        """生成完整報(bào)告"""
        report = f"""
文本統(tǒng)計(jì)報(bào)告:
================
總字符數(shù): {len(self.text)}
有效字符數(shù): {self.character_count()}
詞數(shù): {self.word_count()}
句子數(shù): {self.sentence_count()}
平均詞長: {self.average_word_length():.2f}
可讀性評分: {self.readability_score()}

最常見的詞:
"""
        for word, count in self.most_common_words():
            report += f"  {word}: {count}次\n"
        
        return report

# 測試文本統(tǒng)計(jì)
test_text = """
Python 是一種簡潔而強(qiáng)大的編程語言。它具有簡單易學(xué)的語法，
同時(shí)提供了豐富的標(biāo)準(zhǔn)庫和第三方庫。Python 廣泛應(yīng)用于數(shù)據(jù)科學(xué)、
Web開發(fā)、人工智能等領(lǐng)域。它的設(shè)計(jì)哲學(xué)強(qiáng)調(diào)代碼的可讀性和簡潔性。
"""

stats = TextStatistics(test_text)
print(stats.generate_report())