Работа со строками python: Работа со строками в Python — функции, преобразование, форматирование

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

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

• создание строк;
• конкатенация строк;
• выборка символов по индексам.

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

Строки (strings) используются для хранения текстовых данных. Их создание возможно одним из 3-х способов. Тут все просто, т. к. возможно применение разных кавычек: одинарных, двойных либо тройных. То есть в эти кавычки и нужно обернуть текст:

otus_string_1 = 'Привет, друзья!'

otus_string_2 = "Хотите выучить Python?"

otus_string_3 = """Ждем вас на наших курсах!"""

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

Нужно понимать, что разницы, какие именно кавычки использует разработчик, нет. Главное — открывающие и закрывающие кавычки должны быть однотипными. Если же поставить вначале одинарную кавычку, а в конце двойную — ошибки не избежать.

Можно ли применять кавычки внутри строк?

Можно, для чего есть несколько вариантов. Один из них — использовать внутри строки кавычки другого типа. К примеру, наружные кавычки являются двойными, а внутренние — одинарными. Или наоборот:

otus_string_1 = 'Хотите выучить "Пайтон?" и стать профессионалом'

otus_string_2 = "Запишитесь на курс в 'Отус' уже сегодня!"

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

otus_string_1 = "Я и \'Пайтон\' созданы друг для друга"

У тройных кавычек есть особенности. Заключенные в них строки поддерживают многострочность, то есть для переноса не нужен символ \n. А еще внутри тройных кавычек можно вставлять как двойные, так и одинарные кавычки:

my_string = """Учитесь

программированию

в "Отус"!"""

print (my_string)

Вывод будет следующим:

Строки являются неизменяемыми объектами (как и числа). В этом легко убедиться, если создать переменные с одинаковыми именами, а потом вывести на экран их id — идентификаторы будут различаться:

otus_string = 'Привет, друзья!'

print(id(otus_string))

otus_string = "Хотите выучить Python?"

print(id(otus_string))

Рекомендуется повторить вышеописанные операции самостоятельно и попрактиковаться. Сделать это можно, даже не устанавливая «Пайтон», используя любой онлайн-компилятор.  

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

Конкатенация — это сложение строк, в результате чего они соединяются друг с другом. Самый простой способ сделать это — использовать простейший оператор сложения, то есть знак «+».

Это простейший синтаксис, причем можно брать сколько угодно строк и соединять их:

otus_string = "Я " + "просто " + "обожаю " + "Python!"

print(otus_string)

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

otus_string = "Code" * 10

print(otus_string)

Важное свойство строк — длина (число символов). Узнать количество символов, из которых состоит строка, можно, задействовав встроенную функцию len (от англ. length — длина).

Код ниже посчитает число символов:

otus_string = "Python is a good for coding"

print(len(otus_string))

Итого: строка содержит 27 символов (пробел — тоже символ):

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

otus_string_1 = ""

print(len(otus_string_1))

otus_string_2 = " "

print(len(otus_string_2))

Несколько слов о методах строк

Ранее уже использовались такие методы, как print и id. Есть свои методы и у строковых данных — они принадлежат конкретному классу str. Чтобы вывести их, можно воспользоваться функцией dir:

Зубрить каждый из них нет необходимости, так как нужные методы будут запоминаться с практикой. Чтобы обратиться к одному из них, следует сначала обратиться к соответствующему объекту, потом поставить точку, потом написать нужный метод и круглые скобки. Лучше это увидеть:

string_1 = "oTUs"

string_1 = string_1.title()

print(string_1)

string_1 = string_1.upper()

print(string_1)

string_1 = string_1.lower()

print(string_1)

Что отображено на скриншоте выше:

• была создана новая строка string_1 с содержимым “oTUs”;
• вначале задействовали метод title — вывод слова получился с заглавной буквы;
• потом использовали метод для верхнего регистра upper — заглавными (прописными)  стали все символы строки;
• далее применили lower — все символы стали маленькими (строчными), то есть перешли в нижний регистр.  

Какие еще есть методы:

• replace —для замены одной части исходной строки (подстроки) на другую;
• split — позволяет разделить (не удалить!) строку по переданному делителю, возвращает список;
• join — склеивает подстроки по конкретному разделителю;
• strip. В языке программирования Python strip используется для обрезки ненужных символов, причем ненужный символ передается в виде аргумента. Обрезку можно выполнять по-разному: если с первого символа слева, то применяют не strip, а lstrip, если справа, то rstrip (с конца строки, если интересует последний символ).

Индексы

В «Питоне» у каждого символа есть свой номер — индекс. Если разработчика интересует поиск какого-нибудь символа, к нему можно обратиться. Код ниже возвращает индекс для каждого символа из слова Otus:

string_1 = "Otus"

print(string_1[0])

print(string_1[1])

print(string_1[2])

print(string_1[3])

Тут важен один момент: индексация начинается не с единицы, а с нуля, поэтому первый символ имеет индекс 0.

Дополнительно: преобразование символа в целое число

Компьютеры хранят все данные в виде цифр, и символьных данных это тоже касается. Для представления символов строкового типа String применяют схему перевода. Самая простая из них — ASCII. Если нужно вернуть число для какого-нибудь конкретного символа, используют функцию ord. К примеру, для символа «a» кодовое значение по ASCII будет равняться 97, а для «#» — 35.

Кроме ASCII, также широко известен  Unicode, который тоже поддерживается «Питоном».

Источники:

• https://zen.yandex.ru/media/id/5cab3ea044061700afead675/vse-o-strokah-v-python-5f60744e5622142b93b2031e;
• https://pythonru.com/osnovy/stroki-python.

работа со строками Python 3

2022-08-03

Не знаете как осуществляется работа со строками Python? В Python есть несколько встроенных функций для работы со строками. Встроенные функции — это методы, которые определены в языке программирования.

В этом руководстве мы рассмотрим некоторые строковые функции Python 3.

• Работа со строками Python 3 — создание строк в верхнем и нижнем регистре
• Работа со строками Python 3 — логические методы строк питон
• Как определяется длина строки Python?
• Методы join в Python, split() и функция replace Python 3
• Заключение

Функции str.upper() и str.lower() возвращают строку со всеми буквами исходной строки, преобразованными в прописные или строчные буквы. Символы в строке, которые не являются буквами, меняться не будут.

Преобразуем строку Sammy Shark в верхний регистр:

ss = "Sammy Shark"
print(ss.upper())

Вывод:

SAMMY SHARK

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

print(ss.lower())

Вывод:

sammy shark

строк. Например, если пользователь записывает свое имя в нижнем регистре, мы все равно можем определить, хранится ли логин в базе данных.

В Python есть несколько методов, которые оценивают логический тип значения. Они применяются для валидации полей форм регистрации. Если мы запрашиваем почтовый индекс, то поле должно «принимать» только числовую строку. Но когда пользователь вводит имя, строка должна состоять только из букв.

Существует ряд строковых методов, которые возвращают логические значения:

Метод	True если
str.isalnum()	Строка состоит только из буквенно-цифровых символов (без специальных символов).
str.isalpha()	Строка состоит только из буквенных символов (без специальных символов).
str.islower()	Все буквенные символы строки имеют нижний регистр.
str.isnumeric()	Строка состоит только из цифровых символов.
str.isspace()	Строка состоит только из символов пробелов.
str.istitle()	Строка заглавными буквами.
str. isupper()	Все буквенные символы строки имеют верхний регистр.

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

number = "5"
letters = "abcdef"
print(number.isnumeric())
print(letters.isnumeric())
Вывод:
True
False

Метод str.isnumeric() возвращает для строки number = «5» значение True, а тот же метод для строки letters = «abcdef» возвращает значение False.

Точно так же мы можем проверить, являются ли буквенные символы строки заглавными, прописными или строчными.

Создадим несколько строк:

movie = "2001: A SAMMY ODYSSEY"
book = "A Thousand Splendid Sharks"
poem = "sammy lived in a pretty how town"

Теперь применим логические методы, которые проверяют регистр:

