OOP Method Types Comparison

thanks for this video! Help me to demystify the difference between classmethod and staticmethod.

My first thought was that I could build various constructor, e.g. from_file, from_db, from_api, etc. using @classmethod, but I think that’s wrong…

At least I see no advantage to using it that way.

How would you design a class with various constructors that way?

How about this?

class X():
    def __init__(self, file_name = None, db_name = None):

        if file_name is not None:
            self.from_file(file_name)

        if db_name is not None:
            self.from_db(file_name)

       ...

That way you can call X(file_name = 'blah') or x = X() and then x.from_file(file_name).

Not sure if that is pythonic?

@Dan B Your thinking was right, and I don’t see why you wouldn’t take advantage of the @classmethod decorator to create so-called named constructors. Take a look at the following example:

from collections import namedtuple

class Color(namedtuple('Color', 'r g b')):

    @classmethod
    def exotic_red(cls):
        return cls(1, 0, 0)

    @classmethod
    def monaco_blue(cls, metallic=False):
        if metallic:
            raise Exception('Not available')
        return cls(0.2, 0.5, 0.75)

These methods don’t force you to hardcode the class name because of the cls parameter representing the Color class.

The .__init__() method should only accept some initial state to store in the object, whereas in your example, it contains business logic that forks into a few paths depending on how it was called. Moreover, it lets you create an object with a broken state, which doesn’t have any data loaded from a file nor a database.

Sorry Bartosz, I’m confused…

Where to learn about classes and what should / shouldn’t be in an __init__ method?

My thinking was that it’s just an ‘empty’ individual if neither a file nor a database is given. Is that bad practice?

I’m quite confused by how you’re building the class with a namedtuple (I’ve been using namedtupels for a while, so I think I know how they work, it’s classes I’m not good at).

Many thanks, Dan.

P.S. Also… not sure how to @ you either! Thanks.

Ahh… soo… namedtuple returns a class… so your Color class is just the subclass of the named tuple class that gets ‘called’ when the constructor is wah…

Sorry, I got confused about this: florimond.dev/blog/articles/2018/08/python-mutable-defaults-are-the-source-of-all-evil/

Because tuples are immutable, I guess it’s OK to use it in the class definition here.

I still don’t see how I’d use @classmethod to build a class from a file that had any advantage over just a Class with a ‘from_file’ method.

@Dan B

Sorry Bartosz, I’m confused…

Maybe that wasn’t the most straightforward example. You can forget about the namedtuple and replace it with a little bit of code written by hand:

class Color:

    @classmethod
    def exotic_red(cls):
        return cls(1, 0, 0)

    @classmethod
    def monaco_blue(cls, metallic=False):
        if metallic:
            raise Exception('Not available')
        return cls(0.2, 0.5, 0.75)

    def __init__(self, r, g, b):
        self.r, self.g, self.b = r, g, b

    def __repr__(self):
        return f"Color(r={self.r}, g={self.g}, b={self.b})"

Where to learn about classes and what should / shouldn’t be in an __init__ method?

It’s a matter of practice and learning about good programming principles in general through code reviews, for example.

P.S. Also… not sure how to @ you either! Thanks

There’s no way to @-mention someone at the moment. I simply write someone’s name and bold it so that we have an idea of how to navigate the conversation in a flat list of comments.

I still don’t see how I’d use @classmethod to build a class from a file that had any advantage over just a class with a from_file method.

That’s how you could use the @classmethod decorator as a named constructor in your example:

class X():

    @classmethod
    def from_file(cls, filename):
        with open(filename) as fp:
            return cls(fp.read())

    @classmethod
    def from_db(cls, database):
        with connect(database, ...) as db:
            with db.cursor() as cursor:
                return cls(cursor.execute("SELECT * FROM ..."))

    def __init__(self, data):
        self.data = data

But you could also use the @staticmethod decorator or move those methods out from the class entirely and use regular functions. It’s a question where this code belongs to logically.

The advantage to using named constructors over building the object yourself in steps is that you can’t have a partially initialized object. It’s either initialized fully or not at all, which follows the fail-fast principle.

Bonus indeed.

realpython.com/courses/python-method-types/

Which Editor is this ?

I’m using an alternative Python REPL called bpython in my videos. You can learn more about it here: bpython-interpreter.org. If bpython is difficult to install, I can also recommend ptpython.

I’m running the REPL inside iTerm 2 on macOS.