Python Pitfalls: Passing and Using Class vs. Class Object Type Parameters

Preface

For beginners, Python is indeed simple and easy to use. After all, it's a dynamically typed language—you can use things without defining them, and freely converting between types couldn't be more convenient. So using Python to write small scripts, crawlers, and the like is no problem. However, once you use it to develop a slightly larger project, such as building a web application, you'll run into some issues. People who generally lack experience will fall into certain pitfalls. = =...

Pitfalls

Let's talk about the pitfalls first. Function parameter types are one pitfall, and classes versus class objects are another. Although I had figured this out when using other statically typed languages (such as C#/Java), switching to dynamically typed Python always leaves one a bit puzzled.

Example

Let me illustrate with code.

First, define two classes, both inheriting from the built-in Exception class, which means these two classes are exception classes.

class Error1(Exception):
    def __str__(self):
        return 'error1'


class Error2(Exception):
    def __init__(self):
        print('error2 init')

    def __str__(self):
        return 'error2'

Then define methods for handling exceptions:

def error(err: object):
    print(f'err:{err.__str__()}')

def error2(err: Exception):
    print(err)

Next is the test code:

try:
    raise Error1
except Error1 as e:
    error(e)

if 1 != 2:
    error(Error2)

Running result:

err:error1
  File "/home/test.py", line 33, in <module>
    error(Error2)
  File "/home/test.py", line 19, in error
    print(f'err:{err.__str__()}')
TypeError: __str__() missing 1 required positional argument: 'self'

The result of the first error() is fine, but the second one then threw an exception. Let's look at the error message first: TypeError: __str__() missing 1 required positional argument: 'self'. The self parameter was not provided, because this argument is not an instance of the Error2 class, so naturally there is no self parameter.

At this point you should have some idea: when calling the error(Error2) method, the Error2 argument passed in is actually the Error2 type itself, not an object of it. It's a bit magical that you can actually use a type as an argument.

So how do we solve this? It's simple: just pass in an object of Error2. The code is as follows:

if 1 != 2:
    error(Error2())

Running result

error2 init
err:error2

No problem now. There's still an error2 method in the code above that hasn't been used. Let's try it.

error2(Error2)
error2(Error2())

Running result

<class '__main__.Error2'>
error2 init
error2

As you can see, when using print(Object), if it's a type, it prints information about that type; only when it's an object of the type will it print the result returned by Object.__str__(). Once you understand it, it's actually quite simple. But Python doesn't restrict function parameters. Even if you add type hints to methods, they only serve as hints and don't actually enforce restrictions or implicit conversions. So sometimes after writing code for a long time and getting dizzy, it's easy to fall into the dynamic typing pit T_T...

As is international custom, here's an image: