Содержание

Python 3 #8: методы строк

Смотреть материал на видео

Как мы уже неоднократно говорили, в Python строки являются объектами и у этих объектов есть методы, то есть, функции, выполняющие определенные действия:

строка.имя_метода(аргументы)

Для примера, предположим, у нас имеется такая, уже классическая строка: 

string = "Hello World!"

и мы собираемся для нее вызвать метод

String.upper()

который возвращает строку со всеми заглавными буквами. Для этого, пишется сама строка, ставится точка и записывается имя метода. В конце обязательно ставим круглые скобки: 

string.upper()

Вот по такому синтаксису вызываются различные методы строк. Причем, сама переменная string продолжает ссылается на ту же самую неизмененную строку «Hello World!». Как мы с вами говорили на предыдущем занятии, строки – это неизменяемые объекты, поэтому метод upper возвращает новую строку с заглавными буквами, не меняя прежней.

Если бы нам потребовалось изменить строку, на которую ссылается переменная string, то это можно сделать так: 

string = string.upper()

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

Также этот метод мы можем вызвать непосредственно у строкового литерала: 

"hello".upper()

Так тоже можно делать.

Ну и раз уж мы затронули метод upper, который переводит буквы в верхний регистр, то отметим противоположный ему метод:

String.lower()

который, наоборот, преобразует все буквы в строчные. Например: 

string.lower()

возвращает строку «hello world!». Соответственно, сама строка здесь остается прежней, измененным является новый строковый объект, который и возвращает метод lower. По такому принципу работают все методы при изменении строк. Следующий метод

String.count(sub[, start[, end]])

возвращает число повторений подстроки sub в строке String. Два необязательных аргумента:

  • start – индекс, с которого начинается поиск;
  • end – индекс, которым заканчивается поиск.

В самом простом случае, мы можем для строки 

msg = "abrakadabra"

определить число повторений сочетаний «ra»: 

msg.count("ra")

получим значение 2 – именно столько данная подстрока встречается в нашей строке.

Теперь предположим, что мы хотим начинать поиск с буквы k, имеющей индекс 4.

Тогда метод следует записать со значением start=4: 

msg.count("ra", 4)

и мы получим значение 1. Далее, укажем третий аргумент – индекс, до которого будет осуществляться поиск. Предположим, что мы хотим дойти до 10-го индекса и записываем: 

msg.count("ra", 4, 10)

и получаем значение 0. Почему? Ведь на индексах 9 и 10 как раз идет подстрока «ra»? Но здесь, также как и в срезах, последний индекс исключается из рассмотрения. То есть, мы говорим, что нужно дойти до 10-го, не включая его. А вот если запишем 11: 

msg.count("ra", 4, 11)

то последнее включение найдется.

Следующий метод

String.find(sub[, start[, end]])

возвращает индекс первого найденного вхождения подстроки sub в строке String. А аргументы start и end работают также как и в методе count. Например: 

msg.find("br")

вернет 1, т.к. первое вхождение «br» как раз начинается с индекса 1. Поставим теперь значение start=2: 

msg.find("br", 2)

и поиск начнется уже со второго индекса.

Получим значение 8 – индекс следующего вхождения подстроки «br». Если мы укажем подстроку, которой нет в нашей строке: 

msg.find("brr")

то метод find возвращает -1. Третий аргумент end определяет индекс до которого осуществляется поиск и работает также как и в методе count.

Метод find ищет первое вхождение слева-направо. Если требуется делать поиск в обратном направлении: справа-налево, то для этого используется метод

String.rfind(sub[, start[, end]])

который во всем остальном работает аналогично find. Например: 

msg.rfind("br")

возвратит 8 – первое вхождение справа.

Наконец, третий метод, аналогичный find – это:

String.index(sub[, start[, end]])

Он работает абсолютно также как find, но с одним отличием: если указанная подстрока sub не находится в строке String, то метод приводит к ошибке: 

