15 строковых методов в Python: мастер-класс по обработке текста

# Одинарные кавычки
s1 = 'Привет, Python!'

# Двойные кавычки
s2 = "Строки очень удобны"

# Тройные кавычки для многострочного текста
s3 = """Это многострочная
строка в Python.
Удобно, не правда ли?"""

# Raw-строки игнорируют экранирование
raw_string = r"C:\Users\Username\Documents"

# Конкатенация строк
greeting = "Привет, " + "мир!" # Результат: "Привет, мир!"

# Повторение строки
stars = "*" * 10 # Результат: "**********"

text = "Python"
print(text[0]) # 'P'
print(text[-1]) # 'n'
print(text[1:4]) # 'yth'
print(text[:2]) # 'Py'
print(text[2:]) # 'thon'
print(text[::2]) # 'Pto' (каждый второй символ)

text = "Python – это мощный и удобный язык программирования."

# Поиск подстроки
print(text.find("мощный")) # 12
print(text.find("Java")) # -1 (не найдено)

# index() работает аналогично, но вызывает исключение, если подстрока не найдена
print(text.index("мощный")) # 12
# print(text.index("Java")) # ValueError: substring not found

text = "Python Python Python"
print(text.rfind("Python")) # 14 (позиция последнего вхождения)
print(text.find("Python")) # 0 (позиция первого вхождения)

text = "Python Python Python"
print(text.count("Python")) # 3
print(text.count("P")) # 3
print(text.count("on")) # 3

text = "Python Python Python"
print(text.find("Python", 5)) # 7 (начиная с 5-го индекса)
print(text.find("Python", 5, 10)) # -1 (в диапазоне от 5 до 10)

import re

text = "Телефон: +7(123)456-78-90, email: example@example.com"

# Поиск телефонного номера
phone = re.search(r'\+7\(\d{3}\)\d{3}-\d{2}-\d{2}', text)
print(phone.group() if phone else "Номер не найден") # +7(123)456-78-90

# Поиск email
email = re.search(r'\S+@\S+\.\S+', text)
print(email.group() if email else "Email не найден") # example@example.com

filename = "document.pdf"
print(filename.startswith("doc")) # True
print(filename.endswith(".pdf")) # True
print(filename.endswith((".pdf", ".docx", ".txt"))) # True (проверка нескольких вариантов)

log_entry = "2023-10-15 14:30:45 ERROR: Database connection failed"

# Извлечение даты и времени
datetime_str = log_entry[:19]
print(datetime_str) # "2023-10-15 14:30:45"

# Извлечение уровня логирования
level = log_entry[20:].split(':')[0]
print(level) # "ERROR"

# Извлечение сообщения
message = log_entry[20:].split(': ')[1]
print(message) # "Database connection failed"

# Удаление пробелов с обоих концов
text = " Python "
print(text.strip()) # "Python"

# Удаление пробелов только слева
print(text.lstrip()) # "Python "

# Удаление пробелов только справа
print(text.rstrip()) # " Python"

# Можно указать, какие символы удалять
price = "$100.00$"
print(price.strip("$")) # "100.00"

# Разделение по пробелам (по умолчанию)
sentence = "Python это мощный язык программирования"
words = sentence.split()
print(words) # ['Python', 'это', 'мощный', 'язык', 'программирования']

# Разделение по конкретному символу
csv_data = "1,2,3,4,5"
values = csv_data.split(",")
print(values) # ['1', '2', '3', '4', '5']

# Ограничение количества разделений
limited_split = sentence.split(" ", 2)
print(limited_split) # ['Python', 'это', 'мощный язык программирования']

# Объединение списка строк
words = ['Python', 'это', 'мощный', 'язык']
sentence = " ".join(words)
print(sentence) # "Python это мощный язык"

# Объединение с другими разделителями
csv_row = ",".join(['1', '2', '3', '4', '5'])
print(csv_row) # "1,2,3,4,5"

# Объединение строк с переносом строки
lines = ['Первая строка', 'Вторая строка', 'Третья строка']
text = "\n".join(lines)
print(text)
# Первая строка
# Вторая строка
# Третья строка

text = "Python Programming"

# Все буквы в нижний регистр
print(text.lower()) # "python programming"

# Все буквы в верхний регистр
print(text.upper()) # "PYTHON PROGRAMMING"

# Первый символ каждого слова в верхний регистр
print("hello world".title()) # "Hello World"

# Первый символ строки в верхний регистр
print("hello".capitalize()) # "Hello"

# Инверсия регистра
print("Hello World".swapcase()) # "hELLO wORLD"

