Как в python создать interface?

Question

[Speakermen]

interface User {
    id: number;
    name: string;
}

let employee: User = {
    id: 1, 
    name: "Tom"
}
console.log("id: ", employee.id);
console.log("name: ", employee.name);

Всё что придумал(

class User:
    firstName: str
    lastName: str
    age: int

def createUser(user: User) -> str:
    return f"{user.firstName} {user.lastName} {user.age}"


print(createUser("firstName"))

Comments

[RimMirK]

Уверен что это Python?

[Speakermen]

GNUBack, мне нужны подсказки при добавлении юзера в параметрах функции это удобно в TS
мне нужно типа dto Сервисный слой и контроллеры

print(createUser(firstName="firstName", lastName="lastName", age=20))

[Speakermen]

RimMirK, ну да python я только начал изучать этот швейцарский нож

[Hemul GM]

Speakermen, это не швейцарский нож, это пластиковый швейцарский нож, который похож на настоящий швейцарский нож. Узнаешь об этом потом

Answer 1

[Vindicar]

typing.Protocol играет роль интерфейса, с той поправкой, что наследоваться от него потом необязательно - главное, чтобы набор полей/методов соответствовал.

abc.ABC - это именно абстрактный класс, он требует наследование от себя для соответствия, и часто предполагает наличие какой-то частичной реализации функциональности.

В отличие от него, typing.Protocol обычно применяется только для описания контракта класса, но не для частичной реализации. Так как он не требует наследования, он хорошо подходит для описания структуры объекты, который мы ожидаем на входе - без жётской привязки этого объекта к нашей иерархии классов.

"Обычно", потому что и то, и то можно использовать "не по назначению".

Comments

[Speakermen]

GNUBack, что то типа этого

interface User:
  firstName: str
lastName: str
age: int

class User:
    def __init__(self, firstName: str, lastName: str, age: int):
        if (len(firstName) == 0 or len(lastName) == 0):
            raise Exception("The strings is empty")

        self.firstName = firstName
        self.lastName = lastName
        self.age = age


def createUser(userDto: User) -> str:
    return f"{user.firstName} {user.lastName} {user.age}"


print(createUser(User(firstName="firstName", lastName="", age=0)))

[Vindicar]

Speakermen,

# если раскомментить @декоратор ниже, можно будет проверять,
# реализует ли полученный объект этот протокол ещё и в рантайме,
# с помощью isinstance(some_object, AUser)
# @typing.runtime_checkable
class AUser(typing.Protocol):
    firstName: str
    lastName: str
    age: int

[Speakermen]

Vindicar, спасибо огромное Вам! Я ещё нашёл ну пока не знаю как использовать)

interface supports Python 2.7 and Python 3.4+.

To install interface you have to

pip install python-interface
Example Code:

from interface import implements, Interface

class MyInterface(Interface):

    def method1(self, x):
        pass

    def method2(self, x, y):
        pass


class MyClass(implements(MyInterface)):

    def method1(self, x):
        return x * 2

    def method2(self, x, y):
        return x + y

[fenrir]

Speakermen, все зависит от того для чего вам это нужно и на каком этапе хотите проверять.
По вашему коду тоже будут сообщения в IDE при наличии линтера, если ввести не тот тип

[Алан Гибизов]

fenrir, тут обязательно скриншот кода?

[fenrir]

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

[Алан Гибизов]

fenrir, э… Вы, наверное, шутите? Спойлеры есть… Код вы публиковали неоднократно и корректно…

Но как, Шерлок?

[fenrir]

Алан Гибизов, да, сейчас тоже не знаю что на меня вчера нашло. Спасибо

[Алан Гибизов]

fenrir, https://youtu.be/3hwSgSARNUw

Answer 2

[fenrir]

Смотря о каком определении интерфейса речь. Если речь о формальных интерфейсах, для питона явный способ это сделать это использовать абстрактый базовый класс ABC.
Применительно к вашему случае я бы предложил посмотреть на построители классов данных, например NamedTuple и dataclass

Comments

[Speakermen]

Спасибо dataclasses мне понравился

import dataclasses
from enum import Enum

"""
def calculate(x, y) -> int:
    return {"+": x + y, "-": x - y, "*": x * y, "/": x / y, "%": x % y}

print(calculate(1, 2)["+"])
print(calculate(1, 2)["-"])
print(calculate(1, 2)["/"])
print(calculate(1, 2)["*"])
print(calculate(1, 2)["%"])
"""

"""
@dataclasses.dataclass
class Operands:
    x: int
    y: int


class Operators(Enum):
    PLUS = "+"
    MINUS = "-"
    MULTIPLY = "*"
    DIVISION = "/"
    MODULO = "%"


def calculate(operands: Operands) -> int:
    return {Operators.PLUS: adding(operands), Operators.MINUS: subtracting(operands), Operators.MULTIPLY: multiplying(operands), Operators.DIVISION: dividing(operands), Operators.MODULO: modularDivision(operands)}


def adding(operands: Operands) -> int:
    return operands.x + operands.y


def subtracting(operands: Operands) -> int:
    return operands.x - operands.y


def multiplying(operands: Operands) -> int:
    return operands.x * operands.y


def dividing(operands: Operands) -> int:
    return operands.x / operands.y


def modularDivision(operands: Operands) -> int:
    return operands.x % operands.y


print(calculate(Operands(x=1, y=2))[Operators.PLUS])
print(calculate(Operands(x=1, y=2))[Operators.MINUS])
print(calculate(Operands(x=1, y=2))[Operators.DIVISION])
print(calculate(Operands(x=1, y=2))[Operators.MULTIPLY])
print(calculate(Operands(x=1, y=2))[Operators.MODULO])
"""


@dataclasses.dataclass
class Operands:
    x: int
    y: int


class Operators(Enum):
    PLUS = "+"
    MINUS = "-"
    MULTIPLY = "*"
    DIVISION = "/"
    MODULO = "%"
    All = "all"


def calculate(operands: Operands) -> int:
    return {Operators.PLUS: adding(operands), Operators.MINUS: subtracting(operands), Operators.MULTIPLY: multiplying(operands), Operators.DIVISION: dividing(operands), Operators.MODULO: modularDivision(operands)}


def adding(operands: Operands) -> int:
    return operands.x + operands.y


def subtracting(operands: Operands) -> int:
    return operands.x - operands.y


def multiplying(operands: Operands) -> int:
    return operands.x * operands.y


def dividing(operands: Operands) -> int:
    return operands.x / operands.y


def modularDivision(operands: Operands) -> int:
    return operands.x % operands.y


def calculate(operands: Operands, operators: Operators) -> int:
    match operators:
        case operators.PLUS:
            print(adding(operands))
        case operators.MINUS:
            print(subtracting(operands))
        case operators.MULTIPLY:
            print(multiplying(operands))
        case operators.DIVISION:
            print(dividing(operands))
        case operators.MODULO:
            print(modularDivision(operands))
       case operators.All:
            print(f'Adding (+) = {adding(operands)}')
            print(f'Subtracting (-) = {subtracting(operands)}')
            print(f'Multiplying (*) = {multiplying(operands)}')
            print(f'Dividing (/) = {dividing(operands)}')
            print(f'Modular division (%) = {modularDivision(operands)}')
        case _:
            print("There is no such operator!")


calculate(Operands(x=1, y=2), Operators.PLUS)
calculate(Operands(x=1, y=2), Operators.MINUS)
calculate(Operands(x=1, y=2), Operators.MULTIPLY)
calculate(Operands(x=1, y=2), Operators.DIVISION)
calculate(Operands(x=1, y=2), Operators.MODULO)
calculate(Operands(x=1, y=2), Operators.All)

[fenrir]

Speakermen, да он удобен, что много из коробки предоставляет, но когда речь об изучении, я бы рекомендовал попробовать просто голые классы.
Скажем для вашего примера я бы предложил попробовать дандер методы для перегрузки стандартных операций + - * /, чтобы выполнять их в привычном виде.

Пример перегрузки сложения

class Vector:
    def __init__(self, x, y):
        self.x = float(x)
        self.y = float(y)

    def __str__(self):
        return str(tuple(self))

    def __iter__(self):
        return (i for i in (self.x, self.y))

    def __add__(self, other):
        pairs = map(sum, zip(self, other))
        return Vector(*pairs)


v1 = Vector(2, 3)
v2 = Vector(5, 5)
print(v1 + v2)  # (7.0, 8.0)