matplotlib Diagramm verbreitern?

Ich habe mit pandas ein Wörterbuch (data) ausgelesen und mit matplotlib eine Grafik erstellt:

import matplotlib.pyplot as plt
import pandas as pd

S = pd.Series(data)
S.plot(kind="bar", rot=90)
plt.plot()
plt.show()

Bild zum Beitrag

Das Problem ist, dass es 778 Balken sind (sein sollten) und man deshalb die Beschriftung der X-Achsen nicht mehr sehen kann.

Wie kann ich das Diagramm, also so in die Breite ziehen, dass man alle X-Achsen Beschriftungen sehen kann?

Vielen Dank für eure Antworten.

1 Antwort

Vom Fragesteller als hilfreich ausgezeichnet

wiiha

08.11.2019, 19:00

Du kannst den plot in eine figure speichern, und die größe der figure einstellen, z.B. sowas:

fig, ax = plt.subplots(nrows=1, ncols=1 ,figsize=(10,5))

Oder zeige nicht Werte der x-achse an falls es nicht unbedingt notwendig ist. Ich glaube das geht mit plt.xticks(). Du kannst auch versuchen die Beschriftung zu drehen, falls das sinnvoll ist, z.B. mit plt.xticks( rotation = 90 ).

Scamander1926

Fragesteller

08.11.2019, 19:07

Vielen Dank für deine Antwort, kannst du mir das mit der Figur nochmal genauer erklären oder mir einen Link schicken? Das habe ich noch nicht ganz kapiert.

Die Schrift ist schon um 90Grad gedreht und mir ist die x-Achsen Beschriftung wichtig.

wiiha

08.11.2019, 19:15

@Scamander1926

Eine figure ist sowas wie ein virtuelles leeres Blatt, und dort kannst du dann deine plots rein speichern (z.B. mehrere übereinander legen, oder nebeneinander mit subplots). Die figure sollte man jedenfalls nach Gebrauch schließen, plt.close(fig). Siehe hier: https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.figure.html

Hier ist aber kein gutes Forum für sowas. Suche auf Englisch, und du wirst sehen dass etliche Leute vor dir dasselbe Problem hatten. Das Netz ist voll mit Lösungsvorschlägen dafür.

Ähnliche Fragen

Python (Lineare Regression)?

Hallo ihr Lieben,

meine Gruppe und ich haben Probleme bei einer Aufgabe und hoffen uns kann hier jemand behilflich sein.

Wir müssen eine Lineare Regression mit zwei Merkmalen durchführen und in einem Scatter Plot mit einer Regressionsgeraden repräsentieren.

Ich füge euch ein Bild hinzu, damit ihr sehen könnt was wir bis jetzt haben, nur haben wir Probleme die Regressionsgerade hinzuzufügen.

Wir haben versucht Befehle wie plot_regression_line (x, y) oder plt.plot(x, ymodel) zu benutzen, hat aber leider nichts gebracht und wir kommen absoulut nicht weiter. Zudem wissen wir nicht unter was die regression fällt und ob import matplotlib.pyplot as plt ausreicht oder ob es numpy oder etwas anderes sein muss.

Vielen Dank im Voraus!

...zur Frage

Python: Balkendiagramm beim Sortieren?

Hallo,

ich wollte ein Sortierverfahren programmieren und bei jedem Durchlauf durch das Array soll ein Balkendiagramm erzeugt werden.

Die sortierten Zahlen sollen rot sein und die unsortierten blau.

Bisher habe ich es geschafft, dass die sortierte Liste als Balkendiagramm angezeigt wird. Mein Programm sieht so aus:

def Sortierverfahren_Bubblesort(Liste):
  n = len(Liste)
  for i in range(n):
    for x in range(0, n - i - 1):
      if Liste[x] > Liste[x + 1]:
        Liste[x], Liste[x + 1] = Liste[x + 1], Liste[x]

Sortierverfahren_Bubblesort(Liste)
print("Sortierte Liste: ", Liste)

#Balkendiagramm
import matplotlib.pyplot as plt
import numpy as np

bar_width = 0.5
index = np.arange(len(Liste))
plt.bar(index, Liste, bar_width, color="blue")
plt.xticks(index, range(len(Liste)))
print("Balkendiagramm: ")
plt.show()

Es wäre cool, wenn mir jemand die Lösung dazu sagen würde.

...zur Frage

Koch Kurve Plotten?

Hallo an alle,
ich habe ein kleines Python Skript geschrieben um die Koch Kurve zu plotten jedoch ist das Ergebnis nicht ganz das was ich mir erhofft habt. irgendwie wird nur ein Teil der Schneeflocke geplottet und ich weiß nicht wieso. Vielleicht kann mir ja jemand helfen. Mein Code sieht wie folgt aus

import numpy as np
import matplotlib.pyplot as plt

def KochKurve(A,B,depth):
   L = []
   if depth == 0:
      L.append(A)
      L.append(B)
   else:
      R = np.array([[np.cos(np.pi/3), -np.sin(np.pi/3)],[np.sin(np.pi/3), np.cos(np.pi/3)]])
      C = A + (B-A)/3
      D = A + 2*(B-A)/3
      E = C + R@(D-C)
      L = KochKurve(A,C,depth-1) + KochKurve(C,E,depth-1) + KochKurve(E,D,depth-1) + KochKurve(D,B,depth-1)
   return L

if __name__ == "__main__":
   L = KochKurve(np.array([0,0]),np.array([1,0]),4)
   L = np.array(L)
   plt.plot(L[:,0],L[:,1])
   plt.axis("scaled")
   plt.axis("off")
   plt.show()

Das hier ist meine Ausgabe:

...zur Frage

Python Plot live Update?

Hi zusammen.

Ich möchte in Python einen Live-Plot haben (siehe Beispielanimation hier: https://pythonprogramming.net/static/images/matplotlib/live-matplotlib-graph-tutorial.gif).Das ganze funktioniert bisher, jedoch nur in einem separaten Figure Window. Ich möchte nun diesen "animierten" Plot mit "canvas" auf eine "tkinter" GUI bringen. Beim Ausführen wartet er aber immer ab, bis die komplette Schleife durchlaufen ist und plotted dann nur das Gesamtergebnis. Ich sehe keine Live-Updates. Eine Idee, wie man das hinbekommt?

Ohne die tkinter GUI kann man das erreichen mit matplotlib.pyplot.pause(). Wenn ich das bei canvas anwende, öffnet er an der Stelle aber wieder ein separates Figure. Er updated den Plot nicht in der GUI.

from tkinter import *

from matplotlib.backends.backend_tkagg import (

FigureCanvasTkAgg, NavigationToolbar2Tk)

import matplotlib.pyplot as plt

import time

root = Tk()

figId = plt.figure(1)

plot1 = plt.subplot(211)

plot2 = plt.subplot(212)

plt.draw()

canvas = FigureCanvasTkAgg(figId, master=root)

canvas.get_tk_widget().pack()

vals1 = [5, 6]

vals2 = [-3, 9]

i = 0

while(i<2):

plot1.plot(i,vals1[i],'x')

plot2.plot(i,vals2[i],'x')

i += 1

time.sleep(2)

...zur Frage

Eingabe in Textfeld in eine Datei einfügen (Python)?

Ich möchte in ein Textfeld (tkinter) etwas eingeben und dies dann eine Datei eingeben lassen.

Hier ist mein bisheriger Code (Bin Anfänger):

import tkinter as tk

name = tk.Tk()

entry1 = tk.Entry(name, width = 20)
entry1.pack()

data = open("datei.txt","w")

data.write(entry1)

data.close()

...zur Frage

Wie kann ich meine Python-Funktion zum Zeichnen eines Graphs anpassen?

Hallo,

ich möchte eine Funktion schreiben, die a und b zufällig zwischen 0 und 10 bestimmt, und anschließend einen Graph mit

für -10 < x < 10 zeichnen.

Ich habe einen Code geschrieben, der allerdings immer unterschiedliche a- und b-Werte nutzt, deswegen kommt am Ende keine sinnvolle Funktion heraus.

Habt ihr eine Idee, wie ich das anpassen kann?

Viele Grüße.

import matplotlib.pyplot as plt
import random

def Zufallszahl():
  return random.random() * 10

def Graph(xunten, xoben):
  xs = range(xunten, xoben + 1)
  ys = []
  tupel = (Zufallszahl(), Zufallszahl())

  for x in xs:
    y = tupel[0] * (x ^ 3) + tupel[1]
    ys.append(y)
    print(tupel[0])
    print(tupel[1])

  plt.plot(xs, ys)
  plt.xlabel("X")
  plt.ylabel("Y")
  plt.title("f(x) = a * x ^ 3 + b Random Plot")
  plt.show()

Graph(-10, 10)

...zur Frage

Tipps für das Trainieren eines Neuronalen Netzes?

Hallo zusammen,

ich möchte versuchen, ob ich einem neuronalen Netz beibringen kann, Aktien-Kurse vorherzusagen.
Bzw. einfacher gesagt Aktien in Kaufenswert und Nicht-Kaufenswert zu Clustern.

Ich hab schon verschiedene Aktivierungsfunktionen getestet, ich habe schon verschiedene Lernraten getestet. Und ich habe schon verschieden viele Schichten mit verschieden vielen Neuronen getestet.

Allerdings sieht das Ergebnis nie so wirklich gut aus. Jetzt weiß ich nicht, ob ich was falsch mache oder ob meine Daten Müll sind.

Hätte hier jemand Tipps für mich?

So sieht mein Code aus:

import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.callbacks import EarlyStopping
import matplotlib.pyplot as plt


# Daten einlesen
data = pd.read_csv("data1.csv")


# Input und Output Daten extrahieren
X = data.iloc[:, -7:].values
y = data.iloc[:, 3].values.reshape(-1, 1)


# Input Daten skalieren
scaler = MinMaxScaler()
X = scaler.fit_transform(X)


# Median der Output Daten berechnen
median = np.median(y)


# Output Daten in gute und schlechte Werte einteilen
y = np.where(y > median, 1, 0)


# Neuronales Netz definieren und trainieren
model = keras.Sequential([
    keras.layers.Dense(2048, input_dim=7, activation='relu'),
    keras.layers.Dense(512, activation='relu'),
    keras.layers.Dense(512, activation='relu'),
    keras.layers.Dense(2, activation='relu'),
    keras.layers.Dense(1, activation='sigmoid')
])


learning_rate = 0.001
optimizer = keras.optimizers.Adam(lr=learning_rate)
model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])


