Python Grundlagen

Entwicklungsumgebungen:

• PyCharm (Community-Edition, kostenlos, empfohlen)
• erweiterung zu Eclipse
• Notepad++ - keine IDE, dennoch sehr beliebter minimalistischer Editor für Windows

Tutorials:

• Python Grundlagenkurs
• Python Grundlagenkurs (engl.)
• Kurztutorial: Learn X in Y Minutes
• Kurztutorial: Learn X in Y Minutes (engl.)

Cheat-Sheets (keine Erklärungen):

• Cheat-Sheet
• Quick-Reference (keine Erklärungen)
• Quick-Reference for Helper Functions

import numpy as np

Importumbenennung

from numpy import sin, exp
# nutzt eigentlich np.sin bzw. np.exp
print(sin(0) + exp(0))

from numpy import sin as sinus, exp
# nutzt eigentlich np.sin bzw. np.exp
print(sinus(0) + exp(0))

# erst nötige Pakete
import math

# Hilfsmethoden 
def function1(a):
	return a, a**2, a**3

# Main-Methode (wird direkt Ausgeführt)
test = 42
print(function1(test))

# erst nötige Pakete
import math

# Hilfsmethoden 
def function1(a):
	return a, a**2, a**3

# Main-Methode (wird nur Ausgeführt, wenn Script direkt ausgeführt wird)
if __name__ == "__main__":
	test = 42
	print(function1(test))

# Erst die nötigen Pakete
import math
import sys

# Hilfsmethoden 
def function1(a):
	return a, a**2, a**3

# Der Name main ist dabei beliebig. (`argv} ist dabei die Liste aller 
# Kommandozeilenargumente an das Skript; der Name ist auch beliebig).
# Der zusätzliche Parameter argv ist selbstverständlich optional - 
# es können auch andere Parameter definiert werden.
def main(argv):
	print(argv)
	test = 42
	print(function1(test))

# Main-Methode (wird nur Ausgeführt, wenn Script direkt ausgeführt wird)
if __name__ == "__main__":
	main(sys.argv)

Dokumentation & Cheat Sheet:

• Cheat Sheet
• Dokumentation (engl.)
• Sortierte Liste aller Funktionen

Tutorials:

• Quick-Tutorial (engl.)

datensatz = ... # mehrdimensionales Array (ein Datenpunkt pro Zeile)

# Zufallige Indices bestimmen
indices = np.random.permutation(len(datensatz))
vermischt = datensatz[indices]

Name, Wert2, Wert3, Wert4
abc, 0.33, 0.5, 1234 
abc, 0.04, 1.6, 461 
abc, 0.1, 9.2, 873 
...

# Einlesen der Datei mithilfe von Numpy
array2d = np.loadtxt("dateiname.txt", ...)

# für ... können wir die folgenden optionalen Parameter einsetzen
dtype = np.int64 # für Ganzzahlen oder etwa np.float64 für Fließkommazahlen
skiprows = 12    # Überspringe 12 Zeilen bevor der eigentliche Datensatz anfängt
delimiter = ","  # (Standardmäßig auf alle Whitespace-Zeichen gestellt)
comments = "#"   # Symbol, das angibt, wie Kommentare eingeleitet werden sollen

Dokumentation & Cheat Sheet:

• Cheat Sheet
• Dokumentation (engl.)
• Dokumentation der Plot-Funktion (engl.)

Tutorials:

• Tutorial (engl.)
• Typische Anwendungsbeispiele

import numpy as np
import matplotlib.pyplot as plt

# x- und y-Koordinaten
X = [0,1,5,10,3,6]
Y = [2,2,8,2,3,0]

# Zeichnen und Anzeige
plt.plot(X, Y)
plt.show()

X = np.linspace(0,10, 250)
Y = np.cos(X)*np.cos(2*X)+np.sin(X)

# Zeichnen und Anzeige
plt.plot(X, Y)
plt.show()

t = np.linspace(0,100, 2500)
	
# Parametrische Kurve.
a = np.exp(np.cos(t))-2*np.cos(4*t)-np.sin(t/12)**5
X = np.sin(t)*a
Y = np.cos(t)*a

# Zeichnen und Anzeige
plt.plot(X, Y)
plt.show()

...
plt.plot(X, Y, '.')	   # Punkte, nicht verbunden
plt.plot(X, Y, 'b.')   # Punkte, nicht verbunden, blau
plt.plot(X, Y, 'ro')   # große Punkte, nicht verbunden, rot
plt.plot(X, Y, 'k--')  # gestrichelte Linie, schwarz
...

