Popular recipes tagged "class"

Auto assign self attributes in init using PEP 484 (Python)

2017-04-26T17:26:29-07:00

Python recipe 580790 by Ryan Gonzalez (annotations, class, self, type). Revision 2.

TL;DR: Short way of doing stuff like def __init__(self, a, b): self.a = a; self.b = b, using type annotations from PEP 484, inspired by Dart's MyConstructor(this.a, this.b) and Ruby's/Crystal's/(Moon|Coffee)Script's constructor/initialize(@a, @b).

Python add/set attributes to list (Python)

2015-09-29T16:28:46-07:00

Python recipe 579103 by webby1111 (attributes, class, dictionary, list, subclass). Revision 3.

Python Attribute List

Add/set attributes to python lists.

A google search for "add attributes to python lists" yields no good stackoverflow answer, hence the need for this.

Useful for machine learning stuff where you need labeled feature vectors.

This technique can be easily adapted for other built-ins (e.g. int).

The Problem

a = [1, 2, 4, 8]
a.x = "Hey!" # AttributeError: 'list' object has no attribute 'x'

The Solution

a = L(1, 2, 4, 8)
a.x = "Hey!"
print a       # [1, 2, 4, 8]
print a.x     # "Hey!"
print len(a)  # 4

# You can also do these:
a = L( 1, 2, 4, 8 , x="Hey!" )                 # [1, 2, 4, 8]
a = L( 1, 2, 4, 8 )( x="Hey!" )                # [1, 2, 4, 8]
a = L( [1, 2, 4, 8] , x="Hey!" )               # [1, 2, 4, 8]
a = L( {1, 2, 4, 8} , x="Hey!" )               # [1, 2, 4, 8]
a = L( [2 ** b for b in range(4)] , x="Hey!" ) # [1, 2, 4, 8]
a = L( (2 ** b for b in range(4)) , x="Hey!" ) # [1, 2, 4, 8]
a = L( 2 ** b for b in range(4) )( x="Hey!" )  # [1, 2, 4, 8]
a = L( 2 )                                     # [2]

Data (A Class For Arbitrary Data) (Python)

2015-08-03T15:22:40-07:00

Python recipe 579092 by Alfe (class, data, lightweight).

A class which is designed to be easy to use when one needs a piece of data with a minimum of source required.

Usage:

shop = Data(owner="Homer", address="down the street", ice=Data(flavor="vanilla", amount=3))
print shop
Data:
  owner = 'Homer'
  ice = Data:
          amount = 3
          flavor = 'vanilla'
  address = 'down the street'

Find what class an attribute - ie, myObj.myAttr - comes from, and how it's defined (Python)

2012-10-26T12:59:47-07:00

Python recipe 578305 by Paul Molodowitch (attribute, attributes, class, debugging, inspection, source, __dict__, __getattribute__, __getattr__, __slots__). Revision 3.

When inspecting new code (or when debugging), it can be handy to know exactly where a given attribute on an object or class comes from.

As a simple example, if you have a class MyClass, you might want to know where MyClass().myMethod is defined.

However, things can get tricky when things like __getattr__, __getattribute__, or even compiled objects come into play. That's where this function comes in. It returns what class a given attribute comes from, and what method was used to define it - ie, '__dict__' ('normal' definitions), '__slots__', '__getattr__', '__getattribute__', '(BUILTIN)'.

(Note - this function should't be relied on to be 100% accurate - rather, it's a best guess, for where to look to find it. It takes some pretty infrequent edge cases for it to be wrong, though...)

DoubleDict (Python)

2012-07-24T21:24:14-07:00

Python recipe 578224 by Stephen Chappell (class, dictionary).

After seeing requests for being able to access keys in a dictionary by value, the following recipe was born. It creates the DoubleDict class and allows just that. To ensure that only one key is returned when accessing it by value, values must be unique just as keys are unique, and this rule is automatically enforced. Most dictionary methods are supported, and many more are added to allow working with the dictionary from the view of the values instead of the keys. Several optional metaclasses are also provided to enable optional features in the DoubleDict class such as data consistency checks and atomic method execution.

Progress bar class (Python)

2012-08-09T17:39:10-07:00

Python recipe 578228 by Xavier L. (class, cli, curses, files, module, progress). Revision 5.

See gist:3306295 for future developments.

Here is a little class that lets you present percent complete information in the form of a progress bar using the '=' character to represent completed portions, spaces to represent incomplete portions, '>' to represent the current portion and the actual percent done (rounded to integer) displayed at the end:

[===========> ] 60%

When you initialize the class, you specify the minimum number (defaults to 0), the maximum number (defaults to 100), and the desired width of the progress bar. The brackets [] are included in the size of the progress bar, but you must allow for up to 4 characters extra to display the percentage.

You'd probably want to use this in conjuction with the curses module, or something like that so you can over-write the same portion of the screen to make your updates 'animated'.