early_stopping = EarlyStopping(monitor='val_loss', patience=10)
history = model.fit(X, y, epochs=1000, batch_size=10, validation_split=0.2, callbacks=[early_stopping])


# Vorhersagen treffen und Genauigkeit auswerten
y_pred = np.round(model.predict(X))
accuracy = np.mean(y_pred == y)
false_positives = np.sum((y_pred == 1) & (y == 0))
false_negatives = np.sum((y_pred == 0) & (y == 1))
true_positives = np.sum((y_pred == 1) & (y == 1))
true_negatives = np.sum((y_pred == 0) & (y == 0))


# Ergebnisse ausgeben
print("Genauigkeit:", accuracy)
print("Falsch-Positiv:", false_positives)
print("Falsch-Negativ:", false_negatives)
print("Wahr-Positiv:", true_positives)
print("Wahr-Negativ:", true_negatives)
print("Wahr: ", true_positives + true_negatives)
print("Falsch: ", false_positives + false_negatives)

# Verlauf der Genauigkeit und des Fehlers während des Trainings darstellen
fig, ax = plt.subplots()
ax.plot(history.history['loss'], label='Trainingsfehler')
ax.plot(history.history['val_loss'], label='Validierungsfehler')
ax.set_xlabel('Epochen')
ax.set_ylabel('Fehler')
ax.legend()
fig.savefig('error.png')

...zur Frage

SwiftUI ObservableObject muss raus?

Ich bekomme andauernd den Fehler "Cannot preview in this file" und glaube den Fehler im ObservableObject gefunden zu haben. Das Problem ist halt, dass ich einige Lösungen im Internet benutzt habe, die mich anfangs weitergebracht haben aber jetzt mich dran hindern weiterzukommen. Auf jeden Fall glaube ich, dass das ObservableObject weg muss aber ich scheitere dran wie ich es rausnehme.

Ich vermute es, da mir einer andere Meldung folgendes sagt:

Thread 1: Fatal error: No ObservableObject of type ModelData found. A View.environmentObject(_:) for ModelData may be missing as an ancestor of this view.

