Search results
Results From The WOW.Com Content Network
Python 3 has only new-style classes that are declared as class A:, class A(object): or class A(B):. For classic-style classes, a comparison operation always calls the method of the first operand, while for new-style classes, it always calls the method of the subclass operand, regardless of the order of the operands .
Functions, in Python, are first class objects - which means you can pass a function as an argument to another function, and return functions. Decorators do both of these things. If we stack decorators, the function, as defined, gets passed first to the decorator immediately above it, then the next, and so on.
A class definition is a bit different from a function/method definition. The parentheses in class definitions are for defining from which class you inherit. You don't write def in front of it, and when you inherit from 'object' which is the default you don't need the parentheses for the definition. So you can write either: class C(): Or: class C:
I noticed that in Python, people initialize their class attributes in two different ways. The first way is like this: class MyClass: __element1 = 123 __element2 = "this is Africa" def __init__(self): #pass or something else The other style looks like:
Here we have __init__, a typical initializer of Python class instances, which receives arguments as a typical instance method, having the first non-optional argument (self) that holds a reference to a newly created instance. Class Method. We have some tasks that can be nicely done using classmethods.
If you're still using Python 2, note that the above method works with new-style classes only (in Python 3+ all classes are "new-style" classes). Your code might use some old-style classes. Your code might use some old-style classes.
Apart from the question whether class decorators are the right solution to your problem: In Python 2.6 and higher, there are class decorators with the @-syntax, so you can write: @addID class Foo: pass In older versions, you can do it another way: class Foo: pass Foo = addID(Foo)
A user of course can make a custom special method, which is a very rare case, but often might modify some of the built-in special methods (e.g. you should initialize the class with __init__ that will be executed at first when an instance of a class is created).
Deriving an exception class that does not add new behaviour (e.g., in SciPy): class CompileError(Exception): pass Similarly, classes intended as abstract base class often have an explicit empty __init__ or other methods that subclasses are supposed to derive (e.g., pebl):
In more detail, Python 2.x has docstrings, which allow you to attach a metadata string to various types of object. This is amazingly handy, so Python 3 extends the feature by allowing you to attach metadata to functions describing their parameters and return values. There's no preconceived use case, but the PEP suggests several.