Сравнение строк python: Как сравнить строки в Python? Операторы сравнения строк

Как сравнить строки в Python? Операторы сравнения строк

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

Основные операторы сравнения в Python

Итак, в языке программирования Python для сравнения строк используют следующие операторы:

• оператор <, «меньше»;
• оператор <=, «меньше или равно;
• оператор ==, «равно»;
• оператор !=, «не равно»;
• оператор >, «больше»;
• оператор >=, «больше или равно».

Использование оператора «больше/меньше»

Ниже вы увидите простейший пример сравнения строк в Python с помощью соответствующих операторов: > и <. Давайте сравним строки со словами banana и apple:

print("apple" > "banana")
False
print("apple" < "banana")
True

Так как буква «a» находится перед «b», слово apple будет находиться перед словом banana, что логично (то есть banana больше, чем apple). Однако всё сложнее, чем может показаться на первый взгляд. Давайте для наглядности сравним, равны ли слова Apple и apple:

print("apple" == "Apple")
False
print("apple" > "Apple")
True

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

Что касается нашей ситуации, то здесь латинская «А» имеет значение 65, в то время как значение строчной «а» равно 97.

Кстати, если хотите узнать уникальное значение какого-нибудь символа, используйте функцию ord:

print(ord("A"))
65

При сравнении символов или строк, Python конвертирует символы в их соответствующие порядковые значения, после чего сравнивает слева направо.

Существует функция chr, преобразовывающая порядковое значение в символ. Пример:

print(chr(1040))
А

Например, кириллическая А соответствует значению 1040. Есть свои значения у цифр, а также вспомогательных знаков, включая «?», «=», пробел.

В принципе, вы всегда можете выполнить сравнение строк в Python, предварительно конвертировав строки в один формат, к примеру, в нижний регистр (используем метод lower):

str1 = "apple"
str2 = "Apple"
str2.lower()
print(str1 == str1)
True

Применение оператора «равенство»

Мы можем проверить, равны ли строки, посредством оператора ==:

print("строка1" == "строка2")
False

Естественно, строки не являются равными, т. к. выполняется точное сравнение в Python. Неравными будут и те строки, которые содержат одинаковые, но переставленные местами символы. В последнем случае есть выход: превратить нашу строку в список, отсортировать, сравнить и вывести содержимое:

strA = "abcde"
strB = "abdec"
print(sorted(list(strA)) == sorted(list(strB)))
print(sorted(list(strA)))
print(sorted(list(strB)))
True
['a', 'b', 'c', 'd', 'e']
['a', 'b', 'c', 'd', 'e']

Использование оператора «не равно»

Оператор != выполняет проверку неравенства:

 print("abc" != "zxc")
True

Разумеется, результат True, ведь abc не равно zxc.

Применение операторов «больше или равно/меньше или равно»

Если при использовании оператора <= одна строка будет меньше или равна другой, мы получим True.

print("abc" <= "bcd")
True

В нашем случае «abc» меньше.

Аналогично работает и оператор >=:

print("abc" >= "abc")
True

В этой ситуации очевидно, что строки равны.

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

В Python строка – это последовательность символов, причем отдельный символ тоже считается строкой. Все символы имеют разные значения Unicode или ASCII.

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

Следует учитывать, что компьютер сравнивает не символы как таковые, а их значения в Unicode. Чем больше это значение, тем «больше» символ.

Сравнение строк осуществляется так же, как и сравнение чисел, т. е. для этого нет каких-то специальных методов. Для прямого сравнения значений строк используется оператор ==. Если строки идентичны, возвращается True, в противном случае – False.

Для сравнения строк в Python используются разные операторы. Давайте начнем с операторов == и !=, а затем разберем остальные.

Сравнение строк при помощи == и !=

Сравнение двух строк можно эффективно выполнить с помощью операторов == и !=. Оператор == возвращает True, если строки идентичны, и False в противном случае. Оператор != действует наоборот.

Рассмотрим следующий пример:

 language = 'chinese'
print(language == 'chinese')
print(language != 'chinese')
# Output:
# True
# False

В данном коде language – это переменная, содержащая строку «chinese». Сравнение выполняется путем поочередного сравнения символов одной строки с символами другой строки.

В качестве результата оператор == возвращает True, а оператор != возвращает False, потому что сравниваемые строки одинаковые.

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

 print('chinese' == 'Chinese')
# False
print('chinese' > 'Chinese')
# True
print(ord('c'))
# 99
print(ord('C'))
# 67