msg. index("brr")

тогда как find возвращает -1. Спрашивается: зачем нужен такой ущербный метод index? В действительности такие ошибки можно обрабатывать как исключения и это бывает полезно для сохранения архитектуры программы: когда неожиданные ситуации обрабатываются единым образом в блоке исключений. Но, обо всем этом речь пойдет позже.

Следующий метод

String.replace(old, new, count=-1)

Выполняет замену подстрок old на строку new и возвращает измененную строку. Например, в нашей строке, мы можем заменить все буквы a на o: 

msg.replace("a", 'o')

на выходе получим строку «obrokodobro». Или, так: 

msg.replace("ab", "AB")

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

msg.replace("ab", "")

Третий необязательный аргумент задает максимальное количество замен. Например: 

msg.replace("a", 'o', 2)

Заменит только первые две буквы a: «msg.replace(«a», ‘o’, 2)». При значении -1 количество замен неограниченно.

Следующие методы позволяют определить: из каких символов состоит наша строка. Например, метод

String.isalpha()

возвращает True, если строка целиком состоит из букв и False в противном случае. Посмотрим как он работает: 

msg.isalpha()

вернет True, т.к. наша строка содержит только буквенные символы. А вот для такой строки: 

"hello world".isalpha()

мы получим False, т.к. имеется символ пробела.

Похожий метод

String.isdigit()

возвращает True, если строка целиком состоит из цифр и False в противном случае. Например: 

"5.6".isdigit()

т.к. имеется символ точки, а вот так: 

"56". isdigit()

получим значение True. Такая проверка полезна, например, перед преобразованием строки в целое число: 

dig = input("Введите число: ")
if(dig.isdigit()):
   dig = int(dig)
    print(dig)
else:
   print("Число введено неверно")

Следующий метод

String.rjust(width[, fillchar = ‘ ‘])

возвращает новую строку с заданным числом символов width и при необходимости слева добавляет символы fillchar: 

d="abc"
d.rjust(5)

Получаем строку «  abc» с двумя добавленными слева пробелами. А сама исходная строка как бы прижимается к правому краю. Или, можно сделать так: 

d.rjust(5, "-")

Получим строку «—abc». Причем вторым аргументом можно писать только один символ. Если записать несколько, то возникнет ошибка: 

d.rjust(5, "-*")

Если ширина width будет меньше длины строки: 

d. rjust(2)

то ничего не изменится. Аналогично работает метод

String.ljust(width[, fillchar = ‘ ‘])

который возвращает новую строку с заданным числом символов width, но добавляет символы fillchar уже справа: 

d.ljust(10, "*")

Следующий метод

String.split(sep=None, maxsplit=-1)

возвращает коллекцию строк, на которые разбивается исходная строка String. Разбивка осуществляется по указанному сепаратору sep. Например: 

"Иванов Иван Иванович".split(" ")

Мы здесь разбиваем строку по пробелам. Получаем коллекцию из ФИО. Тот же результат будет и при вызове метода без аргументов, то есть, по умолчанию он разбивает строку по пробелам: 

"Иванов Иван Иванович".split()

А теперь предположим, перед нами такая задача: получить список цифр, которые записаны через запятую. Причем, после запятой может быть пробел, а может и не быть. Программу можно реализовать так: 

digs = "1, 2,3, 4,5,6"
digs.replace(" ", "").split(",")

мы сначала убираем все пробелы и для полученной строки вызываем split, получаем список цифр.

Обратный метод

String.join(список)

возвращает строку из объединенных элементов списка, между которыми будет разделитель String. Например: 

d = digs.replace(" ", "").split(",")
", ".join(d)

получаем строку «1, 2, 3, 4, 5, 6». Или так, изначально была строка: 

fio = "Иванов Иван Иванович"

и мы хотим здесь вместо пробелов поставить запятые: 

fio2 = ",".join(fio.split())

