img
Apprenez la programmation où que vous soyez avec Rachid Saad
📞 Appelez maintenant !

Python les Bases
Chapitre 2 : Variables et types de données

À la fin de ce chapitre, vous serez capable de déclarer des variables en respectant les règles de nommage, de manipuler les principaux types de données (entiers, flottants, chaînes, booléens) et d'effectuer des conversions entre types simples.

1. Introduction aux variables

Les variables sont des éléments fondamentaux en programmation. Elles permettent de stocker des informations et d'y accéder facilement dans un programme.

1.1 Qu'est-ce qu'une variable ?

Une variable est un conteneur qui permet de stocker une valeur en mémoire. En Python, les variables sont créées au moment où on leur assigne une valeur pour la première fois.

exemple_variables.py
# Création de variables
age = 25
nom = "Alice"
est_etudiant = True

1.2 Déclaration et affectation de variables

En Python, on déclare une variable simplement en lui assignant une valeur avec l'opérateur =.

affectation_variables.py
# Affectation simple
x = 10
y = 20

# Affectation multiple
a, b, c = 1, 2, 3

# Réaffectation
variable = "première valeur"
variable = "nouvelle valeur"

1.3 Règles de nommage des variables

Les noms de variables en Python doivent respecter certaines règles :

  • Commencer par une lettre (a-z, A-Z) ou un underscore (_)
  • Ne peuvent contenir que des lettres, chiffres et underscores
  • Respecter la casse (age et Age sont deux variables différentes)
  • Ne pas utiliser de mots-clés réservés du langage (if, for, while, etc.)

1.4 Bonnes pratiques de nommage

Pour écrire un code lisible et maintenable, suivez ces conventions :

  • Utilisez des noms descriptifs et significatifs
  • Privilégiez le snake_case pour les noms de variables
  • Évitez les abréviations obscures
  • Utilisez des constantes en MAJUSCULES pour les valeurs fixes

2. Les types de données de base

Python dispose de plusieurs types de données intégrés pour manipuler différents types d'informations.

2.1 Les nombres

Python supporte trois types numériques : les entiers, les flottants et les complexes.

2.1.1 Entiers (int)

Les entiers sont des nombres positifs ou négatifs sans partie décimale.

entiers.py
# Nombres entiers
age = 25
temperature = -5
population = 7_900_000_000  # Avec séparateur de milliers

2.1.2 Nombres à virgule flottante (float)

Les nombres flottants représentent des nombres réels avec une partie décimale.

flottants.py
# Nombres flottants
pi = 3.14159
temperature = -2.5
prix = 19.99

2.1.3 Nombres complexes (complex)

Les nombres complexes sont représentés par une partie réelle et une partie imaginaire.

complexes.py
# Nombres complexes
z = 3 + 4j
print(z.real)  # Partie réelle: 3.0
print(z.imag)  # Partie imaginaire: 4.0

2.2 Les chaînes de caractères (str)

Les chaînes de caractères permettent de manipuler du texte.

2.2.1 Création et manipulation

Les chaînes peuvent être créées avec des apostrophes simples ou doubles.

chaines.py
# Création de chaînes
nom = 'Alice'
message = "Bonjour le monde"
phrase = "J'aime Python"

# Concaténation
prenom = "Jean"
nom_complet = prenom + " Dupont"

# Répétition
separateur = "-" * 20

2.2.2 Échappement et caractères spéciaux

Certains caractères nécessitent d'être échappés avec un antislash.

echappement.py
# Caractères d'échappement
chaine = "Ceci est une \"citation\" importante"
chemin = "C:\\Users\\Nom\\Documents"
saut_ligne = "Première ligne\nDeuxième ligne"

# Chaînes brutes (raw strings)
chemin_raw = r"C:\Users\Nom\Documents"

2.2.3 Formatage des chaînes

Plusieurs méthodes permettent de formater les chaînes de caractères.

formatage.py
# Formatage avec f-strings (Python 3.6+)
nom = "Alice"
age = 25
message = f"Je m'appelle {nom} et j'ai {age} ans"

# Formatage avec format()
message = "Je m'appelle {} et j'ai {} ans".format(nom, age)

# Formatage avec % (ancienne méthode)
message = "Je m'appelle %s et j'ai %d ans" % (nom, age)

2.3 Les booléens (bool)

Le type booléen représente deux valeurs : True (Vrai) et False (Faux).

booleens.py
# Valeurs booléennes
est_vrai = True
est_faux = False

# Expressions booléennes
resultat = 10 > 5  # True
est_egal = (10 == 5)  # False

2.4 Le type None

None est une constante qui représente l'absence de valeur.

none.py
# Utilisation de None
resultat = None

def fonction_sans_return():
    print("Cette fonction ne retourne rien")

valeur = fonction_sans_return()  # valeur vaut None

3. Les structures de données

Python offre plusieurs structures de données pour organiser et manipuler des collections de valeurs.

3.1 Les listes (list)

Les listes sont des collections ordonnées et modifiables d'éléments.

3.1.1 Création et accès aux éléments

Les listes sont créées avec des crochets et les éléments sont accessibles par index.

listes.py
# Création de listes
nombres = [1, 2, 3, 4, 5]
fruits = ["pomme", "banane", "orange"]
mixte = [1, "deux", 3.0, True]

# Accès aux éléments
premier_fruit = fruits[0]  # "pomme"
dernier_fruit = fruits[-1]  # "orange"
sous_liste = nombres[1:4]  # [2, 3, 4]

