Сравнение строк в 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».