Теперь fio2 ссылается на строку с запятыми «Иванов,Иван,Иванович».

Следующий метод

String.strip()

удаляет пробелы и переносы строк в начале и конце строки. Например: 

"   hello world         \n".strip()

возвращает строку «hello world». Аналогичные методы:

String.rtrip() и String.ltrip()

удаляют пробелы и переносы строк только справа и только слева.

Вот такие методы строк существуют в Python. Для наглядности ниже они представлены в таблице:

Название

Описание

String.upper()

Возвращает строку с заглавными буквами

String.lower()

Возвращает строку с малыми буквами

String.count(sub[, start[, end]])

Определяет число вхождений подстроки в строке

String. find(sub[, start[, end]])

Возвращает индекс первого найденного вхождения

String.rfind(sub[, start[, end]])

Возвращает индекс первого найденного вхождения при поиске справа

String.index(sub[, start[, end]])

Возвращает индекс первого найденного вхождения

String.replace(old, new, count=-1)

Заменяет подстроку old на new

String.isalpha()

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

String. isdigit()

Определяет: состоит ли строка целиком из цифр

String.rjust(width[, fillchar = ‘ ‘])

Расширяет строку, добавляя символы слева

String.ljust(width[, fillchar = ‘ ‘])

Расширяет строку, добавляя символы справа

String.split(sep=None, maxsplit=-1)

Разбивает строку на подстроки

String.join(список)

Объединяет коллекцию в строку

String.strip()

Удаляет пробелы и переносы строк справа и слева

String. rstrip()

Удаляет пробелы и переносы строк справа

String.ltrip()

Удаляет пробелы и переносы строк слева

1. Написать программу корректности ввода телефонного номера по шаблону:

x(xxx)xxxxxx

где x – любая цифра от 0 до 9. Данные представлены в виде строки.

2. Написать программу изменения строки

«2+3+6.7 + 82 + 5.7 +1″

на строку, в которой все «+» заменены на «-» и удалены все пробелы

3. Написать программу вывода чисел 0; -100; 5.6; -3 в виде столбца: 


	0
	-100
	5.6
	-3

в котором все строки выровнены по правому краю (подсказка: воспользуйтесь методом rjust).

4. В строке «abrakadabra» найдите все индексы подстроки «ra» и выведите их (индексы) в консоль.

Видео по теме

#1. Первое знакомство с Python Установка на компьютер

#2. Варианты исполнения команд. Переходим в PyCharm

#3. Переменные, оператор присваивания, функции type и id

#4. Числовые типы, арифметические операции

#5. Математические функции и работа с модулем math

#6. Функции print() и input(). Преобразование строк в числа int() и float()

#7. Логический тип bool. Операторы сравнения и операторы and, or, not

#8. Введение в строки. Базовые операции над строками

#9. Знакомство с индексами и срезами строк

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

#11. Спецсимволы, экранирование символов, row-строки

#12. Форматирование строк: метод format и F-строки

#13. Списки — операторы и функции работы с ними

#14. Срезы списков и сравнение списков

#15. Основные методы списков

#16. Вложенные списки, многомерные списки

#17. Условный оператор if. Конструкция if-else

#18. Вложенные условия и множественный выбор. Конструкция if-elif-else

#19. Тернарный условный оператор. Вложенное тернарное условие

#20. Оператор цикла while

#21. Операторы циклов break, continue и else

#22. Оператор цикла for. Функция range()

#23. Примеры работы оператора цикла for. Функция enumerate()

#24. Итератор и итерируемые объекты. Функции iter() и next()

#25. Вложенные циклы. Примеры задач с вложенными циклами

#26. Треугольник Паскаля как пример работы вложенных циклов

#27. Генераторы списков (List comprehensions)

#28. Вложенные генераторы списков

#29. Введение в словари (dict). Базовые операции над словарями

#30. Методы словаря, перебор элементов словаря в цикле

