用于在Python中为变量分配类的用途

Question

Is there any good reason why one would assign a class to a variable as shown in the code below ? What are some useful/interesting things one can do thanks to that mechanic ?

class foo:

    # Some initialization stuff
    def __init__(self):
        self.x = 0

    # Some methods and other stuff

myVar = foo

Answer 1

The case I've seen most often in production code is dependency injection or "compile-time" configuration.

For example, I may have some classes that implement some strategy or command, but I don't have the details for the constructor yet.

class StrategyOne:...
class StrategyTwo:...

def my_func(vars, Strategy):
    x = some_calculation(vars)
    st = Strategy(x)

An example of using this as configuration can be seen in the django-rest-framework docs

class AccountSerializer(serializers.ModelSerializer):
    class Meta:
        model = Account
        fields = ('id', 'account_name', 'users', 'created')

I think most uses cases fall into the principle of "I don't want to couple to this particular class". Another level of indirection and all.

Take the type checking example for instance. The loop over the collection of types [x for x in lst if isinstance(x, types)] does not depend on any particular types and is thus decoupled from the contents of the list of types.

Answer 2

One important use-case certainly is for type checking or filtering:

class Foo:
    pass

lst = ["bla", 42, Foo()]
types = (str, Foo)
filtered = [x for x in lst if isinstance(x, types)]
# ['bla', <__main__.Foo at 0x7fa3422aa668>]

Another might be for dynamically creating instances of some class, eg with defaultdict .

class Bar:
    def __init__(self):
        self.value = 0

from collections import defaultdict
d = defaultdict(Bar)
for x, y in [(1,1), (1,2), (2,3), (2,4)]:
    d[x].value += y
print(d[1].value) # 3

Answer 3

There are many possibilities. One could be if you have multiple classes, and you want to access the same attribute from all of them.

For example:

classes = [Class1, Class2, Class3]

for c in classes:
    print(c.__dict__)

Answer 4

The only possible reason I can think of is that you will call the constructor multiple times. So, instead of

x1 = foo()
x2 = foo()
x3 = foo()

you can write

cls = foo
x1 = cls()
x2 = cls()
x3 = cls()

So, you can only change cls=foo with cls=bar , and the rest needs no changes.

However, this is only appropriate for code snippets, just to try something quickly. If you actually need to do something multiple times, write a function.