>>> bob = ['Bob Smith', 42, 30000, 'software']
>>> sue = ['Sue Jones', 45, 40000, 'music']
>>> bob[0], sue[2]
('Bob Smith', 40000)

>>> bob[0].split()[-1]
'Smith'

>>> people = [bob,sue]
>>> for person in people:
	print person

>>> people[1][0]
'Sue Jones'

>>> pays = [person[2] for person in people]	# collect all pay
>>> pays
[30000, 40000]
>>> pays = map((lambda x: x[2]), people)	# ditto
>>> sum(person[2] for person in people)
70000

>>> people.append(['Tom', 50, 0, None])
>>> len(people)
3
>>> people[-1][0]
'Tom'

>>> NAME, AGE, PAY = range(3)	#[0,1,2]
>>> bob = ['Bob Smith', 42, 10000]
>>> bob[NAME]
'Bob Smith'

>>> bob = [['name', 'Bob Smith'], ['age', 42], ['pay', 10000]]
>>> sue = [['name', 'Sue Jones'], ['age', 45], ['pay', 20000]]
>>> for person in people:
	print person[0][1], person[2][1]

>>> for person in people:
	for (name, value) in person:
		if name=='name': print value

>>> def field(record, label):	# function
	for (fname, fvalue) in record:
		if fname == label:
			return fvalue
>>> field(bob, 'name')
'Bob Smith'
>>> field(sue, 'pay')
20000

>>> bob = {'name':'Bob Smith', 'age':42, 'pay':30000, 'job':'software'}
>>> sue = {'name':'Sue Jones', 'age':45, 'pay':40000, 'job':'music'}
>>> bob['name'].split()[-1]

>>> bob = dict(name='Bob Smith', age=42, pay=30000, job='dev');
>>> bob
{'pay':30000, 'job':'dev', 'age':42, 'name':'Bob Smith'}
>>> bob['name'], sue['pay']
('Bob Smith', 40000)

>>> bob['name'].split()[-1]
'Smith'

>>> people = [bob,sue]
>>> for person in people:
	print person

>>> people[1][0]
'Sue Jones'

>>> pays = [person[2] for person in people]	# collect all pay
>>> pays
[30000, 40000]
>>> pays = map((lambda x: x[2]), people)	# ditto
>>> sum(person[2] for person in people)
70000

>>> people.append(['Tom', 50, 0, None])
>>> len(people)
3
>>> people[-1][0]
'Tom'

>>> NAME, AGE, PAY = range(3)	#[0,1,2]
>>> bob = ['Bob Smith', 42, 10000]
>>> bob[NAME]
'Bob Smith'

>>> bob = [['name', 'Bob Smith'], ['age', 42], ['pay', 10000]]
>>> sue = [['name', 'Sue Jones'], ['age', 45], ['pay', 20000]]
>>> for person in people:
	print person[0][1], person[2][1]

>>> for person in people:
	for (name, value) in person:
		if name=='name': print value

>>> def field(record, label):	# function
	for (fname, fvalue) in record:
		if fname == label:
			return fvalue
>>> field(bob, 'name')
'Bob Smith'
>>> field(sue, 'pay')
20000

>>> sue = {}
>>> sue['name'] = 'Sue Jones'
>>> sue['age'] = 45
>>> sue['pay'] = 40000
>>> sue['job'] = 'mus'
>>> sue
{'job':'mus', 'pay':40000, 'age':45, 'name':'Sue Jones'}

>>> names = ['name', 'age', 'pay', 'job']
>>> values = ['Sue Jones', 45, 40000, 'mus']
>>> zip(names, values)
[('name', 'Sue Jones'), ('age', 45), ('pay', 40000), ('job', 'mus')]
>>> sue = dict(zip(names, values))
{'job':'mus', 'pay':40000, 'age':45, 'name':'Sue Jones'}

>>> fields = ('name', 'age', 'job', 'pay')
>>> record = dict.fromkeys(fields, '?')
>>> record
{'job':'?', 'pay':'?', 'age':'?', 'name':'?'}

>>> print open('data.txt').read()
001.1 002.2 003.3
010.1 020.2 030.3 040.4
100.1 200.2 300.3
>>> sums = {}
>>> for line in open('data.txt'):
	cols = [float(col) for col in line.split()]
	for pos,val in enumerate(cols):
		sums[pos] = sums.get(pos, 0.0)+val
>>> for key in sorted(sums):
	print key, '=', sums[key]
0=111.3
1=222.6
3=333.9
4=40.4

# initdata.py

#records
bob = {'name':'Bob Smith', 'age':42, 'pay':30000, 'job':'software'}
sue = {'name':'Sue Jones', 'age':45, 'pay':40000, 'job':'music'}

db = {}
db['bob'] = bob
db['sue'] = sue

if __name__=='__main__':	# when run as a script, true only when this file is run, not when it is imported
	for key in db:
		print key, '=>\n', db[key]


# make_db_files.py
dbfilename = 'people-file'
ENDDB = 'enddb.'
ENDREC = 'endrec.'
RECSEP = '=>'

def storeDbase(db, dbfilename=dbfilename):
	"formatted dump of database to flat file"
	dbfile = open(dbfilename, 'w')
	for key in db:
		print >> dbfile, key
		for (name, value) in db[key].items():
			print >> dbfile, name+RECSEP+repr(value)	#repr(): convert the parameter to string
		print >> dbfile, ENDREC
	print >> dbfile, ENDDB
	dbfile.close()
	
def loadDbase(dbfilename=dbfilename):
	"parse data to reconstruct database"
	dbfile = open(dbfilename)
	import sys
	sys.stdin = dbfile
	db = {}
	key = raw_input()	#get input
	while key != ENDDB:
		rec = {}
		field = raw_input()
		while field != ENDREC:
			name, value = field.split(RECSEP)
			rec[name] = eval(value)	# obj = eval(repr(obj)) 
			field = raw_input()
		db[key] = rec
		key = raw_input()
	return db

