Кодеки в Python: принципы работы с UTF-8 и обработка ошибок

# Кодирование: str → bytes
text = "Привет, мир!"
encoded_bytes = text.encode('utf-8')
print(encoded_bytes) # b'\xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82, \xd0\xbc\xd0\xb8\xd1\x80!'

# Декодирование: bytes → str
decoded_text = encoded_bytes.decode('utf-8')
print(decoded_text) # Привет, мир!

import codecs

# Открытие файла с указанием кодировки
with codecs.open('file.txt', 'r', encoding='utf-8') as f:
content = f.read()

# Получение информации о кодеке
encoder, decoder, reader, writer = codecs.lookup('utf-8')

import locale
print(locale.getpreferredencoding()) # Получение системной кодировки по умолчанию

# Анализ размера символов в UTF-8
symbols = ['A', 'Ж', '漢', '𠜎']
for symbol in symbols:
encoded = symbol.encode('utf-8')
print(f"Символ '{symbol}' занимает {len(encoded)} байт в UTF-8: {encoded}")

# Результат:
# Символ 'A' занимает 1 байт в UTF-8: b'A'
# Символ 'Ж' занимает 2 байта в UTF-8: b'\xd0\x96'
# Символ '漢' занимает 3 байта в UTF-8: b'\xe6\xbc\xa2'
# Символ '𠜎' занимает 4 байта в UTF-8: b'\xf0\xa0\x9c\x8e'

# Чтение файла в UTF-8
with open('file.txt', 'r', encoding='utf-8') as f:
content = f.read()

# Запись файла в UTF-8 
with open('output.txt', 'w', encoding='utf-8') as f:
f.write('Текст с символами UTF-8: 你好, مرحبا, привет')

# Использование Unicode в строковых литералах и комментариях
variable_name = "значение" # это комментарий на русском
greeting = "你好" # переменная со значением на китайском

# Использование Unicode в именах переменных (хотя это не рекомендуется)
переменная = 42
print(переменная) # выведет 42

# Пример неверной кодировки
bytes_data = b'\xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82\xff' # Последний байт некорректен для UTF-8

# Разные стратегии обработки ошибок
try:
# По умолчанию вызывает исключение
text_strict = bytes_data.decode('utf-8', errors='strict')
except UnicodeDecodeError as e:
print(f"Strict error: {e}")

# Замена на символ замены ()
text_replace = bytes_data.decode('utf-8', errors='replace')
print(f"Replace: {text_replace}")

# Игнорирование некорректных байтов
text_ignore = bytes_data.decode('utf-8', errors='ignore')
print(f"Ignore: {text_ignore}")

# Экранирование в виде \xNN
text_escape = bytes_data.decode('utf-8', errors='backslashreplace')
print(f"Backslash: {text_escape}")

def read_file_with_fallbacks(filename, preferred_encodings=None):
"""Чтение файла с автоматическим определением кодировки."""
if preferred_encodings is None:
preferred_encodings = ['utf-8', 'cp1251', 'latin1']

for encoding in preferred_encodings:
try:
with open(filename, 'r', encoding=encoding) as f:
return f.read()
except UnicodeDecodeError:
continue

# Если не удалось декодировать ни одной кодировкой, используем latin1
# (гарантированно не вызовет ошибку, так как отображает любой байт в диапазон 0-255)
with open(filename, 'r', encoding='latin1') as f:
return f.read()

import chardet

def detect_and_read(filename):
"""Определяет кодировку файла и читает его с этой кодировкой."""
# Чтение бинарных данных
with open(filename, 'rb') as f:
raw_data = f.read()

# Определение кодировки
result = chardet.detect(raw_data)
encoding = result['encoding']
confidence = result['confidence']

print(f"Detected encoding: {encoding} with confidence {confidence:.2f}")

# Декодирование с определенной кодировкой
return raw_data.decode(encoding)

import chardet

def identify_file_encoding(filename, sample_size=10000):
"""Определяет вероятную кодировку файла."""
with open(filename, 'rb') as f:
# Чтение образца файла для анализа
sample = f.read(sample_size)

result = chardet.detect(sample)
return {
'encoding': result['encoding'],
'confidence': result['confidence'],
'language': result.get('language', 'unknown')
}

# Пример использования
encoding_info = identify_file_encoding('mysterious_data.txt')
print(f"File is probably encoded in {encoding_info['encoding']} "
f"({encoding_info['confidence']:.1%} confident)")

import requests
from bs4 import BeautifulSoup

def get_webpage_with_encoding(url):
"""Получает веб-страницу и определяет её кодировку из заголовков или HTML."""
response = requests.get(url)

# Попытка определить кодировку из заголовков HTTP
content_type = response.headers.get('Content-Type', '')
if 'charset=' in content_type:
encoding = content_type.split('charset=')[1].split(';')[0].strip()
print(f"Encoding from HTTP headers: {encoding}")
else:
encoding = response.encoding
print(f"Encoding determined by requests: {encoding}")

# Проверка наличия метатега с указанием кодировки
soup = BeautifulSoup(response.content, 'html.parser')
meta_charset = soup.find('meta', charset=True)
meta_content_type = soup.find('meta', {'http-equiv': 'Content-Type'})

if meta_charset:
html_encoding = meta_charset.get('charset')
print(f"Encoding from HTML meta charset: {html_encoding}")
elif meta_content_type:
content = meta_content_type.get('content', '')
if 'charset=' in content:
html_encoding = content.split('charset=')[1].split(';')[0].strip()
print(f"Encoding from HTML meta Content-Type: {html_encoding}")

# Используем определенную кодировку для декодирования содержимого
return response.content.decode(encoding, errors='replace')

import csv
import codecs

def read_csv_with_encoding(filename, encoding='utf-8', delimiter=','):
"""Читает CSV-файл с указанной кодировкой."""
with codecs.open(filename, 'r', encoding=encoding, errors='replace') as f:
reader = csv.reader(f, delimiter=delimiter)
return list(reader)

def write_csv_with_encoding(filename, data, encoding='utf-8', delimiter=','):
"""Записывает данные в CSV-файл с указанной кодировкой."""
with codecs.open(filename, 'w', encoding=encoding) as f:
writer = csv.writer(f, delimiter=delimiter)
writer.writerows(data)

import psycopg2

def setup_db_connection_with_encoding():
"""Устанавливает соединение с PostgreSQL с явным указанием кодировки."""
conn = psycopg2.connect(
dbname="mydb",
user="user",
password="password",
host="localhost",
client_encoding='UTF8' # Явное указание кодировки для клиентских данных
)
return conn

# Для MySQL/MariaDB
import mysql.connector

def mysql_connection_with_encoding():
"""Устанавливает соединение с MySQL с явным указанием кодировки."""
conn = mysql.connector.connect(
host="localhost",
user="user",
password="password",
database="mydb",
charset='utf8mb4', # Поддержка полного диапазона Unicode, включая эмодзи
collation='utf8mb4_unicode_ci'
)
return conn

class TextProcessor:
"""Класс для унифицированной обработки текста с различными кодировками."""

def __init__(self, default_encoding='utf-8', fallback_encodings=None):
self.default_encoding = default_encoding
self.fallback_encodings = fallback_encodings or ['cp1251', 'latin1']

def read_file(self, filename, encoding=None):
"""Читает файл с автоопределением кодировки при необходимости."""
if encoding:
try:
with open(filename, 'r', encoding=encoding) as f:
return f.read()
except UnicodeDecodeError:
pass # Переходим к автоопределению при ошибке

# Пробуем стандартную кодировку и запасные варианты
encodings_to_try = [self.default_encoding] + self.fallback_encodings
for enc in encodings_to_try:
try:
with open(filename, 'r', encoding=enc) as f:
return f.read()
except UnicodeDecodeError:
continue

