Das deutsche Python-Forum

Ich bin ganz stolz, dass ich Aufgaben zur Bruchrechnung auch mit Grafiken anzeigen kann.
Das bekomme ich aber nicht hin:
Ich benötige mehrmals Kreissegmente mit verschiedenen Winkeln und konnte mir da bisher nur helfen, indem ich mehrere Funktionen erstellt habe:

Code: Alles auswählen

def bruch2(center_x, center_y, radius, nenner):
        startwinkel = 90
        winkel = 360/nenner
        rad_start = math.radians(startwinkel)
        rad = math.radians(winkel)        
        start_x = center_x - radius *  math.cos(rad_start)
        start_y = center_y - radius *  math.sin(rad_start) 
        end_x = center_x - radius *  math.cos(rad+rad_start) 
        end_y = center_y - radius *  math.sin(rad+rad_start)
        if winkel <=180:
            largeArcFlag = 0
        else:
            largeArcFlag = 1 
        koordinaten = dict( 
                   start_x2 = start_x, start_y2 = start_y, end_x2 = end_x, end_y2 =  end_y, 
                   largeArcFlag2 = largeArcFlag)
        return koordinaten

def hauptnenner(center_x, center_y, radius, nenner):
        startwinkel = 90
        winkel = 360/nenner
        rad_start = math.radians(startwinkel)
        rad = math.radians(winkel)        
        start_x = center_x - radius *  math.cos(rad_start)
        start_y = center_y - radius *  math.sin(rad_start) 
        end_x = center_x - radius *  math.cos(rad+rad_start) 
        end_y = center_y - radius *  math.sin(rad+rad_start)
        if winkel <=180:
            largeArcFlag = 0
        else:
            largeArcFlag = 1 
        koordinaten = dict( 
                   start_x3 = start_x, start_y3 = start_y, end_x3 = end_x, end_y3 =  end_y, 
                   largeArcFlag3 = largeArcFlag)
        return koordinaten

Wie ihr seht ändern sich nur die Key Bezeichner. Ich würde gerne eine Zahl an die Funktion übergeben, die dann jeweils an das x oder y angehängt wird. Geht das?

Ich hatte doch noch eine Idee:

Code: Alles auswählen

def make_segment(center_x, center_y, radius, nenner, id=0):
        startwinkel = 90
        winkel = 360/nenner
        rad_start = math.radians(startwinkel)
        rad = math.radians(winkel)        
        start_x = center_x - radius *  math.cos(rad_start)
        start_y = center_y - radius *  math.sin(rad_start) 
        end_x = center_x - radius *  math.cos(rad+rad_start) 
        end_y = center_y - radius *  math.sin(rad+rad_start)
        if winkel <=180:
            largeArcFlag = 0
        else:
            largeArcFlag = 1
        if id == 2: 
            koordinaten = dict( 
                    start_x2 = start_x, start_y2 = start_y, end_x2 = end_x, end_y2 =  end_y, 
                    largeArcFlag2 = largeArcFlag)
        elif id == 3: 
            koordinaten = dict( 
                    start_x = start_x, start_y = start_y, end_x = end_x, end_y =  end_y, 
                    largeArcFlag3 = largeArcFlag)
        else: 
            koordinaten = dict( 
                    start_x = start_x, start_y = start_y, end_x = end_x, end_y =  end_y, 
                    largeArcFlag3 = largeArcFlag)            
        return koordinaten

Die Frage, die ich mir hier stelle ist, warum liefert die Funktion so ein komisches Wörterbuch? Was wird damit weiter gemacht? Warum kann man nicht an der Stelle wo es benutzt wird, die Fälle unterscheiden?

Ich erzeuge damit jeweils mittels svg Kreissegmente für Brüche mit verschiedenen Nennern:
Bild

... und da die meisten Schüler ungleichnamige Brüche nicht addieren können, bekommen sie bei Klick auf "Hilfe" auch den Hauptnenner angezeigt:
Bild

