#acl AdminGroup:read,write EditorGroup:read,write All:read
#format wiki
#language de
#pragma section-numbers off

SiaProgrammingPython

= 2. Stunde - Übungen =

== For Schleifen ==

=== a) ===

{{{#!python
for ...:
     print i
  
0
1 
2
3
}}}

 * Setzen Sie einen Ausdruck in {{{...}}} ein, um das Ergebnis zu erzeugen

[[SiaExercisesLesson2LoesungFora|Loesung]]

=== b) ===

{{{#!python
for ... in zip(range(0,4,1),range(4,0,-1)):
     print i,j
  
0 4
1 3
2 2
3 1
}}}

 * Setzen Sie einen Ausdruck in {{{...}}} ein, um das Ergebnis zu erzeugen

[[SiaExercisesLesson2LoesungForb|Loesung]]

=== c) ===
{{{
0 0
0 1
0 2
0 3
1 0
1 1
1 2
1 3
2 0
2 1
2 2
2 3
3 0
3 1
3 2
3 3
}}}
 * Wie sehen die dazugehörigen (verschachtelten) Schleifen aus, die dieses Ergebnis erzeugen?

[[SiaExercisesLesson2LoesungForc|Loesung]]

== Numpy/Scipy numerische Typen ==

{{{from numpy import *}}}

Ein Byte besteht aus 8-Bit und deckt den Wertebereich von 0..255 ({{{uint8}}}, unsigned integer) 
oder -128..127 ab.

{{{#!python
b=int8(128)
-128 # Bereichsüberschreitung

b.nbytes
1
}}}

=== a) ===

Welchen Wertebereich decken die folgenden Integer-Typen ab und wieviele Bytes belegen diese im Speicher:

 * bool8
 * uint8, int8
 * uint16, int16
 * uint32, int32
 * uint64, uint64

[[SiaExercisesLesson2LoesungNumpyInt|Loesung]]

=== b) ===

Wieviele Bytes belegen die [[http://en.wikipedia.org/wiki/Floating_point|Float-Point]] Variablen im Speicher
 
 * float32, float64, float96
 * complex64, complex128, complex192

Welchen Wertebereich deckt eine typische ''Double Precision'' ({{{float64}}}) Variable ab?

[[SiaExercisesLesson2LoesungNumpyFloat|Loesung]]

== Datenstrukturen ==

=== a) ===
{{{#!python
D={'A':array(range(10)),'B':array(range(10))+1}
}}}
 * Welche Schlüssel enthält das Dictionary {{{D}}}
 * Geben Sie die Schlüssel mit der Methode {{{.keys()}}} aus
 * Geben Sie den Array {{{A}}} aus
 * Geben Sie die Elemente {{{3:6}}} des Arrays {{{B}}} aus
 * Setzen Sie diese Elemente auf 0
 * Fügen Sie ein neues Schlüssel-Wertepaar {{{C:array(range(0,10,-1))}}} zu {{{D}}} hinzu
 * Programmieren Sie eine Schleife, die alle Elemente von {{{D}}} ausgibt

[[SiaExercisesLesson2LoesungDatenstrukturenA|Loesung]]

=== b) ===
{{attachment:rgb.png}}

{{{#!python
from scipy import empty,mgrid,exp
from pylab import figure,clf,subplot,imshow,title,gray,plot,show,savefig

def gaussian(center, width):
	"""Returns a gaussian function"""
	center_y,center_x=float(center[0]),float(center[1])
	width_y,width_x=float(width[0]),float(width[1])
   	return lambda y,x: exp(-(((center_y-y)/width_y)**2+((center_x-x)/width_x)**2)/2)


Y,X=200,200 
RGB=empty((Y,X,3),float) 
D,I={ 'R':(0,0,0), 'G':(200,100,1), 'B':(00,200,2) },{} 
y, x = mgrid[0:Y,0:X]
figure(1)
clf()
for color in D.keys():
	I[color] = gaussian(D[color][0:2], (100,100))(y, x)
	RGB[:,:,D[color][2]]=I[color]
	subplot(2,2,D[color][2]+1)
	imshow(I[color],origin='lower')
	title(color)
	gray()
subplot(2,2,4)
imshow(RGB,origin='lower')
title('RGB')
show()
savefig('rgb.png',dpi=100)
}}}

 * Stellen Sie eine Liste der Variablen auf, die das Programm enthält
 * Welchen Typs sind die Variablen? Was ist ihre Funktion?
 * Wieviele Arrays werden definiert? 
 * Welche Arrays sind in anderen Datenstrukturen enthalten?
 * Welche Dimension haben die Arrays (-> Methode {{{.shape}}})
 

Legen Sie für jeden Farbkomponente einen horizontalen (y=100) und vertikalen Schnitt (x=100) durch das Array RGB.
Stellen Sie die Schnitte der drei einzelnen Komponenten in einer Abbildung dar.

[[SiaExercisesLesson2LoesungDatenstrukturenB|Loesung]]