CLOS-like around/before/after auxiliary methods (Python)

2011-08-25T22:59:22-07:00

Python recipe 577859 by Jan Kaliszewski (auxiliary, class, clos, decorator, inheritance, method, object, super).

This module provides an easy way to define and use your own around/before/after auxiliary methods, similar to those used in CLOS (Common Lisp Object System).

Make a Class Available in its Own Definition Body! (Python)

2011-09-15T05:36:36-07:00

Python recipe 577867 by Eric Snow (class, metaclass).

This may sound too good to be true, but see for yourself. No time machines involved. Just plug in this metaclass and look for __newclass__ in your class body. It's not perfect, but the problematic corner cases are more bark than bite.

Concrete Class Finder (Python)

2011-08-24T05:29:15-07:00

Python recipe 577858 by Lucio Santi (case, class, design, finder, match, oop, pattern, suitable, switch).

This recipe implements a design pattern useful for performing an object-oriented case analysis for a particular object (or a collection of objects as well). Essentially, it is an alternative to complex if-then-else or switches. Modelling each case with a particular class, the Concrete Class Finder searches for an appropriate case/class that applies to the given object/s. Once found, this class can be used in an homogeneous way, independently of the object/s previously considered.

Dynamically modifying class attributes at runtime (Python)

2011-03-31T20:07:18-07:00

Python recipe 577628 by Nabil Stendardo (class, modification, monkeypatching, open).

However considered bad programming, Ruby/JavaScript-like open classes (i.e. classes which can be modified at runtime) actually can be a programming pattern when developing plug-in architectures. And, guess what, Python has that functionality too. This code allows to add attributes (typically methods) to classes, even when already instantiated.

Make the New Class Available During the Execution of its Body (Python)

2011-08-12T23:44:46-07:00

Python recipe 577744 by Eric Snow (class, metaclass).

When a class object is created, normally the class body is exec'ed first and then the class object is generated with that resulting namespace.

This recipe lets you flip that around, and then make the class object available to the class body during execution.

A flexible state machine class (Python)

2011-05-18T15:17:02-07:00

Python recipe 577701 by Mike Sweeney (class, state_machine). Revision 2.

The operation of the state machine is defined by transitions. The transitions control what value is returned and which new state to switch to, given an "event" input when in a certain current "state". State machines have many applications such as games, process controls, and language parsing.

Keyword Argument Injection with Python Decorators (Python)

2010-09-05T17:06:04-07:00

Python recipe 577382 by Ahmet Emre Aladağ (class, class_decorator, decorator, injection, variable). Revision 2.

In most of the object oriented codes we write, we need to set class attributes to the given argument values and this is a very line-consuming thing. To get over these redundant lines, I found a solution using decorators.

Easy property creation and control (Python)

2010-12-01T17:22:49-08:00

Python recipe 577482 by Kevin L. Sitze (class, property, property_creation, tools, unittests).

The Property class provides basic functionality that allows class level control over how a particular attribute is managed. In its simplest form a Property attribute works exactly like a regular attribute on an instance while providing documentation details about the attribute accessible via the declaring class.

Find all subclasses of a given class (Python)

2009-11-04T20:26:08-08:00

Python recipe 576949 by Gabriel Genellina (class, extending, inheritance, plugin, subclass, subclasses, type). Revision 3.

itersubclasses(cls) returns a generator over all subclasses of cls, in depth first order. cls must be a new-style class; old-style classes are not supported.

Docstring inheritance class decorator (Python)

2011-11-23T20:12:03-08:00

Python recipe 577102 by Alec Thomas (class, decorator, docstring, inheritance). Revision 2.

Inherits method docstrings from parent classes.

Alias class attributes (Python)

2009-06-01T01:19:55-07:00

Python recipe 576787 by Euan Goddard (alias, attribute, class, descriptor, metaclass).

The alias metaclass allows a declarative way of creating aliases to attributes on a class. The main purpose of which is to adapt classes for duck-typing (see doc-string for me detail).

Easy Property Creation in Python (Python)

2009-05-06T11:59:16-07:00

Python recipe 576742 by runsun pan (class, property, property_creation). Revision 4.

Presented in this recipe is a function prop, with that a property myprop can be created as simple as:

@prop
def myprop(): pass

It has only 7 lines of code, easy to understand, easy to customize, will make the code look much netter and will save you a lot of typing.

See discussion and the doc test string for more complicated usages.

Note: This is a recipe created with python v.2.5.2.

Subclass function (Python)

2009-03-23T00:48:54-07:00

Python recipe 576697 by Peter Russell (class, metaprogramming, subclass). Revision 4.

Do not use this function - instead use the built in type(name, bases, dict) constructor This is a function that builds a subclass of some base classes. I wrote it while unaware that type could be used as a constructor.