Основы работы со строками (string) в Python: создание, методы и манипуляции с текстовыми данными

Онлайн-тренажер Python для начинающих

Изучайте Python легко и без перегрузки теорией. Решайте практические задачи с автоматической проверкой, получайте подсказки на русском языке и пишите код прямо в браузере — без необходимости что-либо устанавливать.

Начать курс

Самоучитель Python 3, собранный из материалов данного сайта.Предназначен в основном для тех, кто хочет изучить язык программирования Python с нуля.

Полная таблица методов строк в Python

Метод	Описание	Пример
`upper()`	Преобразование в верхний регистр	`"hello".upper()` → `"HELLO"`
`lower()`	Преобразование в нижний регистр	`"HELLO".lower()` → `"hello"`
`capitalize()`	Первая буква заглавная, остальные строчные	`"hello world".capitalize()` → `"Hello world"`
`title()`	Каждое слово с заглавной буквы	`"hello world".title()` → `"Hello World"`
`swapcase()`	Инверсия регистра	`"Hello".swapcase()` → `"hELLO"`
`casefold()`	Агрессивное приведение к нижнему регистру	`"ß".casefold()` → `"ss"`

Методы очистки и выравнивания

Метод	Описание	Пример
`strip()`	Удаление пробелов с краев	`" hello ".strip()` → `"hello"`
`lstrip()`	Удаление пробелов слева	`" hello ".lstrip()` → `"hello "`
`rstrip()`	Удаление пробелов справа	`" hello ".rstrip()` → `" hello"`
`strip(chars)`	Удаление указанных символов	`"...hello...".strip(".")` → `"hello"`
`center(width)`	Центрирование строки	`"hi".center(10)` → `" hi "`
`ljust(width)`	Выравнивание по левому краю	`"hi".ljust(10)` → `"hi "`
`rjust(width)`	Выравнивание по правому краю	`"hi".rjust(10)` → `" hi"`
`zfill(width)`	Заполнение нулями слева	`"42".zfill(5)` → `"00042"`

Методы замены и модификации

Метод	Описание	Пример
`replace(old, new)`	Замена подстроки	`"hello".replace("l", "x")` → `"hexxo"`
`replace(old, new, count)`	Замена с ограничением количества	`"hello".replace("l", "x", 1)` → `"hexlo"`
`translate(table)`	Замена по таблице символов	`"hello".translate(str.maketrans("l", "x"))` → `"hexxo"`
`expandtabs(tabsize)`	Замена табуляции пробелами	`"a\tb".expandtabs(4)` → `"a b"`

Методы разделения и объединения

Метод	Описание	Пример
`split()`	Разделение по пробелам	`"a b c".split()` → `["a", "b", "c"]`
`split(sep)`	Разделение по разделителю	`"a,b,c".split(",")` → `["a", "b", "c"]`
`split(sep, maxsplit)`	Разделение с лимитом	`"a,b,c".split(",", 1)` → `["a", "b,c"]`
`rsplit()`	Разделение справа	`"a.b.c".rsplit(".", 1)` → `["a.b", "c"]`
`splitlines()`	Разделение по строкам	`"a\nb\nc".splitlines()` → `["a", "b", "c"]`
`partition(sep)`	Разделение на 3 части	`"hello-world".partition("-")` → `("hello", "-", "world")`
`rpartition(sep)`	Разделение справа на 3 части	`"a.b.c".rpartition(".")` → `("a.b", ".", "c")`
`join(iterable)`	Объединение списка	`",".join(["a", "b", "c"])` → `"a,b,c"`

Методы поиска

Метод	Описание	Пример
`find(sub)`	Поиск подстроки (индекс)	`"hello".find("ll")` → `2`
`find(sub, start)`	Поиск с начальной позиции	`"hello".find("l", 3)` → `3`
`find(sub, start, end)`	Поиск в диапазоне	`"hello".find("l", 0, 2)` → `-1`
`rfind(sub)`	Поиск справа	`"hello".rfind("l")` → `3`
`index(sub)`	Поиск с исключением	`"hello".index("ll")` → `2`
`rindex(sub)`	Поиск справа с исключением	`"hello".rindex("l")` → `3`
`count(sub)`	Подсчет вхождений	`"hello".count("l")` → `2`
`count(sub, start, end)`	Подсчет в диапазоне	`"hello".count("l", 0, 3)` → `1`

Методы проверки начала и конца

