Python: Berechnung einfacher mathematischen Funktion

[Hel B. (helbi)]

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.

[Markus E. (markus_e176)]

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.

[Sven B. (scummos)]

import numpy as np
...
x = np.arange(xmin, xmax, step)
y = 1/2*x**3 - 1/2*x**2 + 2*x + 3

[__LC__ (Gast)]

Moin zusammen!

Auch ohne Verwendung von Numpy geht es mit Python üblichen Mitteln recht 
einfach:

import math

xmin = 1
xmax = 4
step = 1

func = lambda x: 0.5 * x**3 - 0.5 * x**2 + 2 * x + 3

x = [xmin + (i * step) for i in range(math.ceil((xmax - xmin)/step))]
y = list(map(func, x))

Viele Grüße
Falk

[Bernd K. (prof7bit)]

__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.

[A. H. (ah8)]

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.

[Programmiersprachentheaterintendant (Gast)]

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...

[Hel B. (helbi)]

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?

[Michael H. (etit-ka)]

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.

[Biscia (Gast)]

> 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.

[Yalu X. (yalu) (Moderator)]

from math import *

# frange generiert float-Werte von start bis ausschließlich stop mit
# der Schrittweite step. Was die Abbruchbedingung betrifft, verhält sich
# frange wie range und np.arange.

def frange(start, stop, step):
    n = ceil((stop - start) / step)
    return (start + i * step for i in range(n))

x_anfang=float(input("Eingabe_Anfangswert:"))
x_ende=float(input("Eingabe_Endwert:"))
sw=float(input("Eingabe_Schrittweite:"))

for x in frange(x_anfang, x_ende, sw):

    y = 1/2*x**3 - 1/2*x**2 + 2*x + 5

    print("x=", x)
    print("y=", y)