Как написать знак принадлежит на питоне

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

• Арифметические операторы
• Операторы сравнения
• Операторы присваивания
• Логические операторы
• Побитовые операторы
• Операторы принадлежности
• Операторы тождества

Арифметические операторы

Арифметические операторы используются для выполнения арифметических операций между двумя операндами. К ним относятся операторы:

• + (сложение),
• - (вычитание),
• * (умножение),
• / (деление),
• % (остаток от деления),
• // (деление нацело)
• ** (возведение в степень).

Подробное описание арифметических операторов приведено в следующей таблице.

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

Операторы сравнения используются для сравнения значений двух операндов и возвращают булеву истину или ложь соответственно. Операторы сравнения описаны в следующей таблице.

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

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

Побитовые операторы

Побитовые операторы выполняют побитовую операцию над значениями двух операндов. Рассмотрим следующий пример.

if a = 7   
   b = 6     
then, binary (a) = 0111    
    binary (b) = 0110    
    
hence, a & b = 0011    
      a | b = 0111    
             a ^ b = 0100    
       ~ a = 1000  

Логические операторы

Операторы принадлежности

Операторы принадлежности в Python используются для проверки существования указанного значения в структуре данных Python. Если значение присутствует в структуре данных, то результирующее значение будет true, в противном случае возвращается false.

Операторы тождества

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

Приоритеты операторов

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

В этом уроке вы узнаете все о разных типах операторов в Python, их синтаксисе и примерах использования.

Что такое операторы

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

Например:

>>> 2+3
5

Здесь оператор + выполняет сложение, 2 и 3 — операнды, а 5 — вывод операции.

Арифметические операторы

Арифметические операторы используются для выполнения математических операций — сложения, вычитания, умножения и т. д.

x = 15
y = 4

# Вывод: x + y = 19
print('x + y =', x+y)

# Вывод: x - y = 11
print('x - y =', x-y)

# Вывод: x * y = 60
print('x * y =', x*y)

# Вывод: x / y = 3.75
print('x / y =', x/y)

