Erstellen von Polynomial Klasse in Python

Question

Erstellen von Polynomial Klasse in Python

stimmen

1

Ich arbeite derzeit an eine Polynomial - Klasse erstellen, die folgenden beinhaltet Add , mul und eval Methoden. Ich bin zur Zeit fest auf dem Beimengungsabschnitt, wenn mir jemand etwas Hilfe auf geben könnte , wie man aus , dass dachte zu bekommen , dass wäre sehr dankbar. Alles funktioniert zur Zeit ohne Fehler , aber wenn ich tun p3 = p1 + p2 und ich drucke p3 ich zusammen die beiden Listen zurück. Jedes Feedback würde sehr geschätzt werden .

class Polynomial(object):

    def __init__(self, *coeffs, num = 0):

        self.coeffs = list(coeffs) # turned into a list

        assert (type(num) is type(1)) 
        self.num = num

    # Needs to be operator overload
    '''
    def __mul__(self, other):
    '''

    def __eval__(self, other, coeff, x):
        result = coeff[-1]
        for i in range(-2, -len(coeff)-1, -1):
            result = result * x + coeff[i]
        return result


    def __add__(self, other):

        assert type(other) is Polynomial

        num = self.coeffs + other.coeffs

        return Polynomial(num)


    def __sub__(self, other):

        assert type(other) is Polynomial
        num = self.coeffs - other.coeffs

        return Polynomial(num)




    def __represntation__(self):
        return Polynomial + str(self.coeffs)   

    def __str__(self):
        rep =     
        degree = len(self.coeffs) - 1
        rep += str(self.coeffs[0]) + x^ + str(degree)       
        for i in range(1, len(self.coeffs)-1):
            coeff = self.coeffs[i]
            if coeff < 0:
                rep +=  -  +  str(-coeff) + x^ + str(degree - i)
            else:
                rep +=  +  +  str(coeff) + x^ + str(degree - i)

            if self.coeffs[-1] < 0:
                rep +=  -  + str(-self.coeffs[-1])
        else:
            rep +=  +  + str(self.coeffs[-1])  
        return rep

python

Veröffentlicht am 13/02/2020 um 23:53
quelle vom benutzer cobettin

In anderen Sprachen...

3 antworten

Green Cloak Guy · Answer 1 · 2020-02-13 23:57

Das Problem ist hier:

num = self.coeffs + other.coeffs

Hinzufügen einer Liste in eine andere Liste verkettet sie. Um einfach hinzufügen Elemente , die einander entsprechen, würden Sie tun möchten ,

from itertools import zip_longest

...

num = [a + b for (a, b) in zip_longest(self.coeffs, other.coeffs, fillvalue=0)]

Wir verwenden zip_longest()statt der allgemeineren zip()weil ein Polynom möglicherweise länger als die andere ist , und wir wollen es nicht ruinieren. Entweder einer von ihnen Gruppe zusammen die entsprechenden Elemente so , dass wir sie leicht hinzufügen und eine Liste derer machen.

Sie würden etwas Ähnliches für die Subtraktion tun.

Bill CX · Answer 2 · 2020-02-14 00:02

stimmen

0

Sie können nicht direkt zwei Listen hinzufügen.

def __add__(self, other):

    assert type(other) is Polynomial
    assert len(self.coeffs) != len(other.coeffs)

    new_ceffs = [item1 + item2 for (item1, item2) in zip(self.coeffs, other.coeffs)]

    return Polynomial(new_ceffs)

Beantwortet am 14/02/2020 um 00:02
quelle vom benutzer Bill CX

Alain T. · Answer 3 · 2020-02-14 02:48

Sie sollten die Reihenfolge der Koeffizienten zu Ihrem Konstruktor übergeben , so dass Indizes in der Reverse - self.coeffsListe entsprechen den Exponenten. Dies würde den Rest des Codes vereinfachen und ermöglichen es Ihnen für Additionen und Subtraktionen zu verwenden zip_longest.

Wenn Sie zu anderen Operationen jedoch bekommen, ich glaube, Sie werden feststellen, dass Ihre innere Struktur einfacher wäre, zu verwalten, wenn es ein Wörterbuch ist. Ein Wörterbuch ist zügige Einträge fehlen somit Besorgnisse der Zuteilung von Räumen für neue Indizes zu vermeiden.

class Polynomial(object):

    def __init__(self, *coeffs):
        self.coeffs = {exp:c for exp,c in enumerate(coeffs[::-1])}

    def __add__(self, other):
        assert type(other) is Polynomial
        result = Polynomial(0)
        result.coeffs = {**self.coeffs}
        for exp,c in other.coeffs.items():
            result.coeffs[exp] = result.coeffs.get(exp,0) + c
        return result

    def __sub__(self, other):
        assert type(other) is Polynomial
        result = Polynomial(0)
        result.coeffs = {**self.coeffs}
        for exp,c in other.coeffs.items():
            result.coeffs[exp] = result.coeffs.get(exp,0) - c
        return result

    def __mul__(self, other):
        assert type(other) is Polynomial
        result = Polynomial(0)
        for exp1,c1 in self.coeffs.items():
            for exp2,c2 in self.coeffs.items():
                result.coeffs[exp1+exp2] = result.coeffs.get(exp1+exp2,0) + c1*c2
        return result

    def __representation__(self):
        return "Polynomial" + str(self.coeffs)   

    def __str__(self):
        result = [""]+[f"{c}x^{i}" for i,c in sorted(self.coeffs.items()) if c]+[""]
        result = "+".join(reversed(result))
        result = result.replace("+1x","+x")
        result = result.replace("-1x","-x")
        result = result.replace("x^0","")
        result = result.replace("x^1+","x+")
        result = result.replace("+-","-")
        result = result.strip("+")
        result = result.replace("+"," + ")
        result = result[:1]+result[1:].replace("-"," - ")
        return result.strip()