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

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

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

Начать курс

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

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

Что такое строки в Python

Строка в Python — это упорядоченная последовательность символов Unicode. Строки могут содержать буквы, цифры, специальные символы и пробелы. Каждый символ в строке имеет свой индекс, начиная с 0.

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

Одинарные и двойные кавычки

Строки можно создавать с помощью одинарных или двойных кавычек. Функционально они эквивалентны, но их выбор может зависеть от содержимого строки.

str1 = 'Hello, World!'
str2 = "Hello, World!"

print(str1)  # Hello, World!
print(str2)  # Hello, World!

Тройные кавычки для многострочных строк

Тройные кавычки (''' или """) используются для создания многострочных строк или строк, содержащих кавычки внутри.

str3 = """Это
многострочная
строка"""

str4 = '''Эта строка содержит "кавычки" внутри'''

print(str3)
print(str4)

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

Экранированные символы позволяют включать специальные символы в строку с помощью обратного слеша ().

newline = "Первая строка\nВторая строка"
tabbed = "Первая строка\tВторая строка"
escaped_quote = "Он сказал: \"Привет!\""

print(newline)
print(tabbed)
print(escaped_quote)

Основные экранированные символы

\n — перевод строки
\t — табуляция
\\ — обратный слеш
\' — одинарная кавычка
\" — двойная кавычка
\r — возврат каретки
\b — забой (backspace)

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

Конкатенация строк

Конкатенация (объединение) строк выполняется с помощью оператора +.

str1 = "Hello"
str2 = "World"
str3 = str1 + ", " + str2 + "!"
print(str3)  # Hello, World!

Повторение строк

Строки можно повторять с помощью оператора *.

str1 = "Hi! "
str2 = str1 * 3
print(str2)  # Hi! Hi! Hi!

Индексация строк

Каждый символ строки имеет индекс, начиная с 0. Отрицательные индексы отсчитываются с конца строки.

str1 = "Hello"
print(str1[0])   # H
print(str1[-1])  # o
print(str1[1])   # e
print(str1[-2])  # l

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

Срезы позволяют извлекать части строки, используя синтаксис [start:end:step].

str1 = "Hello, World!"
print(str1[0:5])    # Hello
print(str1[7:])     # World!
print(str1[:5])     # Hello
print(str1[::2])    # Hlo ol!
print(str1[::-1])   # !dlroW ,olleH

Перебор строки в цикле

text = "1516 the best"
for i in range(len(text)):
    if text[i] in "1234567890":
        print(text[i])
# Вывод: 1, 5, 1, 6

# Более элегантный способ
for char in text:
    if char.isdigit():
        print(char)

Методы строк в Python

таблица с основными методами и функциями для работы со строками в Python:

Методы строк

Метод	Описание	Пример
`upper()`	Преобразует в верхний регистр	`"hello".upper()` → `"HELLO"`
`lower()`	Преобразует в нижний регистр	`"HELLO".lower()` → `"hello"`
`capitalize()`	Делает первую букву заглавной	`"hello".capitalize()` → `"Hello"`
`title()`	Делает заглавной первую букву каждого слова	`"hello world".title()` → `"Hello World"`
`swapcase()`	Меняет регистр символов	`"Hello".swapcase()` → `"hELLO"`
`strip()`	Удаляет пробелы с начала и конца	`" hello ".strip()` → `"hello"`
`lstrip()`	Удаляет пробелы слева	`" hello ".lstrip()` → `"hello "`
`rstrip()`	Удаляет пробелы справа	`" hello ".rstrip()` → `" hello"`
`split()`	Разделяет строку на список	`"a,b,c".split(",")` → `["a", "b", "c"]`
`join()`	Соединяет элементы списка в строку	`",".join(["a", "b", "c"])` → `"a,b,c"`
`replace()`	Заменяет подстроку	`"hello".replace("l", "x")` → `"hexxo"`
`find()`	Находит индекс подстроки	`"hello".find("l")` → `2`
`rfind()`	Находит последний индекс подстроки	`"hello".rfind("l")` → `3`
`index()`	Находит индекс (с ошибкой если не найдено)	`"hello".index("l")` → `2`
`rindex()`	Находит последний индекс (с ошибкой)	`"hello".rindex("l")` → `3`
`count()`	Подсчитывает количество вхождений	`"hello".count("l")` → `2`
`startswith()`	Проверяет начало строки	`"hello".startswith("he")` → `True`
`endswith()`	Проверяет конец строки	`"hello".endswith("lo")` → `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`
`center()`	Центрирует строку	`"hi".center(10)` → `" hi "`
`ljust()`	Выравнивает по левому краю	`"hi".ljust(10)` → `"hi "`
`rjust()`	Выравнивает по правому краю	`"hi".rjust(10)` → `" hi"`
`zfill()`	Заполняет нулями слева	`"42".zfill(5)` → `"00042"`
`encode()`	Кодирует строку в байты	`"hello".encode("utf-8")` → `b'hello'`
`format()`	Форматирует строку	`"Hello {}".format("World")` → `"Hello World"`
`format_map()`	Форматирует с использованием словаря	`"Hello {name}".format_map({"name": "World"})`
`partition()`	Разделяет строку на 3 части	`"a-b-c".partition("-")` → `("a", "-", "b-c")`
`rpartition()`	Разделяет справа на 3 части	`"a-b-c".rpartition("-")` → `("a-b", "-", "c")`
`splitlines()`	Разделяет по строкам	`"a\nb\nc".splitlines()` → `["a", "b", "c"]`
`expandtabs()`	Заменяет табуляции пробелами	`"a\tb".expandtabs(4)` → `"a b"`
`translate()`	Переводит символы по таблице	`"hello".translate(str.maketrans("l", "x"))` → `"hexxo"`
`casefold()`	Агрессивное приведение к нижнему регистру	`"Hello".casefold()` → `"hello"`

Встроенные функции для работы со строками

Функция	Описание	Пример
`len()`	Возвращает длину строки	`len("hello")` → `5`
`str()`	Преобразует в строку	`str(123)` → `"123"`
`repr()`	Возвращает представление строки	`repr("hello")` → `"'hello'"`
`ord()`	Возвращает Unicode код символа	`ord("A")` → `65`
`chr()`	Возвращает символ по Unicode коду	`chr(65)` → `"A"`
`ascii()`	Возвращает ASCII представление	`ascii("héllo")` → `"'h\\xe9llo'"`
`bin()`	Преобразует в двоичную строку	`bin(10)` → `"0b1010"`
`oct()`	Преобразует в восьмеричную строку	`oct(10)` → `"0o12"`
`hex()`	Преобразует в шестнадцатеричную строку	`hex(10)` → `"0xa"`
`format()`	Форматирует значение	`format(3.14, ".2f")` → `"3.14"`
`sorted()`	Сортирует символы строки	`sorted("hello")` → `['e', 'h', 'l', 'l', 'o']`
`reversed()`	Возвращает обратный итератор	`list(reversed("hello"))` → `['o', 'l', 'l', 'e', 'h']`
`enumerate()`	Возвращает пары (индекс, символ)	`list(enumerate("hi"))` → `[(0, 'h'), (1, 'i')]`
`zip()`	Объединяет строки посимвольно	`list(zip("abc", "123"))` → `[('a', '1'), ('b', '2'), ('c', '3')]`
`map()`	Применяет функцию к каждому символу	`list(map(ord, "abc"))` → `[97, 98, 99]`
`filter()`	Фильтрует символы по условию	`list(filter(str.isalpha, "a1b2c"))` → `['a', 'b', 'c']`
`any()`	Проверяет, есть ли True среди символов	`any(c.isdigit() for c in "a1b")` → `True`
`all()`	Проверяет, все ли символы True	`all(c.isalpha() for c in "abc")` → `True`
`sum()`	Суммирует коды символов	`sum(ord(c) for c in "abc")` → `294`
`min()`	Находит минимальный символ	`min("hello")` → `"e"`
`max()`	Находит максимальный символ	`max("hello")` → `"o"`

Специальные методы для создания строк

Метод	Описание	Пример
`str.maketrans()`	Создает таблицу перевода	`str.maketrans("abc", "123")`
`bytes.decode()`	Декодирует байты в строку	`b"hello".decode("utf-8")` → `"hello"`
`bytearray.decode()`	Декодирует массив байтов	`bytearray(b"hello").decode()` → `"hello"`

Эта таблица охватывает основные методы и функции для работы со строками в Python. Каждый метод имеет свое предназначение и может быть полезен в различных ситуациях при обработке текстовых данных.

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

Функция len() возвращает количество символов в строке.

str1 = "Hello"
print(len(str1))  # 5

Изменение регистра

str1 = "Hello, World!"
print(str1.lower())      # hello, world!
print(str1.upper())      # HELLO, WORLD!
print(str1.title())      # Hello, World!
print(str1.capitalize()) # Hello, world!

Удаление пробелов

str1 = "   Hello, World!   "
print(str1.strip())      # "Hello, World!"
print(str1.lstrip())     # "Hello, World!   "
print(str1.rstrip())     # "   Hello, World!"

Замена подстрок

str1 = "Hello, World!"
print(str1.replace("World", "Python"))  # Hello, Python!
print(str1.replace("l", "L", 2))        # HeLLo, World!

Разделение и объединение строк

str1 = "Hello, World!"
list1 = str1.split(", ")
print(list1)  # ['Hello', 'World!']

str2 = ", ".join(list1)
print(str2)  # Hello, World!

# Разделение по строкам
multiline = "line1\nline2\nline3"
lines = multiline.splitlines()
print(lines)  # ['line1', 'line2', 'line3']

Поиск подстрок

str1 = "Hello, World!"
print(str1.find("o"))        # 4
print(str1.rfind("o"))       # 8
print(str1.find("Python"))   # -1
print(str1.index("World"))   # 7
print(str1.count("l"))       # 3

Проверка начала и конца строки

str1 = "Hello, World!"
print(str1.startswith("Hello"))  # True
print(str1.endswith("World!"))   # True
print(str1.startswith("Hi"))     # False

Проверочные методы строк

Проверка содержимого строки

str1 = "Hello"
str2 = "12345"
str3 = "Hello123"
str4 = "   "

print(str1.isalpha())   # True - только буквы
print(str2.isdigit())   # True - только цифры
print(str3.isalnum())   # True - буквы и цифры
print(str4.isspace())   # True - только пробелы

Проверка регистра

str1 = "hello"
str2 = "HELLO"
str3 = "Hello World"

print(str1.islower())   # True
print(str2.isupper())   # True
print(str3.istitle())   # True

Дополнительные проверки

str1 = "123"
str2 = "hello123"
str3 = "HELLO123"

print(str1.isdecimal())      # True
print(str1.isnumeric())      # True
print(str2.isidentifier())   # True
print(str3.isprintable())    # True

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

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

name = "Alice"
age = 25
str1 = "My name is %s and I am %d years old." % (name, age)
print(str1)  # My name is Alice and I am 25 years old.

Метод format()

name = "Alice"
age = 25
str1 = "My name is {} and I am {} years old.".format(name, age)
print(str1)  # My name is Alice and I am 25 years old.

# С именованными параметрами
str2 = "My name is {name} and I am {age} years old.".format(name=name, age=age)
print(str2)

F-строки (f-strings) - рекомендуемый способ

F-строки (форматированные строковые литералы) — это самый современный и удобный способ форматирования строк в Python 3.6+.

name = "Alice"
age = 25
str1 = f"My name is {name} and I am {age} years old."
print(str1)  # My name is Alice and I am 25 years old.

Форматирование чисел

pi = 3.14159
price = 1234.56

print(f"Число Пи: {pi:.2f}")          # Число Пи: 3.14
print(f"Цена: {price:.2f}")           # Цена: 1234.56
print(f"Цена: {price:,.2f}")          # Цена: 1,234.56
print(f"Процент: {0.95:.2%}")         # Процент: 95.00%

Работа с многострочными строками

# Многострочная строка
poem = """Розы красные,
Фиалки синие,
Python прекрасен,
И это истина."""

print(poem)

# Использование для документации
def my_function():
    """
    Это многострочная документация функции.
    Она может содержать подробное описание
    параметров и возвращаемых значений.
    """
    pass

Кодирование и декодирование строк

# Кодирование строки в байты
text = "Привет, мир!"
encoded = text.encode('utf-8')
print(encoded)  # b'\xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82, \xd0\xbc\xd0\xb8\xd1\x80!'

# Декодирование байтов в строку
decoded = encoded.decode('utf-8')
print(decoded)  # Привет, мир!

Практические примеры работы со строками

Проверка email

email = "user@example.com"
if "@" in email and "." in email:
    print("Email корректный")

Подсчет символов

text = "Hello World"
vowels = "aeiouAEIOU"
vowel_count = sum(1 for char in text if char in vowels)
print(f"Количество гласных: {vowel_count}")

Очистка строки

text = "  Hello,    World!  "
cleaned = " ".join(text.split())
print(cleaned)  # "Hello, World!"

Строки в Python предоставляют мощные возможности для работы с текстовыми данными. Понимание основных методов и операций со строками является фундаментальным навыком для любого Python-разработчика. Регулярное использование этих методов поможет вам эффективно обрабатывать и манипулировать текстовыми данными в ваших проектах.