Python partie I

Introduction

Embarquons ensemble dans une aventure passionnante au cœur de Python 🌌! Ce langage, par sa puissance et sa simplicité, repousse les frontières de la programmation classique et se révèle être un outil incontournable dans l'arsenal de tout développeur. Que l'on cherche à analyser de vastes données, créer des applications web vivantes ou explorer l'univers fascinant de l'intelligence artificielle, Python est la clé qui ouvre toutes ces portes 🗝️. Sa syntaxe limpide et son approche intuitive rendent la programmation accessible à tous, favorisant l'innovation et le raisonnement logique. Chaque ligne de code écrite en Python est un pas en avant dans la réalisation de vos projets les plus ambitieux. Dans le tourbillon technologique actuel, Python est plus qu'un langage ; c'est une véritable baguette magique pour ceux prêts à se laisser ensorceler par ses capacités.Prêts pour l'aventure ? 🚀 Let's code!

I- Variables et types de données

En Python, les variables servent de conteneurs pour stocker différentes formes de données. Chaque variable est associée à un nom qui permet de la référencer et de manipuler sa valeur. Python est un langage dynamiquement typé, ce qui signifie que vous n'avez pas besoin de déclarer explicitement le type de variable lors de leur création ; le type est déduit automatiquement lors de l'attribution de valeurs

Ainsi nous distinguons plusieurs types primitifs de vraiable a savoir:

aque type de données a ses propres méthodes et opérations associées. Nous illustrons ci-dessous quelques exemples d'utilisation avec des cas concrets.

Types de données en Python

Python prend en charge plusieurs types de données primitifs, notamment

📌int : pour les nombres entiers

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

Exemple :

# Exemple d'utilisation d'un entier
x = 10
print(x)  # Affiche 10

📌float : pour les nombres décimaux

Les nombres décimaux sont des nombres avec une partie décimale.

Exemple :

# Exemple d'utilisation d'un nombre décimal
pi = 3.14
print(pi)  # Affiche 3.14

📌str : pour les chaînes de caractères

Les chaînes de caractères représentent du texte.

Exemple :

# Exemple d'utilisation d'une chaîne de caractères
name = "Afdel"
print(name)  # Affiche Afdel

📌bool : pour les valeurs booléennes (True ou False)

Les valeurs booléennes représentent le vrai (True) et ou le faux (False).

Exemple :

# Exemple d'utilisation d'une valeur booléenne
is_student = True
print(is_student)  # Affiche True

📌list : pour les listes ordonnées d'éléments

Les listes en Python sont des structures de données polyvalentes et puissantes qui vous permettent de stocker et de manipuler des collections d'éléments de manière efficace.

Création d'une Liste

En Python, une liste est définie en utilisant des crochets [] et en séparant les éléments par des virgules. Voici un exemple de création d'une liste contenant des nombres entiers

Exemple :

# création d'une liste vide
liste_vide = []

#liste de chiffres
notes = [18, 20, 13, 17, 15]
print(numbers)    # Affiche [1, 2, 3, 4, 5]

# Une liste peut aussi prendre des elements de plusieurs types
prenom ="Desmond"
age = 22
taille = 1.68
notes = [13, 13, 15,11]
statut_etiduant = True

afdel= [prenom,age,taille,notes,statut_etiduant]
print(afdel)    # Affiche ['Desmond', 23, 1.68, [13, 13, 15, 11], True]

Manipulations sur les listes

1. Ajout d'éléments

Les éléments peuvent être ajouté à une liste en utilisant deux méthodes principales : append() et insert().

# append() : Ajoute un élément à la fin de la liste
ma_liste = [1, 2, 3]
ma_liste.append(4)
print(ma_liste)  # Affiche: [1, 2, 3, 4]

# insert() : Insère un élément à un index spécifique
ma_liste = [1, 2, 3]
ma_liste.insert(1, 5)
print(ma_liste)  # Affiche: [1, 5, 2, 3]

2. Suppression d'éléments

Pour supprimer des éléments d'une liste en Python, vous disposez de plusieurs méthodes, notamment : remove(), pop() et del

# remove() permet de supprimer la première occurrence d'une valeur spécifiée dans la liste.
ma_liste = [1, 2, 3, 2, 4]
ma_liste.remove(2)
print(ma_liste)  # Affiche: [1, 3, 2, 4]