Ich bin ganz stolz, das hat mich viel Hinzschmalz gekostet.

Das beantwortet aber immer noch nicht, warum Du diese seltsamen Wörterbücher brauchst:

Code: Alles auswählen

import math

def circle_points(center_x, center_y, radius, nenner):
    arc = 2 * math.pi / nenner
    for i in range(nenner):
        yield (
            center_x + radius * math.cos(arc * i - math.pi/2),
            center_y + radius * math.sin(arc * i - math.pi/2)
        )

def lines(center_x, center_y, radius, nenner):
    return ''.join(
        f"M {center_x} {center_y}"
        f"L {x:.3f} {y:.3f}"
        for x, y in circle_points(center_x, center_y, radius, nenner)
    )

def arc(center_x, center_y, radius, nenner):
    points = circle_points(center_x, center_y, radius, nenner)
    x1, y1 = next(points)
    x2, y2 = next(points)
    return ''.join(
        f"M {center_x} {center_y}"
        f"L {x1:.3f} {y1:.3f}"
        f"A {radius} {radius} 0 0 1 {x2:.3f} {y2:.3f}"
        f"c"
    )

svg = f'''
<svg width="100" height="100" xmlns="http://www.w3.org/2000/svg">
  <path d="{arc(50, 50, 48, 7)}" fill="#c0c0ff" />
  <path d="{lines(50, 50, 48, 14)}" stroke="green" fill="transparent" />
  <circle cx="50" cy="50" r="48" stroke="green" fill="transparent"></circle>
</svg>
'''

Sirius3 hat geschrieben: Dienstag 1. August 2023, 22:27 Das beantwortet aber immer noch nicht, warum Du diese seltsamen Wörterbücher brauchst:

Dann kann ich jetzt nur noch sagen: ich konnte es nicht besser. Meine eingeschränkte Intelligenz und meine mangelnde Fähigkeiten zum Verstehen komplexer Zusammenhänge ermöglichte mir keine bessere Möglichkeit. Ich habe es auf andere Codeschnipsel aufgebaut, die funktionieren. Wenn ich dir den ganzen Code hier einstelle, wirst du erkennen, dass das ganze noch ein viel schlimmeres Wörterbuch erzeugt:

Code: Alles auswählen

...
            radius = 60
            center_y = 60                                                                         # erster Bruch
            winkel = [[0,"LightSkyBlue"]]
            n = 1
            parameter = {'name': 'svg/winkel.svg', 'object': 'rechnung', 'winkel': winkel}
            center_x = 100                                                                       
            while n < nenner_1:
                if n < zaehler_1:
                  item = (int(n*360/nenner_1),"LightSkyBlue")
                else:
                  item = (int(n*360/nenner_1),None)
                winkel.append(item)
                n +=1
            koordinaten = dict(center_x = center_x, center_y = center_y, radius = radius, sweep_flag = 1)
            koordinaten1 = segment(center_x, center_y, radius, 360/nenner_1)
            koordinaten.update(koordinaten1)
            center_x2 = 250                                                                         # zweiter Bruch
            winkel2 = [[0,"LightSkyBlue"]]
            n = 1
            while n < nenner_2:
                if n < zaehler_2:
                  item = (int(n*360/nenner_2),"LightSkyBlue")
                else:
                  item = (int(n*360/nenner_2),None)
                winkel2.append(item)
                n +=1
            koordinaten2 = segment(center_x2, center_y, radius, 360/nenner_2, 2)
            koordinaten.update(koordinaten2)
            bruch = {"center_x2" : center_x2, 'winkel2': winkel2}
            parameter.update(bruch)
            if stufe%2 == 1:
                hilfe_id = 31 
            else:
                hilfe_id = 32 
                winkel3 = [[0,None]]                                                                    # Hauptnenner (wird nur für G-Kurs angezeigt)
                n = 1
                while n < kgv:
                    item = (int(n*360/kgv),None)
                    winkel3.append(item)
                    n +=1
                koordinaten3 = segment(center_x, center_y, radius, 360/kgv, 3)
                koordinaten.update(koordinaten3)
                bruch = {'winkel3': winkel3}
                parameter.update(bruch)
                ...

