Basic Python

This lesson includes the basic Python language. No modules have to be imported

Built-in keywords

Python built-in keywords

help> keywords

and                 else                import              raise
assert              except              in                  return
break               exec                is                  try
class               finally             lambda              while
continue            for                 not                 yield
def                 from                or
del                 global              pass
elif                if                  print

Built-in types

Python built-in numeric types

There are four distinct numeric types:

• plain integers int

• long integers long

• floating point numbers float

• complex numbers complex

In addition, Booleans are a subtype of plain integers

Boolean

Boolean (logical) types

• True
• False

Operations

x + y           sum of x and y
x - y           difference of x and y   
x * y           product of x and y      
x / y           quotient of x and y
x // y          (floored) quotient of x and y
x % y           remainder of x / y
-x              x negated       
+x              x unchanged     
abs(x)          absolute value or magnitude of x        
int(x)          x converted to integer
long(x)         x converted to long integer 
float(x)        x converted to floating point   
complex(re,im)  a complex number with real part re, 
                imaginary part im. im defaults to zero
c.conjugate()   conjugate of the complex number c
x ** y          x to the power y

Boolean Operations: and, or, not

x or y          if x is false, then y, else x 
x and y         if x is false, then x, else y 
not x           if x is false, then True, else False    

Comparisons

<               strictly less than      
<=              less than or equal      
>               strictly greater than   
>=              greater than or equal   
==              equal   
!=              not equal       

is              object identity         

Sequence types

• String str

• List list

• Tuple tuple

Operations

x in s  True if an item of s is equal to x, else False  
x not in s      False if an item of s is equal to x, 
        else True       
s + t   the concatenation of s and t    
s[i]    i'th item of s
s[i:j]  slice of s from i to j  
s[i:j:k] slice of s from i to j with step k
len(s)  length of s     
min(s)  smallest item of s      
max(s)  largest item of s       

Variables, assignment

The assignment statement = creates new variables and gives them values

a=2
l=9**1000L
S='Hello'
f=1e5

Lists and tuples

• Lists [] are mutable sequences of values

• Tuples () can not be changed (immutable)

In [5]: a=[1,2,3]
In [6]: b=(1,2,3)

In [7]: a[0]
Out[7]: 1

In [8]: b[0]
Out[8]: 1

In [9]: a[0]=4

In [10]: a
Out[10]: [4, 2, 3]

In [11]: b[0]=4
---------------------------------------------------------------------------
exceptions.TypeError 

Indexing and slicing

• Indices [] select elements of variables

• Indices start from zero

• x[a:b] selects a slice of elements from variable x

In [1]: a=range(10)

In [2]: a
Out[2]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [3]: a[0:4]
Out[3]: [0, 1, 2, 3]

In [4]: a[4:]
Out[4]: [4, 5, 6, 7, 8, 9]

In [5]: a[:4]
Out[5]: [0, 1, 2, 3]

In [6]: a[:-1]
Out[6]: [0, 1, 2, 3, 4, 5, 6, 7, 8]

In [7]: s='Hello world'
In [8]: s[:5]
Out[8]: 'Hello'

In [9]: a=tuple(range(10))
In [10]: a[0:4]
Out[10]: (0, 1, 2, 3)

List built-in functions (methods)

• L.append(object) -- append object to end

• L.count(value) -> integer -- return number of occurrences of value

• L.extend(iterable) -- extend list by appending elements from the iterable

• L.index(value, [start, [stop]]) -> integer -- return first index of value

• L.insert(index, object) -- insert object before index

• L.pop([index]) -> item -- remove and return item at index (default last)

• L.reverse() -- reverse *IN PLACE*

• L.sort() -- sort *IN PLACE*

In [72]: L=['C','A','B']
In [73]: L.sort()

In [74]: L
Out[74]: ['A', 'B', 'C']

In [75]: L.pop()
Out[75]: 'C'

In [76]: L
Out[76]: ['A', 'B']

In [77]: L.insert(1,'C')

In [78]: L
Out[78]: ['A', 'C', 'B']

Nested data structures

In [84]: a=range(10)
In [85]: b=range(0,10,2)
In [86]: b
Out[86]: [0, 2, 4, 6, 8]

In [87]: c=[a,b]

In [88]: c
Out[88]: [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [0, 2, 4, 6, 8]]

In [91]: c[0]
Out[91]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [92]: c[1]
Out[92]: [0, 2, 4, 6, 8]

In [93]: c[0][0:4]
Out[93]: [0, 1, 2, 3]

In [94]: c[1][0:4]
Out[94]: [0, 2, 4, 6]

Dictionary

• A dictionary is like a list, but more general.
• In a list, the indices have to be integers; in a dictionary they can be (almost) any type.

• d={}  creates empty dictionary

•  d[key]=value  add a key, value pair to dictionary

•  d.keys()  returns list of keys

In [95]: D={}
In [96]: D['a']=range(10)
In [97]: D['b']=range(0,10,2)

In [98]: D
Out[98]: {'a': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 'b': [0, 2, 4, 6, 8]}

In [99]: D['a']
Out[99]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [100]: D.keys()
Out[100]: ['a', 'b']

Loops

• Looping over a list is done for the  for  statement

•  enumerate()  returns an enumerated object

In [106]: a=['Hund','Katze','Maus']
In [108]: for i in a:
   .....:     print i
   .....:
Hund
Katze
Maus

In [111]: for i,j in enumerate(a):
   .....:     print i,j
   .....:
0 Hund
1 Katze
2 Maus

Control statements

• Conditions can be checked with if-else statement

•  if  condition: indented block

•  else: 

In [116]: if a==1:
   .....:     print 'a=1'
   .....: else:
   .....:     print 'a != 1'
   .....:
a=1

Modules

There are many ways to import modules. The resulting namespaces are different

• Import module SciPy: import scipy

• List SciPy subpackages help(scipy) or scipy.info(scipy)

• Import SciPy subpackage n-dimensional image package import scipy.ndimage

• List ndimage functions help(scipy.ndimage)

• Help on ndimage function laplace help(scipy.ndimage.laplace)

• Import SciPy module into local namespace from scipy import *

• Import SciPy subpackage ndimage in namespace ndi import scipy.ndimage as ndi

• Write source for this object to output scipy.source(ndi.laplace)

• Reload a (changed) module dreload(module name)