# pop() permet de supprimer et de retourner l'élément à une position donnée dans la liste.
ma_liste = [1, 2, 3, 4]
element_supprime = ma_liste.pop(1)  # Supprime l'élément à l'index 1 (2)
print(ma_liste)  # Output: [1, 3, 4]
print(element_supprime)  # Affiche: 2

#  également utiliser l'instruction del pour supprimer un élément ou une tranche d'éléments en spécifiant l'index ou la plage d'indices à supprimer
ma_liste = [1, 2, 3, 4]
del ma_liste[2]  # Supprime l'élément à l'index 2 (3)
print(ma_liste)  # Affiche: [1, 2, 4]

2. Recherche, comptage et trie d'élements

# index() retourne l'index de la première occurrence d'un élément donné.
ma_liste = [10, 20, 30, 20]
index = ma_liste.index(20)
print(index)  # Affiche: 1

# count() retourne le nombre d'occurrences d'un élément donné dans la liste.
ma_liste = [10, 20, 30, 20]
count = ma_liste.count(20)
print(count)  # Affiche: 2

# sort() trie la liste par ordre croissant
ma_liste = [3, 1, 2]
ma_liste.sort()
print(ma_liste)  # Affiche: [1, 2, 3]

# reverse() : Inverse l'ordre des éléments de la liste
ma_liste = [1, 2, 3]
ma_liste.reverse()
print(ma_liste)  # Affiche: [3, 2, 1]

Les listes sont l'une des structures de données les plus fondamentales et les plus utiles en Python. Elles offrent une grande flexibilité et sont largement utilisées dans de nombreux programmes Python. Apprenez à les maîtriser, car elles seront souvent utilisées dans vos projets de programmation.

📌tuple : pour les tuples, des séquences immuables d'éléments

Les tuples sont des structures de données similaires aux listes, mais avec une différence principale : ils sont immuables, ce qui signifie qu'une fois créés, ils ne peuvent pas être modifiés.

Les tuples sont des collections ordonnées d'éléments, similaires aux listes, mais définies en utilisant des parenthèses () au lieu de crochets [].

Exemple :

# Définition d'un tuple
mon_tuple = (1, 2, 3, 'a', 'b', 'c')

# Accès aux éléments du tuple
print(mon_tuple[0])  # Affiche : 1
print(mon_tuple[3])  # Affiche : 'a'

Propriétés des Tuples

-Les tuples sont immuables, ce qui signifie qu'une fois créés, ils ne peuvent pas être modifiés.
-Ils peuvent contenir des éléments de types différents.
-Les opérations comme l'indexation et la concaténation sont applicables aux tuples.

Exemple :

# Concaténation de tuples
tuple1 = (1, 2, 3)
tuple2 = ('a', 'b', 'c')
concatenation = tuple1 + tuple2
print(concatenation)
# Affiche : (1, 2, 3, 'a', 'b', 'c')

Utilisations sur les Tuples

-Les tuples sont utilisés pour stocker des collections d'éléments immuables.
-Ils sont souvent utilisés pour représenter des enregistrements de données avec des champs fixes.
-Les tuples sont également utilisés dans certains cas où la sécurité des données est importante car ils ne peuvent pas être modifiés accidentellement.

# Déclaration d'un tuple représentant un point en 2D
point = (3, 4)

# Accès aux coordonnées du point
x, y = point
print("Coordonnées x :", x)  # Affiche : Coordonnées x : 3
print("Coordonnées y :", y)  # Affiche : Coordonnées y : 4

Manipulations des Tuples

1. Concaténation de Tuples

Les tuples peuvent être concaténés à l'aide de l'opérateur +, ce qui crée un nouveau tuple contenant les éléments des tuples d'origine.

tuple1 = (1, 2, 3)
tuple2 = ('a', 'b', 'c')
concatenation = tuple1 + tuple2
print(concatenation)  # Affiche : (1, 2, 3, 'a', 'b', 'c')

2. Répétition de Tuples

Vous pouvez répéter un tuple en utilisant l'opérateur *, ce qui crée une nouvelle tuple contenant des répétitions du tuple d'origine.

