How to Compare Two Strings in Python (in 8 Easy Ways)
A guide on how to check if two strings are equal, or similar. Learn how to find the difference between two strings. Make complex comparisons and more!
Play this article
Comparing strings is a fundamental task common to any programming language.
When it comes to Python, there are several ways of doing it. The best one will always depend on the use case, but we can narrow them down to a few that best fit this goal.
In this article, we’ll do exactly that.
By the end of this tutorial, you’ll have learned:
Comparing strings using the == and != operators
The simplest way to check if two strings are equal in Python is to use the == operator. And if you are looking for the opposite, then != is what you need. That’s it!
== and != are boolean operators, meaning they return True or False . For example, == returns True if the two strings match, and False otherwise.
These operators are also case sensitive, which means uppercase letters are treated differently. The example below shows just that, city starts with an uppercase L whereas capital starts with a lowercase l . As a result, Python returns False when comparing them with == .
Comparing strings using the is operator
Another way of comparing if two strings are equal in Python is using the is operator. However, the kind of comparison it performs is different than == . The is operator compare if the 2 string are the same instance.
In Python—and in many other languages—we say two objects are the same instance if they are the same object in memory.
The image below shows how this example would be represented in memory.
As you see, we’re comparing identities, not content. Objects with the same identity usually have the same references, and share the same memory location. Keep that in mind when using the is operator.
Comparing strings using the <, >, <=, and >= operators
The third way of comparing strings is alphabetically. This is useful when we need to determine the lexicographical order of two strings.
Let’s see an example.
To determine the order, Python compares the strings char by char. In our example, the first three letters are the same mar , but the next one is not, c from marcus comes before i from maria .
It’s important to have in mind that this comparisons are case-sensitive. Python treats upper-case and lower-case differently. For example, if we change «maria» to «Maria» , then the result is different because M comes before m .
⚠️ WARNING ⚠️: Avoid comparing strings that represent numbers using these operators. The comparison is done based on alphabetical ordering, which causes «2» < «10» to evaluated to False .
Compare two strings by ignoring the case
Sometimes we may need to compare two strings—a list of strings, or even a dictionary of strings—regardless of the case.
Achieving that will depend on the alphabet we’re dealing with. For ASCII strings, we can either convert both strings to lowercase using str.lower() , or uppercase with str.upper() and compare them.
For other alphabets, such as Greek or German, converting to lowercase to make the strings case insensitive doesn’t always work. Let’s see some examples.
Suppose we have a string in German named ‘Straße’ , which means «Street» . You can also write the same word without the ß , in this case, the word becomes Strasse . If we try to lowercase it, or uppercase it, see what happens.
That happens because a simple call to str.lower() won’t do anything to ß . Its lowercase form is equivalent to ss but ß itself has the same form and shape in lower or upper case.
The best way to ignore case and make effective case insensitive string comparisons is to use str.casefold . According to the docs:
Casefolding is similar to lowercasing but more aggressive because it is intended to remove all case distinctions in a string.
Let’s see what happens when we use str.casefold instead.
How to compare two strings and ignore whitespace
Sometimes you might want to compare two strings by ignoring space characters. The best solution for this problem depends on where the spaces are, whether there are multiple spaces in the string and so on.
The first example we’ll see consider that the only difference between the strings is that one of them have leading and/or trailing spaces. In this case, we can trim both strings using the str.strip method and use the == operator to compare them.
However, sometimes you have a string with whitespaces all over it, including multiple spaces inside it. If that is the case, then str.strip is not enough.
The alternative then is to remove the duplicate whitespaces using a regular expression. This method only returns duplicated chars, so we still need to strip the leading and trailing ones.
Or if you don’t care about duplicates and want to remove everything, then just pass the empty string as the second argument to re.sub .
The last and final method is to use a translation table. This solution is an interesting alternative to regex.
A nice thing about this method is that it allows removing not only spaces but other chars such as punctuation as well.
How to compare two strings for similarity (fuzzy string matching)
Another popular string comparison use case is checking if two strings are almost equal. In this task, we’re interested in knowing how similar they are instead of comparing their equality.
To make it easier to understand, consider a scenario when we have two strings and we are willing to ignore misspelling errors. Unfortunately, that’s not possible with the == operator.
We can solve this problem in two different ways:
- using the difflib from the standard library
- using an external library such as jellysifh
Using difflib
The difflib in the standard library has a SequenceMatcher class that provides a ratio() method that returns a measure of the string’s similarity as a percentage.
Suppose you have two similar strings, say a = «preview» , and b = «previeu» . The only difference between them is the final letter. Let’s imagine that this difference is small enough for you and you want to ignore it.
By using SequenceMatcher.ratio() we can get the percentage in which they are similar and use that number to assert if the two strings are similar enough.
In this example, SequenceMatcher tells us that the two strings are 85% similar. We can then use this number as a threshold and ignore the difference.
There’s one problem, though. The threshold depends on the length of the string. For example, two very small strings, say a = «ab» and b = «ac» will be 50% different.
So, setting up a decent threshold may be tricky. As an alternative, we can try another algorithm, one that the counts transpositions of letters in a string. And the good new is, such an algorithm exists, and that’s what we’ll see next.
Using Damerau-Levenshtein distance
The Damerau-Levenshtein algorithm counts the minimum number of operations needed to change one string into another.
In another words, it tells how many insertions, deletions or substitutions of a single character; or transposition of two adjacent characters we need to perform so that the two string become equal.
In Python, we can use the function damerau_levenshtein_distance from the jellysifh library.
Let’s see what the Damerau-Levenshtein distance is for the last example from the previous section.
It’s 1! So that means to transform «ac» into «ab» we need 1 change. What about the first example?
It’s 1 too! And that makes lots of sense, after all we just need to edit the last letter to make them equal.
This way, we can set the threshold based on number of changes instead of ratio.
How to compare two strings and return the difference
Sometimes we know in advance that two strings are different and we want to know what makes them different. In other words, we want to obtain their «diff».
In the previous section, we used difflib as a way of telling if two strings were similar enough. This module is actually more powerful than that, and we can use it to compare the strings and show their differences.
The annoying thing is that it requires a list of strings instead of just a single string. Then it returns a generator that you can use to join into a single string and print the difference.
String comparison not working?
In this section, we’ll discuss the reasons why your string comparison is not working and how to fix it. The two main reasons based on my experience are:
- using the wrong operator
- having a trailing space or newline
Comparing strings using is instead of ==
This one is very common amongst novice Python developers. It’s easy to use the wrong operator, especially when comparing strings.
As we’ve discussed in this article, only use the is operator if you want to check if the two string are the same instances.
Having a trailing whitespace of newline ( \n )
This one is very common when reading a string from the input function. Whenever we use this function to collect information, the user might accidentally add a trailing space.
If you store the result from the input in a variable, you won’t easily see the problem.
The solution here is to strip the whitespace from the string the user enters and then compare it. You can do it to whatever input source you don’t trust.
Conclusion
In this guide, we saw 8 different ways of comparing strings in Python and two most common mistakes. We saw how we can leverage different operations to perform string comparison and how to use external libraries to do string fuzzy matching.
- Use the == and != operators to compare two strings for equality
- Use the is operator to check if two strings are the same instance
- Use the < , > , <= , and >= operators to compare strings alphabetically
- Use str.casefold() to compare two string ignoring the case
- Trim strings using native methods or regex to ignore whitespaces when performing string comparison
- Use difflib or jellyfish to check if two strings are almost equal (fuzzy matching)
- Use difflib to to compare two strings and return the difference
- String comparison is not working? Check for trailing or leading spaces, or understand if you are using the right operator for the job
That’s it for today, and I hope you learned something new. See you next time!
Условия (if, else, elif) и операторы сравнения
На прошлом занятии мы научились выводить данные с помощью функции print() . Например, чтобы вывести число 5 на экран нужно написать в интерпретаторе print(5) , и он сделает свое дело.
Но что, если нужно что-то ввести в программу из внешнего мира? Например, если наш самописный калькулятор умеет складывать 2 числа и выводить ответ, то как ввести эти самые 2 числа? На помощь придет функция input() . Попробуем написать вышеописанный калькулятор.
Функции input() можно передать в качестве аргумента строку, которую увидит пользователь перед вводом.
Как видно из примера, что-то пошло не так. Вместо заветных 46 после сложения 12 и 34 мы получили 1234. Все дело в типах данных. Функция input() всегда считывает данные в виде строки. Так и в примере она считала 12 и 34 как 2 строки и просто «слепила» их вместе. Мы же хотим складывать числа. Чтобы все работало хорошо, нужно выполнить преобразование типов данных.
В данном случае можно сделать вот так:
То, чего мы и хотели.
Преобразовывать можно не только строку в целое число, но и наоборот. Вот несколько допустимых преобразований:
В примерах мы используем функцию type() . Как должно быть понятно из её названия, она выясняет тип переменной. Возвращает она что-то страшное вида <class ‘str’> . Сейчас не стоит вникать почему так. Нам важно, что преобразование прошло правильно и получился тип str .
Как вы уже поняли, чтобы преобразовать что-то во что-то, надо взять и вызвать функцию, совпадающую по имени с названием типа данных. В нашем примере это str() , int() и float() .
Почему нужно конвертировать строки в числа
Возможно, решая очередную задачу, вы случайно не переведете строки в числа, а программа все равно будет работать. Например, у вас будет такая программа, вычисляющая, какое из 2 введенных чисел больше:
Вы удовлетворитесь ответом и пойдете домой. Но потом выяснится, что если ввести другие 2 числа, то все сломается:
Значит, не все так просто…
Чтобы разобраться в вопросе, нужно знать как сравниваются строки.
Компьютер умеет работать только с одним типом данных — числами. Мы же помимо чисел используем кучу разных типов данных: числа, строки, списки, словари, кортежи (последние 3 будут обсуждаться дальше в курсе). Оказывается, что и они все хранятся и обрабатываются компьютером в виде чисел. Разберемся со строчками.
Когда люди задумались, как можно обрабатывать строки, им прошла в голову простая идея — а давайте создадим единую таблицу, в которой каждому символу поставим в соответствие число. Так появилась таблица ASCII (American standard code for information interchange).
Когда люди стали пользоваться компютером не только в Америке (точнее говоря, не только в англоговорящих странах), то встал вопрос о том, что в таблице не хватает места. Так появились другие таблицы кодировок:
Python версии 3 использует Unicode — кодировку, которая на данный момент включает в себя знаки почти всех письменных языков мира. Emoji в ней, кстати, тоже есть ������������
При сравнении строк, Python переводит все символы строки в числа и производит сравнение чисел.
Если перевести “числовые” строки из примеров выше в списки чисел, то получится:
- ’12’ = [49, 50]
- ’45’ = [52, 53]
- ‘4’ = [52]
- ’30’ = [51, 48]
Когда мы пишем ’12’ < ’45’ , то Python сравнивает числа обоих строк по очереди: 49 < 52 — True , значит строка ’12’ меньше, чем строка ’45’ .
Когда же мы пишем ‘4’ < ’30’ , то Python снова сравнивает числа обоих строк по очереди, но на этот раз получается иначе: 52 < 51 — False и ответ получается ‘4’ > ’30’ , что абсолютно верно с точки зрения сравнения строк, но абсолютный бред с точки зрения сравнения чисел.
Python сравнивает числа по очереди. Если он уже на первом числе может ответить на вопрос “кто больше”, он прекращает сравнение и выдает ответ. Если же строки имеют одинаковую первую букву, то сравниваться они будут по второй и так далее. Такое сравнение называется лексикографическим
Поэтому, если вы работаете с числами, то всегда работайте с ними как с числами, а не как со строками.
Условия
Все рассматриваемые нами ранее программы имели линейную структуру — программа просто выполняла инструкции одну за другой сверху вниз. При этом никаких способов повлиять на ход выполнения у нас не было (разве что только на уровне выводимых на экран параметров). Также важно то, что наши предыдущие программы обязаны были выполнить все инструкции сверху вниз, в противном случае они бы завершались ошибкой.
Теперь предположим, что мы хотим определить абсолютное значение любого числа. Наша программа должна будет напечатать сам x в случае, если он неотрицателен и -x в противном случае. Линейной структурой программы здесь не обойтись*, поэтому нам на помощь приходит инструкция if (если). Вот как это работает в питоне:
На самом деле в python есть функция abs() , с помощью которой можно взять модуль числа. Но в качестве примера использования конструкции if и так хорошо.
Разберем этот кусочек кода. После слова if указывается проверяемое условие (x > 0) , завершающееся двоеточием (это важно). После этого идет блок (последовательность) инструкций, который будет выполнен, если условие истинно. В нашем примере это вывод на экран величины x . Затем идет слово else (иначе), также завершающееся двоеточием (и это важно), и блок инструкций, который будет выполнен, если проверяемое условие неверно. В данном случае будет выведено значение -x .
Обратите особенное внимание на отступы во фрагменте кода выше. Дело в том, что в питоне, для того, чтобы определить, какой именно код выполнить в результате того или иного условия используется как знак двоеточия (в строке с самим условием), так и отступы от левого края строки.
Небольшая ремарка относительно табуляции. Мы используем 4 пробела! В современных текстовых редакторах при нажатии на tab автоматически вставляется 4 пробела. Не надо жать 4 раза кнопку space как вот тут. Никакой войны, никаких табов. Просто 4 пробела.
Во многих других языках вместо отступов используются конструкции, явно указывающие на начало (begin или открывающаяся фигурная скобка в Си) и конец инструкций, связанных с условием (end или закрывающаяся фигурная скобка в Си). Отступы же выполняют примерно ту же роль, но и заодно делают код более читаемым, позволяя читающему быстро понять, какой именно код относится к условию.
Таким образом, условные конструкции в питоне имеют следующий общий вид:
Вторая часть условной конструкции (та, что с else) может и отсутствовать, например так:
Эта программа тоже выведет абсолютное значение x, как и та, что была ранее.
Операторы сравнения
Все операторы сравнения в питоне достаточно интуитивны. Вот список основных:
> — больше. Условие истинно, если то, что слева от знака больше того, что справа.
< — меньше. Условие истинно, если то, что слева от знака меньше того, что справа.
>= — больше либо равно.
<= — меньше либо равно.
== — в точности равно.
!= — не равно.
Вложенные условные инструкции
Условия могут быть вложены одно в другое, чтобы реализовывать еще более сложную логику, например:
Главное, не забывать отступы и двоеточия.
Тип данных bool
Операторы сравнения возвращают значения специального логического типа bool. Значения логического типа могут принимать одно из двух значений: True (истина) или False (ложь) .
Если преобразовать логическое True к типу int , то получится 1 , а преобразование False даст 0 . При обратном преобразовании число 0 преобразуется в False , а любое ненулевое число в True . При преобразовании str в bool пустая строка преобразовывается в False , а любая непустая строка в True .
Рассмотрим несколько примеров:
Обратите внимание, ключевые слова True или False пишутся с большой буквы. Если написать их с маленькой, то python подумает, что это переменная, попытается её найти и сломается, когда не найдет 🙁 . А если вы вздумаете называть свои переменные false или true , то сдать зачет по курсу вам не светит 🙂 . Учитесь сразу хорошему стилю программирования.
Логические операторы
Если мы хотим проверить два или более условий за раз, мы можем воспользоваться операторами and , or или not . Вот как они работают:
and (логическое И) возвращает истину ( True ) только в случае если оба условия по отдельности верны (тоже возвращают True )
or (логическое ИЛИ) вернет истину в случае, если хотя бы одно из условий верно.
not (логическое НЕТ) возьмет результат условия и “обратит” его. То есть, если результат условия True , то not примененный к этому условию вернет False и наоборот.
Давайте посмотрим как это работает на примере. Код ниже проверяет, что хотя бы одно число из двух нацело делится на 10 (кончается на 0) и если так, то печатает YES, а если нет, то печатает NO:
Пусть теперь мы хотим проверить, что числа a и b должны быть еще и обязательно больше нуля:
Как видите, мы можем не только использовать and и or в одном if , но и группировать условия скобками для того, чтобы явно обозначить приоритет вычисления условий.
Посмотрим пример с not . Пусть мы хотим проверить, что число a — положительное, а число b — неотрицательное. Это можно проверить вот таким условием:
Оператор pass очень полезен, когда нужно ничего не делать. Если его не поставить, то будет синтаксическая ошибка. А так, код считается правильным!
Кстати, not (b < 0) можно было бы и заменить на b >= 0 и код бы работал точно так же.
Конструкция elif
Иногда писать конструкции if-else долго и утомительно, особенно если приходится проверять много условий разом. В этом случае на помощь придет elif (сокращение от else if). По сути elif позволяет существенно упростить конструкцию ниже:
И сделать ее вот такой:
Обратите внимание, мы избавились от одного уровня вложенности. То есть, сам код стал более читаемым, но при этом нисколько не проиграл в функциональности. Разумеется, конструкции типа if-elif могут завершиться и блоком else , например так:
Задача: знак числа
В математике есть функция sgn, показывающая знак числа. Она определяется так: если число больше 0, то функция возвращает 1. Если число меньше нуля, то функция возвращает -1. Если число равно 0, то функция возвращает 0. Реализуйте данную функцию — для введенного числа выведите число, определяющее его знак. Используйте операторы сравнения и конструкцию if-elif-else .
Задача: високосный год
Дано натуральное число. Требуется определить, является ли год с данным номером високосным. Если год является високосным, то выведите YES, иначе выведите NO. Напомним, что в соответствии с григорианским календарем, год является високосным, если его номер кратен 4, но не кратен 100, а также если он кратен 400.
Ссылки по теме
Домашнее задание
Вам надо написать на питоне 6 программ, каждая из которых будет спрашивать у пользователя 3 числа (a, b, c) и печатать на экран удовлетворяют ли введенные числа перечисленным свойствам:
Rukovodstvo
статьи и идеи для разработчиков программного обеспечения и веб-разработчиков.
Сравнение строк с использованием Python
В Python строки — это последовательности символов, которые фактически хранятся в памяти как объект. Каждый объект можно идентифицировать с помощью метода id (), как вы можете видеть ниже. Python пытается повторно использовать в памяти объекты с одинаковым значением, что также позволяет очень быстро сравнивать объекты в Python: $ python Python 2.7.9 (по умолчанию, 29 июня 2016 г., 13:08:31) [GCC 4.9.2] на linux2 Введите «help», «copyright», «credits» или «license» для получения дополнительной информации. >>> a = "abc" >>> b = "abc" >>> c = "def" >>> печать
Время чтения: 6 мин.
В Python строки — это последовательности символов, которые фактически хранятся в памяти как объект. Каждый объект можно идентифицировать с помощью id() , как вы можете видеть ниже. Python пытается повторно использовать объекты в памяти с одинаковым значением, что также позволяет очень быстро сравнивать объекты в Python:
Для сравнения строк Python предлагает несколько разных операторов. Сначала мы объясним их более подробно ниже. Во-вторых, мы рассмотрим как string и re , которые содержат методы для обработки неточных совпадений без учета регистра. В-третьих, для работы с многострочными строками очень удобен модуль difflib . Ряд примеров поможет вам понять, как их использовать.
Операторы == и! =
В качестве основного оператора сравнения вы захотите использовать == и != . Они работают точно так же, как и с целыми числами и значениями с плавающей запятой. Оператор == возвращает True если есть точное совпадение, в противном случае будет возвращено False Напротив, оператор != True если совпадений нет, а в противном случае возвращает False . Листинг 1 демонстрирует это.
В for строка, содержащая название швейцарского города «Лозанна», сравнивается с записью из списка других мест, и результат сравнения выводится на стандартный вывод.
Запустив сценарий Python сверху, вы получите следующий результат:
Операторы == и is
Python имеет два оператора сравнения == и is . На первый взгляд они кажутся одинаковыми, но на самом деле это не так. == сравнивает две переменные на основе их фактического значения. Напротив, is сравнивает две переменные на основе идентификатора объекта и возвращает True если две переменные относятся к одному и тому же объекту.
Следующий пример демонстрирует это для трех переменных с целыми значениями. Две переменные a и b имеют одинаковое значение, и Python обращается к одному и тому же объекту, чтобы минимизировать использование памяти.
Как только значение изменится, Python повторно создаст объект и назначит переменную. В следующем фрагменте кода b получает значение 2, а затем b и c относятся к одному и тому же объекту.
Эмпирическое правило , которому надо следовать , чтобы использовать == при сравнении неизменных типов (например , Интс) и is при сравнении объектов.
Дополнительные операторы сравнения
Для сравнения лексикографического порядка вы можете использовать операторы сравнения < , > , <= и >= . Само сравнение проводится посимвольно. Порядок зависит от порядка символов в алфавите. Этот порядок зависит от таблицы символов, которая используется на вашем компьютере при выполнении кода Python.
Имейте в виду, что порядок чувствителен к регистру. Например, латинский алфавит: «Автобус» стоит перед «автобусом». В листинге 2 показано, как эти операторы сравнения работают на практике.
Запустив сценарий Python сверху, вы получите следующий результат:
Сравнение без учета регистра
В предыдущих примерах основное внимание уделялось точному совпадению строк. Чтобы позволить сравнения без учета регистра, Python предлагает специальные строковые методы, такие как upper() и lower() . Оба они напрямую доступны как методы соответствующего строкового объекта.
upper() преобразует всю строку в прописные буквы, а lower() в строчные буквы соответственно. В следующем листинге, основанном на листинге 1, показано, как использовать метод lower() .
Результат выглядит следующим образом:
Использование регулярного выражения
Регулярное выражение — или для краткости «регулярное выражение» — определяет определенный шаблон символов. Что касается этой темы, Джеффри Фридл написал отличную книгу под названием « Освоение регулярных выражений» <.amazon-link>, которую я очень рекомендую.
Чтобы использовать этот механизм в Python, сначала импортируйте модуль re, а затем определите конкретный шаблон. Опять же, следующий пример основан на листинге 1 . Шаблон поиска соответствует «заливу» и начинается со строчной или прописной буквы. А именно, следующий код Python находит все строки, в которых встречается шаблон поиска, независимо от того, в какой позиции строки — в начале, в середине или в конце.
Результат выглядит следующим образом и соответствует "Bayswater", "Table Bay" и "Bombay" из списка мест:
Многострочные и списковые сравнения
Пока что наши сравнения касались лишь нескольких слов. Использование difflib Python также предлагает способ сравнения многострочных строк и целых списков слов. Вывод может быть настроен в соответствии с различными форматами инструментов сравнения.
Следующий пример ( листинг 5 ) сравнивает две многострочные строки построчно и показывает как удаления, так и добавления. После инициализации Differ в строке 12 сравнение выполняется с помощью compare() в строке 15. Результат выводится на стандартный вывод (строка 18).
Запуск сценария создает результат, как показано ниже. Строки с удалениями обозначаются — тогда как строки с добавлением начинаются со знака + Кроме того, строки с изменениями начинаются с вопросительного знака. Изменения обозначаются ^ в соответствующей позиции. Линии без индикатора все те же.
Заключение
В этой статье вы узнали о различных способах сравнения строк в Python. Мы надеемся, что этот обзор поможет вам эффективно программировать в жизни вашего разработчика.
How To Compare Strings in Python
You can compare strings in Python using the equality ( == ) and comparison ( < , > , != , <= , >= ) operators. There are no special methods to compare two strings. In this article, you’ll learn how each of the operators work when comparing strings.
Python string comparison compares the characters in both strings one by one. When different characters are found, then their Unicode code point values are compared. The character with the lower Unicode value is considered to be smaller.
Python Equality and Comparison Operators
Declare the string variable:
The following table shows the results of comparing identical strings ( Apple to Apple ) using different operators.
| Operator | Code | Output |
|---|---|---|
| Equality | print(fruit1 == ‘Apple’) | True |
| Not equal to | print(fruit1 != ‘Apple’) | False |
| Less than | print(fruit1 < ‘Apple’) | False |
| Greater than | print(fruit1 > ‘Apple’) | False |
| Less than or equal to | print(fruit1 <= ‘Apple’) | True |
| Greater than or equal to | print(fruit1 >= ‘Apple’) | True |
Both the strings are exactly the same. In other words, they’re equal. The equality operator and the other equal to operators return True .
If you compare strings of different values, then you get the exact opposite output.
If you compare strings that contain the same substring, such as Apple and ApplePie , then the longer string is considered larger.
Comparing User Input to Evaluate Equality Using Operators
This example code takes and compares input from the user. Then the program uses the results of the comparison to print additional information about the alphabetical order of the input strings. In this case, the program assumes that the smaller string comes before the larger string.
Here’s an example of the potential output when you enter different values:
Here’s an example of the potential output when you enter identical strings:
Note: For this example to work, the user needs to enter either only upper case or only lower case for the first letter of both input strings. For example, if the user enters the strings apple and Banana , then the output will be apple comes after Banana in the dictionary , which is incorrect.
This discrepancy occurs because the Unicode code point values of uppercase letters are always smaller than the Unicode code point values of lowercase letters: the value of a is 97 and the value of B is 66. You can test this yourself by using the ord() function to print the Unicode code point value of the characters.
Conclusion
In this article you learned how to compare strings in Python using the equality ( == ) and comparison ( < , > , != , <= , >= ) operators. Continue your learning about Python strings.
Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.