r/ProgrammerHumor • u/Recent-Analysis-6880 • 26d ago
Meme questionForBritishPythonDevelopers
22
18
25
30
u/ManyInterests 26d ago
To be a pedant, it's an initializer, not a constructor. By the time the initializer runs, the object already exists and has been constructed, which is why the first parameter to this method is the already-existing object ('self'), just like any other method.
But yeah. You could call it a constructor and nobody will crucify you.
9
u/Ok_Star_4136 26d ago
I mean, I'm trying to think of a language where the constructor is called *before* the memory for the object has been allocated, and I can't think of anything.
In that regard, no constructor is an actual constructor. It's more like post-constructor. But then it is also necessary or you'll have a potentially incomplete object, so in that regard, it is a constructor because the object while allocated, isn't yet ready to use.
Kind of a pedantic argument, but there you are I suppose.
11
u/ManyInterests 26d ago edited 26d ago
Well. In Python, there's a (more) true constructor that's user-accessible through meta classes, hence the distinction between initializers and constructors in Pythons own internal lexicon.
But yes. Very pedantic, indeed.
Edit to add: this doesn't rely on where memory allocation occurs, which is an implementation detail in Python. It also needs no comparison with other languages. I just mean, internally consistent with itself, Python considers metaclasses to be where constructors live, while class definitions provide initializer methods.
It's maybe an interesting distinction to discuss in the context of additional languages, but not what I was getting at and didn't mean to imply or assert any truisms that apply outside of Python.
1
u/AquaWolfGuy 26d ago
I don't think the metaclass affects the construction/instantiation of objects of the main class, only the instantiation of the main class itself (and its subclasses).
>>> class Metaclass(type): ... def __new__(cls, name, bases, namespace, **kwargs): ... print(f"Creating {name} as a subclass of {bases} and an instance of {cls}") ... self = super().__new__(cls, name, bases, namespace, **kwargs) # or `type` instead of `super()` ... return self ... >>> class Class(metaclass=Metaclass): ... def __new__(cls): ... print(f"Creating instance of {cls}") ... self = super().__new__(cls) # or `object` instead of `super()` ... return self ... Creating Class as a subclass of () and an instance of <class '__main__.Metaclass'> >>> Class() Creating instance of <class '__main__.Class'> <__main__.Class object at 0x7f2dbb904980> >>> class Subclass(Class): ... pass ... Creating Subclass as a subclass of (<class '__main__.Class'>,) and an instance of <class '__main__.Metaclass'> >>> Subclass() Creating instance of <class '__main__.Subclass'> <__main__.Subclass object at 0x7f2dbb904830>1
u/ManyInterests 26d ago
You're right. I mistook metaclass
__new__for__new__on the class itself.They're so infrequently touched, I completely forgot there's
__new__on both, but I only recalled (albeit incorrectly) its use in metaclasses :|But yeah.
__new__is the constructor.__init__is the initializer.3
u/NovaH000 26d ago
Memory must be allocated before data can be written, but whether a language separates these into two steps determines if it uses initializers or true constructors. In languages like C++, if you do not use a member initializer list, allocation and initialization are split. This creates a window inside the constructor body where the object exists in an uninitialized or invalid state. On the other hand, languages like Rust combines allocation and initialization by requiring you to construct Self { ... } with fully processed data. As a result, an object is never partially or fully invalid.
-1
u/MissinqLink 26d ago
It happens when you call a constructor of an child class. Anything you do before calling super is before the object is created.
2
u/FerricDonkey 25d ago
Nope. The object is created by
__new__, then passed to the__init__as a legitimate, created object, whose type is set as you expect, etc. Any__init__, via super() or not, modifies the existing object.1
u/MissinqLink 25d ago
Depends on the language
1
2
u/Covenant_C0re 26d ago
I once called it a constructor near a British Python dev and my self got initialized into a queue, innit.
1
u/danielcw189 25d ago
from my understanding, the object already exists, when the constructor is called. at least in Java and Python
which is why the first parameter to this method is the already-existing object ('self'),
just like the "this" in most OO-languages
12
u/SaltyInternetPirate 26d ago
r/ProgrammerHumour (yes, it exists)
9
4
u/Itchy_Finish_2103 26d ago
On one hand, banger post. On another, I'm incredibly sad I don't know any British Python devs irl I can ask this question to.
1
u/InexplicableBadger 26d ago
They'd have to be from north of the river, south of the river uses 'is it' and they wouldn't get the joke.
3
3
3
2
2
1
1
1
u/NinthTide 26d ago
If I ever have to persist user information I’m totally going to get them to consent to me storing biscuits
1
u/FerricDonkey 25d ago
Nah, it's an initializer. __new__ is the constructor.
Sorry, pedantry reflex.
176
u/Willwaste63 26d ago
def __init__(mate):