правильное наследование в python

Каждый класс в свой файл и обозвать это дело модулями. Как оформить модуль читать в инете.

Ну это понятно. Смотри. Есть 1 файл, в котором идёт выполнение, например

class A(object):
    def __init__(self):
        self.asd = 123

и так далее.

В класс A я хочу добавить переменную B, которая является классом B, находящимся в другом файле, при этом наследоваться он должен от А.

как ты там сделаешь всем насрать

Блин, кажется до меня дошло, просто пишу self.B = B(A)?

щето

Ты что, хочешь множественное наследование или просто чтобы элемент класса был классом?

Есть у тебя 3 класса, назовем их A, B, C. A это общий для всех классов класс или у тебя другая схема?

Хочу чтобы элемент класса был классом, наследованным от класса, который его вызывает. Чё-то такое. Короче чтобы класс А вызывал функции, которые находятся в классе Б, а класс Б бы наследовался от класса А, и при этом находился в другом модуле.

А общий класс. B и C должны наследоваться от А. При этом быть в других файлах. А класс А их инициализирует как свои переменные и дёргает их функции.

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

Я бы не страдал с циклическими зависимостями и разрулил бы всё попроще. А то выходит что у тебя класс А должен наследоваться от Б, а Б от А. Это — дурная идея вне зависимости от ЯП. Ну или просто дергай методы другого класса как ты делаешь с обычными модулями.

Эх. Ну вот что-то такое примерно: Есть a.py, в нём класс A:

class A(object):
    def __init__(self, a):
        self.asd = 123

есть b.py

#from a import A
from test import class_a

class B(class_a):
    def __init__(self):
        self.qwerty = 'hllo'
    def go(self):
        #print(A.asd)
        print(self.asd)

ну и собственно test.py:

import a
import b

class_a = a.A(123)
class_b = b.B()

class_b.go()

Вот тут уже понятнее что ты хочешь. Хотя мне все равно не нравится что ты пытаешься сделать (я бы сделал отдельно A_BASE от которого бы наследовал всё остальное и уже в унаследованном от него A инициализировал B и C, но если питон позволяет такое наследование как ты хочешь, то норм.) По теме не путай класс и объект, это разные вещи в общем случае. Я медленно читаю и пишу, так что последний коммент пока не видел.

т.е. я хочу чтобы при вызове функции go в классе B он тащил переменную asd из класса A.

я бы сделал отдельно A_BASE от которого бы наследовал всё остальное и уже в унаследованном от него A инициализировал B и C

Можешь примерно расписать как это бы выглядело?

Позволять-то позволяет, когда пространство A, B и C в одном файле. То есть если я в test.py это всё объединю это будет работать. А если раскидать по разным модулям то до меня не доходит как импортнуть объект инициализированного класса и наследоваться от него.

Не совсем понятен юзкейс, но вот тебе помощь — https://stackoverflow.com/a/1081925/3355831

Смысл в том что код разожрался и я хочу раскидать его по разным файлам. Может подскажете как правильно?

К сожалению, такая идея в принципе не работоспособна, т.к. в class B требуется инициализация класса а. Т.е. класс B должен принимать все аргументы класса А и быть самодостаточным.

Так а что мешает его раскидать по файлам? Если нужно именно для тестирования, так для этого бери и импортируй все классы и перед тестированием наполняй их данными. Всё же есть. Нет нужды пробовать наследоваться от существующих объектов.

Но ты можешь сделать так: a.py

class ClassA(object):
    def __init__(self, a):
        self.asd = a
        self.bc = "something"

from a import ClassA

class ClassB(ClassA):
    def __init__(self, a):
        self.qwerty = 'hello'
        super(ClassB, self).__init__(a)
    def go(self):
        print(self.asd)
        print(self.bc)
        print(self.qwerty)

#import a
import b

#class_a = a.ClassA(123)
class_b = b.ClassB(12)

class_b.go()

12
something
hello

Вот! Спасибо огромное. Как раз только что до вызова super() догуглился. То что надо вроде бы.

Только учти, что у тебя там классы наследуются, а не объекты в объекты складываются. Это немного разные вещи. И поставь себе PyCharm, там подсказки по ошибкам и дебаггер очень классные и удобные.

Сам super() не даст то, что нужно. Он помогает переопределить поведение, но не влияет на состояние.

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

переменные становятся доступны из родительских классов

всё хуже. В данном случае он позволяет инициализировать в твоем классе то что инициализируется в родителе. Но инициализация происходит именно в наследнике и никак не связана с состоянием объектов родителей.

т.е. значения тупо копируются? Тогда не совсем то что мне нужно.

Если тебе нужен asd из текущего экземпляра и он определен в инициализаторе:

class B(A):
    def __init__(self, ...):
        super().__init__(self, a)
        ...

    def go(self,):
        return self.asd

class B(A):
    ...
    @classmethod
    def go(cls,):
        return cls.asd

Можно накостылить копирование объект->объект:

class B(A):
    def copyobj(self, obj):
        for k, v in obj.__dict__.items():
            setattr(self, k, v)

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

Надеюсь понятно описал.

Любопытно, к какой задаче требуется такой подход с наследованием?

В каком-то из сообщений выше написал. Разожрался код в одном модуле, хотел реализовать всё это дело в разных классах, и раскидать по разным файлам.

Как можно накостылить, я уже предоставил ссылку выше. Можно написать и более изощрённые способы, но я бы лучше уточнил, в чём конкретно проблема у ТС, т.к. пока методы решения проблемы не впечатляют.

но я бы лучше уточнил, в чём конкретно проблема у ТС, т.к. пока методы решения проблемы не впечатляют.

Поддержу, «разожрался код в одном модуле, хотел реализовать всё это дело в разных классах, и раскидать по разным файлам», не тянет на повод делать такое.

Что-то по количеству плясок вокруг всего этого мне тоже так кажется. Может посоветуете правильный путь тогда как разбивать большие модули на модули поменьше? Функциональный путь мне не особо нравится, т.к. тут тоже будет много мороки.

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

как ты там сделаешь всем насрать

Вквотезы!

Импортируешь базовый класс и наследуешься. В чём проблема?

Привыкаешь к наследованию ромбиком? Давай сразу к abc, чё уж там.

Просто определи пустые методы, лучше - кидающие исключение в случае вызова, в классе A и вызывай их из него сколько влезет.

Потом в B и C просто наследуешь класс А, определяешь нормальные тела тех самых методов и все.

ЕМНИП, в питоне даже не обязательно объявлять такие методы в теле класса А, при этом в других его методах вполне допустимо вызывать «несуществующие методы».

вот, кстати, и у меня по этому поводу вопрос: есть класс, у которого куча методов. Хочется «разбить» этот класс, но так, чтобы по-прежнему вызывать все методы объекта простым object.methodN(), (N -> infinity), как это правильнее сделать?

Хочется «разбить» этот класс, но так, чтобы по-прежнему вызывать все методы объекта простым object.methodN

class C(A, B):

Да, спасибо, это я ступил... :)

О каких методах решения можно говорить, не определив проблему? Это верно. setattr( лучше getattr(, поскольку под капотом класса могут производиться махинации с атрибутом, возвращаемым объектом из другого объекта/класса: если возвращается чужой, а операции производятся со своим, в итоге получится очевидно нежелательное/неопределенное поведение

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

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

а поскольку речь о питоне, где классы легко и непринужденно создаются через

cls=type(name, chain_of_classes, additional_props)