... das erzeugt:

Code: Alles auswählen

{'name': 'svg/winkel.svg', 'object': 'rechnung', 'winkel': [[0, 'LightSkyBlue'], [72, None], [144, None], [216, None], [288, None]], 'center_x2': 250, 'winkel2': [[0, 'LightSkyBlue'], [180, None]], 'winkel3': [[0, None], [36, None], [72, None], [108, None], [144, None], [180, None], 
[216, None], [252, None], [288, None], [324, None]], 'center_x': 100, 'center_y': 60, 'radius': 60, 'sweep_flag': 1, 'start_x': 100.0, 'start_y': 0.0, 'end_x': 157.06339097770922, 'end_y': 41.45898033750315, 'largeArcFlag': 0, 'start_x2': 250.0, 'start_y2': 0.0, 'end_x2': 250.0, 'end_y2': 120.0, 'largeArcFlag2': 0, 'start_x3': 100.0, 'start_y3': 0.0, 'end_x3': 135.2671151375484, 'end_y3': 11.45898033750315, 'largeArcFlag3': 0, 'hilfe': 32}

und im svg:

Code: Alles auswählen

    <symbol id="segment" >
      <path d="M {{parameter.center_x}}, {{parameter.center_y}}
          L {{parameter.start_x}}, {{parameter.start_y}}
          A {{parameter.radius}}, {{parameter.radius}} 0 {{parameter.largeArcFlag}} 1  {{parameter.end_x}}, {{parameter.end_y}}
          Z"
          fill={{parameter.color}}
        />
    </symbol>

    <symbol id="segment2" >
      <path d="M {{parameter.center_x2}}, {{parameter.center_y}}
          L {{parameter.start_x2}}, {{parameter.start_y2}}
          A {{parameter.radius}}, {{parameter.radius}} 0 {{parameter.largeArcFlag2}} 1  {{parameter.end_x2}}, {{parameter.end_y2}}
          Z"
          fill={{parameter.color}}
        />
    </symbol>

    <symbol id="hauptnenner" >
      <path d="M {{parameter.center_x}}, {{parameter.center_y}}
          L {{parameter.start_x}}, {{parameter.start_y}}
          A {{parameter.radius}}, {{parameter.radius}} 0 {{parameter.largeArcFlag3}} 1  {{parameter.end_x3}}, {{parameter.end_y3}}
          Z"
          fill={{parameter.color}}
        />
    </symbol>
</defs> 

  {% elif parameter.object == "rechnung" %}
    <!-- erster Bruch-->
    <g id="Bruch">
      {% for winkel, farbe in parameter.winkel %}
        <use href="#segment" fill= {{farbe}} stroke="grey" transform="rotate({{winkel}} {{parameter.center_x}} {{parameter.center_y}})"/>
      {% endfor %}
      <circle cx={{parameter.center_x}} cy={{parameter.center_y}} r={{parameter.radius}} fill="none" stroke="black" />
    </g>
  <!-- zweiter Bruch-->   
      <circle cx={{parameter.center_x2}} cy={{parameter.center_y}} r={{parameter.radius}} fill="none" stroke="black" />
      {% for winkel, farbe in parameter.winkel2 %}
        <use href="#segment2" fill= {{farbe}} stroke="grey" transform="rotate({{winkel}} {{parameter.center_x2}} {{parameter.center_y}})"/>
      {% endfor %}
  <!-- Hauptnenner-->
    {% if parameter.hilfe == 32  %}
      <g id="haupt">
        {% for winkel, farbe in parameter.winkel3 %}
          <use href="#hauptnenner" fill= None stroke="green"   transform="rotate({{winkel}} {{parameter.center_x}} {{parameter.center_y}})"/>
        {% endfor %}
      </g>
        <use href="#haupt" transform="translate(150)"/>
    {% endif %}

