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

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

Чтобы следовать этому руководству, рекомендуется, чтобы в вашей системе была установлена ​​последняя версия python. Если в вашей системе установлена ​​более старая версия python, вы можете следовать нашему руководству по обновлению python в Linux. 

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

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

# создание строки
приветствие = "Привет, мир"
# выводим строку
печать (приветствие)

Запустив приведенный выше код, вы получите результат Привет мир.

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

var = "" "Lorem ipsum dolor sit amet,
Conctetur Adipiscing Elit,
sed do eiusmod tempor incididunt
ut labore et dolore magna aliqua."" "
печать (var)

Вот результат.

В Python строки представляют собой массивы байтов, представляющих символы Юникода. Но у него нет встроенного типа данных для отдельных символов, как в C или C++. Любая строка, длина которой равна единице, считается символом.

Длина струн 

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

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

var = "Это строка"
print ("Длина строки:", len (var))

Выход:

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

Пример:

var = "Это строка"
count = 0
для я в var:
count = count + 1
print ("Длина строки:", count)

Выход:

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

Конкатенация строк - это слияние или соединение двух строк. Мы можем легко соединить две строки, используя оператор +. Давайте посмотрим на пример соединения двух строк в Python.

# создание двух строк
string1 = "Привет"
string2 = "Мир"
# слияние двух строк
приветствие = строка1 + строка2
печать (приветствие)

В приведенном выше коде мы создали две строки, а именно «Hello» и «World», и сохранили их в двух переменных с именами строка1 а также строка2. Затем мы использовали оператор +, чтобы соединить две строки и сохранить их в переменной с именем приветствия, и отобразили ее с помощью Распечатать() функция.

Выход:

Повторение строки

Мы можем повторять строку несколько раз в Python, используя оператор *. Например, чтобы напечатать строку «Fosslinux» два раза, нам нужно написать следующий код.

print ("Fosslinux" * 2)

Выход:

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

Форматирование строк в Python несложно. Есть три способа:

1. Старый стиль форматирования

Старый стиль форматирования строк выполняется с помощью оператора%. Нам нужно использовать специальные символы, такие как «% s», «% d», «% f», «%.f ». со строкой, а затем укажите кортеж данных, который мы хотим отформатировать в этом месте. Давайте посмотрим, какие данные принимают указанные выше символы.

• % s: Он будет принимать строки или любые другие данные со строковым представлением, например числа.
• % d:Он используется для передачи целочисленных данных в строку.
• % f:Используется для чисел с плавающей запятой.
• %.f: Используется для чисел с плавающей запятой с фиксированной точностью.

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

string1 = "Это отформатированная строка с целым числом% d"% (1)
string2 = "Это отформатированная строка со строкой% s"% ("Fosslinux")
string3 = "Это отформатированная строка с данными с плавающей запятой% f"% (1.01)
печать (строка1)
печать (строка2)
печать (строка3)

Выход:

Как видно из вывода, мы отформатировали строки целочисленными, плавающими и строковыми данными. Этот метод форматирования строк является самым старым, но в настоящее время он используется реже.

2. Использование метода format ()

Это новый метод форматирования строк, представленный в Python 3. Функции format () принимают данные в качестве аргумента и заменяют их в строке, где заполнитель присутствуют. 

Пример:

string1 = "Это отформатированная строка с целым числом ".формат (1)
string2 = "Это отформатированная строка со строкой ".формат ("Fosslinux")
string3 = "Это отформатированная строка с плавающими данными ".формат (1.01)
печать (строка1)
печать (строка2)
печать (строка3)
print (" отличный веб-сайт для обучения  и ".формат ("FossLinux", "Linux", "Python"))

Мы получим отформатированную строку в качестве вывода при запуске вышеуказанного кода, как показано на изображении ниже.

3. ф-струны