tuple1 = ('a', 'b')
repetition = tuple1 * 3
print(repetition)  # Affiche : ('a', 'b', 'a', 'b', 'a', 'b')

3. Indexation et Slicing

Les tuples supportent l'indexation et le slicing pour accéder aux éléments individuels ou à des sous-groupes d'éléments.

mon_tuple = (1, 2, 3, 'a', 'b', 'c')
print(mon_tuple[2])     # Affiche : 3
print(mon_tuple[1:4])   # Affiche : (2, 3, 'a')

Les tuples sont des structures de données utiles en Python lorsqu'on a besoin d'éléments immuables. Ils offrent une alternative aux listes pour stocker des collections d'éléments et sont largement utilisés dans de nombreux programmes Python. Apprenez à les utiliser correctement pour tirer le meilleur parti de leur immuabilité.

📌dict : pour les dictionnaires, des paires clé-valeur

Un dictionnaire en Python est une structure de données qui permet de stocker des paires clé-valeur. Chaque élément du dictionnaire est accessible par sa clé correspondante. Un dictionnaire est déclaré à l'aide d'accolades {}. Chaque élément est une paire clé-valeur, séparée par ':'.

Exemple :

mon_dictionnaire = {"clé1": "valeur1", "clé2": "valeur2", "clé3": "valeur3"}
etudiant = {"nom": "Afdel", "age": "25", "taille": "1,80Kg", "signe": "capricorne", "matricule": "002911"}
print(etudiant["nom"]) # Affiche Afdel

Manipulations des Dictionnaires

Création d'un dictionnaire

personne = {"nom": "Desmond", "age": "25", "ville": "Dakar"}
print("Dictionnaire initial:", personne)
# Affiche: Dictionnaire initial: {'nom': 'Desmond', 'age': '25', 'ville': 'Dakar'}

Ajout d'un élément

personne["email"] = "desmond@example.com"
print("Dictionnaire après ajout:", personne)
# Afficher : Dictionnaire après suppression: {'nom': 'Desmond', 'ville': 'Dakar', 'email': 'desmond@example.com'}

Suppression d'un élément

del personne["age"]
print("Dictionnaire après suppression:", personne)
# Afiche : Dictionnaire après suppression: {'nom': 'Desmond', 'ville': 'Dakar', 'email': 'desmond@example.com'}

Modification de la valeur d'un élément

personne["ville"] = "Douala"
print("Dictionnaire après modification:", personne)
# Affiche : Dictionnaire après modification: {'nom': 'Desmond', 'ville': 'Douala', 'email': 'desmond@example.com'}

Affichage des clés

cles = personne.keys()
print("Clés du dictionnaire:", cles)
# Affcihe : Clés du dictionnaire: dict_keys(['nom', 'ville', 'email'])

Affichage des valeurs

valeurs = personne.values()
print("Valeurs du dictionnaire:", valeurs)
# Affiche : Valeurs du dictionnaire: dict_values(['Desmond', 'Douala', 'desmond@example.com'])

Affichage des paires clé-valeur

paires = personne.items()
print("Paires clé-valeur du dictionnaire:", paires)
# Affiche : Paires clé-valeur du dictionnaire: dict_items([('nom', 'Desmond'), ('ville', 'Douala'), ('email', 'desmond@example.com')])

Suppression de tous les éléments du dictionnaire

personne.clear()
print("Dictionnaire vidé:", personne)
# Affiche : Dictionnaire vidé: {}

Cet exemple montre comment créer un dictionnaire, ajouter des éléments, les supprimer, les modifier, vérifier l'existence d'une clé, afficher les clés, les valeurs et les paires clé-valeur, ainsi que vider complètement le dictionnaire.

💡 Bon a Savoir

En Python, un dictionnaire est une structure de données qui associe des clés à des valeurs. Une caractéristique importante des dictionnaires est que chaque clé doit être unique. Cela signifie qu'un dictionnaire ne peut pas contenir plusieurs clés identiques.

Voici un exemple illustrant cette propriété :

# Création d'un dictionnaire avec des clés uniques
mon_dictionnaire = {'a': 1, 'b': 2, 'c': 3}

# Tentative d'ajouter une clé identique
mon_dictionnaire['a'] = 4  # Cette opération met à jour la valeur associée à la clé 'a'