print(movie.islower())
print(movie.isupper())
print(book.istitle())
print(book.isupper())
print(poem.istitle())
print(poem.islower())

Выполним код и посмотрим на результат:

Вывод для строки movie:

False
True

Вывод для строки book:

True
False

Вывод для строки poem:

False
True

Проверка регистра строки позволяет правильно отсортировать данные. Логические методы также полезны для валидации полей форм на сайте.

Метод  len Python 3 возвращает количество символов в строке. Его можно использовать в тех случаях, когда необходимо установить минимальную или максимальную длину пароля. А также, если необходимо усечь длинные строки.

Чтобы продемонстрировать этот метод в действии, найдем длину предложения:

open_source = "Sammy contributes to open source."
print(len(open_source))

Вывод:

Мы инициализируем переменную open_source строковым значением «Sammy contributes to open source.». Затем передаем эту переменную в метод len() с помощью len(open_source). После этого используем  print() для вывода результата на экран.

Помните, что любой символ, заключенный в одинарные или двойные кавычки, будет учитываться методом len().

Метод join Python объединяет две строки и разделяет их указанным символом.

Давайте создадим строку:

balloon = "Sammy has a balloon."

Теперь используем метод join в питоне, чтобы добавить пробел к этой строке. Мы можем сделать так:

" ".join(balloon)

Если мы выведем это:

print(" ".join(balloon))

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

Вывод:

S a m m y   h a s   a   b a l l o o n .

Функция join python также может использоваться для возврата строки, которая является перевернутой исходной строкой:

print("".join(reversed(balloon)))

Вывод:

.noollab a sah ymmaS

Метод str.join() также полезен для объединения списка строк в новую единственную строку.

Создадим разделенную запятыми строку из списка строк:

print(",".join(["sharks", "crustaceans", "plankton"]))

Вывод:

sharks,crustaceans,plankton

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

".join(["sharks", "crustaceans", "plankton"]).

Также можно и разбивать строки. Для этого используется метод str. split():

print(balloon.split())

Вывод:

['Sammy', 'has', 'a', 'balloon.']

Метод str.split() возвращает список строк, разделенных пробелами, если никакой другой параметр не задан.

Также можно использовать str.split() для удаления определенных частей строки. Например, давайте удалим из строки букву a:

print(balloon.split("a"))

Вывод:

['S', 'mmy h', 's ', ' b', 'lloon.']

Теперь буква a удалена, и строки разделены там, где она располагалась.

Метод str.replace() применять для замены части строки. Допустим, что  шарик, который был у Сэмми, потерян. Поскольку у Сэмми больше нет этого шарика, изменим подстроку «has» на новую строку «had»:

print(balloon.replace("has","had"))

В скобках первая подстрока — это то, что мы хотим заменить, а вторая подстрока — это то, на что мы заменяем первую подстроку.

Вывод:

 Sammy had a balloon.

Методы строк Python str.join(), str.split() и str replace Python позволяют более эффективно управлять строками в Python.

В этом руководстве были рассмотрены некоторые встроенные методы строк Python, которые можно использовать для работы со строками в Python-программах.

Вадим Дворниковавтор-переводчик статьи «An Introduction to String Functions in Python 3»

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

60%

ВЫКЛ

PRO РАСПРОДАЖА — Получите скидку 60% на Programiz PRO в течение ограниченного времени. Получите скидку

Python String capitalize()

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

Python String casefold()

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

Python String center()

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

Python String count()

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

Python String encode()

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

Python String endwith()

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

Заменяет символ табуляции пробелами

Python String find()

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

Python String format()

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

Python String format_map()

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

Python String index()

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

Проверяет, все ли символы являются алфавитными

Python String isdecimal()

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

Python String isdigit()

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

Python String isidentifier()

Проверяет действительность идентификатора

Python String islower()

Проверяет, все ли алфавиты в строке являются строчными

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

Python String isspace()

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

Python String istitle()

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

Python String isupper()

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

Python String join()

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

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

Python String lstrip()

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

Python String maketrans()

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

Python String partition()

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

Python String replace()

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

Python String rfind()

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

Python Возвращает наивысший индекс строки 1 rindex1 900 of Substring

