Der Agent baut einen Block, dreht sich nach links, baut 2 Blöcke, dreht sich nach links, baut 3 Blöcke… bis 6 Blöcke. Es entsteht eine linksdrehende Spirale. Wenn er aussen angekommen ist, baut er 10 Blöcke gerade aus und baut dann erneut eine Spirale - insgesamt 4 Mal. Erst wenn die Funktion baueSpirale() aufgerufen wird, beginnt er mit dem Bau, nicht bei der Definition der Funktion.

<Code ausführen>

agent.set_assist(PLACE_ON_MOVE, True) # bauen während er bewegt
agent.set_assist(DESTROY_OBSTACLES,True) # Hindernisse autom. zerstören

def baueSpirale(richtung):
   for zahl in range(1,7):  # zahl läuft von 1 bis 6
       agent.move(FORWARD,zahl)
       agent.turn(richtung)
     
for i in range(4): # i läuft von 0 bis 3
    baueSpirale(LEFT)
    agent.move(FORWARD,10)
  

Solange n grösser ist als 1 ruft die Funktion sich selbst auf, mit jeweils einem um 2 verkleinerten Argument. Zunächst wird rec1(10) aufgerufen. Dies zeichnet ein Quadrat der Grösse 10×10, danach teleportiert sich der Agent um 1 nach oben, 1 nach Osten und 1 nach Süden. Danach wird dieselbe Funktion aufgerufen mit dem Argument 8 und es wird ein Quadrat der Grösse 8×8 gezeichnet etc. bis 2×2 und wenn rec(0) aufgerufen wird, bricht das Programm ab. Es entsteht eine Pyramide.

Die zweite Funktion rec2 ruft sich zweimal selber auf die verwendet nicht doppelt so viel Speicher, sondern exponentiell mehr Speicher. Am besten stellt man sich dies an einem Baumdiagramm vor: rec2(30,4) ruft rec2(29,6) und rec2(31,5) auf und diese beiden rufen jeweils wieder rec2 zweimal auf. Dies führt zu einem sehr hohen Speicherverbrauch.

Bei call by value wird der Wert einer Variablen als Parameter übergeben, d.h. der Wert wird in die Variable des Parameters kopiert. Ändert man innerhalb einer Funktion dann die Parametervariable, so ändert sich die Variable ausserhalb nicht.
Bei cal by reference wird nur die Adresse (Referenz) an die Parametervariable gebunden, d.h. wenn man innerhalb einer Funktion die Parametervariable ändert, ändert auch diejenige ausserhalb.

Mutable bedeutet veränderbar, immutable unveränderlich. In Python sind die einfachen Datentypen immutable (Zahlen, Boolean, Strings, Tuple) d.h. man kann sie nicht an Ort und Stelle ändern, sondern man kann sie nur überschreiben. Listen hingegen sind mutable: wenn ich eine Liste L1 habe, dann kann ich dieser Liste Elemente hinzufügen oder Elemente ändern.

In Python sind alle Variablentypen (Zahlen, Zeichenketten, Boolean, Listen, etc.) Referenztypen, d.h. der Parametervariablen einer Funktion wird immer die Referenz übergeben. D.h. eigentlich müsste dann die aufrufende Variable jeweils ändern, wenn in einer Funktion die Parametervariable geändert wird, doch da die Grundtypen **immutable sind und nicht geändert werden können, verhalten sie sich im Prinzip wie call by value. Listen hingegen (oder Objekte, wie wir später sehen werden) können hingegen an Ort geändert werden, deshalb verhalten sie sich wie das Konzept call by reference.

Zunächst wird eine Funktion mit zwei Parametern definiert (change_value(list1, list2)). Beim Parameter list1 wird das dritte Element list1[2] auf 5 gesetzt: dies geschieht an Ort. Bei list2 wird hingegen ein neues Listenobjekt erzeugt und list2 zeigt dann auf dieses neue Objekt.
Nun werden zwei Listen definiert l1 und l2.
Die Funktion change_value wird aufgerufen mit den beiden definierten Listen l1 und l2: da alle Variablen in Python Referenztypen sind, werden die Adressen (Referenzen), welche zu l1 und l2 zeigen, übergeben
list1 zeigt nun auf dieselbe Adresse wie l1 und list2 auf dieselbe wie l2. Da nun list1 an Ort und Stelle geändert wird, verändert sich auch l1. Da aber list2 einem neuen Listenobjekt [6,10] zugewiesen wird, wird l2 nicht verändert.

Am Schluss werden l1 und l2 ausgegeben: l1=[1,2,5,4] bzw. [l2=10,11,12]