1.1  9   5.2
1.762543E-02
0 0.01 0.001

9 3 7

F = open(filename, 'r')
n = F.read().split()

open F, $filename; 
$s = join "", <F>; 
@n = split ' ', $s;

(-3, 1.4)  or  (-1.437625E-9, 7.11)  or  (  4, 2 )

m = re.search(r'\(\s*([^,]+)\s*,\s*([^,]+)\s*\)', 
              '(-3,1.4)')
re, im = [float(x) for x in m.groups()]

$s="(-3, 1.4)"; 
($re,$im)= $s=~ /\(\s*([^,]+)\s*,\s*([^,]+)\s*\)/;

\(\s*([^,]+)\s*,\s*([^,]+)\s*\)

s = '(-3,  1.4 )'
re, im = s[1:-1].split(',')

def debug(leading_text, variable):
    if os.environ.get('MYDEBUG', '0') == '1':
        print leading_text, variable

template <class T>
void debug(std::ostream& o, 
           const std::string& leading_text, 
           const T& variable)
{ 
  char* c = getenv("MYDEBUG");
  bool defined = false;
  if (c != NULL) {  // if MYDEBUG is defined ...
    if (std::string(c) == "1") {  // if MYDEBUG is true ...
      defined = true;
    }
  }
  if (defined) {
    o <<  leading_text << " " << variable << std::endl; 
  }
}

# f is some data
plot(f)

plot(f, label='f', xrange=[0,10])

plot(f, label='f', xrange=[0,10], title='f demo',
     linetype='dashed', linecolor='red')

def plot(data, label='', xrange=None, title='',
         linetype='solid', linecolor='black', ...)

if xrange is not None:  # i.e. xrange is specified by the user
    if isinstance(xrange, list):      # list [xmin,xmax] ?
        xmin = xrange[0];  xmax = xrange[1]
    elif isinstance(xrange, str):     # string 'xmin:xmax' ?
        xmin, xmax = re.search(r'(.*):(.*)',xrange).groups()
    elif isinstance(xrange, float):   # just a float?
        xmin = 0;  xmax = xrange

c = 1            # c is an integer
c = [1,2,3]      # c is a list

double c; c = 5.2;   # c can only hold doubles
c = "a string..."    # compiler error

$b = '1.2'
$c = 5*$b;   # implicit type conversion: '1.2' -> 1.2

b = '1.2'
c = 5*b      # illegal; no implicit type conversion

a = 1.2
no of iterations = 100
solution strategy = 'implicit'
c1 = 0
c2 = 0.1
A = 4
c3 = StringFunction('A*sin(x)')

file = open('inputfile.dat', 'r')
for line in file:
    # first replace blanks on the left-hand side of = by _
    variable, value = line.split('=').strip()
    variable = re.sub(' ', '_', variable)
    exec(variable + '=' + value)   # magic...

set heat conduction = 5.0
set dt = 0.1
set rootfinder = bisection
set source = V*exp(-q*t) is function of (t) with V=0.1, q=1
set bc = sin(x)*sin(y)*exp(-0.1*t) is function of (x,y,t)

#!/usr/bin/env python
from Tkinter import *
root = Tk()
Label(root, text='Hello, World!',
      foreground="white", background="black").pack()
root.mainloop()

for i in range(len(A)):
    A[i] = ...

http://folk.uio.no/hpl/scripting/softwarelist.html

http://folk.uio.no/hpl/scripting/scripting-src.tar.gz

tar xvzf scripting-src.tar.gz
export scripting=`pwd`

$scripting/src/py/intro/hw.py

python hw.py 3.4

./hw.py 3.4

Hello, World! sin(3.4)=-0.255541102027

#!/usr/bin/env python

# load system and math module:
import sys, math       

# extract the 1st command-line argument:
r = float(sys.argv[1]) 

s = math.sin(r)

print "Hello, World! sin(" + str(r) + ")=" + str(s)

chmod a+rx hw.py

python hw.py 1.4   # first line is not treated as comment
./hw.py 1.4        # first line is used to specify an interpreter

import sys, math  

r = sys.argv[1]         # r is string
s = math.sin(float(r))  

# sin expects number, not string r
# s becomes a floating-point number

Hello, World! sin(3.4)=-0.255541102027