#31. Кортежи (tuple) и их методы

#32. Множества (set) и их методы

#33. Операции над множествами, сравнение множеств

#34. Генераторы множеств и генераторы словарей

#35. Функции: первое знакомство, определение def и их вызов

#36. Оператор return в функциях. Функциональное программирование

#37. Алгоритм Евклида для нахождения НОД

#38. Именованные аргументы. Фактические и формальные параметры

#39. Функции с произвольным числом параметров *args и **kwargs

#40. Операторы * и ** для упаковки и распаковки коллекций

#41. Рекурсивные функции

#42. Анонимные (lambda) функции

#43. Области видимости переменных. Ключевые слова global и nonlocal

#44. Замыкания в Python

#45. Введение в декораторы функций

#46. Декораторы с параметрами. Сохранение свойств декорируемых функций

#47. Импорт стандартных модулей. Команды import и from

#48. Импорт собственных модулей

#49. Установка сторонних модулей (pip install). Пакетная установка

#50. Пакеты (package) в Python. Вложенные пакеты

#51. Функция open. Чтение данных из файла

#52. Исключение FileNotFoundError и менеджер контекста (with) для файлов

#53. Запись данных в файл в текстовом и бинарном режимах

#54. Выражения генераторы

#55. Функция-генератор. Оператор yield

#56. Функция map. Примеры ее использования

#57. Функция filter для отбора значений итерируемых объектов

#58. Функция zip. Примеры использования

#59. Сортировка с помощью метода sort и функции sorted

#60. Аргумент key для сортировки коллекций по ключу

#61. Функции isinstance и type для проверки типов данных

#62. Функции all и any. Примеры их использования

#63. Расширенное представление чисел. Системы счисления

#64. Битовые операции И, ИЛИ, НЕ, XOR. Сдвиговые операторы

#65. Модуль random стандартной библиотеки

#66. Аннотация базовыми типами

#67. Аннотации типов коллекций

#68. Аннотации типов на уровне классов

#69. Конструкция match/case. Первое знакомство

#70. Конструкция match/case с кортежами и списками

#71. Конструкция match/case со словарями и множествами

#72. Конструкция match/case. Примеры и особенности использования

Строки в Python и методы работы с ними – База знаний Timeweb Community

В одной из прошлых статей я разбирал строки в JavaScript. Теперь пришло время поговорить о строках в языке программирования Python. 

Начнем с теории. Строка – это последовательность символов произвольной длины. Также строки являются объектами класса str, и если мы захотим получить не строку, а число, то можем использовать функцию приведения.

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

Самый простой способ склеить строки в Python – это сложить их с помощью знака «+». Рассмотрим на примере:


str = "a"+"b"
print(str) # Выведет "ab"

Но такой способ не всегда будет нам подходить. Рассмотрим метод join():


str = ["a", "b", "c"]
print("".join(str)) # Выведет "abc"

Перед .join() мы указываем разделитель строк, а в скобках сам их массив.

Для того чтобы разделить строки, используем обратный метод – split(). Тут в скобках указываем набор символов, по которым будет идти разделение, а перед методом не забываем указать имя строки, а после нее поставить точку. Рассмотрим на примере:


str = "a,b,c"
print(str.split(",")) # Выведет ['a', 'b', 'c']

Существует и другой способ разделения строк, он называется срез. Срез str[x:y] позволит нам получить строку от символа x до y. При этом необязательно указывать оба параметра, ведь в таком случае срез произойдет от начала или до самого конца строки.  

Определенный промежуток:


str = "Строки в Python и методы работы с ними"
print(str[9:15]) # Выведет "Python"

С начала строки:


str = "Строки в Python и методы работы с ними"
print(str[:15]) # Выведет "Строки в Python"

До самого конца:


str = "Строки в Python и методы работы с ними"
print(str[18:]) # Выведет "методы работы с ними"

Также можно срезать каждый энный символ при помощи двойного двоеточия:


str = "123456789"
print(str[::2]) # Выведет "13579"

Комьюнити теперь в Телеграм

Подпишитесь и будьте в курсе последних IT-новостей

Подписаться

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

Для подстановки в строку любой переменной, которая может являться результатом работы основной части кода, нам понадобятся f-строки. Они появились в Python 3.6, поэтому я рекомендую использовать только свежие версии этого языка программирования. Рассмотрим на примере работу с f-строками:


num = 2*10
num2 = 100
str = f"Первое число: {num}. Второе число: {num2}"
print(str) # Выведет "Первое число: 20. Второе число: 100"

Поиск в строках

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

Первый метод – startswith(). Он позволяет искать набор символов в начале строки. Рассмотрим на примере:


str =  "Строки в Python и методы работы с ними"
print(str.startswith("Строки")) #Выведет True

Второй метод – endswith(). Он позволяет искать набор символов в конце строки. Рассмотрим на примере:


str =  "...я разбирал строки в JavaScript"
print(str.endswith("JavaScript")) #Выведет True

А если нам нужно найти набор символов в произвольном месте строки, то используем метод find(). Рассмотрим на примере:


str = "Строки в Python и методы работы с ними"
print(str. find("Python")) #Выведет 9

В данном случае скрипт нашел набор символов в строке и вывел индекс начала его вхождения в ней.


str = "Строки в Python и методы работы с ними"
print(str.find("JavaScript")) #Выведет -1

А в этом случае скрипт не нашел набор символов в строке и вывел «-1».

Замена в строках

Для замены одного набора символов на другой в строке используют метод replace(). Рассмотрим данный метод на примере:


str = "Строки в Python и методы работы с ними"
print(str.replace("Python", "JavaScript")) #Выведет "JavaScript"

Вывод каждого символа в строке

Если нам нужно получить и обработать каждый символ в строке отдельно, то мы можем использовать цикл for. Рассмотрим на примере:


str = "123"
for i in str:
print(i) #Выведет "1" "2" "3"

Узнаем длину строки

Для того чтобы получить длину строки, используем метод len():


str = "123"
print(len(str)) # Выведет 3

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

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


str = "123"
print(int(str)) # Выведет 123

Изменение регистра строк в Python

Для того чтобы все буквы в строке были заглавными, используем метод upper():


str = "Строки в Python и методы работы с ними"
print(str.upper()) # Выведет "СТРОКИ В PYTHON И МЕТОДЫ РАБОТЫ С НИМИ"

И метод lower() для строчных букв:


str = "СТРОКИ В PYTHON И МЕТОДЫ РАБОТЫ С НИМИ"
print(str.upper()) # Выведет "строки в python и методы работы с ними"

Чтобы первая буква в строке стала заглавной, следует использовать метод capitalize():


str = "строки в python и методы работы с ними"
print(str.capitalize()) # Выведет "Строки в python и методы работы с ними"

Удаление лишних пробелов из строк

Метод strip() удаляет пробельные символы в начале и в конце строки. lstrip() и rstrip() делают то же самое, но в определенных местах: первый метод в начале строки, а второй – в ее конце.

Итог

Мы разобрали основные методы работы со строками в Python. Предлагайте идеи для статей и удачи в ваших начинаниях!

строковых методов Python | Программаиз

КОДИРОВАНИЕ
PRO
СКИДКА 36%

Попробуйте практический Python с Programiz PRO

Получите скидку сейчас

Python String capitalize()

Преобразует первый символ в заглавную букву

Python String casefold()

преобразует в строки, сложенные регистром

Python String center()

Дополняет строку указанным символом

возвращает вхождения подстроки в строке

Python String encode()

возвращает закодированную строку заданной строки

Python String endwith()

Проверяет, заканчивается ли строка указанным суффиксом find()

