I have a class which sets up some class vars, then several methods that
are passed in data and do work referencing the class vars.
When you say "class vars", do you mean variables which hold classes? Like
"string vars" are variables which hold strings, and "int vars" are
variables that hold ints? Classes (also known as types) are first-class
objects in Python (no pun intended), unlike Java, and so you can store
them in lists, returns them from functions, and bind them in variables.
for aclass in list_of_classes:
do_something_with(aclass)
Consequently, when people talk about "class variables", it is ambiguous,
which is why we prefer to use "class attribute" to refer to attributes on
the class. For example:
class Parrot(object):
breed = "Norwegian Blue" # this is a class attribute
def __init__(self, name="Polly"):
self.name = name # this is an instance attribute
def speak(self):
s = "%s the %s says, 'Hello sailor!'"
print(s % (self.name, self.breed))
Class attributes are attached to the class object itself, and are shared
between all instances. Instance attributes are attached to the instance,
where they over-ride any class attribute of the same name, and are not
shared.
In the following I am going to assume that you actually are talking about
attributes, rather than an actual variable holding a class.
I want to decorate these methods, the decorator needs access to the
class vars, so I thought about making the decorator its own class and
allowing it to accept args.
The one doesn't follow from the other. Writing decorators as classes is
fairly unusual. Normally, they will be regular functions. If your
decorator needs to store so much state that it needs to be a class,
you're probably trying to do too much from a single decorator.
There's more that you need to describe, such as what it is that the
decorator actually does, and whether it does it once, when the decorator
is called, or repeatedly, when the decorated method is called.
The second case is the easiest. Suppose you have a class like this, with
many methods which have code in common. Here's a toy example:
def MyClass(object):
x = "class attribute"
def __init__(self, y):
self.y = y
def spam(self):
do_stuff(self.x)
do_stuff(self.y)
print("spam spam spam spam")
def ham(self):
do_stuff(self.x)
do_stuff(self.y)
return "ham, a growing boy's best friend"
def eggs(self, food="bacon"):
do_stuff(self.x)
do_stuff(self.y)
return "green eggs and %s" % food
A simple decorator function can simplify the common code:
import functools
def decorate(func):
@functools.wraps(func)
def inner(self, *args, **kwargs):
# call the common, repeated, code
do_stuff(self.x)
do_stuff(self.y)
# call the function being wrapped
return func(self, *args, **kwargs)
return inner
def MyClass(object):
x = "class attribute"
def __init__(self, y):
self.y = y
@decorate
def spam(self):
print("spam spam spam spam")
@decorate
def ham(self):
return "ham, a growing boy's best friend"
@decorate
def eggs(self, food="bacon"):
return "green eggs and %s" % food
Notice that because the decorator doesn't do any work until the decorated
function is called, there is no difficulty in accessing attributes
regardless of whether they are attached to the class or the instance.
They won't be looked up until self is known.
A more complicated case is where you need to do some pre-processing, and
you *don't* want that calculation repeated every time the method is
called. Decorators are fantastic for that case too, but here you cannot
access instance attributes, since the instance doesn't exist yet. But you
can access *class attributes*, as more-or-less ordinary local variables
*inside* the class definition. Here's a working sketch of the sort of
thing you can do. Copy and paste the following into a Python interactive
session, and then see if you can follow what is being done when.
# === cut ===
import functools
def decorator_factory(a, b):
# This is a factory function that returns a decorator.
# First we do so pre-processing. This gets called only once (per
# usage of the decorator).
value = a*10 + b - 1
print("precalculation of value = %s" % value)
def decorator(func):
print("decorator called on method '%s'" % func.__name__)
@functools.wraps(func)
def inner(self, fe, fi, fo):
return func(self, fe, fi, fo, fum=value)
return inner
# return the decorator
return decorator
class MyClass(object):
spam = 42
ham = 23
@decorator_factory(spam, ham)
def my_method(self, fe, fi, fo, fum):
print(fe, fi, fo, fum)
x = MyClass()
x.my_method(1, 2, 3)
# === end cut ==
Is your mind boggled yet?
Of course, decorators don't *have* to be functions, they can be any
callable object, such as an instance with a __call__ method. But beware
of making your code too clever. Decorators are powerful, but you can over
do it, and make your code unreadable.
I was hoping to do all the work on in_data from within the decorator,
which requires access to several MyClass vars. Not clear on the
syntax/usage with this approach here, any guidance would be greatly
appreciated!
It's not clear what you actually need to do, so I can't give you any more
guidance apart from the sort of thing that is possible with decorators.