Метод	Описание	Пример
`startswith(prefix)`	Проверка начала	`"hello".startswith("he")` → `True`
`startswith(tuple)`	Проверка нескольких префиксов	`"hello".startswith(("he", "hi"))` → `True`
`endswith(suffix)`	Проверка конца	`"hello".endswith("lo")` → `True`
`endswith(tuple)`	Проверка нескольких суффиксов	`"hello".endswith(("lo", "la"))` → `True`

Методы проверки типа символов

Метод	Описание	Пример
`isdigit()`	Проверка на цифры	`"123".isdigit()` → `True`
`isalpha()`	Проверка на буквы	`"abc".isalpha()` → `True`
`isalnum()`	Проверка на буквы и цифры	`"abc123".isalnum()` → `True`
`isspace()`	Проверка на пробельные символы	`" ".isspace()` → `True`
`islower()`	Проверка на нижний регистр	`"hello".islower()` → `True`
`isupper()`	Проверка на верхний регистр	`"HELLO".isupper()` → `True`
`istitle()`	Проверка на заголовочный регистр	`"Hello World".istitle()` → `True`
`isascii()`	Проверка на ASCII символы	`"hello".isascii()` → `True`
`isdecimal()`	Проверка на десятичные числа	`"123".isdecimal()` → `True`
`isnumeric()`	Проверка на числовые символы	`"123".isnumeric()` → `True`
`isidentifier()`	Проверка на валидный идентификатор	`"var_name".isidentifier()` → `True`
`isprintable()`	Проверка на печатные символы	`"hello".isprintable()` → `True`

Методы кодирования

Метод	Описание	Пример
`encode()`	Кодирование в байты	`"hello".encode()` → `b'hello'`
`encode(encoding)`	Кодирование в указанной кодировке	`"привет".encode("utf-8")` → `b'\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82'`

Методы форматирования

Метод	Описание	Пример
`format(args, *kwargs)`	Форматирование строки	`"Hello {}".format("world")` → `"Hello world"`
`format_map(mapping)`	Форматирование через словарь	`"Hello {name}".format_map({"name": "world"})` → `"Hello world"`

Все эти методы возвращают новую строку, не изменяя исходную, поскольку строки в Python неизменяемы (immutable).

Создание строк в Python

Строки в Python представляют собой упорядоченные последовательности символов и являются одним из основных типов данных. Они могут быть созданы несколькими способами:

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

# Двойные кавычки
my_string = "Привет, мир!"

# Тройные кавычки для многострочных строк
my_string = '''Это многострочная
строка в Python'''

# Тройные двойные кавычки
my_string = """Ещё один способ
создания многострочной строки"""

Индексация и доступ к символам

В Python каждый символ строки имеет свой индекс, начиная с 0. Поддерживается как положительная, так и отрицательная индексация:

my_string = "Python"
print(my_string[0])    # P (первый символ)
print(my_string[-1])   # n (последний символ)
print(my_string[2])    # t (третий символ)
print(my_string[-2])   # o (предпоследний символ)

Срезы строк (slicing)

Срезы позволяют извлекать подстроки из строки. Синтаксис: string[start:stop:step]

my_string = "Hello, World!"

# Основные срезы
print(my_string[7:])     # World! (с 7-го символа до конца)
print(my_string[:5])     # Hello (с начала до 5-го символа)
print(my_string[2:8])    # llo, W (с 2-го до 8-го символа)

# Срезы с шагом
print(my_string[::2])    # Hlo ol! (каждый второй символ)
print(my_string[2::3])   # l r! (с 2-го символа с шагом 3)

# Обратный порядок
print(my_string[::-1])   # !dlroW ,olleH (вся строка в обратном порядке)

# Отрицательные индексы в срезах
print(my_string[-6:-1])  # World (с -6-го до -1-го символа)
print(my_string[-6:])    # World! (с -6-го символа до конца)
print(my_string[-1:-7:-1])  # !dlroW (обратный срез)

Основные операции со строками

Определение длины строки

my_string = "Hello, World!"
print(len(my_string))  # 13

Конкатенация (объединение) строк

string1 = "Hello"
string2 = "World"
result = string1 + ", " + string2 + "!"
print(result)  # Hello, World!

# Повторение строки
repeated = "Python " * 3
print(repeated)  # Python Python Python

Проверка содержания подстроки

text = "Python - мощный язык программирования"
print("Python" in text)        # True
print("Java" not in text)      # True
print("мощный" in text)        # True

Форматирование строк

Метод format()

name = "Анна"
age = 25
city = "Москва"

# Позиционные аргументы
formatted = "Меня зовут {}, мне {} лет, я живу в {}".format(name, age, city)
print(formatted)

# Именованные аргументы
formatted = "Меня зовут {name}, мне {age} лет".format(name=name, age=age)
print(formatted)