# Вывод: x // y = 3
print('x // y =', x//y)

# Вывод: x ** y = 50625
print('x ** y =', x**y)

x + y = 19
x - y = 11
x * y = 60
x / y = 3.75
x // y = 3
x ** y = 50625

x = 10
y = 12

# Вывод: x > y — False
print('x > y —', x>y)

# Вывод: x < y — True
print('x < y —', x<y)

# Вывод: x == y — False
print('x == y —', x==y)

# Вывод: x != y — True
print('x != y —', x!=y)

# Вывод: x >= y — False
print('x >= y —', x>=y)

# Вывод: x <= y — True
print('x <= y —', x<=y)

x > y — False
x < y — True
x == y — False
x != y — True
x >= y — False
x <= y — True

x = True
y = False

print('x and y —', x and y)
print('x or y —', x or y)
print('not x —', not x)

x and y — False
x or y — True
not x — False

x1 = 5
y1 = 5
x2 = 'Привет'
y2 = 'Привет'
x3 = [1,2,3]
y3 = [1,2,3]

# Вывод: False
print(x1 is not y1)

# Вывод: True
print(x2 is y2)

# Вывод: False
print(x3 is y3)

False
True
False

x = 'Привет, мир'
y = {1:'a',2:'b'}

# Вывод: True
print('П' in x)

# Вывод: True
print('привет' not in x)

# Вывод: True
print(1 in y)

# Вывод: False
print('б' in y)

True
True
True
False

Python – весьма перспективный язык программирования, который набирает популярность. Он позволяет создавать функциональный контент совершенно разного направления: от бизнес-софта до развлекательных утилит. Достаточно прост в изучении и освоении с нуля.

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

Немного терминологии

Python является язык общего назначения. Он включает в себя принципы объектно-ориентированного программирования. Поэтому перед тем, как изучать операторы и их нюансы, стоит запомнить несколько ключевых терминов. Без них создать качественное приложение не представляется возможным:

1. Алгоритм – своеобразный набор правил и инструкций. Он необходим для обработки функций и выполнения тех или иных задач.
2. API – интерфейс прикладного программирования. Включает в себя структурные данные, протоколы и правила, позволяющие быстро разрабатывать ПО, а также налаживать его взаимодействие с разного рода службами.
3. Переменные – именованные ячейки памяти. Они резервируются системой с учетом типа используемых данных в исходном коде.
4. Константа – постоянное значение. Оно не подлежит никаким корректировкам на протяжении всего жизненного цикла софта.
5. Аргумент – значение, которое передается в команду или функцию.
6. Объекты – наборы связанных между собой переменных, констант и иных структурных данных, выбираемых и обрабатываемых совместно.
7. Классы – перечни связанных объектов. Наделяются общими свойствами.
8. Итерация – один проход через команду или функцию в коде.

Отдельно стоит выделить такие понятия как «оператор» и «операнд». Первый термин указывает на объект, умеющий управлять операндами. Для этого задействуются специальные символы и записи (функции). Операнд – объект, которым можно манипулировать через так называемые операторы.

Основные операторы

Оператор в Питоне – символ, который будет отвечать за выполнение операции над одним или сразу несколькими операндами. Последним компонентом будет выступать переменная или значение, с которой требуется проводить дальнейшую работу.

Всего в рассматриваемом ЯП несколько типов операторов:

• арифметические;
• сравнения;
• присваивания;
• логические;
• принадлежности;
• битовые;
• тождественные.

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

Арифметические

Арифметические операторы в Python – самые простые. Данная категория «команд» встречается даже новичкам. С ними знакомятся еще в школьной программе. Они отвечают за элементарные математические действия.

Сюда относят:

1. Сложение (+). Производит сложение значений по обе стороны «команды».
2. Вычитание (-). Осуществляет вычитание правой стороны из значения левой в заданном выражении.
3. Умножение (*). Перемножает написанное с обеих сторон выражения.
4. Деление (/). Делит левый операнд на правый. Тип информации результата – это число с плавающей точкой.
5. Возведение в степень (**). Отвечает за возведение первого написанного числа в степень второго у заданной функции.
6. Деление без остатка (//). Производит деление согласно установленным математическим правилам. После этого возвращает значение, оставляя только целочисленную часть от полученного частного. Все, что идет после десятичной точки, система отбросит.
7. Остаток от деления (%). Эта операция также называется делением по модулю. При ее использовании происходит «раздел» и возврат значения остатка.

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

Сравнение

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

1. Меньше (<). True присваивается, если показатель слева меньше, чем справа.
2. Больше (>). True на выходе будет получено, когда «условия» слева больше правого.
3. Меньше или равно (<=). Выдает на выходе истину, если левая часть меньше или такая же, как правая.
4. Больше или равно (>=). True устанавливается, если левая часть записи окажется больше или аналогичной правой.
5. Равно (==). В данном случае происходит проверка на непосредственное равенство. Если параметр слева такой же, как справа, на выходе получится true. В противном случае – False.
6. Не равно (!=). Оператор, который убран в Питоне 3. Он проверяет, не равен ли параметр слева правому. При успешном выполнении условия приложение выдаст True.

Здесь в основном придется учитывать результат в виде True и False. Перечисленные манипуляции тоже достаточно активно используются в разработке софта.

Присваивание

Операторы присваивания будут отвечать за передачу переменной того или иного значения. Тут нет true или false. Данная категория включает в себя:

1. Обычное присваивание (=). Параметр справа передается левой части.
2. Сложение и присваивание (+=). Суммирует параметры с обеих сторон и передает результат левой части.
3. Вычитание и присваивание (-=). Из правого вычитается «левое». Далее последнему передается соответствующий результат.
4. Деление и присваивание (/=).
5. Умножение и присваивание (*=).
6. Деление по модулю и присваивание (%=).
7. Возведение в степень и присваивание (**=).
8. Деление с остатком и присваивание (//=).

Последний является одним из самых важных в Питоне.

Логические операторы

Логические операторы выполняют роль своеобразных союзов. Они будут выдавать на выходе True или False. Дают возможность объединения нескольких условий в единое целое:

1. И (and). Если написанное с двух сторон оператора – это true, то и все выражение окажется true.
2. Или (or). Результат «ложь» выводится тогда, когда два операнда false. В противном случае – true.
3. Не (not). Работает с булевыми значениями. True становится False. Обратное соотношение тоже действует.

Других логических операторов в рассматриваемом языке программирования нет.

Принадлежность

Зато есть операторы принадлежности. Они проверяют, является ли значение частью заданной последовательности: списка, кортежа, строки:

1. В (in). Осуществляет проверку на принадлежность к последовательности. Возвращает True при соответствии указанному условию.
2. Нет в (not in). Проводит проверку на НЕ принадлежность к последовательности.

Других операторов в данной категории нет.

Тождественность

Операторы тождественности проверяют, являются ли операнды одинаковыми. На практике встречаются не слишком часто:

1. Это (is). Если тождественность есть, осуществляется возврат True.
2. Это нет (is not).

Остается изучить последнюю крупную категорию операторов в Питоне.

Битовые операторы

Осуществляют работу над операндами побитово. Здесь можно увидеть:

1. Бинарное И (&). Отвечает за побитовую операцию and.
2. Или (|). Побитово проводит or.
3. Или нет (^). Это – исключающее или (XOR).
4. Инвертирующий оператор (~). Возвращает инвертированные двоичные числа. Будет переворачивать биты.
5. Сдвиг влево (<<). Сдвигает на позицию, указанную справа, левого операнда.
6. Сдвиг вправо (>>).

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

Операторы – это специальные знаки, которые являются командой для интерпретатора Python по выполнению определенных задач. Они бывают абсолютно разными: арифметическими, операторами сравнения, тождественности, принадлежности и так далее. Все они имеют различные особенности, которые сегодня мы рассмотрим более подробно.

Арифметические операторы Python

Как можно догадаться из названия, арифметические операторы нужны для того, чтобы совершать несложные арифметические операции. К таковым относятся:

1. Сложение. Для этого используется оператор +, который является таким же, как и известный математический знак, выполняющий эту функцию.
2. Вычитание. Эта операция осуществляется с использованием знака «–».
3. Умножение. В большинстве компьютерных программ данная арифметическая операция выполняется с использованием знака звездочки *. Python – не исключение.
4. Деление. Для этого используется знак слэша /. Внимание! Он должен быть направлен именно в эту сторону.
5. Остаток от деления. Выглядит так, как математический знак процента (%), но имеет другую функцию.
6. Возведение в степень. Отличается от аналогичного знака в арифметике. Выглядит, как две звездочки, расположенные по горизонтали (**).
7. Деление без остатка. Этот оператор получает исключительно целое число, округленное в меньшую сторону (так, чтобы оставался остаток). При этом он не возвращает остатка.

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

Любые операнды размещаются по разные стороны оператора. В случае с математическими операторами, в большинстве случаев это будет стандартное арифметическое выражение типа a + b = c или n = a+3.

Но оператор деления по модулю, например, будет использоваться таким образом.

с = 10 % 3.

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

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

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

Рассмотрим наиболее распространенные из них.

Оператор =. Это классический оператор присваивания. Обратите внимание, он не проверяет равенство операндов, за это отвечает другой оператор. Он именно используется для присваивания значений или объектов переменным.

Тем не менее, в некоторых случаях он может читаться, как знак «равно», но только если речь не идет о сравнении операндов.

Пример.

x = 5. 

Эта простая строчка кода присваивает переменной x значение 5. То есть, она может читаться, как «x равно 5». Но при этом осуществляется не констатация факта, а действие, после которого переменная x становится равной 5. А до этого действия она может как вовсе отсутствовать, так и содержать любое другое значение. 

Это единственный оператор этой категории, который выполняет одно действие. Остальные же совершают сразу 2.

Оператор +=. Этот оператор сначала добавляет к переменной то число, которое находится во втором операнде, а потом делает так, чтобы эта переменная имела соответствующее значение. 

x += 3

Это то же самое, что x = x + 3.

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

Оператор –=. Выполняет похожую операцию на ту, что делает предыдущий оператор, но при этом со знаком «минус». Он сначала берет переменную, которая стоит в первом операнде, отнимает от содержащегося в ней числе значение, расположенное в правом операнде, а потом результат присваивает этой же переменной, которая стоит в левом операнде. 

На практике все значительно проще, чем может показаться, когда вы читали это правило. Оператор –= аналогичен выражению x = x-y. Просто оно более сокращенное. 

Приведем пример.

x -= 3

Если вместо x подставить значение 2, то получится число -1, поскольку если от двух отнять 3, выйдет именно -1.

Оператор *=. Аналог предыдущих двух операторов присваивания, только выполняющий операцию умножения. Соответственно, принцип его работы аналогичный. 

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

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

Они используются, чтобы сопоставить операнды друг с другом и понять, они равны, или какое-то из них большее, или меньшее. 

Рассмотрим существующие операторы сравнения.

Равно (==). Как и говорилось выше, этот оператор выглядит несколько иначе, чем оператор присваивания. Выглядит он, как два математических знака «равно», стоящих вместе. Он проверяет равенство двух операндов, и в случае соблюдения этого критерия возвращает значение «истина».

Не равно (!=). Также отличается от аналогичного арифметического знака в математике. Противоположный по значению оператор. Возвращает истину, если указанный выше критерий не соблюдается. 

Больше, чем (>) и меньше, чем (<). Операторы, аналогичные таковым в математике. 

Больше или равно (>=) и меньше или равно (<=). Аналоги соответствующих операторов в математике с несколько иным описанием.

Приведем сводную таблицу со значениями и примерами использования этих операторов.

Логические операторы Python

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

И (and). Объединяет условия между собой. Если оба критерия оказываются верными, оператор возвращает значение «истина». Если же нет, то «ложь». 

ИЛИ (or). Проверяет истинность хотя бы одного из указанных операндов. Если из них есть один, который соответствует действительности, то возвращается значение «истина». Если же нет, то «ложь». 

НЕ (not). Выполняет инверсию результата вывода логического оператора или функции. То есть, истина становится ложью и наоборот. 

Приведем сводную таблицу с примерами использования этих операторов, а также их значениями.

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

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

Есть всего два оператора тождественности: 

1. Выполняет сравнение, операндов, и если они являются идентичными, то возвращается значение true. Соответственно, если этот критерий не соблюдается, возвращается значение false. 

is not. Противоположный по принципу работы оператор. В случае тождественности операндов друг другу возвращает false.

Приведем наглядную таблицу с описанием использования операторов тождественности в Python.

Операторы принадлежности Python

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

В Python есть два оператора принадлежности – in и not in. По синтаксису они напоминают все остальные. Сначала ставится операнд 1, после этого оператор, а потом – операнд 2. И выполняют они похожие действия. Просто если строка является составной частью большей строки (или меньший объект – составляющей большего), то оператор in возвращает значение True. Если же здесь бы использовался оператор not in, то возвращаемое значение было бы False.

Приведем небольшую таблицу с примерами использования этих операторов (вернее, шаблонами), а также – их значениями.

Побитовые операторы Python

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

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

Вот более подробная таблица с использованием этих операторов.

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

Рассмотрим ещё одну коллекцию Python — множество (set). Чтобы задать множество, можно перечислить его элементы внутри фигурных скобок. Например, создадим множество гласных букв русского алфавита:

vowels = {"а", "е", "ё", "и", "о", "у", "ы", "э", "ю", "я"}

Для создания пустого множества следует использовать функцию set() без аргументов, а для определения количества элементов используется уже известная нам функция len():

empty_set = set()
print(f"Длина пустого множества равна {len(empty_set)}.")

Вывод программы:

Длина пустого множества равна 0.

Множество можно получить из других коллекций, применив к ним функцию set(). Например, создадим множество из строки:

word = "коллекция"
letters = set(word)
print(letters)

Выполнив программу два раза, получим следующий вывод программы:

{'е', 'о', 'и', 'я', 'к', 'л', 'ц'}
{'л', 'к', 'и', 'ц', 'я', 'е', 'о'}

Обратите внимание: порядок вывода элементов множества при выполнении примера может меняться произвольно из-за свойства неупорядоченности множества. Так, элементы множества не имеют индексов, и можно только проверить принадлежность элемента множеству.

Другое свойство множества — уникальность его элементов: они не имеют дублей.

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

Проверить, принадлежит ли значение множеству, можно с помощью оператора in.

Узнаем, принадлежит ли введённая буква русского алфавита к гласным:

vowels = {"а", "е", "ё", "и", "о", "у", "ы", "э", "ю", "я"}
letter = input("Введите букву русского алфавита: ")
if letter.lower() in vowels:
    print("Гласная буква")
else:
    print("Согласная буква")

По элементам множества можно пройти в цикле:

vowels = {"а", "е", "ё", "и", "о", "у", "ы", "э", "ю", "я"}
for letter in vowels:
    print(letter)

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

Множества в Python позволяют выполнять следующие операции:

• Объединение множеств. Возвращает множество, состоящее из элементов всех объединяемых множеств. Обозначается union() или |. Графическое представление операции:

  

  Пример:

  s_1 = {1, 2, 3}
  s_2 = {3, 4, 5}
  s_union = s_1 | s_2
  # s_union = s_1.union(s_2)
  print(s_union)
  

  Вывод программы:

  {1, 2, 3, 4, 5}

• Пересечение множеств. Возвращает множество, состоящее из общих элементов пересекаемых множеств. Обозначается intersection или &. Графическое представление операции:

  

  Пример:

  s_1 = {1, 2, 3}
  s_2 = {3, 4, 5}
  s_intersection = s_1 & s_2
  # s_intersection = s_1.intersection(s_2)
  print(s_intersection)
  

  Вывод программы:

  {3}

• Разность множеств. Возвращает множество, где указаны элементы из первого множества, которых нет во втором — вычитаемом — множестве. Обозначается difference или -. Графическое представление операции:

  

  Пример:

  s_1 = {1, 2, 3}
  s_2 = {3, 4, 5}
  s_dif = s_1 - s_2
  # s_dif = s_1.difference(s_2)
  print(s_dif)
  

  Вывод программы:

  {1, 2}

• Симметричная разность множеств. Возвращает множество, состоящее из элементов, встречающихся в первом или втором множестве, но не в обоих сразу. Обозначается symmetric_difference или ^.

  

  Пример:

  s_1 = {1, 2, 3}
  s_2 = {3, 4, 5}
  s_sym_dif = s_1 ^ s_2
  # s_sym_dif = s_1.symmetric_difference(s_2)
  print(s_sym_dif)
  

  Вывод программы:

  {1, 2, 4, 5}

В качестве примера использования множеств и их операций определим, какие гласные буквы встречаются в слове «коллекция»:

vowels = {"а", "е", "ё", "и", "о", "у", "ы", "э", "ю", "я"}
letters = set("коллекция")
print(", ".join(letters & vowels))

Вывод программы:

о, я, и, е

Для множеств Python доступны следующие операции сравнения:

• Совпадение двух множеств. Обозначается ==. Пример:

s_1 = {1, 2, 3}
s_2 = {3, 1, 2}
print(s_1 == s_2)

Вывод программы:

True

• Подмножество. Все элементы первого множества есть во втором. Обозначается <=. Пример:

s_1 = {1, 2, 3}
s_2 = {1, 2, 3, 4}
print(s_1 <= s_2)

Вывод программы:

True

• Надмножество. Первое множество содержит все элементы второго. Обозначается >=. Пример:

s_1 = {1, 2, 3}
s_2 = {1, 2, 3, 4}
print(s_2 >= s_1)

Вывод программы:

True

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

Чтобы перейти к ещё одной коллекции, рассмотрим пример: пусть в программе нужно хранить информацию о странах и их столицах. Эту задачу можно решить и с помощью известных нам коллекций. К примеру, списком, в котором элементами будут кортежи, содержащие пары значений — страну и её столицу:

countries_and_capitals = [("Россия", "Москва"), ("США", "Вашингтон"), ("Франция", "Париж")]

Представим, что в такой программе нам необходимо вывести столицу для какой-то страны, например для Франции. Тогда нам придётся пройти в цикле по списку кортежей, сравнивая нулевой элемент каждого кортежа со строкой «Франция». Когда такой кортеж будет найден, мы выведем первый элемент этого кортежа, содержащий строку с названием столицы:

countries_and_capitals = [("Россия", "Москва"), ("США", "Вашингтон"), ("Франция", "Париж")]
for country in countries_and_capitals:
    if country[0] == "Франция":
        print(country[1])
        break

Было бы неплохо, если бы мы могли взять из коллекции значение (название столицы в нашем примере) по названию страны, то есть не по числовому индексу, а по строке. Такая коллекция есть в Python. Она называется «словарь» (dict). Словарь похож на список, но вместо индексов элементов в словаре используются ключи, а по ключам в словаре хранятся значения.

Благодаря словарям нашу программу можно переписать, используя в качестве ключей словаря названия стран, а в качестве значений по ключам — названия столиц этих стран:

countries_and_capitals = {"Россия": "Москва",
                          "США": "Вашингтон",
                          "Франция": "Париж"}
print(countries_and_capitals["Франция"])

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

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

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

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

countries_and_capitals = {"Россия": "Москва",
                          "США": "Вашингтон",
                          "Франция": "Париж"}
countries_and_capitals["Сербия"] = "Белград"
print(countries_and_capitals)

Обратите внимание, при записи значения по уже существующему ключу он создаётся заново с новым значением, а прошлый стирается:

d = {"key": "old_value"}
d["key"] = "new_value"
print(d["key"])

Вывод программы:

new_value

При попытке взять значение по несуществующему ключу происходит исключение KeyError:

countries_and_capitals = {"Россия": "Москва",
                          "США": "Вашингтон",
                          "Франция": "Париж"}
print(countries_and_capitals["Сербия"])

Вывод программы:

KeyError: 'Сербия'

Для проверки существования ключа в словаре следует использовать уже известный нам оператор in:

countries_and_capitals = {"Россия": "Москва",
                          "США": "Вашингтон",
                          "Франция": "Париж"}
if "Сербия" in countries_and_capitals:
    print(countries_and_capitals["Сербия"])
else:
    print("Страна пока не добавлена в словарь")

По ключам в словаре можно пройти в цикле for:

countries_and_capitals = {"Россия": "Москва",
                          "США": "Вашингтон",
                          "Франция": "Париж"}
for country in countries_and_capitals:
    print(f"У страны {country} столица — {countries_and_capitals[country]}.")

Вывод программы:

У страны Россия столица — Москва.
У страны США столица — Вашингтон.
У страны Франция столица — Париж.

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

Пусть с клавиатуры вводятся названия стран, каждая с новой строки. При вводе возможны повторы стран. Сигналом окончания ввода будет строка «СТОП». Необходимо вывести, в каких строках (начиная с 0) встречалась каждая из стран. Для решения задачи будем использовать словарь, в котором по ключам — названиям стран будем хранить список номеров строк, в которых эти страны встречались.

# создаём пустой словарь
countries = dict()
# вводим первую строку до цикла (можно заменить, использовав оператор-морж)
country = input()
# создаём счётчик номеров строк
str_number = 0
# продолжаем цикл, пока не введена строка «СТОП»
while country != "СТОП":
    # если введённой страны нет в словаре, создаём ключ и записываем по ключу список из одного номера строки
    if country not in countries:
        countries[country] = [str_number]
    # иначе добавляем в список по ключу новое значение номера строки
    else:
        countries[country].append(str_number)
    # увеличиваем счётчик
    str_number += 1
    # вводим следующую строку
    country = input()
# выводим название страны и полученные списки с новой строки
for country in countries:
    print(f"{country}: {countries[country]}")

Пример ввода:

США
США
Россия
Россия
Россия
Франция
Сербия
СТОП

Вывод программы:

США: [0, 1]
Россия: [2, 3, 4]
Франция: [5]
Сербия: [6]

Основные операции для словарей перечислены в следующей таблице.

Перепишем код примера про страны с использованием метода get():

# создаём пустой словарь
countries = dict()
# вводим первую строку до цикла (можно заменить, использовав оператор-морж)
country = input()
# создаём счётчик номеров строк
str_number = 0
# продолжаем цикл, пока не введена строка «СТОП»
while country != "СТОП":
    # Если страна country есть среди ключей, то get() возвращает список, 
    # хранящийся по этому ключу, иначе get() возвращает пустой список. 
    # Добавляем в список значение str_number.
    countries[country] = countries.get(country, []) + [str_number]
    # увеличиваем счётчик
    str_number += 1
    # вводим следующую строку
    country = input()
# выводим название страны и полученные списки с новой строки
for country in countries:
    print(f"{country}: {countries[country]}")

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