text = "Python это Python и ещё раз Python"

# Замена всех вхождений
print(text.replace("Python", "Java")) 
# "Java это Java и ещё раз Java"

# Ограничение количества замен
print(text.replace("Python", "Java", 2)) 
# "Java это Java и ещё раз Python"

# Только буквы?
print("Python".isalpha()) # True
print("Python3".isalpha()) # False

# Только цифры?
print("12345".isdigit()) # True
print("123.45".isdigit()) # False

# Расширенные проверки цифр
print("²³¹".isdigit()) # True (Unicode цифры)
print("²³¹".isnumeric()) # True (любые числовые символы)
print("²³¹".isdecimal()) # False (только десятичные цифры)

# Буквы и цифры?
print("Python3".isalnum()) # True
print("Python 3".isalnum()) # False (содержит пробел)

# Только пробельные символы?
print(" \t\n".isspace()) # True
print(" a ".isspace()) # False

# Все символы в нижнем регистре?
print("python".islower()) # True
print("Python".islower()) # False

# Все символы в верхнем регистре?
print("PYTHON".isupper()) # True
print("Python".isupper()) # False

# Начинается ли каждое слово с заглавной буквы?
print("Python Programming".istitle()) # True
print("Python programming".istitle()) # False

filename = "report.pdf"

# Проверка расширения файла
print(filename.endswith(".pdf")) # True
print(filename.endswith((".pdf", ".docx", ".txt"))) # True (проверка нескольких вариантов)

# Проверка префикса
print(filename.startswith("report")) # True
print(filename.startswith(("report", "annual", "monthly"))) # True

def validate_username(username):
"""Проверяет, что имя пользователя содержит только буквы,
цифры и знаки подчёркивания, начинается с буквы и имеет
длину от 3 до 20 символов."""
if not username[0].isalpha():
return False, "Имя должно начинаться с буквы"

if not all(c.isalnum() or c == '_' for c in username):
return False, "Имя может содержать только буквы, цифры и знаки подчёркивания"

if not 3 <= len(username) <= 20:
return False, "Длина имени должна быть от 3 до 20 символов"

return True, "Имя корректно"

# Проверка валидности email (простая реализация)
def is_valid_email(email):
"""Простая проверка формата email."""
if not '@' in email:
return False

local, domain = email.split('@', 1)

if not local or not domain:
return False

if not '.' in domain:
return False

return True

# Проверка надёжности пароля
def check_password_strength(password):
"""Проверяет силу пароля."""
if len(password) < 8:
return "Слабый", "Пароль должен содержать минимум 8 символов"

checks = [
any(c.isupper() for c in password), # Заглавные буквы
any(c.islower() for c in password), # Строчные буквы
any(c.isdigit() for c in password), # Цифры
any(not c.isalnum() for c in password) # Специальные символы
]

strength = sum(checks)
if strength == 4:
return "Сильный", "Пароль соответствует всем требованиям"
elif strength >= 2:
return "Средний", "Рекомендуется добавить разные типы символов"
else:
return "Слабый", "Пароль должен содержать разные типы символов"

def analyze_text(text):
"""Анализирует текст и возвращает статистику."""
# Проверка на пустой текст
if not text.strip():
return {"error": "Пустой текст"}

# Разделение на предложения (простая реализация)
sentences = [s.strip() for s in text.replace('!', '.').replace('?', '.').split('.') if s.strip()]