Возвращает индекс первого вхождения подстроки

Python String format()

форматирует строку в более удобный вывод

Python String format_map()

Форматирует строку с помощью словаря

Python String index()

Возвращает индекс подстроки

Python String isalnum()

Проверяет буквенно-цифровой символ isdecimal()

Проверяет десятичные символы

Python String isdigit()

Проверяет цифровые символы

Python String isidentifier()

Проверяет допустимый идентификатор

Python String islower()

Проверяет, все ли буквы в строке строчные

Python String isnumeric()

Проверяет числовые символы

Python String isprintable()

Проверяет Python String Printable Character 9 00 is1() 1space

Проверяет пробельные символы

Python String istitle()

Проверяет строку с заголовком

Python String isupper()

возвращает, если все символы в верхнем регистре

Python String join()

Возвращает составную строку

Python String ljust()

возвращает выровненную по левому краю строку заданной ширины

Python String lower()

возвращает строку в нижнем регистре

Удаляет ведущие символы

Python String maketrans()

возвращает таблицу перевода

Python String partition()

Возвращает кортеж

Python String replace()

Заменяет подстроку внутри

Python String rfind()

Возвращает наивысший индекс подстроки

Python String rindex()

Возвращает наивысший индекс подстроки width

Python String rpartition()

Возвращает кортеж

Python String rsplit()

Разбивает строку справа

Python String rstrip()

Удаляет конечные символы

Python String split()

Разделяет строку слева

Python String splitlines()

Разделяет строку на границах строк )

Удаляет как начальные, так и конечные символы

Python String swapcase()

заменяет прописные символы на строчные; наоборот

Python String title()

Возвращает строку заголовка с регистром

Python String translate()

возвращает отображаемую символьную строку

Python String upper()

возвращает строку в верхнем регистре

Python String zfill()

Возвращает копию строки, дополненной нулями PythonForBeginners. com

Строки Python — один из самых эффективных инструментов для обработки текстовых данных. В этой статье мы обсудим основы работы со строками и строками в Python.

Содержание

  1. Что такое строка в Python?
  2. Работа со строками в Python
    1. Создание строки
    2. Доступ к символам в строке
    3. Определение длины строки
    4. Поиск символа в строке
    5. Подсчет количества пробелов в строке

      193 0 Разделение строки

    6. Строки в Python
    7. Проверить, начинается ли строка символом или заканчивается символом
    8. Повтор строк несколько раз
    9. Заменить подстроение в строке в Python
    10. Изменение строк верхнего и нижнего чехла
    11. Обратная струна в Python
    12. СТРЕСА A Строка в Python
    13. Concatenate Strings in Python
    14. . Строка в Python?

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

      Строки могут содержать пробелы:

       "hello world".

      Пустая строка — это строка, состоящая из 0 символов.

      Строки Python являются неизменяемыми

      Python распознает как строки все, что заключено в кавычки
      (» » или » «).

      Работа со строками в Python

      Для управления строками мы можем использовать некоторые встроенные методы Python.

      Создать строку

      Чтобы создать строку с заданными символами, вы можете присвоить символы переменной, заключив их в двойные или одинарные кавычки, как показано ниже.

       слово = "Привет, мир"
>>> печатать слово
Hello World

      Доступ к символам в строке

      Чтобы получить доступ к символам строки, мы можем использовать оператор индексации Python [ ], то есть квадратные скобки для доступа к символам в строке, как показано ниже.

       слово = "Привет, мир"
буква = слово [0]
>>> распечатать письмо
H

      Найти длину строки

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

       слово = "Привет, мир"
>>> лен(слово)
11

      Поиск символа в строке

      Чтобы найти индекс символа в строке, мы можем использовать метод find(). Метод find() при вызове строки принимает символ в качестве входного аргумента и возвращает индекс первого вхождения символа, как показано ниже.

      >>> слово = "Привет, мир"
