はてなブックマーク

# code snippet, to be included in 'sitecustomize.py' import sys def info(type, value, tb): if hasattr(sys, 'ps1') or not sys.stderr.isatty(): # we are in interactive mode or we don't have a tty-like # device, so we call the default hook sys.__excepthook__(type, value, tb) else: import traceback, pdb # we are NOT in interactive mode, print the exception... traceback.print_exception(type, value, tb)

Dropbox file uploader via web interface using Python with urllib2 and mechanize (Python recipe) by ccpizza UPDATE: This is script is not maintained and does not anymore with the current version of Dropbox. For a proper command line interface to dropbox I recommend dropbox_uploader: https://github.com/andreafabrizi/Dropbox-Uploader Originally inspired by the example at http://joncraton.org/blog/62/

K fold cross validation partition (Python recipe) by John Reid Takes a sequence and yields K partitions of it into training and validation test sets. Training sets are of size (k-1)*len(X)/K and partition sets are of size len(X)/K def k_fold_cross_validation(X, K, randomise = False): """ Generates K (training, validation) pairs from the items in X. Each pair is a partition of X, where validation i

extended for MacOS. A few modifications make this work for the mac with Carbon, too: a modification to the _Getch to try one more import, a modification to the Unix init, and the inclusion of the instructions for the MacOS with Carbon support. class _Getch: """Gets a single character from standard input. Does not echo to the screen.""" def __init__(self): try: self.impl = _GetchWindows() except Im

ActiveState Code (http://code.activestate.com/recipes/577684/) Space efficient, probabilistic set membership tester. Has no False Negatives but allows a rare False Positive. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 7

You don't have permission to access /recipes/146306-http-client-to-post-using-multipartform-data/ on this server. Apache/2.2.15 (CentOS) Server at code.activestate.com Port 80

Line-oriented processing in Python from command line (like AWK) (Python recipe) by Artur Siekielski A very simple but powerful shell script which enables writing ad-hoc Python scripts for processing line-oriented input. It executes the following code template: $INIT for line in sys.stdin: $LOOP $END where $INIT, $LOOP and $END code blocks are given from command line. If only one argument is given,

ActiveState Code (http://code.activestate.com/recipes/577630/) Compare two images using the root mean squared analysis. A result close to 0 means a good match. # Original function import ImageChops import math, operator def rmsdiff_1997(im1, im2): "Calculate the root-mean-square difference between two images" h = ImageChops.difference(im1, im2).histogram() # calculate rms return math.sqrt(reduce(o

ActiveState Code (http://code.activestate.com/recipes/577197/) Wraps bisect.bisect() in an easy to use class that supports key-functions and straight-forward search methods. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 7

Python (4591 Recipes) See all Python recipes See all recipes for Python 2 See all recipes for Python 3 See recipes with the tag algorithms, database, debugging, files, graphics, linux, math, mathematics, network, oop, programs, python, shortcuts, sysadmin, text, threads, tkinter, web, windows, xml Tcl (162 Recipes) See all Tcl recipes See recipes with the tag binding, database, datastructures, deb

Notice! PyPM is being replaced with the ActiveState Platform, which enhances PyPM’s build and deploy capabilities. Create your free Platform account to download ActivePython or customize Python with the packages you require and get automatic updates. Download ActivePython

class Singleton(type): def __init__(self, *args): type.__init__(self, *args) self._instances = {} def __call__(self, *args): if not args in self._instances: self._instances[args] = type.__call__(self, *args) return self._instances[args] class Test: __metaclass__=Singleton def __init__(self, *args): pass ta1, ta2 = Test(), Test() assert ta1 is ta2 tb1, tb2 = Test(5), Test(5) assert tb1 is tb2 asser

Efficient Running Median using an Indexable Skiplist (Python recipe) by Raymond Hettinger Maintains sorted data as new elements are added and old one removed as a sliding window advances over a stream of data. Also gives fast indexed access to value. Running time per median update is proportional to the log of the window size. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 #!/usr/bin/python """ Run asynchronous tasks in gobject using coroutines. Terminology used: * Job: A coroutine that yield tasks. * Task: A function which

ActiveState Code (http://code.activestate.com/recipes/577518/) This is a pure Python implementation of the rsync algorithm. On my desktop (3.0GHz dual core, 7200RPM), best case throughput for target file hash generation and delta generation is around 2.9MB/s. Absolute worst case scenario (no blocks in common) throughput for delta generation is 200KB/s to 300KB/s on the same system. Tested in Pytho

ActiveState Code (http://code.activestate.com/recipes/576925/) A recipe to find out which function is the caller of the current function. The caller function can be helpful for debugging — if there is no real debugger available. In terms of software engineering (loose coupling etc.) this should not be used in production code though.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 from wxPython.glcanvas import wxGLCanvas from wxPython.wx import * from OpenGL.GLUT import * from OpenGL.GLU import * from OpenGL.GL import * import sys,math name = 'ball_glut' class myGLCanvas(wxGLCanv

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 # Functions can be memoised "by hand" using a dictionary to hold # the return values when they are calculated: # Here is a simple case, using the recursive fibonnaci function # f(n) = f(n-1) + f(n-2) fib_memo = {} def fib(n): if n < 2: return 1 if not f

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 import ctypes class C_function: """This class wraps a Python function into its C equivalent in the given library""" types = ctypes.__dict__ @classmethod def register_type(cls, typename, obj): """Add an

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 #!/usr/bin/env python def run_async(func): """ run_async(func) function decorator, intended to make "func" run in a separate thread (asynchronously). Returns the created Thread object E.g.: @run_async def task1(): do_something @run_async

5091 snippets to learn from and use. Search the recipes.

Using a Python recipe? Installing ActivePython is the easiest way to run your project. Create your free Platform account to download our ready-to-use ActivePython or customize Python with any packages you require. Download ActivePython

Connect to an IRC server and store messages into a file (Python recipe) by Gian Mario Tagliaretti You want to connect to an IRC server, join a channel and store private message into a file on your hard disk for future reading. I haven't tried but I think you can execute this code from an hosting always connected to the internet and read the message through a web browser. import socket, string #som

safer serialization of simple python types, part two (Python recipe) by S W This recipe is a reimplemtation of this recipe, http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/415503 using Python 2.4 decorator syntax. It also has added support for boolean and unicode types, and a keyword argument (compress=False) for the dumps function, which will compress the string. 1 2 3 4 5 6 7 8 9 10 11 1

pypopper - Python POP3 Server (Python recipe) by Daniel Miller While developing <a href="http://pieces.openpolitics.com/thunderbayes/">ThunderBayes</a> (an extension for Thunderbird) I wrote this simple POP3 server to serve a message to my ThunderBayes test setup. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48