View source

{{notes}}

<center>
[[image:python.png|200px]]
</center> 

[[Python clips]] 

== yield generators and iterators == 

<source lang = "python">
def f():
    i = 0 
    while i<10:
        yield i 
        i += 1
    raise StopIteration

for x in f():
    print x 

it = f()
while True:
    try:
        print it.next()
    except:
        print "done"
        break

</source>






== how to find the version == 
=== python version === 
 import sys
 print sys.version 

=== package version === 
 import sympy
 print sympy.version

== site packages path in ubuntu ==
  /usr/lib/python2.5/site-packages
or sometime (when I installed it through a self extracted file):
 /var/lib/python-support/python2.5/

== Web programming == 

[http://wiki.python.org/moin/WebProgramming web programming entry point]

=== Client side programming ===
[http://code.activestate.com/recipes/52199/ Grab a document from the web]

<source lang="python">
import urllib 

doc = urllib.urlopen('http://www.orimosenzon.com').read()
print doc
</source>

=== Server side programming ===

== forward function declaration == 
when is it needed? 
It seems like the function need to be encounter by the parser before it is being called but not necessarily before code-wise

<source lang="python">
# foo2() # NameError: name 'foo2' is not defined 
def foo1():
    print "foo1()"
    foo2() # fine! 

def foo2():
    print "foo2()"
foo1()
</source>

== help == 
 help(''.capitalize)

== find out all the methods of a type == 
 >>> dir('ori')

== lists ==
[http://effbot.org/zone/python-list.htm]
is a list empty? 
<pre>
if not aList:
   ...
</pre> 

=== list indexing ===
sublist:
<pre>
>>> a = [11,22,33,44,55,66,77]
>>> a[2:5]
[33, 44, 55]
>>> a[1:7:2]  # [from, )too, step
[22, 44, 66]
</pre>
=== clonning ===
shallow copy: 
<pre>
>>> a = [11,22,33]
>>> b = a 
>>> b.remove(22)
>>> b
[11, 33]
>>> a
[11, 33]
</pre> 
 
real clonning 
<pre>
>>> a = [11,22,33]
>>> b = a[0:len(a)]
>>> b.remove(22)
>>> b
[11, 33]
>>> a
[11, 22, 33]
</pre>

=== deleting an element from a list === 
the parameter to remove is the '''value''' to be removed:  
<pre>
>>> a = [11,22,33]
>>> a.remove(22)
>>> a
[11, 33]
</pre>

== combine with C ==
[http://www.python.org/doc/2.5.2/ext/intro.html]

== function documentation == 
<source lang="python">
"global documentation"

def foo():
    "foo documentation"

def foo1():
    """This is the documentation of foo1() ..
Using a mutiline string  
"""

print __doc__ 

print foo.__doc__

print foo1.__doc__


</source>

== global and local scopes == 
Local variable shade the global one while in function: 
<pre> 
a = 'out' 

def foo():
    a = 'in' 
    print a

foo()
print a

#in 
#out 
</pre> 

global makes the local variable a refernce to the global variable:   
<pre>
a = 'out' 

def foo():
    global a 
    a = 'in' 
    print a

foo()
print a

#in 
#in 
</pre> 

Unlike c, a scope is not a local variable environment: 
<pre>
a = 'out' 

if True:
    a = 'in' 
    print a

print a

# in 
# in 
</pre>

== exception handling == 
<pre>
try:
    #'dd'+4
    a = 7/0
    print a
except ZeroDivisionError:
    print "wow.. devision by zero occured.."
except:
    print "something happened" 
    raise 
</pre>

== breaking code lines ==
<pre>
print \
      "hi,    how's stuff?"
</pre>

<pre>
print "hi,   \
how's stuff?"
</pre>
(note that in this case it seems very important to have EOL immediately after the \ )

== multiline string ==
<pre>
print """ hi,
I hope you cope,
take care
"""
</pre>

== stdout and stderr == 
<pre>
import sys
sys.stdout.write('this goes to stdout')  
sys.stderr.write('this goes to stderr')  
</pre> 

 ./check.py > tmp.out 
 ./check.py 2> tmp.out 
 ./check.py &> tmp.out

== cygwin python == 
Note that if the %path% variable contain the cygwin/bin before the python, the python is run in a special cygwin mode the effects pathes (for example <code>sys.prefix</code>)

== two command in same line == 
Just separate them with a ; 
 print "hi"; print "bye"

== Command line execution == 
 python -c "..." 
For example 
 python -c "from os.path import join; import sys; sys.path = [ join(sys.prefix, 'Lib', 'site-packages', 'scons-0.97'), join(sys.prefix, 'Lib', 'site-packages', 'scons'), join(sys.prefix, 'scons-0.97'), join(sys.prefix, 'scons')] + sys.path; print sys.path"

== type ==
<pre>
>>> c = (1,2)
>>> type(c)
<type 'tuple'>
>>> type(a)
<type 'numpy.ndarray'>
>>> type(b)
<type 'list'>
>>> c = ([1],[2])
>>> type(c)
<type 'tuple'>
>>> c[1]
[2]
>>> type(c[0])
<type 'list'>
</pre>

== NumPy ==
<pre>
from numpy import *
 
>>> vector1 = array((1,2,3,4,5))

>>> print vector1

[1 2 3 4 5]

>>> matrix1 = array(([0,1],[1,3]))

>>> print matrix1

[[0 1]

[1 3]]

>>> print vector1.shape, matrix1.shape

(5,) (2,2)

>>> print vector1 + vector1

[ 2 4 6 8 10]]

>>> print matrix1 * matrix1

[[0 1] # note that this is not the matrix

[1 9]] # multiplication of linear algebra

matrix multiplication

>>> c1 = matrix(([0,1],[1,0]))
>>> c1
matrix([[0, 1],
        [1, 0]])
>>> c1 * c1
matrix([[1, 0],
        [0, 1]])
>>>
>>> matrix("1 2;3 4")
matrix([[1, 2],
        [3, 4]])


>>> zeros((2,2))
array([[ 0.,  0.],
       [ 0.,  0.]])
>>> ones((2,2))
array([[ 1.,  1.],
       [ 1.,  1.]])
>>> help(numpy) 

>>> identity(3)
array([[ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.]])
>>> m = identity(2)
>>> m[0,0], m[0,1], m[1,0], m[1,1]
(1.0, 0.0, 0.0, 1.0)
</pre>


Numpy contains both an array class and a matrix class. The array class is intended to be a general-purpose n-dimensional array for many kinds of numerical computing, while matrix is intended to facilitate linear algebra computations specifically. In practice there are only a handful of key differences between the two.

=== Operator *, dot(), and multiply() === 
For array, '*' means element-wise multiplication, and the dot() function is used for matrix multiplication.

For matrix, '*' means matrix multiplication, and the multiply() function is used for element-wise multiplication. 

=== Handling of vectors (rank-1 arrays) === 
For array, the vector shapes 1xN, Nx1, and N are all different things. Operations like A[:,1] return a rank-1 array of shape N, not a rank-2 of shape Nx1. Transpose on a rank-1 array does nothing.

* For matrix, rank-1 arrays are always upconverted to 1xN or Nx1 matrices (row or column vectors). A[:,1] returns a rank-2 matrix of shape Nx1. 
    
* Handling of higher-rank arrays (rank > 2)
array objects can have rank > 2.
matrix objects always have exactly rank 2. 
    
=== Convenience attributes === 
array has a .T attribute, which returns the transpose of the data.
matrix also has .H, .I, and .A attributes, which return the conjugate transpose, inverse, and asarray() of the matrix, respectively. 

=== Convenience constructor === 
* The array constructor takes (nested) Python sequences as initializers. As in, array([[1,2,3],[4,5,6]]).

* The matrix constructor additionally takes a convenient string initializer. As in matrix("[1 2 3; 4 5 6]"). 

There are pros and cons to using both:

=== array Pros and Cons===
* :) You can treat rank-1 arrays as either row or column vectors. dot(A,v) treats v as a column vector, while dot(v,A) treats v as a row vector. This can save you having to type a lot of transposes.

* <:( Having to use the dot() function for matrix-multiply is messy -- dot(dot(A,B),C) vs. A*B*C.

* :) Element-wise multiplication is easy: A*B.

* :) array is the "default" NumPy type, so it gets the most testing, and is the type most likely to be returned by 3rd party code that uses NumPy.

* :) Is quite at home handling data of any rank.

