kleine Mathe-Spielereien

mit matplotlib, NumPy, pandas, SciPy, SymPy und weiteren mathematischen Programmbibliotheken.
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Hallo ,ich bin Oswald, ein neues an Mathe interessiertes Mitglied hier im Forum.
Ich möchte hier ein einfaches Programm zur A uswertug beliebiger Mathe.Terms vorstellen und hätte dazu ein e Frage.
1. Wie genau sind die hiermit erhaltenen Werte.
2. Im RIPTutorial habe ich gelesen, dass Auswertungen 'eval' angeblich mit 'Vorsicht' anzuwenden sind.
Für eventuelle Beratung wäre ich danbar. Bin totaler Anfänger in Python.
Oswald




############################# Autor Oswald am 3.4.22 ################
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("")

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) 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 hier alle Terme zur Auswertung eintragen :" , )

print ()
print ()
print("Ergebnis = :", eval(p))
Sirius3
User
Beiträge: 17710
Registriert: Sonntag 21. Oktober 2012, 17:20

Eingerückt wird mit 4 Leerzeichen pro Ebene, nicht 8. Variablennamen schreibt man nach Konvention komplett klein. *-Importe verwendet man nicht, weil man damit unkontrolliert Namen in den eigenen Namensraum schaufelt.
Einen Kommentar leitet man mit einem # ein, nicht mit 29.
Wenn Du die Exponentialfunktion meinst, dann benutze die auch, obwohl ich nicht genau nachvollziehen kann, was Du da so kompliziert ausrechnen willst, weil beide W-Funktionen `Rad ** (1/Wp)` ergeben. Gerundet wird erst bei der Ausgabe, nicht zwischendrin.

`eval` werte beliebige Python-Ausdrücke aus. Wenn Du mit Formeln arbeiten willst, dann gibt es dafür das sympy-Paket.
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Herzlchen Dank für die freundlichen Hinweise.
Ich werde in Zukunft die Python-Kondiditionen besser einhalten.
Es geht mir vornehmlich um' learning by doing'.
A nalog ist das sobei bei meinem nächsten Versuch , wo ich
die Funktion 'lambda' verstehen will.

print("Versuch: Ganze u. Gleitkommazahlen als Radikand u.Wurzelexponenten testen ")
Radikand = float(input("Radikand eingeben:", ))
##############################
for y in{ 2,3,4,5,6,7,8,9,10, 15.2, 10.4 }:
wert =lambda x,y : x **(1/y)
print(y-1 , ".te Wurzel aus",Radikand , " = ", wert(Radikand , ( y -1) ))
##############################

Der Code läuft auf D LE ebenso wie auf Spyder5
Sirius3
User
Beiträge: 17710
Registriert: Sonntag 21. Oktober 2012, 17:20

Warum nimmt y die Werte {2, 3, 4, 5, 6, 7, 8, 9, 10, 10.4, 15.2} an, wo Du doch mit {1, 2, 3, 4, 5, 6, 7, 8, 9, 9.4, 14.2} rechnen willst?
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Der Code funktioniert so:
die aufghelisteten Zahlen stehen für die '2.,3.,4.,..... oder auch 4.4., 5.3. Wurzel , die aus dem vorgegebenen Radikanden 'gezogen' werden.
Die Frage war zu beantworten, ob der Radikand eine Ganzzahl gegeben sein muss oder nicht,
und ob auch der Wurzelexponent eine Ganzzahl sein muss oder nicht.
Mit der Schleife wird quasi eine 'Tabelle aufgestellt, aaus der beliebig viele WSurzeln gleichzeitig verglichen werden können.
Auf euinen Blick können also die Fragen beantwortet werden.
Aus den entstehenden Zahlenreihen kann eine Kurve kostruiert, geplottet werden, aus der wiederum eine
Funktion angenähert werden kann. Es entsteht dabei keine Hyperbel, sondern eine normale Potentialfunktion.
Dasa Orinzip: 'Spielerisch lernen.'
Einfach den Code testen.
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