3.1.2 Méthodes principales

Les listes disposent de nombreuses méthodes pour les manipuler.

methodes_listes.py
# Méthodes des listes
fruits = ["pomme", "banane"]

fruits.append("orange")  # Ajoute à la fin
fruits.insert(1, "kiwi")  # Insère à la position 1
fruits.remove("banane")  # Supprime l'élément
dernier = fruits.pop()  # Supprime et retourne le dernier
fruits.sort()  # Trie la liste

3.2 Les tuples (tuple)

Les tuples sont des listes immuables (non modifiables).

tuples.py
# Création de tuples
coordonnees = (10, 20)
couleur_rgb = (255, 0, 0)
point = (x, y, z)

# Accès aux éléments
x = coordonnees[0]
y = coordonnees[1]

# Les tuples sont immuables
# coordonnees[0] = 15  # Erreur!

3.3 Les dictionnaires (dict)

Les dictionnaires stockent des paires clé-valeur.

dictionnaires.py
# Création de dictionnaires
personne = {
    "nom": "Dupont",
    "prenom": "Jean",
    "age": 30
}

# Accès aux valeurs
nom = personne["nom"]
age = personne.get("age")

# Ajout et modification
personne["ville"] = "Paris"
personne["age"] = 31

3.4 Les ensembles (set)

Les ensembles sont des collections non ordonnées d'éléments uniques.

ensembles.py
# Création d'ensembles
fruits = {"pomme", "banane", "orange"}
nombres = set([1, 2, 3, 4, 5])

# Ajout d'éléments
fruits.add("kiwi")

# Opérations sur les ensembles
a = {1, 2, 3}
b = {3, 4, 5}
union = a | b  # {1, 2, 3, 4, 5}
intersection = a & b  # {3}

4. Opérations sur les variables

Python offre plusieurs opérations pour manipuler et vérifier les types de variables.

4.1 Vérification du type avec type() et isinstance()

Il est souvent utile de vérifier le type d'une variable.

verification_type.py
# Vérification avec type()
x = 10
print(type(x))  # <class 'int'>

y = "hello"
print(type(y))  # <class 'str'>

# Vérification avec isinstance()
nombre = 3.14
print(isinstance(nombre, float))  # True
print(isinstance(nombre, int))  # False

4.2 Conversion de types (casting)

Python permet de convertir un type de données en un autre.

conversion_types.py
# Conversion entre types
x = 10
x_float = float(x)  # 10.0
x_str = str(x)  # "10"

y = "25"
y_int = int(y)  # 25

z = 3.9
z_int = int(z)  # 3 (troncature)

liste = [1, 2, 3]
liste_tuple = tuple(liste)  # (1, 2, 3)

4.3 Opérateurs et types de données

Les opérateurs se comportent différemment selon les types de données.

operateurs_types.py
# Opérations numériques
a = 10 + 5  # 15 (addition)
b = 10 * 2  # 20 (multiplication)

# Opérations sur les chaînes
c = "Hello" + " " + "World"  # "Hello World" (concaténation)
d = "Hi" * 3  # "HiHiHi" (répétition)

# Opérations sur les listes
liste1 = [1, 2] + [3, 4]  # [1, 2, 3, 4] (concaténation)
liste2 = [0] * 5  # [0, 0, 0, 0, 0] (répétition)

5. Portée des variables (scope)

La portée d'une variable définit où elle est accessible dans le code.

5.1 Variables locales et globales

Les variables ont une portée locale ou globale selon où elles sont définies.

portee_variables.py
# Variable globale
variable_globale = "Je suis globale"

def ma_fonction():
    # Variable locale
    variable_locale = "Je suis locale"
    print(variable_locale)  # Accessible
    print(variable_globale)  # Accessible

ma_fonction()
# print(variable_locale)  # Erreur: variable_locale n'est pas définie

5.2 Le mot-clé global

Le mot-clé global permet de modifier une variable globale depuis une fonction.

mot_cle_global.py
compteur = 0

def incrementer():
    global compteur
    compteur += 1

incrementer()
print(compteur)  # 1

incrementer()
print(compteur)  # 2

6. Exercices pratiques

Mettez en pratique les concepts appris avec ces exercices sur les variables et types de données.

6.1 Manipulation de variables

Créez un programme qui :

  • Déclare plusieurs variables de types différents
  • Affiche leur type avec la fonction type()
  • Convertit certaines variables vers d'autres types
  • Effectue des opérations entre variables de types différents

6.2 Travail avec différents types de données

Créez un programme qui :

  • Utilise des listes pour stocker une collection d'éléments
  • Utilise un dictionnaire pour représenter un objet complexe
  • Manipule des chaînes de caractères avec différentes méthodes
  • Utilise des ensembles pour trouver des éléments uniques

6.3 Mini-projets d'application

Réalisez ces mini-projets pour appliquer vos connaissances :

  • Calculateur d'IMC : Demandez le poids et la taille, calculez l'IMC et affichez la catégorie
  • Gestionnaire de contacts : Créez un dictionnaire de contacts et implémentez des fonctions pour ajouter, supprimer et rechercher des contacts
  • Analyseur de texte : Comptez le nombre de mots, de caractères et de phrases dans un texte
  • Convertisseur d'unités : Convertissez entre différentes unités (température, distance, poids)
Contact

📚 Cours à distance

Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.

Appelez-maintenant
By Rachid Saad

Rejoignez notre communauté d'apprentissage à distance

Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!

Revenir aux chapitres : Python les Bases | Allez au cours gratuits