# Индексы
formatted = "Меня зовут {0}, мне {1} лет, я живу в {2}".format(name, age, city)
print(formatted)

F-строки (форматированные строковые литералы)

name = "Анна"
age = 25
print(f"Меня зовут {name}, мне {age} лет")

# Выражения в f-строках
print(f"Через 5 лет мне будет {age + 5} лет")

# Форматирование чисел
price = 1234.5678
print(f"Цена: {price:.2f} рублей")  # Цена: 1234.57 рублей

Старый стиль форматирования (%)

name = "Анна"
age = 25
print("Меня зовут %s, мне %d лет" % (name, age))

Основные методы строк

Методы изменения регистра

text = "Python Programming"

print(text.upper())      # PYTHON PROGRAMMING
print(text.lower())      # python programming
print(text.capitalize()) # Python programming
print(text.title())      # Python Programming
print(text.swapcase())   # pYTHON pROGRAMMING
print(text.casefold())   # python programming (более агрессивное приведение к нижнему регистру)

Методы проверки типа символов

# Проверка на цифры
print("123".isdigit())    # True
print("12.3".isdigit())   # False

# Проверка на буквы
print("abc".isalpha())    # True
print("abc123".isalpha()) # False

# Проверка на буквы и цифры
print("abc123".isalnum()) # True
print("abc 123".isalnum()) # False

# Проверка регистра
print("hello".islower())  # True
print("HELLO".isupper())  # True
print("Hello World".istitle()) # True

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

Методы поиска и замены

text = "Python - лучший язык программирования для изучения Python"

# Поиск подстроки
print(text.find("Python"))      # 0 (первое вхождение)
print(text.rfind("Python"))     # 58 (последнее вхождение)
print(text.find("Java"))        # -1 (не найдено)

# Более безопасный поиск (вызывает исключение если не найдено)
try:
    print(text.index("Python"))  # 0
    print(text.rindex("Python")) # 58
except ValueError:
    print("Подстрока не найдена")

# Подсчет вхождений
print(text.count("Python"))     # 2

# Замена подстроки
new_text = text.replace("Python", "Java")
print(new_text)

# Ограниченная замена
new_text = text.replace("Python", "Java", 1)  # Заменить только первое вхождение
print(new_text)

Методы разбиения и объединения

text = "яблоко,банан,апельсин,груша"

# Разбиение строки
fruits = text.split(",")
print(fruits)  # ['яблоко', 'банан', 'апельсин', 'груша']

# Разбиение с ограничением
fruits = text.split(",", 2)
print(fruits)  # ['яблоко', 'банан', 'апельсин,груша']

# Разбиение по строкам
multiline = "Первая строка\nВторая строка\nТретья строка"
lines = multiline.splitlines()
print(lines)  # ['Первая строка', 'Вторая строка', 'Третья строка']

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

# Разбиение на части
text = "имя:возраст:город"
parts = text.partition(":")
print(parts)  # ('имя', ':', 'возраст:город')

# Разбиение с конца
parts = text.rpartition(":")
print(parts)  # ('имя:возраст', ':', 'город')

Методы очистки строк

text = "   Python Programming   "

# Удаление пробелов
print(text.strip())   # "Python Programming"
print(text.lstrip())  # "Python Programming   "
print(text.rstrip())  # "   Python Programming"

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

# Удаление множества символов
text = "!@#Python#@!"
print(text.strip("!@#"))  # "Python"

Методы выравнивания

text = "Python"

# Выравнивание по центру
print(text.center(20))      # "       Python       "
print(text.center(20, "*")) # "*******Python*******"

# Выравнивание по левому краю
print(text.ljust(20))       # "Python              "
print(text.ljust(20, "-"))  # "Python--------------"

# Выравнивание по правому краю
print(text.rjust(20))       # "              Python"
print(text.rjust(20, "-"))  # "--------------Python"

# Заполнение нулями
number = "42"
print(number.zfill(5))      # "00042"

Методы проверки начала и конца строки

filename = "document.pdf"

print(filename.startswith("doc"))    # True
print(filename.endswith(".pdf"))     # True
print(filename.endswith((".pdf", ".doc", ".txt")))  # True (можно передать кортеж)

# Проверка с указанием диапазона
text = "Python Programming"
print(text.startswith("Pro", 7))     # True (начиная с 7-го символа)
print(text.endswith("gram", 0, 14))  # True (до 14-го символа)

Работа с Unicode и кодировками

# Получение кода символа
print(ord('A'))  # 65
print(ord('Я'))  # 1071