Ich erzeuge also drei Kreissegmente, drehe diese mehrmals und färbe sie je nach Zähler ein.
Diesen Code benutze ich auch bei anderen Aufgabenkategorien und erzeuge damit Kreissegmente für die Berechnung von Bruchteilen und zur Darstellung von Prozenten. Als nächstes brauche ich sie um Winkelbögen für meine Aufgaben zu Winkeln zu erzeugen.
Ich würde das ja gerne eleganter machen, habe es aber nicht geschafft, deinen Code zu entschlüsseln. Könntest du mir hier vielleicht noch auf die Sprünge helfen, welcher Codeteil ungefähr was macht. Es ist mir schon nicht gelungen herauszubekommen, wo die beiden verschiedenen Mittelpunkte einfließen. Zur Not lasse ich es aber auch so (never change a running sytem?).
Ich hoffe, das du nach der Lektüre meines Codes noch ruhig schlafen kannst

Das erst wäre ja, meinen Code einfach auszuführen und sich anzuschauen, was da für SVG herauskommt, um dann zu sehen, wie das mit dem Code zusammenpasst.
Das war ja auch nur eine schnelle Lösung für einen spezifischen Fall, es kann gut sein, wenn man das verallgemeinert, dass es dann ähnlich komplex wird, wie Dein Code.
Wenn es aber zu komplex wird, kann es sinnvoll sein, Funktionen zu schreiben, die schon ganze SVG-Teile erzeugen, und die nur noch passend zusammenzusetzen, statt alles in Wörterbücher zu packen um zum Schluß mit einem Template das SVG zu erzeugen.

Sirius3 hat geschrieben: Mittwoch 2. August 2023, 16:19 Wenn es aber zu komplex wird, kann es sinnvoll sein, Funktionen zu schreiben, die schon ganze SVG-Teile erzeugen, und die nur noch passend zusammenzusetzen, statt alles in Wörterbücher zu packen um zum Schluß mit einem Template das SVG zu erzeugen.

Interessant, da wüsste ich aber auch nicht, wie man das macht. Wie bekomme ich den "SVG-Teil" dann in meinen svg Ordner? Und wie gelingt es mir "...um zum Schluß mit einem Template das SVG zu erzeugen".
Insgesamt bin ich nicht sicher, ob das eine Vereinfachung wäre. Mit meinem Code komme ich ja ganz gut zurecht - und ich verstehe ihn sogar - wobei ich in zwei Wochen sicher wieder darüber nachdenken muss, was ich da zusammengeschustert habe

.

Ich wollte aber nochmal nachtragen, dass ich es toll fände, wenn du mir wenigstens in etwa erklären könntest, was die einzelnen Teile deines Codes machen. Vielleicht lerne ich ja was dazu! Ansonsten hätte ich auch ein Problem, ihn in meinem Code zu integrieren.

Hallo,

als erstes wird die Funktion "arc" aufgerufen, mit der x- und y-Position des Kreises, dem Radius und dem Nenner. In "arc" wird "circle_points" aufgerufen, mit den selben Argumenten. Diese Funktion berechnet, in diesem Fall 7 Punkte (wegen Nenner = 7) am Umfang des Kreises. "yield" gibt für jeden Nenner die Position in x und y als Generator-Objekt zurück. "points" in "arc" ist ein Generator.
Es werden die ersten zwei x und y - Werte genommen und folgenden String wird generiert:

Code: Alles auswählen

M 50 50L 50.000 2.000A 48 48 0 0 1 87.528 20.072c

Bzw.: für svg sieht die Zeile dann so aus:

Code: Alles auswählen

