Как сравнить строки в 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.
Применение операторов «больше или равно/меньше или равно»
print("abc"В нашем случае «abc» меньше.
Аналогично работает и оператор >= :
print("abc" >= "abc") TrueВ этой ситуации очевидно, что строки равны.
Условия (if, else, elif) и операторы сравнения
На прошлом занятии мы научились выводить данные с помощью функции print() . Например, чтобы вывести число 5 на экран нужно написать в интерпретаторе print(5) , и он сделает свое дело.
Но что, если нужно что-то ввести в программу из внешнего мира? Например, если наш самописный калькулятор умеет складывать 2 числа и выводить ответ, то как ввести эти самые 2 числа? На помощь придет функция input() . Попробуем написать вышеописанный калькулятор.
Функции input() можно передать в качестве аргумента строку, которую увидит пользователь перед вводом.
>>> a = input('Введите число a: ') Введите число a: 56 >>> b = input('Введите число b: ') Введите число b: 23 >>> print(a + b) 5623
Как видно из примера, что-то пошло не так. Вместо заветных 46 после сложения 12 и 34 мы получили 1234. Все дело в типах данных. Функция input() всегда считывает данные в виде строки. Так и в примере она считала 12 и 34 как 2 строки и просто «слепила» их вместе. Мы же хотим складывать числа. Чтобы все работало хорошо, нужно выполнить преобразование типов данных.
В данном случае можно сделать вот так:
>>> a = int(input('Введите число a: ')) Введите число a: 56 >>> b = (input('Введите число b: ')) Введите число b: 23 >>> print(a + b) 79
То, чего мы и хотели.
Преобразовывать можно не только строку в целое число, но и наоборот. Вот несколько допустимых преобразований:
>>> # Преобразование числа в строку >>> a = 34 >>> b = str(a) >>> print('Преобразованное число:', b, ', его тип:', type(b)) Преобразованное число: 34 , его тип: class 'str'>
>>> # Преобразование строки в число с плавающей точкой >>> a = '45.34' >>> b = float(a) >>> print(a, type(a)) 45.34 class 'str'> >>> print(b, type(b)) 45.34 float'> >>> b**2 2055.7156000000004
>>> # Преобразовать строку с НЕ числом в число не получится >>> a = 'python' >>> b = int(a) Traceback (most recent call last): File "", line 1, in module> b = int(a) ValueError: invalid literal for int() with base 10: 'python'
В примерах мы используем функцию type() . Как должно быть понятно из её названия, она выясняет тип переменной. Возвращает она что-то страшное вида . Сейчас не стоит вникать почему так. Нам важно, что преобразование прошло правильно и получился тип str .
Как вы уже поняли, чтобы преобразовать что-то во что-то, надо взять и вызвать функцию, совпадающую по имени с названием типа данных. В нашем примере это str() , int() и float() .
Почему нужно конвертировать строки в числа
Возможно, решая очередную задачу, вы случайно не переведете строки в числа, а программа все равно будет работать. Например, у вас будет такая программа, вычисляющая, какое из 2 введенных чисел больше:
>>> a = input('Введите целое число:') Введите целое число:12 >>> b = input('Введите целое число:') Введите целое число:45 >>> if a > b: . print('Большее число:', a) . else: . print('Большее число:', b) Большее число: 45
Вы удовлетворитесь ответом и пойдете домой. Но потом выяснится, что если ввести другие 2 числа, то все сломается:
>>> a = input('Введите целое число:') Введите целое число:4 >>> b = input('Введите целое число:') Введите целое число:30 >>> if a > b: . print('Большее число:', a) . else: . print('Большее число:', b) Большее число: 4
Значит, не все так просто…
Чтобы разобраться в вопросе, нужно знать как сравниваются строки.
Компьютер умеет работать только с одним типом данных - числами. Мы же помимо чисел используем кучу разных типов данных: числа, строки, списки, словари, кортежи (последние 3 будут обсуждаться дальше в курсе). Оказывается, что и они все хранятся и обрабатываются компьютером в виде чисел. Разберемся со строчками.
Когда люди задумались, как можно обрабатывать строки, им прошла в голову простая идея - а давайте создадим единую таблицу, в которой каждому символу поставим в соответствие число. Так появилась таблица ASCII (American standard code for information interchange).
Когда люди стали пользоваться компютером не только в Америке (точнее говоря, не только в англоговорящих странах), то встал вопрос о том, что в таблице не хватает места. Так появились другие таблицы кодировок:
Python версии 3 использует Unicode - кодировку, которая на данный момент включает в себя знаки почти всех письменных языков мира. Emoji в ней, кстати, тоже есть
При сравнении строк, Python переводит все символы строки в числа и производит сравнение чисел.
Если перевести “числовые” строки из примеров выше в списки чисел, то получится:
- '12' = [49, 50]
- '45' = [52, 53]
- '4' = [52]
- '30' = [51, 48]
Когда же мы пишем '4' < '30' , то Python снова сравнивает числа обоих строк по очереди, но на этот раз получается иначе: 52 < 51 - False и ответ получается '4' >'30' , что абсолютно верно с точки зрения сравнения строк, но абсолютный бред с точки зрения сравнения чисел.
Python сравнивает числа по очереди. Если он уже на первом числе может ответить на вопрос “кто больше”, он прекращает сравнение и выдает ответ. Если же строки имеют одинаковую первую букву, то сравниваться они будут по второй и так далее. Такое сравнение называется лексикографическим
Поэтому, если вы работаете с числами, то всегда работайте с ними как с числами, а не как со строками.
Условия
Все рассматриваемые нами ранее программы имели линейную структуру — программа просто выполняла инструкции одну за другой сверху вниз. При этом никаких способов повлиять на ход выполнения у нас не было (разве что только на уровне выводимых на экран параметров). Также важно то, что наши предыдущие программы обязаны были выполнить все инструкции сверху вниз, в противном случае они бы завершались ошибкой.
Теперь предположим, что мы хотим определить абсолютное значение любого числа. Наша программа должна будет напечатать сам x в случае, если он неотрицателен и -x в противном случае. Линейной структурой программы здесь не обойтись*, поэтому нам на помощь приходит инструкция if (если). Вот как это работает в питоне:
>>> # Ввод данных с преобразованием типа >>> x = int(input()) >>> >>> if x > 0: . print(x) >>> else: . print(-x)
На самом деле в python есть функция abs() , с помощью которой можно взять модуль числа. Но в качестве примера использования конструкции if и так хорошо.
Разберем этот кусочек кода. После слова if указывается проверяемое условие (x > 0) , завершающееся двоеточием (это важно). После этого идет блок (последовательность) инструкций, который будет выполнен, если условие истинно. В нашем примере это вывод на экран величины x . Затем идет слово else (иначе), также завершающееся двоеточием (и это важно), и блок инструкций, который будет выполнен, если проверяемое условие неверно. В данном случае будет выведено значение -x .
Обратите особенное внимание на отступы во фрагменте кода выше. Дело в том, что в питоне, для того, чтобы определить, какой именно код выполнить в результате того или иного условия используется как знак двоеточия (в строке с самим условием), так и отступы от левого края строки.
Небольшая ремарка относительно табуляции. Мы используем 4 пробела! В современных текстовых редакторах при нажатии на tab автоматически вставляется 4 пробела. Не надо жать 4 раза кнопку space как вот тут. Никакой войны, никаких табов. Просто 4 пробела.
Во многих других языках вместо отступов используются конструкции, явно указывающие на начало (begin или открывающаяся фигурная скобка в Си) и конец инструкций, связанных с условием (end или закрывающаяся фигурная скобка в Си). Отступы же выполняют примерно ту же роль, но и заодно делают код более читаемым, позволяя читающему быстро понять, какой именно код относится к условию.
Таким образом, условные конструкции в питоне имеют следующий общий вид:
if Условие: блок инструкций, в случае если условие истинно else: блок инструкций, в случае если условие не выполняется
Вторая часть условной конструкции (та, что с else) может и отсутствовать, например так:
>>> x = int(input()) >>> >>> if x 0: . x = -x . >>> print(x)
Эта программа тоже выведет абсолютное значение x, как и та, что была ранее.
Операторы сравнения
Все операторы сравнения в питоне достаточно интуитивны. Вот список основных:
> - больше. Условие истинно, если то, что слева от знака больше того, что справа.
< - меньше. Условие истинно, если то, что слева от знака меньше того, что справа.
>= - больше либо равно.
== - в точности равно.
!= - не равно.
Вложенные условные инструкции
Условия могут быть вложены одно в другое, чтобы реализовывать еще более сложную логику, например:
>>> a = int(input()) >>> b = int(input()) >>> >>> if a > 0: . if b > 0: . print("a, b > 0") . else: . print("a > 0, b < 0") . else: . if b > 0: . print("a, b < 0") . else: . print("a < 0, b >0") .
Главное, не забывать отступы и двоеточия.
Тип данных bool
Операторы сравнения возвращают значения специального логического типа bool. Значения логического типа могут принимать одно из двух значений: True (истина) или False (ложь) .
Если преобразовать логическое True к типу int , то получится 1 , а преобразование False даст 0 . При обратном преобразовании число 0 преобразуется в False , а любое ненулевое число в True . При преобразовании str в bool пустая строка преобразовывается в False , а любая непустая строка в True .
Рассмотрим несколько примеров:
>>> # Сравнение строки >>> name = input('Введите своё имя:') >>> if name != '': >>> print('Привет,', name) >>> else: >>> print('Вы не ввели своё имя!')
>>> # Преобразование bool к int >>> print(int(True)) 1 >>> print(int(False)) 0
Обратите внимание, ключевые слова True или False пишутся с большой буквы. Если написать их с маленькой, то python подумает, что это переменная, попытается её найти и сломается, когда не найдет 🙁 . А если вы вздумаете называть свои переменные false или true , то сдать зачет по курсу вам не светит 🙂 . Учитесь сразу хорошему стилю программирования.
>>> # Преобразование bool к int >>> print(int(true)) Traceback (most recent call last): File "", line 1, in module> print(int(true)) NameError: name 'true' is not defined
Логические операторы
Если мы хотим проверить два или более условий за раз, мы можем воспользоваться операторами and , or или not . Вот как они работают:
and (логическое И) возвращает истину ( True ) только в случае если оба условия по отдельности верны (тоже возвращают True )
or (логическое ИЛИ) вернет истину в случае, если хотя бы одно из условий верно.
not (логическое НЕТ) возьмет результат условия и “обратит” его. То есть, если результат условия True , то not примененный к этому условию вернет False и наоборот.
Давайте посмотрим как это работает на примере. Код ниже проверяет, что хотя бы одно число из двух нацело делится на 10 (кончается на 0) и если так, то печатает YES, а если нет, то печатает NO:
>>> a = int(input()) >>> b = int(input()) >>> >>> if a % 10 == 0 or b % 10 == 0: . print('YES') . else: . print('NO') .
Пусть теперь мы хотим проверить, что числа a и b должны быть еще и обязательно больше нуля:
>>> a = int(input()) >>> b = int(input()) >>> >>> if (a % 10 == 0 and a > 0) or (b % 10 == 0 and b > 0): . print('YES') . else: . print('NO') .
Как видите, мы можем не только использовать and и or в одном if , но и группировать условия скобками для того, чтобы явно обозначить приоритет вычисления условий.
Посмотрим пример с not . Пусть мы хотим проверить, что число a - положительное, а число b - неотрицательное. Это можно проверить вот таким условием:
>>> if a > 0 and not (b 0): . pass .
Оператор pass очень полезен, когда нужно ничего не делать. Если его не поставить, то будет синтаксическая ошибка. А так, код считается правильным!
Кстати, not (b < 0) можно было бы и заменить на b >= 0 и код бы работал точно так же.
Конструкция elif
Иногда писать конструкции if-else долго и утомительно, особенно если приходится проверять много условий разом. В этом случае на помощь придет elif (сокращение от else if). По сути elif позволяет существенно упростить конструкцию ниже:
>>> if a > 0: . pass . else: . if b > 0: . pass .
И сделать ее вот такой:
>>> if a > 0: . pass . elif b > 0: . pass .
Обратите внимание, мы избавились от одного уровня вложенности. То есть, сам код стал более читаемым, но при этом нисколько не проиграл в функциональности. Разумеется, конструкции типа if-elif могут завершиться и блоком else , например так:
>>> if a > 0: . pass . elif b > 0: . pass . elif c > 0: . pass . else: . pass .
Задача: знак числа
В математике есть функция sgn, показывающая знак числа. Она определяется так: если число больше 0, то функция возвращает 1. Если число меньше нуля, то функция возвращает -1. Если число равно 0, то функция возвращает 0. Реализуйте данную функцию — для введенного числа выведите число, определяющее его знак. Используйте операторы сравнения и конструкцию if-elif-else .
>>> x = int(input()) >>> >>> if x > 0: . print(1) . elif x 0: . print(-1) . else: . print(0) .
Задача: високосный год
Дано натуральное число. Требуется определить, является ли год с данным номером високосным. Если год является високосным, то выведите YES, иначе выведите NO. Напомним, что в соответствии с григорианским календарем, год является високосным, если его номер кратен 4, но не кратен 100, а также если он кратен 400.
>>> year = int(input()) >>> if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0): . print('YES') . else: . print('NO') .
Ссылки по теме
- http://pythontutor.ru/lessons/ifelse/
- http://pythonicway.com/python-conditionals
Домашнее задание
Вам надо написать на питоне 6 программ, каждая из которых будет спрашивать у пользователя 3 числа (a, b, c) и печатать на экран удовлетворяют ли введенные числа перечисленным свойствам:
- a и b в сумме дают c
- a умножить на b равно c
- a даёт остаток c при делении на b
- c является решением линейного уравнения ax + b = 0
- a разделить на b равно c
- a в степени b равно c
Оформите каждую программу в виде отдельного файла с расширением .py .
Сравнить число с каждым элементом списка
Надо сравнить сравнить с каждым элементом списка 26 с каждым из 27, 22, 15, 8, 3, 16, 15 52 с каждым из 12, 4, 10, 13, 29, 22, 121 и так далее. Подскажите алгоритм.
Отслеживать
149k 12 12 золотых знаков 59 59 серебряных знаков 132 132 бронзовых знака
задан 12 янв 2022 в 13:31
KAmerad KAmerad KAmerad KAmerad
53 5 5 бронзовых знаков
сравнить с каждым элементом списка
12 янв 2022 в 13:34
for x,y in zip(complaint_stat, week_avg): for z in x: # сравниваем z и y
12 янв 2022 в 13:34
Вы какой результат хотите получить? набор булевых значений? использование модуля numpy вас устроит?
12 янв 2022 в 14:08
5 ответов 5
Сортировка: Сброс на вариант по умолчанию
Можно сделать так:
import numpy as np complaint_stat = [ [27, 22, 15, 8, 3, 16, 15], [12, 4, 10, 13, 29, 22, 121], [5, 7, 6, 13, 2, 1, 25], [15, 6, 14, 19, 25, 7, 3] ] week_avg = [26, 52, 14, 22] a = np.array(complaint_stat) for i in week_avg: print(np.signbit(a-i))
в итоге вы получите четыре массива (по количеству элементов в week_avg, в булевыми значениями, в данном примере, если число из списка week_avg больше complaint_stat, то True, иначе - False:
[[False True True True True True True] [ True True True True False True False] [ True True True True True True True] [ True True True True True True True]] [[ True True True True True True True] [ True True True True True True False] [ True True True True True True True] [ True True True True True True True]] [[False False False True True False False] [ True True True True False False False] [ True True True True True True False] [False True False False False True True]] [[False False True True True True True] [ True True True True False False False] [ True True True True True True False] [ True True True True False True True]]
Операторы сравнения
Эти операторы сравнивают два типа значений, они меньше и больше чем операторы. Для чисел это просто сравнивает числовые значения, чтобы увидеть, что больше:
12 > 4 # True 12 < 4 # False 1 < 4 # True
Для строк они будут сравниваться лексикографически, что похоже на алфавитный порядок, но не совсем то же самое.
"alpha" < "beta" # True "gamma" >"beta" # True "gamma" < "OMEGA" # False
"GAMMA" < "OMEGA" # True
Каждый тип определяет это расчет с < и >операторы по- разному, так что вы должны исследовать , что операторы означают с данным типом перед его использованием.
Не равно
x != y
Это возвращает True , если x и y не равны и в противном случае возвращает значение False .
12 != 1 # True 12 != '12' # True '12' != '12' # False
Равно
x == y
Это выражение , если x и y имеют одинаковое значение и возвращает результат как логическое значение. В целом как тип и значение должны совпадать, так что ИНТ 12 не то же самое , как строка '12' .
12 == 12 # True 12 == 1 # False '12' == '12' # True 'spam' == 'spam' # True 'spam' == 'spam ' # False '12' == 12 # False
Обратите внимание, что каждый тип должен определять функцию, которая будет использоваться для оценки, если два значения одинаковы. Для встроенных типов эти функции ведут себя так, как вы ожидаете, и просто оценивают вещи, основываясь на том же значении. Однако пользовательские типы можно определить тестирование равенства , как бы они ни хотели, в том числе всегда возвращаются True или всегда возвращаются False .
Сравнение цепей
Вы можете сравнить несколько элементов с несколькими операторами сравнения с помощью цепочки сравнения. Например
x > y > z
это просто краткая форма:
x > y and y > z
Это позволит оценить, True , только если оба сравнения True .
a OP b OP c OP d .
Где OP представляет один из нескольких операций сравнения , которые можно использовать, а буквы представляют собой произвольные действительные выражения.
Стиль
Нет теоретического ограничения на количество элементов и операций сравнения, если вы используете правильный синтаксис:
1 > -1 < 2 >0.5 < 100 != 24
Вышеприведенные возвращает True , если каждое сравнение возвращает True .Тем не менее, использование замысловатой цепочки не очень хороший стиль. Хорошая цепочка будет «направленной», не более сложной, чем
1 > x > -4 > y != 8
Побочные эффекты
Как только одно сравнение возвращает значение False , выражение сразу вычисляет значение False , пропуская все остальные сравнения.
Отметим , что выражение exp в a > exp > b будет оцениваться только один раз, в то время как в случае
a > exp and exp > b
exp будет вычисляться дважды , если a > exp верно.
Сравнение по `is` vs` == `
Типичная ошибка является запутанными операторы сравнения равенства is и == .
a == b сравнивает значение и a b .
a is b сравнит тождества и a b .
a = 'Python is fun!' b = 'Python is fun!' a == b # returns True a is b # returns False a = [1, 2, 3, 4, 5] b = a # b references a a == b # True a is b # True b = a[:] # b now references a copy of a a == b # True a is b # False [!!]
В принципе, is можно рассматривать как сокращение для id(a) == id(b) .
Помимо этого, существуют особенности среды выполнения, которые еще больше усложняют ситуацию. Короткие строки и небольшие целые числа будут возвращать True , по сравнению с is , из - за машины Python пытается использовать меньше памяти для одинаковых объектов.
a = 'short' b = 'short' c = 5 d = 5 a is b # True c is d # True
Но более длинные строки и большие целые числа будут храниться отдельно.
a = 'not so short' b = 'not so short' c = 1000 d = 1000 a is b # False c is d # False
Вы должны использовать is , чтобы проверить на None :
if myvar is not None: # not None pass if myvar is None: # None pass
Применение по is является проверка на «дозорных» (то есть уникальный объект).
sentinel = object() def myfunc(var=sentinel): if var is sentinel: # value wasn’t provided pass else: # value was provided pass
Сравнение объектов
Для сравнения равенства пользовательских классов, вы можете переопределить == и != Определяя __eq__ и __ne__ методу. Вы также можете переопределить __lt__ ( < ), __le__ ( ), и __ge__ ( > ). Обратите внимание , что вам нужно только переопределить два метода сравнения, и Python может справиться с остальным ( == таким же , как not < и not >, и т.д.)
class Foo(object): def __init__(self, item): self.my_item = item def __eq__(self, other): return self.my_item == other.my_item a = Foo(5) b = Foo(5) a == b # True a != b # False a is b # False
Заметим , что это простое сравнение предполагает , что other объект (объект сравнивается с) имеет тот же тип объекта. Сравнение с другим типом приведет к ошибке:
class Bar(object): def __init__(self, item): self.other_item = item def __eq__(self, other): return self.other_item == other.other_item def __ne__(self, other): return self.other_item != other.other_item c = Bar(5) a == c # throws AttributeError: 'Foo' object has no attribute 'other_item'
Проверка isinstance() или аналогичный поможет предотвратить это (если это необходимо).