if __name__ == '__main__':
	from initdata import db
	storeDbase(db)
				

## dump_db_file.py
from make_db_file import loadDbase
db = loadDbase()
for key in db:
	print key, '=>\n ', db[key]
print db['sue']['name']


## update_db_file.py
from make_db_file import loadDbase, storeDbase
db = loadDbase()
db['sue']['pay] *= 1.10
db['tom']['name'] = 'Tom Tom'
storeDbase(db)

## make_db_pickle.py
from initdata import db
import pickle
dbfile = open('people-pickle', 'w')
pickle.dump(db, dbfile)
dbfile.close()


## dump_db_pickle.py
import pickle
dbfile = open('people-pickle')
db = pickle.load(dbfile)
for key in db:
	print key, '=>\n ', db[key]
print db['sue']['name']


## make_db_pickle_recs.py
from initdata import bob, sue, tom
import pickle
for (key, record) in [('bob', bob), ('tom', tom), ('sue', sue)]:
	recfile = open(key+'.pkl', w)
	pickle.dump(record, recfile)
	recfile.close()


## dump_db_pickle_recs.py
import pickle, glob
for filename in glob.glob('*.pkl'):
	recfile = open(filename)
	record = pickle.load(recfile)
	print filename, '=>\n ', record

suefile = open('sue.pkl')
print pickle.load(suefile)['name']

## make_db_shelve.py
from initdata import bob, sue
import shelve
db = shelve.open('people-shelve')
db['bob'] = bob
db['sue'] = sue
db.close()


## dump_db_shelve.py
import shelve
db = shelve.open('people-shelve')
for key in db:
	print key, '=>\n ' db[key]
print db['sue']['name']
db.close()

## person.py
class Person:
	def __init__(self, name, age, pay=0, job=None):
		self.name = name
		self.age = age
		self.pay = pay
		self.job = job
	
	def lastName(self):
		return self.name.split()[-1]
	
	def giveRaise(self, percent):
		self.pay *= (1.0+percent)

	def __str__(self):
		return '<%s => %s>' % (self.__class__.__name__, self.name)

if __name__ == '__main__':
	bob = Person('Bob Smith', 42, 30000, 'sweng')
	sue = Person('Sue Jones', 45, 40000, 'music')
	print bob.name, sue.pay
	print bob.lastName()
	sue.giveRaise(.10)
	print sue.pay

## manager.py
from person import Person

class Manager(Person):
	def __init__(self, name, age, pay):
		Person.__init__(self, name, age, pay, 'manager')

	def giveRaise(self, percent, bonus=0.1):
		Person.giveRaise(self, percent+bonus)

# the following are equivalent:
# instance.method(arg1, arg2)
# class.method(instance, arg1, arg2)

if __name__ == '__main__':
	tom = Manager('Tom Jones', 50)
	print tom	#<Manager => Tom Jones>

## make_db_classes.py
import shelve
from person import Person
from manager import Manager

bob = Person('Bob Smith', 42, 30000, 'sweng')
sue = Person('Sue Jones', 45, 40000, 'music')
tom = Manager('Tom Jones', 50, 50000)

db = shelve.open('class-shelve')
db['bob'] = bob
db['sue'] = sue
db['tom'] = tom
db.close()

## dump_db_class.py
import shelve
db = shelve.open('class-shelve')
for key in db:
	print key, '=>\n ', db[key].name, db[key].pay

## peopleinteract_query.py
import shelve 
fieldnames = ('name', 'age', 'job', 'pay')
maxfield = max(len(f) for f in fieldnames)
db = shelve.open('class-shelve')

while True:
	key = raw_input('\nKey? => ')	#key or empty line, exc at eof
	if not key: break
	try:
		record = db[key]
	except:
		print 'No such key "%s"!' % key
	else:
		for field in fieldnames:
			print field.ljust(maxfield), '=>', getattr(record, field)

## peopleinteract_update.py
import shelve
from person import Person
fieldnames = ('name', 'age', 'job', 'pay')

db = shelve.open('class-shelve')
while True:
	key = raw_input('\nKey? => ')
	if not key: break
	if key in db.keys():
		record = db[key]
	else:
		record = Person(name='?', age='?')
	for field in fieldnames:
		currval = getattr(record, field)
		newtext = raw_input('\t[%s]=%s\n\t\tnew?=>' % (field, currval))
		if newtext:
			setattr(record, field, eval(newtext))
	db[key] = record
db.close()

##tkinter001.py
from Tkinter import *
Label(text='Spam').pack()
mainloop()

##tkinter101.py
from Tkinter import *
from tkMessageBox import showinfo

def reply():
	showinfo(title='popup', message='button pressed!')

window = Tk()
button = Button(window, text='press', command=reply)
button.pack()
window.mainloop()

##tkinter102.py
from Tkinter import *
from tkMessageBox import showinfo

class MyGui(Frame):
	def __init__(self, parent=None):
		Frame.__init__(self, parent)
		button = Button(self, text='press', command=self.reply)
		button.pack()
	def reply(self):
		showinfo(title='popup', message='Button pressed!')

if __name__ == '__main__':
	window = MyGui()
	window.pack()
	window.mainloop()

## attachgui.py
from Tkinter import *
from tkinter102 import MyGui

# main app window
mainwin = Tk()
Label(mainwin, text=__name__).pack()

# popup window
popup = Toplevel()
Label(popup, text='Attach').pack(side=LEFT)
MyGui(popup).pack(side=RIGHT)
mainwin.mainloop()

## customizegui.py
from tkMessageBox import showinfo
from tkinter102 import MyGui

class CustomGui(MyGui):
	def reply(self):
		showinfo(title='popup', message='Ouch!')

if __name__ == '__main__':
	CustomGui().pack()
	mainloop()

## tkinter103.py
from Tkinter import *
from tkMessageBox import showinfo

def reply(name):
	showinfo(title='Reply', message='Hello %s!' % name)

top = Tk()
top.title('Echo')
#top.iconbitmap('py-blue-trans-out.ico')

Label(top, text="Enter your name:").pack(side=TOP)
ent = Entry(top)
ent.pack(side=TOP)
btn = Button(top, text="Submit", command=(lambda: reply(ent.get())))
btn.pack(side=LEFT)

top.mainloop()

## peoplegui.py
from Tkinter import *
from tkMessageBox import showerror
import shelve
shelvename = 'class-shelve'
fieldnames = ('name', 'age', 'job', 'pay')

def makeWidgets():
	global entries
	window = Tk()
	window.title('People Shelve')
	form = Frame(window)
	labels = Frame(form)
	values = Frame(form)
	labels.pack(side=LEFT)
	values.pack(side=RIGHT)
	form.pack()
	entries = {}
	for label in ('key',)+fieldnames:
		Label(labels, text=label).pack()
		ent = Entry(values)
		ent.pack()
		entries[label] = ent
	Button(window, text="Fetch", command=fetchRecord).pack(side=LEFT)
	Button(window, text="Update", command=updateRecord).pack(side=LEFT)
	Button(window, text="Quit", command=window.quit).pack(side=RIGHT)
	return window

def fetchRecord():
	key = entries['key'].get()
	try:
		record = db[key]
	except:
		showerror(title='Error', message='No Such Key!')
	else:
		for field in fieldnames:
			entries[field].delete(0,END)
			entries[field].insert(0, repr(getattr(record, field)))

def updateRecord():
	key = entries['key'].get()
	if key in db.keys():
		record = db[key]
	else:
		from person import Person
		record = Person(name='?', age='?')
	for field in fieldnames:
		setattr(record, field, eval(entries[field].get()))
	db[key] = record

db = shelve.open(shelvename)
window = makeWidgets()
window = mainloop()
db.close()
	

## webserver.py
webdir = '.'
port = 80

import os, sys
from BaseHTTPServer import HTTPServer
from CGIHTTPServer import CGIHTTPRequestHandler

if sys.platform[:3] == 'win':
	CGIHTTPRequestHandler.have_popen2 = False
	CGIHTTPRequestHandler.have_popen3 = False

os.chdir(webdir)
srvraddr = ("", port)
srvrobj = HTTPServer(srvraddr, CGIHTTPRequestHandler)
srvrobj.serve_forever()

## cgi101.html
<html>
<title>Interactive Page</title>
<body>
<form method=POST action="cgi-bin/cgi101.py">
	<p><B>Enter your name:</B>
	<p><input type=text name=user>
	<p><input type=submit>
</form>
</body></html>

## cgi101.py
#!/usr/bin/python
import cgi
form = cgi.FieldStorage()
print "Content-type: text/html\n"
print "<title>Reply Page</title>"
if not form.has_key('user'):
	print "<h1>Who are you?</h1>"
else:
	print "<h1>Hello <i>%s</i>!</h1>" % cgi.escape(form['user'].value)

## command line
>>> from urllib import urlopen
>>> conn = urlopen('http://localhost/cgi-bin/cgi101.py?user=Sue+Smith')
>>> reply = conn.read()
>>> reply
'<title>Reply Page</title>\n<h1>Hello <i>Sue Smith</i>!</h1>\n'


## peoplecgi.html
<html>
<title>People Input Form</title>
<body>
<form method=POST action="cgi-bin/peoplecgi.py">
	<table>
	<tr><th>Key  <td><input type=text name=key>
	<tr><th>Name <td><input type=text name=name>
	<tr><th>Age  <td><input type=text name=age>
	<tr><th>Job  <td><input type=text name=job>
	<tr><th>Pay  <td><input type=text name=pay>
	</table>
	<p>
	<input type=submit value="Fetch", name=action>
	<input type=submit value="Update", name=action>
</form>
</body></html>


## peoplecgi.py, 'Permission denied' when executing db = shelve.open()
#!/usr/bin/python
import cgi, shelve
from person import Person
form = cgi.FieldStorage()
print "Content-type: text/html"
shelvename = 'class-shelve'
fieldnames = ('name', 'age', 'job', 'pay')

replyhtml = """
<html>
<title>People Input Form</title>
<body>
<form method=POST action="peoplecgi.py">
	<table>
	<tr><th>Key  <td><input type=text name=key value="%(key)s">
	$ROWS$
	</table>
	<p>
	<input type=submit value="Fetch", name=action>
	<input type=submit value="Update", name=action>
</form>
</body></html>
"""

rowhtml = '<tr><th>%s<td><input type=text name=%s value="%%(%s)s">\n'
rowshtml = ''
for fieldname in fieldnames:
	rowshtml += (rowhtml % ((fieldname,) *3))
replyhtml = replyhtml.replace('$ROWS$', rowshtml)

def htmlize(adict):
	new = adict.copy()
	for field in fieldnames:
		value = new[field]
		new[field] = cgi.escape(repr(value))
	return new

def fetchRecord(db, form):
	try:
		key = form['key'].value
		record = db[key]
		fields = record.__dict__
		fields['key'] = key
	except:
		fields = dict.fromkeys(fieldnames, '?')
		fields['key'] = 'Missing or invalid key!'
	return fields

def updateRecord(db, form):
	if not form.has_key('key'):
		fields = dict.fromkeys(fieldnames, '?')
		fields['key'] = 'Missing key input!'
	else:
		key = form['key'].value
		if key in db.keys():
			record = db[key]
		else:
			record = Person(name='?', age='?')
		for field in fieldnames:
			setattr(record, field, eval(form[field].value))
		db[key] = record
		fields = record.__dict__
		fields['key'] = key
	return fields

db = shelve.open(shelvename)
#bob = Person('Bob Smith', 42, 30000, 'sweng')
#sue = Person('Sue Jones', 45, 40000, 'music')
#tom = Manager('Tom Jones', 50, 50000)

#db = {}#shelve.open('class-shelve')
#db['bob'] = bob
#db['sue'] = sue
#db['tom'] = tom


action = form.has_key('action') and form['action'].value
if action == 'Fetch':
	fields = fetchRecord(db, form)
elif action == 'Update':
	fields = updateRecord(db, form)
else:
	fields = dict.fromkeys(fieldnames, '?')
	fields['key'] = 'Missing or invalid action!'
db.close()
print replyhtml % htmlize(fields)

#if __name__ == '__main__':
#	db = shelve.open(shelvename)
#	print 'in main'
#	print db['bob']
#	db.close()

## more.py
def more(text, numlines=15):
	lines = text.split('\n')
	while lines:
		chunk = lines[:numlines]
		lines = lines[numlines:]
		for line in chunk: print line
		if lines and raw_input('More?) not in ['y', 'Y']: break

if __name__ == '__main__':
	import sys
	more(open(sys.argv[1]).read(), 10)

## command line
>>> str = 'SHRUBBERY'
>>> str.lower()
'shrubbery'
>>> str.isalpha()
>>> str.isdigit()
>>> import string
>>> string.lowercase
>>> str = 'aaa,bbb,ccc'
>>> str.split(',')
['aaa', 'bbb', 'ccc']
>>> str = 'a b\nc\nd'
>>> str.split()
['a','b','c','d']
>>> delim = 'NI'
>>> delim.join(['aaa','bbb','ccc'])
>>> 'aaaNIbbbNIccc'
>>> ' '.join(['A', 'dead', 'parrot'])
'A dead parrot'
>>> chars = list('Lorreta')
['L','o','r','r','e','t','a']
>>> chars.append('!')
>>> ''.join(chars)
'Lorreta!'

>>> str = 'xxaaxxaa'
>>> 'SPAM'.join(str.split('aa'))	# replace, the hard way
'xxSPAMxxSPAM'

>>> int("42"), eval("42")	# string to int
(42, 42)
>>> str(42), repr(42), ("%d" % 42)	# int to string
('42', '42', '42')
>>> "42"+str(1), int("42")+1	# add
('421', 43)

>>> import sys	# system info
>>> sys.platform, sys.maxint, sys.version, sys.path

## os Module
>>> os.getpid()
>>> os.getcmd()
>>> os.chdir(r'c:\tmp')	# r means do not escape
>>> os.pathsep, os.sep, os.pardir, os.curdir, os.linesep
>>> os.path.isdir(r'C:\temp'),	os.path.isfile(r'C:\temp')
(True, False)
>>> os.path.exists(r'C:\temp\data.txt')
0
>>> os.path.getsize(r'C:\autoexec.bat')
260
>>> os.path.split(r'C:\temp\data.txt')
('C:\\temp', 'data.txt')
>>> os.path.join(r'C:\temp', 'output.txt')
'C:\\temp\\output.txt'

>>> name = r'C:\temp\data.txt'
>>> os.path.basename(name), os.path.dirname(name)	# Windows paths
('data.txt', 'C:\\temp')

import os
os.system('dir /B'), os.system('type helloshell.py')

>>> open('helloshell.py').read()
>>> text = os.popen('type helloshell.py').read()	# os.popen also connects to the standard input or output streams of the command
>>> listing = os.popen('dir /B').readlines()

# When os.system and os.popen are called, they must start a brand-new, independent program running on your operating system (they generally run the command in a newly forked process)

## testargv.py
import sys
print sys.argv

## command line test
>>> python testargv.py -i data.txt -o result.txt
['testargv.py', '-i', 'data.txt', '-o', 'result.txt']

# parse arguments library: getopt, optparse

## Shell Environment Variables
>>> import os
>>> os.environ.keys(), os.environ['TEMP']

# it's worth pointing out that it can be made a bit less machine dependent by listing the Unix env command at the top instead of a hardcoded path to the Python executable:

#!/usr/bin/env python
print 'Wait for it...'

## setenv.py
import os
print 'setenv...'
print os.environ['USER']

os.environ['USER'] = 'Brian'
os.system('python echoenv.py')

os.environ['USER'] = 'Arthur'
os.system('python echoenv.py')

os.environ['USER'] = raw_input('?')
print os.popen('python echoenv.py').read()

## echoenv.py
import os
print 'echoenv...'
print 'Hello, ', os.environ['USER']

## teststreams.py
def interact():
	print 'Hello stream world'
	while 1:
		try:
			reply = raw_input('Enter a number>')
		except EOFError:
			break
		else:
			num = int(reply)
			print "%d squared is %d" % (num, num ** 2)
	print 'Bye'

if __name__ == '__main__':
	interact()

## command line
>>> python teststreams.py < input.txt > output.txt
>>> python teststreams.py < input.txt | more

## moreplus.py
import sys
def getreply():
	if sys.stdin.isatty():		# if stdin is console
		return raw_input('?')	
	else:
		if sys.platform[:3] == 'win':	# if stdin was redirected
			import msvcrt
			msvcrt.putch('?')
			key = msvcrt.getche()
			msvcrt.putch('\n')
			return key
		elif sys.platform[:5] == 'linux':	# use linux console device
			print '?'
			console = open('/dev/tty')
			line = console.readline()[:-1]	#strip eoln at line end
			return line
		else:
			print '[pause]'
			import time
			time.sleep(5)
			return 'y'

def more(text, numlines=10):
	lines = text.split('\n')
	while lines:
		chunk = lines[:numlines]
		lines = lines[numlines:]
		for line in chunk: print line
		if lines and getreply() not in ['y', 'Y']: break

if __name__ == '__main__':
	if len(sys.argv) == 1:
		more(sys.stdin.read())
	else:
		more(open(sys.argv[1]).read())

## redirect.py

import sys
class Output:
	def __init__(self):
		self.text = ''
	def write(self, string):
		self.text = self.text+string
	def writelines(self, lines):
		for line in lines: self.write(line)

class Input:
	def __init__(self, input=''):
		self.text = input
	def read(self, *size):	#size is a variable argument list, http://blog.csdn.net/chenjinyu_tang/article/details/8136841
		if not size:
			res, self.text = self.text, ''
		else:
			res, self.text = self.text[:size[0]], self.text[size[0]:]
		return res
	def readline(self):
		eoln = self.text.find('\n')
		if eoln == -1:
			res, self.text = self.text, ''
		else:
			res, self.text = self.text[:eoln+1], self.text[eoln+1:]
		return res
	def redirect(function, args, input):
		savestreams = sys.stdin, sys.stdout
		sys.stdin = Input(input)
		sys.stdout= Output()
		try:
			function(*args)
		except:
			sys.stderr.write('error in function! ')
			sys.stderr.write('%s, %s\n' % tuple(sys.exc_info()[:2]))
		result = sys.stdout.text
		sys.stdin, sys.stdout = savestreams
		return result

## command line
>>> from teststreams import interact
>>> interact()
Hello stream world
Enter a number>2
2 squared is 4
Enter a number>3
3 squared is 9
Enter a number

>>> from redirect import redirect
>>> output = redirect(interact, (), '4\n5\n')
>>> output
'Hello stream world\nEnter a number>4 squared is 16\nEnter a number>5 squared is 25\nEnter a number>Bye\n'

## StringIO Module
>>> from StringIO import StringIO
>>> buff = StringIO()
>>> buff.write('spam\n')
>>> buff.write('eggs\n')
>>> buff.getvalues()
'spam\neggs\n'

>>> buff = StringIO('ham\nspam\n')
>>> buff.readline()
'ham\n'
>>> buff.readline()
'spam\n'
>>> buff.readline()
''

>>> from StringIO import StringIO
>>> import sys
>>> buff = StringIO()

>>> temp = sys.stdout
>>> sys.stdout = buff
>>> print 42, 'spam', 3.141

>>> sys.stdout = temp
>>> buff.getvalue()
'42 spam 3.141\n'

# 2>&1 means redirect the standard error to standard output

## Other Redirection Options
## hello-out.py
print 'Hello shell world'

## hello-in.py
input = raw_input()
open('hello-in.txt', 'w').write('Hello '+input+'\n')

## command line
>>> import os
>>> pipe = os.popen('python hello-out.py')	#'r' is default--read output
>>> pipe.read()
'Hello shell world\n'

>>> pipe = os.popen('python hello-in.py', 'w')
>>> pipe.write('Gumby\n')
>>> pipe.close()
>>> open('hello-in.txt').read()
Hello Gumby\n'

>>>import struct
>>> data = struct.pack('>i4shf', 2, 'spam', 3, 1.234)	# '>i4shf' means big-endian(>), an integer, four-character string, half integer, and float

>>> file = open('data.bin', 'wb')
>>> file.write(data)
>>> file.close()

>>> file = open('data.bin', 'rb')
>>> bytes = file.read()
>>> values = struct.unpack('>i4shf', data)
>>> values
(2, 'spam', 3, 1.23399996)

>>> import os
>>> os.popen('dir /B').readlines()
['about-p.html\n', 'python1.5.tar.gz\n', ...]

>>> import glob
>>> glob.glob('*.html')
['about-pp.html', 'about-pp2e.html', 'about-ppr2e.html']

>>> import os
>>> def lister(dummy, dirname, filesindir):
	print '['+ dirname + ']'
	for fname in filesindir:
		print os.path.join(dirname, fname)

>>> os.path.walk('.', lister, None)

>>> matches = []
>>> for (dirname, dirshere, fileshere) in os.walk(r'D:\PP3E'):
	for filename in fileshere:
		if filename.endswith('.py'):
			pathname = os.path.join(dirname, filename)
			if 'Tkinter' in open(pathname).read():
				matches.append(pathname)

## lister_recur.py
import sys, os

def mylister(currdir):
	print '[' + currdir + ']'
	for file in os.listdir(currdir):
		path = os.path.join(currdir, file)
		if not os.path.isdir(path):
			print path
		else:
			mylister(path)

if __name__ == '__main__':
	mylister(sys.argv[1])

## find.py
#!/usr/bin/python
import fnmatch, os

def find(pattern, startdir=os.curdir):
	matches = []
	os.path.walk(startdir, findvisitor, (matches, pattern))
	matches.sort()
	return matches
	
def findvisitor((matches, pattern), thisdir, nameshere):
	for name in nameshere:
		if fnmatch.fnmatch(name, pattern):
			fullpath = os.path.join(thisdir, name)
			matches.append(fullpath)
			
if __name__ == '__main__':
	import sys
	namepattern, startdir = sys.argv[1], sys.argv[2]
	for name in find(namepattern, startdir): print name 

## usage:
# python find.py *.py .| more

# for name in find.find('*.py'):
#	...do something with name...

## fork1.py
import os

def child():
	print 'Hello from child', os.getpid()
	os._exit(0)	# else goes back to parent loop

def parent():
	while 1:
		newpid = os.fork()
		if newpid == 0:
			child()
		else:
			print 'Hello from parent', os.getpid(), newpid
		if raw_input()=='q': break

parent()

## fork-exec.py
import os

parm = 0
while 1:
	parm = parm+1
	pid = os.fork()
	if pid == 0:
		os.execlp('python', 'python', 'child.py', str(parm))
		assert False, 'error starting program'
	else:
		print 'Child is', pid
		if raw_input() == 'q': break


## child.py
import os, sys
print 'Hello from child', os.getpid(), sys.argv[1]

## thread1.py
import thread

def child(tid):
	print 'Hello from thread', tid

def parent():
	i = 0
	while i:
		i = i+1
		thread.start_new(child, (i,))
		if raw_input() == 'q': break

parent()


## thread-count-mutex.py
import thread, time

def counter(myId, count):
	for i in range(count):
		mutex.acquire()
		#time.sleep(1)
		print '[%s] => %s' % (myId, i)
		mutex.release()

mutex = thread.allocate_lock()
for i in range(10):
	thread.start_new_thread(counter, (i,3))

time.sleep(6)
print 'Main thread exit'


## thread-count-wait1.py
import thread

def counter(myId, count):
	for i in range(count):
		stdoutmutex.acquire()
		print '[%s] => %s' % (myId, i)
		stdoutmutex.release()
	exitmutexes[myId].acquire()	#signal main thread

stdoutmutex = thread.allocate_lock()
exitmutexes = []
for i in range(10):
	exitmutexes.append(thread.allocate_lock())
	thread.start_new(counter, (i, 100))

for mutex in exitmutexes:
	while not mutex.locked(): pass
print 'Main thread exiting.'


## thread-classes.py

import thread

class mythread(threading.Thread):
	def __init__(self, myId, count):
		self.myId = myId
		self.count = count
		threading.Thread.__init__(self)
	
	def run(self):
		for i in range(self.count):
			stdoutmutex.acquire()
			print '[%s] => %s' % (self.myId, i)
			stdoutmutex.release()

stdoutmutex = threading.Lock()	# same as thread.allocate_lock()
threads = []
for i in range(10):
	thread = mythread(i, 100)
	thread.start()
	threads.append(thread)

for thread in threads:
	thread.join()	#wait for thread exits
print 'Main thread exiting'

# subclass with state
class mythread(threading.Thread):
	def __init__(self, myId, count):
		self.i = i
		threading.Thread.__init__(self)
	
	def run(self):
		consumer(self.i)

mythread.start()

# pass action in
thread = threading.Thread(target=(lambda: consumer(i)))
thread.start()

# same but no lambda wrapper for state
threading.Thread(target=consumer, args=(i,)).start()

# basic thread module
thread.start_new_thread(consumer, (i,))

## xd5 ueuetest.py

# the queue object is automatically controlled with thread lock acquire and release calls, such that only one thread can modify the queue at any given point in time.

numconsumers = 2
numproducers = 4
nummessages = 4

import thread,Queue,time
safeprint = thread.allocate_lock()
dataQueue = Queue.Queue()

def producer(idnum):
	for msgnum in range(nummessages):
		time.sleep(idnum)
		dataQueue.put('producer %d:%d' % (idnum, msgnum))

def consumer(idnum):
	while 1:
		time.sleep(0.1)
		try:
			data = dataQueue.get(block=False)
		except Queue.Empty:
			pass
		else:
			safeprint.acquire()
			print 'consmer', idnum, 'got =>',data
			safeprint.release()

if __name__ = '__main__':
	for i in range(numconsumers):
		thread.start_new_thread(consumer, (i,))
	for i in range(numproducers):
		thread.start_new_thread(producor, (i,))
	time.sleep(((numproducers-1)* nummessages) + 1)

>>> sys.exit(N)	# else exits on end of script, with status N

## testexit_sys.py

def later():
	import sys
	print 'Bye sys world'
	sys.exit(42)
	print 'Never reached'

if __name__ == '__main__': later()

>>> from testexit_sys import later
>>> try:
	later()
    except SystemExit:
    	print 'Ignored...'

Bye sys world
Ignored...
>>> from testexit_sys import later
>>> try:
	later()
    finally:
    	print 'Cleanup'

Bye sys world
Cleanup

>>> python testexit_sys.py
Bye sys world
>>> echo $status
42

>>> import os
>>> pipe = os.popen('python testexit_sys.py')
>>> pipe.read()
'Bye sys world\012'
>>> stat = pipe.close()
>>> stat
10752
>>> hex(stat)
'0x2a00'
>>> stat >> 8
42	# 0x2a = 00101010 = 42 

## testexit_os.py

def outahere():
	import os
	print 'Bye os world'
	os._exit(99)	#Unlike os.exit, os_exit is immune to both try/except and try/finally interception
	print 'Never reached'

if __name__ == '__main__': outahere()

>>> from testexit_os import outahere
>>> try:
	outahere()
    except:
    	print 'Ignored'

Bye os world

>>> from testexit_os import outahere
>>> try:
	outahere()
    finally:
    	print 'Cleanup'

Bye os world

>>> python testexit_os.py
Bye os world
>>> echo $status
99

## pipe1.py

import os,time

def child(pipeout):
	zzz = 0
	while 1:
		time.sleep(zzz)
		os.write(pipeout, 'Spam %03d' % zzz)
		zzz = (zzz+1)%5

def parent():
	pipein, pipeout = os.pipe()
	if os.fork() == 0:
		child(pipeout)
	else:
		while 1:
			line = os.read(pipein, 32)
			print 'Parent %d got "%s" at %s ' % (os.getpid(), line, time.time())

parent()

>>> python pipe1.py
Parent 6583 got "Spam 000" at 1424657721.27 
Parent 6583 got "Spam 001" at 1424657722.28 
Parent 6583 got "Spam 002" at 1424657724.28 
Parent 6583 got "Spam 003" at 1424657727.28 
Parent 6583 got "Spam 004Spam 000" at 1424657731.28 
Parent 6583 got "Spam 001" at 1424657732.29 
Parent 6583 got "Spam 002" at 1424657734.29 
Parent 6583 got "Spam 003" at 1424657737.29 
Parent 6583 got "Spam 004Spam 000" at 1424657741.29 
Parent 6583 got "Spam 001" at 1424657742.3 

## pipe2.py

import os,time

def child(pipeout):
	zzz = 0
	while 1:
		time.sleep(zzz)
		os.write(pipeout, 'Spam %03d' % zzz)
		zzz = (zzz+1)%5

def parent():
	pipein, pipeout = os.pipe()
	if os.fork() == 0:
		os.close(pipein)
		child(pipeout)
	else:
		os.close(pipeout)
		pipein = os.fdopen(pipein)
		while 1:
			line = pipein.readline()[:-1]
			print 'Parent %d got "%s" at %s ' % (os.getpid(), line, time.time())

parent()

## spawnv.py
import os, sys

for i in range(10):
	if sys.platform[:3] == 'win':
		pypath = sys.executable
		os.spawnv(os.P_NOWAIT, pypath, ('python', 'child.py', str(i)))
	else:
		pid = os.fork()
		if pid != 0:
			print 'Process %d spawned' % pid
		else:
			os.execlp('python', 'python', 'child.py', str(i))

print 'Main process exiting.'

#parameters of spawnv:

#os.P_NOWAIT and os.P_NOWAITTO:
## The spawn function will return as soon as the new process has been created, with the process ID as the return value.
#os.P_WAIT
## The spawn function will not return until the new process has run to completion and will return the exit code of the run is successful or '-signal' if a signal kills the process
#os.P_DETACH and os.P_OVERLAY
## P_DETACH is similar to P_NOWAIT, but the new process is detached from the comsole of the calling process. If P_OVERLAY is used, the current program will be replaced (much like os.exec)

## split.py

#!/usr/bin/python
import sys, os
kilobytes = 1024
megabytes = kilobytes*1000
chunksize = int(1.4*megabytes)

def split(fromfile, todir, chunksize=chunksize):
	if not os.path.exists(todir):
		os.mkdir(todir)
	else:
		for fname in os.listdir(todir):
			os.remove(os.path.join(todir, fname))
	partnum = 0
	input = open(fromfile, 'rb')
	while 1:
		chunk = input.read(chunksize)
		if not chunk: break
		partnum = partnum+1
		filename = os.path.join(todir, ('path%04d' % partnum))
		fileobj = open(filename, 'wb')
		fileobj.write(chunk)
		fileobj.close()
	input.close()
	assert partnum <= 9999
	return partnum

if __name__ == '__main__':
	if len(sys.argv) == 2 and sys.argv[1]=='-help':
		print 'Use: split.py [file-to-split target-dir [chunksize]]'
	else:
		if len(sys.argv) < 3:
			interactive = 1
			fromfile = raw_input('File to be split? ')
			todir = raw_input('Directory to store part files? ')
		else:
			interactive = 0
			fromfile, todir = sys.argv[1:3]
			if len(sys.argv) == 4: chunksize = int(sys.argv[3])
		absfrom, absto = map(os.path.abspath, [fromfile, todir])
		print 'Splitting', absfrom, 'to', absto, 'by', chunksize
		
		try:
			parts = split(fromfile, todir, chunksize)
		except:
			print 'Error during split:'
			print sys.exc_info()[0], sys.exc_info()[1]
		else:
			print 'Split finished:', parts, 'parts are in', absto
		if interactive:	raw_input('Press Enter key') 


## join.py
#!/usr/bin/python

import os, sys
readsize = 1024

def join(fromdir, tofile):
	output = open(tofile, 'wb')
	parts = os.listdir(fromdir)
	parts.sort()
	for filename in parts:
		filepath = os.path.join(fromdir, filename)
		fileobj = open(filepath, 'rb')
		while 1:
			filebytes = fileobj.read(readsize)
			if not filebytes: break
			output.write(filebytes)
		fileobj.close()
	output.close()

if __name__ == '__main__':
	if len(sys.argv) == 2 and sys.argv[1]=='-help':
		print 'Use: join.py [form-dir-name to-file-name]'
	else:
		if len(sys.argv) != 3:
			interactive = 1
			fromdir = raw_input('Directory containing part files? ')
			tofile = raw_input('Name of file to be recreated? ')
		else:
			interactive = 0
			fromdir, tofile = sys.argv[1:]
		absfrom, absto = map(os.path.abspath, [fromdir, tofile])
		print 'Joining', absfrom, 'to make', absto

		try:
			join(fromdir, tofile)
		except:
			print 'Error joining files:'
			print sys.exc_info()[0], sys.exc_info()[1]
		else:
			print 'Join complete: see', absto
		if interactive: raw_input('Press Enter Key') 

>>> list = ['xx8', 'xx10', 'xx6', 'xx9', 'xx11', 'xx111']
>>> list.sort()
['xx10', 'xx11', 'xx111', 'xx6', 'xx8', 'xx9']
>>> list.sort(lambda x,y: cmp(int(x[2:]), int(y[2:])))
['xx6', 'xx8', 'xx9', 'xx10', 'xx11', 'xx111']

## regtest.py

#!/usr/bin/python
import os, sys, time
from glob import glob

print 'RegTest start.'
print 'user:', os.environ['USER']
print 'path:', os.getcwd()
print 'time:', time.asctime(), '\n'
program = sys.argv[1]
testdir = sys.argv[2]

for test in glob(testdir + '/*.in'):
	if not os.path.exists('%s.out' % test):
		os.system('%s < %s > %s.out 2>&1' % (program, test, test)) 
		print 'GENERATED:', test
	else:
		os.rename(test + '.out', test+'.out.bkp')
		os.system('%s < %s > %s.out 2>&1' % (program, test, test))
		os.system('diff %s.out %s.out.bkp > %s.diffs', % ((test,)*3))
		if os.path.getsize(test+'.diffs') == 0:
			print 'PASSED:', test
			os.remove(test+'.diffs')
		else:
			print 'FAILED:', test, '(see %s.diffs)' % test

print 'RegTest done:', time.asctime()

## LaunchBrowser.py
...
def launchBrowser(Mode='-file', Page='index.html', Site=None, verbose=True):
	...

>>> launchBrowser(Page=r'C:\about-pp.html')
>>> launchBrowser(Mode='-live', Page='index.html', Site='www.python.org')

>>> import webbrowser	# standard library
>>> webbrowser.open_new('file://'+fullfilename)	# or http://...

>>> import mimetypes
>>> mimetypes.guess_type('spam.jpg')
('image/jpeg', None)
>>> mimetypes.guess_type('spam.mp3')
('audio/mpeg', None)
>>> mimetypes.guess_type('spam.mpg')
('video/mpeg', None)
>>> mimetypes.guess_type('spam.xyz')
(None, None)
>>> mimetypes.guess_type('spam.gif.gz')
('image/gif', 'gzip')
>>> mimetypes.guess_extension('audio/basic')
'.au'

## fixeoln_one.py

import os
listonly = False	# True=show file to be changed, don't rewrite

def convertEndlines(format, fname):	# convert one file
	if not os.path.isfile(fname):	
		print 'Not a text file', fname
		return

	newlines = []
	changed = 0
	for line in open(fname, 'rb').readlines():
		if format == 'todos':	# todos: \n => \r\n
			if line[-1:] == '\n' and line[-2:-1] != '\r':
				line = line[:-1]+'\r\n'
				changed = 1
		elif: format == 'tounix':	# tounix: \r\n => \n
			if line[-2:] == '\r\n':
				line = line[:-2]+'\n'
				changed = 1
		newlines.append(line)

	if changed:
		try:
			print 'Changing', fname
			if not listonly: open(fname, 'wb').writelines(newlines)
		except IOError, why:
			print 'Error writing to file %s: skipped (%s)' % (fname, why)

if __name__ == '__main__':
	import sys
	errmsg = 'Required arguments missing: ["todos" | "tounix"] filename'
	assert (len(sys.argv)==3 and sys.argv[1] in ['todos', 'tounix']), errmsg
	convertEndlines(sys.argv[1], sys.argv[2])
	print 'Converted', sys.argv[2]

## gui1e.py

from Tkinter import *
Label(text='Hello GUI world').pack(expand=YES, fill=BOTH)
mainloop()

# expand=YES option: 
#	Asks the packer to expand the allocated space for the widget in general into any unclaimed space in the widget's parent
# fill option
#	Can be used to stretch the widget to occupy all of its allocated space

def weird():
	spam = 42
	return (lambda: spam*2)

act = weird()
print act()	# prints 84

def weird():
	tmp = (lambda: spam*2)
	spam = 42	# even though not set till here
	return tmp

act = weird()
print act()	# prints 84

def odd():
	funcs = []
	for c in 'abcdefg':
		funcs.append((lambda: c))
	return funcs

for func in odd():
	print func(),	#print 7 g's, not a,b,c...!

def odd():
	funcs = []
	for c in 'abcdefg':
		funcs.append((lambda c=c: c))
	return funcs

for func in odd():
	print func(),	#OK: now prints a,b,c...


## gui3d.py
from Tkinter import *
class HelloCallable:
	def __init__(self):
		self.msg = 'Hello __call__ world'
	def __call__(self):	#implement __call__ to make the class invokable
		print self.msg
		import sys; sys.exit()

widget = Button(None, text='Hello event world', command=HelloCallable())
widget.pack()
widget.mainloop()

#>>> python gui3d.py
#Hello __call__ world

# Binding Events
## gui3e.py
from Tkinter import *

def hello(event):
	print 'Press twice to exit'

def quit(event):
	print 'Hello, I must be going...'
	import sys; sys.exit()

widget = Button(None, text='Hello event world')
widget.pack()
widget.bind('<Button-1>', hello)	# bind left mouse clicks
widget.bind('<Double-1>', hello)	# bind double-left clicks
widget.mainloop()

# Using Anchor to Position Instead of Stretch

Button(win, text='Hello', command=greeting).pack(side=LEFT, anchor=N) # anchor=N, NE, NW, S, etc
Label(win, text='Hello container world').pack(side=TOP)
Button(win, text='Quit', command=win.quit).pack(side=RIGHT)

# Reusable GUI Components with Classes

## gui6.py
from Tkinter import *

class Hello(Frame):
	def __init__(self, parent=None):
		Frame.__init__(self, parent)
		self.pack()
		self.data = 42
		self.make_widgets()
	def make_widgets(self):
		widget = Button(self, text='Hello frame world', command=self.message)
		widget.pack(side=LEFT)
	def message(self):
		self.data += 1
		print 'Hello frame world %s!' % self.data

if __name__ == '__main__': Hello().mainloop()

## gui7.py
class HelloPackage:	# Standalone Container Classes
	def __init__(self, parent=None):
		self.top = Frame(parent)
		self.top.pack()
		self.data = 0
		self.make_widgets()
	def make_widgets(self):
		Button(self.top, text='Bye', command=self.top.quit).pack(side=LEFT)
		Button(self.top, text='Hye', command=self.message).pack(side=RIGHT)
	def message(self):
		self.data += 1
		print 'Hello number', self.data
		
if __name__ == '__main__': HelloPackage().top.mainloop()