Listen, Dictionaries

[VinzLaist]

Hallo zusammen,

vielen Dank im Voraus.

Weiß jemand wie ich eine unbestimmte Größe von Listen zu einer zusamnnenfügen kann?
Ich möchte gerne eine Reihe(Folge) von Listen zu einer zusammenfügen.
Die Reihenfolge sollte dabei gleich bleiben.

x und y sind Listen die sich ergeben aus der Eingabe eines Benutzers.

Code: Alles auswählen

for i in range(0,len(x)-1):
            for u in range(0,len(y)-1):
                Raster=[x[i],y[u],x[i+1],y[u],
                    x[i],y[u+1],x[i+1],y[u+1],
                    x[i+1],y[u+1],x[i+1],y[u],
                    x[i+1],y[u+1],x[i+1],y[u+1],
                    x[i],y[u+1],x[i],y[u]]    
             Zeichen(Raster)

habe es bisher so probiert:

Code: Alles auswählen

def addiere(*Raster):
    summe=0
    for s in Raster:
        summe +=s 
    print(summe)

und so:

Code: Alles auswählen

biglist = []
                for i in range(z*s):
                     biglist.append(Raster)
                     print(biglist,len(biglist))

z und s sind Benutzereingaben die zusammen multipliziert die Menge aller Listen wieder gibt.

Mit freundlichen Grüßen

[mutetella]

@VinzLaist
Bin mir nicht sicher, ob ich Dich richtig verstanden hab'... Meinst Du vielleicht ``itertools.product``?

Code: Alles auswählen

>>> import itertools
>>> list(itertools.product((1, 2, 3), (4, 5, 6)))
[(1, 4), (1, 5), (1, 6), (2, 4), (2, 5), (2, 6), (3, 4), (3, 5), (3, 6)]

Oder ``itertools.chain``?

Code: Alles auswählen

>>> list(itertools.chain((1, 2, 3), (2, 3, 4), (3, 4, 5)))
[1, 2, 3, 2, 3, 4, 3, 4, 5]

mutetella

[VinzLaist]

Danke für die Schelle antwort.
Hab es mal ausprobiert, funktionier leider nicht.

Die folgenden Zeilen erzeugen Beispielsweise...

Code: Alles auswählen

for i in range(0,len(x)-1):
            for u in range(0,len(y)-1):
                Raster=[x[i],y[u],x[i+1],y[u],
                    x[i],y[u+1],x[i+1],y[u+1],
                    x[i+1],y[u+1],x[i+1],y[u],
                    x[i+1],y[u+1],x[i+1],y[u+1],
                    x[i],y[u+1],x[i],y[u]]
                     print(Raster)

diese ausgabe:

Code: Alles auswählen

[30, 30, 196, 30, 30, 530, 196, 530, 196, 530, 196, 30, 196, 530, 196, 530, 30, 530, 30, 30]
[196, 30, 362, 30, 196, 530, 362, 530, 362, 530, 362, 30, 362, 530, 362, 530, 196, 530, 196, 30]
[362, 30, 528, 30, 362, 530, 528, 530, 528, 530, 528, 30, 528, 530, 528, 530, 362, 530, 362, 30]
[528, 30, 530, 30, 528, 530, 530, 530, 530, 530, 530, 30, 530, 530, 530, 530, 528, 530, 528, 30]

Das hätte ich dann gerne als eine List.

Kann sehr gut sein, das Sie recht haben und ich nur falsch Programiert habe.

Habe es jetzt mal so eingebenuden.

Code: Alles auswählen

   
 for i in range(0,len(x)-1):
            for u in range(0,len(y)-1):
                Raster=[x[i],y[u],x[i+1],y[u],
                    x[i],y[u+1],x[i+1],y[u+1],
                    x[i+1],y[u+1],x[i+1],y[u],
                    x[i+1],y[u+1],x[i+1],y[u+1],
                    x[i],y[u+1],x[i],y[u]]
                list(itertools.chain(Raster))
                print(Raster)

[BlackJack]