import matplotlib.pyplot as plt

x = ([1, 2, 3, 4, 5, 6, 7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26])

y = ([7.0710678118654755,
3.6840314986403864,
2.6591479484724942,
2.1867241478865562,
1.9193831036664843,
1.7486786215901433,
1.6306894089533097,
1.5444521049463789,
1.4787576366283137,
1.4270914972418183,
1.3854180248814744,
1.3511077973389822,
1.3223761271250098,
1.2979700365523266,
1.2769844983214595,
1.2587497926444526,
1.2427598742099695,
1.2286253559934777,
1.2160417906586574,
1.2047677500064513,
1.1946093492191572,
1.1854091114771534,
1.1770378179487158,
1.1693884504284608,
1.1623716261759758,
1.1444192979749988])



plt.scatter(x, y , label= "Wurzelwerte", color= "green", marker= "*", s=30)
plt.xlabel('x - axis')
plt.ylabel('y - axis')
plt.title('2. bis 26.Wurzel aus Radikand= 50')
plt.legend()

plt.show()
############################################
Hier der einfache Code der auf Spyder 5 einwandfrei läuft.
Die Anwendung von Sympy scheint bis notwendig.
Daten :
y= 2. bis 26. Wurzel aus Radikand = 50.
x = Aufzählung der gewünschen Wurzelradikanden.
Die erhaltene Kurve scheint eine Funktion von der Form 1/x^n zu sein.
Beweisen kann ich das nicht. Dazu reichen meine math. Kenntnisse nicht aus
Ich suche jetzt nach Methoden zum Kurvenfitting auf Python.
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Ergebnis der Auswertungen: :Die Form der erhaltenen Kurve gilt für alle Radikanden , aus denen eine beliebige Anzahl
von Wurzelexponenten gezogen wird .
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Beweis: stark verändeter Radikand (75000) mit identischer Kurve, aber anderen Wurzelwerten


import matplotlib.pyplot as plt


x = ([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26])
y = (
[16.54875459823436,
9.440875112949021,
6.493968991694328,
4.970926289657111,
4.068016051865376,
3.480755144650198,
3.072600708349365,
2.774516983497041,
2.548326704269750,
2.371399437791221,
2.229557420130083,
2.113508915768935,
2.016932336957632,
1.935389183833116,
1.865678199650255,
1.805436306841428,
1.752883541011667,
1.706655145443353,
1.665688141128777,
1.629142919944965,
1.596347927072839,
1.566759910630817,
1.539934881022967,
1.515506573893690,
1.493170258252582,
1.472670410238526])







plt.scatter(x, y, label="Wurzelwerte", color="green", marker="*", s=30)

plt.xlabel('x - axis')
plt.ylabel('y - axis')
plt.title('2. bis 26.Wurzel aus Radikand= 75000')
plt.legend()

##############################
Sirius3
User
Beiträge: 17710
Registriert: Sonntag 21. Oktober 2012, 17:20

Du hast wirklich eine seltsame Art, die 4te Wurzel 2te-Wurzel zu nennen.
Man schreibt das ja auch nicht selbst aus

Code: Alles auswählen

RADIKAND = 75000
x = range(4, 29)
y = [RADIKAND ** (1/k) for k in x]
plt.scatter(x, y, label="Wurzelwerte", color="green", marker="*", s=30)

plt.xlabel('x - axis')
plt.ylabel('y - axis')
plt.title(f'{min(x)}. bis {max(x)}. Wurzel aus Radikand={RADIKAND}')
plt.legend()
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Ich bitte das Versehen zu entschuldigen.
Jetzt stelle ich als Bedispiel die' Verteilung' der insgesamt 62 Primzahlen im Zahlenraum von 1-300 vor.
Über die Verteilung der Primzahlen gibt es sehr viel Literatur. Wie geht es ' oben' weiter ? . ich werde einmal den Bereich
zwischen 10000-10300 untersuchen.