plt.plot(X, Y, color='#eceffa')
plt.plot(X, Y, color=(0.5,0.2,1))       # Werte jeweils zwischen 0 und 1
plt.plot(X, Y, color=(0.5,0.2,1,0.5))   # ... halb durchsichtig
...

...
plt.plot(x, y, 'o')
plt.xlim([-5,3]) # zeichne nur Punkte zwischen -5 und 3 (x-Achse)
plt.xlabel('x-Achse') # Achsen-Name
plt.ylim([0,40]) # zeichne nur Punkte zwischen 0 und 40 (y-Achse)
plt.ylabel('y-Achse') # Achsen-Name
plt.show()

X = np.linspace(0,10, 250)
Y = np.cos(X)*np.cos(2*X)+np.sin(X)
plt.plot(X, Y, 'o')
plt.axhline(0.5, color="b", alpha=0.5)
plt.axvline(0.5, color="b", alpha=0.5)
plt.show()

x = np.linspace(0,2*np.pi, 250)
y = np.cos(x)
y2 = np.sin(np.cos(x)*x)

# Zeichnen und Anzeige
plt.plot(x, y, linewidth=3, label="das ist cos(x)")
plt.plot(x, y2, label="das ist sin(cos(x)*x)")
plt.plot(x, y2,"b.",markersize=1)
plt.legend()
plt.show()

x = ...
y = ...
y2 = ...

# erste Achse
fig, ax1 = plt.subplots()
# statt plt.plot nun ax1.plot
ax1.plot(x, y, 'b-')

# aus xlabel und xlim wird set_xlabel und set_xlim
ax1.set_xlabel('Punkte')

# Färben der y-Achse
ax1.tick_params('y', colors='b')

# zweite y-Achse (mit der gleichen x-Achse)
ax2 = ax1.twinx()
ax2.plot(x, y2, 'r.')

x = np.linspace(0,2*np.pi, 250)
y = np.cos(x)
y2 = np.sin(np.cos(x)*x)

# Zeichnen und Anzeige
fig = plt.figure()
ax_obenlinks   = fig.add_subplot(321)
ax_mitterechts = fig.add_subplot(324)
ax_obenlinks.plot(x, y)
ax_obenlinks.plot(x, x)
ax_mitterechts.plot(x, y2)
plt.show()

import matplotlib.pyplot as plt
from PIL import Image

# Bild einlesen (bild.png ist im selben verzeichnis, wie diese Datei enthalten)
# convert("L") übersetzt das bild in ein Graustufenbild (nur ein Kanal, statt dreien)
image = Image.open("bild.png").convert("L")

# konvertieren in ein numpy-array
img = np.asarray(image)

# Anzeigen (in Graustufen)
fig, ax = plt.subplots()
ax.imshow(img, cmap='gray')
plt.show()

from numpy import sin, cos
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

fig, ax = plt.subplots()
ax.set_xlim([-5,5])
ax.set_ylim([-5,5])

# folgende objekte sollen wie gezeichnet werden
curve, = ax.plot([],[],"-", color="blue")
origin = ax.plot(0,0,"x", color="red")
pos, = ax.plot([],[],"o", color="black")
text = ax.text(0.1, 0.2, '', transform=ax.transAxes)

# wir merken uns alle positionen
curve_pos = [[],[]]

# berechnnung der neuen position
t = np.linspace(0,100, 5000)
a = np.exp(np.cos(t))-2*np.cos(4*t)-np.sin(t/12)**5
curve_pos = [np.sin(t)*a, np.cos(t)*a] #x- und zugehörige y-Werte

# initialisierung der animation (startbild)
def init():
    curve.set_data(curve_pos[0], curve_pos[1])
    pos.set_data([],[])
    text.set_text('')
    return pos,text

# animationsschritt
def step(i):
    pos.set_data([curve_pos[0][i]],[curve_pos[1][i]])
    text.set_text("Schritt "+str(i))
    return pos,text

# interval gibt an, wie lange gewartet wird in ms
# blit=True (nicht alles wird sets neu gezeichnet)
# drittes argument gib an wie sich der index i in step(i) verhält
ani = animation.FuncAnimation(fig, step, np.arange(1, len(t)),
                              interval=25, blit=True, init_func=init)

# als film speichern (mit 15 fps)
# ani.save('butterfly.mp4', fps=15)

# anzeigen
plt.show()

import sys
from PyQt5 import QtWidgets as qw
from PyQt5 import QtGui as qg
# from PyQt5 import QtCore as qc

from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar
import matplotlib.pyplot as plt
import numpy as np