print "Hello, World! sin(" + str(r) + ")=" + str(s)

print "Hello, World! sin(%g)=%g" % (r,s)

print "Hello, World! sin(%(r)g)=%(s)g" % vars()

s1 = "some string with a number %g" % r
s2 = 'some string with a number %g' % r  # = s1

text = """
large portions of a text
can be conveniently placed
inside triple-quoted strings
(newlines are preserved)"""

s3 = r'\(\s+\.\d+\)'
# with ordinary string (must quote backslash):
s3 = '\\(\\s+\\.\\d+\\)'

./datatrans1.py infilename outfilename

infilename  = sys.argv[1]
outfilename = sys.argv[2]

try:
    infilename  = sys.argv[1]
    outfilename = sys.argv[2]
except:
    # try block failed,
    # we miss two command-line arguments
    print 'Usage:', sys.argv[0], 'infile outfile'
    sys.exit(1)

ifile = open( infilename, 'r')  # r for reading
ofile = open(outfilename, 'w')  # w for writing

afile = open(appfilename, 'a')  # a for appending

for line in ifile:
    # process line

0.1   1.4397
0.2   4.325
0.5   9.0

for line in ifile:
    pair = line.split()
    x = float(pair[0]); y = float(pair[1])
    fy = myfunc(y)  # transform y value
    ofile.write('%g  %12.5e\n' % (x,fy))

while 1:
    line = ifile.readline()  # read a line
    if not line: break
    # process line

lines = ifile.readlines()

# go through each line, 
# split line into x and y columns

x = []; y = []   # store data pairs in lists x and y

for line in lines:
    xval, yval = line.split()
    x.append(float(xval))
    y.append(float(yval))

for i in range(start,stop,inc):
    ...
for j in range(stop):
    ...

i = start, start+inc, start+2*inc, ..., stop-1
j = 0, 1, 2, ..., stop-1

ofile = open(outfilename, 'w') # open for writing

for i in range(len(x)):
    fy = myfunc(y[i])  # transform y value
    ofile.write('%g  %12.5e\n' % (x[i], fy))

ofile.close()

./datatrans1.py infile outfile

# or
datatrans1.py infile outfile

python datatrans1.py infile outfile

#!/usr/local/bin/python

#!/home/hpl/projects/scripting/Linux/bin/python

#!/usr/bin/env python

./datatrans1.py qqq someoutfile
Traceback (most recent call last):
  File "./datatrans1.py", line 12, in ?
    ifile = open( infilename, 'r')
IOError:[Errno 2] No such file or directory:'qqq'

from py4cs.numpytools import *
x = sequence(0, 1, 0.001)  # 0.0, 0.001, 0.002, ..., 1.0
x = sin(x)                 # computes sin(x[0]), sin(x[1]) etc.

for i in range(len(x)):
    x[i] = sin(x[i])

import py4cs.filetable
f = open(infilename, 'r')
x, y = py4cs.filetable.read_columns(f)
f.close()

from py4cs.numpytools import *  # import everything in NumPy
x = 10*x
y = 2*y + 0.1*sin(x)

f = open(outfilename, 'w')
py4cs.filetable.write_columns(f, x, y)
f.close()

x = zeros(n, Float)  # array with indices 0,1,...,n-1
x = zeros((m,n), Float)    # two-dimensional array
x[i,j] = 1.0               # indexing
x = zeros((p,q,r), Float)  # three-dimensional array
x[i,j,k] = -2.1
x = sin(x)*cos(x)

from py4cs.anyplot.gnuplot_ import *
x = sequence(0, 2, 0.1)
y = x + sin(10*x)
plot(x, y)

Unix/DOS> ipython
...
In [1]:3*4-1
Out[1]:11

In [2]:from math import *

In [3]:x = 1.2

In [4]:y = sin(x)

In [5]:x
Out[5]:1.2

In [6]:y
Out[6]:0.93203908596722629

In [6]:y
Out[6]:0.93203908596722629

In [7]:_ + 1
Out[7]:1.93203908596722629

In [1]: import math

In [2]: math.<TABKEY>
math.__class__         math.__str__           math.frexp
math.__delattr__       math.acos              math.hypot
math.__dict__          math.asin              math.ldexp
...

In [2]: my_variable_with_a_very_long_name = True

