Bevor wir unser erstes Spiel mit PsychoPy programmieren, müssen wir uns erstmal mit den Grundlagen vertraut machen. Es ist nicht die beste Wahl für die Entwicklung von Spielen, dafür eignen sich Python Arcade oder PyGame besser. Aber es ist die beste Python-Bibliothek für die Entwicklung psychophysischer Experimente (und das ist es, was wir wollen).
Kopier den folgenden Code in die Datei code01.py (du hast doch eine neue Mappe für das Kapitel erstellt, oder?):
"""
Ein minimaler PsychoPy-Code.
"""
# das importiert zwei Module aus psychopy
# visual hat alle visuellen Reize, einschließlich der Window-Klasse
# die wir benötigen, um ein Programmfenster zu erstellen
# event hat Funktionen für die Arbeit mit Maus und Tastatur
from psychopy import visual, event
# ein 800 x 600 Fenster erstellen
win = visual.Window(size=(800, 600))
# auf Tastendruck warten
event.waitKeys()
# das Fenster schließen
win.close()Lauf es, um zu prüfen, ob PsychoPy funktioniert. Wenn du einen Fehler bekommst, der besagt, dass die psychopy-Bibliothek nicht gefunden wurde, überprüfe den aktiven Python-Interpreter. Du solltest ein graues Fenster mit der Überschrift PsychoPy erhalten. Drücke eine beliebige Taste (klicke auf das Fenster, falls du zu einem anderen gewechselt hast, damit es die Tasteneingabe registriert) und es sollte sich schließen. Nicht sehr aufregend, aber es zeigt, dass alles wie erwartet funktioniert.
Füge den Code in code01.py
Der Code ist einfach, aber packt einige neue Sachen. Die erste Zeile ist easy, wir importieren einfach visual und event Module aus der psychopy Bibliothek (eine Bibliothek kann selbst in Unterbibliotheken organisiert sein, um Dinge noch modularer zu gestalten). Dann erstellen wir ein Objekt win using eine Klasse Window mit einer benutzerdefinierten Größe. Die dritte Zeile verwendet die Funktion waitKeys() aus dem event Modul, um auf eine Tasteneingabe zu warten. Die letzte schließt das Fenster, indem sie seine close Methode aufruft. Du solltest keine Probleme mit Zeile #1 und #3 haben, aber du musst etwas über objektorientierte Programmierung lernen, um Zeile #2 und #4 zu verstehen.
Die PsychoPy-Bibliothek ist eine Sammlung von Klassen, die du verwendest, um Objekte zu erstellen, eine Methode, die als objektorientierte Programmierung bekannt ist. Die Kernidee steckt im Namen: Statt Variablen (Daten) und Funktionen (Aktionen) getrennt zu halten, kombinierst du sie in einem Objekt, das eigene Attribute (Variablen) und Methoden (Funktionen) hat. Diese Methode nutzt unsere natürliche Neigung, die Welt als Sammlung von interagierenden Objekten wahrzunehmen.
Erstmal musst du den Unterschied zwischen Klassen und Objekten verstehen. Eine Klasse ist sozusagen eine “Bauplan”, das die Eigenschaften und das Verhalten aller Objekte dieser Klasse beschreibt. Dieser “Bauplan” wird verwendet, um ein Exemplar dieser Klasse zu erstellen, das ein Objekt genannt wird. Zum Beispiel ist Homo sapiens eine Klasse, die Arten beschreibt, die bestimmte Eigenschaften wie Größe haben und bestimmte Dinge tun können, wie zum Beispiel Laufen. Allerdings hat Homo sapiens als Klasse nur eine Idee von Größe, aber keine spezifische Größe selbst. Du kannst also nicht fragen “Wie groß ist Homo sapiens?”, sondern nur, welche durchschnittliche (mittlere, mediane usw.) Größe die Individuen dieser Klasse haben. Genauso wenig kann man sagen: „Lauf, Homo sapiens! Lauf!“, denn abstrakte Konzepte haben Schwierigkeiten, solche realen Handlungen auszuführen. Stattdessen ist Alexander Pastukhov eine Instanz der Klasse Homo sapiens mit einer bestimmten (durchschnittlichen) Größe und einer bestimmten (unterdurchschnittlichen) Fähigkeit zu laufen. Andere Instanzen von Homo sapiens (andere Menschen) haben eine andere Größe und eine andere (typischerweise bessere) Fähigkeit zu laufen. Eine Klasse beschreibt also alle gemeinsamen Eigenschaften und Methoden, die alle Instanzen der Klasse (alle Objekte) haben werden. Aber ein einzelnes Objekt wird sich aufgrund der unterschiedlichen Werte seiner Eigenschaften unterschiedlich verhalten. Wenn Sie also einen Homo sapiens treffen, können Sie sicher sein, dass er per se groß ist, aber Sie müssen sich eine individuelle Instanz ansehen, um herauszufinden, welche Größe er hat.
Window ist eine Klasse, die Eigenschaften beschreibt, die ein PsychoPy-Fenster haben muss, und Aktionen, die es ausführen kann (du kannst die vollständige Liste in der Dokumentation sehen). Um ein Objekt zu erstellen, verwenden wir seine Klassendefinition und speichern das Ergebnis in einer Variablen. Im obigen Code rufen wir die Window-Klasse1 auf, während wir ihr personalisierte Parameter übergeben (size=(800, 600)) und speichern ein Objekt, das sie zurückgibt, in der Variablen win.
Attributes sind im Grunde genommen Variablen, die zur Klasse gehören und somit Variablen, die jedes Objekt besitzen wird. Zum Beispiel hat eine Window-Klasse ein size-Attribut, das seine Bildschirmgröße in Pixeln bestimmt. Es hat auch (Hintergrund-) color, ein Attribut, das bestimmt, ob es im Vollbildmodus angezeigt werden soll, usw. Also wird ein win-Objekt alle diese Attribute haben und sie werden spezifische Werte haben.
Um die Eigenschaften und die Unterscheidung zwischen Klasse/Objekt besser zu verstehen, setze einen Breakpoint auf der dritten Codezeile (event.waitKeys()) und starte den Debugger über F5. Sobald das Fenster erstellt wurde, wird die Ausführung pausieren und du wirst ein win-Objekt in Variables/Locals finden. Klicke darauf und es wird sich erweitern, um alle Attribute und ihre Werte anzuzeigen, einschließlich size (stelle sicher, dass es [800, 600] ist). Beachte, dass du Window selbst nicht in der gleichen Liste sehen wirst. Dies liegt daran, dass es eine Klasse ist, ein abstraktes Konzept, während win ihr Instanz und Objekt dieser Klasse ist.
Methode wie Window.close() sind im Grunde genommen Funktionen, die zur Klasse/Objekt gehören und bestimmte Aktionen am Objekt durchführen. Zum Beispiel schließt die Methode close() das Fenster, flip() aktualisiert es, nachdem wir darin gezeichnet haben, usw. Wichtig ist zu beachten, dass jede Methode nur auf dem Objekt zu dem sie gehört wirkt und nicht auf anderen Instanzen der gleichen Klasse. Das bedeutet, dass du zwei Fenster (win1 und win2) erstellen kannst und win1.close() nur das erste, aber nicht das zweite Fenster schließt (versuche es aus!). Gleiches gilt für Attribute, ihre Änderung in einem Objekt beeinflusst keine anderen Objekte der gleichen Klasse, genau wie die Änderung eines Wertes in einer Variablen keine anderen beeinflusst.
Okay, du hast ja nur einen kleinen Einblick in die objektorientierte Programmierung bekommen, aber das sollte reichen, um die von PsychoPy definierten Klassen verwenden zu können.
In der visual.Window(size=(800, 600))-Aufrufzeile gibt es noch ein paar interessante Dinge, über die wir sprechen müssen. Diese Merkwürdigkeiten beziehen sich auf Funktionen (und damit auf Methoden, die Funktionen sind, die zu einer Klasse gehören) und nicht auf Klassen an sich. Erstens hat die Konstruktor-Methode der Window-Klasse viele Argumente (wenn wir ein Objekt konstruieren, rufen wir eine Konstruktor-Methode der Klasse auf, deshalb sprechen wir über Funktionen). Und doch haben wir nur eines davon übergeben. Das liegt daran, dass du für einzelne Parameter Standardwerte festlegen kannst. In diesem Fall wird, wenn ein Parameter weggelassen wird, ein Standardwert verwendet.
def divide(x1, x2=2):
"""
Teilt Zahlen, verwendet 2 als zweiten Wert, wenn ein zweiter Term weggelassen wird.
Parameters
----------
x1 : float
x2 : float, default=2
Returns
----------
float
"""
return x1 / x2
print(divide(2)) # wir übergeben nur den Wert für x1 und der Standardwert wird für x2 verwendet
print(divide(2, 4))1.0
0.5Wenn du die Dokumentation ansiehst, wirst du sehen, dass für den Window-Klassen-Konstruktor alle Parameter einen Standardwert haben. Das ist ein Teil der PsychoPy-Philosophie, die reichhaltige Anpassungsfähigkeit (schau dir nur die Anzahl der Parameter an!) mit Einfachheit der Benutzung durch sinnvolle Standardwerte verbindet (spezifiziere nichts und das Fenster funktioniert trotzdem).
Zweitens, wir haben den Wert nicht nur übergeben, sondern auch angegeben, für welchen Parameter dieser Wert bestimmt ist, und zwar über size=(800, 600). Diese Schreibweise nennt sich Schlüsselwortargumente. Der Vorteil besteht darin, dass es eindeutiger macht, welchen Parameter du einem Wert zuweist. Außerdem kannst du die Parameter in beliebiger Reihenfolge angeben, solange es im Kontext sinnvoll ist2. Wenn du keine Namen verwendest, werden die Werte den einzelnen Parametern basierend auf ihrer Position (auch bekannt als Positionsparameter) zugewiesen. Du kannst sogar beides mischen, aber Positionsparameter müssen zuerst kommen, siehe Dokumentation, wenn du mehr erfahren möchtest.
# Verwendung von Positionsparametern
print(divide(2, 4))0.5# mit Keyword-Argumenten
print(divide(x2=4, x1=2))0.5# Mixen von Positions- und Keyword-Argumenten
print(divide(2, x2=4))0.5print(divide(2, x1=4))--------------------------------------------------------------------------- TypeError Traceback (most recent call last) Cell In[5], line 1 ----> 1 print(divide(2, x1=4)) TypeError: divide() got multiple values for argument 'x1'
Momentan passiert in unserem Programm nicht viel. Eine Sache, die wir hinzufügen müssen, ist eine Schleife, in der wir wiederholt in ein Fenster zeichnen (und es über seine flip()-Methode aktualisieren) können, die Benutzereingabe überprüfen und andere notwendige Aktionen durchführen.
Okay, dann fangen wir mal damit an, die Schleife und die Verarbeitung von Benutzereingaben hinzuzufügen (das lustige Zeichenteil kommt als nächstes). Die Schleife befindet sich zwischen dem Öffnen und Schließen des Fensters:
importiere Bibliotheken
öffne das Fenster
--> unsere Hauptschleife <--
Schließen des FenstersDie Schleife sollte wiederholt werden, bis der Benutzer die Escape-Taste drückt, und daher benötigst du eine Variable, die dies signalisiert. Mein Ansatz ist, eine Variable gameover zu erstellen und sie auf False zu initialisieren und die Schleife solange zu wiederholen, bis das Spiel vorbei ist. Dann, innerhalb der Schleife, verwende die Funktion event.getKeys(), um zu überprüfen, ob die Escape-Taste gedrückt wurde (dazu musst du keyList=['escape'] übergeben). Die Funktion gibt eine Liste von Tasten zurück, wenn eine davon in der Zwischenzeit gedrückt wurde, oder eine leere Liste, wenn keine Tasten aus der keyList gedrückt wurden. Speichere diesen zurückgegebenen Wert in einer temporären Variable (ich tendiere dazu, sie keys zu nennen). Du wirst erst im nächsten Kapitel etwas über Listen lernen, also verwende für den Moment eine fertige: len(keys) > 0 ist ein Vergleich, der True ist, wenn die Liste nicht leer ist. Wenn die Liste tatsächlich nicht leer ist, bedeutet das, dass der Benutzer die Escape-Taste gedrückt hat (da dies die einzige Taste ist, die wir in dem Funktionsaufruf angegeben haben) und das Spiel sollte vorbei sein. Überlege dir, wie du es ohne eine if-Anweisung machen kannst, indem du den logischen Wert direkt berechnest.
Schreib deinen Code in code02.py.
Obwohl wir jetzt eine nette Game-Loop laufen haben, haben wir immer noch nur ein langweiliges graues Fenster, auf das wir schauen können. Lass uns eine Textstimulanz erstellen, die “Escape drücken zum Beenden” sagt und sie während der Schleife anzeigt. Dafür werden wir die visual.TextStim-Klasse aus der PsychoPy-Bibliothek verwenden.
Erstmal musst du das press_escape_text-Objekt (Instanz der TextStim) vor der Hauptschleife erstellen. Es gibt einige Parameter, mit denen du herumspielen kannst, aber mindestens musst du das Fenster, in dem der Text angezeigt werden soll (unsere win-Variable), und den tatsächlichen Text, den du anzeigen möchtest (text="Escape drücken, um zu beenden"), übergeben. PsychoPy wird für alle anderen Einstellungen seine Voreinstellungen verwenden (Standard-Schriftfamilie, -farbe und -größe, mittig im Fenster platziert).
press_escape_text = visual.TextStim(win, "Escape drücken, um zu beenden")Um die Visualisierungen in PsychoPy anzuzeigen, musst du zuerst jedes Element zeichnen, indem du seine draw() Methode aufrufst, und dann das Fenster aktualisieren, indem du es umblätterst3 Sobald du fertig bist, mit flip() “umblätterst” du die Puffer, damit sie ihre Plätze tauschen. Jetzt wird der gezeichnete Puffer angezeigt und du hast den anderen Puffer zum Zeichnen. Beachte, dass du flip() nur einmal aufrufst, nachdem alle Stimuli gezeichnet wurden. Ich organisiere diesen Code normalerweise in einen separaten Block und füge eine Kommentarlinie # zeichne Stimuli davor ein.
Der # zeichne Stimuli-Block gehört in die Hauptschleife, entweder vor oder nach der Tastaturprüfung.4 Organisiere auch den letzteren als separaten Code-Block mit eigenem kurzem Kommentar.
Schreib deinen Code in code03.py.
Jetzt solltest du eine nette, wenn auch statische, Nachricht in der Mitte des Fensters haben, die dir zeigt, wie du das Spiel beenden kannst. Schau dir die Handbuchseite für visual.TextStim an und versuche, es zu ändern, indem du zusätzliche Parameter an den Klassenaufruf übergibst. Zum Beispiel kannst du seine Farbe, ob der Text fett und/oder kursiv ist, wie er ausgerichtet ist, usw. ändern. Aber wenn du ändern möchtest, wo der Text angezeigt wird, lies weiter unten.
Jetzt müssen wir rausfinden, wie man visuelle Elemente an eine beliebige Stelle auf dem Bildschirm bewegt. Im Grunde ist das sehr einfach, denn jeder visuelle Stimulus (inklusive TextStim, das wir gerade verwendet haben) hat eine pos-Eigenschaft, die seine Position innerhalb eines Fensters angibt. Aber PsychoPy macht es erstmal komplizierter, indem es fünf (5!) verschiedene Positionseinheiten-Systeme hat.
Bevor wir mit den Einheiten loslegen, lass uns ein einfaches weißes Quadrat erstellen. Die Klasse, die wir dafür brauchen, ist visual.Rect. Genau wie TextStim benötigt es die win-Variable (damit es weiß, zu welchem Fenster es gehört), width (standardmäßig 0,5 dieser mysteriösen Einheiten), height (auch standardmäßig 0,5), pos (standardmäßig (0,0)), lineColor (standardmäßig white) und fillColor (standardmäßig None). Also, um ein “standardmäßiges” weißes Quadrat mit der Größe (0,5, 0,5) Einheiten an der Position (0, 0) zu erhalten, musst du nur die win-Variable übergeben: white_square = visual.Rect(win). Allerdings kann es auf einigen Computern zu einem seltsamen Fehler kommen, der PsychoPy daran hindert, den Rahmen korrekt zu zeichnen. Wenn du also auf einen leeren Bildschirm starrst5, füge fillColor="white" zum Aufruf hinzu und du solltest ein ausgefülltes weißes Quadrat sehen.
Du zeichnest das Quadrat genau wie du den Textreiz gezeichnet hast, über seine draw() Methode (und wieder, du zeichnest erst alle Reize und dann drehst du das Fenster einmal um). Schreibe den Code (entweder behalte den Text und zeichne beide, oder lasse den Text weg), führe ihn aus, um ein sehr weißes Quadrat zu sehen.
Schreib deinen Code in code04.py.
Na, dein Quadrat ist kein richtiges Quadrat? Ich hab’s dir ja gesagt: Fünf Einheitensysteme!
Mit height units wird alles in den Einheiten der Fensterhöhe angegeben. Die Mitte des Fensters befindet sich bei (0,0) und das Fenster verläuft vertikal von -0.5 bis 0.5. Die horizontalen Grenzen hängen jedoch vom Seitenverhältnis ab. Für unser 800×600-Fenster (Seitenverhältnis 4:3) verläuft es von -0.666 bis 0.666 (das Fenster ist 1.3333 Fensterhöhen breit). Für ein 600×800-Fenster (Seitenverhältnis 3:4) von -0.375 bis 0.375 (das Fenster ist 0.75 Fensterhöhen breit), für ein quadratisches Fenster 600×600 (Seitenverhältnis 1:1) von -0.5 bis 0.5 (in allen diesen Fällen verläuft es von -0.5 bis 0.5 vertikal). Das bedeutet, dass der tatsächliche Bildschirmabstand für die Einheiten auf beiden Achsen gleich ist. Daher ist ein Quadrat mit size=(0.5, 0.5) tatsächlich ein Quadrat (es spannt den gleichen Abstand vertikal und horizontal). Dadurch erleichtern height units das Größenfestlegen von Objekten, machen das korrekte Platzieren auf der horizontalen Achse jedoch schwieriger (da du das Seitenverhältnis kennen musst).
Mach dein Code besser, indem du das Einheitensystem beim Erstellen des Fensters festlegst: win = visual.Window(..., units="height"). Spiele mit deinem Code, indem du die Position des Quadrats beim Erstellen festlegst. Du musst nur einen zusätzlichen Parameter pos=(<x>, <y>) übergeben.
Schreib deinen Code in code05.py.
Übrigens: Wo ist oben, wenn y unter oder über Null liegt? Leider, im Gegensatz zur x-Achse, kann die y-Achse in beide Richtungen gehen. In PsychoPy zeigt die y-Achse nach oben (d.h. negative Werte bewegen den Quadrat nach unten und positive nach oben). Aber wenn du einen Eyelink Eye-Tracker verwenden würdest, um aufzuzeichnen, wohin die Teilnehmer geschaut haben auf dem Bildschirm, geht die y-Achse von der Spitze des Bildschirms aus und zeigt nach unten6.
Jetzt ändere die Größe des Quadrats (und mache es zu einem nicht-quadratischen Rechteck), indem du width=<some-width-value> und height=<some-height-value> übergibst.
Schreib deinen Code in code06.py.
Normale Einheiten sind die Standard-Einheiten und gehen davon aus, dass das Fenster von -1 bis 1 sowohl entlang der x- als auch der y-Achse reicht. Wiederum ist (0,0) die Mitte des Bildschirms, aber die linke untere Ecke ist (-1, -1) und die rechte obere Ecke ist (1, 1). Das erleichtert das Positionieren deiner Objekte, macht das Größenfestlegen jedoch schwieriger (du musst das Seitenverhältnis kennen, um sicherzustellen, dass ein Quadrat tatsächlich ein Quadrat ist).
Mach dein Code so um, dass er "norm"-Einheiten verwendet, wenn du das Fenster erstellst und deinen weißen quadratischen Reiz größenanpasst, damit es wie ein Quadrat aussieht.
Schreib deinen Code in code07.py.
Für Bildschirmpixel Einheiten liegt das Fensterzentrum immer noch bei (0,0), geht jedoch horizontal von -<Breite-in-Pixeln>/2 bis <Breite-in-Pixeln>/2 (in unserem Fall von -400 bis 400) und vertikal von -<Höhe-in-Pixeln>/2 bis <Höhe-in-Pixeln>/2 (von -300 bis 300). Diese Einheiten können intuitiver sein, wenn du mit einem Fenster fester Größe arbeitest, da der Bereich auf beiden Achsen gleich ist (wie bei den Höheneinheiten). Sie können jedoch Probleme bereiten, wenn die Fenstergröße verändert wurde oder du ein Vollbildfenster auf einem Monitor mit unbekannter Auflösung verwendest. Kurz gesagt, du solltest sie nur verwenden, wenn sie deinen Code dramatisch vereinfachen.
Mach dein Code so, dass er "pix"-Einheiten verwendet und test kurz die Größe und Position deines Quadrats innerhalb des Fensters.
Schreib deinen Code in code08.py.
Im Gegensatz zu den drei Einheiten darüber, das Verwenden von visuellen Winkelgraden erfordert das Wissen über die physikalische Größe des Bildschirms, seine Auflösung und die Betrachtungsdistanz (wie weit deine Augen vom Bildschirm entfernt sind). Sie sind die Maßeinheiten, die in der visuellen Psychophysik verwendet werden, da sie die Stimulusgröße beschreiben, wie sie auf der Netzhaut erscheint (siehe Wikipedia für Details). Daher sind dies die Einheiten, die du verwenden möchtest, wenn du ein echtes Experiment im Labor durchführst.
Hier musst du die physikalische Größe deines Bildschirms und seine Auflösung kennen. Das sind relativ exotische Einheiten für sehr spezifische Anwendungsfälle7.
Bis jetzt haben wir die Position des Quadrats festgelegt, als wir es erstellt haben. Aber du kannst es jederzeit bewegen, indem du neue (<x>, <y>) Koordinaten seinem pos-Eigenschaft zuweist. Zum Beispiel white_square.pos = (-0.1, 0.2). Lass uns experimentieren, indem wir das Quadrat bei jeder Schleifeniteration an eine zufällige Position bewegen (das kann viel blinken verursachen, also wenn du eine lichtempfindliche Epilepsie hast, die durch Blinken ausgelöst werden kann, solltest du es wahrscheinlich nur einmal vor der Schleife machen). Verwende die Einheiten deiner Wahl und erzeuge eine neue Position mithilfe der Funktion random.uniform(a, b), die einen zufälligen Wert innerhalb des Bereichs a..b generiert8. Erzeuge zwei Werte (einen für x, einen für y). Wenn du "norm"-Einheiten verwendest, ist der Bereich für die beiden Dimensionen gleich (von -1 bis 1). Wenn du jedoch "height"-Einheiten verwendet hast, musst du das Seitenverhältnis deines Fensters berücksichtigen (4:3, wenn du ein 800×600-Pix-Fenster verwendest).
Schreib deinen Code in code09.py.
Das war sehr beeindruckend, also lass uns den Quadrat nur springen, wenn du die Leertaste drückst. Dafür müssen wir den Code erweitern, der die Tastatureingabe verarbeitet. Bisher haben wir ihn nur auf die Esc-Taste beschränkt und geprüft, ob eine (also Esc) Taste gedrückt wurde.
In der nächsten Kapitel lernst du über Listen und Indizes, also hier ist noch ein vorgefertigtes. Zuerst füge "space" zur keyList-Parameter hinzu. Als nächstes verwende eine bedingte if-Anweisung, um zu prüfen, ob event.getKeys() eine Tasteneingabe zurückgegeben hat. Wenn ja (len(keys) > 0), kannst du nun prüfen, ob keys[0] gleich "space" oder "escape" ist9. Wenn es letztere war, ist das Spiel vorbei, wie zuvor. Wenn es "space" war, dann bewege das Quadrat an eine neue zufällige Position (und bewege es nicht bei jedem Frame!).
Tipp, wenn du debuggst, setz deinen Breakpoint innerhalb des if-Statements, damit das Programm erst anhält, wenn du eine Taste gedrückt hast (was passiert, wenn du ihn auf der win.flip()-Zeile setzt?)
Schreib deinen Code in code10.py.
Es gibt noch viel mehr zu lernen über PsychoPy, aber wir haben die Grundlagen abgedeckt. Schick deine Dateien ab und mach dich bereit für ein Mole schlagen!
Technisch rufen wir eine Klassenkonstruktor-Methode namens __init__ auf, aber das ist jetzt nicht wichtig.↩︎
Allerdings solltest du zur Konsistenz bei der ursprünglichen Reihenfolge bleiben.↩︎
Dies wird Umblättern genannt, weil ein Fenster zwei Puffer hat: einen, der aktuell auf dem Bildschirm angezeigt wird, und einen anderen, in dem du deine Stimuli zeichnen kannst.↩︎
Ich persönlich ziehe es vor, zuerst zu zeichnen, aber in den meisten Fällen macht es keinen Unterschied.↩︎
Dies war manchmal ein Problem bei Intel-Grafikkarten.↩︎
Das könnte sehr verwirrend sein, wenn du das vergisst, wenn du die Blickdaten auf ein Bild überlagerst, das du in der Studie verwendet hast, und dich fragst, was die Teilnehmer denn gemacht haben.↩︎
So spezifisch, dass ich ehrlich gesagt keins einfallen will.↩︎
Du musst natürlich das random-Modul dafür importieren.↩︎
Du kannst if..else verwenden, da wir nur zwei Optionen haben, aber ich würde empfehlen, auf eine allgemeinere Lösung if..elif zu gehen↩︎