kleine Mathe-Spielereien

mit matplotlib, NumPy, pandas, SciPy, SymPy und weiteren mathematischen Programmbibliotheken.
Benutzeravatar
ThomasL
User
Beiträge: 1366
Registriert: Montag 14. Mai 2018, 14:44
Wohnort: Kreis Unna NRW

Sirius3 hat geschrieben: Donnerstag 21. April 2022, 20:16 Normalerweise benutzt man ein Sieb, das ziemlich schnell viele Primzahlen aussiebt.
Hi, ich habe das immer so verstanden, das die Nicht-Primzahlen ausgesiebt werden und die Primzahlen übrig bleiben. ;-)
Ich bin Pazifist und greife niemanden an, auch nicht mit Worten.
Für alle meine Code Beispiele gilt: "There is always a better way."
https://projecteuler.net/profile/Brotherluii.png
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

24.04.2022
Ich habe jetzt einen Code geschrieben, mit dem einafch und gezielt
Primhzahlen verifiziert werden können. Dabei habe ch die Funktion _fiklter- eingesetzt.
Ich stelle diesen zur Überprüfung vor:



import math
u =int(input("Untergrenze :" , ))
o =int(input("Obergrenze :" , ))


def is_prime(n):
if n <= 2:
return False
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return False
return True


print(list(filter(is_prime, range(u, o))))
for zahl1 in filter(is_prime, range(u, o)):
zahl1 == True

i=2
while i < zahl1 /2:
if zahl1 % i ==0 :
print ("Keine Primzahl!")
#print( "Faktor " +str(i))

i=i+1

print( "Die Zahl "+ str(zahl1 ) + " ist eine Primzahl")
#
Sirius3
User
Beiträge: 17711
Registriert: Sonntag 21. Oktober 2012, 17:20

Man benutzt keine Einbuchstabige Variablennamen, wie u statt untergrenze oder o statt obergrenze.
Was soll die 1 bei `zahl1`? zahl1 wird niemals gleich True sein. Mit dem Ergebnis des Vergleichs machst Du aber eh nichts. Was soll das also?
Deine ›is_prime‹-Funktion liefert jetzt für 2 fälschlicherweise False. Beim Programmieren sollte man doch ein Mindestmaß an Ergeiz haben, fehlerfreie Funktionen schreiben zu wollen.

Die while-Schleife wäre besser eine for-Schleife, weil deutlich besser lesbar. Strings setzt man nicht per + zusammen, sondern nutz Formatstrings. Die letzte print-Ausgabe ist falsch, weil nicht jede Zahl eine Primzahl ist.

Code: Alles auswählen

