Variables et types de données en Python

Introduction

Dans ce laboratoire, vous allez apprendre les concepts fondamentaux des variables et des types de données en Python. Les variables sont des éléments essentiels en programmation qui vous permettent de stocker, d'accéder et de manipuler des données dans votre code. Comprendre les différents types de données est crucial pour écrire des programmes Python efficaces.

Vous allez créer diverses variables, explorer les différents types de données disponibles en Python, effectuer des conversions de type et apprendre à utiliser les variables dans des expressions. Ces compétences constituent la base de la programmation Python et sont nécessaires pour développer des applications plus complexes.

À la fin de ce laboratoire, vous serez à l'aise pour créer et utiliser des variables avec différents types de données en Python.

Skills Graph

Création de vos premières variables Python

Dans cette étape, vous allez apprendre à créer et à utiliser des variables en Python. Les variables sont des conteneurs qui stockent des valeurs de données et leur donnent des noms significatifs pour faciliter leur référence dans votre code.

Commençons par créer un nouveau fichier Python et en définissant quelques variables de base :

1. Ouvrez le fichier /home/labex/project/variables.py dans le WebIDE.

2. Ajoutez le code suivant pour définir trois variables :

## Creating basic variables
water_supply = 100    ## Amount of water in gallons
food_supply = 50      ## Amount of food in pounds
ammunition = 40       ## Number of ammunition rounds

En Python, vous créez une variable en spécifiant un nom suivi du signe égal (=) puis de la valeur que vous souhaitez lui assigner.

3. Ajoutons du code pour afficher les valeurs de ces variables :

## Displaying variable values
print("Water supply:", water_supply)
print("Food supply:", food_supply)
print("Ammunition:", ammunition)

4. Exécutez votre script en ouvrant un terminal dans le WebIDE et en exécutant :

python3 /home/labex/project/variables.py

Vous devriez voir la sortie suivante :

Water supply: 100
Food supply: 50
Ammunition: 40

Félicitations. Vous avez créé vos premières variables Python et affiché leurs valeurs. Ces variables stockent des informations que votre programme peut accéder et manipuler.

Comprendre les types de données numériques

Python dispose de plusieurs types de données utilisés pour classer différents types de données. Dans cette étape, vous allez apprendre à connaître deux types de données numériques : les entiers (integers) et les nombres à virgule flottante (floats).

1. Ouvrez le fichier /home/labex/project/variables.py dans le WebIDE.

2. Ajoutez le code suivant au fichier pour définir des variables avec différents types de données numériques :

## Numeric data types
integer_value = 42        ## Integer (whole number)
float_value = 3.14159     ## Float (decimal number)

3. Explorons les types de ces variables à l'aide de la fonction type() :

## Check the data types
print("\nUnderstanding data types:")
print("integer_value:", integer_value, "- Type:", type(integer_value))
print("float_value:", float_value, "- Type:", type(float_value))

4. Effectuons maintenant quelques opérations de base avec ces types numériques :

## Basic operations with numbers
sum_result = integer_value + float_value
product_result = integer_value * float_value

print("\nBasic operations:")
print(f"{integer_value} + {float_value} = {sum_result}")
print(f"{integer_value} * {float_value} = {product_result}")

5. Exécutez votre script :

python3 /home/labex/project/variables.py

Vous devriez voir une sortie similaire à :

Water supply: 100
Food supply: 50
Ammunition: 40

Understanding data types:
integer_value: 42 - Type: <class 'int'>
float_value: 3.14159 - Type: <class 'float'>

Basic operations:
42 + 3.14159 = 45.14159
42 * 3.14159 = 131.94678

Notez que lorsque vous effectuez des opérations avec des entiers et des nombres à virgule flottante, Python convertit automatiquement le résultat en nombre à virgule flottante si nécessaire.

Travailler avec les chaînes de caractères (strings) et les booléens (booleans)

En plus des types de données numériques, Python propose des chaînes de caractères (strings) pour les données textuelles et des booléens (booleans) pour les valeurs vraies/fausses. Explorons ces types :

1. Ouvrez le fichier /home/labex/project/variables.py dans le WebIDE.

2. Ajoutez le code suivant pour définir des variables de type chaîne de caractères et booléennes :

