Variablen#

Einführung#

Variablen speichern Daten und ermöglichen deren Wiederverwendung und Bearbeitung im gesamten Programm. Python ist eine dynamisch typisierte Sprache, das heißt, der Typ einer Variablen muss nicht explizit deklariert werden. Stattdessen wird der Typ automatisch anhand des zugewiesenen Werts abgeleitet. Zum Beispiel:

angle = 90           # angle is an integer
dist = "Distance: "  # dist is a string
steps = 2.5          # steps is a float

Python ist außerdem stark typisiert, was bedeutet, dass Sie keine Operationen mit inkompatiblen Datentypen durchführen können, ohne diese explizit zu konvertieren. Zum Beispiel:

controller = 1                 # controller is an integer
modules = "3"                  # modules is a string
result = controller + modules  # Creates a TypeError

Um solche Probleme zu beheben, müssen Sie die Datentypen gegebenenfalls explizit konvertieren:

controller = 1                 # controller is an integer
modules = "3"                  # modules is a string

# Convert modules to an integer before adding.
result = int(modules) + controller

Diese API erklärt gängige Variablentypen in Python. Die Liste ist zwar nicht vollständig, deckt aber die Typen ab, die Sie in der Praxis am häufigsten verwenden werden.

  • Lokale Variablen – Werden innerhalb einer Funktion deklariert und nur innerhalb dieses Gültigkeitsbereichs verwendet; am besten geeignet für temporäre oder isolierte Werte.

  • Globale Variablen – Werden außerhalb jeder Funktion deklariert und im gesamten Projekt verwendet; gut geeignet, um Daten zwischen Funktionen auszutauschen.

  • Ganzzahl – Ganze Zahlen, die zum Zählen, für Entfernungen oder für alles ohne Dezimalstellen verwendet werden.

  • Float – Zahlen mit Dezimalstellen, nützlich für präzise Messungen oder Berechnungen.

  • String – Textwerte, die für Meldungen, Beschriftungen oder die Anzeige lesbarer Ausgaben verwendet werden.

  • Boolean – True oder False Werte für Logik und Entscheidungsfindung.

  • NoneType – Stellt das Fehlen eines Wertes in Python dar.

  • Bereich – Erzeugt automatisch Zahlenfolgen, die am häufigsten in Schleifen verwendet werden.

  • Liste – Eine veränderliche Sammlung von Elementen; gut geeignet zum Speichern von Wertegruppen wie Objekten oder Sensormesswerten.

  • 2D Liste – Eine Liste von Listen; ideal zur Darstellung von Zeilen, Rastern oder tabellenartigen Daten.

  • Tupel – Eine feste Folge von Werten, die nicht verändert werden kann; nützlich für gruppierte, unveränderliche Daten.

Deklarieren und Zuweisen einer Variablen#

Um eine Variable zu erstellen, weisen Sie ihr einfach einen Wert mit dem Operator = zu:

distance = 100

Bei der Benennung einer Variablen müssen folgende Regeln beachtet werden:

  • Der Name darf keine Sonderzeichen enthalten (z. B. kein Ausrufezeichen).

  • Der Name darf nicht mit einer Zahl beginnen.

  • Der Name darf keine Leerzeichen enthalten.

  • Der Name darf kein reserviertes Wort in VEXcode sein (z. B. Drivetrain).

Local Variables#

Lokale Variablen werden innerhalb einer Funktion oder eines Codeblocks definiert. Sie sind nur innerhalb des Gültigkeitsbereichs dieser Funktion oder dieses Blocks zugänglich und außerhalb davon nicht sichtbar.

def show_local():
    # This variable only exists inside this function.
    message = "I'm local!" 
    controller.screen.print(message)

show_local()

Lokale Variablen werden häufig verwendet, um temporäre Werte zu speichern, die nur innerhalb einer bestimmten Funktion oder eines bestimmten Teils des Programms relevant sind.

Global Variables#

Globale Variablen werden außerhalb jeglicher Funktionen oder Blöcke definiert. Sie können überall im Programm, auch innerhalb von Funktionen, aufgerufen und gelesen werden.

Hinweis: Eine globale Variable kann überall im Projekt verwendet werden. Das kann hilfreich sein, erschwert aber auch die Fehlersuche. Ändert sich der Wert, müssen Sie möglicherweise viele Teile des Projekts überprüfen, um die Änderung zu finden. Verwenden Sie eine lokale Variable, wenn nur eine Funktion den Wert benötigt.

# The variable is defined outside a function.
message = "I'm global!"  

def show_global():
    # You can access 'message' inside a function.
    controller.screen.print(message)
    controller.screen.next_row()

show_global()
# And you can access 'message' outside a function.
controller.screen.print(message)

Standardmäßig erzeugt die Zuweisung eines Wertes zu einer Variablen innerhalb einer Funktion eine lokale Variable. Um eine globale Variable innerhalb einer Funktion zu ändern, müssen Sie sie explizit mit dem Schlüsselwort global deklarieren.

# Define the global variable.
count = 0 

def increase_count():
    # Use the global keyword to let you modify the
    # global variable.
    global count
    count = count + 1
    controller.screen.print(f"Count: {count}")
    controller.screen.next_row()

increase_count()
increase_count()

Datentypen#

Python-Variablen können verschiedene Datentypen speichern, die jeweils für unterschiedliche Anwendungsfälle geeignet sind. Im Folgenden sind die gebräuchlichsten Typen aufgeführt:

Integer#

Eine ganze Zahl ist eine positive oder negative Zahl.

distance = 50