@VinzLaist: Wenn man das was da mit `print()` ausgegeben wird in einer Liste stehen haben möchte dann muss man vor den Schleifen eine leere Liste erstellen und dann statt die Daten auszugeben sie halt an diese Liste anfügen. Je nach dem wie das Ergebnis aussehen soll gibt es dafür die `append()`- oder die `extend()`-Methode auf Listen. Das sind Grundlagen.

Edit: Und einfach wild herum raten wie man irgendwelche Funktionen kombinieren könnte in der Hoffnung da passiert dann irgendwann schon das was man haben möchte, das funktioniert nicht. Hat auch nicht viel mit programmieren zu tun.

[Sirius3]

@VinzLaist: Wenn man einen list-Aufruf keiner Variable zuweist, kann man ihn auch gleich sein lassen. Das Raster sieht mir ein bißchen wirr aus.
Du mußt schon alles zusammen in einen chain-Aufruf packen:

Code: Alles auswählen

from itertools import islice, chain
x = [30, 196, 362, 528]
y = [30, 530]
print(list(chain(*(
    [xu,yu,xv,yu,
    xu,yv,xv,yv,
    xv,yv,xv,yu,
    xv,yv,xv,yv,
    xu,yv,xu,yu]
    for xu, xv in zip(x, islice(x,1,None))
    for yu, yv in zip(y, islice(y,1,None))
))))

[BlackJack]

Alternativ ohne ``*``-Magie mit `chain.from_iterable()`:

Code: Alles auswählen

print(list(chain.from_iterable(
    [xu, yu, xv, yu,
    xu, yv, xv, yv,
    xv, yv, xv, yu,
    xv, yv, xv, yv,
    xu, yv, xu, yu]
    for xu, xv in zip(x, islice(x, 1, None))
    for yu, yv in zip(y, islice(y, 1, None))
)))

[VinzLaist]

Super danke.

Ganz logisch eigentlich.

[VinzLaist]

Hallo, vielen Dank für die Hilfe.

Das Programm wirft jetzt leider gewisse Koordinaten viel zu oft aus, hat jemand eine Idee wie sich das Problem beheben lässt?

Ich versuche im Prinzip Koordinaten für eine GUI zu erstellen, die ein Viereck mit einer diagonalen Linie bilden.
Der Benutzer soll Spalten, Zeilen einegeben und die Höhe und Länge die das Raster insgesamt haben soll.

Also Länge geteilt durch Spaltenanzahl gleich Länge eines Vierecks aus solch einem Raster.
Das Gleiche im Prinzip für Höhe und Spalten.

Es sollten allerdings auch nicht quadratische Raster möglich sein, z.B. 1x3 oder 2x6.

Wäre sehr glücklich über Vorschläge.


Leider kann ich das von gestern nicht nachvollziehen...

Die Funktion "chain" fügt die Elemente in einer Liste zusammen?
Was macht das Wort "islice"?

Ich habe keine Variable mit den Buchstaben xu,yu,xv,yv gebildet, dennoch läuft das Programm bei mir.

Liegt das an den: for xu, xv in zip(x, islice(x, 1, None)) Zeilen?
for yu, yv in zip(y, islice(y, 1, None))

Was bewirkt das "None"?

Nochmal vielen Dank.

[BlackJack]

@VinzLaist: Sowohl `chain()` als auch `islice()` sind dokumentiert.

Bei der Beschreibung ist mir irgendwie nicht ganz klar was die Eingaben sind und wie dazu die Ausgabe aussehen soll.

[VinzLaist]

Die Eingabe sollte Lännge,Höhe,Zeile Spalte sein.(vom Benutzer)

Daraus sollen sich dann Koordinaten ergeben die sich mit.-z.b -C.create_line verbinden.

Der Benutzer soll dann in einer Canvas Rechtecke je nach größe der Zeilen und Spalten sehen.

Die GUI Befehle kann ich auch soweit, ich bekomme es nur nicht hin einen vernünftige "Koordinaten Liste" zu erstellen.

Code: Alles auswählen

