Строки в Python и методы работы с ними

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

Строки — это набор знаков, заключённый в кавычки. В зависимости от выбранного типа кавычек у строк есть разные свойства:

● Одинарные кавычки — ('). Внутри одинарных кавычек можно использовать двойные кавычки без экранирования: 'He said, "Hello!"'. Экранирование строк в Python — это механизм, который позволяет вставлять специальные символы внутри строк, чтобы они интерпретировались буквально, а не как часть синтаксиса языка.
● Двойные кавычки — ("). Внутри двойных кавычек можно использовать одинарные кавычки без экранирования: "She said, 'Hello!'".
● Тройные кавычки — (''' или """). Тройные кавычки позволяют создавать многострочные строки. Их удобно использовать для строк с переносами.

my_string = '''Это многострочная строка.
Мы перенесли текст на следующую строку.'''

В большинстве случаев можно использовать любой тип кавычек в зависимости от удобства и стиля кода.

Чтобы вставить специальный символ в строку, используется обратный слеш (\). Например:

● \" - двойная кавычка,
● \' - одинарная кавычка,
● \\ - обратный слеш,
● \n - символ новой строки.
● \t - символ табуляции.

my_string = "She said, \"Hello!\""
print(my_string) # Вывод: She said, "Hello!"

Если требуется создать строку, в которой все символы интерпретируются буквально, можно использовать неэкранированные строки с префиксом r или R.

raw_string = r"C:\Program Files\Yandex\Python"
print(raw_string) # Вывод: C:\Program Files\Yandex\Python

Экранирование полезно при работе с регулярными выражениями, путями файловой системы, SQL-запросами и в других случаях, когда нужно точно указать символы в строке.

Выполняется с помощью встроенной функции len(), которая также может использоваться для определения длины списков, кортежей, множеств и других последовательностей. Функция считывает символы, включая пробелы, знаки препинания и специальные символы.

my_string = "Hello, World!"
length = len(my_string)
print(f"Длина строки: {length}")

Чтобы правильно использовать строки в Python, нужно разбираться и в других разделах языка — циклах, функциях, классах и т. д. Этому учат на курсе «Python-разработчик». Также студенты учатся работать с инструментами, которые затем применяют в работе — Git, Nginx, PostgreSQL и другим. Обучение длится 9 месяцев, а после курса вы получите диплом о профессиональной переподготовке.

Позволяет получать отдельные символы или подстроки. Для обхода строки с начала, её символы индексируются с помощью неотрицательных целых чисел. Первый символ имеет индекс 0, второй — индекс 1 и так далее.

my_string = "Hello, World!"
first_char = my_string[0] # Получение первого символа ("H")
second_char = my_string[1] # Получение второго символа ("e")

Для доступа к символам с конца строки можно использовать отрицательные индексы. Последний символ имеет индекс -1, предпоследний — индекс -2 и так далее.

my_string = "Hello, World!"
last_char = my_string[-1] # Получение последнего символа ("!")
second_to_last_char = my_string[-2] # Получение предпоследнего символа ("d")

С помощью срезов можно получать подстроки из строки по заданным индексам. Синтаксис: my_string[start:end], где start — индекс начала среза, а end — индекс конца (не включается). При выходе за границы диапазона возникает ошибка IndexError.

my_string = "Hello, World!"
my_substring = my_string[7:12] # Получение подстроки "World"

Срезы строк с шагом в Python позволяют получать подстроки с заданным интервалом между символами. Срезы с шагом выполняются с помощью следующего синтаксиса:

my_string[start:end:step], где
start: индекс начала среза (включительно).
end: индекс конца среза (не включительно).
step: шаг между символами.

Получение каждого второго символа:

my_string = "Hello, World!"
every_second_char = my_string[::2] # Получение "HloWrd"

Получение обратной строки:

reversed_string = my_string[::-1] # Получение "!dlroW ,olleH"

Получение части строки с определенным шагом:

my_substring = my_string[1:10:3] # Получение "e,Wl"

Если start и end не указаны, срез будет включать всю строку.

Сложение строк в Python (конкатенация) — это процесс объединения двух или более строк в одну. Самый простой способ конкатенации строк — использовать оператор +.

Пример:
first_name = "Ivan"
last_name = "Ivanov"
full_name = first_name + " " + last_name
print(full_name) # Вывод: Ivan Ivanov

Более универсальный способ — метод join(), он позволяет объединить элементы последовательности (например, списка) с помощью заданной строки.

Пример:
words = ["Hello", "world"]
# Соединяем все строки из списка words в одну строку. В качестве разделителя берем простой пробел
sentence = " ".join(words)
print(sentence) # Вывод: Hello world

В Python нельзя вычитать строки, используя знак минуса. Но если под вычитанием подразумевается удаление подстроки из строки, сделать это можно при помощи метода .replace(). В общем случае он применяется для замены подстроки в строке другой подстрокой.

Синтаксис:

string.replace(old, new, count)

old (обязательный параметр): подстрока, которую нужно заменить.

new (обязательный параметр): подстрока, которой мы хотим заменить old.

count (опциональный параметр): максимальное допустимое количество замен. Если не указан, будут заменены все вхождения.

Удаление из строки содержащейся в ней подстроки:

string1 = 'PRAKTIYZKUM'
string2 = 'YZ'
if string2 in string1:
string3 = string1.replace(string2,'')
print(string3) # Вывод: "PRAKTIKUM"

Замена одной подстроки на другую:

original_string = "Hello, World!"
modified_string = original_string.replace("Hello", "Hi")
print(modified_string) # Вывод: "Hi, World!"

Замена всех вхождений:

sentence = "Python is amazing and Python is powerful"
updated_sentence = sentence.replace("Python", "Programming")
print(updated_sentence)
# Вывод: "Programming is amazing and Programming is powerful"

Ограничение количества замен:

text = "kiwi apple apple apple orange apple apple"
updated_text = text.replace("apple", "banana", 2) # Заменяем первые 2 вхождения
print(updated_text) # Вывод: "kiwi banana banana apple orange apple apple"

Строки в Python можно и умножать на числа — дублировать. Это полезно, например, при создании повторяющихся шаблонов или форматировании вывода. Самый простой способ дублирования строки — использовать оператор умножения (*).

original_string = "Hello"
duplicated_string = original_string * 3 # Дублируем строку 3 раза
print(duplicated_string) # Вывод: HelloHelloHello

Используя .split() в питоне, строку можно разделить на подстроки на основе заданного разделителя. Например, можно разбить предложение на слова. Это полезно при анализе логов, чтении CSV-файлов или URL-адресов. Синтаксис:

string.split(separator, maxsplit)

separator (обязательный параметр): строка-разделитель — по умолчанию пробел.

maxsplit (опциональный параметр): максимальное количество разделений. Если не указан, все вхождения разделителя будут использованы.

Разделение строки по пробелам:

my_string = "Hello World"
words = my_string.split() # Разделение по пробелам
print(words) # Вывод: ['Hello', 'World']

Разделение строки по запятой:

csv_data = "apple,banana,orange"
fruits = csv_data.split(",") # Разделение по запятой
print(fruits) # Вывод: ['apple', 'banana', 'orange']

Ограничение количества разделений:

sentence = "Python is amazing and Python is powerful"
words = sentence.split(" ", 2) # Разделение по пробелам, максимум 2 разделения
print(words) # Вывод: ['Python', 'is', 'amazing and Python is powerful']

Иногда надо очистить строку от лишних пробельных символов (пробелов, табуляций, символов новой строки). В этом поможет метод .strip(). Синтаксис:

string.strip([characters])

characters (опциональный параметр): строка, содержащая символы, которые нужно удалить. Если не указан, будут удалены все начальные и конечные пробельные символы. Удаление пробелов в начале и конце строки:

my_string = " Hello, World! "
cleaned_string = my_string.strip()
print(cleaned_string) # Вывод: "Hello, World!"

Удаление символов новой строки:

multiline_string = "\n\nThis is a multiline string.\n\n"
cleaned_multiline = multiline_string.strip("\n")
print(cleaned_multiline)
# Вывод:
# "This is a multiline string."

Если менять подстроку не нужно, а требуется только найти её в исходной строке, на помощь придёт метод .find(). Он возвращает индекс первого вхождения этой подстроки.

Синтаксис:

string.find(substring, start, end)

substring (обязательный параметр): подстрока, которую нужно найти.

start (опциональный параметр): индекс, с которого начинается поиск. По умолчанию поиск идёт с начала строки.

end (опциональный параметр): индекс, на котором заканчивается поиск. По умолчанию поиск идёт до конца строки.

Поиск подстроки в строке:

my_string = "Python is amazing and Python is powerful"
index = my_string.find("amazing")
print(index) # Вывод: 10 (позиция слова "amazing")

Поиск с указанием начальной позиции:

my_string = "Python is amazing and Python is powerful"
index = my_string.find("Python", 15) # Ищем "Python" начиная с позиции 15
print(index) # Вывод: 28 (позиция второго вхождения "Python")

Поиск с ограничением диапазона:

my_string = "Python is amazing and Python is powerful"
index = my_string.find("Python", 0, 15) # Ищем "Python" только в первых 15 символах
print(index) # Вывод: 0 (позиция первого вхождения "Python")

Проверить, содержится ли одна строка внутри другой, можно при помощи оператора in:

my_string = "Hello, World!"
if "World" in my_string:
print("Содержит подстроку 'World'")

Или же наоборот можно убедиться в том, что такая строка не содержится внутри исследуемой:

if "Python" not in my_string:
print("Не содержит подстроку 'Python'")

В Python символ % используется для интерполяции строк, позволяя вставлять значения переменных в другие строки. Этот процесс называется “старым форматированием строк”. Синтаксис: string % values. В строке string используются специальные символы, такие как %s (для строк) и другие.

name = "Alice"
age = 47
message = "My name is %s and I am %d years old." % (name, age)
print(message) # Вывод: "My name is Alice and I am 47 years old."

Форматы для интерполяции:

● %s: вставка строки,
● %d: вставка целого числа,
● %f: вставка числа с плавающей точкой,
● %x: вставка шестнадцатеричного числа.

Вместо % можно использовать {} и метод .format() для более современного форматирования строк.

name = "Bob"
age = 70
message = "My name is {} and I am {} years old.".format(name, age)
print(message) # Вывод: "My name is Bob and I am 70 years old."

В этом примере переменные вставляются в строку в том порядке, в котором они указаны в скобках. Для более чёткого форматирования мы можем использовать именованные аргументы:

name = "Bob"
age = 25
message = "My name is {name} and I am {age} years old.".format(name=name, age=age)
print(message) # Вывод: "My name is Bob and I am 70 years old."

Как и в старом форматировании, мы можем строго указать формат для вставляемых значений:

price = 19.993
formatted_price = "The price is {:.2f} dollars.".format(price)
print(formatted_price) # Вывод: "The price is 19.99 dollars."

Начиная с Python 3.6 можно удобно форматировать строки, используя f-strings. Они позволяют вставлять значения переменных непосредственно в строку, делая код более читаемым и удобным. F-строки создаются путем добавления префикса f или F перед строкой. Внутри f-строки можно использовать фигурные скобки {} для вставки значений переменных.

name = "Alice"
age = 30
message = f"My name is {name} and I am {age} years old."
print(message) # Вывод: "My name is Alice and I am 47 years old."

Внутри фигурных скобок можно указывать выражения, переменные и даже вызывать методы:

price = 19.993
formatted_price = f"The price is {price:.2f} dollars."
print(formatted_price) # Вывод: "The price is 19.99 dollars."

F-строки поддерживают именованные аргументы для более ясного форматирования:

fruit1 = "apple"
fruit2 = "banana"
sentence = f"I like {fruit1} and {fruit2}."
print(sentence) # Вывод: "I like apple and banana."

Внутри f-строк можно выполнять вычисления в пределах фигурных скобок:

x = 5
y = 7
result = f"{x} + {y} = {x + y}"
print(result) # Вывод: "5 + 7 = 12"

Работа с разными кодировками в Python важна при обработке текстовых данных, файлов, сетевых запросов и в других сценариях. В Python строки представляют собой последовательность символов, и каждый символ имеет свой числовой код (кодировку).
По умолчанию строки используют кодировку UTF-8, которая поддерживает множество символов из разных языков.

В Python при чтении или записи файла мы можем указать нужную кодировку. Например,

with open("myfile.txt", "r", encoding="utf-8") as file:
content = file.read()

Строки в Python бывают байтовыми. Они представляют собой последовательность символов от 0 до 255 и используются в работе с бинарными данными, например, изображениями, аудиофайлами, сетевыми пакетами и другими низкоуровневыми ресурсами. Байтовые строки создаются с помощью префикса b перед строкой.

my_bytes = b"Hello, World!"

Байты можно индексировать и использовать срезы так же, как и в обычных строках:

my_bytes = b"Hello, World!"
first_byte = my_bytes[0] # Получение первого байта
slice_of_bytes = my_bytes[2:5] # Получение среза байтов

Байты поддерживают некоторые методы, такие как .find(), .count(), .startswith(), .endswith() и другие:

my_bytes = b"Hello, World!"
index = my_bytes.find(b"World") # Поиск подстроки в байтах
count = my_bytes.count(b"l") # Подсчет вхождений байта

Преобразование между строками и байтами:

● Метод .encode() преобразует строку в байты с заданной кодировкой (например, UTF-8).
● Метод .decode() обратно преобразует байты в строку.

my_string = "Привет, мир!"
my_bytes = my_string.encode("utf-8") # Преобразование в байты
decoded_string = my_bytes.decode("utf-8") # Обратное преобразование в строку