* :) Closer in semantics to tensor algebra, if you are familiar with that.

* :) All operations (*, /, +, ** etc.) are elementwise 

=== matrix Pros and Cons ===
* :\ Behavior is more like that of MATLAB® matrices.

* <:( Maximum of rank-2. To hold rank-3 data you need array or perhaps a Python list of matrix.

* <:( Minimum of rank-2. You cannot have vectors. They must be cast as single-column or single-row matrices.

* <:( Since array is the default in NumPy, some functions may return an array even if you give them a matrix as an argument. This shouldn't happen with NumPy functions (if it does it's a bug), but 3rd party code based on NumPy may not honor type preservation like NumPy does.

* :) A*B is matrix multiplication, so more convenient for linear algebra.

* <:( Element-wise multiplication requires calling a function, multipy(A,B).

* <:( The use of operator overloading is a bit illogical: * does not work elementwise but / does. 

=== Summary === 
There are solid arguments for both camps. It probably boils down mostly to how much actual matrix multiplication you do in your code, and how much you appreciate the error checking benefits of having a row vs column vector distinction. In the end, you don't really have to choose one or the other. You can mix-and-match. You can use array for the bulk of your code, and switch over to matrix in the sections where you have nitty-gritty linear algebra.

power: **

invert: m ** -1

=== polynomials ===
A one-dimensional polynomial class.

p = poly1d([1,2,3]) constructs the polynomial x**2 + 2 x + 3

p(0.5) evaluates the polynomial at the location

p.r  is a list of roots

p.c  is the coefficient array [1,2,3]

p.order is the polynomial order (after leading zeros in p.c are removed)

p[k] is the coefficient on the kth power of x (backwards from
     sequencing the coefficient array.

polynomials can be added, substracted, multplied and divided (returns
     quotient and remainder).

asarray(p) will also give the coefficient array, so polynomials can
     be used in all functions that accept arrays.

p = poly1d([1,2,3], variable='lambda') will use lambda in the

string representation of p.

== else in loop ==
<pre>
i=0
while i<7:
  if i>5: #try 8
    break
  i += 1
else:
  print "end due to completion"
</pre>

== string ==
find index of first ocurance
 s.find("*",1)

== classes ==
=== basic ===
<pre>

class A:
    _a = 0
    def foo(self):
        print "A.foo() invoked"
        self._a += 1
       
a = A()
b = A()
a.foo()
A.foo(a)

b._a = 17
print a._a,b._a
</pre>
=== member variable creation on demand ===
<pre>
class A:
    def createData(self):
        self.data = 17  # this command actually created this member variable 
    def printData(self):
        print self.data

a = A()
a.createData()
a.printData()
</pre>

=== polymorphism ===
<pre>
class A:
    "This is the documentation of A.."
    def foo(self):
        print "A.foo() invoked"

class B:
    "this is b.."
    def foo(self):
        print "B.foo() invoked"
   

def f(obj):
    obj.foo()

map(f,[A(),B()])   
</pre>

=== class iterator ===
<pre>
class A:
    "This is the documentation of A.."
    data = [1,2,3,4]
    def __iter__(self):
        return AIter(self)
   
class AIter:
    def __init__(self,obj):
        self.obj = obj
        self.i = 0
    def next(self):
        if self.i == len(self.obj.data):
            raise StopIteration
        else:
            ret = self.obj.data[self.i]
            self.i += 1
            return ret
       
# now..
for i in A():
    print i
</pre>

== functional programming ==
<pre>

def compose(f1,f2):
    return lambda x:f1(f2(x))
print compose(lambda x:x+1,lambda x:2*x)(3)
--
def mymap(f1,lst):
    for x in lst:
        f1(x)

def f(x):
    print x+1
mymap(f,[1,2,3])

---
print map(lambda x:x+1,[1,2,3])
</pre>

== import ==
<pre>
* import M
let you do M.foo()

from M import foo
let you do foo()

from M import *
 like using namespace...
</pre>

== Dictionary == 
python build in type to represent map (hash-table functionality) 
<pre>
myDict = {'ori':17, 'yosi':21, 'motke':107}
myDict['ori'] = 18 
print myDict['yosi']
myDict.keys()
myDict.values()
myDict.get('yosi')
myDict.get('yosi',-1) # gives 21
myDict.get('yosii',-1) # gives -1 (which is the default value) 
</pre>

== default values for parameters == 
<pre>
def f(a='a',b='b',c='c'):
    print a+' '+b+' '+c

f()       # a b c
f(b='b1') # a b1 c
</pre>
== formated string ==
 a = 'really, %s is nice' % 'yosi'

 
 'hello %s, how are %s?' % ('there','you')

(Is this the closet we get in Python to Perl's string interpulation?)

== file handling ==
<pre>
f=open('file.txt', 'r')
content = f.read()
print content
</pre> 

 
<pre>
import os

# os.chdir('/home')
files = os.listdir('/home')
for file in files:
    print file

# os.system('ls')
</pre>

== glob == 
<pre>
import glob

files = glob.glob('*.txt')
for f in files: 
    print f
</pre>

== file traversal == 
<pre>
import os

def traverse(path):
    files = os.listdir(path)
    for f in files:
        pathf = path+'/'+f
        if os.path.isdir(pathf):
            print '>>>>>'+f
            traverse(pathf)
            print '<<<<<'+f 
        else:
            print f

traverse('.')
</pre>
== __cmp__ and __str__ == 
<pre>
class A:
    # m_data
    def __init__(self,data):
        self.m_data = data
    def __str__(self):
        return '[A: '+str(self.m_data)+']'
    def _cmp__(self,other):
        return cmp(self.m_data,other.m_data)
        

a1 = A(17)
a2 = A(18)
print a1
print cmp(a1,a2)
</pre>

== input from console == 
<pre>
print 'please enter a number'
a = raw_input()
print 'you entered '+a  
</pre>

== random == 
<pre>
import random 
print random.randint(1,100)
</pre>

<pre>
import random 
num = random.randint(1,100)

while True:
    print "you're guess?"
    g = int(raw_input())
    if g == num:
        break
    if g < num:
        print "that's too small"
    else:
        print "that's too big"
        
print "the number is indeed "+str(num)
</pre>
== yield == 
<pre>
def foo():
    yield 1
    yield 7

for x in foo():
    print x
</pre>

== myFilter == 
<pre>
def myFilter(func,lst):
    ret = []
    for x in lst:
        if func(x):
            ret += [x]
    return ret

(func,lst) = (lambda x: x%3 == 0, range(1,20))

print myFilter(func,lst)

print filter(func,lst)
</pre>

== split == 
<pre>
str1 = 'this is a whole sentence bli blu bla'

words = str1.split() #str1.split('b')

for word in words:
    print word
 </pre>


== load in interactive mode == 
  execfile('check.py')


== Help == 
help() 
module, keyword.. 

== ls == 
os.listdir('.')
 
== system == 
system(...)
system(command) -> exit_status
Execute the command (a string) in a subshell.



== which platform? == 
 import sys 
 sys.platform

 import platform
 platform.platform()
 platform.system()

== args[] == 
<pre>
import sys 
print sys.argv[0] # program name 
print sys.argv[1] # first argument  
</pre>

== Installing help == 
# Download html documentation  [http://www.python.org/doc/2.5.2/download/] and extract to a directory (say /my/path/python_doc
# PYTHONDOCS=/my/path/python_doc; export PYTHONDOCS 
# Now, the help() command will enable you to enter keywords as well (as modules)

== misc == 
* pass - do nothing - just for syntax fillings.. 
<pre>
if True:
    pass 
#    a = 'hello there'
print 'hello'
</pre>