print(mon_dictionnaire) # Affiche {'a': 4, 'b': 2, 'c': 3}

Dans cet exemple, nous créons un dictionnaire `mon_dictionnaire` avec des clés uniques `'a'`, `'b'`, et `'c'`, chacune associée à une valeur différente. Lorsque nous essayons d'ajouter une clé identique `'a'`, la valeur associée à cette clé est simplement mise à jour. Le résultat final ne contient toujours qu'une seule entrée pour la clé `'a'`, conformément à la nature unique des clés dans un dictionnaire Python.

📌set : pour les ensembles, des collections non ordonnées d'éléments uniques

Un ensemble, souvent appelé "set" en anglais, est une structure de données en informatique qui représente une collection d'éléments uniques et non ordonnés. En d'autres termes, un ensemble ne permet pas de stocker des éléments en double et ne garantit pas un ordre spécifique des éléments stockés à l'intérieur.

Exemple :

# Déclaration d'un ensemble avec des éléments répétés
mon_set = {1, 2, 3, 2, 4, 5, 3}
print(mon_set)  # Affiche {1, 2, 3, 4, 5}

Manipulations des Ensembles :

1. Ajout d'éléments :

Vous pouvez ajouter des éléments à un ensemble à l'aide de la méthode add().

mon_set = {1, 2, 3}
mon_set.add(4)
print(mon_set)  # Affiche {1, 2, 3, 4}
            

2. Suppression d'éléments :

Vous pouvez supprimer des éléments d'un ensemble à l'aide de la méthode remove().

mon_set = {1, 2, 3}
mon_set.remove(2)
print(mon_set)  # Affiche {1, 3}
            

3. Vider un ensemble :

Vous pouvez vider un ensemble en utilisant la méthode clear().

mon_set = {1, 2, 3}
mon_set.clear()
print(mon_set)  # Affiche set()
            

# Vérification de l'appartenance à un ensemble
mon_set = {1, 2, 3, 4, 5}
print(3 in mon_set)  # Affiche True
print(6 in mon_set)  # Affiche False

# Opérations ensemblistes
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union = set1.union(set2)  # Union de deux ensembles
print(union)  # Affiche {1, 2, 3, 4, 5}

intersection = set1.intersection(set2)  # Intersection de deux ensembles
print(intersection)  # Affiche {3}

difference = set1.difference(set2)  # Différence de deux ensembles
print(difference)  # Affiche {1, 2}

Les ensembles offrent une manière efficace de travailler avec des collections d'éléments uniques en Python. Ils sont largement utilisés pour des opérations qui nécessitent des éléments distincts sans ordre spécifique.

II- Structures de contrôle en Python

Les structures de contrôle en Python sont des outils essentiels pour gérer le flux d'exécution d'un programme. Elles permettent de prendre des décisions en fonction de conditions, d'itérer sur des éléments de données, et de répéter des actions tant qu'une condition est remplie. Dans ce cours, nous explorerons les différentes structures de contrôle disponibles en Python, notamment les instructions conditionnelles (if-elif-else), les boucles (for et while), ainsi que la gestion des exceptions.

L'instruction if

L'instruction if permet d'exécuter un bloc de code uniquement si une condition est vraie.

age = 18
if age >= 18:
    print("Vous êtes majeur.") # Affiche Vous êtes majeur.
#car la condition est respectée, l'age est egale a 18

L'instruction if-else

L'instruction if-else permet d'exécuter un bloc de code si une condition est vraie, sinon un autre bloc de code est exécuté.

age = 15
if age >= 18:
    print("Vous êtes majeur.")
else:
    print("Vous êtes mineur.")
# Affiche Vous êtes mineur.
#car dasn ce cas l'age n'est ni supérieure, ni egale a 18

L'instruction if-elif-else

L'instruction if-elif-else en Python permet de tester plusieurs conditions alternatives de manière séquentielle. Elle est utilisée lorsque vous avez plus de deux conditions à vérifier dans votre programme.

Voici comment elle fonctionne :

L'instruction if est utilisée pour tester la première condition. Si elle est vraie, le bloc de code associé à cette condition est exécuté, et les autres blocs elif et else sont ignorés.