# Разделение на слова и очистка
words = []
for sentence in sentences:
words.extend([word.strip('.,;:()-"\'').lower() 
for word in sentence.split() 
if word.strip('.,;:()-"\'")])

# Подсчет частоты слов
word_freq = {}
for word in words:
if word: # Игнорируем пустые строки
word_freq[word] = word_freq.get(word, 0) + 1

# Статистика
stats = {
"sentence_count": len(sentences),
"word_count": len(words),
"unique_word_count": len(word_freq),
"most_common_words": sorted(word_freq.items(), key=lambda x: x[1], reverse=True)[:5]
}

return stats

# Пример использования
sample_text = """
Python – это интерпретируемый, объектно-ориентированный, высокоуровневый язык программирования с динамической семантикой.
Его высокоуровневые встроенные структуры данных, в сочетании с динамической типизацией и динамическим связыванием,
делают его привлекательным для быстрой разработки приложений. Python прост в освоении и использовании!
"""

print(analyze_text(sample_text))

def format_phone_number(phone):
"""
Форматирует номер телефона в стандартный вид: +7 (XXX) XXX-XX-XX
Принимает различные форматы ввода.
"""
# Удаляем все нецифровые символы
digits = ''.join(c for c in phone if c.isdigit())

# Проверка длины номера
if len(digits) < 10 or len(digits) > 11:
return None, "Неправильная длина номера телефона"

# Обработка номера без кода страны
if len(digits) == 10:
digits = '7' + digits

# Проверка кода страны
if digits[0] not in ['7', '8']:
return None, "Неправильный код страны"

# Форматирование номера
formatted = '+7 ({}) {}-{}-{}'.format(
digits[1:4], digits[4:7], digits[7:9], digits[9:11]
)

return formatted, "Номер успешно отформатирован"

# Примеры использования
test_numbers = [
"+7(123)456-78-90",
"8123-456-78-90",
"123-456-7890",
"+7 (123) 4567890",
"9123456789" # Неверный формат
]

for number in test_numbers:
formatted, message = format_phone_number(number)
print(f"{number}: {formatted if formatted else 'Ошибка'} – {message}")

def generate_slug(title):
"""
Преобразует заголовок в URL-слаг:
- удаляет лишние пробелы
- переводит в нижний регистр
- заменяет пробелы на дефисы
- удаляет специальные символы
- транслитерирует кириллицу (упрощенно)
"""
# Словарь для транслитерации (упрощенный)
transliteration = {
'а': 'a', 'б': 'b', 'в': 'v', 'г': 'g', 'д': 'd', 'е': 'e', 'ё': 'e',
'ж': 'zh', 'з': 'z', 'и': 'i', 'й': 'y', 'к': 'k', 'л': 'l', 'м': 'm',
'н': 'n', 'о': 'o', 'п': 'p', 'р': 'r', 'с': 's', 'т': 't', 'у': 'u',
'ф': 'f', 'х': 'h', 'ц': 'ts', 'ч': 'ch', 'ш': 'sh', 'щ': 'sch',
'ъ': '', 'ы': 'y', 'ь': '', 'э': 'e', 'ю': 'yu', 'я': 'ya'
}

# Удаляем лишние пробелы и приводим к нижнему регистру
title = title.strip().lower()

# Транслитерация кириллицы
result = ''
for char in title:
if char in transliteration:
result += transliteration[char]
elif char.isalnum() or char in ' -':
result += char
else:
result += ' ' # Заменяем спецсимволы пробелами

# Заменяем пробелы на дефисы и удаляем дубликаты дефисов
slug = '-'.join(word for word in result.split() if word)

# Ограничиваем длину слага
max_length = 80
if len(slug) > max_length:
slug = slug[:max_length].rsplit('-', 1)[0]

return slug

# Примеры использования
titles = [
"Работа со строками в Python: 15 основных методов",
"Как использовать f-строки и форматирование в Python 3.6+",
"Разработка веб-приложений на Django: практическое руководство для начинающих!"
]

for title in titles:
print(f"Оригинал: {title}")
print(f"Слаг: {generate_slug(title)}")
print()

def parse_csv(csv_text, delimiter=',', quote_char='"', has_header=True):
"""
Парсит текст в формате CSV и возвращает список словарей или список списков.

Args:
csv_text (str): Текст в формате CSV
delimiter (str): Разделитель полей
quote_char (str): Символ кавычек для полей с разделителями
has_header (bool): Флаг наличия строки заголовков

Returns:
list: Список словарей (если has_header=True) или список списков
"""
lines = [line.strip() for line in csv_text.strip().split('\n') if line.strip()]
if not lines:
return []

def parse_line(line):
"""Парсит одну строку CSV с учетом кавычек."""
fields = []
current_field = []
in_quotes = False

for char in line:
if char == quote_char and (not current_field or in_quotes):
in_quotes = not in_quotes
elif char == delimiter and not in_quotes:
fields.append(''.join(current_field))
current_field = []
else:
current_field.append(char)

# Добавляем последнее поле
fields.append(''.join(current_field))

# Убираем кавычки из полей
return [field.strip().strip(quote_char) for field in fields]

# Парсим все строки
parsed_lines = [parse_line(line) for line in lines]

if not has_header:
return parsed_lines

# Используем первую строку как заголовки
headers = parsed_lines[0]
data = []

for line in parsed_lines[1:]:
row_dict = {}
for i, value in enumerate(line):
if i < len(headers):
row_dict[headers[i]] = value
data.append(row_dict)

return data

# Пример использования
csv_sample = '''
"Имя","Возраст","Город"
"Иван Петров","28","Москва"
"Анна Сидорова","24","Санкт-Петербург"
"Алексей Иванов, младший","32","Казань"
'''

parsed_data = parse_csv(csv_sample)
for row in parsed_data:
print(row)