Python Frequently Asked Questions

2003-07-29

sys.version
sys.hexversion
sys.version_info
(defun my-python-mode-hook ()
  (setq font-lock-keywords python-font-lock-keywords)
  (font-lock-mode 1))
(add-hook 'python-mode-hook 'my-python-mode-hook)

(year, month, day, ...)
>>> L = []
>>> dir(L)
['append', 'count', 'extend', 'index', 'insert', 'pop', 'remove',
'reverse', 'sort']
>>> help(L.append)
Help on built-in function append:

append(...)
    L.append(object) -- append object to end
>>> L.append(1)
>>> L
[1]

make test
import test.autotest

import test.test_spam

hostname$ python
>>> import _tkinter
>>> import Tkinter
>>> Tkinter._test()

Modules/Setup
_tkinter
TKPATH
TCL_LIBRARY
TK_LIBRARY
make clean
make clobber
Misc/
statichere PyTypeObject bstreamtype = {
    PyObject_HEAD_INIT(NULL) /* must be set by init function */
    0,
    "bstream",
    sizeof(bstreamobject),

...

void
initbstream()
{
    /* Patch object type */
    bstreamtype.ob_type = &PyType_Type;
    Py_InitModule("bstream", functions);
    ...
}

rlcompleter
readline.parse_and_bind("tab: complete")

--enable-shared
L2 = []
for i in range[3]:
     L2.append(L1[i])

L2 = list(L1[:3]) # "list" is redundant if L1 is a list.

>>> map(None, [1,2,3], [4,5,6])
[(1, 4), (2, 5), (3, 6)]

>>> map( math.sin, (1,2,3,4))
[0.841470984808, 0.909297426826, 0.14112000806,   -0.756802495308]

"".join([s1,s2,s3,s4,s5,s6,s7])` may be far faster than
the more obvious ``s1+s2+s3+s4+s5+s6+s7
ff()
ff ()
def ff(x):
    ...do something with x computing result...
    return result

list = map(ff, oldlist)

for x in sequence:
    value = ff(x)
    ...do something with value...

ff()
def ffseq(seq):
    resultseq = []
    for x in seq:
        ...do something with x computing result...
        resultseq.append(result)
    return resultseq

list = ffseq(oldlist)
for value in ffseq(sequence):
    ...do something with value...

for key in token:
    dict[key] = dict.get(key, 0) + 1

dict_get = dict.get  # look up the method once
for key in token:
    dict[key] = dict_get(key, 0) + 1

def degree_sin(deg):
    return math.sin(deg * math.pi / 180.0)

def degree_sin(deg, factor = math.pi/180.0, sin = math.sin):
    return sin(deg * factor)

x = 1 # make a global

def f():
      print x # try to print the global
      ...
      for j in range(100):
           if q>3:
              x=4

def f():
      global x
      print x # try to print the global
      ...
      for j in range(100):
           if q>3:
              x=4

global
global
global
pass

import config
config.x = 1

import config
import mod
print config.x

from modulename import *
Tkinter
threading
wxPython
Circular imports are fine where both modules use the "import <module>"
form of import. They fail when the 2nd module wants to grab a name
out of the first ("from module import name") and the import is at
the top level. That's because names in the 1st are not yet available,
because the first module is busy importing the 2nd.  

*
**
def f(x, *tup, **kwargs):
        ...
        kwargs['width']='14.3c'
        ...
        g(x, *tup, **kwargs)

def f(x, *tup, **kwargs):
        ...
        kwargs['width']='14.3c'
        ...
        apply(g, (x,)+tup, kwargs)

def func2(a, b):
    a = 'new-value'        # a and b are local names
    b = b + 1              # assigned to new objects
    return a, b            # return new values

x, y = 'old-value', 99
x, y = func2(x, y)
print x, y                 # output: new-value 100

def func1(a):
    a[0] = 'new-value'     # 'a' references a mutable list
    a[1] = a[1] + 1        # changes a shared object

args = ['old-value', 99]
func1(args)
print args[0], args[1]     # output: new-value 100

def func3(args):
    args['a'] = 'new-value'     # args is a mutable dictionary
    args['b'] = args['b'] + 1   # change it in-place

args = {'a':' old-value', 'b': 99}
func3(args)
print args['a'], args['b']

class callByRef:
    def __init__(self, **args):
        for (key, value) in args.items():
            setattr(self, key, value)

def func4(args):
    args.a = 'new-value'        # args is a mutable callByRef
    args.b = args.b + 1         # change object in-place

args = callByRef(a='old-value', b=99)
func4(args)
print args.a, args.b

def linear(a,b):
    def result(x, a=a, b=b):
        return a*x + b
    return result

class linear:
   def __init__(self, a, b):
       self.a, self.b = a,b
   def __call__(self, x):
       return self.a * x + self.b

taxes = linear(0.3,2)

class exponential(linear):
   # __init__ inherited
   def __call__(self, x):
       return self.a * (x ** self.b)

class counter:
    value = 0
    def set(self, x): self.value = x
    def up(self): self.value=self.value+1
    def down(self): self.value=self.value-1

count = counter()
inc, dec, reset = count.up, count.down, count.set

new_l = l[:]

class A:
    pass

B = A

a = B()
b = a
print b
<__main__.A instance at 016D07CC>
print a
<__main__.A instance at 016D07CC>

def q(cond,on_true,on_false):
    from inspect import isfunction

    if cond:
        if not isfunction(on_true): return on_true
        else: return apply(on_true)
    else:
        if not isfunction(on_false): return on_false 
        else: return apply(on_false)

# Primes < 1000
print filter(None,map(lambda y:y*reduce(lambda x,y:x*y!=0,
map(lambda x,y=y:y%x,range(2,int(pow(y,0.5)+1))),1),range(2,1000)))

# First 10 Fibonacci numbers
print map(lambda x,f=lambda x,f:(x<=1) or (f(x-1,f)+f(x-2,f)): f(x,f),
range(10))

# Mandelbrot set
print (lambda Ru,Ro,Iu,Io,IM,Sx,Sy:reduce(lambda x,y:x+y,map(lambda y,
Iu=Iu,Io=Io,Ru=Ru,Ro=Ro,Sy=Sy,L=lambda yc,Iu=Iu,Io=Io,Ru=Ru,Ro=Ro,i=IM,
Sx=Sx,Sy=Sy:reduce(lambda x,y:x+y,map(lambda x,xc=Ru,yc=yc,Ru=Ru,Ro=Ro,
i=i,Sx=Sx,F=lambda xc,yc,x,y,k,f=lambda xc,yc,x,y,k,f:(k<=0)or (x*x+y*y
>=4.0) or 1+f(xc,yc,x*x-y*y+xc,2.0*x*y+yc,k-1,f):f(xc,yc,x,y,k,f):chr(
64+F(Ru+x*(Ro-Ru)/Sx,yc,0,0,i)),range(Sx))):L(Iu+y*(Io-Iu)/Sy),range(Sy
))))(-2.1, 0.7, -1.2, 1.2, 30, 80, 24)
#    \___ ___  \___ ___  |   |   |__ lines on screen
#        V          V      |   |______ columns on screen
#        |          |      |__________ maximum of "iterations"
#        |          |_________________ range on y axis
#        |____________________________ range on x axis

>>> a = 010

>>> a
8

>>> a = 0xa5
>>> a
165
>>> b = 0XB2
>>> b
178

>>> s = "Hello, world"
>>> a = list(s)
>>> print a
['H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd']
>>> a[7:] = list("there!")
>>> import string
>>> print string.join(a, '')
'Hello, there!'

>>> import array
>>> a = array.array('c', s)
>>> print a
array('c', 'Hello, world')
>>> a[0] = 'y' ; print a
array('c', 'yello world')
>>> a.tostring()
'yello, world'

def a():
    pass

def b():
    pass

dispatch = {'go': a, 'stop': b}  # Note lack of parens for funcs

dispatch[get_input()]()  # Note trailing parens to call function

import foo
getattr(foo, 'bar')()

class Foo:
    def do_foo(self):
        ...

    def do_bar(self):
        ...

 f = getattr(foo_instance, 'do_' + opname)
 f()

def myFunc():
    print "hello"

fname = "myFunc"

f = locals()[fname]
f()

f = eval(fname)
f()

rstrip()
S
S.splitlines()[0]
#!/usr/bin/python 

import re, os, StringIO

lines=StringIO.StringIO(
  "The Python Programming Language\r\n"
  "The Python Programming Language \r \r \r\r\n"
  "The\rProgramming\rLanguage\r\n"
  "The\rProgramming\rLanguage\r\r\r\r\n"
  "The\r\rProgramming\r\rLanguage\r\r\r\r\n"
)

ln=re.compile("(?:[\r]?\n|\r)$") # dos:\r\n, unix:\n, mac:\r, others: unknown
# os.linesep does not work if someone ftps(in binary mode) a dos/mac text file
# to your unix box
#ln=re.compile(os.linesep + "$")

while 1:
  s=lines.readline()
  if not s: break
  print "1.(%s)" % `s.rstrip()`
  print "2.(%s)" % `ln.sub( "", s, 1)`
  print "3.(%s)" % `s.splitlines()[0]`
  print "4.(%s)" % `s.splitlines()`
  print

lines.close()

list.reverse()
try:
        for x in list:
                "do something with x"
finally:
        list.reverse()

rev = list[:]
rev.reverse()
for x in rev:
        <do something with x>

for i in range(len(sequence)-1, -1, -1):
        x = sequence[i]
        <do something with x>

class Rev:
        def __init__(self, seq):
                self.forw = seq
        def __len__(self):
                return len(self.forw)
        def __getitem__(self, i):
                return self.forw[-(i + 1)]

for x in Rev(list):
        <do something with x>

if List:
   List.sort()
   last = List[-1]
   for i in range(len(List)-2, -1, -1):
       if last==List[i]: del List[i]
       else: last=List[i]

d = {}
for x in List: d[x]=x
List = d.values()

lisp_list = ("like",  ("this",  ("example", None) ) )

A = [[None] * 2] * 3

A = [None]*3
for i in range(3):
     A[i] = [None] * 2

w, h = 2, 3
A = map(lambda i,w=w: [None] * w, range(h))

w,h = 2,3
A = [ [None]*w for i in range(h) ]

def method_map(objects, method, arguments):
     """method_map([a,b], "flog", (1,2)) gives [a.flog(1,2), b.flog(1,2)]"""
     nobjects = len(objects)
     methods = map(getattr, objects, [method]*nobjects)
     return map(apply, methods, [arguments]*nobjects)

import UserDict, string

class SortedDict(UserDict.UserDict):
  def __repr__(self):
    result = []
    append = result.append
    keys = self.data.keys()
    keys.sort()
    for k in keys:
      append("%s: %s" % (`k`, `self.data[k]`))
    return "{%s}" % string.join(result, ", ")

  ___str__ = __repr__

def st(List, Metric):
    def pairing(element, M = Metric):
          return (M(element), element)
    paired = map(pairing, List)
    paired.sort()
    return map(stripit, paired)

def stripit(pair):
    return pair[1]

import string
Usorted = st(L, string.upper)

def intfield(s):
      return string.atoi( string.strip(s[10:15] ) )

Isorted = st(L, intfield)

tmp1 = [ (x.upper(), x) for x in L ] # Schwartzian transform
tmp1.sort()
Usorted = [ x[1] for x in tmp1 ]

tmp2 = [ (int(s[10:15]), s) for s in L ] # Schwartzian transform
tmp2.sort()
Isorted = [ x[1] for x in tmp2 ]

def Icmp(s1, s2):
      return cmp( intfield(s1), intfield(s2) )

Isorted = L[:]
Isorted.sort(Icmp)

>>> list1 = ["what", "I'm", "sorting", "by"]
>>> list2 = ["something", "else", "to", "sort"]
>>> pairs = map(None, list1, list2)
>>> pairs
[('what', 'something'), ("I'm", 'else'), ('sorting', 'to'), ('by', 'sort')]
>>> pairs.sort()
>>> pairs
[("I'm", 'else'), ('by', 'sort'), ('sorting', 'to'), ('what', 'something')]
>>> result = pairs[:]
>>> for i in xrange(len(result)): result[i] = result[i][1]
...
>>> result
['else', 'sort', 'to', 'something']

>>> list1 = ["what", "I'm", "sorting", "by"]
>>> list2 = ["something", "else", "to", "sort"]
>>> pairs = zip(list1, list2)
>>> pairs
[('what', 'something'), ("I'm", 'else'), ('sorting', 'to'), ('by', 'sort')]
>>> pairs.sort()
>>> result = [ x[1] for x in pairs ]
>>> result
['else', 'sort', 'to', 'something']

result = []
for p in pairs: result.append(p[1])

result = []
append = result.append
for p in pairs: append(p[1])

def is_instance_of(the_instance, the_class):
    try:
        raise the_instance
    except the_class:
        return 1
    except:
        return 0

try:
              raise the_instance
except Audible:
              the_instance.play(largo)
except Visual:
              the_instance.display(gaudy)
except Olfactory:
              sniff(the_instance)
except:
              raise ValueError, "dunno what to do with this!"

class MyClass:
    ThisIsMyClass = 1
    ...

def is_a_MyClass(the_instance):
    return hasattr(the_instance, 'ThisIsMyClass')

class IntruderClass:
    ThisIsMyClass = 1    # Masquerade as MyClass
    ...

from string import upper

class UpperOut:
      def __init__(self, outfile):
            self.__outfile = outfile
      def write(self, str):
            self.__outfile.write( upper(str) )
      def __getattr__(self, name):
            return getattr(self.__outfile, name)

class X:
     ...
     def __setattr__(self, name, value):
          self.__dict__[name] = value
     ...

class subclass(superclass1, superclass2, superclass3):
    delegate_glorp = superclass2
    ...
    def glorp(self, arg1, arg2):
          ... subclass specific stuff ...
          self.delegate_glorp.glorp(self, arg1, arg2)
     ...

class subsubclass(subclass):
     delegate_glorp = superclass3
     ...

BaseAlias = <real base class>
class Derived(BaseAlias):
        def meth(self):
                BaseAlias.meth(self)
                ...

class C:
    count = 0   # number of times C.__init__ called

    def __init__(self):
        C.count = C.count + 1

    def getcount(self):
        return C.count  # or return self.count

self.count = 42

C.count = 314

C.getcount

def getcount():
    return C.count

# helper class to disguise function objects
class _static:
    def __init__(self, f):
        self.__call__ = f

class C:
    count = 0

    def __init__(self):
        C.count = C.count + 1

    def getcount():
        return C.count
    getcount = _static(getcount)

    def sum(x, y):
        return x + y
    sum = _static(sum)

C(); C()
c = C()
print C.getcount()  # prints 3
print c.getcount()  # prints 3
print C.sum(27, 15) # prints 42

class C {
    C() { cout << "No arguments\n"; }
    C(int i) { cout << "Argument is " << i << "\n"; }
}

class C:
    def __init__(self, i=None):
        if i is None:
            print "No arguments"
        else:
            print "Argument is", i

def __init__(self, *args):
    ....

>>> import py_compile
>>> py_compile.compile('abc.py')

python compile.py abc.py

python compile.py *

import sys
from py_compile import compile

if len(sys.argv) <= 1:
   sys.exit(1)

for file in sys.argv[1:]:
   compile(file)

if __name__ == '__main__': main()

from bar import bar_var
foo_var=1

from foo import foo_var
bar_var=2

main imports foo
Empty globals for foo are created
foo is compiled and starts executing
foo imports bar
Empty globals for bar are created
bar is compiled and starts executing
bar imports foo (which is a no-op since there already is a module named foo)
bar.foo_var = foo.foo_var
...

exports (globals, functions, and classes that don't need imported base classes)
import statements
active code (including globals that are initialized from imported values).

__import__('x.y.z').y.z

m = __import__(s)
for i in string.split(s, ".")[1:]:
    m = getattr(m, i)

import modname
reload(modname)

from modname import some_objects

FAQ.txt
from Tkinter import tkinter
tkinter.createfilehandler(file, mask, callback)

callback(file, mask)

tkinter.deletefilehandler(file)

import struct

f = open(filename, "rb")  # Open in binary mode for portability
s = f.read(8)
x, y, z = struct.unpack(">hhl", s)

if __name__=="__main__":
     main_logic()

if __name__ == "__main__":
   self_test()

import string
testdata = "just a random sequence of characters"

class FakeInputFile:
  data = testdata
  position = 0
  closed = 0

  def read(self, n=None):
      self.testclosed()
      p = self.position
      if n is None:
         result= self.data[p:]
      else:
         result= self.data[p: p+n]
      self.position = p + len(result)
      return result

  def seek(self, n, m=0):
      self.testclosed()
      last = len(self.data)
      p = self.position
      if m==0: 
         final=n
      elif m==1:
         final=n+p
      elif m==2:
         final=len(self.data)+n
      else:
         raise ValueError, "bad m"
      if final<0:
         raise IOError, "negative seek"
      self.position = final

  def isatty(self):
      return 0

  def tell(self):
      return self.position

  def close(self):
      self.closed = 1

  def testclosed(self):
      if self.closed:
         raise IOError, "file closed"

#!/usr/local/bin/python

#! /usr/bin/env python

#! /bin/sh
""":"
exec python $0 ${1+"$@"}
"""

__doc__ = """...Whatever..."""

import random

random.random()

randrange(a, b) chooses an integer in the range [a, b)
uniform(a, b) chooses a floating point number in the range [a, b)
normalvariate(mean, sdev) sample from normal (Gaussian) distribution

choice(S) chooses random element from a given sequence
shuffle(L) shuffles a list in-place, i.e. permutes it randomly

FAQ.txt
import sys, smtplib

fromaddr = raw_input("From: ")
toaddrs  = raw_input("To: ").split(',')
print "Enter message, end with ^D:"
msg = ''
while 1:
    line = sys.stdin.readline()
    if not line:
        break
    msg = msg + line

# The actual mail send
server = smtplib.SMTP('localhost')
server.sendmail(fromaddr, toaddrs, msg)
server.quit()

SENDMAIL = "/usr/sbin/sendmail" # sendmail location
import os
p = os.popen("%s -t -i" % SENDMAIL, "w")
p.write("To: `cary@ratatosk.org <mailto:cary@ratatosk.org>`_\n")
p.write("Subject: test\n")
p.write("\n") # blank line separating headers from body
p.write("Some text\n")
p.write("some more text\n")
sts = p.close()
if sts != 0:
    print "Sendmail exit status", sts

import termios, sys, os
fd = sys.stdin.fileno()
old = termios.tcgetattr(fd)
new = termios.tcgetattr(fd)
new[3] = new[3] & ~termios.ICANON & ~termios.ECHO
new[6][termios.VMIN] = 1
new[6][termios.VTIME] = 0
termios.tcsetattr(fd, termios.TCSANOW, new)
s = ''    # We'll save the characters typed and add them to the pool.
try:
    while 1:
        c = os.read(fd, 1)
        print "Got character", `c`
        s = s+c
finally:
    termios.tcsetattr(fd, termios.TCSAFLUSH, old)

import termios, fcntl, sys, os
fd = sys.stdin.fileno()

oldterm = termios.tcgetattr(fd)
newattr = termios.tcgetattr(fd)
newattr[3] = newattr[3] & ~termios.ICANON & ~termios.ECHO
termios.tcsetattr(fd, termios.TCSANOW, newattr)

oldflags = fcntl.fcntl(fd, fcntl.F_GETFL)
fcntl.fcntl(fd, fcntl.F_SETFL, oldflags | os.O_NONBLOCK)

try:
    while 1:
        try:
            c = sys.stdin.read(1)
            print "Got character", `c`
        except IOError: pass
finally:
    termios.tcsetattr(fd, termios.TCSAFLUSH, oldterm)
    fcntl.fcntl(fd, fcntl.F_SETFL, oldflags)

import popen2
fromchild, tochild = popen2.popen2("command")
tochild.write("input\n")
tochild.flush()
output = fromchild.readline()

import tempfile
import os
class Popen3:
   """
   This is a deadlock-save version of popen, that returns
   an object with errorlevel, out (a string) and err (a string).
   (capturestderr may not work under windows.)
   Example: print Popen3('grep spam','\n\nhere spam\n\n').out
   """
   def __init__(self,command,input=None,capturestderr=None):
       outfile=tempfile.mktemp()
       command="( %s ) > %s" % (command,outfile)
       if input:
           infile=tempfile.mktemp()
           open(infile,"w").write(input)
           command=command+" <"+infile
       if capturestderr:
           errfile=tempfile.mktemp()
           command=command+" 2>"+errfile
       self.errorlevel=os.system(command) >> 8
       self.out=open(outfile,"r").read()
       os.remove(outfile)
       if input:
           os.remove(infile)
       if capturestderr:
           self.err=open(errfile,"r").read()
           os.remove(errfile)

handler(signum, frame)

def handler(signum, frame):
        ...

#!/usr/local/bin/python

import httplib, sys, time

### build the query string
qs = "First=Josephine&MI=Q&Last=Public"

### connect and send the server a path
httpobj = httplib.HTTP('www.some-server.out-there', 80)
httpobj.putrequest('POST', '/cgi-bin/some-cgi-script')
### now generate the rest of the HTTP headers...
httpobj.putheader('Accept', '*/*')
httpobj.putheader('Connection', 'Keep-Alive')
httpobj.putheader('Content-type', 'application/x-www-form-urlencoded')
httpobj.putheader('Content-length', '%d' % len(qs))
httpobj.endheaders()
httpobj.send(qs)
### find out what the server said in response...
reply, msg, hdrs = httpobj.getreply()
if reply != 200:
    sys.stdout.write(httpobj.getfile().read())

>>> from urllib import quote
>>> x = quote("Guy Steele, Jr.")
>>> x
'Guy%20Steele,%20Jr.'
>>> query_string = "name="+x
>>> query_string
'name=Guy%20Steele,%20Jr.'

import sys
print sys.builtin_module_names

largeString = 'z' * (100 * 1024)
myPickle = cPickle.dumps(largeString, 1)

sys.stdout.close() # ditto for stdin and stderr

os.close(0)   # close C's stdin stream
os.close(1)   # close C's stdout stream
os.close(2)   # close C's stderr stream

import thread
def run(name, n):
    for i in range(n): print name, i
for i in range(10):
    thread.start_new(run, (i, 100))

import thread, time
def run(name, n):
    for i in range(n): print name, i
for i in range(10):
   thread.start_new(run, (i, 100))
time.sleep(10) # <----------------------------!

 import thread, time
def run(name, n):
     time.sleep(0.001) # <---------------------!
     for i in range(n): print name, i
 for i in range(10):
     thread.start_new(run, (i, 100))
 time.sleep(10)

L.append(x)
L1.extend(L2)
x = L[i]
x = L.pop()
L1[i:j] = L2
L.sort()
x = y
x.field = y
D[x] = y
D1.update(D2)
D.keys()

i = i+1
L.append(L[-1])
L[i] = L[j]
D[x] = D[x] + 1

PyObject *
PyObject_CallMethod(PyObject *object, char *method_name,
                    char *arg_format, ...);

res = PyObject_CallMethod(f, "seek", "(ii)", 10, 0);
if (res == NULL) {
        ... an exception occurred ...
}
else {
        Py_DECREF(res);
}

>>> class StdoutCatcher:
...  def __init__(self):
...   self.data = ''
...  def write(self, stuff):
...   self.data = self.data + stuff
...  
>>> import sys
>>> sys.stdout = StdoutCatcher()
>>> print 'foo'
>>> print 'hello world!'
>>> sys.stderr.write(sys.stdout.data)
foo
hello world!

module = PyImport_ImportModule("<modulename>");

attr = PyObject_GetAttrString(module, "<attrname>");

module = Py_InitModule("yourmodule", yourmodule_functions);

#include <Python.h>
#include <node.h>
#include <errcode.h>
#include <grammar.h>
#include <parsetok.h>
#include <compile.h>

int testcomplete(char *code)
  /* code should end in \n */
  /* return -1 for error, 0 for incomplete, 1 for complete */
{
  node *n;
  perrdetail e;

  n = PyParser_ParseString(code, &_PyParser_Grammar,
                           Py_file_input, &e);
  if (n == NULL) {
    if (e.error == E_EOF) 
      return 0;
    return -1;
  }

  PyNode_Free(n);
  return 1;
}

#include <stdio.h>
#include <readline.h>

#include <Python.h>
#include <object.h>
#include <compile.h>
#include <eval.h>

int main (int argc, char* argv[])
{
  int i, j, done = 0;                          /* lengths of line, code */
  char ps1[] = ">>> ";
  char ps2[] = "... ";
  char *prompt = ps1;
  char *msg, *line, *code = NULL;
  PyObject *src, *glb, *loc;
  PyObject *exc, *val, *trb, *obj, *dum;

  Py_Initialize ();
  loc = PyDict_New ();
  glb = PyDict_New ();
  PyDict_SetItemString (glb, "__builtins__", PyEval_GetBuiltins ());

  while (!done)
  {
    line = readline (prompt);

    if (NULL == line)                          /* CTRL-D pressed */
    {
      done = 1;
    }
    else
    {
      i = strlen (line);

      if (i > 0)
        add_history (line);                    /* save non-empty lines */

      if (NULL == code)                        /* nothing in code yet */
        j = 0;
      else
        j = strlen (code);

      code = realloc (code, i + j + 2);
      if (NULL == code)                        /* out of memory */
        exit (1);

      if (0 == j)                              /* code was empty, so */
        code[0] = '\0';                        /* keep strncat happy */

      strncat (code, line, i);                 /* append line to code */
      code[i + j] = '\n';                      /* append '\n' to code */
      code[i + j + 1] = '\0';

      src = Py_CompileString (code, "<stdin>", Py_single_input);       

      if (NULL != src)                         /* compiled just fine - */
      {
        if (ps1  == prompt ||                  /* ">>> " or */
            '\n' == code[i + j - 1])           /* "... " and double '\n' */
        {                                               /* so execute it */
          dum = PyEval_EvalCode ((PyCodeObject *)src, glb, loc);
          Py_XDECREF (dum);
          Py_XDECREF (src);
          free (code);
          code = NULL;
          if (PyErr_Occurred ())
            PyErr_Print ();
          prompt = ps1;
        }
      }                                        /* syntax error or E_EOF? */
      else if (PyErr_ExceptionMatches (PyExc_SyntaxError))           
      {
        PyErr_Fetch (&exc, &val, &trb);        /* clears exception! */

        if (PyArg_ParseTuple (val, "sO", &msg, &obj) &&
            !strcmp (msg, "unexpected EOF while parsing")) /* E_EOF */
        {
          Py_XDECREF (exc);
          Py_XDECREF (val);
          Py_XDECREF (trb);
          prompt = ps2;
        }
        else                                   /* some other syntax error */
        {
          PyErr_Restore (exc, val, trb);
          PyErr_Print ();
          free (code);
          code = NULL;
          prompt = ps1;
        }
      }
      else                                     /* some non-syntax error */
      {
        PyErr_Print ();
        free (code);
        code = NULL;
        prompt = ps1;
      }

      free (line);
    }
  }

  Py_XDECREF(glb);
  Py_XDECREF(loc);
  Py_Finalize();
  exit(0);
}

# A user-defined class behaving almost identical
# to a built-in dictionary.
class UserDict:
        def __init__(self): self.data = {}
        def __repr__(self): return repr(self.data)
        def __cmp__(self, dict):
                if type(dict) == type(self.data):
                        return cmp(self.data, dict)
                else:
                        return cmp(self.data, dict.data)
        def __len__(self): return len(self.data)
        def __getitem__(self, key): return self.data[key]
        def __setitem__(self, key, item): self.data[key] = item
        def __delitem__(self, key): del self.data[key]
        def keys(self): return self.data.keys()
        def items(self): return self.data.items()
        def values(self): return self.data.values()
        def has_key(self, key): return self.data.has_key(key)

value = unicode(value, "utf-8")

try:
    x = unicode(value, "ascii")
except UnicodeError:
    value = unicode(value, "utf-8")
else:
    # value was valid ASCII data
    pass

# Set the string encoding used by the Unicode implementation.
# The default is 'ascii'
encoding = "ascii" # <= CHANGE THIS if you wish

# Enable to support locale aware default string encodings.
import locale
loc = locale.getdefaultlocale()
if loc[1]:
    encoding = loc[1]
if encoding != "ascii":
    import sys
    sys.setdefaultencoding(encoding)

PyUnicodeUCS4
>>> import sys
>>> if sys.maxunicode > 65535:
...     print 'UCS4 build'
... else:
...     print 'UCS2 build'

", ".join(['1', '2', '4', '8', '16'])

"1, 2, 4, 8, 16"

"1, 2, 4, 8, 16".split(", ")

string.join(['1', '2', '4', '8', '16'], ", ")

>>> 1.2-1.0
0.199999999999999996

>>> 0.2
0.20000000000000001
>>> print 0.2
0.2

epsilon = 0.0000000000001 # Tiny allowed error
expected_result = 0.4

if expected_result-epsilon <= computation() <= expected_result+epsilon:
   ...

try:
    value = dict[key]
except KeyError:
    dict[key] = getvalue(key)
    value = dict[key]

if dict.has_key(key):
    value = dict[key]
else:
    dict[key] = getvalue(key)
    value = dict[key]

value = dict.setdefault(key, getvalue(key))

if (x <= y)
        x++;
        y--;
z++;

x+1
import sys
sys.exc_traceback = sys.last_traceback = None

for file in <very long list of files>:
    f = open(file)
    c = f.read(1)

for file in <very long list of files>:
    f = open(file)
    c = f.read(1)
    f.close()

os.listdir('.')
FAQ.txt
d = {[1,2]: '12'}
print d[[1,2]]

FAQ.txt
FAQ.txt
FAQ.txt
class listwrapper:
     def __init__(self, the_list):
           self.the_list = the_list
     def __cmp__(self, other):
           return self.the_list == other.the_list
     def __hash__(self):
           l = self.the_list
           result = 98767 - len(l)*555
           for i in range(len(l)):
                try:
                     result = result + (hash(l[i]) % 9999999) * 1001 + i
                except:
                     result = (result % 7777777) + i * 333
           return result

keys = dict.keys()
keys.sort()
for key in keys:
        ...do whatever with dict[key]...

import sys

def my_exitfunc():
     print "cleaning up"
     import sys
     # do order dependant deletions here
     ...
     # now delete everything else in arbitrary order
     for x in sys.modules.values():
          d = x.__dict__
          for name in d.keys():
               del d[name]

sys.exitfunc = my_exitfunc

instance.attribute(arg1, arg2)

Class.attribute(instance, arg1, arg2)

instance.attribute = value

def C_hello():
      print "hello"

class C:
     hello = [C_hello]
     counter = [0]

 I = C()

def foo(dict={}):  # XXX shared reference to one dict for all calls
    ...

def foo(dict=None):
        if dict is None:
                dict = {} # create a new dict for local namespace

class label: pass # declare a label
try:
     ...
     if (condition): raise label() # goto label
     ...
except label: # where to goto
     pass
...

f = open("/mydir/file.txt") # works fine!

dir = r"\this\is\my\dos\dir" "\\"
dir = r"\this\is\my\dos\dir\ "[:-1]
dir = "\\this\\is\\my\\dos\\dir\\"

while (line = readline(f)) {
    ...do something with line...
}

while 1:
    line = f.readline()
    if not line:
        break
    ...do something with line...

if (x = 0) {
    ...error handling...
}
else {
    ...code that only works for nonzero x...
}

line = f.readline()
while line:
    ...do something with line...
    line = f.readline()

def with_is_broken(a):
   with a:
      print x

function(args).dict[index][index].a = 21
function(args).dict[index][index].b = 42
function(args).dict[index][index].c = 63

ref = function(args).dict[index][index]
ref.a = 21
ref.b = 42
ref.c = 63

if a==b
    print a

if a==b:
    print a

import sys
if sys.platform == "win32":
   import win32pipe
   popen = win32pipe.popen
else:
   import os
   popen = os.popen

try:
     import really_fast_implementation
     choice = really_fast_implementation
except ImportError:
     import slower_implementation
     choice = slower_implementation

C:\>

D:\Steve\Projects\Python>

python

Python 2.2 (#28, Dec 21 2001, 12:21:22) [MSC 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

>>> print "Hello"
Hello
>>> "Hello" * 3
HelloHelloHello

'python' is not recognized as an internal or external command,
operable program or batch file.

Bad command or filename

dir C:\py*

c:\Python22\python

PATH C:\Python22;%PATH%

;C:\Python22

python

C:\> cd \Steve\Projects\Python
C:\Steve\Projects\Python> python pytest.py

C:\> python \Steve\Projects\Python\pytest.py

pytest.py

C:\Steve\Projects\Python\pytest.py

python C:\Steve\Projects\Python\pytest.py

python

python {program-file}

python --help

@setlocal enableextensions & python -x %~f0 %* & goto :EOF

@echo off
rem = """
rem run python on this bat file. Needs the full path where
rem you keep your python files. The -x causes python to skip
rem the first line of the file:
python -x c:\aaa\Python\\"%0".bat %1 %2 %3 %4 %5 %6 %7 %8 %9
goto endofpython
rem """

# The python program goes here:

print "hello, Python"

# For the end of the batch file:
rem = """
:endofpython
rem """

FAQ.txt
#include "python.h"
...
Py_Initialize();  // Initialize Python.
initmyAppc();  // Initialize (import) the helper class. 
PyRun_SimpleString("import myApp") ;  // Import the shadow class.

Py_INCREF(Py_None);
_resultobj = Py_None;
return _resultobj;

return Py_BuildValue("");

FAQ.txt
FAQ.txt
FAQ.txt
def kill(pid):
    """kill function for Win32"""
    import win32api
    handle = win32api.OpenProcess(1, 0, pid)
    return (0 != win32api.TerminateProcess(handle, 0))

>>> import os
>>> os.path.isdir( '\\\\rorschach\\public')
0
>>> os.path.isdir( '\\\\rorschach\\public\\')
1

k: is not a directory
k:\ is a directory
k:\media is a directory
k:\media\ is not a directory

\\conky\foo  is not a directory
\\conky\foo\ is a directory
\\conky\foo\media is a directory
\\conky\foo\media\ is not a directory

"...\python.exe -u ..."

import win32pipe
f = win32pipe.popen('dir /c c:\\')
print f.readlines()
f.close()

ImportError: DLL load failed: One of the library files needed
to run this application cannot be found.

This version uses CTL3D32.DLL whitch is not the correct version.
This version is used for windows NT applications only.

Date:	2003-07-29
Version:	1.5
Web site:	http://www.python.org/