Python String rjust()

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

Python String rpartition()

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

Python String rsplit()

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

Python String rstrip()

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

Python String split()

Разбивает строку слева ()

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

Python String strip()

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

Python String swapcase()

поменять символы верхнего регистра на символы нижнего регистра; наоборот

Python String title()

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

Python String translate()

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

Python String upper()

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

3 0 0z 9011 Python String Возвращает копию строки, дополненной нулями

Подробное руководство (более 55 примеров кода)

21 апреля 2022 г.

Типы данных помогают нам классифицировать элементы данных. Они определяют виды операций, которые мы можем выполнять над элементом данных. В Python общие стандартные типы данных включают числа , строка , список , кортеж , логическое значение , набор и словарь .

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

---

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

A строка — это объект, содержащий последовательность символов. Символ — это строка длины один. Одиночный символ также является строкой в ​​Python. Как ни странно, символьный тип данных отсутствует в языке программирования Python. Однако мы находим символьный тип данных в других языках программирования, таких как C, Kotlin и Java.

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

 # Строка с одинарными кавычками
single_quote = 'a' # Это пример символа в других языках программирования. Это строка в Python
# Еще одна строка в одинарных кавычках
other_single_quote = 'Программирование учит вас терпению.'
# Строка с двойными кавычками
двойная_кавычка = "аа"
# Еще одна строка в двойных кавычках
other_double_quote = "Это невозможно, пока это не будет сделано!"
# Строка с тройными кавычками
Triple_quote = '''ааа'''
# Также строка с тройными кавычками
other_triple_quote = """Добро пожаловать в язык программирования Python. Готов, 1, 2, 3, вперёд!"""
# Использование функции str()
string_function = str(123.45) # str() преобразует тип данных с плавающей запятой в тип данных string
# Еще одна функция str()
other_string_function = str(True) # str() преобразует логический тип данных в строковый тип данных
# Пустая строка
пустая_строка = ''
# Также пустая строка
вторая_пустая_строка = ""
# Мы еще не закончили
Third_empty_string = """""" # Это тоже пустая строка: '''''' 

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

 # Ввод в программу Python
input_float = input() # Введите: 3.142
input_boolean = input() # Введите: True
# Преобразование входных данных в другие типы данных
convert_float = float(input_float) # преобразует строковый тип данных в число с плавающей запятой
convert_boolean = bool(input_boolean) # преобразует строковый тип данных в bool 

Мы используем функцию type() для определения типа данных объекта в Python. Он возвращает класс объекта. Когда объект является строкой, он возвращает класс str . Точно так же он возвращает dict , int , float , tuple , bool class , когда объект является словарем, целым числом, числом с плавающей запятой, кортежем или логическим значением соответственно. Давайте теперь воспользуемся функцией type() для определения типов данных переменных, объявленных в предыдущих фрагментах кода:

 # Типы/классы данных с type()
печать (тип (одинарная кавычка))
печать (тип (another_triple_quote))
печать (тип (пустая_строка))
печать (тип (input_float))
печать (тип (input_boolean))
печать (тип (convert_float))
печать (тип (convert_boolean)) 

Мы обсудили, как объявлять строки. Давайте теперь перейдем к взаимосвязи между строками и таблицей ASCII.

---

Таблица ASCII и строковый символ Python

Американский стандартный код для обмена информацией (ASCII) был разработан, чтобы помочь нам преобразовать символы или тексты в числа, поскольку наборы чисел легче хранить в памяти компьютера, чем тексты. ASCII кодирует 128 символов в основном английского языка, которые используются при обработке информации в компьютерах и программировании. Английские символы, закодированные с помощью ASCII, включают строчные буквы (a–z), прописные буквы (A–Z), цифры (0–9). ) и символы, такие как знаки препинания.

Функция ord() преобразует строку Python длиной один (символ) в ее десятичное представление в таблице ASCII, а функция chr() преобразует десятичное представление обратно в строку. Например:

 строка импорта