In [3]: my<TABKEY>
In [3]: my_variable_with_a_very_long_name

In [1]:run scriptfile arg1 arg2 ...

In [1]:run datatrans2.py .datatrans_infile tmp1

In [29]:%pdb on  # invoke pdb automatically
In [30]:run datatrans2.py infile tmp2

/home/work/scripting/src/py/intro/datatrans2.py
      7     print "Usage:",sys.argv[0], "infile outfile"; sys.exit(1)
      8
----> 9 ifile = open(infilename, 'r')  # open file for reading
     10 lines = ifile.readlines()      # read file into list of lines
     11 ifile.close()

IOError: [Errno 2] No such file or directory: 'infile'
> /home/work/scripting/src/py/intro/datatrans2.py(9)?()
-> ifile = open(infilename, 'r')  # open file for reading
(Pdb) print infilename
infile

 
somescript -option1 value1 -option2 value2

oscillator < file

3.0
0.04
1.0
...
(i.e., values of m, b, c, etc.)

set title 'case: m=3 b=0.7 c=1 f(y)=y A=5 ...';

# screen plot: (x,y) data are in the file sim.dat
plot 'sim.dat' title 'y(t)' with lines;

# hardcopies:
set size ratio 0.3 1.5, 1.0;  
set term postscript eps mono dashed 'Times-Roman' 28;
set output 'case.ps';
plot 'sim.dat' title 'y(t)' with lines;

# make a plot in PNG format as well:
set term png small;
set output 'case.png';
plot 'sim.dat' title 'y(t)' with lines;

oscillator < inputfile

gnuplot -persist -geometry 800x200 case.gp

./simviz1.py -m 3.2 -b 0.9 -dt 0.01 -case run1

m = 1.0; b = 0.7; c = 5.0; func = 'y'; A = 5.0; 
w = 2*math.pi; y0 = 0.2; tstop = 30.0; dt = 0.05; 
case = 'tmp1'; screenplot = 1

# read variables from the command line, one by one:
while len(sys.argv) >= 2:
    option = sys.argv[1];       del sys.argv[1]
    if   option == '-m':
        m = float(sys.argv[1]); del sys.argv[1]
    ...

dir = case              # subdirectory name
import os, shutil
if os.path.isdir(dir):  # does dir exist?
    shutil.rmtree(dir)  # yes, remove old files
os.mkdir(dir)           # make dir directory
os.chdir(dir)           # move to dir

os.system(command)

# examples:
os.system('myprog < input_file')
os.system('ls *')  # bad, Unix-specific

cmd = 'oscillator < %s.i' % case  # command to run
import commands
failure, output = commands.getstatusoutput(cmd)
if failure:
    print 'running the oscillator code failed'
    print output
    sys.exit(1)

f = open(case + '.gnuplot', 'w')
f.write("""
set title '%s: m=%g b=%g c=%g f(y)=%s A=%g ...';
...
""" % (case,m,b,c,func,A,w,y0,dt,case,case))
...
f.close()

cmd = 'gnuplot -geometry 800x200 -persist ' \
      + case + '.gnuplot'
failure, output = commands.getstatusoutput(cmd)
if failure:
    print 'running gnuplot failed'; print output; sys.exit(1)

f = open(case + '.m', 'w')  # write to Matlab M-file
# (the character % must be written as %% in printf-like strings)
f.write("""
load sim.dat              %% read sim.dat into sim matrix
plot(sim(:,1),sim(:,2))   %% plot 1st column as x, 2nd as y
legend('y(t)')
title('%s: m=%g b=%g c=%g f(y)=%s A=%g w=%g y0=%g dt=%g')
outfile = '%s.ps';  print('-dps',  outfile)  %% ps BW plot
outfile = '%s.png'; print('-dpng', outfile)  %% png color plot
""" % (case,m,b,c,func,A,w,y0,dt,case,case))
if screenplot: f.write('pause(30)\n')
f.write('exit\n'); f.close()

if screenplot:
    cmd = 'matlab -nodesktop -r ' + case + ' > /dev/null &'
else:
    cmd = 'matlab -nodisplay -nojvm -r ' + case
failure, output = commands.getstatusoutput(cmd)

./loop4simviz1.py m_min m_max dm \
                  [options as for simviz1.py]