class PlotWindow(qw.QDialog):
    def __init__(self, parent=None):
        super(PlotWindow, self).__init__(parent)

        # das Diagramm auf dem wir zeichnen
        self.figure, self.axis = plt.subplots()

		# FigueCanvas ist ein qt-Widget, das das Diagramm anzeigen kann
        self.canvas = FigureCanvas(self.figure)

        # die Matplotlib-NavigationsLeiste
        self.toolbar = NavigationToolbar(self.canvas, self)

		# Layout (wie Sie es bereits kennen)
        self.button = qw.QPushButton('Plot')
        self.button.clicked.connect(self.plot)
        layout = qw.QVBoxLayout()
        layout.addWidget(self.toolbar)
        layout.addWidget(self.canvas)
        layout.addWidget(self.button)
        self.setLayout(layout)

	# Die Plot-Funktion kann nun wie vorher definiert werden:
    def plot(self):
        x = np.linspace(0,10, 250)
        y = np.cos(x)*np.cos(2*x)+np.sin(x)

        # Zeichnen und Anzeige
        self.axis.plot(x, y)

        # Achtung: keine plt.show!
        # (Neu-)Zeichnen des Canva
        self.canvas.draw()

if __name__ == '__main__':
    app = qw.QApplication(sys.argv)
    main = PlotWindow()
    main.show()

    sys.exit(app.exec_())

• QtCore enthält alle nicht-GUI-Klassen, die auch von den anderen PyQt-Modulen verwendet werden.
• QtWidgets enthält GUI-Komponenten, um klassische UI-Fenster zu strukturieren. (Buttons, Fenster, Textfelder, etc.)
• QtGui enthält auch GUI-Komponenten, jedoch auf einer etwas niedriger liegenden Ebene: Bilder, 2D-Graphik, Schrift, Event-Handling

import sys
from PyQt5 import QtWidgets as qw
from PyQt5 import QtGui as qg
from PyQt5 import QtCore as qc

# Verwendung später:
qw.QKlasseAusQtWidgets(...)
qg.QKlasseAusQtGui(...)
qw.QKlasseAusQtCore(...)

import sys
from PyQt5.QtWidgets import QKlasseAusQtWidgets
from PyQt5.QtGui import QKlasseAusQtGui
from PyQt5.QtCore import QKlasseAusQtCore

# Verwendung später:
QKlasseAusQtWidgets(...)
QKlasseAusQtGui(...)
QKlasseAusQtCore(...)

# Initialisierung des Programms und Ihrer GUI
app = qw.QApplication(sys.argv)

# ...
# Ihr Programmcode
# ...

# Starten der Ereignisschleife (engl. event loop; Abfangen von Klicken, 
# Tippen, etc.) und beenden des gesamten Programms beim Beenden des Qt-Teils 
# (dies geschieht standardmäßig beim Schließen aller Fenster).
# Diese beiden Schritte zu trennen ist innerhalb dieses Praktikums nicht nötig.
sys.exit(app.exec_())

import sys
from PyQt5 import QtWidgets as qw
from PyQt5 import QtGui as qg
from PyQt5 import QtCore as qc

app = qw.QApplication(sys.argv)
w = qw.QWidget()
b = qw.QLabel(w)
b.setText("Hallo Welt!")
w.setGeometry(120,120,200,50)
b.move(100,200)
w.setWindowTitle("Tadaa, ein Fenster")
w.show()
sys.exit(app.exec_())

import sys
from PyQt5 import QtWidgets as qw
from PyQt5 import QtGui as qg
from PyQt5 import QtCore as qc

app = qw.QApplication(sys.argv)
fenster1 = qw.QWidget()
fenster2 = qw.QWidget()
fenster3 = qw.QWidget()
% w.setGeometry(120,120,200,50)

# Fensternamen
fenster1.setWindowTitle("Das ist Fenster 1") # angezeigter Fenstername
fenster2.setWindowTitle("Das ist Fenster 2 (maximiert)")
fenster3.setWindowTitle("Das ist Fenster 3 (minimiert)")

# typische Fenstermanipulation
fenster1.resize(300, 500) # Größe festlegen
fenster1.move(10,10)      # auf dem Bildschirm verschieben

# Anzeigen der Fenster
fenster1.show()
fenster2.showMaximized()
fenster2.showMinimized()

Fenster auf dem Bildschirm zentrieren

# Zentrieren auf dem Bildschirm
fg = fenster4.frameGeometry()
centrum = QDesktopWidget().availableGeometry().center()
fg.moveCenter(center)
fenster4.move(fg.topLeft())

Ableiten von QWidget