<path d="M 50 50L 50.000 2.000A 48 48 0 0 1 87.528 20.072c" fill="#c0c0ff" />

Dananch wird "lines" aufgerufen und darin passiert so etwas ähnliches. Der Unterschied ist, dass der Nenner verdoppelt wurde und jeder x und y - Wert der von "circle_points" zurück gegeben wird verarbeitet wird, bzw in den String eingebettet wird.
Die Funktion gibt also so einen String zurück:

Code: Alles auswählen

M 50 50L 50.000 2.000M 50 50L 70.826 6.753M 50 50L 87.528 20.072M 50 50L 96.797 39.319M 50 50L 96.797 60.681M 50 50L 87.528 79.928M 50 50L 70.826 93.247M 50 50L 50.000 98.000M 50 50L 29.174 93.247M 50 50L 12.472 79.928M 50 50L 3.203 60.681M 50 50L 3.203 39.319M 50 50L 12.472 20.072M 50 50L 29.174 6.753

Die Auswirkungen auf svg kennst du sicherlich besser als ich.

Das wäre mal so grob gesagt, was passiert. Ich gehe davon aus, dass die Berechnungen nicht im Detail erklärt werden müssen? Lass dir mal überall einzelne Werte ausgeben, wenn etwas unklar ist und wenn es dann noch unklar ist, dann kann man es hier genauer erklären.

Grüße
Dennis

P.S. Ich freue mich für dich, dass du nach vielen Anstrengungen zu einem erfolgreichen Ergebnis gekommen bist. Dein Code wird auch nach jedem Code-Review hier besser werden

Dinge, die zusammengehören, sollten auch beieinander stehen. Du definierst winkel und n, die in der while-Schleife gebraucht werden, dazwischen werden dann aber noch parameter und center_x definiert, die nichts mit der Schleife zu tun haben.
Eingerückt wird immer mit 4 Leerzeichen pro Ebene, nicht mal 4 und mal 2.
Wenn man das nur etwas anders anordnet, wird alles gleich viel klarer:

Code: Alles auswählen

radius = 60
center_y = 60
center_x = 100
center_x2 = 250

winkel = [[0,"LightSkyBlue"]]
n = 1
while n < nenner_1:
    if n < zaehler_1:
        item = (int(n * 360 / nenner_1), "LightSkyBlue")
    else:
        item = (int(n * 360 / nenner_1), None)
    winkel.append(item)
    n +=1

winkel2 = [[0, "LightSkyBlue"]]
n = 1
while n < nenner_2:
    if n < zaehler_2:
      item = (int(n * 360 / nenner_2), "LightSkyBlue")
    else:
      item = (int(n * 360 / nenner_2), None)
    winkel2.append(item)
    n +=1

parameter = {
    'name': 'svg/winkel.svg',
    'object': 'rechnung',
    'winkel': winkel,
    "center_x2" : center_x2,
    'winkel2': winkel2
}
koordinaten = {
    "center_x": center_x,
    "center_y": center_y,
    "radius": radius,
    "sweep_flag": 1,
    **segment(center_x, center_y, radius, 360/nenner_1),
    **segment(center_x2, center_y, radius, 360/nenner_2, 2),
}            
if stufe % 2 == 1:
    hilfe_id = 31 
else:
    # Hauptnenner (wird nur für G-Kurs angezeigt)
    hilfe_id = 32 
    winkel3 = [[0, None]]
    n = 1
    while n < kgv:
        item = (int(n*360/kgv), None)
        winkel3.append(item)
        n +=1
    koordinaten.update(segment(center_x, center_y, radius, 360/kgv, 3))
    parameter['winkel3'] = winkel3

Jetzt hat es da viel kopierten Code, den man besser in Funktionen auslagert und die while-Schleife wäre besser eine for-Schleife. Der Fall n=0 ist gar kein Spezielfall!

Code: Alles auswählen