Итак, в данном случае мы сравниваем символ «c» в слове «chinese» с символом «C» в слове «Chinese».

Как мы видим, строки «chinese» и «Сhinese» – не одно и то же. Поэтому после сравнения этих строк с помощью оператора == оператор print() возвращает False . Выведя значения Unicode для «c» и «C», мы видим, что значение «C» (67) меньше, чем значение «c» (99). На этом сравнение прекращается, и выражение print('chinese' > 'Chinese') возвращает True.

Мы получаем результат: «chinese» больше, чем «Сhinese», потому что первый символ в одном слове больше первого символа во втором.

[python_ad_block]

Сравнение строк другими операторами

Для сравнения строк в Python используются не только == и !=. Как и при сравнении чисел, мы можем использовать операторы <, >, <= и >=.

string = 'chinese'
string1 = 'china'
print(string < string1)
# False
print(string > string1)
# True
print(string <= string1)
# False
print(string >= string1)
# True

Мы присваиваем значение «chinese» для string и «china» для string1. Теперь сравним эти две строки с помощью операторов сравнения  <, >

, <=, >=.

После сравнения string и string1 оператором < мы получаем False. Первые четыре символа «chinese» и «china» идентичны. Однако пятый символ переменной string – «е», в то время как пятый символ string1 – «а». Значение «e» в Юникоде равно 101, а «a» – 97. Таким образом, в результате сравнения этих переменных «chinese» оказывается больше, чем «china».

Сравнение строк с помощью is

Теперь давайте поговорим про сравнение строк с помощью оператора is. Он работает следующим образом. Если две переменные указывают на один объект, оператор возвращает True, иначе — False.

Обратите внимание, что даже если обе строки имеют одинаковое значение, все равно может вернуться False — если у сравниваемых объектов разные id. Подробнее про разницу между операторами == и is можно почитать в статье «Чем == отличается от is?».

Итак, рассмотрим следующий пример. Мы берем три строки: string1, string2, string3. Переменной string1 мы присваиваем значение ['u', 'v', 'w']. Переменную string2 приравниваем к string1. string3 приравниваем к string1, но не просто, а преобразовав в список string3 = list(string1), хотя, по сути, это и так список, т.е. значения не поменяются. А далее мы сравниваем строки операторами == и is.

string1 = ['u', 'v', 'w']
string2 = string1
string3 = list(string1)
print(string1 == string2)
# True
print(string1 == string3)
# True
print(string1 is string2)
# True
print(string1 is string3)
# False
print(id(string1))
# 139879412641216
print(id(string2))
# 139879412641216
print(id(string3))
# 139879412022144

Переменные string1 и string2 абсолютно идентичны и ссылаются на одни и те же объекты. Однако для string3 мы создали новый объект, и хотя значение string3 совпадает со значением string1, они ссылаются на разные объекты.

Адреса объектов определяются с помощью функции id(). Мы видим, что адреса объектов string3 и string1 действительно разные, в то время как адреса string2 и string1 совпадают.

Именно поэтому сравнение string1 и string2 обоими операторами возвращает True, поскольку они имеют не только одинаковое значение, но и одинаковый адрес.

Сравнение string1 и string3 оператором == дает True, а оператором is дает False, так как значения совпадают, но объекты и их адреса — разные.

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

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

Здесь мы берем три строковые переменные с именами str_1, str_2, str_3. Значения str_1 и str_2 вводятся пользователем. Значение str_3 приравнивается к значению str_1. Дальше мы сравниваем строки разными операторами сравнения: ==, !=, <= ,>=.

 str_1 = input('Enter the value of str_1: ')
# Enter the value of str_1: chinese
str_2 = input('Enter the value of str_2: ')
# Enter the value of str_2: china
str_3 = str_1
print(str_1 == str_2)
# False
print(str_1 != str_2)
# True
print(str_1 <= str_2)
# False
print(str_1 >= str_2)
# True
print(str_1 is str_2)
# False
print(str_1 is str_3)
# True

Когда мы запускаем нашу программу, пользователя просят ввести значения str_1 и str_2. После присвоения значений переменным эти строки сравниваются разными операторами.

Введенное значение str_1 – «chinese», а str_2 – «china». Сначала мы сравниваем эти строки с помощью оператора ==. Поскольку значения не совпадают, мы получаем результат False. Затем мы сравниваем наши строки с помощью оператора !=. Поскольку значения не совпадают, мы получаем результат True.

