Here is a set of small scripts, which demonstrate some features of

Python programming.
# this is the first comment
#! python
# integer variables
SPAM = 1
#! python
print "Hello, Python"
#! python
# string variable
STRING = "# This is not a comment."
print STRING

#! python
# integer arith
a=4
print a
b=12+5
print b
c=b%a
print c
#! python
# trailing comma
i = 256*256
print 'The value of i is', i

#! python
# Fibonacci series:
# the sum of two elements defines the next
a, b = 0, 1
while b < 200:
print b,
a, b = b, a+b

#! python
# input and operator if
x = int(raw_input("Please enter an integer: "))
if x < 0:
x = 0
print 'Negative changed to zero'
elif x == 0:
print 'Zero'
elif x == 1:
print 'Single'
else:
print 'More'
#! python
# operator for:
# Measure some strings:
a = ['cat', 'window', 'defenestrate']
for x in a:
print x, len(x)

#! python
# range function
print range(10)
print range(5, 10)
print range(0, 10, 3)
a = ['Mary', 'had', 'a', 'little', 'lamb']
for i in range(len(a)):
print i, a[i]

#! python
# break operator
# prime numbers
for n in range(2, 1000):
for x in range(2, n):
if n % x == 0:
print n, 'equals', x, '*', n/x
break
else:
# loop fell through without finding a factor
print n, 'is a prime number'

#! python
#pass statement does nothing.
#It can be used when a statement is required syntactically but the program requi
res no action. For example:
while True:
pass # Busy-wait for keyboard interrupt

#! python
# Defining Functions
def fib(n):
# write Fibonacci series up to n
"""Print a Fibonacci series up to n."""
a, b = 0, 1
while b < n:
print b,
a, b = b, a+b
# Now call the function we just defined:
fib(2000)
! python
# function that returns a list of the numbers of the Fibonacci series
def fib2(n): # return Fibonacci series up to n
"""Return a list containing the Fibonacci series up to n."""
result = []
a, b = 0, 1
while b < n:
result.append(b)
# see below
a, b = b, a+b
return result
#===================================
f100 = fib2(100)
# call it
print f100
# write the result
#! python
# work with strings
# Strings can be concatenated (glued together) with the + operator, and repeated
with *:
word = 'Help' + 'A'
print word
print '<' + word*5 + '>'
# Two string literals next to each other are automatically concatenated;
# the first line above could also have been written "word = 'Help' 'A'";

# this only works with two literals, not with arbitrary string expressions:
st='str' 'ing'
print st
st='str'.strip() + 'ing'
print st

# <- This is ok
# <- This is ok

# Strings can be subscripted (indexed); like in C, the first character of a stri

ng
# has subscript (index) 0. There is no separate character type; a character is
# simply a string of size one. Like in Icon, substrings can be specified with
# the slice notation: two indices separated by a colon.
print word[4]
print word[0:2]
print word[2:4]
# Slice indices have useful defaults; an omitted first index defaults to zero,
# an omitted second index defaults to the size of the string being sliced.
print word[:2]
print word[2:]

# The first two characters

# All but the first two characters

# Python strings cannot be changed. Assigning to an indexed position in the stri

ng results in an error:
# However, creating a new string with the combined content is easy and efficient
:
print 'x' + word[1:]
print 'Splat' + word[4]
# Here's a useful invariant of slice operations: s[:i] + s[i:] equals s.
print word[:2] + word[2:]
print word[:3] + word[3:]
# Degenerate slice indices are handled gracefully: an index that is too large is
replaced
# by the string size, an upper bound smaller than the lower bound returns an emp
ty string.
print word[1:100]
print word[10:]
print word[2:1]
# Indices may be negative numbers, to start counting from the right. For example
:
print word[-1]

# The last character

print word[-2]

# The last-but-one character

print word[-2:]

# The last two characters

print word[:-2]

# All but the last two characters

# But note that -0 is really the same as 0, so it does not count from the right!
print word[-0]

# (since -0 equals 0)

# Out-of-range negative slice indices are truncated, but don't try this for sing
le-element (non-slice) indices:
print word[-100:]
# print word[-10]

# error

#The best way to remember how slices work is to think of the indices as pointing
between characters,
#with the left edge of the first character numbered 0. Then the right edge of th
e last character
#of a string of n characters has index n, for example:
# +---+---+---+---+---+
# | H | e | l | p | A |
# +---+---+---+---+---+
# 0 1 2 3 4 5
#-5 -4 -3 -2 -1
s = 'supercalifragilisticexpialidocious'
print s
print len(s)