# Преобразование символов верхнего регистра в их десятичные числа ASCII
ascii_upper_case = string.ascii_uppercase # Вывод: ABCDEFGHIJKLMNOPQRSTUVWXYZ
for one_letter in ascii_upper_case[:5]: # Перебираем ABCDE
    печать (орд (одна_буква)) 

 65
66
67
68
69 

 # Преобразование цифровых символов в их десятичные числа ASCII
ascii_digits = string.digits # Вывод: 0123456789
for one_digit in ascii_digits[:5]: # Цикл по 01234
    печать (порядок (одна_цифра)) 

 48
49
50
51
52 

В приведенном выше фрагменте кода мы перебрали строки ABCDE и 01234 и преобразовали каждый символ в его десятичное представление в таблице ASCII. Мы также можем выполнить обратную операцию с chr() , с помощью которой мы преобразуем десятичные числа в таблице ASCII в их строковые символы Python. Например:

 decimal_rep_ascii = [37, 44, 63, 82, 100]
для one_decimal в decimal_rep_ascii:
    печать (chr (one_decimal)) 

 %
,
?
р
д 

В таблице ASCII строковые символы в выводе вышеуказанной программы сопоставляются с соответствующими им десятичными числами. До сих пор мы обсуждали, как объявлять строки Python и как символ строки отображается в таблицу ASCII. Далее давайте обсудим атрибуты строки.

---

Свойства строки

Нулевой индекс: Первый элемент в строке имеет нулевой индекс, а последний элемент имеет индекс len(string) - 1 . Например:

 immutable_string = "Подотчетность"
печать (длина (неизменяемая_строка))
печать (неизменяемая_строка. индекс ('A'))
печать (иммутабельная_строка. индекс ('y')) 

 14
0
13 

Неизменяемость . Это означает, что мы не можем обновлять символы в строке. Например, мы не можем удалить элемент из строки или попытаться присвоить новый элемент в любой из позиций его индекса. Если мы попытаемся обновить строку, она выдаст Ошибка типа :

 immutable_string = "Подотчетность"
# Назначить новый элемент с индексом 0
immutable_string[0] = 'В' 

 -------------------------------------------------- --------------------------
TypeError Traceback (последний последний вызов)
~\AppData\Local\Temp/ipykernel_11336/2351953155.py в
      2
      3 # Назначить новый элемент с индексом 0
----> 4 immutable_string[0] = 'B'
TypeError: объект 'str' не поддерживает назначение элемента 

Однако мы можем переназначить строку переменной immutable_string , но следует отметить, что это не одна и та же строка, поскольку они не указывают на один и тот же объект в памяти. Python не обновляет старый строковый объект; он создает новый, как мы видим по идентификаторам:

 immutable_string = "Подотчетность"