Последним методом форматирования строк является интерполяция строк или f-строки, представленные в версии Python 3.6. Мы можем указать имя переменной непосредственно в f-строке, и интерпретатор Python заменит имя переменной на соответствующее ему значение данных. Строки f начинаются с буквы f, и мы можем напрямую вводить данные в их соответствующие позиции. Этот метод форматирования строк стал довольно популярным в последнее время. Чтобы увидеть демонстрацию его работы, скопируйте приведенный ниже код и запустите его в своей среде разработки Python.

string1 = f "Это отформатированная строка с целым числом 1"
string2 = f "Это отформатированная строка со строкой 'fosslinux'"
string3 = f "Это отформатированная строка с плавающими данными 0.01 "
печать (строка1)
печать (строка2)
печать (строка3)
a = "Fosslinux"
b = "Linux"
c = "Python"
print (f "a - отличный сайт для изучения b и c")

Мы использовали метод интерполяции строк для форматирования строк в приведенном выше коде. Строки, начинающиеся с символа f, являются f-строками. Строка f упростила нашу работу, и мы можем записывать переменные непосредственно в строки, задавая переменные в заполнитель. Запустив приведенный выше код, мы получим следующий вывод.

Проверить подстроку

Часто нам может потребоваться проверить наличие символа или подстроки в строке. Это можно сделать с помощью в а также не в Ключевые слова Python. Например, чтобы проверить, Привет присутствует в строке Привет мир, нам нужно запустить следующий код.

x = "привет" в "привет, мир"
печать (х)

Запустив приведенный выше код в среде IDE Python, мы получим логическое значение Правда в качестве вывода, что означает, что подстрока «hello» присутствует в «hello world».

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

string = "FossLinux - отличный веб-сайт для изучения Linux и Python"
print ("Fosslinux" в строке)
print ("FossLinux" в строке)
print ("Foss" в строке)
print ("Pyt" в строке)
print ("hon" в строке)
print ("Python" не в строке)

Выход:

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

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

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

language = 'Fosslinux'
# распаковываем строку в переменные
a, b, c, d, e, f, g, h, i = язык
печать (а)
печать (б)
печать (с)
печать (d)
печать (е)
печать (е)
печать (г)
печать (ч)
печать (я)

Выход:

Индексирующие строки

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

строка = "Fosslinux"
печать (строка [0])
печать (строка [1])
печать (строка [2])
печать (строка [3])

В приведенном выше коде мы сначала создаем строку с именем Fosslinux, а затем мы используем индексирование строки Python, чтобы получить первый, второй, третий и четвертый символы строки. Мы получим следующий вывод в терминале при запуске кода.

Python также поддерживает отрицательную индексацию, что очень полезно, когда мы можем начать отсчет с правой стороны. Например, чтобы получить второй последний символ строки «Fosslinux», нам нужно написать следующий код.

строка = "Fosslinux"
print ("Второй последний член строки:", строка [-2])

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

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

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

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

строка = "Fosslinux"
print ("Последний член строки:", строка [-1])

Выход:

Мы также можем использовать функцию len () с индексацией, чтобы получить последний член. Для этого нам нужно вычислить длину строки, а затем нам нужно найти символ, индексируя значение, которое на единицу меньше длины строки. См. Пример ниже.

строка = "Fosslinux"
длина = len (строка)
last_index = длина-1
print ("Последний член строки:", строка [last_index])

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

Выход:

Нарезка струн

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

строка = "Fosslinux"
print (строка [1: 6])
print (строка [0: 4])

Выход:

Пропуск символов при нарезке

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

строка [начало: остановка: шаг]

Начало и конец - это номера индексов по умолчанию, которые мы использовали в приведенном выше синтаксисе до сих пор. Параметр step принимает целое число, которое используется для указания количества символов, которые нужно оставить на каждом шаге.

Реверсивные струны

Мы можем легко перевернуть строку, используя метод нарезки. Например, см. Приведенный ниже код. Скопируйте приведенный ниже код в свою среду разработки Python и запустите его.