>>> print word.find("H") # найти слово H в строке
0

      Вы также можете выполнять манипуляции со строками в python, чтобы найти частоту символа в строке. Для этого мы можем использовать метод count(). Метод count() при вызове строки принимает символ в качестве входного аргумента и возвращает частоту появления символа, как показано ниже.

       >>> слово = "Привет, мир"
>>> print word.count('l') # подсчитать, сколько раз l встречается в строке
3

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

       >>> слово = "Привет, мир"
>>> print word.index("World") # найти в строке буквы World
6

      Подсчет количества пробелов в строке

      Чтобы подсчитать количество пробелов в строке, вы можете передать символ пробела в метод count(), как показано ниже.

       s = "Количество пробелов"
>>> напечатать s.count(' ')
8

      Нарезка строк

      Чтобы выполнить манипуляции со строками в Python, вы можете использовать синтаксис имя_строки[ начальный_индекс : конечный_индекс ], чтобы получить подстроку строки. Здесь операция нарезки дает нам подстроку, содержащую символы от start_index до end_index-1 строки string_name.

      Имейте в виду, что python, как и многие другие языки, начинает отсчет с 0!!

       слово = "Привет, мир"
print word[0] #получить один символ слова
print word[0:1] # получить один символ слова (так же, как указано выше)
print word[0:3] # получить первые три символа
print word[:3] # получить первые три символа
print word[-3:] # получить последние три символа
print word[3:] #получить все, кроме трех первых символов
print word[:-3] #получить все, кроме трех последних символов
слово = "Привет, мир"
word[start:end] # элементы от начала до конца-1
word[start:] # элементы начинаются с остальной части списка
word[:end] # элементы от начала до конца-1
word[:] # копия всего списка

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

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

       слово = "Привет, мир"
>>> word.split(' ') # Разбить по пробелам
['Hello', 'World']

      В приведенном выше примере мы разделили строку по символу пробела.

      Проверить, начинается ли строка с или заканчивается символом

      Чтобы проверить, начинается ли строка с определенного символа или заканчивается им, вы можете использовать методы startwith() или endwith() соответственно.

      Метод startupwith() при вызове строки принимает символ в качестве входного аргумента. Если строка начинается с данного символа, она возвращает True. В противном случае возвращается False.

      Метод endwith() при вызове строки принимает символ в качестве входного аргумента. Если строка заканчивается данным символом, она возвращает True. В противном случае возвращается False. Вы можете наблюдать это на следующем примере.

       слово = "привет мир"
>>> слово.начинается с("Н")
Истинный
>>> word.endswith("d")
Истинный
>>> word.endswith("w")
Ложь

      Повторять строки несколько раз

      Вы можете повторять строку несколько раз, используя оператор умножения. Когда мы умножаем любую заданную строку или символ на положительное число N, это повторяется N раз. Вы можете наблюдать это на следующем примере.

       print "."* 10 # печатает десять точек
>>> напечатать "." * 10
..........

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

      Вы также можете заменить подстроку другой подстрокой, используя метод replace(). Метод replace() при вызове для строки принимает заменяемую подстроку в качестве первого входного аргумента, а замещающую строку — в качестве второго входного аргумента. После выполнения он заменяет указанную подстроку строкой замены и возвращает измененную строку. Вы можете выполнять манипуляции со строками в Python, используя метод replace(), как показано ниже.

       слово = "Привет, мир"
>>> word. replace("Здравствуйте", "До свидания")
«До свидания, мир»

      Изменение строк в верхнем и нижнем регистре

      Вы можете преобразовать строку в верхний, нижний и заглавный регистры с помощью методов upper(), lower() и title().

      Метод upper() при вызове строки переводит строку в верхний регистр и возвращает измененную строку.

      Метод lower() при вызове строки переводит строку в нижний регистр и возвращает измененную строку.

      Метод title() при вызове строки изменяет строку на titlsecase и возвращает измененную строку.

      Вы также можете использовать заглавные буквы в строке или поменять местами заглавные буквы в строке, используя методы capitalize() и swapcase().

      Метод capitalize() при вызове строки делает первый символ строки заглавным и возвращает измененную строку.

      Метод swapcase() при вызове строки изменяет строчные символы на прописные и наоборот. После выполнения он возвращает измененную строку.

      Вы можете наблюдать эти варианты использования в следующем примере.

       строка = "Привет, мир"