def winkel_erzeugen(nenner, zaehler, farbe):
    winkel = []
    for n in range(nenner):
        winkel.append((
            int(n * 360 // nenner),
            farbe if n < zaehler else None
        ))
    return winkel

...
radius = 60
center_y = 60
center_x = 100
center_x2 = 250

parameter = {
    'name': 'svg/winkel.svg',
    'object': 'rechnung',
    'winkel': winkel_erzeugen(nenner_1, zaehler_1, "LightSkyBlue"),
    "center_x2" : center_x2,
    'winkel2': winkel_erzeugen(nenner_2, zaehler_2, "LightSkyBlue")
}
koordinaten = {
    "center_x": center_x,
    "center_y": center_y,
    "radius": radius,
    "sweep_flag": 1,
    **segment(center_x, center_y, radius, 360/nenner_1),
    **segment(center_x2, center_y, radius, 360/nenner_2, 2),
}            
if stufe % 2 == 1:
    hilfe_id = 31 
else:
    # Hauptnenner (wird nur für G-Kurs angezeigt)
    hilfe_id = 32 
    koordinaten.update(segment(center_x, center_y, radius, 360/kgv, 3))
    parameter['winkel3'] = winkel_erzeugen(kgv, 0, "LightSkyBlue")

Wenn man aber Deine Ausgabe anschaut, dann gibt es gar keine zwei Wörterbücher `parameter` und `koordinaten`?!?! Warum sind die dann in Deinem Code?
Dadurch wird der Code ja nochmal um einiges klarer und systematischer:

Code: Alles auswählen

parameter = {
    'name': 'svg/winkel.svg',
    'object': 'rechnung',
    "sweep_flag": 1,
    "radius": radius,
    "center_y": center_y,
    "center_x": center_x,
    'winkel': winkel_erzeugen(nenner_1, zaehler_1, "LightSkyBlue"),
    **segment(center_x, center_y, radius, 360/nenner_1),
    "center_x2" : center_x2,
    'winkel2': winkel_erzeugen(nenner_2, zaehler_2, "LightSkyBlue")
    **segment(center_x2, center_y, radius, 360/nenner_2, 2),
}            
if stufe % 2 == 1:
    hilfe_id = 31 
else:
    # Hauptnenner (wird nur für G-Kurs angezeigt)
    hilfe_id = 32 
    parameter['winkel3'] = winkel_erzeugen(kgv, 0, "LightSkyBlue")
    parameter.update(segment(center_x, center_y, radius, 360/kgv, 3))

Und auch hier gilt wieder, statt Schlüssel durchzunummerieren benutzt man eine passende Datenstruktur!

Code: Alles auswählen

def segment(center_x, center_y, radius, winkel):
    startwinkel = 90
    rad_start = math.radians(startwinkel)
    rad_end = math.radians(startwinkel + winkel)
    return {
        "start_x": center_x - radius *  math.cos(rad_start),
        "start_y": center_y - radius *  math.sin(rad_start),
        "end_x": center_x - radius *  math.cos(rad_end),
        "end_y": center_y - radius *  math.sin(rad_end),
        "largeArcFlag": 0 if winkel < 180 else 1,
    }

def rad_erzeugen(center_x, center_y, radius, nenner, zaehler):
    return {
        "radius": radius,
        "center_y": center_y,
        "center_x": center_x,
        'winkel': winkel_erzeugen(nenner, zaehler, "LightSkyBlue"),
        **segment(center_x, center_y, radius, 360 / nenner),
    }

...
radius = 60
center_y = 60
center_x = 100
center_x2 = 250

parameter = {
    'name': 'svg/winkel.svg',
    'object': 'rechnung',
    "sweep_flag": 1,
    "rad": [
        rad_erzeugen(center_x, center_y, radius, nenner_1, zaehler_1),
        rad_erzeugen(center_x2, center_y, radius, nenner_2, zaehler_2),
    ]
}            
if stufe % 2 == 1:
    hilfe_id = 31 
else:
    # Hauptnenner (wird nur für G-Kurs angezeigt)
    hilfe_id = 32 
    parameter['rad'].append(rad_erzeugen(center_x, center_y, radius, kgv, 0))

Mit den Änderungen wird auch der svg-Code deutlich einfacher.

Ach, ihr seid so lieb zu mir!
Also zunächst mal:

Sirius3 hat geschrieben: Mittwoch 2. August 2023, 22:11 Wenn man aber Deine Ausgabe anschaut, dann gibt es gar keine zwei Wörterbücher `parameter` und `koordinaten`?!?! Warum

... Schlamperei! Da habe ich die letzte Zeile im geposteten Code vergessen:

Code: Alles auswählen

parameter.update(koordinaten)

Um es mir übersichtlicher zu machen, habe ich die Koordinaten der Kreissegmente outgesourced und am Ende wieder angehängt.
Du hast schon recht, mein Code wird mit deiner Struktur viel übersichtlicher. (Ob ich das auch mal lerne?)
Aber zum Prinzip: In deinem ersten Vorschlag hast du, wenn ich das richtig sehe, direkt Strings erzeugt, die ich in svg nutzen könnte (wenn ich wüsste wie

) und im neuen Vorschlag nutzt du dann doch ein Dict - das gefällt mir besser, damit kann ich umgehen - der Code entstpricht ja etwa meinem, ist nur ordenlicher. Allerdings ist da, glaube ich, noch nicht berücksichtigt, dass ein Bruch wie z.B. 2/5 bei mir zwei blaue und drei farblose Elemente hat und die Hilfslinien, die den Hauptnenner zeigen, ebenfalls keine Füllung haben.
Aber insgesamt kann ich meinen Code jetzt etwas aufräumen.

Pitwheazle hat geschrieben: Donnerstag 3. August 2023, 10:57 Ach, ihr seid so lieb zu mir!
Also zunächst mal:
Sirius3 hat geschrieben: Mittwoch 2. August 2023, 22:11 Wenn man aber Deine Ausgabe anschaut, dann gibt es gar keine zwei Wörterbücher `parameter` und `koordinaten`?!?! Warum
... Schlamperei! Da habe ich die letzte Zeile im geposteten Code vergessen:
Code: Alles auswählen
parameter.update(koordinaten)
Um es mir übersichtlicher zu machen, habe ich die Koordinaten der Kreissegmente outgesourced und am Ende wieder angehängt.
Du hast schon recht, mein Code wird mit deiner Struktur viel übersichtlicher. (Ob ich das auch mal lerne?)
Aber zum Prinzip: In deinem ersten Vorschlag hast du, wenn ich das richtig sehe, direkt Strings erzeugt, die ich in svg nutzen könnte (wenn ich wüsste wie ) und im neuen Vorschlag nutzt du dann doch ein Dict - das gefällt mir besser, damit kann ich umgehen - der Code entstpricht ja etwa meinem, ist nur ordenlicher.

@Sirius3 Das ist Zauberei! Ich habe das jetzt übernommen und es funktioniert ohne Anpassungen. Vielen Dank mal wieder für die Mühe! Der Code ist jetzt viel schöner

.

Das deutsche Python-Forum

key Bezeichner in dict ändern

key Bezeichner in dict ändern

Re: key Bezeichner in dict ändern

Re: key Bezeichner in dict ändern

Re: key Bezeichner in dict ändern

Re: key Bezeichner in dict ändern

Re: key Bezeichner in dict ändern

Re: key Bezeichner in dict ändern

Re: key Bezeichner in dict ändern

Re: key Bezeichner in dict ändern

Re: key Bezeichner in dict ändern

Re: key Bezeichner in dict ändern

Re: key Bezeichner in dict ändern

Re: key Bezeichner in dict ändern

Re: key Bezeichner in dict ändern