Дальше мы сравниваем строки с помощью оператора <=. Поскольку str_1 больше str_2, мы получаем True. И, в конце, мы используем is для сравнения строк. str_1 и str_2 имеют разные значения и ссылаются на разные объекты, поэтому результат будет False. Значения str_2 и str_3 идентичны, а переменные ссылаются на один объект, поэтому мы получим True.

Заключение

В этой статье мы поговорили про сравнение строк в Python с помощью различных операторов: ==, !=, >, <, >= и <=. Вы узнали, как именно происходит сравнение, какие строки считаются большими, а какие — меньшими. Мы также разобрали, чем отличается применение == и is, и показали разницу на примерах.

Надеемся, эта статья была вам полезна. Успехов в написании кода!

Перевод статьи «Python string comparison».

Как сравнить строку в Python? (Сравнение строк 101)

В этой статье мы узнаем, как сравнивать строки в Python. Мы обсудим, зачем нам нужно сравнивать строки и какие есть операторы сравнения строк в python, с примерами и исходным кодом!

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

Строка обычно представляет собой последовательность символов. Символ является структурным элементом строки. Это может быть буква, цифра или символ. Например, в английском языке у нас есть 26 алфавитов, каждый из которых является алфавитом.

Но компьютерная система не понимает символов и поэтому имеет дело с двоичными числами. Все символы, которые мы видим на нашем экране, хранятся внутри и обрабатываются как комбинация нулей и единиц.

Преобразование символов и двоичных чисел называется кодированием, а обратное — декодированием. Некоторые из популярных кодировок — ASCII и Unicode. В языке программирования Python

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

Зачем сравнивать строки?

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

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

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

Операторы сравнения строк Python

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

• == :  Этот оператор проверяет, равны ли две строки.
• !=:  Этот оператор проверяет, не равны ли две строки.
• <:  Этот оператор проверяет, меньше ли строка слева, чем строка справа.
• <=:  Этот оператор проверяет, является ли строка слева меньше или равна строке справа.
• >: Этот оператор проверяет, больше ли строка слева, чем строка справа.
• >=:  Этот оператор проверяет, больше ли строка слева, чем строка справа.

Давайте рассмотрим пример, чтобы понять эти операторы:

 string1 = "Абрар"
строка2 = "Ахмед"
строка3 = "ABCD"
строка4 = "ABCD"
если строка1 <= строка2:
    print(string1," меньше ",string2," больше")
если строка2 >= строка4:
    print(string4,"меньше",string2,"больше")
если строка3 == строка4:
    печать (строка3," равна ",строка4)
если строка1 != строка3:
    print(строка1," не равно ", строка3) 

 

Вывод:

 Абрар меньше Ахмед больше
ABCD меньше Ахмед больше
АВСD равно АВСD
Абрар не равен ABCD 

 

Проверка равенства строк в Python

В python мы можем проверить, равны строки или нет, используя два метода. Первый метод заключается в использовании оператора относительного равенства «==» для выполнения сравнения строк.

Второй метод заключается в использовании специальной строковой функции для выполнения сравнений, функции __eq__(). Это волшебная функция, определенная в классе string, которая сравнивает две строки и возвращает True, если они равны, или Fale, если они не равны.

Пример:

 s1 = 'Строка'
s2 = 'Строка'
s3 = 'строка'

# проверка равенства с учетом регистра
если s1 == s2:
    print('s1 и s2 равны.')

если s1.__eq__(s2):
    print('s1 и s2 равны.') 

 

Здесь мы проверяем, равны ли строки s1 и s2, а затем используем условный оператор «если» с комбинацией оператора равенства.

Вывод:

 s1 и s2 равны.

 s1 и s2 равны. 

 

Как насчет сравнения без учета регистра?

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

Регистр строк можно изменить с помощью трех встроенных функций: casefold(), upper() и lower(). Оба метода casefold() и lower() преобразуют строку в нижний регистр.

Отличие состоит в том, что casefold() более агрессивен и может преобразовывать в нижний регистр больше букв, чем lower(). Метод upper() можно использовать для преобразования всех символов строки в верхний регистр.

 s1 = 'Строка'
s2 = 'Строка'
s3 = 'строка'

если s1.casefold() == s3.casefold():
    печать (s1.casefold())
    печать (s3.casefold())
    print('s1 и s3 равны при сравнении без учета регистра')

если s1.lower() == s3.lower():
    печать (s1.lower())
    печать (s3.lower())
    print('s1 и s3 равны при сравнении без учета регистра')

если s1.upper() == s3.upper():
    печать (s1.upper())
    печать (s3.upper())
    print('s1 и s3 равны при сравнении без учета регистра') 

 