import sys
from PyQt5 import QtWidgets as qw
class MyGUIProgram(qw.QWidget):

	# statische (optionale) Methode zum Starten
	# des GUI-Programms
	def spawn():
		app = qw.QApplication(sys.argv)
		MyGUIProgram()
		sys.exit(app.exec_())

	# Konstruktor
	def __init__(self):
		# Konstruktor von QWidget
		super().__init__()

		# gute Idee: Lagern Sie Code aus, um Ihren Code
		# übersichtlich zu halten
		self.setWindowTitle('SnakeGame')
		self.init_mainWindow() #ausgelagerte GUI-Erstellung
		self.show()

if __name__ == "__main__":
	MyGUIProgram.spawn()

b = qw.QPushButton("drück mich!")
b.resize(150,200)
b.show()

QPushButton

btn = qw.QPushButton("drück mich!")
btn.setDefault()        # Standard-Button
btn.setEnabled(False)   # ausgegraut

btn.clicked.connect(fn) # fn wird bei Klick ausgeführt 
# (es sind "echte" Funktionen oder lambda-Ausdrücke möglich, z.B.)
btn.clicked.connect(lambda: print("hey"))
def clicked():
	print("ho")
btn.clicked.connect(clicked)
btn.pressed.connect(fn) # sobald Maus gedrückt wird
btn.released.connect(fn)# sobald Maus losgelassen wird

QLabel

lbl = qw.QLabel("Ha! Du kannst mich nicht ändern!")
lbl2 = qw.QLabel()
lbl2.setText("nachträglich verändert")
lbl2.setAlignment(qc.Qt.AlignRight)     # Ausrichtung

QLineEdit

le  = qw.QLineEdit()
le2 = qw.QLineEdit("Initialtext")

# Einstellungen
le.setMaxLength(10)                   # Maximallänge
le.setAlignment(qc.Qt.AlignRight)     # Ausrichtung
le.setFont(qg.QFont("Arial", 20))     # Schriftart (Arial, Größe 20)

# direkte Validierung
le2.setValidator(QIntValidator())     # nur Ganzzahlen
le2.setValidator(QDoubleValidator())  # nur Fließkommazahlen 
le2.setValidator(QDoubleValidator(0.99, 99.99, 2))  # (festes Format)

# signals (wie bei QPushButton)
le2.cursorPositionChanged.connect(fn) # Parameter: (int alt, int neu)
le2.editingFinished.connect(fn)
le2.selectionChanged.connect(fn)
le2.textChanged.connect(fn)           # parameter: QString
le2.textEdited.connect(fn)            # parameter: QString

QCheckBox

cb = qw.QCheckBox("Possibility 1")
cb.setChecked(True) # Standardmäßig an oder aus?
cb.setText("abc")
cb.text()           # getter (hier: "abc")
cb.isChecked()

# Funktionsaufruf bei Statusänderung
cb.toggled.connect(fn)

Absolute Positionierung

# Initialisierung wie üblich
import sys
from PyQt5 import QtWidgets as qw
from PyQt5 import QtGui as qg
from PyQt5 import QtCore as qc
app = qw.QApplication(sys.argv)

win = qw.QWidget()			
win.setGeometry(10, 30, 300, 200) # Position: (10,30) auf dem Bildschirm
                                  # Größe:  (300,200)
btn = qw.QPushButton("Jim",win)
btn.move(20,20)                   # Position (20,20) in parent=win
btn2 = qw.QPushButton("Jim2",parent=win)
btn2.move(120,120)                # Position (120,120) in parent=win

# Anzeigen und Starten
win.show()
app.exec_()

• bei Größenänderungen einzelner Widgets oder des Hauptfensters müsste das ganze Layout angepasst werden,
• Layoutänderungen können mühsam werden, da eine Größenänderungen eines Elements Änderungen an allen anderen Elementen nach sich ziehen kann,
• die Darstellung des Layouts kann sich auf verschiedenen Geräten und diversen Auflösungen unterscheiden.

QHBoxLayout und QVBoxLayout

# Initialisierung wie üblich
import sys
from PyQt5 import QtWidgets as qw
from PyQt5 import QtGui as qg
from PyQt5 import QtCore as qc
app = qw.QApplication(sys.argv)

win = qw.QWidget()
btn1 = qw.QPushButton("Jim")
btn2 = qw.QPushButton("Benjamin")
lbl = qw.QLabel("Entscheide dich:")
btn3 = qw.QPushButton("blau")
btn4 = qw.QPushButton("rot")

vbox = qw.QVBoxLayout()
vbox.addWidget(btn1)     # erst btn1
vbox.addWidget(btn2)     # darunter btn2
vbox.addStretch()        # skalierter leerer Platz
vbox.addWidget(lbl)      # darunter ein Label

