3.2 Erzeugen von Datentypen

Transkript

1 3.2 Erzeugen von Datentypen Der Datentyp Charge Charge ist ein Datentyp für geladene Teilchen auf einer Fläche (Punktladung). Potential in px, yq Das elektrische Potential V im Punkt px, yq bezgl. p ist k q0 bewirkt durch die Punktladung in px r 0, y 0 q wird beschrieben durch r px 0, y 0 q Punktladung p mit Ladung q 0 px, yq V k q0 r Dabei ist q 0 die Ladung im Punkt px 0, y 0 q, r ist der Abstand zwischen px, yq und px 0, y 0 q und k N m2 ist die Coulombsche C 2 Konstante. Unser Ziel ist, das Potential an verschiedenen Punkten der Ebene bezgl. mehrerer Punktladungen zu berechnen

2 Die API für Charge Unser Datentyp Charge soll Folgendes beschreiben: eine Ladung an einem Punkt in der Ebene, d.h. den Wert der Ladung q0 und die Koordinaten des Punktes px0, y0q das Potential an bel. Punkt px, y q bewirkt durch die Punktladung, d.h. k q0 Abstand von px0, y0q zu px, yq Operation Charge(x0,y0,q0) Beschreibung eine neue Punktladung an Punkt px0, y 0q mit Ladung q0 c.potentialat(x, y) das Potential an Punkt px, y q bewirkt durch Punktladung c str(c) q0 in (x0,y0) zur Darstellung von c als String

3 In Python beschreibt man Datentypen durch Klassen. Die Klasse Charge muss die Werte q0, x0, y 0 für bel. Punktladungen speichern können (Konstruktur), für jeden Punkt px, yq das Potential, das von der Punktladung im Punkt px0, y 0q bewirkt wird, bestimmen können (Methoden), und eine Punktladung als string darstellen können (spezielle Funktionen).

4 # Die Datei charge.py mit der Klasse Charge. import sys, stdio, math def test(): c = Charge(0.51, 0.63, 21.3) stdio.writeln(c) stdio.writeln(c.potentialat(0.7,0.8)) class Charge: # Ein Konstruktor def init (self, x0, y0, q0): self._xkoord = x0 self._ykoord = y0 self._ladung = q0 # Eine Methode def potentialat(self, x, y): COULOMB = 8.99e9 dx = x - self._xkoord dy = y - self._ykoord r = math.sqrt(dx*dx + dy*dy) if r == 0.0: if self._ladung > 0: return float('inf') else: return -float('inf') return COULOMB * self._ladung / r # Eine spezielle Funktion def str (self): text = str(self._ladung) + ' in (' + str(self._xkoord) + ', ' + str(self._ykoord) + ')' return text

5 3.2.5 Der Konstruktor Signatur spezielle Parameter-Variable gewöhnliche Parameter-Variablen def init ( self, x0, y0, q0 ): self. xkoord = x0 Instanz-Variablen self. ykoord = y0 Funktions-Rumpf self. ladung = q0

6 3.2.6 Konstruktor-Abarbeitung auf dem Objekt-Level Charge c = Charge(0.1,0.2,3.0) self x0 [ init (self,0.1,0.2,3.0)] y0 0.1 q

7 3.2.6 Konstruktor-Abarbeitung auf dem Objekt-Level Charge c = Charge(0.1,0.2,3.0) self x0 [ init (self,0.1,0.2,3.0)] y0 0.1 q0 0.2 self. xkoord = x0 self x0 y0 q0 Charge xkoord

8 3.2.6 Konstruktor-Abarbeitung auf dem Objekt-Level Charge c = Charge(0.1,0.2,3.0) self x0 [ init (self,0.1,0.2,3.0)] y0 0.1 q0 0.2 self. xkoord = x0 self. ykoord = y0 self x0 y0 q0 Charge xkoord ykoord

