Объекты a и b указывают на один и тот же экземпляр класса Singleton, поэтому a is b возвращает True. Это стало возможным благодаря специальной логике в методе __new__, который отвечает за создание объекта. В классе Singleton есть класс-переменная _instance, где хранится единственный созданный объект.

При первом вызове конструктора Singleton(10) переменная _instance пуста, и __new__ создает новый объект. Этот объект сохраняется в _instance, и далее возвращается. При втором вызове Singleton(20) метод new видит, что _instance уже существует, и возвращает его же, не создавая новый. Таким образом, a и b — это ссылки на один и тот же объект. Метод __init__ при этом всё равно вызывается повторно, и устанавливает self.value = 20, затирая предыдущее значение. Это тонкость: __new__ управляет созданием, а __init__ вызывается каждый раз, даже если объект не создавался заново. Такой шаблон называется синглтон — он гарантирует, что у класса будет только один экземпляр.

class Singleton:
    _instance = None  # Класс-переменная, где будет храниться единственный экземпляр

    def __new__(cls, *args, **kwargs):
        # Этот метод вызывается ПЕРЕД __init__, чтобы создать объект
        if cls._instance is None:
            # Если объект еще не создан — создаем его через стандартный способ
            cls._instance = super().__new__(cls)
        # Если уже создан — просто возвращаем его
        return cls._instance

    def __init__(self, value):
        # Этот метод вызывается КАЖДЫЙ РАЗ, даже если объект уже существует
        self.value = value  # Значение перезаписывается при каждом вызове

# Создаем первый экземпляр
a = Singleton(10)

# Пытаемся создать второй экземпляр с другим значением
b = Singleton(20)

print(a.value)  # 20 — потому что __init__ второй раз перезаписал значение
print(b.value)  # 20 — это тот же объект, что и a, с тем же атрибутом
print(a is b)   # True — это один и тот же объект в памяти

Суперклассы (родительские классы) указываются в скобках после имени класса.
Наследование от нескольких суперклассов возможно, и выглядит оно довольно интуитивно:

class Robot(Walkable, Talkable):  # Наследуемся сразу от двух классов
    …

Вы указываете суперклассы класса, перечисляя их внутри круглых скобок в операторе class после имени нового класса. Порядок слева направо, в котором классы перечисляются в круглых скобках, дает порядок слева направо при поиске в иерархии наследования, представленной деревом классов. Следовательно, walk и talk будут доступны объекту r.

Поскольку walk и talk в разных вызовах print(), то они разделены разрывом строки.

1: Неверно, так как мы генерируем только 3 числа:

- 1
0    1
1    17
2     8
3    22
dtype: int64 

2: неверно, так как мы генерируем только 3 числа

- 2
0    31
1    17
2     8 
dtype: int64 

3: верно, все числа целые, находятся в допустимом диапазоне, их точно 3.

- 3
0    30
1    17
2     8
dtype: int64

Мы передаем строку "10" в функцию get_value.

Что происходит в функции:

— x — это строка (str).
— Функция проверяет тип через isinstance(x, str) — условие срабатывает.
— Выполняется операция x + "1", то есть обычная конкатенация строк.

"10" + "1" = "101"

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

Когда мы вызываем:

print(greet("Alice"))

происходит следующее:

— "Alice" передается как позиционный аргумент name.
— greeting не передан явно, поэтому используется значение по умолчанию "Hello".
— Формируется строка: "Hello, Alice!"

Python пытается понять, что такое MyClass, но его еще нет:

def func(x: MyClass) -> None:  # Ошибка: MyClass еще не определен
    ...
    
class MyClass:
    ...

from __future__ import annotations делает так, что все аннотации типов воспринимаются как строки. Это позволяет использовать поздние ссылки (на классы, которые еще не объявлены) — User.

То есть Python не будет сразу требовать, чтобы MyClass уже был определен. Он просто запомнит строку MyClass и разберется с этим позже, когда все классы уже будут объявлены.