for i in range(2, zahl1 // 2):
    if zahl1 % i == 0:
        print("Keine Primzahl!")
        # print(f"Faktor {i}")

print(f"Die Zahl {zahl1} ist eine Primzahl")
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Ich hoffe, dass es mir unter Umgehung der vob Dir angemahnten Fehler,
endlich gelungen ist, einen vernünftigen und nicht falschen Code zu produzieren.
Jetzt bin ich mit meiner Kunst, nach langen Bemühungen, am Ende.
Mit herzlichen Grüseen und einem dicken Dankeschön für Deine Hilfe.
OSWALD


###Erstellt am 29.04.22 von OSWALD

import math
unten =int(input("Untergrenze :",))
oben =int(input("Obergrenze :" , ))



def is_prime(n):

if n <= 2:
return False
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return False
return True


print(list(filter(is_prime, range(unten, oben))))
for zahl in filter(is_prime, range(unten, oben)):

prim =0
i=2

for i in range(unten, i // 2):
if prim % i == 0:
print(i)


def Prim_Test(i):



if i ==2 or i==3: return True
if i%2==0 or i<2: return False
for i in range(1, int(i**0.5)+1, 2):
return False

return True


i = int(input("untere Primzahl eingeben: "))
max = int(input("oberste Primzahl eingeben: "))
i = range(unten,oben)
even_numbers = list(filter(lambda x: (x%2 == 0), i))
print(even_numbers),
print("Liste frei von falschen Zahlen ")
##############################################
Benutzeravatar
__blackjack__
User
Beiträge: 13004
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

@OSWALD: Die Einrückungstiefe sieht ziemlich willkürlich aus. Das sollten 4 Leerzeichen pro Ebene sein.

Die Funktion `Prim_Test()` wird nirgends verwendet. Und warum im letzten Schritt alle geraden Zahlen zwischen einer Unter- und Obergrenze berechnet werden, ist auch nicht so wirklich klar wenn man Primzahlen ermitteln will.

Alles was nach dem ersten `print()` kommt macht keinen Sinn und führt bei bestimmten Eingabewerten auch zum Programmabbruch weil `i` nicht immer definiert ist, bevor es verwendet wird.

Auf Modulebene sollte nur Code stehen der Konstanten, Funktionen, und Klassen definiert. Das Hauptprogramm steht üblicherweise in einer Funktion die `main()` heisst. Die ruft man nur auf, wenn das Modul als Programm ausgeführt wird, aber nicht wenn es als Modul importiert wird. Dann kann man beispielsweise einzelne Funktionen in einer Python-Shell ”live” ausprobieren und auch automatisierte Tests schreiben.

Code: Alles auswählen

#!/usr/bin/env python3
import math


def is_prime(n):
    if n <= 2:
        return False
    for i in range(2, int(math.sqrt(n)) + 1):
        if n % i == 0:
            return False
    return True


def main():
    unten = int(input("Untergrenze : "))
    oben = int(input("Obergrenze  : "))
    print(list(filter(is_prime, range(unten, oben))))


if __name__ == "__main__":
    main()
Die `is_prime()`-Funktion ist immer noch fehlerhaft, denn 2 ist eine Primzahl, aber die Funktion sagt sie wäre es nicht:

Code: Alles auswählen

$ py forum7.py
Untergrenze : 0
Obergrenze  : 50
[3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
“Most people find the concept of programming obvious, but the doing impossible.” — Alan J. Perlis
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Hallo, ich darf mich wieder zurückmelden. Heute mit einem anderen Thema.

Die Auswertung von unendlichen Reihen mit Python, ohne Hilfe andere rBibliotheken,
über die Berechnung von Partialsummen, Abschätzung von Konvergenz und Divergenz.

Als Beispiel: die Berechnung von e.
########## e = (1+1/n)**n
import math
from math import *

Hier das kurze Programm :
n=0
##########e = (1+1/n)**n
Beginn = int(input("Beginn :" , ))
Obergrenze = int(input("Obergrenze : ", ))


summe=[]
for n in (Beginn, Obergrenze):
n = (( 1+ 1/n)**n)
print(n)

summe.append(n)
print(summe)
####################################
Hier das Ergebnis:
####################################
ython 3.10.4 (tags/v3.10.4:9d38120, Mar 23 2022, 23:13:41) [MSC v.1929 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.


Beginn :1
Obergrenze : 5000
2.0
[2.0]
2.718010050101555
[2.0, 2.718010050101555]

Das Ergebnis ist (ab etwa einer Obergrenze von 5000 erkennbar richtig. ch habe die Zahlen gleich doppelt ausgeworfen,
aber mit den folgenden Zahlen kann ich gar nichts anfangen. Sicher kann mich jemand hier aufklären.
Außerdem: Nicht bei allen von mir Reihen waren meine Versuche erfolgreich.


0.050487008068736974
0.012594835613238816
0.0025489379837327123
0.00045250925444257647
7.458712205073751e-05
1.1816348106175658e-05
1.833985745229462e-06
2.816939701466478e-07
4.304014885464642e-08
6.558768101048276e-09
9.98149688872051e-10
1.5180329709333957e-10
2.3079304557044703e-11
3.5082634987650543e-12
5.332436262706794e-13
8.104778137735783e-14
1.2318209415277085e-14
1.872188323654198e-15
2.8454386755477355e-16
4.324618505073087e-17
6.572730291498365e-18
9.989495128643864e-19
1.5182424375625324e-19
2.307483707732941e-20
3.5070028991563684e-21
5.330078299293386e-22
8.100858458974732e-23
1.2311996826871296e-23
1.8712247086544574e-24
2.8439593923330265e-25
4.3223590291399403e-26
6.569287738541901e-27
9.984256533795814e-28
1.5174457640517221e-28
2.3062725190024217e-29
3.505161803933908e-30
5.327279916091014e-31
8.096605204431579e-32
1.2305532442193609e-32
1.870242217103828e-33
2.842466156636773e-34
4.3200895465466265e-35
6.565838487328931e-36
9.979014225791795e-37
1.5166490176498089e-37
2.3050615929506084e-38
3.5033213917412275e-39
5.324482786649144e-40
8.092354019290326e-41
1.2299071327214592e-41
1.869260231958779e-42
2.8409736977872404e-43
4.317821250100233e-44
6.562391043020961e-45
9.973774667147705e-46
1.5158526893460464e-46
2.303851302522727e-47
3.501481945732783e-48
5.3216871257565405e-49
8.088105066186793e-50
1.229261360463325e-50
1.8682787624080136e-51
2.8394820225612686e-52
4.315554144637774e-53
6.558945408818276e-54
9.968537859572889e-55
1.5150567791605058e-55
2.3026416475671123e-56
3.499643465539633e-57
5.318892932747272e-58
8.08385834402893e-59
1.2286159272729094e-59
1.867297808185429e-60
2.8379911305509165e-61
4.313288229536582e-62
6.555501583772494e-63
9.963303801624418e-64
1.5142612868737672e-64
2.3014326277501933e-65
3.4978059506547355e-66
5.3161002068506664e-67
8.0796138516454e-68
1.2279708329721854e-68
1.8663173690204506e-69
2.8365010213449523e-70
4.311023504171651e-71
6.552059566933704e-72
9.958072491858577e-73
1.51346621226641e-73
2.3002242427384855e-74
3.4959694005712494e-75
5.313308947296407e-76
8.075371587865444e-77
1.2273260773832164e-77
1.8653374446426428e-78
2.8350116945323585e-79
4.308759967918298e-80
6.548619357352494e-81
9.952843928832414e-82
9.952843928832414e-82


Gute Zeit OSWALD
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Hier noch ein Beispiel: eine harmonische Reihe.
Durch kontinuierliche Erhöhung kann man die Annäherung an die Endsumme
verfolgen. Wen man die letzte Zeile des Programms ausblendet, werden die
einzelnen Werte nicht angezeigt . Ein hohe Obergrenze erreicht den Kontrollwert.


# Die harmonische Reihe 1/x**2
# Summe der Reihe = pi**2/6 = 1.64.......
import math
from math import pi
print("Vorweg : Ergebniskontrolle :" ,pi*pi/6)
print()
print("Mit Erhöhung de Obergrenze -> Endsumme")

Beginn = int(input("Beginn :" , ))
Obergrenze = int(input("Obergrenze : ", ))

x=1
partialsum=[]
for x in range(Beginn, Obergrenze
):
x= (1/x**2)
partialsum.append(x)
print(sum(partialsum))
####################################
Gute Zeit OSWALD
Benutzeravatar
__blackjack__
User
Beiträge: 13004
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

@OSWALD: `math` wird importiert, aber nicht verwendet.

Namen werden in Python klein_mit_unterstrichen geschrieben. Ausnahmen sind Konstanten (KOMPLETT_GROSS) und Klassen (PascalCase).

Die Liste `partialsum` wird gar nicht wirklich verwendet, denn statt die Werte im Speicher zu sammeln und immer wieder alle aufzusummieren, wäre es effizienter nur die aktuelle Summe zu speichern.

Es ist auch verwirrend `x` unnötigerweise vor der Schleife zu initialisieren und *in* der Schleife dann noch mal an einen anderen Wert zu binden.

Code: Alles auswählen

#!/usr/bin/env python3
"""
Die harmonische Reihe 1/x²

Summe der Reihe = pi²/6 = 1.64…
"""
from math import pi as PI


def main():
    grenzwert = PI ** 2 / 6
    print("Vorweg : Ergebniskontrolle:", grenzwert)
    print()
    print("Mit Erhöhung de Obergrenze -> Endsumme")

    beginn = int(input("Begin: "))
    obergrenze = int(input("Obergrenze: "))
    partial_sum = 0
    for x in range(beginn, obergrenze):
        partial_sum += 1 / x ** 2
        print(f"{partial_sum} (Abweichung {grenzwert - partial_sum})")


if __name__ == "__main__":
    main()
“Most people find the concept of programming obvious, but the doing impossible.” — Alan J. Perlis
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Hallo __blackjack__, .
Python ist leider immer noch mein Problem.
Es ist typisch. Wenn man eine Programmiersprache nicht von Grund auf systematisch lernt und glaubt,
dass Python so leicht zu erlernen ist, dann passieren immer wieder diese leidigen Fehler.
Ein technisches Problem habe ich mit dem Kopieren. Bei diesem Vorgang wird das Original-
format des Textes offenbar automatisch verändert. Ich rücke natürlich stets korrekt ein, denn sonst würde
der Code ja nicht laufen.
Da mein Augenlicht nicht mehr das beste ist, tue ich mir mit dem Lesen des Python-Textes im Forum schwer. mit der
kleinen Schriftgröße.
Für das perfekte Superprogramm danke ich natürlich herzlich.
Ic persönlich habe noch nie einen Unterricht in Python oder einer anderen Sprache genossen.
Angelesen ist eben nicht gelernt. Reines Hobby. Vielleicht mache ich doch noch den einen oder anderen Fortschritt
bei Python. Auf jeden Fall macht es riesigen Spaß. Es hätte eben schon vor Jahren Python geben müssen.
Gute Zeit
Oswald
__deets__
User
Beiträge: 14493
Registriert: Mittwoch 14. Oktober 2015, 14:29

Du musst beim einkopieren des Codes die Code-Tags darum machen. Leider. Das heisst zu Beginn muss

[code*]

stehen, und dann danach

[/code*]

ABER ACHTUNG: ohne die Sternchen!

Du kannst das auch mit dem </>-Knopf im vollstaendigen Editor erledigen lassen. Einfach mal ein bisschen mit der Vorschau herumspielen.

Was die Textgroesse angeht: fuer mich funktioniert es super, den Browser einfach mit "Control-+" und "Control--" oder ueber das Menue alles hochskalieren zu lassen. Probier auch das mal aus. Das Layout der Seite funktioniert dann immer noch gut.
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Code: Alles auswählen

[code]
[/code]4.6.22

Versuch einer korrekten Kopie



########## eine von diversen "Leibniz Reihe"n
# (-1)**n / 2*n +1 = pi/4 =0.79
#Autor:blackjack und OSWALD vom 3.6.22
#!/usr/bin/env python3

from math import pi
print("Partialsumme von pi/4 = ", pi/4)

def main():
grenzwert = 0.79
print("Vorweg : Ergebniskontrolle:", grenzwert)
print()
print("Mit Erhöhung de Obergrenze -> Endsumme")

beginn = int(input("Beginn: "))
obergrenze = int(input("Obergrenze: "))
partial_sum = 0
for x in range(beginn, obergrenze):
partial_sum += (-1**x) / (2*x+1)


print(f"{partial_sum} (Abweichung {grenzwert - partial_sum})")

if __name__ == "__main__":
main()
Benutzeravatar
Kebap
User
Beiträge: 686
Registriert: Dienstag 15. November 2011, 14:20
Wohnort: Dortmund

Hallo Oswald, willkommen im Forum und viel Spaß mit Python!
OSWALD hat geschrieben: Sonntag 5. Juni 2022, 16:31 Versuch einer korrekten Kopie
Versuch es vielleicht mal so:

1. Klick auf das Symbol </> - das hatte in deinem letzten Versuch schon funktioniert, ich sehe da sogar 2-3 Code-Felder.
2. Direkt anschließend drücke 4x auf die Return-Taste, um ein paar Leerzeilen zwischen den Code-Tags einzufügen.
3. Zuletzt drücke noch 2x auf die Cursor-nach-oben-Taste, um wieder genau in der Mitte der Leerzeilen zu landen.
An dieser Stelle kannst du dann dein Programm einfügen. Du erhältst eine besser lesbare Darstellung für alle. :geek:
MorgenGrauen: 1 Welt, 8 Rassen, 13 Gilden, >250 Abenteuer, >5000 Waffen & Rüstungen,
>7000 NPC, >16000 Räume, >200 freiwillige Programmierer, nur Text, viel Spaß, seit 1992.
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Code: Alles auswählen



Hallo, herzlichen Dank für die  sehr gute Beschreibung und Hilfe.
Mit einem abschließenden Beitrag zum Thema "Reihen"  h ier der Test

#Hier soll zum Abschluß  des Themas "Unendliche Reihen"
#noch einmal die Leistungfsfähigkeit von Python demonstriert werden.
#In einer Mathematik-Vorlesung zum Thema stellte der Dozent  als
#einführendes Beispiel   die Reihe 1/(x**2 -1) vor und bemerkte:
#"diese Reihe hat die Summe 3/4 und das will ich jetzt beweisen".
#
Der  mathematische Beweis war  dann eine höchst komplizierte Berechnung.
#Die  Studenten ?          kaum einer konnte zunächst folgen oder begreifen.
#Der   Dozent ?  "            Man muss sich erst mal ein paar Tricks einfallen lassen,
#sonst wird das nix; z.B. muss ich    jetzt    nicht  mit   der '1', sondern mit  '2'
# als S tart       begimnnen!                                             " 
#
Natürlich  kann  der Student mit der  alleinigen Anwendung von Python
#Mathmetik niemals begreifen, aber er kann zumindest seine Arbeit
#überprüfen. Es ist so wie mit der Anwendung des Taschenrechners
#beim Lernen des Einmaleins.


import math
from math import *
grenzwert = 0.75
print("Grenzwert =  " , grenzwert)


beginn= int(input("Beginn    : ",))
obergrenze =int(input("Obergrenze  : "  ,))
partial_sum =[]
for x in range(beginn, obergrenze):
     x  = 1/(x**2-1) 
     partial_sum.append(x)
     print(sum(partial_sum))
      
               
Gute Zeit  OSWALD



Benutzeravatar
__blackjack__
User
Beiträge: 13004
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

@OSWALD: Leistungsfähigkeit von Python und den Bibliotheken die es dafür gibt, kann man für diesen Fall wohl eher so zeigen:

Code: Alles auswählen

In [88]: import sympy                                                           

In [89]: from sympy.abc import x                                                

In [90]: sympy.pprint(sympy.Sum(1 / (x ** 2 - 1), (x, 2, sympy.oo)))            
  ∞         
 ____       
 ╲          
  ╲     1   
   ╲  ──────
   ╱   2    
  ╱   x  - 1
 ╱          
 ‾‾‾‾       
x = 2       

In [91]: sympy.pprint(sympy.Sum(1 / (x ** 2 - 1), (x, 2, sympy.oo)).nsimplify())
3/4
“Most people find the concept of programming obvious, but the doing impossible.” — Alan J. Perlis
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Sympy ist natürlich genial und dem Olymp vorbehalten.

Python ist aber die Mutter der olympischen Götter.
Gute Zeit Oswald
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Code: Alles auswählen

[/











 Eine neue "Spielerei" von OSWALD

#  Die Auswertung von Reihen  und die Berechnung
#  von Partialsummen steht in einem engen
#  mathem.  Zusammenung  mit der Berechnung
#  von bestimmnten Integralen. Dort  erfolgt die
#  Berechnung allerdings anders  und kann in der
#  Praxis der angewandten Mathematik eventuell
#  viel umständlicher sein.
#
#  Um die Rechnerei mit den Zahlen zu vereinfachen,
#  habe ich mir  einen nützlichen Code ausgedacht.
#  Dieser kann auch mit einer höheren  Anzahl von
#  Polynom-Gliedern durchgeführt werden und erweitert 
#  damit die Anwendungsmöglichkeiten.

#####################################1.Beispiel
import math
from math import e
# Zur Auswertung  geben  Sie bitte zuerst die Obergenze(a_oben) und die
#   Untergrenze(b_unten) ein. Anschließend erfolgt sofort die Auswertung
#   des best. Integrals
     

def main():
    
     #    f(x)  =  -  x**2+          3*x            + 4
     #    F(x) =  -  1/3*x**3   + 3/2*x**2     +4
    x = 0 
    y=  0


     
    a_oben =  int(input("a_oben :",  ))
    b_unten = int(input("b_unten:" , ))
     
    x =  - 1/3* a_oben**3   +   (3/2* b_unten**2 ) + 4
    print(x) 
 
if __name__ == "__main__":
  main() 

###################################     2.Beispiel
 


def main():

   #    f(x)  =    x**3   -  2*x** 2  - 4*x +5
   #    F(x) =   1/3*x**4   + 3/2*x**3 - 4/4*x**2 +5 dx  
     
    a_oben =  int(input("a_oben :",  ))
    b_unten = int(input("b_unten:" , ))
     
    x =  - 1/3* a_oben**3   +   3/2* b_unten**2   - 4/4*b_unten**2  +5
    print(x) 
 

if __name__ == "__main__":
  main() 
######################################3.Beispiel

def main():
    
    
     #    F(x) =  3/4*e** (3*x-4)
    a_oben =  int(input("a_oben :",  ))
    b_unten = int(input("b_unten:" , ))
     
    x =  3/4*e**(3*a_oben-4)  
    print(x) 
 
if __name__ == "__main__":
   main() 

##############################################
#Zur Kontrolle der einzelnen Terme können Sie  das folgende
#beiliegende Programm verwenden 



###########Auswertung beliebiger mathematischer Funktionen  29.5.2022

 
import math
from math import *

print("                                        A u s w e r t u n g   beliebiger mathematischer    T e r m e ")
print()
print("")

 
Wurzel =lambda x,y : x **(1/y)
      

def W10(Rad, Wp):
          mantisse =(1/Wp)* log10(Rad)
          Ergebnis= round(10 **mantisse,4 )    
          return Ergebnis
def Wnat(R, Wp):
          mantisse =(1/Wp)* log(R)
          Ergebnis= round(2.7183 **mantisse ,6)    
          return Ergebnis

print(" Geben Sie bitte einzelne oder gleichzeitig   mehrere  Terme ein:")
print(" erlaubt sind alle mathematischen  in Python integrierten Funktionen, sowie eigene Funktionen")
print(" z.B. die hier gelisteten Wurzelfunktionen :")
print("und  'W10)'und 'Wnat' , sowie    pi/6,  e* 5 , log10, log, W10(e,2) , Wurzel(100,3)   usw.   ")
print ()
print("Beispiel für eine mehrfache Eingabe:  : sin(5)+ cos(0)-exp(2) +W10(100,2) -Wnat(1100,3) +log(2*5 )")
print ()
print ()
print ()

p=  input("Bitte   Terme zur Auswertung eintragen  :" ,   )

print ()
print ()
print("Ergebnis = :", eval(p))
#  bei a_oben  = 2   und B_unt ist das Ergebnis  = 5.54179201.......
#########################################
















code]
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Code: Alles auswählen

[/
3.06.22
Die  Berechnung des Flächen-Integrals
wurde  optimiert.
 
 


#1.Beispiel  a_oben =  5
#                 b_unten =  2
#                 Ergebnis = F_a - F_b 
 	
def main():
    
    #    f(x)  =   5       
    #    F(x) =   5*x +C
    a_oben =0
    b_unten=0
    
     
    a_oben =  int(input("a_oben :",  ))
    b_unten = int(input("b_unten:" , ))
     
    print("a_oben = ", a_oben )
    print("b_unten= ", b_unten) 
     
     
    x1=  5*a_oben
    x2=  5*b_unten
    print( F_a - F_b  )
    
 
if __name__ == "__main__":
  main() 

#######################

#2.Beispiel  
#        a_oben = 2
#        b:_unten =  -2
#        Ergebnis = F_a - F_b


  def main():
    
     #    f(x)  =  (x- 2 )*(x+2)    = (x**2 - 4*x)  
     #    F(x) =  1/3*x**3  - 4*x  +C
     
    a_oben =2
    b_unten= -2
    
     
    a_oben =  int(input("a_oben :",  ))
    b_unten = int(input("b_unten:" , ))
     
    print("a_oben = ", a_oben )
    print("b_unten= ", b_unten) 
     
     
    F_a =  1/3*a_oben**3   -  4* a_oben
    F_b=   1/3*b_unten**3  -  4*(b_unten)

    print( F_a - F_b  )
    
 
if __name__ == "__main__":
    main() 

Gute Zeit 
OSDWALD


code]
Sirius3
User
Beiträge: 17711
Registriert: Sonntag 21. Oktober 2012, 17:20

Statt Formeln zweimal im Code zu haben, definiert man sich Funktionen. a_oben und b_unten werden mit Werten initialisiert, die gleich durch einen Input überschrieben werden. Bei dieser mathematischen Formel würde man erwarten, dass man Kommazahlen eingeben kann.
Das a und das b sind verwirrend, was ist die Bedeutung der Variablen - a, b oder oben und unten?

Code: Alles auswählen

def integrated_f(x):
    # f(x) = (x- 2) * (x+2) = x**2 - 4
    return x**3 / 3   -  4 * x

def main():
    oben =  float(input("obere Grenze :"))
    unten = float(input("untere Grenze:"))
    print(integrated_f(oben) - integrated_f(unten))

if __name__ == "__main__":
    main()
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Code: Alles auswählen

[/
HALLO  IRIUS:
Herzlichen  Dank für dieses  geniale MEISTERSTÜCK.
Ich gehe mal davon aus, dass es sich  bei diesem Programm  um   das  "berüchtigte"  OOP -Konzept handelt.
An OOP habe ich mich  bisher noch nicht  heran gewagt. 
Jetzt versuche ich das  umgehend.   Ist halt auch nicht unbedingt Anfängersache.
.
Leider hat mein Programmier-Versuch nur bei ganz einfachen Funktionen 
des bestimmten Integrals scheinbar geklappt. 
Aber  eigentlich  kann  man nur aus den eigenen Fehlern lernen 
und professionelle Hilfe ist unersetzbar. 

Vielen Dank und gute Zeit  OSWALD
code]
Sirius3
User
Beiträge: 17711
Registriert: Sonntag 21. Oktober 2012, 17:20

Nein, da gibt es kein OOP. Das Programm ist rein prozedural.
Wenn Du wirklich mit Symbolen rechnen willst, hat Dir ja __blackjack__ schon sympy empfohlen.
Antworten