9 3.2.6 Konstruktor-Abarbeitung auf dem Objekt-Level Charge c = Charge(0.1,0.2,3.0) self x0 [ init (self,0.1,0.2,3.0)] y0 0.1 q0 0.2 self. xkoord = x0 self. ykoord = y0 self. ladung = q self x0 y0 q0 Charge xkoord ykoord ladung

10 Konstruktor-Abarbeitung auf dem Objekt-Level Charge c = Charge(0.1,0.2,3.0) self x0 [ init (self,0.1,0.2,3.0)] y0 0.1 q0 0.2 self. xkoord = x0 self. ykoord = y0 self. ladung = q self x0 y0 q0 Charge xkoord ykoord ladung [return self] c Charge xkoord ykoord ladung

11 Methoden Signatur spezielle Parameter-Variable gewöhnliche Parameter-Variablen def potentialat( self, x, y ): COULOMB = 8.99e9 lokale Variablen dx = x - self. xkoord dy = y - self. ykoord Instanz-Variablen r = math.sqrt(dx*dx, dy*dy) if r == 0.0:... Funktions-Aufruf return Anweisung return COULOMB * self. ladung / r 3.2.7

12 Variablen in Methoden Parameter-Variablen Bsp.: self, x, y Aufgabe: Übergabe von Argumenten beim Aufruf der Methode Gültigkeitsbereich (scope): Methode Instanz-Variablen Bsp.: xkoord, ykoord Aufgabe: Speicherung von Werten des Datentyps Gültigkeitsbereich (scope): Klasse lokale Variablen Bsp.: dx, dy Aufgabe: Speicherung von temporären Werten beim Rechnen Gültigkeitsbereich (scope): Methode

13 Spezielle Funktionen und Konventionen Die Funktion str(c) in der API: nach Konvention wird beim Aufruf str(c) die Methode c. str () angewendet. Beim Aufruf von stdio.writeln(c) wird von Python stdio.writeln(str(c)) ausgeführt (etc.). Die Schreibweise mit Unterlänge wird dann benutzt, wenn ein Variablen- oder Methodenname nur innerhalb der Klasse benutzt werden soll. In Python gibt es keine Möglichkeit, die Benutzung dieser Variablen- und Methodennamen zu verbieten. Andere Programmiersprachen bieten Konzepte dafür.

14 Erzeugen eines Datentyps Kurze Zusammenfassung 1. Angabe der API Ziel: einfache Benutzung des Datentyps von Klienten Klarheit über Struktur des Datentyps: welche Daten und welche Methoden? 2. Implementierung einer Klasse in Python Konstruktur init mit self als erster Parameter-Variable gefolgt von den gewöhnlichen Parameter-Variablen Methoden gemäß der API mit self als erster Parameter-Variable gefolgt von den gewöhnlichen Parameter-Variablen spezielle Funktionen, deren Namen von doppelte Unterlängen eingeschlossen sind mit self als erster Parameter-Variable 3. Testen der Implementierung

15 Bsp.: Visualisierung von Potentialen Wir wollen Punktladungen aus einer Datei einlesen (alle Punkte haben Koordinaten px, y q mit 0 ď x, y ď 1), die Potentiale aller Punkte mit Koordinaten 0 ď x, y ď 1 berechnen (das Potential in einem Punkt ist die Summe der Potentiale aller Punktladungen in dem Punkt) und graphisch darstellen, z.b. verschiedene Graustufen hohes Potential ist hell und niedriges Potential ist dunkel. % more charges.txt

16 Welche Datenstruturen wollen wir benutzen? Charge Picture zur Darstellung des Ergebnis-Bildes. Der Zugriff auf die einzelnen Punkte des Bildes ist dabei sehr einfach. Color InStream zum Einlesen der Datei.

17 Die API von InStream

