Пожалуй самой большой ошибкой в стандарте python есть отсутствие деструкторов.
Создатели языка поторопились и поместили в язык все преимущества и отказались от всех недостатков C++, заисключением понятия самоочистки.
Идея деструктора в С++ - производить очистку объекта. Дополнительно к этому комплилятор снабжает код, дополнительными проверками и деструкторами локальных объектов.
В питоне я хотел бы видеть возможность принудительно очистить объект, в случае если объект был очищен и на него остались ссылки вызывается исключение. Эта логическая схема отлично зарекомендовала себя в языке С++. С той только разницей что это не выдилялось как самостоятельное направление и содеража потенциальные проблемы защиты.
Например, когда вы создаете объект в С++, у него вызывается функция инициализатор, которая подготавливает объект к использованию. Когда вы заканчиваете работать с объектом, вы вызываете delete *pointer. Она освобождает память, очищает локальные переменные и вызывает их дестркуторы. После чего объект удаляется. Однако, если не смотня на то что вы удалили объект, вы продолжаете с ним работать - вызывается исключения защиты памяти или что нибудь другое.
Выходит что в С++ разработана одна из самых лучших моделей работы с объектами, содержащая небольшие проблемы и понтенциальные проблемы вызывающие недостаток по защите среды исполнения и кучи памяти. В питоне же наоборот.
В питоне вы получаете обсолютную защиту по памяти, но получаете куда более страшные ошибки по утечкам памяти и не линейности работы и временем жизни объектов.
Теперь я продемонстрирую наглядно мои слова:
C++
class My
{
Some m_some;
public:
My(){}
~My(){};
};
{
My *m = new My();
delete m;
}Вы легко создате объект и компилятор помогает вам удалить его, среда исполнения следит за тем чтобы объект не использовался повторно. Разумеется было бы правильей и надежей делать это через использование счетчика ссылок на объект (refcount). Но такая модель была бы менее эффективной и мнее производительной. Главное здесь - вы получаете полное понимание и контрольза жизнью объекта и система помогает вам избежать ошибок, правдо ценой стабильности.
Возмем питон.
class Data: some = None def __init__(self): None def __del__(self): None def close(self): None
Если вы работаете с объектом и захотели его удалить, вы не можете быть увереным, что объект не испльзуется!
self.data = {}
self.data[obj] = Data()
self.data[obj].close()
del self.data[obj]Для реализации надежного удаления вы должны сделать работу за компилятор:
- вызвать метод очистки
- проследить что все локальные переменные удалены
- проследить за тем что все глобальные ссылки на объект удалены.
И все равно вы не получаете полной гарантий в том, что объект удален!
В добавок к этому, вы приобретаете привычку писать кучу ненужного кода по инициализации и очистки объектов, создате дополнительные проверки, дублирующий код, и очистку.
Куда было бы приятней такая конструкция:
self.data = {}
self.data[obj] = Data()
superdel self.data[obj]В которой superdel - вызывает деструктур именуемый __superdel__ у класса, после чего удаляет объект из массива и проверяет (!) количство ссылок на объект. В случае если фукнция деструктора класса __superdel__ не смогла очистить объект от локальных или глобальных ссылок superdel вызывает исключение!
И это все, что отделяет питон от самого гибкого и удобного инструмента разработки!
1 коммент.: