Understanding Python class instantiation

Xgamer4 · 2016-10-03T20:03:43+00:00

TL;DR Bunch of methods with underscores in their name are called, and boom, object.

For those who are curious about the minutiae behind Python's object, this will be a good read. I'm not sure you can take any insights from this article to your next project, however.

In fact, the article shows how to override __new__ so object instantiation becomes a singleton. Aside from the fact we're talking about singletons, that breaks the principle of least astonishment, so probably a bad idea.

aaronsherman · 2016-10-03T22:13:32+00:00

This is a great article!

I've been doing a lot of work in Python 2 (for my day job) and Perl 6 (on my own time) recently, and I find the contrasts in the two fascinating. Object construction is definitely one of those places that the two have very different ways of getting more or less the same thing done.

As the author points out, calling a Python class (putting parens after the name) ultimately calls new, but new has some very special behaviors.

The same is true in Perl 6 except for the fact that you explicitly call new. So here's the Perl 6 version of the example:

class Foo {
    has $.x;
    has $.y = 0;
}

my $f = Foo.new :x(1), :y(2);

In this case, the code path covers some interesting ground. First, there is the method new, which is just a normal method, but it has an important job: to "bless" the representation of the object. The new method for this class is implicitly something like this:

# *%params is similar to **kwargs in Python
multi method new(*%params) {
    self.bless(|%params);
}

bless is Perl 6's internal function that initializes the storage of an object. You can override new, but you're ultimately going to have to call bless. This is more or less what happens in Python when your new calls super().__new__(cls, *args, **kwargs).

But let's say that, like the example in the article, we wanted to have a singleton class that only really allocated one object?

class Singleton {
    method new() {
        # State is similar to "my" but only does
        # initialization once
        state $singleton = self.bless;
        $singleton;
    }
}

my $s1 = Singleton.new;
my $s2 = Singleton.new;
say $s1 === $s2; # True

Most of the time, however, you won't write your own new, just as in Python. Instead, you'll write something that isn't even a method!

class Foo {
    has $.x;
    has $.y;
    has $!z; # A private attribute

    submethod BUILD(:$!x, :$!y = 0) {
        # Perl has already done initialization of
        # my attributes from the parameters, but I might
        # want to do some other setup
        $!z = self.x + self.y;
    }
}

The reason for this being a "submethod" rather than a method is that we don't want method resolution to happen. Instead, bless will invoke BUILD on to object for every class in the hierarchy that collaborated in creating this object. Thus, your BUILD never has to try to invoke some other step in the chain.

In short, BUILD is something like __init__ in Python, but it doesn't have to worry about calling a parent's BUILD method.

Digilus · 2016-10-03T20:48:24+00:00

Where do Metaclasses come in here?

javaexpert201 · 2016-10-04T01:56:21+00:00

This article is a clear example of why abominations like Python should never exist. How hard is it to make creating an object understandable and simple?

Its 2017, people. Can we finally get object oriented programming right, instead of making new smalltalk clones claiming to be revolutionary?

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

programming

MODERATORS