Вывод:

 строка

 нить

 s1 и s3 равны при сравнении без учета регистра

 нить

 нить

 s1 и s3 равны при сравнении без учета регистра

 НИТЬ

 НИТЬ

 s1 и s3 равны при сравнении без учета регистра 

 

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

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

Заключение

В программировании бывают разные ситуации, которые требуют от нас выполнения сравнения строк, например проверки или поиска имени и т. д. Теперь вы знаете, как сравнивать строки в python? Теперь вы должны сделать это самостоятельно и запустить приведенный выше исходный код в своей системе.1

Различные методы сравнения строк Python

---

В этом кратком руководстве давайте рассмотрим различные методы сравнения строк в Python. Мы также рассмотрим различные крайние случаи, ограничения и предостережения.

Содержание

• Сравнение строк Python
• Операторы сравнения строк
• «==» и «!=»
• «есть» и «не есть»
• Ограничения и предостережения

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

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

Данные в вашей программе представлены как объекты, и объект имеет эти 3 свойства. Identity (Id) — Identity содержит адрес памяти, в которой хранятся данные. Далее, Тип — это тип данных объекта, а Значение — это содержимое, которое хранит объект.

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

Операторы сравнения строк

Из различных методов, которые можно использовать для сравнения строк в python, ниже я объяснил два наиболее часто используемых метода.

Примечание: Все эти методы сравнения возвращают логическое значение true или false .

Сравнение строк Python с использованием «==» и «!=»:

== и != часто используются для сравнения строк Python. Эти операторы сравнивают значения Unicode для всех элементов строки и возвращают логическое значение true или false.

Значения Unicode — это способ хранения строк в Python. Каждому элементу строки присваивается Unicode, это помогает сохранять единообразие элементов независимо от языка, который использует программист. Подробнее об этом можно прочитать здесь.

Таким образом, эти операторы отношения сравнивают строки на основе их значений Unicode.

Использование «==»

«==» — это метод сравнения строк Python, который проверяет, равны ли оба значения операндов. Этот оператор является наиболее часто используемым методом проверки равенства в python.

 s1 = 'гибкий!'
печать (идентификатор (s1))
# Выход = 2621679855024
s2 = 'гибкий!'
печать (идентификатор (s2))
# Выход = 2621679855024
s3 = «гибкий»
печать (идентификатор (31))
# Выход = 140735453670112
печать (s1 == s2)
#выход = Истина
печать (s2 == s3)
#выход = Ложь
 

Оператор возвращает True и False соответственно. Также обратите внимание, что идентификатор s1 и s2 идентичен.

Однако имейте в виду, что функция Id вернет другой номер в зависимости от вашего компилятора.

Использование «!=»

!= — это еще один оператор сравнения строк Python, который проверяет, не равны ли значения операндов. Он выполняет операцию, противоположную оператору == . Фрагмент кода ниже является реализацией того же самого.

 s1 = 'гибкий!'
s2 = 'гибкий!'
s3 = «гибкий»
печать (s1! = s2)
#Вывод = Ложь
печать (s2! = s3)
#Вывод = Истина
 

Сравнение строк Python с использованием «есть» и «не является»

— это и 9Операторы 0162 not is очень похожи на == и != соответственно. Однако, в отличие от реляционных операторов, — это , а — это не . Сравнивается с идентификатором (id) объектов и возвращает true , если они имеют один и тот же идентификатор.

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

Это то, что вы должны иметь в виду, используя для сравнения оператор — это , а — это не .

Использование «is»:

 s1 = 'гибкий!'
s2 = 'гибкий!'
s3 = «гибкий»
печать (s1 есть s2)
#выход = Истина
печать (s2 есть s3)
#выход = Ложь
 

Использование «не»:

 s1 = 'гибкий!'
s2 = 'гибкий!'
s3 = «гибкий»
напечатать (s1 не s2)
#выход = Ложь
печать (s2 не s3)
#выход = Истина
 

Теперь давайте посмотрим, как меняется Identity (id) при изменении значения.

 s1 = 'гибкий!'
печать (идентификатор (s1))
# Выход = 2621679855024
s2 = 'гибкий!'
печать (идентификатор (s2))
# Выход = 2621679855024
#Теперь обновим s1
s1 = «гибкий»
печать (идентификатор (s1))
# Вывод - 2621680032944
 

Когда значение s1 изменяется, s2 немедленно перестает ссылаться на s1 и получает новый идентификатор.