try:
    m_min = float(sys.argv[1])
    m_max = float(sys.argv[2])
    dm    = float(sys.argv[3])
except:
    print 'Usage:',sys.argv[0],\
    'm_min m_max m_increment [ simviz1.py options ]'
    sys.exit(1)

['-b','5','-c','1.1'] -> '-b 5 -c 1.1'

simviz1_options = ' '.join(sys.argv[4:])

./loop4simviz1.py 0.5 2 0.5 -b 2.1 -A  3.6

m_min:  0.5
m_max:  2.0
dm:     0.5
simviz1_options = '-b 2.1 -A 3.6'

for m in range(m_min, m_max, dm):

m = m_min
while m <= m_max:
    case = 'tmp_m_%g' % m
    s = 'python simviz1.py %s -m %g -case %s' % \
        (simviz1_options,m,case)
    failure, output = commands.getstatusoutput(s)
    m += dm

html = open('tmp_mruns.html', 'w')
html.write('<HTML><BODY BGCOLOR="white">\n')

m = m_min
while m <= m_max:
    case = 'tmp_m_%g' % m
    cmd = 'python simviz1.py %s -m %g -case %s' % \
          (simviz1_options, m, case)
    failure, output = commands.getstatusoutput(cmd)
    html.write('<H1>m=%g</H1> <IMG SRC="%s">\n' \
         % (m,os.path.join(case,case+'.png')))
    m += dm
html.write('</BODY></HTML>\n')

# concatenate file1.ps, file2.ps, and so on to 
# one single file figs.ps, having pages with 
# 3 rows with 2 plots in each row (-par preserves 
# the aspect ratio of the plots)

epsmerge -o figs.ps -x 2 -y 3 -par \
         file1.ps file2.ps file3.ps ...

convert -delay 50 -loop 1000 -crop 0x0 \
        plot1.png plot2.png plot3.png plot4.png ...  movie.gif

animate movie.gif  # or display movie.gif

# easy:
'-m %g' % m
# is replaced with
'-%s %s' % (str(prm_name), str(prm_value))
# prm_value plays the role of the m variable
# prm_name ('m', 'b', 'c', ...) is read as input

simviz1.py  : run simulation and visualization
simviz2.py  : additional option for yaxis scale

loop4simviz1.py : m loop calling simviz1.py
loop4simviz2.py : loop over any parameter in
                  simviz2.py and make movie

./loop4simviz2.py m 0.1 6.1 0.5 -yaxis -0.5 0.5 -noscreenplot

./loop4simviz2.py c 5 30 2 -yaxis -0.7 0.7 -b 0.5 \
                  -func siny -noscreenplot

./loop4simviz2.py b 0 2 0.25 -yaxis -0.5 0.5 -A 4

tmp_c.gif          # animated GIF (movie)
animate tmp_c.gif

tmp_c_runs.html    # browsable HTML document
tmp_c_runs.ps      # all plots in a ps-file

tmp_m_2.1   tmp_b_0   tmp_c_29

./loop4simviz2_2html.py m 0.1 6.1 0.5 -yaxis -0.5 0.5 -noscreenplot
ls -d tmp_*
mozilla tmp_m_summary.html

some comment line
1.5
  measurements  model1 model2
     0.0         0.1    1.0
     0.1         0.1    0.188
     0.2         0.2    0.25

0    0.1
1.5  0.1
3    0.2

infilename = sys.argv[1]
ifile = open(infilename, 'r') # open for reading
line = ifile.readline()

dt = float(ifile.readline())

ynames = ifile.readline().split()

outfiles = []
for name in ynames:
    outfiles.append(open(name + '.dat', 'w'))

t = 0.0    # t value
# read the rest of the file line by line:
while 1:
    line = ifile.readline()
    if not line: break

    yvalues = line.split()

    # skip blank lines:
    if len(yvalues) == 0: continue  

    for i in range(len(outfiles)):
        outfiles[i].write('%12g %12.5e\n' % \
                          (t, float(yvalues[i])))
    t += dt

for file in outfiles:  
    file.close()

prm['damping'] = 0.2             # number

def x3(x): 
    return x*x*x
prm['stiffness'] = x3            # function object

prm['model1'] = [1.2, 1.5, 0.1]  # list object

y = {}           # declare empty dictionary
# ynames: names of y curves
for name in ynames:
    y[name] = [] # for each key, make empty list

