kleine Mathe-Spielereien

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

23.08.2022
Arbeiten mit scipy

Ein Versuch Kurvenfitting zu verstehen.

Anpassen einer Funktion an Daten aus einem Histogramm.
Ein Peak von normal (Gauß'schen) verteilten Daten Zeile 21
Exponentiell abklingender Hintergrund. Zeile 11
Durch gegenseitige Veränderung kann (optimal zunächst )
dann auch durch Verlauf der Exponentialfunktion
der Peak bei x = und umgekhrt der Peak (Normalverteilung)
verschoben werden. Art und Menge ()
So erklärt sich der Zusanmmenhang zwischen Datenmenge(size),
Art der Daten(angewandte Verteilung)
Neben dem Plot werden auh die Koordinaten angezeigt.

G ute Zeit OSWALD



Code: Alles auswählen



import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
 

# 2.) Define fit function.
def fit_function(x, A, beta, B, mu, sigma):
    return (A * np.exp(-x/beta) + B * np.exp(-1.0 * (x - mu)**2 / (2 * sigma**2)))

# 3.) Eexponential-Funktion und gauss-Daten sowie  Histogramm erzeugen
data = np.random.exponential(scale=2.0, size=100000)
data2 = np.random.normal(loc=3.0, scale=0.3, size=150000)
bins = np.linspace(0, 6, 61)
data_entries_1, bins_1 = np.histogram(data, bins=bins)
data_entries_2, bins_2 = np.histogram(data2, bins=bins)

# 4.) Add histograms of exponential and gaussian data.
data_entries = data_entries_1 + data_entries_2
binscenters = np.array([0.5 * (bins[i] + bins[i+1]) for i in range(len(bins)-1)])

# 5.) Fit the function to the histogram data.
popt, pcov = curve_fit(fit_function, xdata=binscenters, ydata=data_entries, p0=[20000, 2.0, 2000, 3.0, 0.3])
print(popt)

# 6.)
# Generate enough x values to make the curves look smooth.
xspace = np.linspace(0, 6, 100000)

# Plot the histogram and the fitted function.
plt.bar(binscenters, data_entries, width=bins[1] - bins[0], color='navy', label=r'Histogram Einträge')
plt.plot(xspace, fit_function(xspace, *popt), color='red', linewidth=2.5, label=r'Angepasster  Funktionsverlauf ')

# Make the plot nicer.
plt.xlim(0,10)
plt.xlabel(r'x - Achse')
plt.ylabel('Anzahl der Eintragungen')
plt.title('Exponentiell abfallend  mit ''Gauss peak')
plt.legend(loc='best')
plt.show()



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

Code: Alles auswählen

import numpy as np
import matplotlib.pyplot as plt
 



t = np.linspace(-10, 10, 100)
sig = 3/t*2
plt.axhline(y=0, color="black", linestyle="")
plt.axhline(y=0.5, color="black", linestyle="")
plt.axhline(y=1.0, color="black", linestyle="")
plt.axvline(color="red")
plt.axline((0, 0.5), slope=0.001, color="black", linestyle=(0, (5, 5)))
plt.plot(t, sig, linewidth=1, label="F(3/t*2)")
plt.xlim(-10, 10)
plt.xlabel("t")
plt.grid(True)
plt.title("Normal-Hyperbel mit den  beiden  Asymptoten")
plt.legend(fontsize=10)

plt.show()

Die Hyperbel scheint eine Diva zu sein , 
die sich zwar visuell gut darstellen lässt,
aber offenbar ihre Eigenschaft nur mittels
analytischer Geometrie durch Parameter 
ausführlich manipulieren lässt. 
Mir ist es jedenfalls nicht gelungen mit der
Formel f(1/x) ihre Normalform zu verändern.
Hier mein Versuch.

Gute Zeit   OSWALD






















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

28.08.2022
Zum Abschluss als letzter Kegelschnitt d er Kreis
Gute Zeit OSWALDÖ

Code: Alles auswählen

[
import matplotlib.pyplot as plt
import numpy as np
# Koordinaten setzen
x1 = - 2.5
x2 =   2.5
y1 = - 2.5
y2 =   2.5

radius =1.5

# Mittelpunkt =(0,0)
# 1* nachrechts  =(1,0)
# 1* nachoben    =(0.1)
# 1* nachlinks   =(-1,0)
# 1* nac hunten  =(0,-1)


circle1 = plt.Circle((0,0),radius, color = 'r', fill = False, clip_on = False)
fig, ax = plt.subplots()
ax.add_artist(circle1)
plt.axis("equal")
ax.spines['left'].set_position('zero')
ax.spines['bottom'].set_position('zero')
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
plt.xlim(left=x1)
plt.xlim(right=x2)
plt.ylim(bottom=y1)
plt.ylim(top=y2)
plt.axhline(linewidth=1, color='r')
plt.axvline(linewidth=1, color='r')

plt.title("Einheitskreis   mit Parametern  " ,color = "r")
plt.grid(color='r', linestyle='-', linewidth=0.3)
plt.show()
 


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

29.08.2022
Weil es soviel Spaß macht, habe ich jetzt noch zwei weitere KREISE
ins 'Spiel' gebracht . Man könnte sogar weitere Kreise hinzufügen.

Eigenschaften.: Beliebige Farben
beliebige Radien, leere und /oder gefüllte Kreise und
beliebige Positionen der Mittelpunkte auf dem Spielfeld.

Gute Zeit OSWALD

Code: Alles auswählen

#Das 3-Kreise-Spiewl
 
import matplotlib.pyplot as plt
import numpy as np
# Define limits of coordinate system
x1 = - 6
x2 =   6
y1 = - 6
y2 =   6

radius1 = 1.0
radius2 = 1.5
radius3 = 2.0

circle1 = plt.Circle((3,0), radius1 , color = 'g',fill = True, clip_on = False) 
circle2 = plt.Circle((0,0), radius2, color = 'r', fill = False, clip_on = False)
circle3=  plt.Circle((0,0), radius3 ,color = 'b', fill = False, clip_on = False)
 
fig, ax = plt.subplots()
ax.add_artist(circle1)

ax.add_artist(circle2) 
ax.add_artist(circle3) 
plt.axis("equal")
ax.spines['left'].set_position('zero')
ax.spines['bottom'].set_position('zero')
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')
plt.xlim(left=x1)
plt.xlim(right=x2)
plt.ylim(bottom=y1)
plt.ylim(top=y2)
plt.axhline(linewidth=2, color='k')
plt.axvline(linewidth=2, color='k')

##plt.grid(True)
plt.grid(color='r', linestyle='-', linewidth=0.5)
plt.show()



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

31.08.2022
Im Zusammenhang mitmatplotlib hätte ich eine kurze Frage an
die Experten: Ist bei den '3 Kreisen' das Vorliegen eines Isomorphismus
zu erkennen? Ja oder Nein genügt. Danke im Voraus
Gute Zeit OSWALD
OSWALD
User
Beiträge: 77
Registriert: Freitag 18. März 2022, 17:32

Code: Alles auswählen

import numpy as np
from scipy.cluster.vq import kmeans2
import matplotlib.pyplot as plt
#Erstellen Sie z, ein Array mit der Form (100, 2), das eine Mischung von Stichproben aus
#+ drei multivariaten Normalverteilungen enthält.

rng = np.random.default_rng()
a = rng.multivariate_normal([0, 6], [[2, 1], [1, 6.5]], size= 12)
b = rng.multivariate_normal([2, 0], [[1, -1], [-1, 3]], size=20)
                            
c = rng.multivariate_normal([6, 4], [[5, 0], [0, 1.2]], size=34)
z = np.concatenate((a, b, c))
rng.shuffle(z)
 

centroid, label = kmeans2(z, 3, minit='points')
centroid
 
#Wie viele Punkte hat jeder Cluster?

counts = np.bincount(label)
 
 
#Zeichnen Sie die Cluster.

w0 = z[label == 0]
w1 = z[label == 1]
w2 = z[label == 2]
plt.plot(w0[:, 0], w0[:, 1], '.', alpha=0.5, label='Cluster 0')
plt.plot(w1[:, 0], w1[:, 1], '.', alpha=0.5, label='cluster 1')
plt.plot(w2[:, 0], w2[:, 1], '.', alpha=0.5, label='Cluster 2')
plt.plot(centroid[:, 0], centroid[:, 1], 'k*', label='Schwerpunkte')
plt.axis('equal')
plt.legend(shadow=True)
plt.title(" 3 Cluster, 3 Schwerpunkte  ")

plt.show()




Dere Versuch in die Geheimnisse der Clusteranalyse
einzudringen wird sehr schwer sein und zeitaufwendig.
Diese ist vorhanden.
Zunächst der erste Code, der allerdings noch sehr wenig aussagt.
Deshalb müssen noch sehr viele Details geklärt werden.
Diese versuche ich in der Folge in einzelnen Programmen in der Folge
nach und nach zu zeiogen.
Gute Zeit OSWALD
OSWALD
User
Beiträge: 77
Registriert: Freitag 18. März 2022, 17:32

6.09.2022
eine weitere Visualisierung von Cluster mit Scipy:

Code: Alles auswählen

import  numpy as np
from numpy import array
from scipy.cluster.vq import vq, kmeans, whiten
import matplotlib.pyplot as plt

features  = array ([[ 1.9,2.3],
                   [ 1.5,2.5],
                   [ 0.8,0.6],
                   [ 0.4,1.8],
                   [ 0.1,0.1],
                   [ 0.2,1.8],
                   [ 2.0,0.5],
                   [ 0.3,1.5],
                   [ 1.0,1.0]])
whitened = whiten(features)
book = np.array((whitened[0],whitened[2]))
kmeans(whitened,book)
 
codes = 2
kmeans(whitened,codes)
(array([[ 2.3110306 ,  2.86287398],    # random
       [ 1.32544402,  0.65607529],
       [ 0.40782893,  2.02786907]]), 0.5196582527686241)
#  Anzahl der Daten bestimmen
pts =40
rng = np.random.default_rng()
a = rng.multivariate_normal([0, 0], [[4, 1], [1, 4]], size=pts)
b = rng.multivariate_normal([30, 10],
                            [[10, 2], [2, 1]],
                            size=pts)
features = np.concatenate((a, b))
# Alle Daten zusammenfügen
whitened = whiten(features)
# 2 Cluster in der Datenmenge gefunden
codebook, distortion = kmeans(whitened, 2)
# Plot whitened data and cluster centers in red
plt.scatter(whitened[:, 0], whitened[:, 1])
plt.scatter(codebook[:, 0], codebook[:, 1], c='r')
plt.title(" 2 Cluster, 2 Schwerpunkte(rot) ")
#plt.grid(True)


plt.show()











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

6.09.2022
und die letzte Cluster-Visualisierung.
Eine Erklärung folgt.

Code: Alles auswählen


import scipy 
from scipy.cluster import hierarchy
from scipy.cluster.hierarchy import dendrogram
import numpy as np
import matplotlib.pyplot as plt
  
# The data points are given as list of lists
data = np.array([
    [1, 4],
    [2, 2],
    [3, 7],
    [4, 6],
    [5, 1],
    [6, 3],
    [8, 10],
    [9, 11]
])
  
# Datenübernahme
x, y = data.T
  
# zunächst  Daten als Koordinaten zeigen
plt.scatter(x, y)
plt.title("zuerst Daten  als x/y Punkte plotten"  )
plt.grid(True)
plt.show()
 
# CDendrogramm  erstellen
# Z = linkage matrix
Z = hierarchy.linkage(data, method='average')
  
plt.figure(4)
plt.title("Daten aus  Matrix übernehmen")
  
# Dendrogram plotting using linkage matrix
dendrogram = hierarchy.dendrogram(Z)

 
# Creating Dendrogram for our data
# max_d = cut-off/ Werteschranke
max_d = 4
  
Z = hierarchy.linkage(data, method='average')
plt.figure()
plt.title("Beispiel für Dendrogramme ,S chranke =4")
dendrogram = hierarchy.dendrogram(Z)
  
# Cutting the dendrogram at max_d
plt.axhline(y=max_d, c='k')
plt.show




isualisierung von Clustern mit Scipy:
3 Methoden zur Illustration wurden ausgewählt,
aus Dutzenden Modellen und Algorithmen..

1. scipy.cluster.vq.kmeans2
Klassifizieren Sie eine Reihe von Beobachtungen mithilfe des k-Means-Algorithmus
in k Cluster.
Der Algorithmus versucht, den euklidischen Abstand
zwischen Beobachtungen und Schwerpunkten zu minimieren.
Mehrere Initialisierungsmethoden sind enthalten.
2. scipy.cluster.vq.kmeans
Führt k-Mittelwerte für einen Satz von Beobachtungsvektoren aus,
die k Cluster bilden.
3. scipy.cluster.hierarchy.linkage
Verknüpfung ( y , method = 'single' , metric = ' euclidan ' ,
optimale_ordering = False )
Hierarchisches/agglomeratives Clustering,
mitkomprimierter 1-D-Entfernungsmatrix oder ein 2-D-Array
von Beobachtungsvektoren.
Für alle Cluster gemeinsam gilt:
Bestimmung der Clusterzahl
Festlegung Clustermittelpunkt/Schwerpunkte
Berechnung der Mittelwerte
Zuteilung der Datenpunkte zu neuen Clustern
Clusterhierarchie/ Clusteralgorithmen
z.B Euklidischer Abstand zweier Punkte

Um Missverständnisse zu vermeiden:
Mit einer ' Cluster-Analyse ' im klassischen Sinne
haben diese Darlegungen nichts zu tun.
Die Anwendung einer Cluster-Analyse ist eine ganz andere Hausnummer.

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

12.09.2022
Jetzt kann man Daten einzeln mit Koordinaten eintragen.
Ein oft vermisstes Tool.
Gute Zeit OSWALD

Code: Alles auswählen


import matplotlib.pyplot as plt

plt.rcParams["figure.figsize"] =[ 8,8]
plt.rcParams["figure.autolayout"] = True

x = [3, 1, 3,3, 5,8 ]
y = [5, 2, 4,2, 3 ,5]
 
plt.plot(x, y, 'ro')
plt.axis([-10, 10, 10, 0])

for i, j in zip(x, y):
   plt.text(i, j+0.5, '({}, {})'.format(i, j))
plt.grid(True)
plt.title('Daten einzeln mit Koordinaten eintragen')
plt.show()
 


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

Kleine Korrektur:
oben handelt es sich um ein Streudiagramm.
Hier erfolgt der Eintrag von einzelnen Daten,
Gute Zeit OSWALD

Code: Alles auswählen

import numpy as np
import matplotlib.pyplot as plt

plt.rcParams["figure.figsize"] = [7.50, 7.50]
plt.rcParams["figure.autolayout"] = True

x = [3, 1, 2, 5,8]
y = [5, 2, 4, 7,4]

plt.plot(x, y, 'r*')
plt.axis([0, 10, 0, 10])

for i, j in zip(x, y):
   plt.text(i, j+1.0, '({}, {})'.format(i, j))
plt.grid(True)
plt.title()
plt.show()
 


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

Code: Alles auswählen


from sympy.solvers import solveset
from sympy import Symbol

x = Symbol('x')

print(solveset((x+4) *(x-7),x))
print(solveset(5*x**2 + 4*x -5, x))
print()
print(solveset((x-3) * (x+5) * (x-10),x))

print()
print(solveset(x**3 - 5,x))
print()
print(solveset(x**3-1,x))
   

import matplotlib.pyplot as plt
import numpy as np

# 100 linearly spaced numbers
x = np.linspace(-10,10,50,0.25)

# the function, which is y = x^2 here
y =  (x-3) * (x+5) * (x-10)



# setting the axes at the centre

fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.spines['left'].set_position('center')
ax.spines['bottom'].set_position('zero')
ax.spines['right'].set_color('none')
ax.spines['top'].set_color('none')
ax.xaxis.set_ticks_position('bottom')
ax.yaxis.set_ticks_position('left')

# plot the function
plt.plot(x,y, 'r')

# show the plot



plt.show()

Heute  geht es um die kubische Gleichung.
Generationen von Mathematikern haben sich um
Lösungen bemüht. Diese sind äusserst kompliziert
Übrigens bei dieser Gelegenheit  ist man erstmals 
auf komplexe Zahlen gestoßen.
Ich habe bei SymPy  gesucht und gefunden.
SymPy löst alle Gleichungen  beliebigen Grades.
Zusätzlich können mit diesem  Code auch alle 
untersuchten Funktionen visualisieret werden.
Es ist einfach genial,  was Python 3usammen mit 
seinen Bibliotheken leistet.
Und das alles  mit open source.
Ein Geschenk für die Wissenschaft!

Gute Zeit  OSWALD




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

23.09.2022
NUMPY und Polynoe
Fünf Funktionen

Gute Zeit OSWALD


Code: Alles auswählen


##########Summe  aller polynom- codes
print("Addition von zwei Polynomen)")

import numpy as np

from numpy.polynomial import polynomial as P
c1 = (1,2,3,7,6)
c2 = (3,2,1,5,7)
sum = P.polyadd(c1,c2); sum
#array([4.,  4.,  4.])
P.polyval(2, sum) # 4 + 4(2) + 4(2**2)
print("Summe    : ",P.polyval(2, sum) ) 

###################################
print("Subtraktion von Polynomen")
import numpy as np
from numpy.polynomial import chebyshev as C
c1 = (1,2,3)
c2 = (3,2,1)
print("Ergebnis c1-c2 "  ,C.chebsub(c1,c2))
print("Ergebnis c2-c1) :",C.chebsub(c2,c1))
##################################
print('Produkt von zwei beliebigen Polynomen')
import numpy as np
from numpy.polynomial import polynomial as P
c1 = (1,2,3)
c2 = (3,2,1)
P.polymul(c1,c2)
print("Ergebnis, neues array : ", P.polymul(c1,c2))
##############


print("Division von Polynomen")
print()
import numpy as np
from numpy.polynomial import polynomial as P
c1 = (1,2,3,5)
c2 = (3,2,1,3)
print("Division von c1 durch c2 ergibt :",  P.polydiv(c1,c2))


sum = P.polyadd(c1,c2); sum

P.polyval(2, sum)  
print("Summe    : ",P.polyval(1, sum) )  
print("Division von c2 durch c1 ergibt :",  P.polydiv(c2,c1))
 
sum = P.polyadd(c2,c1); sum
P.polyval(2, sum)  
print("Summe    : ",P.polyval(2, sum) ) 

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

print("Alle Elemente eines vorgebenen Polynoms potenzieren")
print()
import numpy as np
from numpy.polynomial import polynomial as P
P.polypow([1,2,3], 2) 
print("2.Potenz  der Arrayelemente ",P.polypow([1,2,3], 2))
print()
P.polypow([1,2,3], 3) 
print("3.Potenz  der Arrayelemente ",P.polypow([1,2,3], 3))
###################################
 
######################################


Die Ergebnisse kommen alle gleichzeitig
und sind deswegen eventuell nicht gut zu lesen..
Benutzeravatar
Dennis89
User
Beiträge: 589
Registriert: Freitag 11. Dezember 2020, 15:13

Hallo,

wenn du die Ergebnisse verzögert haben möchtest (also verzögert kommen die eh, aber sehr kurz), dann kannst du zwischen den 'print'-Anweisungen ein 'time.sleep' setzen.
'sleep' bekommt als Argument die Sekundenanzahl, für die das Programm schlafen soll. Das heißt in der Zeit wird nichts gemacht. Für 5 Sekunden also 'sleep(5)'.

Mir sind bei deinem Code ein paar ';' ins Auge geschossen, die brauchst du in Python nicht, du kannst die den Tastendruck sparen. Es passiert gar nichts wenn in einer Zeile nur 'sum' steht. Das kann also auch weg. Und an der Stelle noch ein Hinweis, es gibt in Python eine Funktion die 'sum' heißt. Vielleicht findest du für dein 'sum' einen anderen Namen, damit es keine Überschneidungen gibt.
Und was ich noch sagen wollte um dir etwas Tipparbeit zu ersparen, du hast in deinem Code 3 mal diese Zeile: 'from numpy.polynomial import polynomial as P'. Das ist nicht notwendig. Normal schreibt man alle importe die man benötigt ganz an den Anfang des Programcodes und die Importe kannst du dann im ganzen Programm so oft verwenden wie du willst. Es ist nicht nötig die Zeile nochmal irgendwo zu schreiben.

Selber Code, selbes Ergebnis (hoffentlich), nur etwas kürzer:

Code: Alles auswählen

from numpy.polynomial import polynomial as P
from numpy.polynomial import chebyshev as C

print("Addition von zwei Polynomen)")
c1 = (1, 2, 3, 7, 6)
c2 = (3, 2, 1, 5, 7)
sum = P.polyadd(c1, c2)
P.polyval(2, sum)
print("Summe    : ", P.polyval(2, sum))
print("Subtraktion von Polynomen")
c1 = (1, 2, 3)
c2 = (3, 2, 1)
print("Ergebnis c1-c2 ", C.chebsub(c1, c2))
print("Ergebnis c2-c1) :", C.chebsub(c2, c1))
print('Produkt von zwei beliebigen Polynomen')
c1 = (1, 2, 3)
c2 = (3, 2, 1)
P.polymul(c1, c2)
print("Ergebnis, neues array : ", P.polymul(c1, c2))
print("Division von Polynomen")
print()
c1 = (1, 2, 3, 5)
c2 = (3, 2, 1, 3)
print("Division von c1 durch c2 ergibt :", P.polydiv(c1, c2))
sum = P.polyadd(c1, c2)
P.polyval(2, sum)
print("Summe    : ", P.polyval(1, sum))
print("Division von c2 durch c1 ergibt :", P.polydiv(c2, c1))
sum = P.polyadd(c2, c1)
P.polyval(2, sum)
print("Summe    : ", P.polyval(2, sum))
print("Alle Elemente eines vorgebenen Polynoms potenzieren")
print()
P.polypow([1, 2, 3], 2)
print("2.Potenz  der Arrayelemente ", P.polypow([1, 2, 3], 2))
print()
P.polypow([1, 2, 3], 3)
print("3.Potenz  der Arrayelemente ", P.polypow([1, 2, 3], 3))


Weiterhin viel Erfolg
Dennis
“A ship is always safe at the shore, but that is not what it is built for.”
OSWALD
User
Beiträge: 77
Registriert: Freitag 18. März 2022, 17:32

Dennis, keine Geschäftsidee, mit 91 zu spät, ein reines Hobby.
Und wenn's gefällt, dann mir auch.
OSWALD
User
Beiträge: 77
Registriert: Freitag 18. März 2022, 17:32

Hallo Dennis89,
ich habe Dein Program herunter geladen und gestartet.
Als erstes sticht die Diszplin des Profis ins Auge.
Übersichtlich ,kein überflüssiges Wort und hervorragend lesbar...
Und besonders freut mich, dass Du meine Eregebnisse
bestätigen kannst..
Wenn ich ehrlich bin, mein Programm konnte ich nur schreiben,
weil die Bibliotheken so hervorragende Informationen liefern.
Danke
Gute Zeit OSWALD
Benutzeravatar
Dennis89
User
Beiträge: 589
Registriert: Freitag 11. Dezember 2020, 15:13

Hallo Oswald,

kurz zum Verständnis und abgesehen davon das ich Meilen weit vom Profi entfernt bin, den Code den ich hier geteilt habe, ist deiner.
Ich habe nur ein paar unnötige Sachen entfernt. Damit wollte ich dir zeigen, wie mit zwei drei wenigen Handgriffen dein Code etwas strukturierter und lesbarer wird.

Dass das bei dir nur Hobby ist (bei mir übrigens auch) verstehe ich und ich muss sagen es gefällt mir dir "zu zuschauen" wie du hier immer weiter machst. Gerade deswegen wollte ich dir einfache Tipps geben, damit du weniger Tipparbeit hast.

Naja wie dem auch sei, mach weiter so.
Viele Grüße
Dennis
“A ship is always safe at the shore, but that is not what it is built for.”
OSWALD
User
Beiträge: 77
Registriert: Freitag 18. März 2022, 17:32

23.09.2022
Hallo Dennis89 vielen Dank für Deine Zeilen.
Der Tip mit dem time.sleep() war super. Ich muss mich jetzt endlich mehr um
das Python selbst kümmern, da steckt noch eine Unmege von tollen
Funktionen und features drin. Bei mir steht im Vordergrund eigentlich nur die
Mathematik, die ihrerseits eigentlich die wichtigste Grundlage für die
Informatik ist. Nach langem Berufsleben ist das Hobby wichtig für die
seelische und körperliche Gesundheit.

Herzliche Grüsse
OSWALD


Wer immer strebend sich bemüht, den können wir erlösen. FII Goethe (leìider heute nicht mehr 'ìn'
OSWALD
User
Beiträge: 77
Registriert: Freitag 18. März 2022, 17:32

23.09.2022 Im Uusamenhang mit den gezeigten Polynom-Funktionen
durfte auch die mächtige EXPAND-Methode von Sympy von
großem Interesse sein..
Hier der der Code:

Code: Alles auswählen

from sympy import *
x, y, z = symbols('x,y,z')

print(((x + y)*(x - y)).expand(basic=True))
 
print(((x + y + z)**2).expand(basic=True))

print(((x+y)**1/3).expand(basic = True))

print(((sin(x)+ y)*(x - y)).expand(basic=True))

print(((log(x) + exp(y))*(x)).expand(basic=True))

print((((x) + (y))** 4).expand(basic=True)) 



Gute Zeit OSWALD
Antworten