hbox = qw.QHBoxLayout()
vbox.addLayout(hbox)     # darunter ein neues Layout (als Widget)

hbox.addWidget(btn3)     # links:  btn3
hbox.addStretch()        # Mitte:  gestreckte leere Fläche
hbox.addWidget(btn4)     # rechts: btn4

win.setLayout(vbox)
win.show()
app.exec_()

QFormLayout

# Initialisierung wie üblich
import sys
from PyQt5 import QtWidgets as qw
from PyQt5 import QtGui as qg
from PyQt5 import QtCore as qc
app = qw.QApplication(sys.argv)

win = qw.QWidget()

form = qw.QFormLayout()
form.addRow(qw.QLabel("test"), qw.QLineEdit())
form.addRow(qw.QLabel("name"), qw.QPushButton())

hbox = qw.QHBoxLayout()
hbox.addWidget(qw.QCheckBox("check1"))
hbox.addWidget(qw.QCheckBox("check2"))
hbox.addWidget(qw.QCheckBox("check3"))

form.addRow(qw.QLabel("check"), hbox)

win.setLayout(form)      # Wichtig! Erst hier wird das Layout an win angefügt
win.show()
app.exec_()

QGridLayout

# Initialisierung wie üblich
import sys
from PyQt5 import QtWidgets as qw
from PyQt5 import QtGui as qg
from PyQt5 import QtCore as qc
app = qw.QApplication(sys.argv)

win = qw.QWidget()	
grid = qw.QGridLayout()

# einzelne Zellen
for i in range(1,4):
	for j in range(1,3):
		grid.addWidget(qw.QPushBu("Knopf"+str(i)+"/"+str(j)), i,j) # Position (i,j)

# mehrere Zellen
grid.addWidget(qw.QPushBut("Knopf Quad"), 1,3, 2, 2) # Position (1,3), Größe (2,2)
grid.addWidget(qw.QPushBut("Knopf Lang"), 1,5, 4, 1)
grid.addWidget(qw.QPushBu("Knopf Breit"), 4,1, 1, 2)

# Layouts selbst können auch hinzugefügt werden
grid.addLayout(...)

win.setLayout(grid)
win.show()
app.exec_()

# Initialisierung wie üblich
import sys
from PyQt5 import QtWidgets as qw
from PyQt5 import QtGui as qg
from PyQt5 import QtCore as qc
app = qw.QApplication(sys.argv)

win = qw.QWidget()

form = qw.QFormLayout()
testlbl = qw.QLabel("test")
testlbl.setToolTip("Informationen zum Label Test")
le = qw.QLineEdit()
# Der Text kann dabei auch formattiert werden
le.setToolTip("<u>Hier</u> muss <b>eine Eingabe</b> vorgenommen werden.")
form.addRow(testlbl, le) 

win.setLayout(form)      # Wichtig! Erst hier wird das Layout an win angefügt
win.show()
app.exec_()

Entscheidungs-Dialog

def dialog():
	d = qw.QDialog()
	d.setWindowTitle("Dialogtitel")

	# kann der Dialog umgangen werden um andere Fenster zu bedienen?
	d.setWindowModality(qc.Qt.ApplicationModal) # nein (Standard)
	# d.setWindowModality(qc.Qt.WindowModal)    # ja

	# ... wie QWidget verwendbar
	btnok = qw.QPushButton("Ok, lass mich in ruhe.",d)
	btnno = qw.QPushButton("Nein.",d)
	hbox = qw.QHBoxLayout()
	hbox.addWidget(btnok)
	hbox.addWidget(btnno)
	d.setLayout(hbox)

	# akzeptieren / ablehnen
	btnok.clicked.connect(lambda: d.accept())
	btnno.clicked.connect(lambda: d.reject())

	# bei Fehler / Erfolg an Hauptfenster melden
	d.rejected.connect(lambda: b.setText("Oh, wie schade!"))
	d.accepted.connect(lambda: b.setText("Erfolg!"))

	# Extras
	btnok.setDefault(True)           # btn wird bei Enter gedrückt
	d.exec_()                        # Fenster ausführen

w = qw.QWidget()	
b = qw.QPushButton("Die Entscheidung",w)
b.clicked.connect(dialog)
w.show()

Dateiauswahl-Dialog

def fdialog():
	d = qw.QFileDialog()
	d.setWindowTitle("Dialogtitel")

	# bei Auswahl einer Datei
	d.fileSelected.connect(lambda file: lbl.setText(file))
	
	d.exec_()                        # Fenster ausführen