Da ich nach meinem Verständnis aber eigentlich kein ObservableObject brauche denke ich muss es raus.

Für Alternativen und einer Belehrung bin ich trotzdem offen ^^

import SwiftUI

struct CategoryHome: View {
   @EnvironmentObject var modelData: ModelData

    var body: some View {
        NavigationView {
            List{
                
                Image("Denkmal")
                              .resizable()
                              .scaledToFill()
                              .frame(height: 200)
                              .clipped()
                              .listRowInsets(EdgeInsets())
                
                
               ForEach(modelData.categories.keys.sorted(), id: \.self) { key in
                    CategoryRow(categoryName: key, items: modelData.categories[key]!)
                }
                .listRowInsets(EdgeInsets())
                
            }
            .navigationTitle("Featured")
             


        }
    }
}

struct CategoryHome_Previews: PreviewProvider {
    static var previews: some View {
        CategoryHome()

    }
}

import Foundation
import Combine

final class ModelData: ObservableObject {
    @Published var GeschichteJN: [GeschichteDekl] = load("GeschichteData.json")
  

  

    var categories: [String: [GeschichteDekl]] {
        Dictionary(
            grouping: GeschichteJN,
            by: { $0.category.rawValue }
        )
    }
}

func load<T: Decodable>(_ filename: String) -> T {
    let data: Data

    guard let file = Bundle.main.url(forResource: filename, withExtension: nil)
        else {
            fatalError("Couldn't find \(filename) in main bundle.")
    }

    do {
        data = try Data(contentsOf: file)
    } catch {
        fatalError("Couldn't load \(filename) from main bundle:\n\(error)")
    }

    do {
        let decoder = JSONDecoder()
        return try decoder.decode(T.self, from: data)
    } catch {
        fatalError("Couldn't parse \(filename) as \(T.self):\n\(error)")
    }
}

...zur Frage

Ki auf Raspberry Pi?

Hallo Leute ich habe ein Video bei YouTube gesehen wo einer einen gpt voice assistent in Python Code auf einen Raspberry Pi installiert und benutzt. Ich habe dass mal ausprobiert aus Spaß und hätte gerne gewusst wie man 1. Eine weibliche Stimme statt einer Männlichen Stimme benutzen kann und 2. Die Sprachausgabe in Deutsch einstellen kann habe den Python Code mal hier rein kopiert hoffe ihr könnt mir helfen. Ein paar Sachen habe ich wie zum Beispiel language en auf de umgestellt leider klappt dass nicht so ganz.

Danke im vorraus

import os

import openai

from dotenv import load_dotenv

import time

import speech_recognition as sr

import pyttsx3

import numpy as np

from gtts import gTTS

import subprocess

mytext = 'Welcome to me'

language = 'en'

# from os.path import join, dirname

# import matplotlib.pyplot as plt

# ^ matplotlib is great for visualising data and for testing purposes but usually not needed for production

openai.api_key=' '

load_dotenv()

model = 'gpt-3.5-turbo'

# Set up the speech recognition and text-to-speech engines

r = sr.Recognizer()

engine = pyttsx3.init("dummy")

voice = engine.getProperty('voices')[1]

engine.setProperty('voice', voice.id)

name = "YOUR NAME HERE"

greetings = [f"whats up master {name}",

"yeah?",

"Well, hello there, Master of Puns and Jokes - how's it going today?",

f"Ahoy there, Captain {name}! How's the ship sailing?",

f"Bonjour, Monsieur {name}! Comment ça va? Wait, why the hell am I speaking French?" ]

# Listen for the wake word "hey pos"

def listen_for_wake_word(source):

print("Listening for 'Hey'...")

while True:

audio = r.listen(source)

try:

text = r.recognize_google(audio)

if "hey" in text.lower():

print("Wake word detected.")

engine.say(np.random.choice(greetings))

engine.runAndWait()

listen_and_respond(source)

break

except sr.UnknownValueError:

pass

# Listen for input and respond with OpenAI API

def listen_and_respond(source):

print("Listening...")

while True:

audio = r.listen(source)

try:

text = r.recognize_google(audio)

print(f"You said: {text}")

if not text:

continue

# Send input to OpenAI API

response = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=[{"role": "user", "content": f"{text}"}])

