Introduction à Python : Variables, Types et Opérateurs

Objectifs Pédagogiques

Comprendre la notion de variable et son usage en Python.
Identifier les principaux types de données manipulés dans les programmes.
Savoir effectuer des calculs simples et manipuler des chaînes de caractères.
Appréhender les conversions de types entre entiers, flottants, chaînes, booléens.
Savoir utiliser les opérateurs de comparaison et logiques.
Maîtriser les bases des expressions et de leur évaluation.

Notions

1. Qu’est-ce qu’une variable ?

Définition

Une variable est un nom associé à une valeur. Elle permet de stocker des données pour les réutiliser ou les modifier dans un programme.

En Python, vous déclarez une variable simplement par une affectation :

age = 25
nom = "Alice"

Python déduit automatiquement le type de la variable en fonction de la valeur assignée.

2. Types de données fondamentaux

Python utilise différents types pour représenter les données.

2.1 Les principaux types

Type	Exemple	Description
`int`	`x = 42`	Nombre entier
`float`	`pi = 3.14`	Nombre à virgule flottante
`str`	`nom = "Alice"`	Chaîne de caractères
`bool`	`actif = True`	Booléen (vrai ou faux)
`list`	`notes = [12, 15, 18]`	Liste ordonnée de valeurs
`dict`	`{"nom": "Bob", "age": 30}`	Dictionnaire (clé-valeur)

2.2 Identifier un type

x = 10
print(type(x))  # Affiche : <class 'int'>

3. Opérations de base

3.1 Opérateurs arithmétiques

Opérateur	Utilisation	Exemple
`+`	Addition	`5 + 2`
`-`	Soustraction	`7 - 4`
`*`	Multiplication	`3 * 4`
`/`	Division	`10 / 2`
`//`	Division entière	`9 // 2` → 4
`%`	Modulo	`9 % 2` → 1
`**`	Puissance	`2 ** 3` → 8

Exemple

```python a = 5 b = 3 print(a * b) # Affiche 15 print(a ** b) # Affiche 125 ```

3.2 Concaténation de chaînes

prenom = "Lina"
message = "Bonjour, " + prenom
print(message)  # Bonjour, Lina

4. Conversion de types

Il est parfois nécessaire de convertir une valeur d’un type à un autre.

Fonction	Rôle
`int()`	Convertit en entier
`float()`	Convertit en flottant
`str()`	Convertit en chaîne
`bool()`	Convertit en booléen

Exemple

```python age_str = "20" age = int(age_str) print(age + 5) # Affiche 25 ```

5. Opérateurs de comparaison

Ces opérateurs retournent True ou False selon le résultat de la comparaison.

Opérateur	Signification	Exemple
`==`	Égal à	`x == 10`
`!=`	Différent de	`x != 5`
`>`	Supérieur à	`x > 8`
`<`	Inférieur à	`x < 12`
`>=`	Supérieur ou égal	`x >= 10`
`<=`	Inférieur ou égal	`x <= 20`

6. Opérateurs logiques

Ils permettent de combiner des expressions booléennes.

Opérateur	Signification
`and`	ET logique
`or`	OU logique
`not`	NON logique

age = 16
print(age > 10 and age < 18)  # True

7. Expressions et priorités

Une expression est une combinaison de variables, de constantes et d’opérateurs. Python respecte un ordre de priorité :

Parenthèses ()
Puissance **
Multiplication, division, modulo * / // %
Addition et soustraction + -

Exemple

```python resultat = (3 + 2) * 4 # 5 * 4 = 20 ```

8. Interaction avec l'utilisateur

Utilisez input() pour obtenir une saisie :

nom = input("Quel est ton prénom ? ")
print("Bonjour, " + nom + " !")

⚠️ L’entrée est toujours de type str. Utilisez int() si vous attendez un nombre :

age = int(input("Quel est ton âge ? "))
print("Dans 5 ans, tu auras", age + 5)

Exercices Corrigés

Exercice 1

Énoncé : Créez une variable age, ajoutez 5 et affichez le résultat.

age = 20
print(age + 5)

Exercice 2

Énoncé : Créez une variable nom et affichez "Bonjour, nom".

nom = "Emma"
print("Bonjour, " + nom)

Exercice 3

Énoncé : Convertissez la chaîne "20" en entier, ajoutez 10 et affichez le résultat.

x = "20"
x_int = int(x)
print(x_int + 10)  # 30

Exercice 4

Énoncé : Créez une expression qui teste si un nombre est entre 10 et 20.

x = 15
print(x > 10 and x < 20)  # True

Exercice 5

Énoncé : Calculez (x + y) * z.

x = 2
y = 3
z = 4
print((x + y) * z)  # 20

Exercice 6

Énoncé : Vérifiez si un mot est contenu dans une phrase.

phrase = "Bienvenue à tous"
print("tous" in phrase)  # True

À retenir

Python utilise une syntaxe simple et lisible.
Les variables ne nécessitent pas de type explicite.
Les opérateurs permettent des calculs, des comparaisons et des logiques.
L’interaction utilisateur passe par `input()`.
Les conversions de types sont nécessaires pour manipuler correctement les entrées.