#! python
# Default Argument Values
def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):
while True:
ok = raw_input(prompt)
if ok in ('y', 'ye', 'yes'): return True
if ok in ('n', 'no', 'nop', 'nope'): return False
retries = retries - 1
if retries < 0: raise IOError, 'refusenik user'
print complaint
#==============================================================
i = 5
def f(arg=i):
print arg
i = 6
f()
#==============================================================

z=ask_ok('really quit???')
if z==False :
print "bad"

#! python
# Lambda Forms
def make_incrementor(n):
return lambda x: x + n
#==================================
f = make_incrementor(42)
print f(0)
print f(1)
print f(15)
//==============================================================================
=====
//
//==============================================================================
=====
#! python
# speed test
nn=10000000
i=0;
s=0;
print "beginning..."
while i
#! python
# raw input of strings only!
st = raw_input("")
print st
st=st*3 # triple the string
print st

#! python
# math
import math
print math.cos(math.pi / 4.0)
print math.log(1024, 2)

#! python
# random
import random
print random.choice(['apple', 'pear', 'banana'])
print random.sample(xrange(100), 10)
print random.random()

# sampling without replacement

print random.randrange(6)

# random float
# random integer chosen from range(6)

#! python
def perm(l):
# Compute the list of all permutations of l
if len(l) <= 1:
return [l]
r = [] # here is new list with all permutations!
for i in range(len(l)):
s = l[:i] + l[i+1:]
p = perm(s)
for x in p:
r.append(l[i:i+1] + x)
return r
#==============================================
a=[1,2,3]
print perm(a)
#! python
a=2+3j
b=2-3j
print a*a
print a*b
print a.real
print b.imag
#! python
while True:
try:
x = int(raw_input("Please enter a number: "))
break
except ValueError:
print "Oops! That was no valid number. Try again..."
#! python

import string, sys

try:
f = open('myfile.txt')
s = f.readline()
i = int(string.strip(s))
except IOError, (errno, strerror):
print "I/O error(%s): %s" % (errno, strerror)
except ValueError:
print "Could not convert data to an integer."
except:
print "Unexpected error:", sys.exc_info()[0]
raise
#! python
# work with lists
a = ['spam', 'eggs', 100, 1234]
print " list a=",a
# list indices start at 0,
print 'a[0]=', a[0]
print 'a[3]=', a[3]
print 'a[-2]=', a[-2]
# lists can be sliced, concatenated and so on:
print "a[1:-1]=", a[1:-1]
print a[:2] + ['bacon', 2*2]
print 3*a[:3] + ['Boe!']
# possible to change individual elements of a list:
a[2] = a[2] + 23
print "changing a[2]=", a
#Assignment to slices is also possible, and this can even change the size of the
list:
# Replace some items:
a[0:2] = [1, 12]
print a
# Remove some:
a[0:2] = []
print a
# Insert some:
a[1:1] = ['bletch', 'xyzzy']
print a
a[:0] = a
print a

# Insert (a copy of) itself at the beginning

print "length=", len(a)

# possible to nest lists (create lists containing other lists)

q = [2, 3]
p = [1, q, 4]
print " nest list=", p
print 'length =', len(p)
print p[1]
print p[1][0]
p[1].append('xtra')
print p
print q

#! python
# more work with lists
a = [66.6, 333, 333, 1, 1234.5]
print a.count(333), a.count(66.6), a.count('x')
a.insert(2, -1)
print a
a.append(333)
print a
print a.index(333)
a.remove(333)
print a
a.reverse()
print a
a.sort()
print a

#! python
# huge list making
nn=1000000
a = []
i=0
while i
#! python
# Using Lists as Stacks
stack = [3, 4, 5]

stack.append(6)
stack.append(7)
print stack
x=stack.pop()
print "popped ",x
print stack
x=stack.pop()
print "popped ",x
x=stack.pop()
print "popped ",x
print stack
#! python
# Using Lists as Queues
queue = ["Eric", "John", "Michael"]
queue.append("Terry")
# Terry arrives
queue.append("Graham")
# Graham arrives
print queue
s=queue.pop(0)
print s
s=queue.pop(0)
print s
print queue

#! python
# The del statement
a = [-1, 1, 66.6, 333, 333, 1234.5]
del a[0]
print a
del a[2:4]
print a

#! python
# filter of sequence
def f(x): return x % 2 != 0 and x % 3 != 0
res=filter(f, range(2, 25))
print res
#! python

# map of sequence
def cube(x): return x*x*x
res=map(cube, range(1, 11))
print res
#! python
# reduce(func, sequence)" returns a single value constructed by
# calling the binary function func on the first two items of the sequence,
# then on the result and the next item, and so on
def add(x,y): return x+y
r=reduce(add, range(1, 11))
print r # 55