response_text = response.choices[0].message.content

print(response_text)

#myobj = gTTS(text = response_text, lang = language, slow = False)

#myobj.save("test.wav")

#os.system("aplay test.wav")

# Speak the response

print("speaking")

os.system("espeak ' "+response_text + "'")

engine.say(response_text)

engine.runAndWait()

if not audio:

listen_for_wake_word(source)

except sr.UnknownValueError:

time.sleep(2)

print("Silence found, shutting up, listening...")

listen_for_wake_word(source)

break

except sr.RequestError as e:

print(f"Could not request results; {e}")

engine.say(f"Could not request results; {e}")

engine.runAndWait()

listen_for_wake_word(source)

break

# Use the default microphone as the audio source

with sr.Microphone() as source:

listen_for_wake_word(source)

...zur Frage

Wie kann ich meinen Python-Code schneller machen?

Hallo,

ich habe gestern in Python ein paar Funktionen geschrieben, die mir ein interessantes Bild ausrechnen sollen. Ich kriege es jedoch nicht hin, dass das Programm einigermaßen schnell läuft und am Ende muss auch die Auflösung darunter leiden

Wenn da mal jemand drüberschauen könnte, wäre das wirklich hilfreich.

import numpy as np
import matplotlib.pyplot as plt
from math import pi, sqrt, atan

#Punkt definieren
class point:
    def __init__(self,x=0,y=0,z=0):
        self.x = x
        self.y = y

    #Operationen
    def __str__(self):
        return "({0},{1})".format(self.x, self.y)

    def __add__(self, other):
        return point(self.x+other.x,self.y+other.y)

    def __sub__(self, other):
        return point(self.x - other.x, self.y - other.y)

    def __abs__(self):
        return sqrt(self.x**2 + self.y**2)

    def __mul__(self, other):
        if type(other) == point:
            return point(self.x * other.x, self.y * other.y)
        return point(self.x * other, self.y * other)

    def __truediv__(self, other):
        if type(other) == point:
            return point(self.x / other.x, self.y / other.y)
        return point(self.x / other, self.y / other)

    def __neg__(self):
        return point(-self.x,-self.y)

# weitere Funktionen für Punkte
def dis(PointA,PointB):
    return abs(PointB-PointA)

def dir(PointA,PointB):
    return (PointB-PointA)/dis(PointA,PointB)


#Funktion für den Wert
def grav_v(x,y,time=5,frames=60):
    p = point(-1,0)
    sp = point(x+1,y)

    c = point(0,0)
    sc = point(0,0)
    
    #Vielleicht wegen des for-loops so langsam?
    for k in range(frames*time):
        try:
            plus = dir(p,c) * 1/dis(p,c)**2 / frames
            sp += plus
            p += sp/frames
            sc -= plus
            c += sc/frames
        except:
            pass

    return p


#Funktion für das Bild
def grav_c(a=-4, b=4, smoothness=1):
    ROWS = []
    p = 0
    print(0)
    #zwei for-loops...
    for Y in np.linspace(a,b,int(200*smoothness)):
        row = []
        for X in np.linspace(a,b,int(200*smoothness)):
            g = grav_v(X, Y)
            row.append( (abs(atan(g.x)*2/pi), abs(atan(g.y)*2/pi), abs(atan(abs(g))*2/pi)) )
        ROWS.append(row)
        p += 1
        print(p / (200 * smoothness))
    plt.imshow(ROWS, extent=(a, b, a, b))
    plt.show()

grav_c()

...zur Frage

Einzelne Zahlen aus txt-Dateien in Python einlesen?

Guten Tag.

Ich lerne zur Zeit Python an der Hochschule und arbeite mit Python 3.5. Bisher kam ich immer gut zurecht, doch nun haben wir eine Hausübung bekommen, die mir etwas Kopfzerbrechen bereitet.

Die Aufgabe ist folgende:

Lesen Sie aus der Datei unip-mini.dat.txt Zeile SQ die Länge aller Proteine in eine Liste. Plotten Sie die Liste als Histogramm mit 50 Balken.

Beispiel, wie so eine Zeile aussieht: SQ SEQUENCE 458 AA; 53921 MW; E46E5C85D7ACA139 CRC64;

Länge: 458