lines = ifile.readlines()  # list of all lines
...
for line in lines[3:]:
    yvalues = [float(x) for x in line.split()]
    i = 0  # counter for yvalues
    for name in ynames:
        y[name].append(yvalues[i]); i += 1

yvalues = [float(x) for x in line.split()]

# same as
numbers = line.split()
yvalues = []
for s in numbers:
    yvalues.append(float(s))

some comment line
1.5
  measurements  model1 model2
     0.0         0.1    1.0
     0.1         0.1    0.188
     0.2         0.2    0.25

'measurements': [0.0, 0.1, 0.2], 
'model1':       [0.1, 0.1, 0.2], 
'model2':       [1.0, 0.188, 0.25]

y, dt = load_data('somedatafile.dat')
print y

>>> y
{'tmp-model2': [1.0, 0.188, 0.25], 
'tmp-model1': [0.10000000000000001, 0.10000000000000001, 
               0.20000000000000001], 
'tmp-measurements': [0.0, 0.10000000000000001, 0.20000000000000001]}

for i in range(len(list)):
    e1 = list1[i];  e2 = list2[i]
    # work with e1 and e2

for e1, e2 in zip(list1, list2):
    # work with element e1 from list1 and e2 from list2

for name, value in zip(ynames, yvalues):
    y[name].append(value)

from convert3 import load_data, dump_data

y, timestep = load_data('.convert_infile1')

from math import fabs
for name in y:  # run through keys in y
    maxabsy = max([fabs(yval) for yval in y[name]])
    print 'max abs(y[%s](t)) = %g' % (name, maxabsy)

dump_data(y, timestep)

if __name__ == '__main__':
    import sys
    try:     
        infilename = sys.argv[1]
    except:  
        usage = 'Usage: %s infile' % sys.argv[0]
        print usage; sys.exit(1)
    y, dt = load_data(infilename)
    dump_data(y, dt)

unix> ./convert3.py someinputfile.dat

import convert3
y, dt = convert3.load_data('someinputfile.dat')
# do more with y?
dump_data(y, dt)

s = myjoin(['s1', 's2', 's3'], '*')
# s becomes 's1*s2*s3'

function myjoin(list, delimiter)
  joined = first element in list
  for element in rest of list:
    concatenate joined, delimiter and element
  return joined

"""
unix> python hw.py 3.1459
Hello, World! sin(3.1459)=-0.00430733309102
"""

unix> a2ps --line-numbers=1 -4 -o outputfile.ps *.py

>>> t = 0.1
>>> def f(x):
...     return math.sin(x)
...
>>> f(t)
0.099833416646828155
>>> os.path.splitext('/some/long/path/myfile.dat')
('/some/long/path/myfile', '.dat')

>>> help(os.path.splitext)

# #if defined('DEBUG') and DEBUG >= 2
# write out debug info at level 2:
...
# #elif DEBUG == 0
# write out minimal debug info:
...
# #else
# no debug output
# #endif

#  #include "myfile.py"

# #ifdef MyDEBUG
....debug code....
# #endif

# #define MyDEBUG

# #define MyDEBUG 2

preprocess -DMyDEBUG=2 myscript.p.py > myscript.py

cmd = 'myprog -c file.1 -p -f -q > res'
failure = os.system(cmd)
if failure:
  print '%s: running myprog failed' % sys.argv[0]
  sys.exit(1)

pipe = os.popen(cmd)
output = pipe.readlines()
pipe.close()

for line in output:
  # process line

import commands
failure, output = commands.getstatusoutput(cmd)

if failure:
    print 'Could not run', cmd; sys.exit(1)

for line in output.splitlines()  # or output.split('\n'):
    # process line

gnuplot = os.popen('gnuplot -persist', 'w')
gnuplot.write("""
set xrange [0:10]; set yrange [-2:2]
plot sin(x)
quit
""")
gnuplot.close()  # gnuplot is now run with the written input

gnuplot <<EOF
set xrange [0:10]; set yrange [-2:2]
plot sin(x)
quit
EOF

# copy files to remote host via scp and password dialog
cmd = 'scp %s %s@%s:%s' % (filename, user, host, directory)
import pexpect
child = pexpect.spawn(cmd)
child.expect('password:')
child.sendline('&%$hQxz?+MbH')
child.expect(pexpect.EOF)  # important; wait for end of scp session
child.close()