строка = "Fosslinux"
print ("Обратная строка", строка, "равно", строка [:: - 1])

Этот код перевернет строку «Fosslinux.”Запустив код, мы получим следующий вывод.

Экранирование символа в строках

Escape-символы в программировании - отличный способ добавить непечатаемые символы в строки. Например, чтобы добавить символ новой строки в строки, мы используем escape-символ «\ n». См. Приведенный ниже код для демонстрации.

print ("\ n \ n \ n Привет \ n \ n, мир")

Запустив код, мы получим следующий вывод.

Как мы видим в коде, новые строки автоматически добавляются вместо «\ n». Вот где в игру вступает escape-последовательность. В python присутствует много символов последовательности. Я перечислю их все здесь; вы можете попробовать все из них, чтобы увидеть, как каждый работает.

• \ ': Он используется для указания одинарной кавычки в строке. Как и в некоторых местах, мы не можем указывать одинарные кавычки напрямую.
• \\: Этот символ используется для обозначения обратной косой черты, поскольку во многих местах мы не можем использовать \ напрямую.
• \ п: Этот символ представляет собой символ новой строки, который добавит новую строку.
• \р: представляет собой возврат каретки.
• \ t: представляет вкладку.
• \ b: представляет собой символ возврата.
• \ f: Эта escape-последовательность используется для представления формы.
• \ ooo: Этот символ используется для обозначения восьмеричного числа.
• \ xhh: Этот символ используется для представления шестнадцатеричного значения.
• \ а: Этот символ используется для предупреждения.
• \ s: Этот символ используется для обозначения пробела.
• \ v: представляет собой вертикальную табуляцию.

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

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

Преобразование строковых регистров

У нас есть несколько встроенных функций, которые можно использовать для преобразования строковых регистров. Давайте обсудим их все.

нить.капитализировать ()

Этот метод используется для извлечения выгоды из целевой строки. Когда мы используем метод как нить.извлекать выгоду, он вернет строку с заглавной буквы, я.е., преобразование первого символа в верхний регистр, а всех остальных символов в нижний регистр. Чтобы увидеть практическую демонстрацию его рабочей копии и запустить следующий код в своей среде разработки Python.

строка = "fosslinux"
print (строка.капитализировать ())

Мы использовали капитализировать () метод объекта String, используя его с заглавной буквы. Запустив код, мы получим следующий вывод.

.верхний ()

Этот метод используется для преобразования строки в верхний регистр, i.е., заглавными буквами все символы, присутствующие в строке. 

Пример:

строка = "Fosslinux"
print (строка.верхний ())

Выход:

нить.ниже()

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

Пример:

строка = "FOSSLinux"
print (строка.ниже())

Выход:

нить.swapcase ()

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

строка = "FOSSlinux"
print (строка.swapcase ())

Выход:

нить.заглавие()

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

Пример:

string = "Fosslinux великолепен"
print (строка.заглавие())

Выход:

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

Классификация персонажей

У нас также есть методы для проверки регистра строки, будь то прописные, строчные и т. Д. Обсудим их кратко на примерах.

нить.isalnum ()

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

Пример:

строка1 = "Fosslinux123"
string2 = "Fosslinux великолепен"
string3 = "Fosslinux @ # 123"
печать (строка1.isalnum ()) # содержать только буквы и цифры
печать (строка2.isalnum ()) # содержать пробелы
печать (строка3.isalnum ()) # содержать специальные символы

Выход:

нить.isalpha ()

Этот строковый метод аналогичен указанному выше, но он проверяет только алфавиты, а не числа в строке, что означает, что строка должна содержать только алфавиты. Например, запустите следующий код.

строка1 = "Fosslinux123"
string2 = "Fosslinux"
печать (строка1.isalpha ()) # содержать алфавит и цифры
печать (строка2.isalpha ()) # содержать только алфавит

Мы получим False для первого, потому что он содержит числа, и мы получим True для следующего, поскольку он содержит только алфавиты. 