Wie man grundsätzlich Dateien in Python einliest, ist mir bekannt. Ich bin auch schon so weit, dass es nur diejenigen Zeilen einliest, die eben mit SQ beginnen. Allerdings möchte ich ja nur die Länge der Proteine in der Liste haben. Nun ist mein Problem, dass ich eben nicht weiß, wie ich es fertig stelle, dass lediglich die Länge in die Liste eingefügt wird.

Mein Code sieht bisher wie folgt aus:

    #!/usr/bin/python3

    import numpy as np
    import matplotlib.mlab as mlab
    import matplotlib.pyplot as plt

    def main():
        if os.path.isfile(sys.argv[1]) == False:
            print("Datei", sys.argv[1], "nicht gefunden")
            exit(0)
        with open(sys.argv[1]) as filetoread:
            lines = filetoread.readlines()
        seq = []

        for i in range(len(lines)):
            if(re.search('SQ   ', lines[i])):
                seq.append(lines[i])

        print(seq)


    if __name__ == "__main__":
        import sys
        import os
        import string
        main()

Könnte mir da vielleicht jemand helfen? Vielleicht gehe ich die Sache ja gerade auch einfach ganz falsch an und merke es nicht.

Mit freundlichen Grüßen

...zur Frage

Data Scraping: Wieso wird keine Auslastung angegeben?

Hi,

mein Fitnessstudio hat auf seiner Webseite einen Zähler, wie viele freie Plätze es gibt. ich wollte mir diese "scrapen" und einen Graph erstellen, sodass ich weiß, wann am wenigsten los ist.

Ich habe folgenden Code geschrieben:

from bs4 import BeautifulSoup
import requests
import pandas as pd
import time

url = "https://www.jumpers-fitness.com/studios/augsburg-haunstetten"
try:
  while True:
    response = requests.get(url)
    soup = BeautifulSoup(response.content, "html.parser")
    auslastung_element = soup.find("span", class_="js-free-spots")

    if auslastung_element is None:
      print("Das Auslastungselement wurde nicht gefunden.")
    else:
      auslastung = auslastung_element.text.strip()
print(auslastung)
      timestamp = pd.Timestamp.now()
      data = pd.DataFrame({"Timestamp": [timestamp], "Auslastung": [auslastung]})
      data.to_csv("auslastung.csv", mode="a", index=False, header=False)

    time.sleep(60) # 1 Stunde = 3600 Sekunden
except Exception as e:
  print("Fehler aufgetreten:", e)
  input("Drücke Enter, um das Programm zu beenden.")

Dieser funktioniert aber nicht und gibt keine Auslastung an.

Kann mir jemand helfen?

Danke

...zur Frage

Bestimmte Wertepaare plotten (Python)?

Hallo,

Ich versuche mich momentan in Python einwenig zurecht zu finden. Ich habe mir einen Dataframe erstellt und habe den jetzt mit matplotlib geplottet. Nun wollte ich von meiner X bzw. Y Spalte nur noch bestimmte Zeilen plotten lassen, zum Beispiel 3-7. Mit df.loc habe ich es auch geschafft die Daten zu selektieren. Wenn ich jetzt aber versuche sie zu plotten, werden die x und y werte an den achsen nach der Reihe angeordnet und nicht mehr nach Größe, es entsteht also immer eine Gerade.

Hoffentlich kann mit jemand helfen. Vielen Dank!

Gruß

...zur Frage

Wie nennt man diesen Diagrammtyp?

Hi zusammen,

ich sehe oft diese Form von Diagrammen. Auf diese Weise werden mehrere Datenreihen zusammengefasst und in einem Diagramm dargestellt. Die Datenpunkte sind die Mittelwerte aller Y-Reihen an der Stelle X. Die vertikalen Linien geben die Standardabweichung an. Man kann somit ablesen, wie "einig" sich die Werte an den Stellen X sind, bzw wie stark sie streuen.

Ich kenne das eigentlich nur als Box-Whisker-Plot, aber dort sind immer die klobigen Kästchen - ich finde diese Darstellung hier viel schöner. Weiß jemand wie man sie nennt und/oder wie man sie in Python (Matplotlib) darstellen kann?

(Das Diagramm sollte im Anhang der Frage erscheinen)

...zur Frage

Was möchtest Du wissen?

Deine Frage stellen