Si la première condition est fausse, l'instruction elif (contraction de "else if") est utilisée pour tester une autre condition. Si cette condition est vraie, le bloc de code associé à cette condition est exécuté, et les autres blocs elif et else sont ignorés.

Si aucune des conditions précédentes n'est vraie, le bloc de code associé à l'instruction else est exécuté.

note = 75

if note >= 90:
    print("Excellent")
elif note >= 80:
    print("Très bien")
elif note >= 70:
    print("Bien")
elif note >= 60:
    print("Assez bien")
else:
    print("Insuffisant")

 # Affiche Bien

Les instructions conditionnelles ainsi que les opérateurs en Python sont utilisés pour évaluer les conditions, vous serez en mesure d'écrire des programmes plus intérréssant qui répondent de manière claire aux différentes situations que vous rencontrerez.

Opérateurs de comparaison

• == : égal à
• != : différent de
• < : inférieur à
• > : supérieur à
• <= : inférieur ou égal à
• >= : supérieur ou égal à

Opérateurs logiques et d'appartenance

Les opérateurs logiques permettent de combiner plusieurs conditions :

• and : retourne True si les deux conditions sont vraies et False dans le cas contraire
• or : retourne True si au moins l'une des conditions est vraie et False dans le cas contraire
• not : retourne True si la condition est fausse et False dans le cas contraire
• not in : retourne True si la condition est fausse et False dans le cas contraire

📌for : pour parcourir des séquences

L'instruction for en Python est utilisée pour parcourir des séquences telles que les listes, les tuples, les ensembles ou les chaînes de caractères. Elle permet d'exécuter un bloc de code pour chaque élément de la séquence.

# Exemple d'utilisation de la boucle for
nombre = [1, 2, 3, 4, 5]
for nb in nombre:
    print(nb)

Utilisation de la fonction range() :

La fonction range() est couramment utilisée avec la boucle for pour générer une séquence de nombres. Elle permet de créer une séquence d'entiers allant d'un nombre de départ à un nombre de fin, avec un pas optionnel.

Syntaxe de la fonction range() :

range(debut, fin, pas)

debut : La valeur de départ de la séquence (par défaut, 0).

fin : La valeur de fin de la séquence (non incluse).

pas : L'incrément entre chaque nombre de la séquence (par défaut, 1).

for i in range(5):
print(i)

Ce bout de code affichera les nombres de 0 à 4 sur des lignes différentes.

for i in range(1, 10, 2):
    print(i)
# Ce code affichera les nombres impairs de 1 à 9 sur des lignes différentes

La boucle for en Python est essentielle pour parcourir des séquences de données, exécutant un bloc de code spécifique pour chaque élément. Avec range(), vous générez des séquences de nombres pour contrôler les itérations.

📌while : pour exécuter une boucle tant qu'une condition est vraie

La boucle while est utilisée en Python pour exécuter un bloc de code tant qu'une condition donnée est vraie. Elle permet de répéter l'exécution d'un ensemble d'instructions jusqu'à ce que la condition devienne fausse.

Supposons que nous voulions afficher les nombres de 1 à 5 à l'aide d'une boucle while :

count = 1
while count <= 5:
    print(count)
    count += 1

Imaginons que nous voulions calculer la somme des entiers de 1 à 10 à l'aide d'une boucle while :

total = 0
count = 1
while count <= 10:
    total += count
    count += 1
print("La somme des entiers de 1 à 10 est :", total)

La boucle while en Python est un outil puissant que pourrez utiliser pour écrire des programmes efficaces et flexibles qui répondent aux besoins de votre application en utilisant cette structure de contrôle de flux.

📌 Instruction break

L'instruction break est utilisée pour interrompre la boucle prématurément si une condition est remplie.

count = 1
while True:
    print(count)
    count += 1
    if count == 5:
        break
# Ce code affiche les nombres de 1 à 4 sur des lignes différentes, puis la boucle s'arrête lorsque count est égal à 5.

for i in range(10):
    if i == 5:
        break
    print(i)
# Ce code affichera les nombres de 0 à 4, puis la boucle s'arrêtera dès que i sera égal à 5.

📌 Instruction continue

L'instruction continue est utilisée pour passer à l'itération suivante de la boucle sans exécuter le reste du code dans le bloc de boucle.

