Popular recipes tagged "meta:loc=209"

Python Game of Life (Python)

2014-01-14T14:34:17-08:00

Python recipe 578808 by Christian Careaga (game, pygame, python).

Conway's Game of Life written in Python with Pygame!

Here is a screenshot: http://adf.ly/c4cnA

Here is the exe version!: http://adf.ly/c4bMO

Hope you like it!

A point-in-polygon program (S.W. Sloan algorithm) (Python)

2014-04-24T18:13:34-07:00

Python recipe 578381 by PG (point, polygon). Revision 2.

Class to compute if a point(s) lies inside/outside/on-side of a polygon.

UPDATE: The class now works with sequences of points.

This is a Python 3 implementation of the Sloan's improved version (FORTRAN 77 code) of the Nordbeck and Rystedt algorithm, published in the paper:

SLOAN, S.W. (1985): A point-in-polygon program. Adv. Eng. Software, Vol 7, No. 1, pp 45-47.

This class has 1 public method (is_inside) that returns the minimum distance to the nearest point of the polygon:

If is_inside < 0 then point is outside the polygon. If is_inside = 0 then point in on a side of the polygon. If is_inside > 0 then point is inside the polygon.

Multiprocess-safe logging file-handler + interprocess RLock (Python)

2010-09-22T17:30:10-07:00

Python recipe 577395 by Jan Kaliszewski (concurrency, file, file_lock, flock, handler, logging, process, rlock, threading, threadsafe). Revision 11.

A Python 2.x/3.x-compatibile multiprocess-safe logging file-handler (logging.FileHandler replacement, designed for logging to a single file from multiple independent processes) together with a simple interprocess recursive lock -- universal abstract classes + Unix/Linux implementation.

Update: It's is a deeply revised version. Especially, now it --

is Python 2.4, 2.5, 2.6, 3.1 -compatibile (previously Py>=2.6 was needed); probably works also with 2.7, 3.0 and 3.2 (but not tested if it does);
is multiprocess-safe as well as thread-safe (proviously thread safety within a process was missed);
is based on public interfaces only (previously FileHandler._open() was called and overriden);
implement full RLock instance interface, as documented for threading.RLock (previously non-blocking mode and context-manager interface were missing).

The module contains:

Unix/Linux-only example implementation (with flock-based locking): FLockRLock and FLockFileHandler classes.
universal abstract classes -- which may be useful at developing implementation for non-Unix platforms: MultiprocessRLock, MultiprocessFileHandler, LockedFileHandler,

Also a quick-and-dirty test was added.

It is still an alpha version -- I'll be very grateful for any feedback.

Further updates:

2010-09-20: Some corrections, especially: non-blocking mode bug in MultiprocessRLock.acquire() fixed; _test() function improved; plus fixes in the description below.
2010-09-22: _test() improved and moved to description section. Mistaken copyright-notice removed.

Object snoop - experiment with Python special methods (Python)

2010-09-05T17:54:50-07:00

Python recipe 577383 by Wai Yip Tung (metaprogramming, methods, object).

In Python, classes can define their own behavior with respect to language operators. For example, if a class defines __getitem__(), then x[i], where x is an instance of the clas, will be execute by a call to x.__getitem__(i).

While Python has an extensive documentation on the special methods, reading a specification may not be the best way to reveal the intricate details. object_snoop allows user to observe how Python expressions and statements are translated into special method calls. object_snoop defines most special methods. It simple print a trace and returns a fixed but sensible result. Users are invited to build complex expressions to experiment how Python special methods work.

Method-based URL dispatcher for the Tornado web server (Python)

2009-11-20T11:51:47-08:00

Python recipe 576958 by Dan McDougall (dispatcher, shortcuts, subclass, tornado, url, web). Revision 5.

The MethodDispatcher is a subclass of tornado.web.RequestHandler that will use the methods contained in subclasses of MethodDispatcher to handle requests. In other words, instead of having to make a new RequestHandler class for every URL in your application you can subclass MethodDispatcher and use the methods contained therein as your URLs.

The MethodDispatcher also adds the convenience of automatically passing arguments to your class methods. So there is no need to use Tornado's get_argument() method.