import matplotlib.pyplot as plt


x = ([1,2,3,4,5,6,7,8,9,10,
11,12,13,14,15,16,17,18,19,20,
21,22,23,24,25,26,27,28,29,30,
31,32,33,34,35,36,37,38,39,40,
41,42,43,44,45,46,47,48,49,50,
51,52,53,54,55,56,57,58,59,60,
61,62])
y= ([2,3,5,7,11,13,17,19,23,29,
31,37,41,43,47,53,59,61,67,71,
73,79,83,89,97,101,103,107,109,113,
127,131,137,139,149,151,157,163,167,173,
179,181,191,193,197,199,211,223,227,229,
233,239,241,251,257,263, 269,271,277,281,
283,293])






plt.scatter(x, y, label="Primzahlenverteilung" , color="green", marker=".", s=62)

plt.xlabel('x - axis')
plt.ylabel('y - axis')
plt.title('62 Primzahlen sind innerhalb von( 1-300) enthalten')
plt.legend()
#############
Python macht Spaß . Gruß OSAWLD
Sirius3
User
Beiträge: 17710
Registriert: Sonntag 21. Oktober 2012, 17:20

Und auch hier würde man sich eine Funktion schreiben, die Primzahlen berechnet, statt sie händisch in eine Liste zu schreiben. Das wäre auch eine schöne Mathematische Spielerei und außerdem eine gute Möglichkeit Python zu lernen.
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Ich benütze bereits ein kleines Programm, mit dem ich alle Primzahlen auflisten kann.
Nach einer Veränderung kann ich alle Primzahlen von beliebigem Minimal- bis Maximalwert
ausdrucken.
Dazu habe ich eine jur.Frage. Darf ich hier im Forum diesen kurzen Code nach meiner Veränderung
anzeigen ? Die Veränderungen durch mich sind klar gekennzeichnet.
__deets__
User
Beiträge: 14493
Registriert: Mittwoch 14. Oktober 2015, 14:29

Die Frage koennen wir nicht beantworten, wir haben den urspruenglichen Code ja nicht geschrieben. Und davon haengt das letztlich ab.
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

0 me

Zeile......
Ich darf hier wenigstens den von mir erzeugten Code zeigen und dazu die zwei letzten Zeinen des Originalcodes. 10 if n % i == 0:
11 return False
12 return True


########## die Zeilen 15 bis 25 von Oswald ergänzt#####################
15meineliste = []
16maxwert = int(input("Maximalwert", ))
17for s in range(minwert,maxwert):
18 if prim(s) == True:
19 print(s+1)
2ineliste.append(prim(s))
21print(len(meineliste) )
22 ####################


Damit kann ich beliebige Wertebereiche auf Primzahlen prüfen, diese ausdrucken und zusätzlich die Anzahl der Primzahlen
ermitteln und ausdrucken
Damit konnte folgendes festgestellt werden:
Im Bereich von 1-300 war die Anzahl der Primzahlen bei 62. In höheren gleich gorßen Wertebereichen
war die Anzahl der Primzahlen wesentlich geringer, z.B. zwischen 20000 und 20300 liegt sie nur bei 31.
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

ntschuldigung
Eine Zeile des Codes ging irgendwie verloren. Hier erneut.


########## Zeilen 15 bis 25 von Oswald ergänzt
meineliste = []
minwert = int(input("Mininalwert:", ))
maxwert = int(input("Maximalwert", ))
for s in range(minwert,maxwert):
if prim(s) == True:
print(s+1)
meineliste.append(prim(s))
print(len(meineliste) )
##########
Benutzeravatar
__blackjack__
User
Beiträge: 13003
Registriert: Samstag 2. Juni 2018, 10:21
Wohnort: 127.0.0.1
Kontaktdaten:

@OSWALD: Es ist nicht wirklich sinnvoll für jede Primzahl den gleichen Wert (`True`) an eine Liste anzuhängen wenn am Ende nur die Länge dieser Liste von Interesse ist. Das das keinen Sinn macht, würde man eventuell auch bemerken wenn man versuchte den schlechten Namen `meineliste` durch einen Namen zu ersetzen der die Bedeutung der Werte in dieser Liste sinnvoll und verständlich beschreibt.

Man vergleicht nicht mit literalen Wahrheitswerten. ``prim(s) == True`` ergibt `True` wenn ``prim(s)`` wahr ergibt und `False` wenn ``prim(s)`` unwahr ergibt, also kann man auch gleich einfach das Ergebnis von ``prim(s)`` direkt verwenden. Wenn man auf das Gegenteil testen möchte, gibt es ``not``.

`s` ist an der Stelle übrigens auch ein schlechter Name.

Warum wird ``s + 1`` ausgegeben und nicht der Wert von `s`?

Und Dir ist klar, dass `range()` den angegebenen Endpunkt *nicht* mehr enthält‽
“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

Danke für die Hinweise.
Bin gerade dabei geschätzten Hinweise.
Bin gerade dabei , Python u.Co zu lernen und in der typischen Phase , in der man steckt,
wenn man glaubt, nicht mehr weiter zu kommen.
Ich bin schon Rentner (90) und betreibe das Ganze als 'Übung für die grauen Zellen. Nicht mehr und nicht weniger.
Ein Hobby für und mit Zahlen.
Vor langen Jahren habe ich mit Visual C++ , Visual Foxpro usw. bef asst, als es das phantastische Python
noch gar nicht gab. -
Warum bin ich überhaupt hier im Forum Mitglied geworden.?
Habe hier viel gelesen und gelernt.
In Python habe ich bisher an Sqlite 3, GUI , Mathplotlib , Numpy 'geschnuppert' und meine private Sreuererklärung, sowie mit meiner ' Stromverbrauch-Datenbank' gespielt. Immerhin kann ich meinen Stromverbrauch und Kosten kontrollieren.
Gute Zeit mit Python.
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Mit dem folgenden Code können bis in den Millionenbereich und mehr
hinauf aus beliebigen Zahlenräumen jeweils die Primzahlen und ihre Amzahl
im Bereich werden. C ode läuft auf IDLE u.Spyder 5.
#####################################
import math

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


meineliste = []

minwert = int(input("Untergrenze:", ))
maxwert = int(input("Obergrenze", ))

for s in range(minwert,maxwert):
if test(s) == True:
print(s+1)
meineliste.append(test(s))

print(len(meineliste) )
##################################### ###
Sirius3
User
Beiträge: 17710
Registriert: Sonntag 21. Oktober 2012, 17:20

Warum testest Du die Teilbarkeit durch 2 zweimal? Der Code ist übrigens falsch, oder hast Du schon `test(1)` probiert?
OSWALD
User
Beiträge: 346
Registriert: Freitag 18. März 2022, 17:32

Hallo Sirius , bin wieder an Bord:
Anbei zunächst der korrekte Code. Er funktioniert von beliebiger ' Untergrenze bis Maximalwert'.
Mit dem Rest , Zahl der jeweiligen A nzahl vonPrimzahlen pro Intervall kämpfe ich noch.
Muss eben noch sehr viel Python lernen. Kann dauern.

#############
mport math

def prim(n):
if n == 2:
return True
if n % 2 == 0:
return False
else:
for i in range(2,int(math.sqrt(n))+1):
if n % i == 0:
return False
return True
unten = int(input ("Anfangswert :", ))
oben = int(input("Maximalwert eingeben: "))


for i in range(unten,oben):
if prim(i) == True:

print(i)
#############
Frohe Ostern Oswald
Antworten