## String data type - for text
camp_name = "Python Base Camp"
location = 'Programming Valley'  ## Strings can use single or double quotes

## Boolean data type - for true/false values
is_safe = True
has_water = True
enemy_nearby = False

3. Ajoutez du code pour vérifier et afficher ces variables :

## Displaying string and boolean variables
print("\nString variables:")
print("Camp name:", camp_name, "- Type:", type(camp_name))
print("Location:", location, "- Type:", type(location))

print("\nBoolean variables:")
print("Is the camp safe?", is_safe, "- Type:", type(is_safe))
print("Is water available?", has_water, "- Type:", type(has_water))
print("Is enemy nearby?", enemy_nearby, "- Type:", type(enemy_nearby))

4. Demonstrons également quelques opérations sur les chaînes de caractères :

## String operations
full_location = camp_name + " in " + location
print("\nFull location:", full_location)

## String repetition
border = "-" * 20
print(border)
print("Camp Information")
print(border)

5. Exécutez votre script :

python3 /home/labex/project/variables.py

Vous devriez voir une sortie similaire à :

Water supply: 100
Food supply: 50
Ammunition: 40

Understanding data types:
integer_value: 42 - Type: <class 'int'>
float_value: 3.14159 - Type: <class 'float'>

Basic operations:
42 + 3.14159 = 45.14159
42 * 3.14159 = 131.94678

String variables:
Camp name: Python Base Camp - Type: <class 'str'>
Location: Programming Valley - Type: <class 'str'>

Boolean variables:
Is the camp safe? True - Type: <class 'bool'>
Is water available? True - Type: <class 'bool'>
Is enemy nearby? False - Type: <class 'bool'>

Full location: Python Base Camp in Programming Valley
--------------------
Camp Information
--------------------

Remarquez comment les chaînes de caractères peuvent être concaténées avec l'opérateur + et répétées avec l'opérateur *. Les booléens sont utiles pour représenter des conditions et contrôler le flux du programme.

Conversion de type et vérification de type

Parfois, vous avez besoin de convertir des valeurs d'un type de données à un autre ou de vérifier le type de données d'une variable. Cela s'appelle la conversion de type (ou le transtypage - type casting). Explorons ce concept :

1. Ouvrez le fichier /home/labex/project/variables.py dans le WebIDE.

2. Ajoutez du code pour démontrer la conversion de type :

## Type conversion examples
print("\nType Conversion Examples:")

## Converting string to integer
supplies_str = "75"
supplies_int = int(supplies_str)
print(f"String '{supplies_str}' converted to integer: {supplies_int} - Type: {type(supplies_int)}")

## Converting integer to string
days_int = 30
days_str = str(days_int)
print(f"Integer {days_int} converted to string: '{days_str}' - Type: {type(days_str)}")

## Converting integer to float
distance_int = 100
distance_float = float(distance_int)
print(f"Integer {distance_int} converted to float: {distance_float} - Type: {type(distance_float)}")

## Converting float to integer (note: this truncates the decimal part)
temperature_float = 32.7
temperature_int = int(temperature_float)
print(f"Float {temperature_float} converted to integer: {temperature_int} - Type: {type(temperature_int)}")

3. Ajoutez du code pour vérifier les types de données :

## Type checking
print("\nType Checking Examples:")
value1 = 42
value2 = "42"
value3 = 42.0

print(f"Is {value1} an integer? {isinstance(value1, int)}")
print(f"Is {value2} an integer? {isinstance(value2, int)}")
print(f"Is {value3} a float? {isinstance(value3, float)}")
print(f"Is {value2} a string? {isinstance(value2, str)}")

4. Exécutez votre script :

python3 /home/labex/project/variables.py

Vous devriez voir une sortie similaire à :

...previous output...

Type Conversion Examples:
String '75' converted to integer: 75 - Type: <class 'int'>
Integer 30 converted to string: '30' - Type: <class 'str'>
Integer 100 converted to float: 100.0 - Type: <class 'float'>
Float 32.7 converted to integer: 32 - Type: <class 'int'>

Type Checking Examples:
Is 42 an integer? True
Is 42 an integer? False
Is 42.0 a float? True
Is 42 a string? True

Notez que :