# Получение символа по коду
print(chr(65))   # A
print(chr(1071)) # Я

# Работа с Unicode
text = "Привет, мир! ?"
print(len(text))  # 13 (включая эмодзи)

# Кодирование и декодирование
text = "Привет"
encoded = text.encode('utf-8')
print(encoded)  # b'\xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82'
decoded = encoded.decode('utf-8')
print(decoded)  # Привет

Экранирование символов

# Специальные символы
print("Строка с \"кавычками\"")
print('Строка с \'кавычками\'')
print("Строка с \\ обратным слешем")
print("Строка с \n новой строкой")
print("Строка с \t табуляцией")

# Raw строки (без экранирования)
print(r"C:\Users\name\Documents")  # C:\Users\name\Documents
print(r"Строка с \n без новой строки")  # Строка с \n без новой строки

Сравнение строк

# Лексикографическое сравнение
print("apple" < "banana")  # True
print("Apple" < "apple")   # True (заглавные буквы имеют меньший код)

# Сравнение без учета регистра
str1 = "Python"
str2 = "python"
print(str1.lower() == str2.lower())  # True

# Численное сравнение
print("10" > "2")  # False (строковое сравнение)
print(int("10") > int("2"))  # True (численное сравнение)

Полезные практические примеры

Валидация данных

def validate_email(email):
    """Простая валидация email"""
    return "@" in email and "." in email.split("@")[-1]

def validate_phone(phone):
    """Проверка номера телефона (только цифры)"""
    clean_phone = phone.replace("-", "").replace(" ", "").replace("(", "").replace(")", "")
    return clean_phone.isdigit() and len(clean_phone) >= 10

# Примеры использования
print(validate_email("user@example.com"))  # True
print(validate_phone("+7 (123) 456-78-90"))  # False (содержит +)

Обработка текста

def clean_text(text):
    """Очистка и нормализация текста"""
    # Удаление лишних пробелов
    text = " ".join(text.split())
    # Приведение к нижнему регистру
    text = text.lower()
    # Удаление знаков пунктуации (простой пример)
    import string
    text = text.translate(str.maketrans("", "", string.punctuation))
    return text

text = "  Привет,   МИР!!!  Как    дела?  "
print(clean_text(text))  # привет мир как дела

Генерация текста

def generate_report(name, sales_data):
    """Генерация отчета о продажах"""
    total_sales = sum(sales_data.values())
    best_month = max(sales_data, key=sales_data.get)
    
    report = f"""
    Отчет о продажах для {name}
    {'=' * 30}
    
    Общая сумма продаж: {total_sales:,.2f} руб.
    Лучший месяц: {best_month} ({sales_data[best_month]:,.2f} руб.)
    
    Детализация по месяцам:
    """
    
    for month, amount in sales_data.items():
        report += f"  {month}: {amount:,.2f} руб.\n"
    
    return report

sales = {"Январь": 125000, "Февраль": 140000, "Март": 98000}
print(generate_report("ООО Рога и Копыта", sales))

Таблица основных методов строк

Метод	Описание	Пример
`upper()`	Преобразование в верхний регистр	`"hello".upper()` → `"HELLO"`
`lower()`	Преобразование в нижний регистр	`"HELLO".lower()` → `"hello"`
`capitalize()`	Первая буква заглавная	`"hello".capitalize()` → `"Hello"`
`title()`	Каждое слово с заглавной буквы	`"hello world".title()` → `"Hello World"`
`strip()`	Удаление пробелов с краев	`" hello ".strip()` → `"hello"`
`replace(old, new)`	Замена подстроки	`"hello".replace("l", "x")` → `"hexxo"`
`split(sep)`	Разделение строки	`"a,b,c".split(",")` → `["a", "b", "c"]`
`join(iterable)`	Объединение списка	`",".join(["a", "b"])` → `"a,b"`
`find(sub)`	Поиск подстроки	`"hello".find("ll")` → `2`
`count(sub)`	Подсчет вхождений	`"hello".count("l")` → `2`
`startswith(prefix)`	Проверка начала	`"hello".startswith("he")` → `True`
`endswith(suffix)`	Проверка конца	`"hello".endswith("lo")` → `True`
`isdigit()`	Проверка на цифры	`"123".isdigit()` → `True`
`isalpha()`	Проверка на буквы	`"abc".isalpha()` → `True`
`isalnum()`	Проверка на буквы и цифры	`"abc123".isalnum()` → `True`

Строки в Python являются неизменяемыми объектами, поэтому все методы возвращают новую строку, не изменяя исходную. Это важно помнить при работе с большими объемами текстовых данных для оптимизации производительности приложений.