Arbeiten mit Arrays (Matrizen)

Beitrag von **Heinrichs** » Fr 26. Nov 2021, 15:03

In diesem Beitrag möchte ich darstellen, wie man mit Python 2-dimensionale Arrays behandelt. Ein Beispiel für ein 2-dimensionales Array ist die folgende Matrix mit 3 Zeilen und 5 Spalten:

Code: Alles auswählen

+----+----+----+----+----+
|  0 |  1 |  2 |  3 |  4 |
| 10 | 11 | 12 | 13 | 14 |
| 20 | 21 | 22 | 23 | 24 |
+----+----+----+----+----+

Im Gegensatz zu vielen anderen Programmiersprachen bietet (Micro-)Python keine Array-Typen an. Üblicherweise greift man in Python zur Darstellung von Matrizen auf Listen zurück.

Explizite Definition einer Matrix

Diese bietet sich bei kleineren Tabellen an. Die Vorgehensweise ist folgendermaßen:

Code: Alles auswählen

matrix1 = [
            [ 0,  1,  2,  3,  4], # Zeile 0
            [10, 11, 12, 13, 14], # Zeile 1
            [20, 21, 22, 23, 24]  # Zeile 2
          ]

matrix1 besteht aus einer Liste mit 3 Elementen; jedes dieser Elemente besteht seinerseits aus einer Liste (die jeweils eine Zeile der Matrix darstellt). Diese Matrix oder auch einzelne Bestandteile der Matrix kann man sich folgendermaßen anzeigen lassen:

Wie kann man nun eine solche Matrix bzw. Teile von ihr ausgeben?

Mit dem Befehl

Code: Alles auswählen

print('matrix1:', matrix1)

wird die gesamte Tabelle als Liste der einzelnen Zeilenlisten dargestellt:

Code: Alles auswählen

matrix1: [[0, 1, 2, 3, 4], [10, 11, 12, 13, 14], [20, 21, 22, 23, 24]]

Mit

Code: Alles auswählen

print('matrix1[2]: ', matrix1[2])

erhält man eine einzelne Zeile, in diesem Fall die Zeile 2:

Code: Alles auswählen

matrix1[2]:  [20, 21, 22, 23, 24]

und mit

Code: Alles auswählen

print('matrix1[2][3]: ', matrix1[2][3])

wird das Matrixelement aus Zeile 2 | Spalte 3 angezeigt:

Code: Alles auswählen

matrix1[2][3]:  23

Dies ist das Element 3 der Zeilenliste mit dem Index 2.

Allgemein bezieht sich matrix1[ i ][ j ] auf das Matrixelement aus Zeile i und Spalte j.

Programmierte Ein- und Ausgabe

In vielen Fällen (z. B. bei großen Matrizen) ist es sinnvoll, die Matrix durch das Programm selbst erzeugen zu lassen. Dazu definiert man zunächst eine Matrix, deren Elemente alle den Wert 0 haben. Für die oben angegebene Matrix würde das so aussehen:

Code: Alles auswählen

w = 5 # Weite (Spaltenanzahl)...
h = 3 # Höhe (Zeilenanzahl) der Matrix
matrix2 = [[0 for j in range(w)] for i in range(h)] # Matrix mit w Spalten und h Zeilen

Wie funktioniert das? Schauen wir uns dazu das Beispiel

Code: Alles auswählen

>>> ['hallo' for i in range(4)]
['hallo', 'hallo', 'hallo', 'hallo']

an: Hier wird eine Liste mit 4 Elementen erzeugt; jedes dieser Elemente besteht aus der Zeichenkette 'hallo'.

Bei der Definition der matrix2 wird zunächst durch [0 for j in range(w)] eine Liste aus den 5 Null-Elementen erzeugt: [0, 0, 0, 0, 0]. Durch [... for i in range(h)] wird nun seinerseits eine Liste mit 3 [0, 0, 0, 0, 0]-Elementen erzeugt. Das Ergebnis ist die folgende Liste:

Code: Alles auswählen

[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]

Die Matrix kann nun in einer verschachtelten Schleife vollständig mit Werten gefüllt werden, z. B. folgendermaßen

Code: Alles auswählen