• int() convertit les valeurs en entiers
• float() convertit les valeurs en nombres à virgule flottante
• str() convertit les valeurs en chaînes de caractères
• Lors de la conversion d'un nombre à virgule flottante en entier, la partie décimale est tronquée (pas arrondie)
• La fonction isinstance() vérifie si une variable est d'un type spécifique

Ces fonctions de conversion sont utiles lorsque vous avez besoin de traiter les entrées des utilisateurs ou lorsque vous travaillez avec des données provenant de différentes sources.

Variables dans les expressions et la prise de décision

Les variables deviennent vraiment puissantes lorsqu'elles sont utilisées dans des expressions et des structures de prise de décision. Explorons comment utiliser les variables dans des calculs et des instructions conditionnelles :

1. Ouvrez le fichier /home/labex/project/variables.py dans le WebIDE.

2. Ajoutez du code pour démontrer l'utilisation de variables dans des calculs :

## Variables in expressions
print("\nVariables in Expressions:")

water_per_day = 4  ## gallons
food_per_day = 2.5  ## pounds

## Calculate how long supplies will last
water_days = water_supply / water_per_day
food_days = food_supply / food_per_day

print(f"With {water_supply} gallons of water, consuming {water_per_day} gallons per day, water will last {water_days} days")
print(f"With {food_supply} pounds of food, consuming {food_per_day} pounds per day, food will last {food_days} days")

3. Ajoutez du code pour démontrer l'utilisation de variables dans des instructions conditionnelles :

## Using variables for decision making
print("\nDecision Making with Variables:")

## Check which supply will run out first
if water_days < food_days:
    limiting_factor = "Water"
    limiting_days = water_days
else:
    limiting_factor = "Food"
    limiting_days = food_days

print(f"{limiting_factor} will run out first, after {limiting_days} days")

## Check if supplies are sufficient for a 10-day journey
journey_days = 10
sufficient_supplies = water_days >= journey_days and food_days >= journey_days and ammunition >= 20

print(f"Planning a {journey_days}-day journey.")
print(f"Do we have sufficient supplies? {sufficient_supplies}")

## Provide specific supply status
if water_days < journey_days:
    print(f"Warning: Water will only last {water_days:.1f} days.")
if food_days < journey_days:
    print(f"Warning: Food will only last {food_days:.1f} days.")
if ammunition < 20:
    print(f"Warning: Only {ammunition} rounds of ammunition available.")

4. Exécutez votre script :

python3 /home/labex/project/variables.py

Vous devriez voir une sortie similaire à :

...previous output...

Variables in Expressions:
With 100 gallons of water, consuming 4 gallons per day, water will last 25.0 days
With 50 pounds of food, consuming 2.5 pounds per day, food will last 20.0 days

Decision Making with Variables:
Food will run out first, after 20.0 days
Planning a 10-day journey.
Do we have sufficient supplies? True

Cela démontre comment vous pouvez utiliser des variables dans des calculs mathématiques et comment prendre des décisions en fonction des valeurs des variables. Remarquez comment nous utilisons des opérateurs de comparaison (<, >=) et des opérateurs logiques (and) pour créer des conditions.

La syntaxe de formatage {water_days:.1f} spécifie que le nombre à virgule flottante doit être affiché avec une décimale.

Résumé

Dans ce laboratoire (lab), vous avez appris les concepts fondamentaux des variables et des types de données en Python. Vous avez créé et utilisé des variables de différents types, notamment :

• Des entiers (integers) pour les nombres entiers
• Des nombres à virgule flottante (floats) pour les nombres décimaux
• Des chaînes de caractères (strings) pour les données textuelles
• Des booléens (booleans) pour les valeurs vraies/fausses

Vous avez également appris à :

• Vérifier le type d'une variable à l'aide de la fonction type()
• Convertir entre différents types de données à l'aide de fonctions telles que int(), float() et str()
• Utiliser des variables dans des expressions et des calculs
• Prendre des décisions en fonction des valeurs des variables à l'aide d'instructions conditionnelles

Ces concepts constituent la base de la programmation en Python. Les variables vous permettent de stocker et de manipuler des données, tandis que la compréhension des différents types de données vous aide à utiliser le bon type pour chaque situation. Au fur et à mesure de votre progression dans le monde de Python, vous vous appuierez sur ces bases pour créer des programmes plus complexes et puissants.