18 potential.py # potential.py import sys, stdio, stddraw, stdarray, math from charge import Charge from color import Color from picture import Picture from instream import InStream # Lies einen Dateinamen von der Kommandzeile # und öffne die Datei mit diesem Namen. dateiname = sys.argv[1] eingabe = InStream(dateiname) # Die Datei enthält zuerst die Anzahl (int) # der Punktladungen, die folgen, # und anschließend die Punktladungen bestehend # aus den Koordinaten (x,y) des Punktes und # der Ladung a (alles float). # Die Datei wird eingelesen # und die Punktladungen werden erzeugt. n = eingabe.readint() charges = stdarray.create1d(n) for i in range(n): x = eingabe.readfloat() y = eingabe.readfloat() q = eingabe.readfloat() charges[i] = Charge(x,y,q) # Die Ausgabe ist ein quadratisches Bild mit # aufloesung*aufloesung Pixeln. aufloesung = 400 # Das Potential für jedes Pixel wird berechnet. # potentials ist ein 2d-Array, in dem die # Potentiale gespeichert werden. Es wird später # für die Darstellung als Picture verwendet. # allepotentiale ist ein 1d-Array, in dem alle # Potentiale gespeichert werden. Es wird später # zur Umrechnung der Potentiale in Graustufen # verwendet. potentials = \ stdarray.create2d(aufloesung,aufloesung) allepotentiale = [] for s in range(aufloesung): for z in range(aufloesung): x = 1.0 * s / aufloesung y = 1.0 * z / aufloesung v = 0.0 for i in range(n): v += charges[i].potentialat(x,y) potentials[s][z] = v allepotentiale += [v] # Sortiere das Array mit allen Potentialen. allepotentiale.sort() blocklaenge = len(allepotentiale) /

19 # Sortiere das Array mit allen Potentialen. allepotentiale.sort() # Die Potentiale im sortierten Array allepotentiale im ersten 256stel # des Arrays erhalten Graustufe 0, im zweiten 256stel Graustufe 1 # und so weiter, bis im 256sten 256stel die Graustufe 255 erreicht wird. # Die Länge dieser Abschnitte wird durch blocklaenge bestimmt. blocklaenge = len(allepotentiale) / 256 # Das Potential für jedes Pixel wird dargestellt. pic = Picture(aufloesung,aufloesung) # Berechne für jedes Pixel des Bildes die Graustufe. for s in range(aufloesung): for z in range(aufloesung): # Bestimme die Graustufe. gray = 0 while potentials[s][z] > allepotentiale[(gray+1)*blocklaenge-1] and gray<=254: gray += 1 graustufe = Color(gray,gray,gray) pic.set(s,pic.height()-1-z, graustufe) # Male pic auf dem Bildschirm stddraw.setcanvassize(pic.width(),pic.height()) stddraw.picture(pic) stddraw.show()

20 Die Umwandlung von Potentialen in Graustufen kann auf verschiedene Weisen dargestellt werden... Das erste Bild ensteht mit dem angegebenen Programm.

21 Turtle-Graphik Der Datentyp Turtle Idee: Bilder lassen sich mit einem Bleistift malen, indem man wiederholt eine Richtung einnimmt in diese Richtung einen geraden Strich einer bestimmten Länge zeichnet Bsp.: ein gleichseitiges Dreieck malt man durch: nimm Richtung 0 ein male einen 10cm langen Strich drehe die Richtung 120 nach links male einen 10cm langen Strich drehe die Richtung 120 nach links male einen 10cm langen Strich

22 Die API für Turtle Ein Datentyp zum Malen auf diese Art muss die Stelle und die Richtung speichern, eine Methode zum Ziehen eines Strichs und eine Methode zum Ändern der Richtung haben. Operation Turtle(x0,y0,a0) t.goforward(s) t.turnleft(d) str(t) Beschreibung eine neue Turtle an Punkt px0, y0q mit Richtung a0 Turtle t geht s Schritte vorwärts und malt dabei einen Strich Turtle t dreht d Grad nach links (x0,y0) mit Richtung a0 zur Darstellung von t als String

