Hilfe bei Protable Python 2.6.1.

[Thunder Wolf]

Hallo werte User des Programmierforums,

ich arbeite derzeit mit Portable Phyton und habe folgendes Problem:
Hier erstmal der bisherige Code

# -*- coding: cp1252 -*-
# (c) Mattes
class Bruch:
def __init__(self, zaehler,nenner):
self.zaehler = zaehler
self.nenner = nenner

def gibZaehler(self):
return self.zaehler

def gibNenner(self):
return self.nenner

def toString(self):
return str(self.zaehler) + "/" + str(self.nenner)

def clone(self):
return Bruch(self.zaehler, self.nenner)

def add(self, bruch2):
zaehler = self.zaehler * bruch2.nenner + bruch2.zaehler*self.nenner
nenner = self.nenner * bruch2.nenner
ergebnis = Bruch(zaehler, nenner)
return ergebnis

def sub(self, bruch2):
zaehler = self.zaehler * bruch2.nenner - bruch2.zaehler*self.nenner
nenner = self.nenner * bruch2.nenner
ergebnis = Bruch(zaehler, nenner)
return ergebnis

def mul(self, bruch2):
zaehler = self.zaehler * bruch2.zaehler
nenner = self.nenner * bruch2.nenner
ergebnis = Bruch(zaehler, nenner)
return ergebnis


def div(self, bruch2):
zaehler = self.zaehler * bruch2.nenner
nenner = self.nenner * bruch2.zaehler
ergebnis = Bruch(zaehler, nenner)
return ergebnis

def erweitern(self, faktor):
self.zaehler = self.zaehler * faktor
self.nenner = self.nenner * faktor


def ggT(self, a, b):
# ggT für positive Zahlen ermitteln:
if a<0:
a=-a
if b<0:
b=-b
# teiler auf kleinere der beiden Zahlen setzen
if a<b:
teiler = a
else:
teiler = b
# teiler herunterzählern, bis Teiler von beiden
while (a%teiler!=0 or b%teiler!=0):
teiler = teiler - 1
return teiler

def kuerzen(self):
ggT = self.ggT(self.zaehler,self.nenner)
self.zaehler = self.zaehler / ggT
self.nenner = self.nenner / ggT

def kehrWert(self):
return Bruch(self.nenner, self.zaehler)


class EffizienterBruch(Bruch):
def __init__(self, zaehler, nenner):
Bruch.__init__(self, zaehler, nenner)
self.kuerzen()

## def ggT(self, a, b):
## ergebnis = a
## if b==0:
## return a
## elif a>b:
## return self.ggT(b,a-b)
## else:
## return self.ggT(a,b-a)

def ggT(self, a, b):
if a<0:
a=-a
if b<0:
b=-b
if b==0:
return a
else:
return self.ggT(b,a%b)


def kgV(self,a,b):
return a*b/self.ggT(a,b)

def add(self, bruch2):
hauptNenner = self.kgV(self.nenner,bruch2.nenner)
erweiterungsFaktor1 = hauptNenner//self.nenner
erweiterungsFaktor2 = hauptNenner//bruch2.nenner
zaehler = self.zaehler * erweiterungsFaktor1 + bruch2.zaehler * erweiterungsFaktor2
ergebnis = EffizienterBruch(zaehler, hauptNenner)
ergebnis.kuerzen()
return ergebnis

def sub(self, bruch2):
hauptNenner = self.kgV(self.nenner,bruch2.nenner)
erweiterungsFaktor1 = hauptNenner//self.nenner
erweiterungsFaktor2 = hauptNenner//bruch2.nenner
zaehler = self.zaehler * erweiterungsFaktor1 - bruch2.zaehler * erweiterungsFaktor2
ergebnis = EffizienterBruch(zaehler, hauptNenner)
self.kuerzen()
return ergebnis

def mul(self, bruch2):
zaehler = self.zaehler * bruch2.zaehler
nenner = self.nenner * bruch2.nenner
ergebnis = EffizienterBruch(zaehler, nenner)
ergebnis.kuerzen()
return ergebnis


