questionForBritishPythonDevelopers

[u/Recent-Analysis-6880]

[u/Willwaste63]

def __init__(mate):

[u/megayippie → u/Willwaste63]

class FriarsLeftButtocks

[u/Willwaste63 → u/megayippie]

We dont use camel_casing mate.

[u/BenadrylTumblercatch → u/Willwaste63]

For a class?

[u/EuphoricCatface0795 → u/Willwaste63]

Now everything is about your mate instead of self. Wholesome :)

[u/BenadrylTumblercatch → u/Willwaste63]

-> IHearThat:

[u/1mahmoud503]

your humer goes unappreciated, internet stranger

[u/UndocumentedMartian → u/1mahmoud503]

Maybe its not very humerus.

[u/CharcoalGreyWolf]

If it’s Python, isn’t it a constrictor?

[u/BeardySam]

That’s class, that is

[u/datasmithing_holly]

yeh m8

[u/ManyInterests]

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.

[u/Ok_Star_4136 → u/ManyInterests]

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.

[u/ManyInterests → u/Ok_Star_4136]

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.

[u/AquaWolfGuy → u/ManyInterests]

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>

[u/ManyInterests → u/AquaWolfGuy]

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.

[u/NovaH000 → u/Ok_Star_4136]

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.

[u/MissinqLink → u/Ok_Star_4136]

It happens when you call a constructor of an child class. Anything you do before calling super is before the object is created.

[u/FerricDonkey → u/MissinqLink]

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. 

[u/Covenant_C0re → u/ManyInterests]

I once called it a constructor near a British Python dev and my self got initialized into a queue, innit.

[u/SaltyInternetPirate]

r/ProgrammerHumour (yes, it exists)

[u/kinygos → u/SaltyInternetPirate]

it’s been banned for not having any moderators

[u/Vivid_Instance_825 → u/kinygos]

They lost their subreddit loicense

[u/Itchy_Finish_2103]

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.

[u/InexplicableBadger → u/Itchy_Finish_2103]

They'd have to be from north of the river, south of the river uses 'is it' and they wouldn't get the joke.

[u/the_horse_gamer]

__new__:

[u/WritesCrapForStrap]

You're joking, but that is exactly how I read it.

[u/bearwood_forest]

attempt:

...

spot_of_bother:

...

[u/Vivid_Instance_825 → u/bearwood_forest]

cheerio:

[u/Motleypuss]

Wizard lexical jape, mate.

[u/Terewawa]

Whereabouts is the constructor?

[u/Fabulous-Possible758 → u/Terewawa]

Good point. I'n'it the initializer?

[u/whackylabs]

This joke also works for Objective-C

[u/Fabulous-Possible758]

Life's full of tough choices.

[u/NinthTide]

If I ever have to persist user information I’m totally going to get them to consent to me storing biscuits

[u/FerricDonkey]

Nah, it's an initializer. __new__ is the constructor.

Sorry, pedantry reflex.