def case_insensitive_search(text, pattern):
    """基礎(chǔ)的大小寫不敏感查找"""
    return pattern.lower() in text.lower()

# 示例：
log_line = "[ERROR] Database connection failed"
print(case_insensitive_search(log_line, "Error"))  # True

def find_case_insensitive(text, pattern):
    """
    查找并返回原始大小寫的匹配結(jié)果
    """
    lower_text = text.lower()
    lower_pattern = pattern.lower()
    pos = lower_text.find(lower_pattern)
    if pos >= 0:
        return text[pos:pos+len(pattern)]
    return None

# 保留原始大小寫的查找
result = find_case_insensitive("PyThon is Powerful", "PYTHON")
print(result)  # "PyThon"

import timeit

# 測(cè)試10萬(wàn)次操作的耗時(shí)
setup = "text = 'A' * 1000000 + 'target'; pattern = 'TARGET'"
t1 = timeit.timeit("pattern.lower() in text.lower()", setup=setup, number=100000)
t2 = timeit.timeit("text.lower().find(pattern.lower()) != -1", setup=setup, number=100000)

print(f"in操作符: {t1:.3f}秒, find方法: {t2:.3f}秒")

import re

# 基礎(chǔ)使用
pattern = re.compile(r"python\d+", re.IGNORECASE)
match = pattern.search("Learn Python3 today!")
print(match.group())  # Python3

# 多模式組合
def find_all_cases(text, words):
    """查找多個(gè)詞語(yǔ)的任意大小寫形式"""
    pattern = re.compile(r"\b(" + "|".join(words) + r")\b", 
                         re.IGNORECASE)
    return pattern.findall(text)

# 示例：
keywords = ["server", "database", "connection"]
matches = find_all_cases("SERVER failed to connect to DATABASE", keywords)
# ['SERVER', 'DATABASE']

def case_insensitive_replace(text, old, new):
    """保留原文本大小寫的替換函數(shù)"""
    pattern = re.compile(re.escape(old), re.IGNORECASE)
    return pattern.sub(new, text)

# 示例：
original = "Python is Great! PYTHON is awesome."
updated = case_insensitive_replace(original, "python", "Java")
# "Java is Great! Java is awesome."

# 正確處理單詞邊界（避免替換部分單詞）
text = "Array indexing and database_index"
pattern = re.compile(r"\bindex\b", re.IGNORECASE)
print(pattern.sub("IDX", text))  # Array IDXing and database_index

import re
import mmap

def large_file_replace(file_path, old, new):
    """大文件內(nèi)存映射替換"""
    pattern = re.compile(re.escape(old), re.IGNORECASE)
    
    with open(file_path, 'r+') as f:
        # 內(nèi)存映射處理
        mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_WRITE)
        
        # 查找所有匹配
        last_position = 0
        while match := pattern.search(mm, last_position):
            start, end = match.span()
            mm.seek(start)
            mm.write(new.encode() + b' ' * (end - start - len(new)))
            last_position = start + len(new)
        
        mm.close()

# 替換100MB日志文件中的關(guān)鍵詞
large_file_replace("app.log", "error", "WARNING")

class CaseInsensitiveStream:
    """大小寫不敏感的流處理器"""
    def __init__(self, stream, chunk_size=4096):
        self.stream = stream
        self.buffer = ""
        self.chunk_size = chunk_size
    
    def read(self, size=-1):
        return self.stream.read(size).lower()
    
    def find(self, pattern):
        """流式查找特定模式"""
        pattern_lower = pattern.lower()
        position = 0
        
        while True:
            # 填充緩沖區(qū)
            if len(self.buffer) < len(pattern_lower) * 2:
                data = self.stream.read(self.chunk_size)
                if not data:
                    break
                self.buffer += data.lower()
            
            # 在緩沖區(qū)中查找
            if (pos := self.buffer.find(pattern_lower)) != -1:
                return position + pos
            
            # 調(diào)整緩沖區(qū)
            keep_size = max(len(pattern_lower), self.chunk_size//2)
            self.buffer = self.buffer[-keep_size:]
            position += self.chunk_size - keep_size
        
        return -1

import regex  # 第三方regex庫(kù)支持高級(jí)模糊匹配

def fuzzy_case_match(text, pattern, max_errors=2):
    """允許大小寫差異和拼寫錯(cuò)誤的模糊匹配"""
    flags = regex.IGNORECASE | regex.BESTMATCH
    matches = regex.findall(rf"({pattern}){{e<={max_errors}}}", text, flags=flags)
    return matches

# 示例：
text = "Authentication failed for usr Admin"
matches = fuzzy_case_match(text, "user admin", max_errors=3)
# ['usr Admin']

def partial_case_insensitive_match(text, pattern):
    """
    部分大小寫敏感的匹配：
    要求首字母大小寫匹配，其余不敏感
    """
    if not pattern:
        return True
    
    # 構(gòu)建靈活的正則表達(dá)式
    regex_pattern = pattern[0]  # 首字母直接匹配
    for char in pattern[1:]:
        if char.isalpha():
            regex_pattern += f"[{char.lower()}{char.upper()}]"
        else:
            regex_pattern += re.escape(char)
    
    return re.search(regex_pattern, text) is not None

# 示例：
print(partial_case_insensitive_match("Admin", "admin"))  # False
print(partial_case_insensitive_match("admin", "admin"))  # True
print(partial_case_insensitive_match("aDmin", "admin"))  # True

from sqlalchemy import func

# 假設(shè)User模型有username字段
def find_user_case_insensitive(username):
    # 方法1：使用func.lower進(jìn)行大小寫轉(zhuǎn)換
    return User.query.filter(func.lower(User.username) == func.lower(username)).first()

    # 方法2：使用SQLite的collate NOCASE（僅適用SQLite）
    # return User.query.filter(User.username.collate('NOCASE') == username).first()

    # 方法3：使用PostgreSQL的citext擴(kuò)展
    # 需要預(yù)先創(chuàng)建citext類型字段
    # return User.query.filter(User.username_citext == username).first()

# 創(chuàng)建函數(shù)索引（MySQL示例）
# 大小寫不敏感索引創(chuàng)建：
CREATE INDEX idx_users_username ON users((lower(username)));

import unicodedata

def normalize_caseless(text):
    """Unicode規(guī)范化處理"""
    return unicodedata.normalize("NFKD", text.casefold())

def casefold_compare(s1, s2):
    """支持Unicode的大小寫不敏感比較"""
    return normalize_caseless(s1) == normalize_caseless(s2)

# 測(cè)試特殊字符
str1 = "stra?e"  # 德語(yǔ)街道
str2 = "STRASSE"  # 大寫形式
print(casefold_compare(str1, str2))  # True

import locale
import re

def tr_insensitive(pattern):
    """土耳其語(yǔ)敏感的大小寫處理"""
    if locale.getlocale()[0] == 'tr_TR':
        # 處理土耳其語(yǔ)特殊的點(diǎn)/無點(diǎn)i
        return re.sub(r'i', r'[i?]', pattern, flags=re.IGNORECASE)
    return pattern

# 使用示例
def locale_sensitive_search(text, pattern):
    locale.setlocale(locale.LC_ALL, 'tr_TR.UTF-8')  # 設(shè)置土耳其語(yǔ)環(huán)境
    pattern = tr_insensitive(pattern)
    return re.search(pattern, text, re.IGNORECASE)

import re
from collections import defaultdict

class LogLevelNormalizer:
    LOG_PATTERN = r"\[([^\]]+)\]"
    
    def __init__(self):
        self.level_mapper = defaultdict(int)
        self.level_patterns = [
            (r"err", "ERROR"),
            (r"fatal", "FATAL"),
            (r"warn", "WARN"),
            (r"info", "INFO"),
            (r"debug", "DEBUG")
        ]
    
    def normalize(self, log_line):
        """規(guī)范日志級(jí)別大小寫格式"""
        if match := re.search(self.LOG_PATTERN, log_line):
            original_level = match.group(1)
            normalized = self._map_level(original_level)
            return log_line.replace(f"[{original_level}]", f"[{normalized}]")
        return log_line
    
    def _map_level(self, level):
        """匹配并映射日志級(jí)別"""
        level_lower = level.lower()
        for pattern, normalized in self.level_patterns:
            if re.search(pattern, level_lower):
                self.level_mapper[level] = normalized
                return normalized
        return "UNKNOWN"  # 未知日志級(jí)別處理

# 使用示例：
normalizer = LogLevelNormalizer()
print(normalizer.normalize("[ERror] DB connection failed"))  # [ERROR] DB connection failed

# 使用casefold()處理國(guó)際字符
text.casefold()  # 優(yōu)于text.lower()

# 一次編譯，多次使用
pattern = re.compile(r"critical", re.IGNORECASE)
results = pattern.findall(big_data)

# 內(nèi)存映射+滑動(dòng)窗口處理
with open("huge.log") as f:
    window = collections.deque(maxlen=4096)
    for chunk in iter(lambda: f.read(1024), ''):
        window.extend(chunk)
        # 在窗口中進(jìn)行不區(qū)分大小寫搜索

# 明確指定編碼
with open("data.txt", encoding='utf-8', errors='ignore') as f:
    text = f.read()

# 數(shù)據(jù)庫(kù)查詢參數(shù)化
cursor.execute(
    "SELECT * FROM users WHERE LOWER(username)= %s",
    (username.lower(),)
)

import locale
# 設(shè)置系統(tǒng)語(yǔ)言環(huán)境
locale.setlocale(locale.LC_ALL, 'en_US.UTF-8')