Zmienne#

Wstęp#

Zmienne przechowują dane i umożliwiają ich ponowne wykorzystanie oraz manipulowanie nimi w całym programie. Python jest językiem dynamicznie typowanym, ​​co oznacza, że ​​nie trzeba jawnie deklarować typu zmiennej. Zamiast tego typ jest automatycznie wnioskowany na podstawie przypisanej jej wartości. Na przykład:

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

Python jest również silnie typizowany, co oznacza, że ​​nie można wykonywać operacji na niekompatybilnych typach bez ich jawnej konwersji. Na przykład:

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

Aby rozwiązać takie problemy, należy w razie potrzeby jawnie przekonwertować typy:

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

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

To API wyjaśnia popularne typy zmiennych w Pythonie. Choć nie jest to wyczerpująca lista, obejmuje ona typy, których najczęściej będziesz używać w praktyce.

  • Zmienne lokalne – Deklarowane wewnątrz funkcji i używane tylko w jej zasięgu; najlepiej sprawdzają się w przypadku wartości tymczasowych lub izolowanych.

  • Zmienne globalne – Deklarowane poza jakąkolwiek funkcją i używane w całym projekcie; przydatne do udostępniania danych między funkcjami.

  • Całkowita – Liczby całkowite używane do liczenia, określania odległości lub czegokolwiek bez części dziesiętnych.

  • Float – Liczby z przecinkami dziesiętnymi, przydatne do precyzyjnych pomiarów lub obliczeń.

  • String – Wartości tekstowe używane w wiadomościach, etykietach lub do wyświetlania czytelnych wyników.

  • Boolean – True lub False wartości dla logiki i podejmowania decyzji.

  • NoneType – oznacza brak wartości w Pythonie.

  • Zakres – automatycznie generuje sekwencje liczb, najczęściej używane w pętlach.

  • Lista – Zmienna kolekcja elementów, przydatna do przechowywania grup wartości, np. obiektów lub odczytów czujników.

  • Lista 2D – Lista list, idealna do przedstawiania wierszy, siatek lub danych w formie tabeli.

  • Krotka – stała sekwencja wartości, której nie można zmienić; przydatna w przypadku zgrupowanych, niezmiennych danych.

Deklarowanie i przypisywanie zmiennej#

Aby utworzyć zmienną, wystarczy przypisać wartość do nazwy za pomocą operatora =:

distance = 100

Podczas nadawania nazw zmiennej należy przestrzegać następujących zasad:

  • Nazwa nie może zawierać znaków specjalnych (np. wykrzyknika).

  • Nazwa nie może zaczynać się od cyfry.

  • W nazwie nie można używać spacji.

  • Nazwa nie może być słowem zastrzeżonym w kodzie VEX (np. Drivetrain).

Local Variables#

Zmienne lokalne są definiowane wewnątrz funkcji lub bloku kodu. Są dostępne tylko w zakresie tej funkcji lub bloku i nie są widoczne poza nim.

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

show_local()

Zmiennych lokalnych powszechnie używa się do przechowywania wartości tymczasowych, które są istotne tylko w obrębie konkretnej funkcji lub części programu.

Global Variables#

Zmienne globalne są definiowane poza dowolną funkcją lub blokiem. Można do nich uzyskać dostęp i odczytać je w dowolnym miejscu programu, również wewnątrz funkcji.

Uwaga: zmienna globalna może być używana w dowolnym miejscu projektu. Może to być pomocne, ale może również utrudnić znalezienie błędów. Jeśli wartość ulegnie zmianie, konieczne może być sprawdzenie wielu części projektu, aby dowiedzieć się, gdzie nastąpiła zmiana. Użyj zmiennej lokalnej, gdy tylko jedna funkcja potrzebuje tej wartości.

# 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)

Domyślnie przypisanie wartości zmiennej wewnątrz funkcji tworzy zmienną lokalną. Aby zmodyfikować zmienną globalną wewnątrz funkcji, należy ją jawnie zadeklarować za pomocą słowa kluczowego global.

# 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()

Typy danych#

Zmienne Pythona mogą przechowywać różne typy danych, z których każdy nadaje się do innego zastosowania. Poniżej przedstawiamy najczęściej używane typy:

Integer#

Liczba całkowita jest liczbą dodatnią lub ujemną.

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#

Float to liczba dziesiętna.

# Store a value with decimal points.
raw_value = 0.88

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

String#

String to sekwencja znaków powszechnie stosowana w tekście.

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

Uwaga: Ciąg musi być zawsze ujęty w pasujące cudzysłowy, pojedyncze ( ’ ) lub podwójne ( ” ). Możesz użyć dowolnego ze stylów, ale znaki otwierające i zamykające muszą być takie same.

Boolean#

Wartość Boolean reprezentuje wartości True lub False.

# 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...")

Wartości logiczne można zmieniać w dowolnym momencie projektu.

# 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 oznacza brak wartości w Pythonie.

# 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#

Zakres to sekwencja liczb, powszechnie używana w pętlach do generowania sekwencji liczbowych. Ma ona następujący format:

range(start, stop, step)

Komponenty

Opis

start

Opcjonalnie. Wartość początkowa jest inkluzywna (sekwencja zaczyna się tutaj). Wartość domyślna to 0.

stop

Wartość końcowa ma charakter wyłączny (sekwencja kończy się przed tą liczbą).

step

Opcjonalnie. Ten krok określa, o ile wzrasta (lub maleje) każda liczba. Domyślnie jest to 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#

Lista przechowuje grupę elementów w jednej zmiennej. Możesz dodawać, usuwać, zmieniać lub używać każdego elementu osobno w projekcie. Listy są przydatne, gdy chcesz przechowywać powiązane wartości, takie jak odczyty czujników, kolory lub nazwy obiektów. Listy tworzy się za pomocą nawiasów kwadratowych [].

# 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()

Użyj polecenia append , aby dodać elementy do listy.

# 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#

Lista 2D, czyli lista list, jest powszechnie używana do reprezentowania siatek, tabel lub macierzy. Każda podlista reprezentuje wiersz lub określoną grupę danych.

# 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()

Można modyfikować poszczególne elementy lub nawet całe podlisty w ramach listy 2D:

# 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#

Krotka to sekwencja elementów, których nie można zmienić po utworzeniu. Często używa się jej do grupowania powiązanych wartości.

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

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

Krotki tworzy się za pomocą nawiasów () zamiast nawiasów kwadratowych [].

On this page