def Koordinaten(l=5,h=5,s=4,z=1):
    
    Spaltenlänge = int((l/s)*100)
    Zeilenhöhe = int((h/z)*100)

    a = list(range(0,l*100,Spaltenlänge))
    a.append(l*100)
    x = list([item + 100 for item in a])

    b = list(range(0,h*100,Zeilenhöhe))#ab 3*3 3-linen zuviel
    b.append(h*100)
    y = list([item +100 for item in b])

    L=(list(chain.from_iterable(
            [xu, yu, xv, yu,
             xu, yv, xv, yv,
             xv, yv, xv, yu,
             #xv, yv, xv, yv,
             xu, yv, xu, yu]
        for xu, xv in zip(x, islice(x, 1, None))
        for yu, yv in zip(y, islice(y, 1, None))

C.create_line(L, width = 3)

[BlackJack]

@VinzLaist: Mir ist immer noch nicht klar wie das Ergebnis zu der Eingabe aussehen soll. Irgendwie Rechtecke aber auch irgendetwas mit Diagonalen, das ist nicht wirklich selbsterklärend. Und anscheinend etwas was man mit *einem* Linienzug zeichnen kann? Ohne das Linien mehrfach gezeichnet werden?

Du solltest dringend an den Namen arbeiten. Für Koordinatenanteile gehen ja einbuchstabige Namen wie `x` und `y` weil man die aus der Mathematik dafür kennt, aber bei `l`, `h`, `s`, `z`, `a`, `b`, `C`, und `L` muss man schon arg raten was die Werte wohl bedeuten mögen. Wobei auch `x` und `y` nicht gut gewählt sind da sie jeweils für viele Werte stehen und nicht für einen Einzelwert wie der Name vermuten lässt. `Koordinaten` ist ein passabler Name für Koordinaten, aber weniger für eine Funktion die Koordinaten berechnet und zeichnet. Funktionen werden konventionell nach Tätigkeiten benannt weil sie etwas tun und um sie von anderen, ”passiveren” Werten unterscheiden zu können. Ausserdem deutet ein führender Grossbuchstabe auf eine Klasse hin und nicht auf eine Funktion. In dem Zusammenhang Lesestoff: Style Guide for Python Code.

[pillmuncher]

So ganz verstehe ich nicht, was du willst, aber vielleicht ist es das hier:

Code: Alles auswählen

#!/bin/env python3
# -*- coding: utf-8 -*-

from collections import namedtuple

Line = namedtuple('Line', 'x1 y1 x2 y2')

def make_grid_lines(cols, rows, width, height):
    cols += 1
    rows += 1
    max_width = cols * width
    max_height = rows * height
    for x in range(cols):
        x *= width
        yield Line(x1=x, y1=.0, x2=x, y2=max_height)
    for y in range(rows):
        y *= height
        yield Line(x1=.0, y1=y, x2=max_width, y2=y)

def main():
    c = int(input('Spalten:'))
    r = int(input('Zeilen:'))
    w = float(input('Breite:'))
    h = float(input('Höhe:'))
    print(list(make_grid_lines(c, r, w, h)))

if __name__ == '__main__':
    main()

Ergebnis:

Code: Alles auswählen

Spalten:2
Zeilen:3
Breite:1.4
Höhe:1.7
[Line(x1=0.0, y1=0.0, x2=0.0, y2=6.8), Line(x1=1.4, y1=0.0, x2=1.4, y2=6.8), Line(x1=2.8, y1=0.0, x2=2.8, y2=6.8), Line(x1=0.0, y1=0.0, x2=4.199999999999999, y2=0.0), Line(x1=0.0, y1=1.7, x2=4.199999999999999, y2=1.7), Line(x1=0.0, y1=3.4, x2=4.199999999999999, y2=3.4), Line(x1=0.0, y1=5.1, x2=4.199999999999999, y2=5.1)]

[VinzLaist]

Danke das ist es schon ziemlich genau.

Werde das mal versuchen Nachzuvollziehen und dann müssten sich meine Probleme auch erledigt haben.