Variables#

Introduction#

Les variables stockent des données et permettent de les réutiliser et de les manipuler dans tout le programme. Python est un langage à typage dynamique, ce qui signifie qu’il n’est pas nécessaire de déclarer explicitement le type d’une variable. Ce type est automatiquement déduit de la valeur qui lui est attribuée. Par exemple :

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

Python est également fortement typé, ce qui signifie que vous ne pouvez pas effectuer d’opérations sur des types incompatibles sans les convertir explicitement. Par exemple :

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

Pour résoudre ces problèmes, vous devez convertir explicitement les types, le cas échéant :

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

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

Cette API explique les types de variables courants en Python. Bien qu’elle ne soit pas exhaustive, elle couvre les types que vous serez le plus susceptible d’utiliser en pratique.

  • Variables locales – Déclarées à l’intérieur d’une fonction et utilisées uniquement dans cette portée ; idéal pour les valeurs temporaires ou isolées.

  • Variables globales – Déclarées en dehors de toute fonction et utilisées dans tout le projet ; utiles pour partager des données entre les fonctions.

  • Entier – Nombres entiers utilisés pour le comptage, les distances ou tout ce qui n’a pas de décimales.

  • Flottant – Nombres décimaux, utiles pour des mesures ou des calculs précis.

  • Chaîne – Valeurs de texte, utilisées pour les messages, les étiquettes ou l’affichage d’une sortie lisible.

  • Booléen – True ou False valeurs pour la logique et la prise de décision.

  • NoneType – Représente l’absence de valeur en Python.

  • Range – Génère automatiquement des séquences de nombres, généralement utilisées dans les boucles.

  • Liste – Une collection modifiable d’éléments ; idéale pour stocker des groupes de valeurs comme des objets ou des relevés de capteurs.

  • Liste 2D – Une liste de listes ; idéale pour représenter des lignes, des grilles ou des données de type tableau.

  • Tuple – Une séquence fixe de valeurs qui ne peuvent pas être modifiées ; utile pour les données groupées et immuables.

Déclaration et affectation d’une variable#

Pour créer une variable, il suffit d’attribuer une valeur à un nom à l’aide de l’opérateur = :

distance = 100

Lors de la dénomination d’une variable, les règles suivantes doivent être respectées :

  • Le nom ne peut pas contenir de caractères spéciaux (par exemple, un point d’exclamation).

  • Le nom ne peut pas commencer par un chiffre.

  • Le nom ne peut pas contenir d’espaces.

  • Le nom ne peut pas être un mot réservé dans VEXcode (par exemple, Drivetrain).

Local Variables#

Les variables locales sont définies à l’intérieur d’une fonction ou d’un bloc de code. Elles ne sont accessibles que dans la portée de cette fonction ou de ce bloc et ne sont pas visibles en dehors de celui-ci.

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

show_local()

Les variables locales sont couramment utilisées pour stocker des valeurs temporaires qui ne sont pertinentes que dans une fonction ou une partie spécifique du programme.

Global Variables#

Les variables globales sont définies en dehors de toute fonction ou bloc. Elles peuvent être consultées et lues partout dans le programme, y compris à l’intérieur des fonctions.

Remarque : Une variable globale peut être utilisée partout dans votre projet. Cela peut s’avérer utile, mais aussi compliquer la recherche de bogues. Si sa valeur change, vous devrez peut-être vérifier plusieurs parties du projet pour trouver l’endroit où le changement a eu lieu. Utilisez une variable locale lorsqu’une seule fonction a besoin de sa valeur.

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

Par défaut, l’affectation d’une valeur à une variable à l’intérieur d’une fonction crée une variable locale. Pour modifier une variable globale à l’intérieur d’une fonction, vous devez la déclarer explicitement à l’aide du mot-clé 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()

Types de données#

Les variables Python peuvent stocker différents types de données, chacun adapté à des cas d’utilisation spécifiques. Voici les types les plus couramment utilisés :

Integer#

Un entier est un nombre positif ou négatif.

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#

Un nombre à virgule flottante est un nombre décimal.

# Store a value with decimal points.
raw_value = 0.88

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

String#

Une chaîne de caractères est une séquence de caractères, couramment utilisée pour le texte.

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

Remarque : Une chaîne de caractères doit toujours être encadrée par des guillemets identiques, simples ( ’ ) ou doubles ( ” ). Vous pouvez utiliser l’un ou l’autre style, mais les guillemets ouvrants et fermants doivent correspondre.

Boolean#

Un booléen représente True ou False valeurs.

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

Les valeurs booléennes peuvent être modifiées à tout moment du projet.

# 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ésente l’absence de valeur en 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#

Une plage est une séquence de nombres, couramment utilisée dans les boucles pour générer des séquences numériques. Elle suit le format suivant :

range(start, stop, step)

Composants

Description

start

Facultatif. La valeur de départ est inclusive (la séquence commence ici). La valeur par défaut est 0.

stop

La valeur d’arrêt est exclusive (la séquence s’arrête avant ce nombre).

step

Facultatif. Le pas détermine l’incrément (ou la diminution) de chaque nombre. La valeur par défaut est 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#

Une liste stocke un groupe d’éléments dans une seule variable. Vous pouvez ajouter, supprimer ou modifier des éléments, ou les utiliser individuellement dans votre projet. Les listes sont utiles pour regrouper des valeurs liées, comme des relevés de capteurs, des couleurs ou des noms d’objets. Les listes sont créées à l’aide de crochets : [].

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

Utilisez append pour ajouter des éléments à une liste.

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

Une liste 2D, ou liste de listes, est couramment utilisée pour représenter des grilles, des tableaux ou des matrices. Chaque sous-liste représente une ligne ou un groupement spécifique de données.

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

Vous pouvez modifier des éléments spécifiques, voire des sous-listes entières, au sein d’une liste 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#

Un tuple est une séquence d’éléments qui ne peuvent plus être modifiés après leur création. Il est souvent utilisé pour regrouper des valeurs liées entre elles.

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

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

Les tuples sont créés à l’aide de parenthèses () plutôt que de crochets [].

Sur cette page