Выход:

нить.isdigit ()

Этот метод аналогичен приведенному выше, но вместо алфавитов он проверяет, состоит ли строка только из цифр. Он возвращает True, если все символы в строке являются цифрами; иначе возвращает False.

нить.isidentifier ()

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

Пример:

строка1 = "Fosslinux123"
строка2 = "123Fosslinux"
строка3 = "_Fosslinux"
string4 = "Fosslinux @ 1234"
печать (строка1.isidentifier ()) # Верно
печать (строка2.isidentifier ()) # Ложь (начинается с цифр)
печать (строка3.isidentifier ()) # Верно
печать (строка4.isidentifier ()) # False (содержат специальные символы @)

Выход:

нить.islower ()

Этот строковый метод проверяет, все ли строковые символы являются строчными. Если да, он возвращает True, иначе возвращает False.

нить.isupper ()

Этот строковый метод проверяет, все ли символы, присутствующие в строке, являются прописными. Если да, то он возвращает True, иначе возвращает False.

нить.istitle ()

В istitle () метод строки вернет True, если первый алфавит из всех слов, присутствующих в строке, является прописным, а все остальные символы - строчными.

нить.isprintable ()

Он возвращает True, если все символы, присутствующие в строке, можно распечатать, i.е., неэскейп-символы; иначе он возвращает False. Чтобы увидеть, как это работает, запустите следующий код.

string1 = "Fosslinux"
строка2 = "\ nFosslinux"
печать (строка1.isprintable ()) # Верно
печать (строка2.isprintable ()) # False (содержит символ новой строки)

Выход:

нить.isspace ()

В нить.isspace () метод вернет True, если все строковые символы являются пробелами; иначе он вернет False.

Другие важные функции

нить.считать()

Метод count () объекта String используется для получения количества раз, когда указанное значение встречается. 

Пример:

строка = "Fosslinux"
print (строка.count ("s"))

В приведенном выше коде мы использовали считать() чтобы узнать, сколько раз символ «s» встречается в строке «Fosslinux.”

Выход:

нить.начинается с()

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

строка = "Fosslinux"
print (строка.начинается с ("F"))
print (строка.начинается с ("Fo"))
print (строка.начинается с ("Фосс"))
print (строка.начинается с ("Ископаемые"))

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

нить.заканчивается ()

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

нить.найти()

Метод find () объекта String - важный метод поиска символа или подстроки в строке. Он принимает подстроку в качестве аргумента и возвращает индекс подстроки, если он присутствует в строке; иначе возвращает -1. 

Пример:

строка = "Fosslinux"
print (строка.найти ("лин"))

Запустив приведенный выше код, мы получим результат как 4, который является начальным индексом подстроки «lin» в «Fosslinux».â €

нить.заменять()

Синтаксис этого метода - заменить (старый, новый). Требуется два аргумента; одна - это старая подстрока, а новая - это подстрока. Он заменяет всю старую подстроку новой подстрокой во всей строке.

Пример:

строка = "Fosslinux"
print (строка.replace ("Foss", ""))

Мы получим только Linux напечатано на экране как Фосс заменяется пробелом при запуске вышеуказанного кода.  Выход: 

нить.расколоть()

Этот метод принимает разделитель в качестве аргумента, разбивает строку в соответствии с разделителем и возвращает список Python. 

Пример:

string = "Fosslinux - отличное место для начала изучения Linux и Python"
print (строка.расколоть(" "))

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

нить.полоска()

Этот метод используется для удаления всех начальных и конечных пробелов из строки.

Заключение

Это все о строках и их использовании в Python. Изучение руководства даст вам представление о том, насколько полезно работать со строками в python. Вы также можете просмотреть руководство по использованию цикла for в python, окончательного цикла для итераций в python. Наконец, прежде чем мы уйдем, вы можете взглянуть на метод переворота строки в Python, который пригодится при обработке строк.