w = qw.QWidget()	
hbox = qw.QHBoxLayout()
lbl = qw.QLineEdit("standarddateiname.txt")
hbox.addWidget(lbl)
b = qw.QPushButton("Dateiauswahl")
hbox.addWidget(b)
b.clicked.connect(fdialog)
w.setLayout(hbox)
w.show()

timer = QTimer()
timer.setInterval(300)    # Timer-Reset alle 300ms
timer.timeout.connect(fn) # fn sei die Funktion, die aufgerufen werden soll
timer.start(ms)           # ms: Anzahl der Millisekunden, nach denen der Timer die 
                          # Ausführung von fn erstmals startet. (Standardmäßig ms=0)
timer.stop()              # Timer anhalten
timer.setSingleShot(True) # einmalige Ausführung von fn
timer.isActive()

• QPixmap repräsentiert dabei ein off-screen Bild, auf dem mithilfe der Klasse QPainter gemalt werden kann. QPainter kann dabei alles, was ein Zeichenprogramm wie Paint auch kann: Quadrate, Kreise, Text zeichnen und dabei eine Auswahl an Pinseln verwenden.
• QImage repräsentiert hingegen die "rohen" Pixeldaten, die per Hand geändert werden können.

Anzeigen einer Bilddatei

import sys
from PyQt5 import QtWidgets as qw
from PyQt5 import QtGui as qg
from PyQt5 import QtCore as qc
app = qw.QApplication(sys.argv)

# in QLabel wird das Bild angezeigt
display = qw.QLabel()

# Laden der Datei in eine Pixmap (nicht direkt bearbeitbar)
bild = qg.QPixmap("bild.png")
display.setPixmap(bild)

# Alternativ: QImage (muss zu QPixmap konvertiert werden)
bild = qg.QImage("bild.png")
display.setPixmap(qg.QPixmap.fromImage(bild))

# Fenster anzeigen
display.show()
app.exec_()

Skalieren eines Bildes

# Möglichkeit 1
display = qw.QLabel()
display.resize(200,300)
pixmap = ... # wie oben qg.QPixmap(...) oder qg.QPixmap.fromImage(...)
scaledpixmap = pixmap.scaled(display.size(), Qt.KeepAspectRatio)
display.setPixmap(scaledpixmap)

# Möglichkeit 2
display = qw.QLabel()
pixmap = ... # wie oben qg.QPixmap(...) oder qg.QPixmap.fromImage(...)
scaledpixmap = pixmap.scaled(200,300, Qt.KeepAspectRatio)
display.setPixmap(scaledpixmap)

Erstellen und Manipulation eines Bildes

# wir erstellen zuerst das Bild
breite, hoehe = 400, 300
# QImage-Formate: http://doc.qt.io/qt-5/qimage.html#Format-enum
img = qg.QImage(breite, hoehe, qg.QImage.Format_RGBA8888)
img.fill(qc.Qt.white) # Bild mit Standardwerten füllen (Wichtig!)

# das Format der Pixelfarbe lautet 0xRRGGBBAA, wobei
# RR, GG, BB jeweils die Hex-Darstellung der Farbwerte für 
# Rot, Grün und Blau zwischen 0 und 255 ist (d.h. 195 entspräche C3). 
# 0 bedeutet, dass die Farbe nicht vorhanden ist, 
# 255 ist der Maximalwert jeder Farbe.
# AA beschreibt die Transparenz (0 für Transparent, 255 für Sichtbar)
img.setPixel(10,20, 0x00ff00ff) # Grün

# das Setzen von Hex-Werten bedarf einiger Übung und Gewöhnung.
# Glücklicherweise ist es auch möglich, die Farbwerte im 10er-System
# anzugeben (Werte jeweils zwischen 0 und 255).
img.setPixelColor(20,40,qg.QColor(20,30,155)) 

# Anzeigen in QLabel
display.setPixmap(qg.QPixmap.fromImage(img))

# neue Manipulation ist erst beim Neu-Zeichnen sichtbar!
img.setPixelColor(80,80,qg.QColor(20,30,155)) 

# erneut Zeichnen
display.setPixmap(qg.QPixmap.fromImage(img))

Erstellen eines Bildes aus einem Numpy-Array

breite, hoehe = 400, 300
npbild = np.zeros([hoehe,breite,4], dtype=np.uint8) # RGBA (A: Transparenz)
npbild += 255 # nun ist das Bild weiß
npbild[20,30,:] = [135,23,53,255] # setzen eines Farbpixels im Numpy-Array
npbild[20,30,0] = 255             # setzen des Rotwertes eines anderen Pixels
img = QImage(npbild, breite, hoehe, QImage.Format_RGBA8888)

