Group items tagged

if A: will call A.__nonzero__()

and so A is not None is faster since there is much less work to do

if A: seems to be more efficient

To do element-wise operations on a list - for example, to produce a list consisting of each element of list A multiplied by 2 Method 1 [2*x for x in A] - this technique is called list comprehension Method 2 if you have defined a function double(x) which doubles x map(double, A) Method 3 define the function that doubles x on the fly, anonymously map(lambda x: 2*x, A)

Comprehensions are just a simple form of iterators. Generators are just a simple form of iterators

The first argument of every class method, including the __init__() method, is always a reference to the current instance of the class. By convention, this argument is named self.

self is not a reserved word in Python, merely a naming convention

usually __iter__() just return self if you have already define the next() method (generator object)

While you are looking at the collections module, consider inheriting from Sequence, Mapping or another abstract base class if that is more appropriate. Here is an example for a Sequence subclass:

if hasattr(self.data[0], "__iter__": return self.data[0].__iter__() return self.data.__iter__()

I just found xrange() (suprised I hadn't seen it before...) and added it to the above example. xrange() is an iterable version of range() which has the advantage of not prebuilding the list

a much better way to write GUI apps in Python is to use Trolltech's QT Designer to WYSIWYG-ly create a nice-looking interface, and then automatically generate the necessary code for it with pyuic (which is a UI compiler for QT that comes with the PyQT package.)

The subprocess module allows you to spawn new processes, connect to their input/output/error pipes, and obtain their return codes. This module intends to replace several other, older modules and functions, such as: os.system os.spawn* os.popen* popen2.* commands.*

If print() is a function, it would be much easier to replace it within one module (just def print(*args):...) or even throughout a program (e.g. by putting a different function in __builtin__.print). As it is, one can do this by writing a class with a write() method and assigning that to sys.stdout -- that's not bad, but definitely a much larger conceptual leap, and it works at a different level than print.

here are the basic rules for the customization of ==, !=, <, >, <=, and >=: For all six of the above operators, if __cmp__ is defined on the left-hand argument, it is called with the right-hand argument. A result of -1 indicates the LHS is less than the RHS. A result of 0 indicates they are equal. A result of 1 indicates the LHS is greater than the RHS

__eq__ is not used for !=

For <, __lt__ is used. For >, __gt__. For <= and >=, __le__ and __ge__ respectively

The Dependency Injection (DI) is an essential pattern when building large systems. It forces classes to be more modular and reusable by making them depend on an interface instead of a concrete class. Simply put classes favor instances passed into the init instead of creating new instances.

The FOX toolkit is an open source, cross-platform widget toolkit, that is, a library of basic elements for building a graphical user interface (GUI). FOX stands for Free Objects for X.

FOX differentiates itself in the following way from other cross-platform toolkits: Tk is a cross-platform toolkit but does not have all of the widgets that FOX considers desirable. Qt had a different licensing model, which might have required a commercial license in some cases where FOX would not. (This is no longer the case starting with Qt 4.5.) wxWidgets promotes the use of native widgets on each supported platform. FLTK is a fast, low-footprint library that supports rapid application development, and requires less code to use, but lacks advanced widgets. All of these toolkits have some support for programming natively on Mac OS and/or Mac OS X platforms, which FOX currently does not support[

ABOUT Slut is a programming framework for generative, synthetic, interactive, network-enabled graphics. Slut generates images from processes. Such processes may be simple "construction plans" or they may depend on user input. They may be drawn from incoming network data or messages that are sent to the network. Produced images may be adaptive, accumulative or static. They may look and feel like computer games or they may inform like scientific visualizations. They may be lyrical, cynical, political, intrusive (literally over the network), simply beautiful or banal.

Setting Up a Pygame Program