for i in range(10):
    if i % 2 == 0:
        continue
    print(i)
# Ce code affichera tous les nombres impairs de 0 à 9 en sautant les nombres pairs.

count = 0
while count < 5:
    count += 1
    if count == 3:
        continue
    print(count)
# Ce code affiche les nombres de 1 à 5 sur des lignes différentes, mais il saute le nombre 3.

⚠️ Attention aux boucles infinies :

Il est important de faire attention aux boucles infinies, où la condition de la boucle reste toujours vraie, ce qui entraîne l'exécution continue du bloc de code sans fin.

III- Fonctions primitives

Les fonctions permettent de regrouper du code réutilisable :

📌 Fonction help()

La fonction help() en Python est une fonction intégrée qui permet d'obtenir de l'aide sur les modules, les fonctions, les classes, les méthodes, etc. Elle affiche généralement la documentation associée à l'objet passé en argument. c'est a mon sens la fonction la plus essentielle de ce language

help(print)
# affiche: print(*args, sep=' ', end='\n', file=None, flush=False)
    Prints the values to a stream, or to sys.stdout by default.

    sep
      string inserted between values, default a space.
    end
      string appended after the last value, default a newline.
    file
      a file-like object (stream); defaults to the current sys.stdout.
    flush
      whether to forcibly flush the stream.

📌 Fonction print()

La fonction print() est utilisée pour afficher du texte ou d'autres objets sur la sortie standard (généralement la console). Nous l'avons utilisé tou au long de ce cours et on constate qu'elle peut prendre en charge plusieurs arguments et peut afficher des chaînes de caractères, des nombres, des variables, etc.

print("salut, j'apprends a coder en python!")

📌 Fonction input()

La fonction input() est utilisée pour obtenir une entrée de l'utilisateur depuis la console. Elle affiche un message facultatif, puis attend que l'utilisateur saisisse une valeur au clavier. La valeur saisie est généralement stockée dans une variable pour une utilisation ultérieure.

nom = input("Entrez votre nom : ")
print("Bonjour,", nom)

📌 Fonction len()

La fonction len() est utilisée pour obtenir la longueur d'un objet. Elle peut être utilisée avec des chaînes de caractères, des listes, des tuples, des dictionnaires et d'autres types d'objets qui prennent en charge la notion de longueur.

ma_liste = [1, 2, 3, 4, 5]
longueur = len(ma_liste)
print("La longueur de la liste est :", longueur)

En plus des fonctions print(), input(), help(), len (), Python offre d'autres fonctions primitives que je vous encourage à explorer par vous même. voici une liste non exhaustive que vous completerez surement suivant vos besoins personnels

• int(), float(), str(): Convertit entre différents types de données.
• abs(): Retourne la valeur absolue d'un nombre.
• sum(): Calcule la somme des éléments d'un itérable.
• min() et max(): Trouvent le minimum ou le maximum dans une collection d'éléments.
• round(): Arrondit un nombre à un certain nombre de décimales.
• type(): Retourne le type de donnée d'une variable.
• isinstance(): Vérifie si un objet est une instance d'un type spécifique.
• sorted(): Retourne une nouvelle liste triée à partir de l'itérable donné.
• zip(): Regroupe les éléments de deux ou plusieurs itérables, créant ainsi des paires ou des n-uplets.
• enumerate(): Fournit un compteur et la valeur à partir d'un itérable, utile dans les boucles.
• map(): Applique une fonction à tous les éléments d'un itérable.
• filter(): Filtre les éléments d'un itérable, ne laissant passer que ceux pour lesquels une fonction renvoie True.
• eval(): Évalue une chaîne de caractères comme une expression Python.

Conclusion

Découvrir les bases de Python, c'est comme ouvrir la porte d'un vaste univers de programmation 🚀. Bien que nous ayons effleuré seulement la surface, l'apprentissage ne s'arrête jamais. N'oubliez pas d'explorer plus loin, de pratiquer régulièrement, et de rejoindre des communautés pour partager vos découvertes. La suite promet d'être excitante avec la programmation fonctionnelle et orientée objet au programme des parties 2 et 3 🎓. Gardez votre curiosité en éveil et continuez à coder !