Speichern eines Bildes

# wir erstellen zuerst das Bild
breite, hoehe = 400, 300
img = qg.QImage(breite, hoehe, qg.QImage.Format_RGBA8888)
img.fill(qc.Qt.white) # Bild mit Standardwerten füllen (Wichtig!)

# Ändern von Pixelinformationen
img.setPixel(10,20, 0x00ff00ff) # Grün

img.save("neues_bild.png")

QPainter Grundfunktionen

import sys
from PyQt5.QtWidgets import *
from PyQt5.QtGui import *
from PyQt5.QtCore import *
app = QApplication(sys.argv)

# Qlabel zum Anzeigen des Bildes
display = QLabel()
display.setGeometry(QRect(0,0,400, 600))

# unsere Hauptzeichenfläche
canvas = QImage(400,600, QImage.Format_RGBA8888)
painter = QPainter(canvas)

# Linien
linienbreite = 2
painter.setPen(QPen(Qt.blue, linienbreite, Qt.DotLine, Qt.SquareCap, Qt.BevelJoin))
painter.drawLine(50,50,50,100)
painter.setPen(QPen(QColor(100,200,300,50), 5*linienbreite, Qt.SolidLine, Qt.RoundCap, Qt.BevelJoin))
painter.drawLine(70,50,70,100)

# Rechtecke (beachten Sie die Verwendung von Stiften (Pen) und Pinseln (Brush)
painter.fillRect(100,50,150,200,Qt.white)
painter.setPen(QPen(Qt.red, linienbreite, Qt.DashLine, Qt.SquareCap, Qt.BevelJoin))
painter.drawRect(120,70,170,220)
painter.setPen(Qt.NoPen)
painter.setBrush(Qt.green)
painter.drawRect(220,170,270,320)

# Ellipsen
painter.setBrush(Qt.NoBrush)
painter.setPen(QPen(QColor(0,150,150,100), 20))
painter.drawEllipse(QPoint(230,180),30,50)

# Text
painter.setPen(Qt.black)
groesse = 20
painter.setFont(QFont("Helvetica", groesse));
painter.drawText(100,300, "Hallo Welt!")

display.setPixmap(QPixmap.fromImage(canvas))
display.show()
sys.exit(app.exec_())

Bildebenen

# Qlabel zum Anzeigen des Bildes
display = QLabel()
display.setGeometry(QRect(0,0,width*zoom, height*zoom))

# unsere Hauptzeichenfläche
canvas = QPixmap(1000,500) # oder QImage
painter = QPainter(canvas)

# Hintergrund Ebene
ebene1 = QPixmap(1000,500) # oder QImage
painter1 = QPainter(ebene1)
# ... langsamer code, komplexes Zeichnen der Ebene

# Objekt auf eigener Ebene
ebene2 = QPixmap(200,300) # oder QImage
painter2 = QPainter(canvas)
# langsamer code, komplexes Zeichnen der Ebene

# ... in der redraw-Schleife
    # weiß färben
    painter.fillRect(0,0,1000,500,Qt.white)

    # Hintergrund hinzufügen, (0,0) ist die Startposition
	painter.drawPixmap(0,0,ebene1) # bei QImage: .drawImage(...)

    # Objekt hinzufügen
	painter.drawPixmap(234,345,ebene2) # bei QImage: .drawImage(...)

    # skalieren auf die Größe der Zeichenfläche
	# für Canvas vom Typ: QPixmap
    display.setPixmap(canvas)
	# für canvas vom Typ: QImage
	display.setPixmap(QPixmap.fromImage(canvas))

# Initialisierung wie üblich
import sys
from PyQt5 import QtWidgets as qw
from PyQt5 import QtGui as qg
from PyQt5 import QtCore as qc
app = qw.QApplication(sys.argv)
	
main = qw.QMainWindow()
main.resize(500,600)
main.setWindowTitle("Hauptfenster")

# Zentrale Teil kann wie Üblich gefüllt werden
win = qw.QWidget()
main.setCentralWidget(win)
hbox = qw.QHBoxLayout()
win.setLayout(hbox)
hbox.addWidget(qw.QPushButton("links"))
hbox.addWidget(qw.QPushButton("Mitte"))
hbox.addWidget(qw.QPushButton("rechts"))

# MainWindow hat auch eine Statusleiste
# (diese kann selbst auch Widgets anzeigen)
stat = main.statusBar()
# stat.addWidget(qw.QLabel("Statustext")) # linksbündig, wird evtl. von showMessage überblendet
stat.addPermanentWidget(qw.QLabel("Statustext2")) # rechtsbündig
stat.showMessage("wird 2s lang eingeblendet", 2000)
# stat.showMessage("wird angezeigt, bis gelöscht wird")
# stat.clearMessage() # löschen angezeigter Nachrichten