>>> напечатать string.upper()
ПРИВЕТ, МИР
>>> напечатать string.lower()
Привет, мир
>>> напечатать string.title()
Привет, мир
>>> напечатать string.capitalize()
Привет, мир
>>> напечатать string.swapcase()
HELLO WORLD

      Перевернуть строку в Python

      Чтобы перевернуть строку, вы можете использовать функцию reversed() и метод join().

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

      Метод join() при вызове строки-разделителя принимает список символов в качестве входного аргумента и объединяет символы списка с помощью разделителя. После выполнения он возвращает результирующую строку.

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

       строка = "Привет, мир"
>>> напечатать ''.join (обратный (строка))
dlroW olleH

      Удаление строки в Python

      Строки Python имеют методы strip(), lstrip(), rstrip() для удаления любого символа с обоих концов строки.

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

      Метод lstrip() при вызове строки принимает символ в качестве входного аргумента и удаляет символ из начала (слева) строки.

      Метод rstrip() при вызове строки принимает символ в качестве входного аргумента и удаляет символ с конца (справа) строки.

       word = "Hello World"

      Вы можете удалить символы новой строки из конца строки, передав “\n” в качестве входного аргумента методу rstrip().

       >>> напечатать word. strip('\n')
Привет, мир
strip() # удаляет с обоих концов
lstrip() #удаляет начальные символы (левая полоса)
rstrip() #удаляет конечные символы (правая полоса)
>>> слово = "xyz"
>>> печатать слово
xyz
>>> напечатать word.strip()
xyz
>>> напечатать word.lstrip()
xyz
>>> напечатать word.rstrip()
хиз

      Объединение строк в Python

      Чтобы объединить строки в Python, используйте оператор «+», как показано ниже.

       "Привет" + "Мир" # = "Привет, мир"
"Привет" + "Мир" + "!"# = "Привет, мир!"

      Как обсуждалось выше, метод join() при вызове строки-разделителя принимает список символов в качестве входного аргумента и объединяет символы списка с помощью разделителя. После выполнения он возвращает результирующую строку.

       >>> print ":".join(word) # #добавьте : между каждым символом
Привет, мир
>>> print " ".join(word) # добавить пробел между каждым символом
Привет, мир

      Тестирование

      Строку в Python можно проверить на истинность.

      Тип возвращаемого значения будет логическим (True или False)

       word = "Hello World"
word. isalnum() #проверить, являются ли все символы буквенно-цифровыми
word.isalpha() #проверить, все ли символы в строке являются буквенными
word.isdigit() # проверяет, содержит ли строка цифры
word.istitle() # проверяет, содержит ли строка заглавные слова
word.isupper() # проверяет, содержит ли строка верхний регистр
word.islower() # проверяет, содержит ли строка строчные буквы
word.isspace() # проверяет, содержит ли строка пробелы
word.endswith('d') #проверяет, заканчивается ли строка буквой d
word.startswith('H') #проверить, начинается ли строка с H

      Заключение

      В этой статье мы обсудили различные способы выполнения манипуляций со строками в Python. Чтобы узнать больше о программировании на Python, вы можете прочитать эту статью о понимании списков в Python. Вам также может понравиться эта статья о том, как создать чат-бот на python.

      Рекомендуемое обучение Python

      Курс: Python 3 для начинающих

      Более 15 часов видеоконтента с пошаговыми инструкциями для начинающих.

      No related posts.