RU
EN
RU
EN
ТЕОРИЯ И ПРАКТИКА
-
Ввод и вывод данных
- Задачи
-
Условия
- Задачи
-
Цикл for
- Задачи
-
Строки
- Задачи
-
Цикл while
- Задачи
-
Списки
- Задачи
-
Двумерные массивы
- Задачи
-
Словари
- Задачи
-
Множества
- Задачи
-
Функции и рекурсия
- Задачи
Занятие 4. Строки и методы строк в питоне
Введение в строки Python и их методы
Определение строк в Python
Строка (string, str) — это последовательность символов. Всё, что вы заключаете в кавычки, Python воспринимает как строку: будь то буквы, цифры, знаки препинания или пробелы. Это один из самых фундаментальных и часто используемых типов данных.
Особенность строк — неизменяемость
Ключевая особенность строк в Python — они неизменяемы (immutable). Это означает, что после создания строки вы не можете изменить её отдельные символы. Любая операция, которая "изменяет" строку (например, замена символа или перевод в другой регистр), на самом деле создает новую строку в памяти.
# Попытка изменить символ в строке приведет к ошибке
my_string = "hello"
# my_string[0] = 'H' # Это вызовет TypeError: 'str' object does not support item assignment
# Правильный способ — создать новую строку
new_string = "H" + my_string[1:]
print(new_string) # Вывод: Hello
Назначение строк в программировании: ввод данных
Строки — это основной способ взаимодействия программы с пользователем и внешним миром. Они используются для:
- Получения данных от пользователя (например, через функцию
input()). - Чтения и записи данных в файлы.
- Отправки и получения информации по сети.
- Отображения сообщений, ошибок и результатов работы программы.
# Пример получения данных от пользователя
user_name = input("Введите ваше имя: ")
print("Привет, " + user_name + "!")
Создание и соединение строк в Python
Использование одинарных кавычек (' ')
Самый простой способ создать строку — заключить текст в одинарные кавычки.
string_one = 'Это строка в одинарных кавычках.'
print(string_one)
Использование двойных кавычек (" ")
Двойные кавычки работают абсолютно так же, как и одинарные.
string_two = "Это строка в двойных кавычках."
print(string_two)
Отличия между одинарными и двойными кавычками
Основное отличие — удобство. Если внутри строки нужно использовать одинарную кавычку (например, апостроф), всю строку удобнее заключить в двойные, и наоборот.
# Внутри двойных кавычек можно свободно использовать одинарные
quote_string = "Он сказал: 'Привет, мир!'"
print(quote_string)
# Внутри одинарных кавычек — двойные
another_quote = 'Цитата: "Быть или не быть".'
print(another_quote)
Тройные кавычки (''' ''' и """ """)
Тройные кавычки (как одинарные, так и двойные) обладают двумя суперспособностями.
Создание многострочных строк
Текст, заключенный в тройные кавычки, может располагаться на нескольких строках, и все переносы строк сохранятся.
multi_line_string = """Это первая строка.
Это вторая строка.
А это третья с отступом."""
print(multi_line_string)
Включение кавычек внутрь строки
Внутри тройных кавычек можно свободно использовать и одинарные, и двойные кавычки без каких-либо проблем.
complex_string = '''В этой строке можно использовать "двойные" и 'одинарные' кавычки.'''
print(complex_string)
Создание и соединение строк
Примеры создания различных строк
Выбор типа кавычек — это в первую очередь вопрос удобства. Вот практические примеры, когда какой тип кавычек лучше использовать:
Одинарные кавычки (
'): Идеальны для простых строк без вложенных кавычек.simple_string = 'Просто текст.' print(simple_string)Двойные кавычки (
"): Незаменимы, если внутри строки есть апостроф или одинарная кавычка.# Использование апострофа внутри строки dialogue = "Don't worry, be happy!" print(dialogue)Тройные кавычки (
"""или'''): Лучший выбор для многострочного текста или когда внутри строки встречаются и одинарные, и двойные кавычки.# Пример с многострочностью и разными кавычками complex_quote = '''Он сказал: "It's a beautiful day, isn't it?"''' print(complex_quote)
Экранированные символы
Что такое экранирование символов
Экранирование — это способ вставить в строку специальные символы, которые нельзя просто так напечатать. Для этого используется обратный слэш \, который говорит Python, что следующий за ним символ нужно интерпретировать по-особенному.
Основные специальные символы
Создание новой строки в Python: \n
\n — символ переноса строки.
new_line_example = "Первая строка\nВторая строка"
print(new_line_example)
# Вывод:
# Первая строка
# Вторая строка
\t — табуляция
\t — вставляет символ табуляции (обычно это несколько пробелов).
tab_example = "Имя:\tАлекс"
print(tab_example)
# Вывод: Имя: Алекс
\ — обратный слэш
Чтобы вставить в строку сам символ \, его нужно экранировать: \\.
slash_example = "Путь к файлу: C:\\Users\\Public"
print(slash_example)
# Вывод: Путь к файлу: C:\Users\Public
' — одинарная кавычка
Позволяет вставить одинарную кавычку в строку, созданную с помощью одинарных кавычек.
single_quote_example = 'Это пример использования \'одинарной кавычки\' внутри.'
print(single_quote_example)
" — двойная кавычка
Аналогично для двойных кавычек.
double_quote_example = "Он процитировал: \"Да здравствует Python!\"."
print(double_quote_example)
Почему экранирование важно
Экранирование позволяет точно контролировать содержимое строки, включая в нее непечатаемые символы (как \n) и символы, которые имеют специальное значение для синтаксиса Python (как кавычки).
Экранированные символы
Почему экранирование важно
Экранирование с помощью обратного слэша \ решает две ключевые задачи:
- Вставка непечатаемых символов: Оно позволяет добавить в строку символы, которые нельзя просто так ввести с клавиатуры, например, символ новой строки (
\n) или табуляции (\t). Без экранирования было бы невозможно управлять форматированием текста внутри одной строки. - Устранение неоднозначности: Оно сообщает интерпретатору Python, что следующий символ нужно воспринимать буквально, а не как часть синтаксиса. Например, в строке
'It\'s my life'слэш говорит, что апостроф — это часть словаIt's, а не конец строки. Без него Python увидел бы конец строки послеItи выдал бы синтаксическую ошибку.
Строковые операции и функции в Python
Конкатенация (оператор +)
Конкатенация — это "склеивание" строк.
Объединение двух и более строк
Оператор + объединяет строки в одну новую.
# Пример конкатенации строк в Python
str1 = "Привет, "
str2 = "мир"
str3 = "!"
result = str1 + str2 + str3
print(result) # Вывод: Привет, мир!
Повторение строк (оператор * в Python)
Оператор * позволяет повторить строку заданное количество раз.
Повторение строки
Умножение строки на целое число создает новую строку, состоящую из повторений исходной.
# Пример повторения
laugh = "ха"
repeated_laugh = laugh * 5
print(repeated_laugh) # Вывод: хахахахаха
Индексация строк
Каждый символ в строке имеет свой порядковый номер — индекс. Индексация позволяет получить доступ к отдельному символу.
Индексация с начала (начиная с 0)
Нумерация символов в Python всегда начинается с 0.
Отрицательная индексация (с конца)
Индекс -1 соответствует последнему символу, -2 — предпоследнему, и так далее.
# Пример обращения к символам по индексу
word = "Python"
# P y t h o n
# 0 1 2 3 4 5
# -6 -5 -4 -3 -2 -1
first_char = word[0]
third_char = word[2]
last_char = word[-1]
pre_last_char = word[-2]
print(f"Первый символ: {first_char}") # Вывод: Первый символ: P
print(f"Третий символ: {third_char}") # Вывод: Третий символ: t
print(f"Последний символ: {last_char}") # Вывод: Последний символ: n
print(f"Предпоследний: {pre_last_char}") # Вывод: Предпоследний: o
Срезы строк в Python
Срез (slice) — это мощный инструмент для получения части строки (подстроки).
Основы срезов: [start:stop]
Срез берет символы с индекса start до индекса stop, не включая сам stop.
Пропуск start или stop
[:stop]— срез от начала доstop.[start:]— срез отstartдо конца.[:]— полная копия строки.
Шаг среза [start:stop:step]
step указывает, с каким шагом нужно брать символы. Например, шаг 2 возьмет каждый второй символ. Шаг -1 перевернет строку.
# Примеры различных срезов
s = "Апельсин"
# 0 1 2 3 4 5 6 7
# А п е л ь с и н
# Срез с 1 по 4 (не включая) индекс
print(s[1:4]) # Вывод: пел
# Срез с начала до 5-го индекса
print(s[:5]) # Вывод: Апель
# Срез с 3-го индекса до конца
print(s[3:]) # Вывод: льсин
# Каждый второй символ
print(s[::2]) # Вывод: Аелсьн
# Перевернуть строку (классический трюк)
print(s[::-1]) # Вывод: нисьлепА
Перебор строки циклом for
Итерация по символам строки
Цикл for позволяет легко пройтись по каждому символу строки по очереди.
for char in "Python":
print(char)
Пример перебора с условием
Можно использовать цикл для анализа строки, например, для подсчета гласных.
vowels = "аеёиоуыэюя"
my_text = "Пример текста для анализа"
vowel_count = 0
for letter in my_text.lower(): # .lower() чтобы учесть и 'А', и 'а'
if letter in vowels:
vowel_count += 1
print(f"Количество гласных: {vowel_count}") # Вывод: Количество гласных: 7
Перебор строки циклом for
Итерация по символам строки
Цикл for — это основной способ последовательно обработать каждый символ в строке. Python автоматически "проходит" по строке от начала до конца, на каждом шаге помещая очередной символ в переменную цикла.
for char in "Python":
print(f"Текущий символ: {char}")
Перебор строки с условием
Внутри цикла можно использовать условные операторы (if, elif, else) для анализа каждого символа и выполнения действий в зависимости от этого условия.
# Пример: посчитаем только цифры в строке
address = "ул. Ленина, дом 25, корпус 3"
digit_count = 0
for symbol in address:
if symbol.isdigit(): # Проверяем, является ли символ цифрой
digit_count += 1
print(f"В адресе найдено цифр: {digit_count}") # Вывод: В адресе найдено цифр: 3
Методы строк в Python
Методы — это встроенные функции, которые можно вызывать у объекта-строки для выполнения различных действий. Синтаксис: строка.метод().
Длина строки в Python: len()
len() — это не метод, а встроенная функция, но она используется со строками постоянно. Возвращает количество символов в строке.
text = "Hello, World!"
print(len(text)) # Вывод: 13
lower() — перевод в нижний регистр
Возвращает копию строки, где все символы переведены в нижний регистр.
text = "ПРИВЕТ, МИР!"
print(text.lower()) # Вывод: привет, мир!
метод upper() — перевод в верхний регистр
Возвращает копию строки, где все символы переведены в верхний регистр.
text = "привет, мир!"
print(text.upper()) # Вывод: ПРИВЕТ, МИР!
метод strip() — удаление пробелов
Удаляет пробельные символы (пробелы, табы, переносы строк) с начала и конца строки. Варианты: lstrip() (слева), rstrip() (справа).
text_with_spaces = " много пробелов по краям "
print(f"'{text_with_spaces.strip()}'") # Вывод: 'много пробелов по краям'
метод replace(old, new) — замена подстроки
Заменяет все вхождения подстроки old на подстроку new.
text = "Я люблю яблоки, яблоки очень вкусные."
print(text.replace("яблоки", "бананы"))
# Вывод: Я люблю бананы, бананы очень вкусные.
метод split(separator) — разделение строки
Разделяет строку на список (list) подстрок по указанному разделителю separator. Если разделитель не указан, разделяет по пробельным символам.
csv_data = "Иванов,Иван,30,Москва"
items = csv_data.split(',')
print(items) # Вывод: ['Иванов', 'Иван', '30', 'Москва']
sentence = "Это простое предложение"
words = sentence.split()
print(words) # Вывод: ['Это', 'простое', 'предложение']
метод join(iterable) — объединение списка строк
Собирает элементы списка (или другого итерируемого объекта) в одну строку, вставляя между ними строку, у которой был вызван метод.
words_list = ['Python', 'это', 'мощно']
separator = ' '
result = separator.join(words_list)
print(result) # Вывод: Python это мощно
# Более частый синтаксис
result_alt = " ".join(words_list)
print(result_alt) # Вывод: Python это мощно
метод find(substring) и rfind(substring) — поиск подстроки
find() ищет первое вхождение substring и возвращает индекс его начала. rfind() ищет с конца. Если подстрока не найдена, оба метода возвращают -1.
text = "alpha beta gamma beta"
print(text.find("beta")) # Вывод: 6 (находит первое вхождение)
print(text.rfind("beta")) # Вывод: 17 (находит последнее вхождение)
print(text.find("delta")) # Вывод: -1 (не найдено)
метод startswith(prefix) — проверка начала строки
Возвращает True, если строка начинается с указанного prefix, иначе False.
filename = "document.pdf"
print(filename.startswith("doc")) # Вывод: True
print(filename.startswith("img")) # Вывод: False
метод endswith(suffix) — проверка окончания строки
Возвращает True, если строка заканчивается на указанный suffix, иначе False.
filename = "image.jpg"
print(filename.endswith(".jpg")) # Вывод: True
print(filename.endswith(".png")) # Вывод: False
Строковые методы проверки
Эти методы возвращают True или False в зависимости от содержимого строки.
метод isalpha() — состоит ли строка только из букв
print("Python".isalpha()) # Вывод: True
print("Python3".isalpha())# Вывод: False
метод isdigit() — состоит ли строка только из цифр
print("12345".isdigit()) # Вывод: True
print("123a".isdigit()) # Вывод: False
метод isalnum() — состоит ли строка из букв и цифр
print("Python3".isalnum()) # Вывод: True
print("Python 3".isalnum())# Вывод: False (пробел не буква и не цифра)
метод islower() — все ли символы в нижнем регистре
print("hello".islower()) # Вывод: True
print("Hello".islower()) # Вывод: False
метод isupper() — все ли символы в верхнем регистре
print("HELLO".isupper()) # Вывод: True
print("HellO".isupper()) # Вывод: False
метод isspace() — состоит ли строка из пробельных символов
print(" \t\n".isspace()) # Вывод: True
print(" a ".isspace()) # Вывод: False
Пример использования continue
Оператор continue прерывает текущую итерацию цикла и немедленно переходит к следующей. Он полезен, когда нужно пропустить обработку некоторых элементов.
# Выведем все символы, кроме гласных
word = "самоучитель"
vowels = "аоуиеы"
a = ""
for letter in word:
if letter in vowels:
continue # Если буква гласная, пропускаем оставшуюся часть цикла и идем к следующей букве
a+=letter
print(a)
Блок else в цикле for
В Python циклы for и while могут иметь блок else. Это уникальная особенность, которая часто сбивает с толку новичков, но на самом деле очень полезна.
Когда выполняется блок else
Блок else после цикла for выполняется только в одном случае: если цикл завершился естественным образом, то есть прошел все свои итерации и не был прерван оператором break.
Пример цикла с else без прерываний break
Если цикл просто заканчивается, else сработает.
for i in range(3):
print(f"Итерация {i}")
else:
print("Цикл завершился полностью без прерываний.")
Поведение else при использовании break — не выполняется
Если цикл прерывается оператором break, блок else не выполняется. Это позволяет легко определить, был ли цикл завершен досрочно (например, потому что что-то было найдено) или он прошел до конца.
# Поиск символа в строке
my_string = "hello world"
char_to_find = 'x'
for char in my_string:
if char == char_to_find:
print(f"Символ '{char_to_find}' найден!")
break # Прерываем цикл, так как нашли то, что искали
else:
# Этот блок выполнится, только если цикл for прошел до конца и не нашел символ
print(f"Символ '{char_to_find}' в строке не найден.")
Теперь изменим char_to_find на 'w':
# Поиск символа в строке
my_string = "hello world"
char_to_find = 'w'
for char in my_string:
if char == char_to_find:
print(f"Символ '{char_to_find}' найден!")
break # Прерываем цикл, так как нашли то, что искали
else:
# Этот блок выполнится, только если цикл for прошел до конца и не нашел символ
print(f"Символ '{char_to_find}' в строке не найден.")
Обратите внимание, что сообщение из блока else не было выведено, так как цикл был прерван.
Форматирование строк в Python
Форматирование — это создание строк по шаблону с подстановкой в него данных.
Оператор % (старый стиль)
Считается устаревшим, но до сих пор встречается в старом коде.
# %s для строки, %d для целого числа, %f для числа с плавающей точкой
name = "Алиса"
age = 25
text = "Имя: %s, Возраст: %d" % (name, age)
print(text) # Вывод: Имя: Алиса, Возраст: 25
Метод format()
Более гибкий и современный способ, чем %.
# Позиционные параметры
text1 = "Имя: {}, Возраст: {}".format("Боб", 30)
print(text1) # Вывод: Имя: Боб, Возраст: 30
# Именованные параметры
text2 = "Имя: {name}, Возраст: {age}".format(name="Карл", age=42)
print(text2) # Вывод: Имя: Карл, Возраст: 42
F-строки: форматирование строк в Python
F-строки (форматированные строковые литералы) — самый современный, удобный и быстрый способ форматирования. Строка начинается с буквы f перед кавычками.
Вставка переменных и выражений
Можно вставлять переменные и даже вычислять выражения прямо внутри {}.
name = "Диана"
age = 28
# Примеры использования f-строк
print(f"Привет, меня зовут {name} и мне {age} лет.")
print(f"Через 5 лет мне будет {age + 5} лет.")
print(f"Мое имя в верхнем регистре: {name.upper()}.")
Форматирование чисел: преобразование строк
F-строки и метод format() предоставляют мощные средства для форматирования чисел.
Округление до определенного количества знаков
:.2f означает "число с плавающей точкой, 2 знака после запятой".
pi = 3.14159265
print(f"Число Пи с точностью до 2 знаков: {pi:.2f}") # Вывод: 3.14
Выравнивание и ширина поля
Можно задать общую ширину поля и выравнивание.
value = 123
# :>10 - выровнять по правому краю в поле шириной 10 символов
# :<10 - по левому
# :^10 - по центру
print(f"|{value:>10}|") # Вывод: | 123|
print(f"|{value:<10}|") # Вывод: |123 |
print(f"|{value:^10}|") # Вывод: | 123 |
F-строки: форматирование строк в Python
F-строки (форматированные строковые литералы) — это самый современный, читаемый и производительный способ форматирования строк в Python (начиная с версии 3.6). Чтобы создать f-строку, просто поставьте букву f перед открывающей кавычкой.
Вставка переменных и выражений
Главное преимущество f-строк — возможность вставлять переменные и даже целые выражения прямо в строку, заключая их в фигурные скобки {}.
name = "Елена"
age = 30
profession = "разработчик"
# Просто вставляем переменные
print(f"Привет, меня зовут {name}.")
# Вставляем выражения и результаты вызова методов
print(f"Мне {age} лет, и мое имя в верхнем регистре: {name.upper()}.")
print(f"Через 10 лет мне будет {age + 10} лет.")
print(f"Я работаю как {profession.replace('разработчик', 'инженер')}.")
Форматирование чисел и строк внутри f-строк
F-строки позволяют не просто вставлять значения, но и управлять их отображением с помощью специального синтаксиса внутри фигурных скобок, который следует за двоеточием {значение:формат}.
Примеры использования
Форматирование чисел
Вы можете легко контролировать представление чисел, что особенно важно для данных с плавающей точкой.
Округление до определенного количества знаков
Для округления используется синтаксис :.Nf, где N — количество знаков после запятой.
pi_value = 3.1415926535
price = 50
print(f"Число Пи с точностью до 3 знаков: {pi_value:.3f}") # Вывод: 3.142 (происходит математическое округление)
print(f"Цена товара: ${price:.2f}") # Вывод: $50.00 (добавляются нули)
Выравнивание и ширина поля
Можно задать минимальную ширину поля для вывода значения и способ его выравнивания. Это полезно для создания аккуратных таблиц или отчетов.
<— выравнивание по левому краю>— выравнивание по правому краю^— выравнивание по центру
item = "Яблоки"
quantity = 5
cost = 250.5
# Задаем поле шириной 15 символов с выравниванием по левому краю
print(f"|{item:<15}|")
# Задаем поле шириной 5 символов с выравниванием по центру
print(f"|{quantity:^5}|")
# Задаем поле шириной 10 символов с выравниванием по правому краю и 2 знаками после запятой
print(f"|{cost:>10.2f}|")
# Все вместе в одной строке:
print(f"| {item:<15} | {quantity:^5} | {cost:>10.2f} |")
Также можно указать символ для заполнения пустого пространства, поставив его перед символом выравнивания.
code = "A45"
print(f"Код товара: {code:->10}") # Вывод: Код товара: -------A45
print(f"Код товара: {code:*^10}") # Вывод: Код товара: ***A45****
Дополнительные темы
Многострочные строки с тройными кавычками — практические применения
Они идеально подходят для хранения шаблонов, например, HTML-кода, SQL-запросов или писем.
user_id = 105
sql_query = f"""
SELECT
user_name,
email
FROM
users
WHERE
id = {user_id};
"""
print(sql_query)
Особенности использования кавычек внутри строк
Резюме способов вставить кавычку в строку:
- Использовать другой тип кавычек для обрамления:
"Это 'цитата'" - Экранировать кавычку:
'Это \'цитата\'' - Использовать тройные кавычки:
'''Это "цитата" и еще одна 'цитата'.'''
Практические советы и рекомендации
- Предпочитайте f-строки: Для форматирования строк всегда используйте f-строки, если версия вашего Python это позволяет (3.6+). Это самый читаемый и эффективный способ.
- Помните о неизменяемости: Если вам нужно много раз изменять строку в цикле (например, дописывать по одному символу), эффективнее будет собирать символы в список, а в конце объединить их методом
.join(). - Комбинируйте методы: Методы можно вызывать цепочкой. Это лаконично и эффективно.
# Пример цепочки методов
raw_input = " ИМЯ ПОЛЬЗОВАТЕЛЯ \n"
# 1. Удаляем пробелы по краям -> "ИМЯ ПОЛЬЗОВАТЕЛЯ"
# 2. Переводим в нижний регистр -> "имя пользователя"
# 3. Заменяем пробел на подчеркивание -> "имя_пользователя"
clean_username = raw_input.strip().lower().replace(" ", "_")
print(clean_username) # Вывод: имя_пользователя
Таблица методов для работы со строками в Python
| Метод | Описание | Пример использования |
|---|---|---|
| Изменение регистра | ||
s.capitalize() |
Делает первую букву строки заглавной, а все остальные — строчными. | s = 'hello world'print(s.capitalize()) → Hello world |
s.lower() |
Преобразует все символы строки в нижний регистр. | s = 'PYTHON'print(s.lower()) → python |
s.upper() |
Преобразует все символы строки в верхний регистр. | s = 'python'print(s.upper()) → PYTHON |
s.title() |
Делает первую букву каждого слова в строке заглавной. | s = 'hello world'print(s.title()) → Hello World |
s.swapcase() |
Меняет регистр всех букв в строке на противоположный. | s = 'PyThOn'print(s.swapcase()) → pYtHoN |
s.casefold() |
Более агрессивное преобразование в нижний регистр для сравнения. | s = 'Straße'print(s.casefold()) → strasse |
| Поиск и замена | ||
s.count(sub) |
Считает количество непересекающихся вхождений подстроки sub. |
s = 'hello world'print(s.count('l')) → 3 |
s.find(sub) |
Возвращает индекс первого вхождения подстроки sub. Если не найдено, возвращает -1. |
s = 'python'print(s.find('th')) → 2 |
s.rfind(sub) |
Возвращает индекс последнего вхождения подстроки sub. |
s = 'hello, world'print(s.rfind('o')) → 8 |
s.index(sub) |
Как find(), но вызывает ошибку ValueError, если подстрока не найдена. |
s = 'python'print(s.index('on')) → 4 |
s.rindex(sub) |
Как rfind(), но вызывает ошибку ValueError, если подстрока не найдена. |
s = 'hello, world'print(s.rindex('o')) → 8 |
s.replace(old, new) |
Заменяет все вхождения подстроки old на new. |
s = 'I like cats'print(s.replace('cats', 'dogs')) → I like dogs |
| Проверки | ||
s.startswith(prefix) |
Проверяет, начинается ли строка с указанного префикса prefix. |
s = 'file.txt'print(s.startswith('file')) → True |
s.endswith(suffix) |
Проверяет, заканчивается ли строка указанным суффиксом suffix. |
s = 'image.jpg'print(s.endswith('.jpg')) → True |
s.isalnum() |
True, если все символы строки — буквы или цифры, и строка не пуста. |
s = 'Python3'print(s.isalnum()) → True |
s.isalpha() |
True, если все символы строки — буквы, и строка не пуста. |
s = 'Python'print(s.isalpha()) → True |
s.isdigit() |
True, если все символы строки — цифры, и строка не пуста. |
s = '12345'print(s.isdigit()) → True |
s.islower() |
True, если все буквы в строке в нижнем регистре. |
s = 'python'print(s.islower()) → True |
s.isupper() |
True, если все буквы в строке в верхнем регистре. |
s = 'PYTHON'print(s.isupper()) → True |
s.isspace() |
True, если строка состоит только из пробельных символов. |
s = ' \t\n'print(s.isspace()) → True |
s.istitle() |
True, если строка является "заголовком" (см. title()). |
s = 'Hello World'print(s.istitle()) → True |
| Разделение и объединение | ||
s.split(sep=None) |
Разделяет строку по разделителю sep и возвращает список строк. По умолчанию sep — любой пробельный символ. |
s = 'one,two,three'print(s.split(',')) → ['one', 'two', 'three'] |
s.rsplit(sep=None) |
Разделяет строку, начиная справа. | s = 'a-b-c-d'print(s.rsplit('-', 2)) → ['a-b', 'c', 'd'] |
s.splitlines() |
Разделяет строку по символам переноса строки. | s = 'line1\nline2'print(s.splitlines()) → ['line1', 'line2'] |
sep.join(iterable) |
Объединяет элементы списка iterable в одну строку, используя sep в качестве разделителя. |
words = ['Python', 'is', 'fun']print(' '.join(words)) → Python is fun |
s.partition(sep) |
Разделяет строку по первому вхождению sep на кортеж из трех частей: до sep, сам sep и после sep. |
s = 'user@domain.com'print(s.partition('@')) → ('user', '@', 'domain.com') |
| Удаление символов | ||
s.strip(chars) |
Удаляет указанные символы chars (по умолчанию пробельные) с начала и конца строки. |
s = ' _hello_ 'print(s.strip()) → _hello_print(s.strip(' _')) → hello |
s.lstrip(chars) |
Удаляет указанные символы chars с начала строки. |
s = '___spam___'print(s.lstrip('_')) → spam___ |
s.rstrip(chars) |
Удаляет указанные символы chars с конца строки. |
s = '___spam___'print(s.rstrip('_')) → ___spam |
| Форматирование и выравнивание | ||
s.center(width, fill) |
Центрирует строку, добавляя по бокам символ fill до достижения ширины width. |
s = 'OK'print(s.center(10, '*')) → ****OK**** |
s.ljust(width, fill) |
Выравнивает строку по левому краю. | s = 'text'print(s.ljust(10, '.')) → text...... |
s.rjust(width, fill) |
Выравнивает строку по правому краю. | s = 'text'print(s.rjust(10, '.')) → ......text |
s.zfill(width) |
Дополняет строку нулями слева до длины width. |
s = '42'print(s.zfill(5)) → 00042 |
s.format(*args) |
Форматирует строку, подставляя значения в поля, отмеченные {}. |
s = 'Привет, {}!'print(s.format('мир')) → Привет, мир! |