печать (идентификатор (неизменяемая_строка))
immutable_string = "Вместимость"
печать (идентификатор (неизменяемая_строка)
test_immutable = неизменяемая_строка
печать (идентификатор (test_immutable)) 

2693751670576
2693751671024
2693751671024 

Вы получите другие идентификаторы, чем в примере, потому что мы запускаем наши программы на разных компьютерах, поэтому наши адреса памяти разные. Однако оба идентификатора также должны быть разными на одном компьютере. Это означает, что обе переменные immutable_string указывают на разные адреса в памяти. Мы присвоили последнюю переменную immutable_string переменной test_immutable . Вы можете видеть, что test_immutable и последняя переменная immutable_string указывают на один и тот же адрес.

Конкатенация: объединение двух или более строк вместе для получения новой строки с символом + . Например:

 first_string = "Данные"
second_string = "квест"
Third_string = "Путь науки о данных"
четвертая_строка = первая_строка + вторая_строка
печать (четвертая_строка)
пятая_строка = четвертая_строка + " " + третья_строка
печать (пятая_строка) 

 Датаквест
Путь науки о данных Dataquest 

Повторение: Строка может повторяться с символом * . Например:

 печать("Га" * 3) 

 Ха-Ха-Ха 

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

 main_string = "Я изучил R и Python на Dataquest. Вы тоже можете это сделать!"
# Индекс 0
печать (основная_строка [0])
# Индекс 1
печать (основная_строка [1])
# Проверяем, является ли индекс 1 пробелом
печать (основная_строка[1].isspace())
# Нарезка 1
печать (основная_строка [0:11])
# Нарезка 2:
печать (основная_строка [-18:])
# Нарезка и конкатенация
print(main_string[0:11] + "." + main_string[-18:]) 

 я
Истинный
Я выучил Р
Вы тоже можете это сделать!
Я выучил R. Ты тоже сможешь! 

---

Строковые методы

str.split(sep=None, maxsplit=-1): Метод разделения строк содержит два атрибута: sep и maxsplit . Когда этот метод вызывается со значениями по умолчанию, он разбивает строку везде, где есть пробел. Этот метод возвращает список строк:

 string = "Яблоко, банан, апельсин, черника"
печать (строка. split()) 

 ['Яблоко', 'Банан', 'Апельсин', 'Черника'] 

Мы видим, что строка не разделена правильно, потому что разделенная строка содержит , . Мы можем использовать sep=',' для разделения везде, где есть , :

 печать (string.split (sep = ',')) 

 ['Яблоко', 'Банан', 'Апельсин', 'Черника'] 

Это лучше, чем предыдущий сплит. Однако мы можем видеть пробелы перед некоторыми разделяемыми строками. Мы можем удалить это с помощью (sep=', ') :

 # Обратите внимание на пробел после запятой
печать (строка.split (sep = ', ')) 

 ['Яблоко', 'Банан', 'Апельсин', 'Черника'] 

Теперь строка правильно разделена. Иногда мы не хотим разбивать максимальное количество раз. Мы можем использовать атрибут maxsplit , чтобы указать, сколько раз мы собираемся разделить:

 печать (string.split (sep = ', ', maxsplit = 1))
print(string.split(sep=', ', maxsplit=2)) 

 ['Яблоко', 'Банан, Апельсин, Черника']
['Яблоко', 'Банан', 'Апельсин, Черника'] 

str. splitlines(keepends=False): Иногда нам нужно обработать корпус с разными разрывами строк ( '\n' , \n\n' , '\r' , ' \r\n' ) на границах. Мы хотим разбивать на предложения, а не на отдельные слова. Для этого мы будем использовать метод splitline . Когда keepends=True , разрывы строк включаются в текст; в противном случае они исключаются. Давайте посмотрим, как это делается на тексте шекспировского «Макбета»:

 import nltk # Возможно, вам придется установить `pip install nltk`, чтобы использовать эту библиотеку.
макбет = nltk.corpus.gutenberg.raw('шекспир-макбет.txt')
печать (macbeth.splitlines (keepends = True) [: 5]) 

 ['[Трагедия Макбета Уильяма Шекспира 1603]\n', '\n', '\n', 'Actus Primus. Скона Прима.\n', '\n'] 

str.strip([chars]): Мы удаляем конечные пробелы или символы с обеих сторон строки с помощью метода strip . Например:

 string = "Apple Apple Apple нет яблока в коробке яблоко яблоко "
stripped_string = строка.strip()
печать (stripped_string)
left_stripped_string = (
    stripped_string
    .lstrip('Яблоко')
    .lstrip()
    .lstrip('Яблоко')
    .lstrip()
    .lstrip('Яблоко')
    .lstrip()
)
печать (left_stripped_string)
капитализированная_строка = левая_стрипированная_строка.capitalize()
печать (заглавная_строка)
right_stripped_string = (
    капитализированная_строка
    .rstrip('яблоко')
    .rstrip()
    .rstrip('яблоко')
    .rstrip()
)
печать (right_stripped_string) 

 Яблоко Яблоко Яблоко Яблоко без яблока в коробке яблоко яблоко
нет яблока в коробке яблоко яблоко
Нет яблока в коробке яблоко яблоко
Нет яблока в коробке 

В приведенном выше фрагменте кода мы использовали методы lstrip и rstrip , которые удаляют конечные пробелы или символы с левой и правой сторон строки соответственно. Мы также использовали метод заглавных букв , который преобразует строку в регистр предложений.

ул.zзаполнение(ширина): Метод zfill дополняет строку префиксом 0 для получения указанной ширины . Например:

 пример = "0,8" # длина (пример) равна 3
example_zfill = example.zfill(5) # len(example_zfill) равно 5
печать (пример_zfill) 

 000,8 

str.isalpha(): Этот метод возвращает True , если все символы в строке являются алфавитами; в противном случае возвращается False :

 # Алфавитная строка
Alphabet_one = "Обучение"
печать (alphabet_one.isalpha())
# Содержит пробел
Alphabet_two = "Изучение Python"
печать (alphabet_two.isalpha())
# Содержит запятые
Alphabet_three = "Обучение"
print(alphabet_three.isalpha()) 

 Правда
ЛОЖЬ
Ложь 

Аналогично, str.isalnum() возвращает True , если символы строки являются буквенно-цифровыми; str.isdecimal() возвращает True , если символы строки являются десятичными; str. isdigit() возвращает True , если символы строки являются цифрами; и str.isnumeric() возвращает True , если строковые символы являются числовыми.

str.islower() возвращает True , если все символы в строке строчные. str.isupper() возвращает True , если все символы в строке в верхнем регистре, а str.istitle() возвращает True , если первая буква каждого слова заглавная:

 # пример islower()
string_one = "Искусственная нейронная сеть"
печать (string_one.islower())
string_two = string_one.lower() # преобразует строку в нижний регистр
печать (string_two.islower())
# пример isupper()
string_three = string_one.upper() # преобразует строку в верхний регистр
печать (string_three.isupper())
# пример istitle()
печать (string_one.istitle()) 

 Ложь
Истинный
Истинный
Правда 

str.endswith(suffix) возвращает True , если строка заканчивается указанным суффиксом. str.startswith(prefix) возвращает True , если строка начинается с указанного префикса:

 предложений = ['Пришло время освоить науку о данных', 'Я люблю статистические вычисления', 'Есть, спать, программировать']
# конец с() пример
for one_sentence в предложениях:
    print(one_sentence.endswith(('наука', 'вычисления', 'Код'))) 

 Правда
Истинный
Ложь 

 # пример запуска с()
for one_sentence в предложениях:
    print(one_sentence.startswith(('Время', 'Я', 'Эа'))) 

 Правда
Истинный
Правда 

str.find(substring) возвращает наименьший индекс, если подстрока присутствует в строке; в противном случае возвращается -1. str.rfind(substring) возвращает самый высокий индекс. str.index(substring) и str.rindex(substring) также возвращают самый низкий и самый высокий индекс подстроки соответственно, если они найдены. Если подстроки нет в строке, они поднимают ЗначениеОшибка .

 строка = "программирование"
# примеры find() и rfind()
печать (строка. найти ('м'))
печать (строка. найти ('про'))
печать (строка.rfind ('m'))
печать (строка.rfind ('игра'))
# примеры index() и rindex()
печать (строка.индекс ('м'))
печать (строка.индекс ('про'))
печать (строка.rindex ('m'))
печать (строка.rindex ('игра')) 

 6
0
7
-1
6
0
7
-------------------------------------------------- -------------------------
ValueError Traceback (последний последний вызов)
~\AppData\Local\Temp/ipykernel_11336/3954098241.py в
     11 print(string.index('pro')) # Вывод: 0
     12 print(string.rindex('m')) # Вывод: 7
---> 13 print(string.rindex('game')) # Вывод: ValueError: подстрока не найдена
ValueError: подстрока не найдена 

str.maketrans(dict_map) создает таблицу перевода из карты словаря, а str.translate(maketrans) заменяет элементы в переводе их новыми значениями. Например:

 пример = "abcde"
mapped = {'a':'1', 'b':'2', 'c':'3', 'd':'4', 'e':'5'}
print(example. translate(example.maketrans(mapped))) 

 12345 

---

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

Цикл по строке. Строки повторяемы. Следовательно, они поддерживают циклические операции с для цикла и , перечисляют :

.

 # Пример цикла for
слово = "банк"
для буквы в слове:
    печать (письмо) 

 б
а
н
к 

 # Пример перечисления
для idx значение в перечислении (слово):
    печать (idx, значение) 

 0 б
1 год
2 н
3 к 

Строковые и реляционные операторы : когда две строки сравниваются с использованием операторов отношения ( > , < , == и т. д.), элементы двух строк сравниваются по их десятичным числам ASCII индекс за индексом. Например:

 печать ('а' > 'б')
печать ('abc' > 'b') 

 Ложь
Ложь 

В обоих случаях выводится False . Оператор отношения сначала сравнил десятичные числа ASCII элементов по индексу 0 для обеих строк. С b больше, чем a , возвращает False ; десятичные числа ASCII других элементов и длина строк в этом случае не имеют значения.

Если строки имеют одинаковую длину, он сравнивает десятичные числа ASCII каждого элемента из индекса 0 , пока не найдет элементы с разными десятичными числами ASCII. Например:

 печать('abd' > 'abc') 

 Правда 

В приведенном выше фрагменте кода первые два элемента имеют одинаковые десятичные числа ASCII; однако имеется несовпадение в третьем элементе, а так как d больше c , он возвращает True . В ситуации, когда все числа ASCII для элементов совпадают, более длинная строка больше, чем более короткая. Например:

 печать('abcd' > 'abc') 

 Правда 

Проверка принадлежности строки. Оператор в используется для проверки того, является ли подстрока частью строки:

 печать («данные» в «dataquest»)
печать («грамм» в «программировании») 

Истинный
Правда 

Другой способ проверить принадлежность строки, заменить подстроку или найти шаблон — использовать регулярное выражение

 импорт повторно
подстрока = 'грамм'
строка = 'программирование'
замена = '1234'
# Проверить членство
печать (поиск (подстрока, строка))
# Заменить строку
print(re. sub(подстрока, замена, строка)) 

про1234минг 

Форматирование строки. f-string и методы str.format() используются для форматирования строк. Оба используют фигурную скобку {} заполнителей. Например:

 понедельник, вторник, среда = "понедельник", "вторник", "среда"
format_string_one = "{} {} {}".format(понедельник, вторник, среда)
печать (format_string_one)
format_string_two = "{2} {1} {0}".format(понедельник, вторник, среда)
печать (format_string_two)
format_string_three = "{один} {два} {три}".format(один=вторник, два=среда, три=понедельник)
печать (format_string_three)
format_string_four = f"{понедельник} {вторник} {среда}"
печать (format_string_four) 

 Понедельник Вторник Среда
среда вторник понедельник
вторник среда понедельник
Понедельник Вторник Среда 

f-строки более удобочитаемы и реализуются быстрее, чем метод str.format() . Таким образом, f-строка является предпочтительным методом форматирования строки.

Обработка кавычек и апострофа : знак апострофа (') представляет строку в Python. Чтобы сообщить Python, что мы имеем дело не со строкой, мы должны использовать escape-символ Python 9.0216 (\) . Итак, апостроф в Python представлен как \'. В отличие от обработки апострофов, в Python существует множество способов обработки кавычек. Среди них:

 # 1. Представление строки в одинарной кавычке (`""`) и оператора в кавычках в двойной кавычке (`""`)
quotes_one = '"Друзья не разрешают друзьям использовать мини-пакеты больше 32" - Янн Лекун'
печать (quotes_one)
# 2. Представьте строку в двойных кавычках `("")` и оператор в кавычках с помощью escape и двойных кавычек `(\"statement\")`
quotes_two = "\"Друзья не разрешают друзьям использовать мини-пакеты больше 32\" - Янн ЛеКун"
печать (quotes_two)
# 3. Представьте строку в тройных кавычках `("""""")` и цитируемый оператор в двойных кавычках ("")
quote_three = """"Друзья не разрешают друзьям использовать мини-пакеты больше 32" - Янн ЛеКун"""
печать (quote_three) 

 «Друзья не разрешают друзьям использовать мини-пакеты больше 32» — Янн ЛеКун
«Друзья не позволяют друзьям использовать мини-пакеты больше 32» — Янн ЛеКун.
No related posts.