# ... und auch eine Menüleiste
menu = main.menuBar()
menu.setNativeMenuBar(False) # optional: OS X stellt das Menü anders dar

m1 = menu.addMenu("Datei")
m1.addAction("Neu")
# Menüeintrag mit Tastenkürzel
m1.addAction("Öffnen")
m1sub = m1.addMenu("Untermenü")
m1sub.addAction("Versteckt")
m1.addSeparator()
close = qw.QAction("Beenden", main)
close.setShortcut("Ctrl+Q")
close.setStatusTip("Schließt das Programm")
close.triggered.connect(lambda: main.close())

m1.addAction(close)
m2 = menu.addMenu("Bearbeiten")
for i in range(3):
	for j in range(4):
		m2.addSeparator()
		m2.addAction("Platzhalter")
menu.addSeparator()

def opendialog(clickable):
	dialog = qw.QDialog()
	dialog.resize(200,150)
	qw.QLabel("Programmversion 3.1415",dialog)
	dialog.exec_()
m3 = menu.addMenu("Info")
info = m3.addAction("Info")
info.triggered.connect(opendialog)

main.show()
app.exec_()

Tastaturevents

# Initialisierung wie üblich
import sys
from PyQt5 import QtWidgets as qw
from PyQt5 import QtGui as qg
from PyQt5 import QtCore as qc
app = qw.QApplication(sys.argv)

# Einfaches Layout (nur eine leere Fläche)
win = qw.QMainWindow()            
win.setGeometry(10, 30, 300, 200) # Position: (10,30) auf dem Bildschirm
                                  # Größe:  (300,200)

# Tastendruck in QMainWindow abfangen 
def fn(e):
    win.statusBar().showMessage("Taste mit key-code "+str(e.key())+" gedrückt", 1000)
    if e.key() == qc.Qt.Key_Escape:
        win.close()
win.keyPressEvent = fn

# Anzeigen und Starten
win.show()
app.exec_()

# Initialisierung wie üblich
import sys
from PyQt5 import QtWidgets as qw
from PyQt5 import QtGui as qg
from PyQt5 import QtCore as qc

class TastenTest(qw.QWidget):
    
	# einfaches Layout
	def __init__(self):
		super().__init__()
		self.setGeometry(10, 30, 300, 200)
		self.show()

	# Überladen der leeren Standardfunktion
	def keyPressEvent(self, e):
		self.statusBar().showMessage("Taste mit key-code "+str(e.key())+" gedrückt", 1000)
		if e.key() == qc.Qt.Key_Escape:
			win.close()
        
if __name__ == '__main__':
	app = qw.QApplication(sys.argv)
	ex = TastenTest()
	sys.exit(app.exec_())

• qc.Qt.Key_Escape
• qc.Qt.Key_Return
• qc.Qt.Key_Print (Drucken-Taste)
• qc.Qt.Key_Left, qc.Qt.Key_Right, qc.Qt.Key_Up, qc.Qt.Key_Down (Pfeiltasten)
• qc.Qt.Key_F1, qc.Qt.Key_F2, qc.Qt.Key_F..., qc.Qt.Key_F35 (Funktionstasten)
• qc.Qt.Key_0, qc.Qt.Key_1, qc.Qt.Key_..., qc.Qt.Key_9 (Zifferntasten)
• qc.Qt.Key_A, qc.Qt.Key_B, qc.Qt.Key_..., qc.Qt.Key_Z

Mausevents

import sys
from PyQt5 import QtWidgets as qw
from PyQt5 import QtGui as qg
from PyQt5 import QtCore as qc

class MausTest(qw.QMainWindow):
    
    # einfaches Layout
    def __init__(self):
        super().__init__()
        self.setGeometry(10, 30, 300, 200)
        self.show()
    
        # Mouse-Events werden sonst nur aufgerufen, wenn eine Maustaste gedrückt wird.
        self.setMouseTracking(True)

    # Überladen der leeren Standardfunktion
    def mouseMoveEvent(self, e):
        self.statusBar().showMessage("Maus-Position ("+str(e.x())+","+str(e.y())+")", 1000)
        if e.button() == qc.Qt.LeftButton:
            self.statusBar().showMessage("Maus-Position ("+str(e.x())+","+str(e.y())+") + Linke Maustaste", 1000)
        
if __name__ == '__main__':
    app = qw.QApplication(sys.argv)
    ex = MausTest()
    sys.exit(app.exec_())

Andere Events