Строка — это набор символов, представляющих текстовую информацию. Строки в Python являются неизменяемыми объектами, что означает, что после создания строки ее нельзя изменить.
Строки являются одним из наиболее распространенных типов данных в Python и используются для хранения и обработки текстовой информации во многих приложениях, таких как:
- Обработка текстовых файлов, например, для чтения и записи данных.
- Работа с пользовательским вводом, например, при вводе имени или адреса электронной почты.
- Создание и форматирование текстовых сообщений, например, для отправки по электронной почте или SMS.
- Работа с базами данных, где данные хранятся в виде строк.
- Обработка и анализ данных, содержащих текстовую информацию, например, анализ отзывов пользователей на товары или услуги.
В работе с строками в Python используются различные операции и методы для выполнения задач, таких как:
- Получение длины строки.
- Извлечение подстроки из строки.
- Поиск символов и подстрок в строке.
- Замена символов и подстрок в строке.
- Разделение строки на части и объединение строк в одну.
- Форматирование строк для вывода информации в нужном виде.
Примеры задач, где необходима работа со строками:
- Поиск и замена подстроки в тексте — для обработки больших объемов текстовой информации, например, для замены определенного слова в тексте на другое или для поиска всех вхождений слова в тексте.
- Разбиение строки на подстроки — для анализа данных, содержащих список значений, разделенных запятыми или другими символами.
- Валидация пользовательского ввода — для проверки, соответствует ли введенное пользователем значение формату строки, например, для проверки правильности ввода адреса электронной почты или номера телефона.
- Форматирование текстовых сообщений — для вывода информации в нужном формате, например, для создания уведомлений или сообщений об ошибках.
- Обработка текстовых файлов — для чтения и записи данных в текстовых файлах, например, для создания отчетов или обработки данных в формате CSV.
Запись строк
В Python строки могут быть записаны в кавычках одного из трех типов: одинарных кавычек ('
), двойных кавычек ("
) и тройных кавычек ('''
или """
). Использование тройных кавычек позволяет записывать многострочные строки.
Примеры записи строк:
# Одинарные кавычки
string_1 = 'Это строка, записанная в одинарных кавычках'
# Двойные кавычки
string_2 = "Это строка, записанная в двойных кавычках"
# Тройные кавычки
string_3 = '''Это многострочная
строка, записанная в тройных
кавычках'''
Специальные символы в Python. Как сделать принудительный перевод строки.
Также можно использовать обратный слеш (\
) для записи специальных символов, таких как перевод строки (\n
), табуляция (\t
), кавычки и т.д.
Примеры:
# Использование обратного слеша для записи специальных символов
string_4 = 'Это строка с переводом\nстроки'
string_5 = "Это строка с табуляцией\tвнутри"
# Использование обратного слеша для записи кавычек
string_6 = "Это строка со \"знаками\" кавычек"
string_7 = 'Это строка с \'одинарными\' кавычками'
Какие кавычки лучше использовать: одинарные или двойные?
Разница между одинарными ('
) и двойными ("
) кавычками при записи строк в Python заключается только в способе записи кавычек внутри строки.
Если строка записана в одинарных кавычках, то внутри строки можно использовать двойные кавычки без необходимости экранировать их обратным слешем (\
), и наоборот.
Пример:
string_1 = 'Это строка с "двойными" кавычками'
string_2 = "Это строка с 'одинарными' кавычками"
Строковые операторы
Строковые операторы — это операторы, которые могут быть применены к строкам в Python и позволяют производить над ними различные операции.
Список строковых операторов в Python:
+
: объединение строк*
: повторение строки%
: форматирование строкin
: вхождение подстроки в строку
Примеры использования строковых операторов на реальных задачах:
Конкатенация (слияние) строк
Достигается с помощью оператора `+`
# объединяем две строки
first_name = 'John'
last_name = 'Doe'
full_name = first_name + ' ' + last_name
print(full_name) # John Doe
Повторение строки
# повторяем строку три раза
message = 'Python is great!'
triple_message = message * 3
print(triple_message) # Python is great!Python is great!Python is great!
Форматирование строки
Форматирование позволяет отобразить строку в определенном виде. Подробно, о форматировании строк, я расскажу далее по тексту, а пока небольшой пример.
# выводим информацию о продукте
product_name = 'Кофеварка'
product_price = 1999.99
info = 'Название: %s, Цена: %.2f руб.' % (product_name, product_price)
print(info) # Название: Кофеварка, Цена: 1999.99 руб.
В данном примере в текст info подставляется значение переменных product_name
и product_price
, причем цена округляется до 2 знаков после запятой.
Операторы in, not in
Операторы in
и not in
позволяют проверить, содержится ли подстрока в строке или нет. Они возвращают логическое значение True
или False
(Истина или Ложь).
Оператор in
используется, чтобы проверить, содержится ли подстрока в строке:
text = "Hello, world!"
substring = "world"
if substring in text:
print("Substring found!")
else:
print("Substring not found!")
Задания для закрепления строковых операторов
Задание 1. Написать программу, которая спрашивает у пользователя его имя и фамилию, а затем выводит приветствие вида «Привет, Имя Фамилия!» с использованием оператора +.
# Запрашиваем у пользователя имя и фамилию
name = input("Введите ваше имя: ")
surname = input("Введите вашу фамилию: ")
# Выводим приветствие
print("Привет, " + name + " " + surname + "!")
Задание 2. Написать программу, которая спрашивает у пользователя слово и повторяет его три раза через пробел с использованием оператора *
# Запрашиваем у пользователя слово
word = input("Введите слово: ")+" "
# Выводим повторение слова три раза
print(word * 3)
Срезы и индексы
Срезы (slicing) и индексы позволяют получить часть строки, выбрав определенный диапазон символов.
Индексы элементов строк
Индексы используются для доступа к отдельным символам строки в Python.
Индексация (нумерация) начинается с 0, то есть первый символ имеет индекс 0, второй — индекс 1 и т.д. Отрицательные индексы начинаются с -1, то есть последний символ имеет индекс -1, предпоследний — индекс -2 и т.д.
Пример: Получение символа по индексу (номеру)
my_string = "Hello, world!"
# Получение символа по индексу
first_char = my_string[0]
last_char = my_string[-1]
print(first_char) # 'H'
print(last_char) # '!'
В данном примере, мы получаем первый и последний символ строки Hello, world!
Первый элемент имеет индекс (номер) 0, а последний -1 (минус 1). Также, можно обратиться к последнему элементу, указав индекс 12, а к первому -13 (минус 13)
Важно помнить, что строки в Python являются неизменяемыми объектами. Это означает, что если вы попытаетесь изменить символ в строке, вы получите ошибку. Однако вы можете получать подстроки из строки с помощью индексов и срезов
my_string = "Hello, world!"
# Изменение символа по индексу
my_string[0] = 'h' # Ошибка! Строки в Python являются неизменяемыми объектами
Срезы
Для извлечения подстроки из строки можно использовать срезы. Срезы позволяют выбирать из строки подстроку, начиная с определенного индекса и до определенного индекса. Синтаксис срезов в Python выглядит следующим образом:
s[start:stop:step]
где s
— это строка, start
— начальный индекс среза, stop
— конечный индекс среза (данный элемент не будет включен в срез, только все элементы до него!), step
— шаг среза.
Примеры:
Извлечение подстроки из строки:
s = "Hello, world!"
substring = s[0:5] # Выбираем подстроку "Hello"
print(substring) # Выводим на экран "Hello"
В данном примере, мы выбрали символы с 0 (начального) до 4 (пятый не включается!). Получилась строка из 5 символов — Hello
Извлечение каждого второго символа из строки:
s = "abcdefghijklmnopqrstuvwxyz"
substring = s[::2] # Выбираем каждый второй символ из строки
print(substring) # Выводим на экран "acegikmoqsuwy"
Здесь, мы с вами пропустили два первых значения среза (start и stop). Об этом говорят пустые двоеточия без цифр. Это означает, что мы будет работать со всей строкой от начала до конца. А третий параметр — step, задали равным 2. То есть, возьмем каждый второй символ, начиная с начального (нулевого).
Извлечение подстроки из строки с отрицательным индексом:
s = "Hello, world!"
substring = s[-6:-1] # Выбираем подстроку "world"
print(substring) # Выводим на экран "world"
Здесь, мы используем в срезе отрицательные индексы. Напомню, что отрицательные индексы позволяют делать нумерацию с конца строки. -6 в параметре start, позволяет задать начало среза с шестого с конца символа (w). -1 в stop означает, что конечный символ среза — последний элемент строки. Напомню, что срез делается ДО элемента с индексом stop и не включает его. То есть, в срезу возьмутся все символы, начиная с шестого с конца и до предпоследнего.
Извлечение подстроки с определенным шагом
s = "abcdefghijklmnopqrstuvwxyz"
substring = s[2:10:2] # Выбираем каждый второй символ из подстроки "cdefghij"
print(substring) # Выводим на экран "cegi"
В данном примере, мы получаем в срез все символы начиная с индекса 2 (символ c) до индекса 9 (символ j) и берем их с шагом 2, то есть каждый второй.
Отрицательные значения в срезах
Отрицательные значения в срезах используются для обращения к символам или подстрокам с конца строки. Так, например, если мы хотим получить последний символ строки, мы можем использовать индекс -1, предпоследний -2, и так далее.
При использовании отрицательных индексов в срезах, счет начинается с конца строки, то есть последний символ имеет индекс -1, предпоследний -2 и так далее. При этом левый конец среза должен быть больше правого, иначе будет возвращаться пустая строка.
Пример:
s = "Hello, World!"
# Получаем последний символ
last_char = s[-1] # '!'
# Получаем последние 4 символа
last_chars = s[-4:] # 'ld!'
# Получаем все символы кроме первых 7
without_first = s[-7:] # ' World!'
Шаг в срезе
При использовании среза можно указать не только начальный и конечный индексы, но и шаг. Шаг указывает, через сколько символов следует брать элементы из строки. По умолчанию шаг равен 1.
Если значение шага отрицательное, то выбираются элементы в обратном порядке. Например, если у нас есть строка «hello world», и мы хотим выбрать каждый второй символ в обратном порядке, то можно использовать срез с отрицательным шагом:
s = "hello world"
result = s[::-2]
print(result) # "drlolh"
В случае использования отрицательного шага в срезе строк, начальный индекс (start) должен указывать на конечный символ среза, а конечный индекс (stop) должен указывать на первый символ среза.
Например, если у нас есть строка «hello world» и мы хотим извлечь подстроку «dlrow», используя отрицательный шаг, то мы можем использовать следующий срез:
s = "hello world"
sub = s[9:3:-1]
print(sub) # "dlrow"
Здесь start равен 9, так как это индекс символа «d», который является последним символом в срезе, а stop равен 3, так как это индекс символа «w», который является первым символом в срезе. Шаг равен -1, что означает, что мы переходим от конца строки к ее началу.
Важно помнить, что в случае использования отрицательного шага в срезе, индексы должны быть указаны в порядке убывания.
Пропуски значений в срезе
Пропуск компонента среза в Python обозначается двумя точками подряд :
. Он используется для указания значения по умолчанию для start, stop и step в срезе.
Если при задании среза опустить start, то считается, что он равен нулю. Если опустить stop, то это означает, что срез должен браться до конца строки. Если опустить step, то считается, что он равен 1.
Рассмотрим несколько примеров:
string = "Hello, world!"
# извлечение первых 5 символов
print(string[:5]) # выведет "Hello"
# извлечение последних 6 символов
print(string[-6:]) # выведет "world!"
# извлечение символов с шагом 2, начиная с третьего символа
print(string[2::2]) # выведет "lo ol"
В первом примере мы использовали пропуск для start, чтобы получить первые 5 символов строки. Во втором примере мы использовали пропуск для step, чтобы получить все символы строки с шагом 1, начиная с шестого символа с конца. В третьем примере мы использовали пропуск для stop, чтобы получить все символы строки с шагом 2, начиная с третьего символа.
Также можно использовать несколько пропусков для задания среза, который включает в себя всю строку:
string = "Hello, world!"
# получение всей строки
print(string[:]) # выведет "Hello, world!"
Задания для закрепления работы со срезами
Задание 3. Напишите программу, которая принимает строку от пользователя и выводит на экран первые 3 символа строки. Если строка короче 3 символов, выведите всю строку.
string = input("Введите строку: ")
print(string[:3])
Пример работы программы:
Введите строку: Привет, мир!
Прив
Задание 4. Напишите программу, которая принимает строку от пользователя и выводит на экран последние 3 символа строки. Если строка короче 3 символов, выведите всю строку.
string = input("Введите строку: ")
print(string[-3:])
Пример работы программы:
Введите строку: Привет, мир!
ир!
Задание 5. Напишите программу, которая принимает строку от пользователя и выводит на экран символы с 2 по 5. Если строка короче 5 символов, выведите всю строку.
string = input("Введите строку: ")
print(string[1:5])
Пример работы программы:
Введите строку: Привет, мир!
риве
Задание 6. Напишите программу, которая принимает строку от пользователя и выводит на экран каждый третий символ начиная с 2-го символа. Если строка короче 2 символов, выведите всю строку.
string = input("Введите строку: ")
print(string[1::3])
Пример работы программы:
Введите строку: Привет, мир!
и,р
Задание 7. Напишите программу, которая принимает строку от пользователя и выводит на экран каждый второй символ в обратном порядке. Если строка короче 2 символов, выведите всю строку.
string = input("Введите строку: ")
print(string[::-2])
Пример работы программы:
Введите строку: Привет, мир!
рмтвП
Задание 8. Напишите программу, которая принимает строку от пользователя и выводит на экран символы с шагом 2 начиная со второго символа и до предпоследнего символа. Если строка короче 3 символов, выведите всю строку.
string = input("Введите строку: ")
print(string[1:-1:2])
Пример работы программы:
Введите строку: Привет, мир!
ри м
Как посчитать количество символов в строке
Для того чтобы узнать длину строки в Python, можно использовать встроенную функцию len()
. Эта функция принимает на вход объект, длину которого нужно узнать, и возвращает целое число, равное количеству элементов в этом объекте.
Пример 1: определение длины строки
string = "Hello, world!"
length = len(string)
print(length) # 13
В этом примере мы создаем строку "Hello, world!"
и вызываем функцию len()
для определения ее длины. Результатом выполнения программы будет число 13
, так как в этой строке содержится 13 символов.
Задание для закрепления работы с функцией len()
Задание 9. Написать программу, которая принимает на вход строку и выводит первую и последнюю букву строки, а также все символы между ними в обратном порядке.
s = "hello world"
length = len(s) # получаем длину строки
start = s[0] # получаем первый символ
end = s[length-1] # получаем последний символ
middle = s[1:length-1] # получаем все символы между первым и последним
reverse_middle = middle[::-1] # переворачиваем символы между первым и последним
result = start + reverse_middle + end # объединяем символы в нужном порядке
print(result) # выводим результат
В данном примере мы сначала получаем длину строки с помощью функции len()
, затем извлекаем первый и последний символы строки с помощью индексов 0
и length-1
соответственно. Затем мы получаем все символы между первым и последним символом с помощью среза [1:length-1]
. Для переворачивания символов между первым и последним мы используем срез с отрицательным шагом [::-1]
. Наконец, мы объединяем символы в нужном порядке и выводим результат.
Строковые методы
Методы строк — это функции, которые могут быть применены к строке в Python. Они предназначены для выполнения различных операций со строками, таких как поиск подстроки, замена символов, преобразование регистра и многое другое.
Методы строк очень полезны, потому что они позволяют легко изменять и манипулировать строками, что может быть особенно полезно при обработке данных. Вместо того, чтобы написать свой собственный код для выполнения этих операций, можно использовать готовые методы, которые уже встроены в Python.
Для вызова метода по отношению к строковой переменной нужно написать имя переменной, затем точку и имя метода, а после открывающей скобки передать аргументы метода (если они нужны). Например, если у нас есть строковая переменная my_string
и мы хотим применить метод upper()
для преобразования строки в верхний регистр, то мы можем вызвать его следующим образом:
my_string = "Hello, World!"
my_string = my_string.upper()
Некоторые примеры методов строк:
upper()
: преобразует все символы в верхний регистр.lower()
: преобразует все символы в нижний регистр.replace()
: заменяет одну подстроку на другую.find()
: ищет подстроку в строке и возвращает ее позицию.count()
: считает количество вхождений подстроки в строку.
Например, метод upper()
можно использовать для преобразования всех символов в строке в верхний регистр:
s = "hello world"
s_upper = s.upper()
print(s_upper) # Выведет: HELLO WORLD
Метод replace()
можно использовать для замены всех вхождений одной подстроки на другую:
s = "hello world"
s_replaced = s.replace("o", "0")
print(s_replaced) # Выведет: hell0 w0rld
Обзор методов Python
- Метод
find()
: возвращает индекс первого вхождения подстроки в строке (или -1, если подстрока не найдена). Метод может принимать два параметра: искомую подстроку и индекс начала поиска (опционально). Если индекс начала поиска не указан, то поиск начинается с начала строки. Методrfind()
является аналогом методаfind()
, но возвращает индекс последнего вхождения подстроки в строку (с конца строки), а не первого.
Пример:
s = 'Hello, world!'
print(s.find('l')) # выводит 2, индекс первого вхождения буквы 'l'
print(s.find('world')) # выводит 7, индекс первого вхождения подстроки 'world'
print(s.find('l', 3)) # выводит 3, индекс первого вхождения буквы 'l' начиная с индекса 3
print(s.find('x')) # выводит -1, так как буква 'x' не найдена
- Метод
count()
: возвращает количество вхождений подстроки в строку. Метод также может принимать два параметра: искомую подстроку и индекс начала поиска (опционально). Если индекс начала поиска не указан, то поиск начинается с начала строки.
Пример:
s = 'Hello, world!'
print(s.count('l')) # выводит 3, так как буква 'l' встречается 3 раза в строке
print(s.count('world')) # выводит 1, так как подстрока 'world' встречается 1 раз в строке
print(s.count('l', 3)) # выводит 2, так как буква 'l' встречается 2 раза начиная с индекса 3
print(s.count('x')) # выводит 0, так как буква 'x' не встречается в строке
- Метод
replace()
: заменяет все вхождения одной подстроки на другую подстроку в строке. Метод принимает два параметра: подстроку, которую нужно заменить, и подстроку, на которую нужно заменить первую подстроку.
Пример:
s = 'Hello, world!'
new_s = s.replace('o', 'i')
print(new_s) # выводит 'Helli, wirld!'
- Метод
chr()
: возвращает символ по заданному коду символа.
Пример:
print(chr(65)) # выводит 'A'
- Метод
ord()
: возвращает число Unicode для заданного символа.
Пример:
print(ord('A')) # выводит 65
Метод split()
используется для разделения строки на подстроки по определенному разделителю. Разделитель может быть передан как аргумент метода или, если аргумент не указан, то пробел является разделителем по умолчанию. Результатом работы метода является список подстрок. Пример использования:
# Разделение строки по пробелу
text = "Hello, world!"
words = text.split()
print(words) # ['Hello,', 'world!']
# Разделение строки по запятой
text = "apple,banana,pear"
fruits = text.split(",")
print(fruits) # ['apple', 'banana', 'pear']
Метод join()
используется для объединения элементов последовательности в строку, используя заданный разделитель. Метод применяется к разделителю и передается последовательность в качестве аргумента. Результатом является строка, состоящая из элементов последовательности, объединенных разделителем. Пример использования:
# Объединение списка в строку с разделителем запятая
fruits = ['apple', 'banana', 'pear']
text = ','.join(fruits)
print(text) # 'apple,banana,pear'
# Объединение списка в строку с разделителем пробел
words = ['Hello,', 'world!']
text = ' '.join(words)
print(text) # 'Hello, world!'
Прочие строковые методы
Список методов строк, отвечающих за разделение и сборку строки:
split(sep=None, maxsplit=-1)
: разделяет строку на подстроки, используя заданный разделительsep
. Если разделитель не указан, используется пробел.maxsplit
определяет максимальное количество разбиений (по умолчанию все).rsplit(sep=None, maxsplit=-1)
: разделяет строку на подстроки, используя заданный разделительsep
, начиная справа.splitlines(keepends=False)
: разделяет строку на подстроки по символам перевода строки. Еслиkeepends=True
, символы перевода строки остаются в строке.join(iterable)
: объединяет элементы итерируемого объекта в строку, разделяя их текущей строкой.replace(old, new, count=-1)
: заменяет все вхождения подстрокиold
на подстрокуnew
.count
определяет максимальное количество замен (по умолчанию все).partition(sep)
: разделяет строку на три части: все, что находится до первого вхожденияsep
, самоsep
, и все, что находится после первого вхожденияsep
. Еслиsep
не найден, возвращает оригинальную строку и две пустые строки.rpartition(sep)
: аналогиченpartition()
, но разделение производится справа.
Проверки вхождения
str.endswith(suffix[, start[, end]])
: ВозвращаетTrue
, если строка заканчивается заданным суффиксом, иначе возвращаетFalse
.str.startswith(prefix[, start[, end]])
: ВозвращаетTrue
, если строка начинается заданным префиксом, иначе возвращаетFalse
.str.isalnum()
: ВозвращаетTrue
, если все символы в строке являются буквами или цифрами, иначе возвращаетFalse
.str.isalpha()
: ВозвращаетTrue
, если все символы в строке являются буквами, иначе возвращаетFalse
.str.isdecimal()
: ВозвращаетTrue
, если все символы в строке являются десятичными цифрами, иначе возвращаетFalse
.str.isdigit()
: ВозвращаетTrue
, если все символы в строке являются цифрами, иначе возвращаетFalse
.str.isidentifier()
: ВозвращаетTrue
, если строка является допустимым идентификатором Python, иначе возвращаетFalse
.str.islower()
: ВозвращаетTrue
, если все символы в строке являются строчными буквами, иначе возвращаетFalse
.str.isnumeric()
: ВозвращаетTrue
, если все символы в строке являются числами, иначе возвращаетFalse
.str.isprintable()
: ВозвращаетTrue
, если все символы в строке печатаемые, иначе возвращаетFalse
.str.isspace()
: ВозвращаетTrue
, если все символы в строке являются пробельными символами, иначе возвращаетFalse
.str.istitle()
: ВозвращаетTrue
, если строка начинается с заглавной буквы и все остальные символы в строке являются строчными, иначе возвращаетFalse
.str.isupper()
: ВозвращаетTrue
, если все символы в строке являются заглавными буквами, иначе возвращаетFalse
.str.count(sub[, start[, end]])
: Возвращает количество вхождений подстроки в строку.str.find(sub[, start[, end]])
: Возвращает индекс первого вхождения подстроки в строку, или-1
, если подстрока не найдена.str.index(sub[, start[, end]])
: То же, что иstr.find()
, но если подстрока не найдена, вызывает исключение.str.rfind(sub[, start[, end]])
: Возвращает индекс последнего вхождения подстроки в строку, или-1
, если подстрока не найдена
Преобразование строк
upper()
: переводит все символы строки в верхний регистрlower()
: переводит все символы строки в нижний регистрcapitalize()
: переводит первый символ строки в верхний регистр, а все остальные в нижнийtitle()
: переводит первый символ каждого слова в верхний регистр, а все остальные в нижнийswapcase()
: переводит символы верхнего регистра в нижний и символы нижнего регистра в верхнийstrip([chars])
: удаляет все вхождения указанных символов с начала и конца строки (по умолчанию пробелы)rstrip([chars])
: удаляет все вхождения указанных символов с конца строки (по умолчанию пробелы)lstrip([chars])
: удаляет все вхождения указанных символов с начала строки (по умолчанию пробелы)replace(old, new[, count])
: заменяет все вхождения указанной подстрокиold
на подстрокуnew
, не болееcount
раз (по умолчанию все вхождения)translate(table[, deletechars])
: возвращает копию строки, в которой все символы, указанные в таблицеtable
, заменены на соответствующие символы или удаляются (если передан параметрdeletechars
)maketrans(x[, y[, z]])
: создает таблицу, используемую для перевода символов с помощью методаtranslate()
. Если указан один аргумент, он должен быть словарем, где ключи — это символы, которые нужно заменить, а значения — символы, на которые нужно их заменить. Если переданы два аргумента, они должны быть строками равной длины, где каждый символ первой строки заменяется соответствующим символом из второй строки. Если передан третий аргумент, он должен быть строкой, в которой указаны символы, которые нужно удалить из строки.
Задания на закрепление использования строковых методов
Задание 10.Найти индекс первого вхождения символа в строке и вывести его на экран.
s = "hello world"
char = "o"
index = s.find(char)
print(f"The index of '{char}' in '{s}' is {index}")
Задание 11. Посчитать количество вхождений символа в строке и вывести результат на экран.
s = "hello world"
char = "l"
count = s.count(char)
print(f"The character '{char}' occurs {count} times in '{s}'")
Задание 12. Заменить все вхождения символа в строке на другой символ и вывести результат на экран.
s = "hello world"
old_char = "l"
new_char = "z"
new_s = s.replace(old_char, new_char)
print(f"The string '{s}' with all '{old_char}' replaced by '{new_char}' is '{new_s}'")
Задание 13. Найти индекс последнего вхождения символа в строке и вывести его на экран.
s = "hello world"
char = "l"
index = s.rfind(char)
print(f"The index of the last occurrence of '{char}' in '{s}' is {index}")
Форматирование строк
Форматирование строк — это когда мы хотим напечатать какой-то текст, но в нем надо заменить некоторые слова на другие слова или значения, например, числа.
Мы используем специальные знаки, чтобы показать, где мы хотим, чтобы произошла эта замена. Такой способ делает текст удобным для чтения.
Вместо того, чтобы создавать длинные строки с конкатенацией и разделителями, можно использовать специальные символы, которые обозначают места вставки значений.
В Python есть несколько способов форматирования строк, включая использование оператора %
, метода format()
, а также f-строк (начиная с Python 3.6). Они позволяют указывать значения, которые будут вставлены в строку, а также форматировать их в соответствии с определенными правилами.
Например, мы можем использовать форматирование строк, чтобы вывести значение переменной в предложении:
name = "John"
age = 30
print("My name is %s and I'm %d years old." % (name, age))
Здесь символ %s
обозначает место, где должно быть вставлено значение строки, а символ %d
обозначает место, где должно быть вставлено целое число. Значения для вставки передаются в виде кортежа в круглых скобках после символа %
.
Результат выполнения данного кода будет следующим:
My name is John and I'm 30 years old.
Таким образом, форматирование строк позволяет создавать более читабельный и понятный код, упрощая работу с динамическими значениями в строках.
Синтаксис использования форматирования
Для форматирования строк в Python можно использовать общий синтаксис, который состоит из строки-шаблона и значения, которые нужно вставить в этот шаблон. Чтобы вставить значение в строку-шаблон, нужно использовать фигурные скобки {} и перед ними указать номер позиции в списке значений, начиная с 0. Например, если нужно вставить два значения — строку «hello» и число 42, то шаблон будет выглядеть так:
template = "String: {}, Number: {}"
values = ["hello", 42]
result = template.format(*values)
print(result)
В этом примере мы задали строку-шаблон template
с двумя фигурными скобками, и список values
, содержащий два значения, которые нужно вставить в шаблон. Затем мы вызвали метод format()
для строки-шаблона и передали в него список значений с помощью звездочки *
. Результат выполнения этого кода будет следующим:
String: hello, Number: 42
Спецификатор формата
Полный спецификатор (описание синтаксиса) форматирования в Python имеет следующий вид:
[[fill]align][sign][#][0][width][,][.precision][type]
Квадратные скобки обозначают необязательные параметры. Подробнее о спецификаторах синтаксиса можно узнать тут. Давайте разберем каждый параметр подробнее:
fill
: символ, используемый для заполнения пустого пространства между значением и шириной поля. По умолчанию используется пробел.align
: выравнивание значения внутри ширины поля. Возможные значения:<
: выравнивание по левому краю (по умолчанию)>
: выравнивание по правому краю^
: выравнивание по центру=
: выравнивание по центру и заполнение пустого пространства символом fill для числовых типов данных
sign
: показывать ли знак для числовых значений. Возможные значения:+
: всегда показывать знак, даже для положительных чисел-
: только для отрицательных чисел (по умолчанию): использовать пробел для положительных чисел, знак для отрицательных
#
: добавить дополнительную информацию о формате. Возможные значения:o
: добавить префикс ‘0o’ для восьмеричных чиселx
илиX
: добавить префикс ‘0x’ или ‘0X’ для шестнадцатеричных чисел соответственноb
: добавить префикс ‘0b’ для двоичных чисел.
: при использовании с типомf
илиF
— всегда показывать десятичную точку
0
: заполнить пустое место нулями вместо пробеловwidth
: минимальная ширина поля. Если значение меньше, чем указанная ширина, то оно заполняется символами fill. По умолчанию равно 0.,
: добавлять разделитель тысячных для целых чисел.precision
: точность для числовых типов данных (количество знаков после десятичной точки). Для остальных типов игнорируется.type
: тип форматирования. Возможные значения:d
илиi
: десятичное число (целочисленный тип)o
: восьмеричное числоx
илиX
: шестнадцатеричное числоb
: двоичное числоe
илиE
: число в экспоненциальной записи (например,3.14e+00
)f
или `F : число в записи десятичной дроби, например: 1.25
Звучит сложно, поэтому разберем эти параметры на примерах.
Выравнивание в форматировании
- {:<N} — выравнивание по левому краю, заполнение пробелами справа до длины N
- {:>N} — выравнивание по правому краю, заполнение пробелами слева до длины N
- {:^N} — выравнивание по центру, заполнение пробелами с обеих сторон до длины N
Пример использования выравнивания:
name = "John"
age = 30
print("{:<10} {:^10} {:>10}".format(name, age, "years old"))
Вывод:
John 30 years old
Слово John было выровнено по левому краю с отступом 10, «30» — по центру с отступом 10, а «years old
» по правому краю с отступом 10. Поэкспериментируйте с разными значениями отступов и сравните результат.
Заполнители
Заполнитель в форматировании строк используется для добавления символов-заполнителей между отформатированным значением и границей поля, если значение занимает меньшее количество символов, чем заданная ширина поля.
Для использования заполнителя необходимо добавить символ-заполнитель после двоеточия в спецификаторе формата, например, ‘{:05}’. В этом примере заполнитель ‘0’ будет добавлен перед значением, если значение занимает меньше пяти символов.
Примеры использования заполнителя:
# Использование заполнителя нуля
num = 7
print("Number: {:03}".format(num)) # Вывод: Number: 007
# Использование заполнителя пробела
text = "hello"
print("Text: {:>10}".format(text)) # Вывод: Text: hello
В первом примере мы использовали заполнитель нуля, чтобы добавить два нуля перед числом 7 и выровнять его по ширине в три символа. Во втором примере мы использовали заполнитель пробела, чтобы добавить пять пробелов перед словом «hello» и выровнять его по ширине в десять символов.
Заполнитель можно использовать с различными типами данных, включая числа, строки и даты. Кроме того, можно использовать не только одиночные символы-заполнители, но и строки-заполнители.
Примеры использования заполнителя со строками, числами и датами:
# Использование заполнителя со строкой
name = "Alice"
print("Hello, {:*>10}!".format(name)) # Вывод: Hello, *****Alice!
# Использование заполнителя с числом
num = 42
print("Number: {:,.2f}".format(num)) # Вывод: Number: 42.00
# Использование заполнителя с датой
from datetime import datetime
dt = datetime(2022, 4, 1)
print("Date: {:%Y-%m-%d}".format(dt)) # Вывод: Date: 2022-04-01
В первом примере мы использовали строковый заполнитель ‘*’, чтобы заполнить пустое пространство перед именем «Alice». Во втором примере мы использовали заполнитель запятой и точки, чтобы отделить тысячи и добавить два знака после запятой к числу 42. В третьем примере мы использовали заполнитель для форматирования даты в формате «ГГГГ-ММ-ДД».
Использование знаков для чисел.
Часто требуется указать знак не только для отрицательных, но и для положительных чисел. Как это сделать:
x = 10
print("{:+} {:<10}".format(x, bin(x)))
В данном случае, переменная x
имеет положительное значение и была выведена со знаком +
+10 0b1010
Использование различных представлений типов данных
- d — целое число
- f — число с плавающей точкой
- s — строка
- b — двоичное число
- o — восьмеричное число
- x — шестнадцатеричное число
x = 10.5
print("{:.2f} {:d} {:o} {:x} {}".format(x, 42, 42, 42, "string"))
В данном примере мы выводим переменную x
с двумя знаками после запятой, а также число 42
в десятичной, восьмеричной и шестнадцатеричной системе счисления.
10.50 42 52 2a string
Использование перевода строки и табуляции
Специальные символы:
- \n — перевод строки
- \t — символ табуляции
Пример использования специальных символов:
print("first line\nsecond line\ttabbed")
В данном примере, был использован перевод на новую строку после first line
и добавлена табуляция (широкий отступ) после second line
.
first line
second line tabbed
Задания на форматирование строк
Задание 14. Создайте переменную
name
со значением вашего имени и переменнуюage
со значением вашего возраста. Выведите строку «Меня зовут <имя>, мне <возраст> лет.» с помощью форматирования строк.Создайте переменную
balance
со значением вашего баланса на счете и переменнуюcurrency
со значением валюты (например, «руб.» или «$»). Выведите строку «На вашем счете <balance> <currency>.» с помощью форматирования строк.Создайте переменную
temperature
со значением температуры в градусах Цельсия. Выведите строку «Температура сегодня <temperature> градусов Цельсия» с помощью форматирования строк.Создайте переменную
text
со значением произвольного текста. Затем выведите этот текст, заменив все буквы «а» на знак «*». Используйте методreplace()
и форматирование строк.
# Задание 1
name = "Иван"
age = 25
print(f"Меня зовут {name}, мне {age} лет.")
# Задание 2
balance = 5000
currency = "руб."
print(f"На вашем счете {balance} {currency}.")
# Задание 3
temperature = 18
print(f"Температура сегодня {temperature} градусов Цельсия.")
# Задание 4
text = "Это пример текста со словом абракадабра"
new_text = text.replace("а", "*")
print(f"Оригинальный текст: {text}")
print(f"Измененный текст: {new_text}")
Видеоурок по строкам
Для тех, кому удобнее видео:
Модуль string
В Python модуль string
предоставляет несколько констант и классов, которые представляют различные строки, символы и определенные категории символов. Вот краткий обзор возможностей модуля string
:
- Константы:
string.ascii_letters
: Содержит все буквы ASCII (верхний и нижний регистр).string.ascii_lowercase
: Содержит все строчные буквы ASCII.string.ascii_uppercase
: Содержит все заглавные буквы ASCII.string.digits
: Содержит все десятичные цифры (0-9).string.hexdigits
: Содержит шестнадцатеричные цифры (0-9, a-f, A-F).string.octdigits
: Содержит восьмеричные цифры (0-7).string.punctuation
: Содержит знаки пунктуации.string.printable
: Содержит все печатаемые символы.
- Функции:
string.capwords(s, sep=None)
: Возвращает строку, в которой каждое слово начинается с заглавной буквы, а все остальные буквы строчные. Пример:import string s = "hello world" result = string.capwords(s) print(result) # Вывод: Hello World
- Классы:
string.Template
: Позволяет создавать шаблоны строк с заменяемыми переменными. Пример:from string import Template template = Template("$name is a great $job!") result = template.substitute(name="John", job="developer") print(result) # Вывод: John is a great developer!
Практические задания на строки в Python
Задание 15. Составить программу, которая запрашивает название футбольной команды и повторяет его на экране со словами «— это чемпион!»
Для решения этой задачи нам нужно запросить у пользователя название футбольной команды, затем с помощью метода format()
сформировать строку с сообщением о том, что данная команда является чемпионом.
Вот как может выглядеть код для этой задачи:
team_name = input("Введите название футбольной команды: ")
message = "{} — это чемпион!".format(team_name)
print(message)
Пользователю будет предложено ввести название команды, например, «Ливерпуль». Затем программа с помощью метода format()
создаст сообщение «Ливерпуль — это чемпион!» и выведет его на экран.
Пример работы программы:
Введите название футбольной команды: Ливерпуль
Ливерпуль — это чемпион!
Задание 16. Составить программу, которая запрашивает название романа и фамилию его автора, а затем выводит сообщение: «Писатель … — автор романа …» (на месте многоточий должны быть выведены соответствующие значения).
Для решения данной задачи мы можем использовать функцию input()
для запроса названия романа и фамилии автора у пользователя, а затем использовать форматирование строк для вывода сообщения.
Вот пример кода:
# Запрос названия романа и фамилии автора
title = input("Введите название романа: ")
author = input("Введите фамилию автора: ")
# Вывод сообщения с использованием форматирования строк
print("Писатель {} — автор романа {}".format(author, title))
Пользователь сначала увидит приглашение для ввода названия романа, а затем — фамилии автора. После того, как пользователь введет оба значения, программа использует форматирование строк для вывода сообщения в формате «Писатель … — автор романа …», где многоточия заменены на соответствующие значения, которые ввел пользователь.
Задание 17. Дано название города. Определить, четно или нет количество символов в нем.
city = input("Введите название города: ")
if len(city) % 2 == 0:
print("Количество символов в городе", city, "чётное.")
else:
print("Количество символов в городе", city, "нечётное.")
В этом коде мы сначала запрашиваем у пользователя название города с помощью функции input()
и сохраняем его в переменную city
. Затем мы проверяем, является ли количество символов в строке city
четным или нечетным. Если остаток от деления на два равен нулю, то количество символов четное, и мы выводим соответствующее сообщение. Если остаток от деления на два не равен нулю, то количество символов нечетное, и мы выводим другое сообщение.
Пример работы программы:
Введите название города: Москва
Количество символов в городе Москва чётное.
Задание 18. Дано слово. Верно ли, что оно начинается и оканчивается на одну и ту же букву?
Важно! Приступайте к решению задачи только после изучения темы на условные конструкции! Если тема не пройдена, пропускайте.
Для решения этой задачи можно воспользоваться методами работы со строками. В частности, нам нужно получить первый и последний символ строки и сравнить их.
Вот пример кода, решающего данную задачу:
word = input("Введите слово: ")
first_char = word[0]
last_char = word[-1]
if first_char == last_char:
print("Слово начинается и оканчивается на одну и ту же букву")
else:
print("Слово не начинается и не оканчивается на одну и ту же букву")
В данном коде мы сначала запрашиваем у пользователя слово и сохраняем его в переменную word
. Затем мы получаем первый символ слова, обращаясь к нему по индексу 0
, и последний символ слова, обращаясь к нему по индексу -1
.
Далее мы сравниваем первый и последний символы, используя условный оператор if
. Если они равны, то выводим сообщение «Слово начинается и оканчивается на одну и ту же букву», а если не равны, то выводим сообщение «Слово не начинается и не оканчивается на одну и ту же букву».
Пример работы программы:
Введите слово: радар
Слово начинается и оканчивается на одну и ту же букву
Задание 19. Дано слово. Получить и вывести на экран буквосочетание, состоящее из его третьего и последнего символа.
Для получения буквосочетания, состоящего из третьего и последнего символа, можно воспользоваться индексацией строк и сложением строк.
Вот пример решения задачи:
word = input("Введите слово: ")
result = word[2] + word[-1] # Складываем третий и последний символы
print(«Буквосочетание:», result)
Сначала мы запрашиваем у пользователя слово и сохраняем его в переменной word
. Затем мы складываем третий и последний символы и выводим результат на экран.
Например, если пользователь введет слово «python», то программа выведет на экран:
Буквосочетание: tn
Задание 20. Из слова яблоко путем срезов получить слова блок и око.
Для получения слова блок можно использовать срезы следующим образом:
word = "яблоко"
block = word[2:6]
print(block) # "блок"
Здесь мы используем срез с индекса 2 (включительно) до индекса 6 (не включая), что соответствует символам «б», «л», «о» и «к» в слове «яблоко».
Для получения слова око можно использовать следующий код:
word = "яблоко"
oko = word[-2:] + word[1:2]
print(oko) # "око"
Здесь мы объединяем срез, начинающийся с предпоследнего символа слова (-2) и заканчивающийся последним символом (:), с срезом, состоящим из второй буквы слова (1) и длиной 1 символ (:2). Полученные два среза мы объединяем с помощью оператора «+», чтобы получить искомое слово «око».
Задание 21. Из слова курсор путем замены его букв получить слово танцор.
Для замены букв в слове можно использовать метод replace()
.
Пример кода:
word = "курсор"
new_word = word.replace("к", "т").replace("с", "н")
print(new_word) # выводит "танцор"
В этом примере мы сначала заменяем букву «к» на «т» с помощью метода replace()
, а затем заменяем букву «с» на «н» в полученном слове. В результате получаем слово «танцор».
Задание 22. Дано слово длиной кратной трем. Поменять местами его трети следующим образом: первую треть слова разместить на месте третьей, вторую треть — на месте первой, третью треть — на месте второй.
Для решения задачи нужно использовать срезы строк. В Python можно получить часть строки, используя следующий синтаксис: string[start:end:step]
, где start
— индекс первого символа, который нужно взять, end
— индекс последнего символа + 1, который необходимо взять, step
— шаг, с которым нужно взять символы (по умолчанию 1).
Для данной задачи мы можем использовать следующий алгоритм:
- Получить длину слова.
- Разбить слово на три части, используя срезы строк.
- Поменять местами полученные части слова в соответствии с условием задачи.
- Объединить полученные части слова в одно слово и вывести результат на экран.
Пример кода для решения этой задачи:
word = "abcdef"
length = len(word)
third = length // 3 # вычисляем длину одной трети слова
part1 = word[:third] # первая треть слова
part2 = word[third:2*third] # вторая треть слова
part3 = word[2*third:] # третья треть слова
new_word = part3 + part1 + part2 # меняем местами трети слова
print(new_word) # выводим результат на экран
Вывод программы будет: efabcde
В данном примере мы использовали длину слова abcdef
, которая кратна трем. Если длина слова не будет кратна трем, то алгоритм работать не будет.
Задание 23. Дано предложение из более чем 4 слов. Определить число слов нем. Переставить второе и четвертое слова местами.
Мы можем использовать методы строк, такие как count
и find
, чтобы выполнить эти задачи.
Вот решение:
# Заданное предложение
sentence = "Это задание для проверки умений программировать без циклов и условий"
# Определение количества слов в предложении
num_words = sentence.count(" ") + 1
print("Количество слов в предложении:", num_words)
# Перестановка второго и четвертого слов
first_space = sentence.find(" ")
second_space = sentence.find(" ", first_space + 1)
third_space = sentence.find(" ", second_space + 1)
new_sentence = sentence[:second_space+1] + sentence[third_space+1:second_space+1] + sentence[second_space+1:third_space+1] + sentence[third_space+1:]
print("Измененное предложение:", new_sentence)
В этом решении мы сначала определяем количество слов в предложении, подсчитывая количество пробелов и добавляя 1. Затем мы находим индексы пробелов, чтобы переставить второе и четвертое слова. Мы используем эти индексы для создания новой строки, где мы помещаем второе слово перед третьим и четвертым словом перед вторым. Наконец, мы выводим на экран количество слов в предложении и измененное предложение.
Задание 24. Дано предложение. Определить долю (в %) букв а в нем.
Для решения этой задачи мы можем использовать метод count()
для подсчета количества букв «а» в предложении и функцию len()
для определения общего количества символов. Затем мы можем вычислить долю букв «а» в предложении в процентах.
Вот код, который решает эту задачу:
sentence = input("Введите предложение: ")
count_a = sentence.count('a') + sentence.count('A') # учитываем и заглавные и строчные буквы
percent_a = count_a / len(sentence) * 100
print(f"Доля букв 'a' в предложении составляет {percent_a:.2f}%")
В этом коде мы сначала запрашиваем у пользователя предложение с помощью функции input()
. Затем мы используем метод count()
для подсчета количества букв «a» в предложении, учитывая как заглавные, так и строчные буквы. Затем мы используем функцию len()
для определения общего количества символов в предложении.
Наконец, мы вычисляем долю букв «a» в предложении в процентах, используя формулу (количество букв "a" / общее количество символов) * 100
. Здесь мы используем форматирование строк, чтобы вывести результат с двумя знаками после запятой.
Пример работы программы:
Введите предложение: The quick brown fox jumps over the lazy dog
Доля букв 'a' в предложении составляет 7.14%
Задание 25. Дано предложение. Заменить в нем все вхождения буквосочетания бит на рог.
Для замены всех вхождений буквосочетания «бит» на «рог» можно воспользоваться методом replace() строки. Программа будет выглядеть следующим образом:
sentence = "В глубоком биту лежит корабль"
new_sentence = sentence.replace("бит", "рог")
print(new_sentence)
Задание 26. Дано слово. Поменять местами его m-ю и n-ю буквы.
й буквами, n-ю букву и часть слова после n-й буквы. Затем мы объединяем эти части в новую строку.
Вот пример кода:
word = input("Введите слово: ")
m = int(input("Введите номер m-й буквы: "))
n = int(input("Введите номер n-й буквы: "))
if m > n:
m, n = n, m # Если m > n, меняем их местами
new_word = word[:m-1] + word[n-1] + word[m:n-1] + word[m-1] + word[n:]
print("Новое слово: ", new_word)
В этом примере мы сначала запрашиваем слово и номера m-й и n-й буквы. Затем мы проверяем, чтобы m было меньше или равно n, иначе мы меняем их местами. Затем мы создаем новую строку, используя срезы, и выводим ее на экран.
Пример работы программы:
Введите слово: python
Введите номер m-й буквы: 2
Введите номер n-й буквы: 5
Новое слово: pthyon
Задание 27. Дано предложение. Удалить из него все буквы с.
Для решения этой задачи мы можем использовать метод replace()
для замены всех вхождений буквы «с» на пустую строку «».
Пример работы программы:
sentence = "У Саши сегодня супер солнечный день"
modified_sentence = sentence.replace("с", "")
print(modified_sentence)
Вывод:
У аши егодня упер олнечный день
Здесь мы создали строку sentence
с предложением, которое содержит букву «с». Затем мы использовали метод replace()
для замены всех вхождений буквы «с» на пустую строку «» и сохранили результат в переменную modified_sentence
. Наконец, мы вывели результат на экран. Как видим, все буквы «с» были удалены из предложения.
Задание 28. У вас есть информация о товаре, такая как его имя, цена и количество. Создайте строку, которая форматирует эту информацию для отображения в чеке с выравниванием по правому краю.
product_name = "Молоко"
price = 2.5
quantity = 3
total = price * quantity
formatted_line = f"{product_name: <10} {price: >5} x {quantity: >2} = {total: >6.2f}"
Задание 29. Попросите пользователя ввести температуру в градусах Цельсия и конвертируйте её в градусы Фаренгейта, используя форматирование строки для вывода результата.
Конвертация делается по формуле:
fahrenheit = (celsius * 9/5) + 32
celsius = float(input("Введите температуру в градусах Цельсия: "))
fahrenheit = (celsius * 9/5) + 32
print(f"Температура в градусах Фаренгейта: {fahrenheit:.2f} °F")
Задание 30. У вас есть данные о доходе, расходах и прибыли компании. Используйте форматирование строк для создания отчёта с выравниванием чисел по правому краю и выводом денежных значений.
Пример:
Доход: $ 50,000.00
Расходы: $ 35,000.00
Прибыль: $ 15,000.00
income = 50000
expenses = 35000
profit = income - expenses
report = f"Доход: ${income:>22,.2f}\nРасходы: ${expenses:>20,.2f}\nПрибыль: ${profit:>20,.2f}"
Задание 31. Попросите пользователя ввести число и используйте форматирование строки для вывода числа с указанием знака (+ или -) перед ним.
number = float(input("Введите число: "))
print(f"Число со знаком: {:+number}")
Задание 32. У вас есть данные в виде списка списков, и вы хотите создать таблицу для их отображения.
Задачу можно решать только после изучения тем «Списки», «Циклы».
data = [ ["Имя", "Возраст", "Город"],
["Анна", 28, "Москва"],
["Иван", 32, "Санкт-Петербург"],
["Елена", 24, "Киев"] ]
data = [ ["Имя", "Возраст", "Город"],
["Анна", 28, "Москва"],
["Иван", 32, "Санкт-Петербург"],
["Елена", 24, "Киев"]
]
for row in data:
print(f"{row[0]: <15} {row[1]: >10} {row[2]: <15}")
Индивидуальное и групповое обучение «Python Junior»
Если вы хотите научиться программировать на Python, могу помочь. Запишитесь на мой курс «Python Junior» и начните свой путь в мир ИТ уже сегодня!
Контакты
Для получения дополнительной информации и записи на курсы свяжитесь со мной:
Телеграм: https://t.me/Vvkomlev
Email: victor.komlev@mail.ru
Объясняю сложное простыми словами. Даже если вы никогда не работали с ИТ и далеки от программирования, теперь у вас точно все получится! Проверено десятками примеров моих учеников.
Гибкий график обучения. Я предлагаю занятия в мини-группах и индивидуально, что позволяет каждому заниматься в удобном темпе. Вы можете совмещать обучение с работой или учебой.
Практическая направленность. 80%: практики, 20% теории. У меня множество авторских заданий, которые фокусируются на практике. Вы не просто изучаете теорию, а сразу применяете знания в реальных проектах и задачах.
Разнообразие учебных материалов: Теория представлена в виде текстовых уроков с примерами и видео, что делает обучение максимально эффективным и удобным.
Понимаю, что обучение информационным технологиям может быть сложным, особенно для новичков. Моя цель – сделать этот процесс максимально простым и увлекательным. У меня персонализированный подход к каждому ученику. Максимальный фокус внимания на ваши потребности и уровень подготовки.