src/py/examples/simviz/simviz1_ssh_pexpect.py

infilename = '.myprog.cpp'
infile = open(infilename, 'r')  # open file for reading 

# load file into a list of lines:
lines = infile.readlines()    

# load file into a string:
filestr = infile.read()

while 1:
    line = infile.readline()
    if not line: break
    # process line

outfilename = '.myprog2.cpp'
outfile = open(outfilename, 'w')
outfile.write('some string\n')

outfile = open(outfilename, 'a')
outfile.write('....')

b =  1.2       # b is a number
b = '1.2'      # b is a string
a = 0.5 * b    # illegal: b is NOT converted to float
a = 0.5 * float(b)   # this works

==   !=  <  >  <=  >=

b = '1.2'

if b < 100:    print b, '< 100'
else:          print b, '>= 100'

if float(b) < 100:   # floating-point number comparison
# or
if b < str(100):     # string comparison

a = '';  a = [];  a = ();  a = {};  # empty structures
a = 0;   a = 0.0
if a:       # false
if not a:   # true

arglist = [myarg1, 'displacement', "tmp.ps"]

arglist[0] = myarg1
arglist[1] = 'displacement'

n = 100
mylist = [0.0]*n

arglist = []  # start with empty list
arglist.append(myarg1)
arglist.append('displacement')

 filename, plottitle, psfile  = arglist
(filename, plottitle, psfile) = arglist
[filename, plottitle, psfile] = arglist

filename = arglist[0]
plottitle = arglist[1]

for entry in arglist:
    print 'entry is', entry

start = 0;  stop = len(arglist);  step = 1
for index in range(start, stop, step):
    print 'arglist[%d]=%s' % (index,arglist[index])

mylist.reverse()  # reverse order
for item in mylist:
    # do something...

y = [ float(yi) for yi in line.split() ]  # call function float
x = [ a+i*h for i in range(n+1) ]         # execute expression

y = []
for yi in line.split():
    y.append(float(yi))

y = map(float, line.split())
y = map(lambda i: a+i*h, range(n+1))

>>> mylist = ['t2.ps', 1.45, ['t2.gif', 't2.png'],\
          { 'factor' : 1.0, 'c' : 0.9} ]
>>> mylist[3]
{'c': 0.90000000000000002, 'factor': 1.0}
>>> mylist[3]['factor']
1.0
>>> print mylist
['t2.ps', 1.45, ['t2.gif', 't2.png'], 
 {'c': 0.90000000000000002, 'factor': 1.0}]

mylist.sort()

>>> print mylist
[1.4, 8.2, 77, 10]
>>> mylist.sort()
>>> print mylist
[1.4, 8.2, 10, 77]

>>> s1=[1.2, 1.3, 1.4]   # list
>>> s2=(1.2, 1.3, 1.4)   # tuple
>>> s2=1.2, 1.3, 1.4     # may skip parenthesis
>>> s1[1]=0              # ok
>>> s2[1]=0              # illegal
Traceback (innermost last):
  File "<pyshell#17>", line 1, in ?
    s2[1]=0
TypeError: object doesn't support item assignment

>>> s2.sort()
AttributeError: 'tuple' object has no attribute 'sort'

d['mass']           # extract item corresp. to key 'mass'
d.keys()            # return copy of list of keys
d.get('mass',1.0)   # return 1.0 if 'mass' is not a key
d.has_key('mass')   # does d have a key 'mass'?
d.items()           # return list of (key,value) tuples
del d['mass']       # delete an item
len(d)              # the number of items

d = { 'key1' : value1, 'key2' : value2 }

d['key1'] = anothervalue1
d['key2'] = anothervalue2
d['key3'] = value2

movies[1]       = 'heatsim1.mpeg'
movies[0.1]     = 'heatsim2.mpeg'
movies[0.001]   = 'heatsim5.mpeg'
movies[0.00001] = 'heatsim8.mpeg'

g77 = {
  'name'          : 'g77',
  'description'   : 'GNU f77 compiler, v2.95.4',
  'compile_flags' : ' -pg',
  'link_flags'    : ' -pg',
  'libs'          : '-lf2c',
  'opt'           : '-O3 -ffast-math -funroll-loops'
}