drone.take_off(climb_to=500)
# Move the robot forward for the variable value in mm.
drone.climb_for(direction=DOWN, distance=distance, velocity=50, units=MM)
wait(2, SECONDS)

# Add to the variable and move forward the new value, 
# for 100mm total.
distance = distance + 50
drone.climb_for(direction=UP, distance=distance, velocity=50, units=MM)
wait(2, SECONDS)

drone.land()

Float#

Eine Gleitkommazahl ist eine Dezimalzahl.

# Store a value with decimal points.
raw_value = 0.88

# Print the decimal value as a percentage.
controller.screen.print(raw_value * 100, "%")

String#

Eine Zeichenkette ist eine Folge von Zeichen, die üblicherweise für Texte verwendet wird.

# Set the variable to a string then print the string.
message = "Ready!"
controller.screen.print(message)

Hinweis: Eine Zeichenkette muss immer in passende Anführungszeichen eingeschlossen werden, entweder in einfache ( ’ ) oder doppelte ( ” ). Sie können beide Stile verwenden, aber die öffnenden und schließenden Anführungszeichen müssen übereinstimmen.

Boolean#

Ein Boolescher Wert repräsentiert True (Falsch) oder False Falsch).

# Set the state of the variable.
delivered = False

# Print different messages depending on the Boolean.
if delivered:
    controller.screen.print("Package delivered!")
else: 
    controller.screen.print("Delivering...")

Boolesche Werte können zu jedem Zeitpunkt im Projekt geändert werden.

# Print the value of the delivered variable
delivered = True
controller.screen.print(delivered)
wait(2,SECONDS)

# Clear the screen and print the value of the variable again
controller.screen.clear_screen(color=GREEN)
delivered = False
controller.screen.print(delivered)

NoneType#

NoneType repräsentiert das Fehlen eines Wertes in Python.

# Write what the controller's task should be as a string
current_task = None

# Check if a task is assigned
if current_task is None:
    controller.screen.print("No task!")
else:
    controller.screen.print(f"Task: {current_task}")

Range#

Ein Bereich ist eine Zahlenfolge, die häufig in Schleifen verwendet wird, um Zahlenfolgen zu erzeugen. Er hat folgendes Format:

range(start, stop, step)

Komponenten

Beschreibung

start

Optional. Der Startwert ist inklusive (die Sequenz beginnt hier). Der Standardwert ist 0.

stop

Der Stoppwert ist exklusiv (die Sequenz endet vor dieser Zahl).

step

Optional. Dieser Schritt bestimmt, um wie viel jede Zahl erhöht (oder verringert) wird. Der Standardwert ist 1.

 
# Move back and forth four times then land.
drone.take_off(climb_to=500)
for i in range(4):
    drone.move_for(direction=0, distance=500, velocity=50, units=MM)
    wait(1, SECONDS)
    drone.move_for(direction=180, distance=500, velocity=50, units=MM)
    wait(1, SECONDS)
drone.land()


# Count by 2 starting at 1 and ending before 12.
for index in range(1, 12, 2): 
    # Print the values on the screen with each loop.
    controller.screen.print(index)
    controller.screen.next_row()

List#

Eine Liste speichert eine Gruppe von Elementen in einer Variable. Sie können Elemente hinzufügen, entfernen, ändern oder jedes Element einzeln in Ihrem Projekt verwenden. Listen sind nützlich, wenn Sie zusammengehörige Werte wie Sensorwerte, Farben oder Objektnamen zusammenhalten möchten. Listen werden mit eckigen Klammern erstellt [].

# Define a list of colors.
colors = ["Red", "Green", "Blue"]

# Repeat for the number of items in the colors list.
for color in colors:
    # Print each color in order
    controller.screen.print(color)
    controller.screen.next_row()

Verwenden Sie append , um Elemente zu einer Liste hinzuzufügen.

# Define a list of colors.
colors = ["Red", "Green", "Blue"]

# Append a new color to the list.
colors.append("Yellow")

# Repeat for the number of items in the colors list.
for color in colors:
    # Print each color in order
    controller.screen.print(color)
    controller.screen.next_row()

2D List#

Eine 2D-Liste, oder Liste von Listen, wird häufig zur Darstellung von Rastern, Tabellen oder Matrizen verwendet. Jede Unterliste repräsentiert eine Zeile oder eine bestimmte Datengruppe.

# Assign the values in the matrix 2D list.
matrix = [
    ["A", 1, "Red"],
    ["B", 2, "Orange"],
    ["C", 3, "Yellow"]
]
# Loop through each row.
for row in matrix: 
    # Loop through each column in the row.
    for element in row: 
        controller.screen.print(element, end=", ")
    controller.screen.next_row()

Sie können einzelne Elemente oder sogar ganze Unterlisten innerhalb einer 2D-Liste ändern:

# Assign the values in the matrix 2D list.
matrix = [
    ["A", 1, "Red"],
    ["B", 2, "Orange"],
    ["C", 3, "Yellow"]
]
# Modify the color (in column 2) in row 0.
matrix[0][2] = "Blue"

# Print the modified row from the matrix 2D list.
controller.screen.print(matrix[0])

Tuple#

Ein Tupel ist eine Folge von Elementen, die nach ihrer Erstellung nicht mehr verändert werden können. Tupel werden häufig verwendet, um zusammengehörige Werte zu gruppieren.

# Define a tuple.
set_1 = (100, "Left")

# Print the tuple.
controller.screen.print(set_1)

Tupel werden mit runden Klammern () anstatt mit eckigen Klammern [] erstellt.

On this page