101 вопрос для собеседования Python разработчику

Перечень вопросов с ответами, которые часто встречаются на собеседованиях на вакансию junior python developer. Некоторые вопросы часто попадаются и при собеседованиях на вакансию мидла.

• Часть 1
• Часть 2
• Часть 3
• Часть 4
• Часть 5

1. Что такое Python?

Python — это высокоуровневый, интерпретируемый, общего назначения язык программирования. Он был разработан в конце 1980-х годов и впервые выпущен в 1991 году Гвидо ван Россумом. Язык Python прославился своей простотой, читаемостью и элегантностью кода.

Основные характеристики Python:

• Простота и читаемость кода: Python имеет простой и понятный синтаксис, что делает его доступным для начинающих и удобным для опытных разработчиков.
• Интерпретируемость: Python является интерпретируемым языком, что означает, что код исполняется построчно с использованием интерпретатора Python, а не компилируется в машинный код, как это делают языки программирования, такие как C++ или Java.
• Общего назначения: Python подходит для разработки разнообразных приложений, включая веб-приложения, научные вычисления, автоматизацию задач, мобильные приложения и многое другое.
• Динамическая типизация: В Python переменные могут изменять свой тип данных в процессе выполнения программы, что облегчает разработку и уменьшает количество необходимого кода.
• Множество библиотек и фреймворков: Python обладает обширной стандартной библиотекой и множеством сторонних библиотек и фреймворков, которые упрощают разработку различных приложений.
• Поддержка ООП (объектно-ориентированное программирование): Python поддерживает принципы ООП, что позволяет создавать модульные и расширяемые программы.

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

2. В каком году была опубликована первая статья о Python?

Первая статья о Python была опубликована в январе 1991 года. Эта статья, написанная создателем Python Гвидо ван Россумом, называлась «Python — новый, интерпретируемый язык программирования». В ней Гвидо представил Python общественности и описал его основные принципы и возможности. С этого момента Python начал привлекать внимание программистов и стал популярным языком программирования, который продолжает развиваться и использоваться во множестве проектов и областей.

3. Какие типы данных существуют в Python? На какие классы они разделены?

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

1. Числовые типы данных:
   • Целые числа (int): представляют целочисленные значения, например, 42, -10.
   • Вещественные числа (float): представляют числа с плавающей точкой, например, 3.14, -0.5.
   • Комплексные числа (complex): представляются в виде «re + imj», где re — действительная часть, im — мнимая часть, j — мнимая единица.
2. Строковые типы данных:
   • Строки (str): представляют последовательность символов, заключенных в одинарные, двойные или тройные кавычки.
3. Логический тип данных:
   • Булевый (bool): может принимать два значения — True (истина) или False (ложь). Используется для логических операций.
4. Коллекции данных:
   • Списки (list): упорядоченные изменяемые коллекции объектов.
   • Кортежи (tuple): упорядоченные неизменяемые коллекции объектов.
   • Множества (set): неупорядоченные коллекции уникальных элементов.
   • Словари (dict): неупорядоченные коллекции пар «ключ: значение», где каждый ключ уникален.
5. None:
   • Тип данных NoneType: представляет отсутствие значения или пустоту. Обозначается ключевым словом None.

Каждый из этих типов данных имеет свои особенности и используется для различных целей при написании программ на Python.

4. Что такое лямбда-функция? Какова ее цель?

Лямбда-функция в Python — это анонимная (безымянная) функция, которая может состоять из одного выражения. Она создается с помощью ключевого слова «lambda» и обычно используется там, где требуется небольшая функция, которая не будет повторно использоваться в программе.

Синтаксис лямбда-функции выглядит так:

lambda arguments: expression

Где:

• «arguments» — список аргументов, которые принимает функция (может быть пустым или содержать один или более аргументов).
• «expression» — выражение, которое выполняется при вызове функции и возвращает результат.