for i in range(h):
    for j in range(w):
        matrix2[i][j] = i*10+j # i:Zeilenindex, j:Spaltenindex

Damit erhält man nun dieselbe Tabelle wie bei matrix1.

Hier noch zwei Beispiele zur Schleifen-gesteuerten Ausgabe einer Matrix:

Code: Alles auswählen

# Alle Zeilen-Listen untereinander ausgeben:
for i in range(h):
    print(matrix2[i])
print()    

# Alle Elemente der Matrix (in einer einzigen Zeile) hintereinander ausgeben:
for i in range(h):
    for j in range(w):
        print(matrix2[i][j], end =' ')

Zu guter Letzt die wesentlichen Teile in einem einzigen Programm zum eigenen Testen...

Code: Alles auswählen

# matrizen.py


############### Explizite Eingabe von (kleinen) Matrizen als Liste von Listen ###############

matrix1 = [
            [ 0,  1,  2,  3,  4], # Zeile 0
            [10, 11, 12, 13, 14], # Zeile 1
            [20, 21, 22, 23, 24]  # Zeile 2
          ]

############### Ausgaben von matrix1 ########################################################

# als(als Liste von Listen):
print('matrix1:', matrix1)
print()

# einzelne Zeilen bzw. Elemente
print('matrix1[2]: ', matrix1[2]) # Zeile 2 der Matrix
print('matrix1[2][3]: ', matrix1[2][3]) # Matrixelement aus Zeile 2 | Spalte 3
print()


############### Programmierte Ein- und Ausgaben (auch) von größeren Matrizen ###########################

w = 5 # Weite (Spaltenanzahl)...
h = 3 # Höhe (Zeilenanzahl) der Matrix

# Initialisierung der Matrix liefert eine Matrix mit lauter 0-Elementen:
matrix2 = [[0 for j in range(w)] for i in range(h)] # Matrix mit w Spalten und h Zeilen
# Ausgabe zum Testen:
print(matrix2)

# Belegung der Matrix mit Werten:
for i in range(h):
    for j in range(w):
        matrix2[i][j] = i*10+j # i:Zeilenindex, j:Spaltenindex        

# Ausgabe der Matrix (als Liste von Listen):
print('matrix2:', matrix2)
print()

# Alle Zeilen-Listen untereinander ausgeben:
for i in range(h):
    print(matrix2[i])
print()    

# Alle Elemente der Matrix (in einer einzigen Zeile) hintereinander ausgeben:
for i in range(h):
    for j in range(w):
        print(matrix2[i][j], end =' ')

Eine Anwendung

Auf dem Display des TTGO fliegt ein Gleiter durch die Weiten des Alls...

Code: Alles auswählen

# glider.py (27.11.2021)

# Eine einfache Animation: Gleiter fliegt durch das Weltall

from time import sleep

################ Initialisierung des Displays ####################

from machine import Pin, SPI
import st7789

spi = SPI(2, baudrate=20000000, polarity=1, sck=Pin(18), mosi=Pin(19))
display = st7789.ST7789(spi, 135, 240,  reset=Pin(23, Pin.OUT), cs=Pin(5, Pin.OUT), dc=Pin(16, Pin.OUT), backlight=Pin(4, Pin.OUT), rotation=3)
# Landscape

display.init()
display.fill(st7789.BLUE)

############### Definition der Glider-Funktion ###############

def zeichne_glider(x, y):
    w = 16
    h = 16
    matrix = [
                [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0],
                [0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0],
                [0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0],             
                [0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0],
                [0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0],
                [1,1,0,0,1,1,1,1,1,1,1,0,0,0,0,0],
                [1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0],
                [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
                [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
                [1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0],
                [1,1,0,0,1,1,1,1,1,1,1,0,0,0,0,0],
                [0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0],
                [0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0],            
                [0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0],
                [0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0],
                [0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0],
            ]    
   
    for j in range(h):
        for i in range(w):
            if matrix[j][i] == 1:
                display.pixel(x+i, y+j, st7789.YELLOW)
                
               
############### Hauptprogramm ###############

while True:
    for x in range(40):
        zeichne_glider(6*x, 50)
        sleep(0.1)
        display.fill(st7789.BLUE)

.