Hallo, als Anfänger übe ich Lernprogramme auf Python. Hier geht es um Berechnung einer mathematischen Funktion. Ich schreibe ein Python-Programm das vom Benutzer zwei Zahlenwerte x_anfang und x_ende (Ganzzahlen) anfordert. Die mathematische Funktion soll dann für alle Werte in diesem Wertebereich berechnet werden: y = ½ x³ – ½ x² + 2x + 3 Die jeweiligen x und y Werte sollen auf dem Bildschirm ausgeben werden. --------------------- Das Programm habe ich so geschrieben: ----------------------- from math import * x_anfang=float(input("Eingabe_Anfangswert:")) x_ende=float(input("Eingabe_Endwert:")) sw=float(input("Eingabe_Schrittweite:")) x=float y = 1/2*x**3 - 1/2*x**2 + 2*x + 3 for x in arange(x_anfang, x_ende, sw): print("x=", x) print("y=", y) #print() ----------------------------------- Nach dem "RUN" erhalte ich Eingabenaufforderungen, aber danach Fehlermeldung: >>> RESTART: C:/....... Berechnung math Funkion.py Eingabe_Anfangswert:1 Eingabe_Endwert:3 Eingabe_Schrittweite:1 Traceback (most recent call last): File "C:/........... Berechnung math Funkion.py", line 9, in <module> y = 1/2*x**3 - 1/2*x**2 + 2*x + 3 TypeError: unsupported operand type(s) for ** or pow(): 'type' and 'int' >>> Was ist mein Fehler und wie kann ich das Programm fehlerfrei und lauffähig machen? Bitte um Korrektur.
:
Verschoben durch User
Die fehlermeldung sagt, dass du versuchst, die Operation ** auf eine Variable vom Typ int (3) und eine zweite Variable vom Typ "Type" (float) anzuwenden. Du legst mit x=float keine neue float-Variable an, sondern eine Variable vom Typ "Datentyp", deren Inhalt 'Float' ist. Lass die Zeile x=... einfach weg. Dann wird dir das nächste Problem auffallen, y=... muss für jeden Schleifendurchlauf aufgerufen werden.
import numpy as np ... x = np.arange(xmin, xmax, step) y = 1/2*x**3 - 1/2*x**2 + 2*x + 3
Moin zusammen! Auch ohne Verwendung von Numpy geht es mit Python üblichen Mitteln recht einfach:
1 | import math |
2 | |
3 | xmin = 1 |
4 | xmax = 4 |
5 | step = 1 |
6 | |
7 | func = lambda x: 0.5 * x**3 - 0.5 * x**2 + 2 * x + 3 |
8 | |
9 | x = [xmin + (i * step) for i in range(math.ceil((xmax - xmin)/step))] |
10 | y = list(map(func, x)) |
Viele Grüße Falk
__LC__ schrieb: > func = lambda x: 0.5 * x**3 - 0.5 * x**2 + 2 * x + 3 Man muß aber auch keine anonymen Funktionen hinschreiben nur um ihnen dann gleich einem Namen zuzuweisen so daß sie nicht mehr anonym sind. Für das Definieren benannter Funktionen wurde das Schlüsselwort def erfunden. Das ist leichter zu lesen.
:
Bearbeitet durch User
Polynome berechnet man in der Programmierung typischerweise mit dem Horner Schema: y = ½ x³ – ½ x² + 2x + 3 = ((½x – ½)x + 2)x + 3 Damit bist Du schon mal die Potenzen los. Wenn Du jetzt noch ½ ausklammerst kannst Du den Großteil der Berechnung sogar auf Ganzzahlarithmetik beschränken: y = (((x – 1)x + 4)x + 6) / 2 Ob bei der letzten Division dann noch Gleitkommagenauigkeit gefordert ist musst Du selber wissen. (In dem Fall dann besser * 0.5 statt / 2). In vielen praktischen Fällen dürfte die Ganzzahldivision aber sogar genügen.
:
Bearbeitet durch User
Bernd K. schrieb: > __LC__ schrieb: >> func = lambda x: 0.5 * x**3 - 0.5 * x**2 + 2 * x + 3 > > Man muß aber auch keine anonymen Funktionen hinschreiben nur um ihnen > dann gleich einem Namen zuzuweisen so daß sie nicht mehr anonym sind. > Für das Definieren benannter Funktionen wurde das Schlüsselwort def > erfunden. Das ist leichter zu lesen. Jawoll. In diesem Fall bin ich für die Ausnahme: es wird verdeutlicht dass auch eine Funktion ein first class citizen ist, schlicht einer Variablen zugewiesen werden kann und dann als Parameter an eine Funktion weitergereicht werden kann. Nennen wir es hier Stilmittel. Selbstverständlich ist dies "äquivalent" zu def Jedoch geht so einem Einsteiger vielleicht eher ein Licht auf richtung funktionaler Programmierung. Vielleicht wird auch die Neugierde angestachelt was es mit dem lambda auf sich hat...
Vielen Dank an alle.
Ich habe Programm-Code wie folgt geändert:
from math import *
x_anfang=float(input("Eingabe_Anfangswert:"))
x_ende=float(input("Eingabe_Endwert:"))
sw=float(input("Eingabe_Schrittweite:"))
for x in range(x_anfang, x_ende, sw):
y = 1/2*x**3 - 1/2*x**2 + 2*x + 5
print("x=", x)
print("y=", y)
#print()
es ergab sich folgende Meldung (beim "RUN"):
RESTART: C:/....../....Berechnung math Funkion.py
Eingabe_Anfangswert:1
Eingabe_Endwert:3
Eingabe_Schrittweite:1
Traceback (most recent call last):
File "C:/.../..Berechnung math Funkion.py", line 11, in <module>
for x in range(x_anfang, x_ende, sw):
TypeError: 'float' object cannot be interpreted as an integer
>>>
1. es scheint mir zu sein, dass mein PC die "numpy" nicht verwenden
kann. Ich verstehe, dass "numpy" soll eine Bibliothek für
Befehle/Funktionen ... zu sein und bei mir ist die "nupmy" ist nicht
dabei. Kann ich die Numpy importieren aus internet? Wenn ja chan welchen
Spreicherort?
2. Ich habe -arange- (fliessende komma) zu -range- geändert.
3. Ich habe die Zeile
x=float
intfernt. In der Fehlermelnung wird mitgeteilt, dass "TypeError:
'float' object cannot be interpreted as an integer"
Warum interpretiert das Programm die Variable x (? oder was?) als
integer?
Ich habe niergendwo 'integer' zugewiesen. Hat das stillschweigend
passiert? Wo/wie genau? Was muss man ändern damit das nicht passiert?
Zu 1: Ja, installieren kannst du es z.B. via pip. Einfach mal googlen (oder gleich Anaconda installieren, da sind die wichtigsten Pakete dabei - und noch viel mehr). Aus 2 folgt 3: range erwartet Ganzzahlen, arange funktioniert mit float. Un du castest die Eingabe mit x_anfang=float(input("Eingabe_Anfangswert:")) explizit zu float.
> Traceback (most recent call last): > File "C:/.../..Berechnung math Funkion.py", line 11, in <module> > for x in range(x_anfang, x_ende, sw): > TypeError: 'float' obj > > 3. Ich habe die Zeile > x=float > intfernt. In der Fehlermelnung wird mitgeteilt, dass "TypeError: > 'float' object cannot be interpreted as an integer" > > Warum interpretiert das Programm die Variable x (? oder was?) als > integer? > Ich habe niergendwo 'integer' zugewiesen. Hat das stillschweigend > passiert? Wo/wie genau? Was muss man ändern damit das nicht passiert? Die Funktion range(...) funktioniert nur mit integer, weil nur zu ganze Zahlen Vorgänger und Nachfolger definierbar sind. Zu Fliesskommazahlen nicht. Damit nix unerwartetes passiert, musst Du vor der Werteübergabe an range(...) diese Fliesskommawerte explizit "ganz machen" und zwar explizit so wie Du es meinst, denn es gibt mehrere Möglichkeiten.
1 | from math import * |
2 | |
3 | # frange generiert float-Werte von start bis ausschließlich stop mit |
4 | # der Schrittweite step. Was die Abbruchbedingung betrifft, verhält sich |
5 | # frange wie range und np.arange. |
6 | |
7 | def frange(start, stop, step): |
8 | n = ceil((stop - start) / step) |
9 | return (start + i * step for i in range(n)) |
10 | |
11 | x_anfang=float(input("Eingabe_Anfangswert:")) |
12 | x_ende=float(input("Eingabe_Endwert:")) |
13 | sw=float(input("Eingabe_Schrittweite:")) |
14 | |
15 | for x in frange(x_anfang, x_ende, sw): |
16 | |
17 | y = 1/2*x**3 - 1/2*x**2 + 2*x + 5 |
18 | |
19 | print("x=", x) |
20 | print("y=", y) |
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.