Непонимание наследования

А что конкретно не понятно?

вобщем это всё от динамичности. Думай об этом что оно всё в рантайме происходит.

В Development же.

а что простите должно не работать?

наверное, не понятно почему в A можно вызвать метод из B, если в сигнатуре никакого B нету. Справедливый вопрос для людей без питона головного мозга))

сначало «подставилось» то есть написалось

class C(): def __init__(self): self.Bfunc() def Bfunc(self): print «Bfunc»

потом «исполнилось»

почему ф-я из B вызывается в A?

но это же не должно работать! я так думаю. И думал, пока не сделал «ошибку» которая оказалась не ошибкой.

Мне кажется, что эта тема не стоит Development, но я не знаю как перенести.

Почему не должно? Ты же вызываешь из C, который знает и про A, и про B. А компилируется оно потому, что язык динамический, и ему глубоко плевать, что там в self. Раз вызывают, значит наверное есть. Будем выполнять - там разберёмся.

почему ф-я из B вызывается в A?

Это метод, а не функция. И вовсе не из A он вызывается.

но это же не должно работать!

и не будет, если напишешь:

A()

я к тому, что A про B ничего не знает! В этом суть) Как именно оно работает я понимаю, но вот зачем так сделано понять не могу.

Поиск метода Bfunc у объекта происходит в рантайме. А как ищутся методы в python? А очень просто, у любого объекта есть словарь __dict__, хранящий имеющиеся методы, в котором, при вызове метода, ищется вызываемый метод и исполняется, если нашли. Так что всё ок, т.к. метод Bfunc имеется у C.

не суть.

проверено)) но логически и из C не должно.

Зачем? Как вариант, это можно использовать для идеи миксинов: http://ru.wikipedia.org/wiki/Примесь_(программирование)

перефразирую - я не понимаю, почему именно так сделано. Получается, что метод А без С неработоспособен и будет выдавать ошибку.

Ну, ты понимаешь, что self — это ссылка на ОБЪЕКТ класса?( который создаётся имя_класса() )

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

Это я понимаю (см. коммент выше)

Это я понимаю

Ну а теперь проследи как ты передаёшь self по методам при вызове C()

Она вызывается не в A, а в C, просто выполняется тот вариант функции __init__, который унаследован из A. И этот вариант ищет у себя (а мы говорим о классе C) функцию Bfunc и находит её в той части, что унаследована от B.

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

Для этого существует документация и комментарии. Да и применяется не часто, так что всё окей с этим.

основная мысль - зачем так сделано, ведь это делает код нечитабельным совершенно!

но вот зачем так сделано понять не могу

Потому что в Питоне нет интерфейсов.

основная мысль - зачем так сделано

Это возможно потому что нету проверки типов.
Когда ты пишешь class A: def init(self) self.bfunk() <- здесь self неизвестного типа, нельзя проверить содержит ли self bfunk или нет.

Зависит от среды и её умения выдавать варнинги в таких ситуациях. Можно например поступать как clang с макросами - если в них явная ошибка, наплевать до тех пор, пока макрос не инстанцируется - а потом поставить курсор ошибки где-то в теле макроса.

Т.е. среда видит вызов конструктора c = C() и ничего не показывает, всё ок; видит a = A() - и создаёт предупреждение с курсором на __init__ класса A.

функция

ололо. как ты не инстанцируеш А через A.__init__(self).

а в С++ такое не прокатывает(

ты упоролся такой код писать

и да, в топике тебе все разъяснили

по поводу читаемости: если упоротые люди пишут код, то он в любом случае будет нечитаемым.

Предлагаешь все языки ограничить тем, что умеет C++? :)

я предлагаю не делать глупостей) а с++ для меня эталон логичности.

>а с++ для меня эталон логичности

Готовь броню, тут может быть битва. Сегодня ещё и пятница (^ ^)

готов в битве:D

Это тот про который уже и авторы сказали что говно вышло в итоге?

тот?

Сам напиши, тогда поймешь.
В самом деле, в ООП особых премудростей нет.

что значит нет? если 2 класса никак не связаны логически, то и методы друг-друга использовать не должны!

прекрати троллить, люби и воспринимай питон таким как он есть

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

здесь self неизвестного типа, нельзя проверить содержит ли self bfunk или нет.

Но если очень хочется, то

class A(object):
        def __init__(self):
            if isinstance(self, B):
                self.Bfunc()

class A:
        def __init__(self):
            if hasattr(self, 'Bfunc') and hasattr(self.Bfunc, '__call__'):
                self.Bfunc()

пора пилить свою джангу на C++)))

Ну, вот пример из реальной жизни.

Есть class Base, в котором написан обработчик, который выполняет в нужном месте цепочку методов (_get_blah, _get_blahblah etc). Заранее он не знает, какие методы.

Я от него наследую и добавляю конкретные методы _get_..., которые мне надо, и он их исполняет, а код, исполняющий их, хранится отдельно в классе Base

Получается, что питон неработоспособен и будет выдавать ошибку.

Вот так лучше.

Ты первый раз в жизни увидел динамический язык? Или ты тупишь? Или нарываешься на -20?

с++ для меня эталон логичности.

Это язык в котором чтение и запись достигается при помощи битового сдвига потоков ввода-вывода?

ужасы динамических языков

Это язык в котором чтение и запись достигается при помощи битового сдвига потоков ввода-вывода?

Не осиливаешь больше одного значения для каждого операнда? А вычитание и отрицательные числа тебя тоже в ступор вводят?

если 2 класса никак не связаны логически, то и методы друг-друга использовать не должны!

Именно поэтому никто и не любит множественное наследование.