23 Was brauchen wir? Mittels stddraw.line(a,b,x,y) kann man einen Strich von Punkt pa, bq nach Punkt px, yq malen. Wir müssen also aus Punkt pa, bq, Winkel α und Strichlänge s den von der Turtle beim Malen erreichten Punkt ausrechnen. pa ` s cos α, b ` s sin αq s s sin α pa, bq α s cos α

24 turtle.py import sys, stddraw, math class Turtle: def init (self,x0,y0,a0): self._x = x0 self._y = y0 self._angle = a0 def turnleft(self,delta): self._angle += delta % 360 def goforward(self,stepnumber): oldx = self._x oldy = self._y self._x += stepnumber * math.cos(math.radians(self._angle)) self._y += stepnumber * math.sin(math.radians(self._angle)) stddraw.line(oldx, oldy, self._x, self._y) def str (): return '(' + x0 + ',' + y0 + ') mit Richtung ' + a0

25 # Der Test-Client liest einen int-wert n von der Konsole ein # und zeichnet ein n-eck def test(): n = int(sys.argv[1]) step = math.sin(math.radians(180.0/n)) t1 = Turtle(0, 0, 0) stddraw.setcanvassize(800,800) stddraw.setxscale(-0.2,1.2) stddraw.setyscale(-0.2,1.2) for i in range(n): t1.goforward(step) t1.turnleft(360.0/n) stddraw.show() if name == ' main ': test()

26 Erweiterung der API für Turtle Wir wollen der Turtle beim Malen zuschauen können und erlauben ihr, zufällige Schritte zu machen (und in anderen Farben zu malen). Operation Beschreibung Turtle(x0,y0,a0,steps,delay) eine neue Turtle an Punkt px0, y0q mit Richtung a0 ; das Malen eines Strichs wird in steps (default 1) Etappen zerteilt und nach jeder Etappe wird das bisher gemalte für delay ms (default 10) angezeigt t.goforward(s) t.turnleft(d) t.randomstep(s) Turtle t geht s Schritte vorwärts und malt dabei einen Strich Turtle t dreht d Grad nach links Turtle t ändert die Richtung zufällig und macht einen Schritt der Länge s

27 Die neue Methode randomstep(s) in turtle.py import stdrandom Class Turtle:... def randomstep(self,steplength): angle = stdrandom.uniformfloat(0.0,360.0) self.turnleft(angle) self.goforward(steplength)

28 Brown sche Bewegung Wir lassen die Turtle eine zufällige Wanderung über die Ebene machen. # drunk1.py import sys, stddraw import sys, stddraw, stdrandom from turtle import Turtle python drunk1.py trials = int(sys.argv[1]) step = float(sys.argv[2]) stddraw.setpenradius(0.0) t = Turtle(0.5,0.5,0.0,1,0) for x in range(trials): angle = stdrandom.uniformfloat(0.0,360.0) t.turnleft(angle) t.goforward(step) stddraw.show()

29 Wir können jetzt auch viele Turtles gleichzeitig malen lassen. # drunkn.py import sys, stddraw, stdrandom from color import Color from turtle import Turtle n = int (sys.argv[1]) trials = int(sys.argv[2]) step = float(sys.argv[3]) python drunkn.py stddraw.setpenradius(0.0) # Erzeuge ein Array aus n turtles mit # zufälligen Startpositionen. turtles = stdarray.create1d(n) for t in range(n): x = stdrandom.uniformfloat(0.1,0.9) y = stdrandom.uniformfloat(0.1,0.9) turtles[t] = Turtle(x,y,0.0,1,1) # Lasse sie alle für trials Schritte laufen. for t in range(trials): for t in turtles: t.randomstep(step) stddraw.show()

30 Zusammenfassung Wir haben die ersten Schritte dazu gesehen, wie man einen Datentyp entwirft, eine API dafür angibt und den Datentyp in Python als Klasse implementiert. Wir werden noch mehr Schritte dazu sehen.