#! python
# A tuple consists of a number of values separated by commas
t = 12345, 54321, 'hello!' # tuple packing
print t[0]
print t
(12345, 54321, 'hello!')
# Tuples may be nested:
u = t, (1, 2, 3, 4, 5)
print u
# ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

#! python
# Dictionaries are sometimes as ``associative memories'' or ``associative arrays
''
tel = {'jack': 4098, 'sape': 4139}
tel['guido'] = 4127
print tel
print tel['jack']
del tel['sape']
tel['irv'] = 4127
print tel
print tel.keys()
x=tel.has_key('guido')
print x
# The dict() constructor builds dictionaries directly from lists

# of key-value pairs stored as tuples. When the pairs form a pattern,

# list comprehensions can compactly specify the key-value list.
d=dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
print d
vec=[1,2,3,4,5]
dd=dict([(x, x**2) for x in vec])
print dd

# use a list comprehension

#! python
# Standard Module sys
import sys
print sys.path
sys.path.append('c:\temp')
print sys.path
print sys.version
print sys.platform
print sys.maxint

#! python
#=======================================================
# dir() is used to find out which names a module defines
import sys
print dir(sys)
# Without arguments, dir() lists the names you have defined currently
#! python
# convert any value to a string: pass it to the repr() or str()
s = 'Hello, world.'
print str(s)
print repr(s)
print str(0.1)
print repr(0.1)
x = 10 * 3.25
y = 200 * 200
s = 'The value of x is ' + repr(x) + ', and y is ' + repr(y) + '...'
print s
# The repr() of a string adds string quotes and backslashes:

hello = 'hello, world\n'

hellos = repr(hello)
print hellos # 'hello, world\n'
# The argument to repr() may be any Python object:
print repr((x, y, ('spam', 'eggs')))
# reverse quotes are convenient in interactive sessions:
print `x, y, ('spam', 'eggs')`

#! python
# two ways to write a table of squares and cubes:
for x in range(1, 11):
print repr(x).rjust(2), repr(x*x).rjust(3),
# Note trailing comma on previous line
print repr(x*x*x).rjust(4)
print '================================================='
for x in range(1,11):
print '%2d %3d %4d' % (x, x*x, x*x*x)

#! python
# output results from running "python demo.py one two three"
# at the command line:
import sys
print sys.argv[] # ['demo.py', 'one', 'two', 'three']

#! python
# String Pattern Matching - regular expression
import re
r=re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest')
print r # ['foot', 'fell', 'fastest']
s=re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat')
print s # 'cat in the hat'

#! python
# dates are easily constructed and formatted
from datetime import date

now = date.today()
print now
datetime.date(2003, 12, 2)
print now.strftime("%m-%d-%y or %d%b %Y is a %A on the %d day of %B")
# dates support calendar arithmetic
birthday = date(1964, 7, 31)
age = now - birthday
print age.days # 14368

#! python
# Internet Access
import urllib2
for line in urllib2.urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl'):
if 'EST' in line:
# look for Eastern Standard Time
print line
import smtplib
server = smtplib.SMTP('localhost')
server.sendmail('soothsayer@tmp.org', 'jceasar@tmp.org',
"""To: jceasar@tmp.org
From: soothsayer@tmp.org
Beware the Ides of March.
""")
server.quit()
# work with files
#open file for write
f=open('c:/TEMP/workpy.txt','w')
print f
f.write("aaaaaaaaaaaaaaaaaaa\n")
f.write("bbbbbbbbbbbbbb");

# work with files

#open file for read
f=open('c:/TEMP/workpy.txt','r')
# line reading

s=f.readline()
print s
f.close()

# work with files

#open file for read
f=open('c:/TEMP/workpy.txt','r')
# pieces reading
s1=f.read(5)
print s1
s2=f.read(19)
print s2
s2=f.read(25)
print s2
f.close()

# work with files

#open file for read
f=open('c:/TEMP/workpy.txt','r')
# pieces reading
s1=f.read(5)
print s1
print f.tell()
s2=f.read(19)
print s2
print f.tell()
s2=f.read(25)
print s2
print f.tell()
f.close()
# work with files
# seek
f=open('c:/TEMP/workpy.txt','r+')
f.write('0123456789abcdef')
f.seek(5)
# Go to the 6th byte in the file

print f.read(1)
f.seek(-3, 2) # Go to the 3rd byte before the end
print f.read(1)

#! python
# The glob module provides a function for making file lists from
# directory wildcard searches:
import glob
s=glob.glob('*.*')
print s # ['primes.py', 'random.py', 'quote.py']