def div(self, bruch2):
zaehler = self.zaehler * bruch2.nenner
nenner = self.nenner * bruch2.zaehler
ergebnis = EffizienterBruch(zaehler, nenner)
ergebnis.kuerzen()
return ergebnis


class KettenBruch(EffizienterBruch):
def __init__(self, zaehler, nenner):
EffizienterBruch.__init__(self,zaehler, nenner)


def __init__(self, faktorenListe):
a = self.ketteAufloesenIterativ(faktorenListe)
self.zaehler = a.zaehler
self.nenner = a.nenner
self.kuerzen()

def ketteAufloesenIterativ(self, faktorenListe):
length = len(faktorenListe)
b = EffizienterBruch(faktorenListe[length-1],1)
print("Faktor "+str(length-1)+" ist "+ str(faktorenListe[length-1])+", b = "+b.toString())
for i in range(length-1):
b = b.kehrWert()
b = b.add(EffizienterBruch(faktorenListe[length-(i+2)],1))
#print("Faktor "+str(length-(i+2))+" ist "+ str(faktorenListe[length-(i+2)])+", b = "+b.toString())
return b





def ketteAufloesenRekursiv(self, faktorenListe):
if len(faktorenListe)==1:
return EffizienterBruch(faktorenListe[0],1)
else:
b = EffizienterBruch(faktorenListe[0],1)
c = self.ketteAufloesenRekursiv(faktorenListe[1:len(faktorenListe)])
c = c.kehrWert()
return b.add(c)

def ketteAufloesen(self, faktorenListe):
if len(faktorenListe)==1:
return EffizienterBruch(faktorenListe[0],1)
else:
b = EffizienterBruch(faktorenListe[0],1)
c = self.ketteAufloesenRekursiv(faktorenListe[1:len(faktorenListe)])
c = c.kehrWert()
return b.add(c)


def eggT(self, a, b, liste):
if b==0:
return a
else:
liste.append(a//b)
return self.eggT(b,a%b,liste)

def toString(self):
liste = self.toFaktorenListe()
st = "["
for i in liste:
st = st + str(i) + ", "
if len(st)>1:
st = st[0:len(st)-2]
st = st+"]"
return st

def toFaktorenListe(self):
liste = []
self.eggT(self.zaehler,self.nenner,liste)
return liste


##t1 = Bruch(3,4)
##print t1.toString()
##t2 = Bruch(1,4)
##print t2.toString()
##b1 = t1.add(t2)
##print b1.toString()
##b2 = t1.sub(t2)
##print b2.toString()
##b3 = t1.mul(t2)
##print b3.toString()
##b4 = t1.div(t2)
##print b4.toString()
##
##b2gekuerzt = b2.clone()
##b2gekuerzt.kuerzen()
##print b2.toString() + " = "+b2gekuerzt.toString()
##
##print "*****************************************"
##
##t1 = EffizienterBruch(3,4)
##print t1.toString()
##t2 = EffizienterBruch(1,4)
##print t2.toString()
##b1 = t1.add(t2)
##print b1.toString()
##b2 = t1.sub(t2)
##print b2.toString()
##b3 = t1.mul(t2)
##print b3.toString()
##b4 = t1.div(t2)
##print b4.toString()
##
##b2gekuerzt = b2.clone()
##b2gekuerzt.kuerzen()
##print b2.toString() + " = "+b2gekuerzt.toString()
##
##liste = [1]
##for i in range(2,10):
## liste.append(i)
## k = KettenBruch(liste)
##
##print k.toString()

Ich verstehe nicht, was es mit dem sogenannten Kettenbrauch auf sich hat und mein Lehrer ist einfach zu stolz um uns das zu erklären, da er meint, dass wir dies schon können müssten, obwohl wir es noch nie dran genommen haben.
Kann mir jemand bei diesem Problem helfen und mir auch erklären, was es mit dem Kettenbruch auf sich hat?