Например, вот простой пример лямбда-функции, которая возвращает квадрат числа:

square = lambda x: x * x
print(square(5))  # Выведет: 25

Целью лямбда-функций является создание небольших функций на лету, которые могут быть переданы или использованы в других функциях. Они часто используются в функциях высшего порядка (таких как map, filter, reduce) или как аргументы для сортировки данных. Лямбда-функции удобны в тех случаях, когда определение обычной функции может быть избыточным, и требуется простая и краткая функциональность.

5. Что такое PEP 8?

PEP 8 (Python Enhancement Proposal 8) — это руководство по стилю кодирования для языка программирования Python. Он описывает рекомендации и стандарты для форматирования кода Python, чтобы обеспечить единообразный и читаемый стиль написания программ. PEP 8 создан Гвидо ван Россумом, создателем Python, и является широко принятым стандартом в сообществе Python.

PEP 8 включает рекомендации по следующим аспектам:

1. Отступы: Использование пробелов для отступов, а не табуляции. Рекомендуется использовать 4 пробела на один уровень отступа.
2. Размещение пробелов: Размещение пробелов вокруг операторов, аргументов функций, ключевых слов и других элементов кода для улучшения читаемости.
3. Максимальная длина строки: Рекомендуется ограничивать длину строки кода до 79 символов, чтобы код был читаемым на экранах с небольшим разрешением.
4. Именование переменных и функций: Соглашение об именовании переменных, функций, классов и модулей для улучшения понимания кода.
5. Пустые строки: Использование пустых строк для логической группировки кода и улучшения читаемости.
6. Импорты: Соглашение о порядке и стиле импортов, включая использование относительных импортов.
7. Комментарии: Правила для написания комментариев в коде, чтобы пояснять логику и функциональность.
8. Использование пробелов и скобок: Размещение пробелов вокруг операторов и внутри скобок, чтобы сделать код более читаемым.

Соблюдение рекомендаций PEP 8 помогает создавать чистый, структурированный и понятный код на Python, что упрощает совместную разработку и обслуживание программ. Множество инструментов и IDE поддерживают автоматическую проверку соответствия кода стандарту PEP 8.

6. Как получить документацию по атрибутам объекта?

В Python вы можете получить документацию по атрибутам объекта с помощью встроенной функции help() или обратившись к атрибуту __doc__ объекта. Оба метода предоставляют доступ к документации, но с некоторыми различиями.

1. Использование функции help():

Функция help() выводит информацию о переданном объекте, включая его атрибуты и документацию (если она доступна). Вы можете передать в функцию имя объекта или сам объект.

Пример:

# Пример с модулем
import math
help(math)

# Пример с классом
class MyClass:
    """Это пример класса с документацией."""

    def __init__(self):
        pass

help(MyClass)

2. Использование атрибута __doc__:

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

Пример:

# Пример с модулем
import math
print(math.__doc__)

# Пример с классом
class MyClass:
    """Это пример класса с документацией."""

    def __init__(self):
        pass

print(MyClass.__doc__)

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

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

7. Что такое docstring?

Docstring (Documentation String) — это специальный тип комментариев в Python, используемый для документирования модулей, функций, классов и методов. Он представляет собой строку, которая располагается внутри тела объекта и предоставляет информацию о его назначении, использовании и других деталях.

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

Пример использования docstring для функции:

def add_numbers(a, b):
    """
    Функция сложения двух чисел.

    Параметры:
    a (int): Первое число.
    b (int): Второе число.

    Возвращает:
    int: Результат сложения a и b.
    """
    return a + b

Пример использования docstring для класса:

class MyClass:
    """
    Пример класса с docstring.

    Атрибуты:
    name (str): Имя экземпляра класса.
    """

    def __init__(self, name):
        self.name = name

    def say_hello(self):
        """
        Метод для вывода приветствия с именем объекта.
        """
        print(f"Привет, {self.name}!")

