Как сравнивать строки в R (3 примера)


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

Способ 1: сравнить две строки

#case-sensitive comparison
string1 == string2
#case-insensitive comparison
tolower (string1) == tolower (string2)

Метод 2: сравнение двух векторов строк

#case-sensitive comparison
identical(vector1, vector2)
#case-insensitive comparison
identical( tolower (vector1), tolower (vector2))

Метод 3: найти сходство между двумя векторами строк

#find which strings in vector1 are also in vector2
vector1[vector1 %in% vector2]

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

Пример 1. Проверка идентичности двух векторов

В следующем коде показано, как сравнить две строки в R, чтобы определить, равны ли они:

#define two strings
string1 <- "Mavericks"
string2 <- "mavericks"
#case-sensitive comparison
string1 == string2
[1] FALSE
#case-insensitive comparison
tolower (string1) == tolower (string2)
[1] TRUE

Сравнение с учетом регистра возвращает значение FALSE , поскольку две строки не полностью идентичны.

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

Пример 2: сравнение двух векторов строк

В следующем коде показано, как использовать функцию идентичных() , чтобы определить, равны ли два вектора строк:

#define two vectors of strings
vector1 <- c("hey", "hello", "HI")
vector2 <- c("hey", "hello", "hi")
#case-sensitive comparison
identical(vector1, vector2)
[1] FALSE
#case-insensitive comparison
identical( tolower (vector1), tolower (vector2))
[1] TRUE

Сравнение с учетом регистра возвращает значение FALSE , поскольку два вектора не содержат одинаковых строк в одном и том же регистре.

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

Пример 3. Поиск сходства между двумя векторами строк

В следующем коде показано, как использовать оператор %in% , чтобы определить, какие строки в одном векторе принадлежат другому вектору:

#define two vectors of strings
vector1 <- c("hey", "hello", "greetings")
vector2 <- c("hey", "hello", "hi")
#find which strings in vector1 are also in vector2
vector1[vector1 %in% vector2]
[1] "hey" "hello"

Из вывода мы видим, что строки «привет» и «привет» существуют как в векторе1, так и в векторе2.

Связанный: Как использовать оператор %in% в R

Дополнительные ресурсы

В следующих руководствах объясняется, как выполнять другие распространенные операции в R:

Как сравнить два столбца в R
Как сравнить два вектора в R
Как найти расположение символа в строке в R
Как преобразовать вектор в строку в R

2 — Условия и операторы сравнения


Содержание

  1. Ввод данных и преобразование типов
  2. Почему нужно конвертировать строки в числа
  3. Условия
  4. Операторы сравнения
  5. Вложенные условные инструкции
  6. Тип данных bool
  7. Логические операторы
  8. Конструкция elif
  9. Задачи
    1. Знак числа
    2. Високосный год
  10. Ссылки по теме
  11. Домашнее задание

Ввод данных и преобразования типов

На прошлом занятии мы научились выводить данные с помощью функции

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 <class 'float'>
>>> b**2
2055.7156000000004
>>> # Преобразовать строку с НЕ числом в число не получится
>>> a = 'python'
>>> b = int(a)
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    b = int(a)
ValueError: invalid literal for int() with base 10: 'python'

В примерах мы используем функцию type(). Как должно быть понятно из её названия, она выясняет тип переменной. Возвращает она что-то страшное вида

<class 'str'>. Сейчас не стоит вникать почему так. Нам важно, что преобразование прошло правильно и получился тип 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).

Когда люди стали пользоваться компютером не только в Америке (точнее говоря, не только в англоговорящих странах), то встал вопрос о том, что в таблице не хватает места. Так появились другие таблицы кодировок:

  • Windows-1251
  • КОИ-8
  • ISO-8859
  • Юникод
  • и множество других…

Python версии 3 использует Unicode — кодировку, которая на данный момент включает в себя знаки почти всех письменных языков мира. Emoji в ней, кстати, тоже есть 😀😃😇👩‍💻🐁

При сравнении строк, Python переводит все символы строки в числа и производит сравнение чисел.

Если перевести “числовые” строки из примеров выше в списки чисел, то получится:

  • '12' = [49, 50]
  • '45' = [52, 53]
  • '4' = [52]
  • '30' = [51, 48]

Когда мы пишем '12' < '45', то Python сравнивает числа обоих строк по очереди: 49 < 52True, значит строка '12' меньше, чем строка '45'.

Когда же мы пишем '4' < '30', то Python снова сравнивает числа обоих строк по очереди, но на этот раз получается иначе:

52 < 51False и ответ получается '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 "<pyshell#32>", 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) и печатать на экран удовлетворяют ли введенные числа перечисленным свойствам:

  1. a и b в сумме дают c
  2. a умножить на b равно c
  3. a даёт остаток c при делении на b
  4. c является решением линейного уравнения ax + b = 0
  5. a разделить на b равно c
  6. a в степени b равно c

Оформите каждую программу в виде отдельного файла с расширением .