arg_counter = 1
while arg_counter < len(sys.argv):
    option = sys.argv[arg_counter]    
    option = option[2:]  # remove double hyphen
    if option in cmlargs: 
	# next command-line argument is the value:
        arg_counter += 1
	value = sys.argv[arg_counter] 
        cmlargs[cmlarg] = value
    else:
        # illegal option
    arg_counter += 1

f = open(cmlargs['case'] + '.', 'w')
f.write(cmlargs['m']     + '\n')
f.write(cmlargs['b']     + '\n')
f.write(cmlargs['c']     + '\n')
f.write(cmlargs['func']  + '\n')
...
# make gnuplot script:
f = open(cmlargs['case'] + '.gnuplot', 'w')
f.write("""
set title '%s: m=%s b=%s c=%s f(y)=%s A=%s w=%s y0=%s dt=%s';
""" % (cmlargs['case'],cmlargs['m'],cmlargs['b'],
       cmlargs['c'],cmlargs['func'],cmlargs['A'],
       cmlargs['w'],cmlargs['y0'],cmlargs['dt']))
if not cmlargs['noscreenplot']:
    f.write("plot 'sim.dat' title 'y(t)' with lines;\n")

os.environ['PATH']
os.environ['HOME']
os.environ['scripting']

sorted_env = os.environ.keys()
sorted_env.sort()

for key in sorted_env:
    print '%s = %s' % (key, os.environ[key])

program = 'vtk'
path = os.environ['PATH']  
# PATH can be /usr/bin:/usr/local/bin:/usr/X11/bin
# os.pathsep is the separator in PATH 
# (: on Unix, ; on Windows) 
paths = path.split(os.pathsep)
for d in paths:
    if os.path.isdir(d):
        if os.path.isfile(os.path.join(d, program)):
             program_path = d; break

try:  # program was found if program_path is defined
    print '%s found in %s' % (program, program_path)
except:      
    print '%s not found' % program

if sys.platform[:3] == 'win':
    # Windows-specific actions

for d in paths:
    if os.path.isdir(d):
        fullpath = os.path.join(dir, program)
        if sys.platform[:3] == 'win':   # windows machine?
            for ext in '.exe', '.bat':  # add extensions
                if os.path.isfile(fullpath + ext):
                    program_path = d; break
        else:
            if os.path.isfile(fullpath):
                program_path = d; break

>>> files = 'case1.ps case2.ps    case3.ps'
>>> files.split()
['case1.ps', 'case2.ps', 'case3.ps']

>>> files = 'case1.ps, case2.ps, case3.ps'
>>> files.split(', ')
['case1.ps', 'case2.ps', 'case3.ps']
>>> files.split(',  ')  # extra erroneous space after comma...
['case1.ps, case2.ps, case3.ps']  # unsuccessful split

1.432 5E-09
1.0

3.2 5 69 -111
4 7 8

f = open(filename, 'r')
numbers = f.read().split()

numbers = [ float(x) for x in f.read().split() ]

>>> line1 = 'iteration 12:    eps= 1.245E-05'
>>> line1.split()
['iteration', '12:', 'eps=', '1.245E-05']
>>> w = line1.split()
>>> ' '.join(w)  # join w elements with delimiter ' '
'iteration 12: eps= 1.245E-05'

>>> '@@@'.join(w)
'iteration@@@12:@@@eps=@@@1.245E-05'

if line == 'double':
   # line equals 'double'

if line.find('double') != -1:
   # line contains 'double'

import fnmatch
if fnmatch.fnmatch(line, 'double'):
   # line contains 'double'

double*   [Dd]ouble

import re
if re.search(r'double', line): 
    # line contains 'double'

double[A-Za-z0-9_]*  [Dd]ouble  (DOUBLE|double)

newstring = oldstring.replace(substring, newsubstring)

import re
str = re.sub(pattern, replacement, str)

s1 = 'with forward quotes'
s2 = "with double quotes"
s3 = 'with single quotes and a variable: %(r1)g' \
     % vars()
s4 = """as a triple double (or single) quoted string"""
s5 = """triple double (or single) quoted strings
allow multi-line text (i.e., newline is preserved)
with other quotes like ' and  "
"""

