Basic Python
This lesson includes the basic Python language. No modules have to be imported
Contents
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 yBoolean 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)