Использование docstring позволяет другим разработчикам легче понимать ваш код и его функциональность. Также они могут быть использованы инструментами автодокументации, чтобы сгенерировать автоматическую документацию для вашего кода. Соблюдение стандартов PEP 257 рекомендует определенный формат написания docstring, чтобы документация была читаемой и структурированной.

8. В чем разница между типами list и tuple?

В Python list и tuple являются двумя различными типами коллекций, которые используются для хранения набора значений. Однако у них есть следующие основные различия:

1. Изменяемость:
   • list: Является изменяемой коллекцией, что означает, что вы можете изменять, добавлять, удалять элементы после создания списка.
   • tuple: Является неизменяемой коллекцией, и после его создания нельзя изменить, добавить или удалить элементы.

Пример:

# Пример с list
my_list = [1, 2, 3]
my_list[0] = 100  # Разрешено изменение элемента списка
my_list.append(4)  # Разрешено добавление элемента в список

# Пример с tuple
my_tuple = (1, 2, 3)
my_tuple[0] = 100  # Вызовет ошибку, так как tuple неизменяемый

2. Синтаксис:
   • list: Определяется с использованием квадратных скобок [ ].
   • tuple: Определяется с использованием круглых скобок ( ).

Пример:

my_list = [1, 2, 3]
my_tuple = (1, 2, 3)

3. Производительность:
   • В некоторых случаях tuple может быть чуть более производительным, чем list, потому что он не может изменяться после создания, что делает его более оптимизированным для определенных операций. Однако это различие обычно незначительно и зависит от конкретного контекста использования.

Когда использовать list:

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

Когда использовать tuple:

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

9. Может ли индекс списка быть отрицательным?

Да, в Python индекс списка может быть отрицательным. При использовании отрицательного индекса элементы списка нумеруются справа налево, начиная с -1.

Таким образом, когда вы используете отрицательный индекс для доступа к элементу списка, Python будет обращаться к элементам, начиная с последнего и двигаясь к началу списка.

Пример:

my_list = [10, 20, 30, 40, 50]

print(my_list[-1])  # Выведет: 50 (последний элемент списка)
print(my_list[-2])  # Выведет: 40 (предпоследний элемент списка)
print(my_list[-3])  # Выведет: 30

Использование отрицательных индексов может быть удобным, когда вы хотите получить доступ к элементам с конца списка без необходимости знать его длину. Однако стоит помнить, что при использовании отрицательного индекса, необходимо убедиться, что индекс находится в допустимом диапазоне, чтобы избежать ошибки «IndexError». Например, в приведенном выше примере, индекс -4 привел бы к ошибке, так как его нет в списке.

10. Что означает конструкция pass?

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

Когда вам необходимо объявить блок кода синтаксически, но вы еще не знаете, что именно будет внутри этого блока, вы можете использовать pass. Он предотвращает ошибки синтаксиса и позволяет вам создавать заглушки для будущего кода, который будет добавлен позже.

11. В чем разница между многопоточным и многопроцессорным приложением?

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

Многопоточное приложение:

1. В многопоточном приложении используются потоки для выполнения задач. Потоки — это легковесные подзадачи внутри процесса.
2. Все потоки в многопоточном приложении используют общее пространство памяти процесса, что означает, что они могут обмениваться данными и ресурсами без необходимости в явной синхронизации.
3. Многопоточные приложения подходят для задач, которые имеют большое количество ввода-вывода (I/O) операций, таких как чтение и запись файлов, сетевые операции и другие блокирующие операции, так как потоки могут переключаться между собой при блокировке одного из них.
4. В Python для работы с потоками можно использовать стандартный модуль threading.

Многопроцессорное приложение:

1. В многопроцессорных приложениях используются отдельные процессы для выполнения задач. Процессы представляют собой изолированные и независимые единицы выполнения, каждая из которых имеет свое собственное пространство памяти.
2. Многопроцессорные приложения обычно имеют меньше проблем с синхронизацией и конкуренцией за ресурсы, так как каждый процесс работает в своем собственном адресном пространстве.
3. Многопроцессорные приложения подходят для вычислительно интенсивных задач, так как каждый процесс может выполняться на отдельном ядре процессора, что позволяет эффективно использовать многопоточность современных многоядерных процессоров.
4. В Python для работы с процессами можно использовать стандартный модуль multiprocessing.

Важно отметить, что многопоточные приложения в Python могут столкнуться с проблемами синхронизации и гонками данных из-за использования GIL (глобальной блокировки интерпретатора) в CPython (стандартная реализация Python). В свою очередь, многопроцессорные приложения в Python избегают этой проблемы, так как каждый процесс работает в своем собственном адресном пространстве и имеет свою собственную GIL.

12. Как просмотреть методы объекта?

В Python вы можете просмотреть методы объекта, используя функцию dir(). Функция dir() возвращает список имен атрибутов и методов объекта. Если вызвать dir() без аргументов, она вернет список имен в текущей области видимости.

Чтобы просмотреть методы объекта, выполните следующие шаги:

1. Создайте или получите объект, методы которого вы хотите просмотреть.
2. Используйте функцию dir() и передайте объект в качестве аргумента.

Пример:

# Создаем список и получаем его методы
my_list = [1, 2, 3]
methods_list = dir(my_list)
print(methods_list)

В этом примере мы создаем список my_list и затем используем dir() для просмотра всех его методов. Результатом будет список имен методов списка, таких как append(), pop(), count() и т. д.

Обратите внимание, что dir() также возвращает имена атрибутов и специальных методов (например, __init__, __str__ и т. д.), которые могут быть полезны при работе с объектами.

13. Что такое *args и **kwargs в определении функции?

*args и **kwargs являются специальными параметрами в определении функции в Python и предоставляют возможность обрабатывать переменное количество аргументов.

1. *args (аргументы со звездочкой): *args позволяет передавать произвольное количество позиционных аргументов в функцию. Звездочка * перед параметром args указывает интерпретатору, что он должен собирать все переданные позиционные аргументы в кортеж (tuple) и передать этот кортеж в функцию. Внутри функции вы можете обращаться к аргументам через args как к обычному кортежу.

Пример:

def my_function(*args):
    for arg in args:
        print(arg)

my_function(1, 2, 3)

В этом примере функция my_function принимает произвольное количество позиционных аргументов. При вызове my_function(1, 2, 3) аргументы 1, 2 и 3 будут собраны в кортеж args, и цикл for выведет каждый аргумент на экран.

2. **kwargs (аргументы с двумя звездочками): **kwargs позволяет передавать произвольное количество именованных аргументов в функцию. Звездочки ** перед параметром kwargs указывают интерпретатору, что он должен собрать все переданные именованные аргументы в словарь (dictionary) и передать этот словарь в функцию. Внутри функции вы можете обращаться к аргументам через kwargs как к обычному словарю.

Пример:

def my_function(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

my_function(name="John", age=30, city="New York")

В этом примере функция my_function принимает произвольное количество именованных аргументов. При вызове my_function(name="John", age=30, city="New York") аргументы name, age и city будут собраны в словарь kwargs, и цикл for выведет каждую пару ключ-значение на экран.

Обратите внимание, что *args и **kwargs можно использовать вместе в определении функции для обработки и позиционных, и именованных аргументов одновременно.

14. Полностью ли Python поддерживает ООП?

Да, Python полностью поддерживает объектно-ориентированное программирование (ООП). ООП является одним из ключевых аспектов языка Python. Весь его стандартный библиотека построена на основе ООП.

Python поддерживает следующие основные принципы объектно-ориентированного программирования:

1. Классы и объекты: Вы можете определить собственные классы, которые являются шаблонами для создания объектов. Классы определяют состояние и поведение объектов, а объекты представляют экземпляры этих классов.
2. Инкапсуляция: ООП в Python позволяет скрывать внутренние детали реализации классов и предоставлять публичные методы для доступа к их поведению и состоянию.
3. Наследование: Python поддерживает наследование, что позволяет создавать новые классы на основе существующих, наследуя их поведение и расширяя функциональность.
4. Полиморфизм: Python поддерживает полиморфизм, который позволяет использовать объекты различных классов с одним и тем же интерфейсом, без необходимости знать их конкретный тип.

В Python всё является объектом, включая базовые типы данных, функции и модули. Это делает Python очень гибким и мощным для разработки в объектно-ориентированном стиле.

15. Что такое globals() и locals()?

globals() и locals() — это встроенные функции в Python, которые возвращают словари, содержащие информацию обо всех глобальных и локальных переменных соответственно.

globals(): Функция globals() возвращает словарь, содержащий все глобальные переменные в текущем глобальном пространстве имен. Глобальные переменные — это переменные, определенные на верхнем уровне вашего скрипта или в модуле. В словаре, возвращаемом globals(), ключами являются имена переменных, а значениями — соответствующие им значения.

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

Обратите внимание, что области видимости глобальных и локальных переменных могут отличаться, и использование globals() и locals() может быть полезно для отладки и понимания доступных переменных в разных частях вашего кода.

16. Что хранится в атрибуте dict?

В Python атрибут dict представляет собой встроенный тип данных «словарь» (dictionary). Словарь является структурой данных, которая хранит коллекцию пар «ключ-значение». Каждый элемент словаря состоит из уникального ключа и соответствующего ему значения.

Основные особенности словарей в Python:

1. Уникальные ключи: Каждый ключ в словаре должен быть уникальным. Если вы попытаетесь использовать один и тот же ключ дважды, его значение будет перезаписано.
2. Изменяемость: Словари являются изменяемыми, что означает, что вы можете добавлять, изменять или удалять элементы после их создания.
3. Неупорядоченность: В словаре нет фиксированного порядка элементов. Элементы хранятся в хэш-таблице, что позволяет быстро находить значения по ключу. Но не гарантирует сохранение порядка.

Пример создания и использования словаря:

# Создаем словарь
my_dict = {"name": "John", "age": 30, "city": "New York"}

# Доступ к элементам по ключу
print(my_dict["name"])  # Выведет: "John"
print(my_dict["age"])   # Выведет: 30

# Добавление нового элемента
my_dict["occupation"] = "Engineer"

# Изменение значения элемента
my_dict["age"] = 31

# Удаление элемента
del my_dict["city"]

# Вывод всего словаря
print(my_dict)  # Выведет: {'name': 'John', 'age': 31, 'occupation': 'Engineer'}

Словари широко используются в Python для хранения и обработки данных. И они являются очень удобным инструментом для решения различных задач. Важно помнить, что ключи словаря должны быть хэшируемыми типами данных. Такими как строки, числа или кортежи.

17. Как проверить файл .py на наличие ошибок синтаксиса без его запуска?

Для проверки файла .py на наличие ошибок синтаксиса без его запуска можно использовать инструменты проверки синтаксиса, такие как pyflakes или flake8. Эти инструменты позволяют обнаружить ошибки синтаксиса. Неправильные импорты, неиспользуемые переменные и другие потенциальные проблемы в коде.

Если в вашем коде есть ошибки синтаксиса или другие проблемы. Эти инструменты выведут соответствующие предупреждения или ошибки, указав строку и местоположение проблемы.

Примечание: pyflakes проверяет только ошибки синтаксиса, в то время как flake8 также проверяет стиль кодирования и может выводить предупреждения о неправильном форматировании кода согласно PEP8 (стандарты стиля кодирования для Python). Если вам интересно следовать стандартам PEP8, то flake8 может быть полезным инструментом для проверки стиля вашего кода.

18. Зачем в Python используется ключевое слово self?

В Python ключевое слово self используется в методах классов для ссылки на текущий экземпляр класса. Это обязательный параметр в методах класса. Хотя его имя может быть любым (чаще всего используется слово «self» по соглашению).

Когда вы вызываете метод у экземпляра класса. Python автоматически передает этому методу ссылку на сам экземпляр в качестве первого аргумента. Эта ссылка и называется self.

Использование self позволяет обращаться к атрибутам и методам текущего экземпляра класса внутри методов этого класса. Без использования self невозможно получить доступ к атрибутам или вызвать другие методы класса, потому что Python не знает, к какому экземпляру класса относится вызов метода.

Пример использования self в методе класса:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say_hello(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

# Создание экземпляра класса Person
person1 = Person("Alice", 25)

# Вызов метода say_hello у экземпляра person1
person1.say_hello()

В этом примере метод say_hello() класса Person использует self.name и self.age для получения доступа к атрибутам name и age текущего экземпляра класса. Это позволяет методу выводить информацию о конкретном человеке, которому принадлежит экземпляр класса Person.

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

19. Что такое декоратор? Как написать свой собственный декоратор?

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

Декораторы работают следующим образом: они принимают функцию, к которой применяются. И возвращают новую функцию (или замыкание), которая оборачивает исходную функцию. Это позволяет выполнить дополнительный код до и/или после вызова исходной функции.

Декораторы обычно записываются с использованием символа «@» перед определением функции, к которой применяется декоратор.

Вот пример простого декоратора, который добавляет логирование к функции:

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("Calling the function...")
        result = func(*args, **kwargs)
        print("Function call completed.")
        return result
    return wrapper

@my_decorator
def my_function(x, y):
    return x + y

result = my_function(2, 3)

В этом примере my_decorator — это декоратор, который добавляет логирование перед и после вызова функции my_function. При вызове my_function(2, 3) будет выведено:

Calling the function...
Function call completed.

Для написания своего собственного декоратора, вы можете определить функцию, которая принимает другую функцию в качестве аргумента. Создает и возвращает новую функцию (wrapper), которая оборачивает исходную функцию и выполняет дополнительный код.

Вот пример простого декоратора, который замеряет время выполнения функции:

import time

def timer_decorator(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"Function '{func.__name__}' executed in {end_time - start_time:.4f} seconds.")
        return result
    return wrapper

@timer_decorator
def slow_function():
    time.sleep(2)
    return "Function completed."

result = slow_function()

В этом примере timer_decorator — это декоратор, который измеряет время выполнения функции slow_function. При вызове slow_function() будет выведено время, затраченное на ее выполнение.

20. Что может быть ключевым словом в словаре?

В Python ключевым словом (или «ключом») в словаре может быть любой хэшируемый тип данных. Хэшируемый тип данных — это тип данных, который имеет уникальный хэш-значение. И его значение не может быть изменено после создания объекта. Некоторые примеры хэшируемых типов данных в Python включают:

1. Числа (int, float, complex)
2. Строки (str)
3. Кортежи (tuple)
4. Фиксированные множества (frozenset)

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

# Использование чисел в качестве ключей
my_dict1 = {1: "One", 2: "Two", 3: "Three"}

# Использование строк в качестве ключей
my_dict2 = {"apple": 1, "banana": 2, "orange": 3}

# Использование кортежа в качестве ключа
my_dict3 = {(1, 2): "Tuple Key"}

# Использование фиксированного множества в качестве ключа
my_dict4 = {frozenset([1, 2]): "Frozen Set Key"}

Заметьте, что списки (list) являются нехэшируемыми типами данных. Поэтому они не могут использоваться в качестве ключей словаря. Если попытаться использовать список в качестве ключа, возникнет ошибка.

my_dict = {[1, 2]: "Error: List cannot be used as a key"}

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