# Если все попытки не удались, используем детектирование
return self._detect_and_read(filename)

def _detect_and_read(self, filename):
"""Определяет кодировку файла и читает его."""
import chardet

with open(filename, 'rb') as f:
raw_data = f.read()

result = chardet.detect(raw_data)
encoding = result['encoding'] or 'latin1'

return raw_data.decode(encoding, errors='replace')

def write_file(self, filename, content, encoding=None):
"""Записывает содержимое в файл с указанной кодировкой."""
with open(filename, 'w', encoding=encoding or self.default_encoding) as f:
f.write(content)

def convert_encoding(self, text, from_encoding, to_encoding):
"""Конвертирует текст из одной кодировки в другую."""
# Сначала декодируем из исходной кодировки в Unicode
if isinstance(text, bytes):
unicode_text = text.decode(from_encoding, errors='replace')
else:
# Если текст уже в Unicode, кодируем в from_encoding и декодируем обратно
# для имитации конвертации (может привести к потере данных)
unicode_text = text.encode(from_encoding, errors='replace').decode(from_encoding)

# Затем кодируем в целевую кодировку и декодируем обратно в Unicode
return unicode_text.encode(to_encoding, errors='replace').decode(to_encoding)

import time
import sys

# Тестирование производительности различных подходов
def benchmark_string_processing():
# Создаем большой текст с не-ASCII символами
text = "Привет, мир! " * 100000
bytes_data = text.encode('utf-8')

# Тест 1: Постепенная конкатенация строк
start = time.time()
result1 = ""
for char in text:
result1 += char.upper()
time1 = time.time() – start

# Тест 2: Список с join
start = time.time()
chars = []
for char in text:
chars.append(char.upper())
result2 = ''.join(chars)
time2 = time.time() – start

# Тест 3: Генератор списка с join
start = time.time()
result3 = ''.join(char.upper() for char in text)
time3 = time.time() – start

# Тест 4: Встроенный метод upper
start = time.time()
result4 = text.upper()
time4 = time.time() – start

print(f"Concatenation: {time1:.4f}s")
print(f"List + join: {time2:.4f}s")
print(f"Generator + join: {time3:.4f}s")
print(f"Built-in method: {time4:.4f}s")

# Проверка одинаковости результатов
assert result1 == result2 == result3 == result4

def unicode_shield(func):
"""Декоратор для защиты функций от Unicode-ошибок."""
def wrapper(*args, **kwargs):
try:
return func(*args, **kwargs)
except UnicodeError as e:
# Логируем ошибку с контекстом
import logging
logging.error(f"Unicode error in {func.__name__}: {e}")

# Пытаемся восстановиться, применяя более лояльную стратегию
# к аргументам, которые могут быть строками
new_args = []
for arg in args:
if isinstance(arg, bytes):
# Пробуем различные кодировки
for enc in ['utf-8', 'latin1', 'cp1251']:
try:
new_args.append(arg.decode(enc, errors='replace'))
break
except UnicodeError:
continue
else:
# Если все попытки не удались, используем latin1
new_args.append(arg.decode('latin1', errors='replace'))
elif isinstance(arg, str):
# Убедимся, что строка не содержит суррогатных пар
new_args.append(arg.encode('utf-8', errors='replace').decode('utf-8'))
else:
new_args.append(arg)

# Аналогично для keyword-аргументов
new_kwargs = {}
for key, value in kwargs.items():
if isinstance(value, bytes) or isinstance(value, str):
# Аналогичная обработка как для args
# ...
pass
else:
new_kwargs[key] = value

# Повторная попытка с "очищенными" аргументами
return func(*new_args, **new_kwargs)

return wrapper

# Пример использования декоратора
@unicode_shield
def process_user_input(text):
"""Обработка пользовательского ввода с защитой от Unicode-ошибок."""
# Какая-то обработка текста
return text.upper()