Example

To demonstrate the advantages of using MethodDispatcher I'll present a standard Tornado app with multiple URLs and re-write it using MethodDispatcher...

The standard Tornado way

class Foo(tornado.web.RequestHandler):
    def get(self):
        self.write('foo')

class Bar(tornado.web.RequestHandler):
    def get(self):
        self.write('bar')

class SimonSays(tornado.web.RequestHandler):
    def get(self):
        say = self.get_argument("say")
        self.write('Simon says, %s' % `say`)

application = tornado.web.Application([
    (r"/foo", Foo),
    (r"/bar", Bar),
    (r"/simonsays", SimonSays),
])

The MethodDispatcher way

class FooBar(MethodDispatcher):
    def foo(self):
        self.write("foo")

    def bar(self):
        self.write("bar")

    def simonsays(self, say):
        self.write("Simon Says, %s" % `say`)

application = tornado.web.Application([
    (r"/.*", FooBar)
])

Notes

As you can see from the above example, using the MethodDispatcher can significantly reduce the complexity of Tornado applications. Here's some other things to keep in mind when using the MethodDispatcher:

MethodDispatcher will ignore any methods that begin with an underscore (_). This prevents builtins and private methods from being exposed to the web.
The '/' path is special: It always maps to self.index().
MethodDispatcher does not require that your methods distinquish between GET and POST requests. Whether a GET or POST is performed the matching method will be called with any passed arguments or POSTed data. Because of the way this works you should not use get() and post() in your MethodDispatcher subclasses unless you want to override this functionality.
When an argument is passed with a single value (/simonsays?say=hello) the value passed to the argument will be de-listed. In other words, it will be passed to your method like so: {'say': 'hello'}. This overrides the default Tornado behavior which would return the value as a list: {'say': ['hello']}. If more than one value is passed MethodDispatcher will use the default behavior.

Python reader for SPSS .por files (Python)

2009-06-15T15:37:39-07:00

Python recipe 576809 by wouter (por, portable, reader, spp, value_labels).

SPSS can output ASCII .por files that include variable definitions (labels, value labels) and data. These files are useful to be able to read but strange enough I couldn't find any documentation anywhere.

I've reverse engineered the format so that it works for the (fairly complex) files I need to open, so maybe it is of some use for other people interfacing SPSS with python.

This code is placed in the public domain as far as allowed by law, parts (if any) that cannot be relased in the public domain are irrevocably licensed to all readers under the Creative Commons license without restrictions ... but if you improve it it would be great if you could share it. The code uses a base N decoder plucked from the web somewhere (can't find it) that was also public domain.

-- wouter (wouter@vanatteveldt.com)

Class for writing content to Excel and formatting it (Python)

2007-09-07T03:08:02-07:00

Python recipe 528870 by Grant Paton-Simpson (database). Revision 4.

Class for creating Excel spreadsheets - esp writing data and formatting them. NB OpenOffice Calc will be easily able to open the outputs too.

typeparser (Python)

2007-04-15T04:24:53-07:00

Python recipe 511473 by Florian Leitner (algorithms). Revision 2.

Python type-string parser. The code evolved from a post in python-list on 11/22/05 by Fredrik Lundh on a dictionary parser. It parses a type-string to their type objects for all basic types. Raises SyntaxError and SemanticError on failures.

Supported types: * containers: defaultdict, deque, dict, list, tuple, set * basic types: Decimal, bool, float, int, long, str * None type

REQUIRES PYTHON >= 2.5

Helper subclass for win32pdhquery (Python)

2004-09-03T10:03:51-07:00

Python recipe 303338 by Brett Cannon (debugging).

One of the few perks one can have when developing on Windows (at least NT or newer) is the use of the Performance Data Helper (the PDH can be found on Windows XP under the Control Panel at Administrative Tools -> Performance) for system statistics gathering. There is a bevy of counters available that can greatly help you measure the impact your code has on the current system.

And luckily win32all provides a wrapper to create counters. The only drawback, though, is that the API is not the best in the world. So, to help deal with that I wrote a subclass to help with adding counters and formatting the output in a more usable fashion as either CSV or a dict that can be pickled.