Top-rated recipes tagged "classes"

Implementing class-based callbacks in Python (Python)

2017-04-20T23:34:50-07:00

Python recipe 580788 by Vasudev Ram (callbacks, classes, functions, methods, objects, programming, python).

This is a follow-on to this recently posted recipe:

Implementing function-based callbacks in Python: https://code.activestate.com/recipes/580787-implementing-function-based-callbacks-in-python/?in=user-4173351

This new recipe shows how to create and use callbacks in Python, using classes with methods, instead of plain functions, as was done in the recipe linked above. All other points such as reasons and benefits for using callbacks, are more or less the same as mentioned in the previous recipe, except that class instances can carry state around, so to that extent, the two approaches are different.

https://jugad2.blogspot.in/2017/04/python-callbacks-using-classes-and.html

Money Game (Python)

2014-12-22T23:38:38-08:00

Python recipe 578988 by Lance Spence (classes, games).

I created this simple program as a possible start to something larger while I continue to learn Python. It's a simple program that can be used to help young kids learn to count change in US currency.

Make a Class's Name Available in its Definition Body (Python)

2011-08-04T21:38:40-07:00

Python recipe 577813 by Eric Snow (classes).

Since a class object is created after the body is executed, it can't be available to the class body. Even the name is unavailable, at least by default. However, you can use the __prepare__() method in a metaclass to stick it in there. This recipe is a simple demonstration of how.

Calculate the MRO of a class (Python)

2011-06-11T08:31:09-07:00

Python recipe 577748 by Steven D'Aprano (c3, classes, method, mro, order, resolution).

This function allows you to calculate the Method Resolution Order (MRO, or sometimes linearization) of a class or base classes. This is the so-called "C3" algorithm, as used by Python (new-style classes, from version 2.3 and higher). The MRO is the order of base classes that Python uses to search for methods and attributes. For single inheritance, the MRO is obvious and straight-forward and not very exciting, but for multiple inheritance it's not always obvious what the MRO should be.

Mixin and Overlay (Python)

2011-06-01T05:16:47-07:00

Python recipe 577730 by Eric Snow (classes, inheritance, mixins).

The Two Sides of Classes

Class inheritance either adds new attributes to a class, or changes existing attributes. However, this distinction is not made in Python's class system. This recipe is a stab at providing that separation. It takes advantage of metaclasses and class decorators to do it.

For this recipe the two sides of class inheritance are called mixins and overlays. Mixins add new attributes to a class. Overlays change existing attributes, which in the case of methods means changing the behavior of the methods. However, overlays do not add any attributes.

Separation of Concerns

Another issue with class inheritance is that abstraction rarely breaks down into perfect trees with a clear separation of concerns. Python allows multiple inheritance, which can help, but requires cooperation between classes in the diamond hierarchy. Mixins and overlays help with this problem. Hopefully, that will be evidenced by the recipe and subsequent examples.

With this approach, the main single inheritance line can focus on the core abstraction and mixins/overlays can be used to extend the classes in other directions. This does not solve all the problems regarding separation of concerns, but it solves some. I hope to address the rest in another recipe that centers around delegation through a component architecture on instances.

Interfaces

Since Python 2.6 we have had Abstract Base Classes providing a mechanism for promising what interfaces an object provides. I'll show in one of the examples how an ABC can be split into a interface portion and a mixin portion. The recipe takes advantage of the ABC functionality in the Python type system. I expect that mixins and overlays would be a good fit with one of my other recipes (Recipe 577711).

The Recipe Classes

This recipe provides a standard approach to applying mixin classes without using inheritance. This is done through a metaclass. The metaclass builds a __mixins__ attribute on the class and provides a mixes_in class decorator. Applying that decorator to the class will add the attributes in __mixins__ to the decorated class. However, if any of those names are already bound on the name then it will fail. The decorator returns the modified class.

Note: Traditional mixins are typically done through multiple inheritance, as opposed to class decorators.

This recipe also provides a companion to mixin classes, called overlays. This is done through a metaclass in exactly the same way as the mixins, but provides an __overlays__ attribute and a class decorator called overlays. In contrast to mixins, if an overlay attribute is missing on the decorated class, it will fail. This is because the decorator will return a new class that inherits from the decorated class, and overrides the attributes in __overlays__.

Note: Metaclasses are used here because we need to pull from the class namespace there. A class decorator does not afford us the same functionality without more complexity.

Note: This recipe should work fine in 2.7 with a switch to the __metaclass__ syntax.

Trace decorator for debugging (Python)

2011-01-24T18:40:51-08:00

Python recipe 577551 by Kevin L. Sitze (classes, debug, debugging, decorators, functions, inspection, modules, trace). Revision 2.

This package provides a decorator for tracing function and method calls in your applications. The tracing capabilities are managed through the logging package, and several mechanisms are provided for controlling the destination of the trace output.

It also provides functionality for adding decorators to existing classes or modules.

Tracking Child Classes (Python)

2012-05-30T10:00:21-07:00

Python recipe 578137 by Evert van de Waal (child, classes).

This recipe allows a base class to keep track of the child classes that inherit from it using a metaclass.

Turn a Function Into a Class (Python)

2011-10-05T18:38:43-07:00

Python recipe 577822 by Eric Snow (classes, functions).

The only catch is that the function has to return locals() at the end. And it doesn't do the __prepare__ part of 3.x metaclasses.

Simple Abstract "Constants" to Use When @abstractproperty is Overkill or Misleading (Python)

2011-08-12T23:35:45-07:00

Python recipe 577761 by Eric Snow (attributes, classes).

Use these instead of abstract properties when you don't plan on the abstract attribute being implemented with a property. And you can still give your attribute a docstring!