s6 = r'raw strings start with r and \ remains backslash'
s7 = r"""another raw string with a double backslash: \\ """

myfile = filename + '_tmp' + '.dat'

>>> teststr = '0123456789'
>>> teststr[0:5]; teststr[:5]
'01234'
'01234'
>>> teststr[3:8]
'34567'
>>> teststr[3:]
'3456789'

>>> s2=(1.2, 1.3, 1.4)   # tuple
>>> s2[1]=0              # illegal

class MyBase:

    def __init__(self,i,j):  # constructor
        self.i = i; self.j = j

    def write(self):         # member function
        print 'MyBase: i=',self.i,'j=',self.j

obj1 = MyBase(6,9); obj1.write()

class MySub(MyBase):

    def __init__(self,i,j,k):  # constructor
        MyBase.__init__(self,i,j)
        self.k = k;
 
   def write(self):
        print 'MySub: i=',self.i,'j=',self.j,'k=',self.k

# this function works with any object that has a write func:
def write(v): v.write()

# make a MySub instance
i = MySub(7,8,9)

write(i)   # will call MySub's write

def function_name(arg1, arg2, arg3):
    # statements
    return something

def debug(comment, variable):
    if os.environ.get('PYDEBUG', '0') == '1':
        print comment, variable
...
v1 = file.readlines()[3:]
debug('file %s (exclusive header):' % file.name, v1)

v2 = somefunc()
debug('result of calling somefunc:', v2)

def mkdir(dirname, mode=0777, remove=1, chdir=1):
    if os.path.isdir(dirname):
        if remove:  shutil.rmtree(dirname)
        elif :      return 0  # did not make a new directory
    os.mkdir(dir, mode)
    if chdir: os.chdir(dirname)
    return 1      # made a new directory

mkdir('tmp1')
mkdir('tmp1', remove=0, mode=0755)
mkdir('tmp1', 0755, 0, 1)             # less readable

def somefunc(a, b, *rest):
    for arg in rest:
        # treat the rest...

# call:
somefunc(1.2, 9, 'one text', 'another text')
#                ...........rest...........

def somefunc(a, b, *rest, **kw):
    #...
    for arg in rest:
        # work with arg...
    for key in kw.keys():
        # work kw[key]

def statistics(*args):
    avg = 0;  n = 0;   # local variables
    for number in args:  # sum up all the numbers
        n = n + 1; avg = avg + number
    avg = avg / float(n) # float() to ensure non-integer division

    min = args[0]; max = args[0]
    for term in args:
        if term < min: min = term
        if term > max: max = term
    return avg, min, max  # return tuple

average, vmin, vmax = statistics(v1, v2, v3, b)

def statistics(*args):
    return (reduce(operator.add, args)/float(len(args)), 
            min(args), max(args))

>>> def swap(a, b):
        tmp = b; b = a; a = tmp;
    
>>> a=1.2; b=1.3; swap(a, b)
>>> print a, b    # has a and b been swapped?
(1.2, 1.3)  # no...

>>> def swap(a, b):
    return (b,a)   # return tuple

# or smarter, just say  (b,a) = (a,b)  or simply  b,a = a,b

>>> def somefunc(mutable, item, item_value):
	mutable[item] = item_value
	
>>> a = ['a','b','c']  # a list
>>> somefunc(a, 1, 'surprise')
>>> print a
['a', 'surprise', 'c']

def myfunc(i1, i2, i3, i4=False, io1=0):
    # io1: input and output variable
    ...
    # pack all output variables in a tuple:
    return io1, o1, o2, o3

# usage:
a, b, c, d = myfunc(e, f, g, h, a)

s = 1

def myfunc(x, y):
    z = 0  # local variable, dies when we leave the func.
    global s
    s = 2  # assignment requires decl. as global
    return y-1,z+1

ls *.ps *.gif

import glob
filelist = glob.glob('*.ps') + glob.glob('*.gif')

import shutil
shutil.copy(myfile, tmpfile)

os.rename(myfile, 'tmp.1')

os.remove('mydata')
# or os.unlink('mydata')

filename = os.path.join(os.pardir, 'src', 'lib')

# Unix:    ../src/lib
# Windows: ..\src\lib

shutil.copy(filename, os.curdir)

# Unix:  cp ../src/lib .

# os.pardir : ..
# os.curdir : .