Partie N°2: Programmation par Python
prof:[Link]
Happy CodersAcademy
Python
Les domaines d’applications de python
Python est un langage polyvalent utilisé dans de nombreux domaines grâce à sa simplicité, sa puissance et son écosystème
riche en bibliothèques.
1- Développement Web 2- Data Science et Analyse de
Données
3- Développement d’Interfaces
Graphiques
Les domaines d’applications de python
5- Développement de Jeux Vidéo
4- intelligence Artificielle Machine
Learning
Panda3D
6- Automatisation et Scripts
7- Internet des objets
Selenium
PYTHON & Algorithme
1. Introduction à la programmation orientée objet
2. Introduction à Python
3. Installation Python et Anaconda
4. Découverte Python (Premiers pas)
5. Instructions
6. Structures de données
7. Algorithme de tri
8. Développement des algorithmes de la recherche séquentielle et binaire
9. Exercices et Challenges
1. Introduction à la programmation orientée objet :
La programmation orientée objet est l'un des outils les plus importants dans le développement logiciel. C'est une
façon de programmer qui permet une meilleure organisation de son code.
Le code développé à l'aide de la programmation orientée objet est bien plus flexible et donc facilement exportable.
Objet
Attribut méthode
Classe
méthode Attribut
Exemple
Prenons une classe Voiture pour illustrer :
• Classe : Voiture
• Attributs : make (marque), model (modèle), year
(année)
• Méthodes : start() (démarrer), drive() (conduire),
stop() (arrêter)
• Objet : Une instance de la classe Car, par exemple,
une voiture spécifique avec make = "Toyota", model
= "Corolla", year = 2020.
Les principes fondamentaux de la POO
Objet Polymorphisme
Classe
Encapsulation
Héritage
Héritage
L'héritage permet à une classe dérivée d’hériter des propriétés et des
comportements (méthodes) d’une classe parente. Cela permet de réutiliser du
code, de créer des relations hiérarchiques et de spécialiser des comportements
+---------------------+
| Animal |
+---------------------+
| - nom: str |
+---------------------+
| + faire_son(): str |
+---------------------+
^
|
+-------+-------+
| |
+------------+ +------------+
| Chien | | Chat |
+------------+ +------------+
| + faire_son() | | + faire_son()|
+------------+ +------------+
Encapsulation
Encapsulation : C'est le mécanisme qui consiste à cacher les détails internes d'une classe
(comme les attributs ou données) et à permettre l'accès à ces données via des
méthodes publiques (souvent appelées "getters" et "setters"). Cela permet de protéger
l'intégrité des données en empêchant l'accès direct.
+---------------------+
| CompteBancaire |
+---------------------+
| - __titulaire: str |
| - __solde: float |
+---------------------+
| + deposer(montant) |
| + retirer(montant) |
| + obtenir_solde() |
+---------------------+
Polymorphisme
Polymorphisme : Le polymorphisme permet d'utiliser des objets de différentes classes via
une interface commune. On peut appeler la même méthode sur des objets de
différentes classes, et chaque classe fournira sa propre implémentation de la méthode.
+---------------------+
| Animal |
+---------------------+
| - nom: str |
+---------------------+
| + faire_son(): str |
+---------------------+
^
|
+-------+-------+
| |
+------------+ +------------+
| Chien | | Chat |
+------------+ +------------+
| + faire_son()| | + faire_son()|
+------------+ +------------+
^
|
+------------------------+
| faire_faire_son(animal) |
+------------------------+
| + appel de faire_son() |
+------------------------+
Versions de langage Python
Python continue à évoluer, mais cette évolution ne vise qu’à améliorer ou perfectionner le produit. Il est
donc très rare qu’il faille modifier les programmes afin de les adapter à une nouvelle version qui serait devenue
incompatible avec les précédentes
Python 2.0
‣ Décembre 2000 ~ the present Python 2.7
‣ Syntax : Exemple fonction print : print "bonjour“
Python 3.0
‣ Décembre 2008 ~ the present Python 3.8
‣ Syntax : Exemple fonction print : print ("bonjour“)
‣ Plus de bibliothèques.
La version actuelle de Python est 3.13.1
3. Installation Python et Anaconda :
3.1 – Installation simple de Python:
Vous pouvez télécharger gratuitement le logiciel Python depuis le site officiel ci-dessous :
[Link]
L’installation de Python peut-être un vrai challenge. Déjà il faut se décider entre les versions 2.X et 3.X du
langage (Slide suivant). Et par la suite, choisir les librairies nécessaires (ainsi que les versions compatibles). Sans
oublier les subtilités liées aux différents OS (Windows, Linux, Mac…) qui peuvent rendre l’installation encore plus
douloureuse.
Premier pas et notions importantes
‣ Calculer avec Python :
Vous pouvez entrer des instructions Python dans la première cellule. Par exemple :
Pour exécuter le contenu de cette cellule, vous avez plusieurs possibilités :
▪ Cliquer sur le menu Cell, puis Run Cells.
▪ Cliquer sur le bouton Run (sous la barre de menu).
▪ Presser simultanément les touches Ctrl + Entrée.
Premier pas et notions importantes
‣ Calculer avec Jupyter/Python :
Dans tous les cas, vous devriez obtenir quelque chose qui ressemble à l'image ci-
dessous.
La notation In [1] à gauche de la cellule indique qu'il s'agit de la première cellule
exécutée;
‣ Convention de nommage :
- Commencer par une lettre ou un underscore.
- Elle doit ne pas contenir de caractères spéciaux.
- Elle ne doit pas contenir d'espaces.
- On peut utiliser des underscores (_).
- Il est encouragé d’utiliser des noms qui puissent directement commenter votre code.
- Il faut absolument éviter d’utiliser un mot « réservé » par Python (cf. liste ci-dessous)
False Class finally is return
None continue for lambda try
True def from nonlocal while
and del global not with
as elif if or yield
assert else import pass
break except in raise
‣ Type des Variables :
Le type d’une variable correspond à la nature de celle-ci :
- Entier numérique (int).
- Nombre flottant (float).
- Chaîne de caractères (str).
- Booléen (bool).
- Listes.
- Dictionnaires.
- Tuples.
Saisir la commande type(_)
‣ Sélection ou exécution conditionnelle
La plus simple de ces instructions conditionnelles est l’instruction if. Pour expérimenter son
fonctionnement, veuillez entrer dans votre éditeur Python les deux lignes suivantes :
>>> a = 0
>>> if a > 0 :
... print("a est positif")
elif a < 0 :
... print("a est négatif")
else:
... print("a est nul")
‣ Opérateurs de comparaison
La condition évaluée après l’instruction if peut contenir les opérateurs de
comparaison suivants :
x == y # x est égal à y >>> a = 7
x != y # x est différent de y >>> if (a % 2 == 0):
x>y # x est plus grand que y ... print("a est pair")
x<y # x est plus petit que y ... print("parce que le reste de sa division par 2 est nul")
x >= y # x est plus grand que, ou égal à y ... else:
x <= y # x est plus petit que, ou égal à ... print("a est impair")
‣ Instructions imbriquées
Il est parfaitement possible d’imbriquer plusieurs instructions composées, de manière à
réaliser des structures de décision complexes. Exemple :
if embranchement == "vertébrés": #1
if classe == "mammifères": #2
if ordre == "carnivores": #3
if famille == "félins": #4
print("c’est peut-être un chat") #5
print("c’est en tous cas un mammifère") #6
elif classe == "oiseaux": #7
print("c’est peut-être un canari") #8
print("la classification des animaux est complexe") #9
‣ Répétitions en boucle – l’instruction while
Nous allons commencer par l’une des plus fondamentales : la boucle construite à
partir de l’instruction while. Veuillez donc entrer les commandes ci-dessous :
>>> a = 0 # Il faut que la conditionne soit toujours vérifiée
>>> while (a < 7) : # (n’oubliez pas le double point !)
............. a = a + 1 # (n’oubliez pas l’indentation !)
............. print(a)
>>> n = 3
>>> while n < 5:
... print("hello !")
LISTE , TUPLE , DICTIONNAIRE
Caractéristique Liste Tuple Dictionnaire
Type Ordonnée, Mutable Ordonnée, Immuable Non ordonné (<= 3.6) /
Ordonné (>= 3.7)
Syntaxe [] () { clé: valeur }
Accessibilité Par indice ([i]) Par indice ([i]) Par clé (["clé"])
Modification Possible Impossible Possible
Doublons Autorisés Autorisés Les clés doivent être
uniques
Performance Plus lente Plus rapide Variable selon l'usage
Exercice 1 : Tri d’une liste
Écrivez un programme Python qui effectue les opérations suivantes :
1. Demandez à l’utilisateur d’entrer une série de nombres séparés par des espaces.
2. Convertissez ces nombres en une liste.
3. Triez la liste dans l’ordre croissant et affichez-la.
4. Triez la même liste dans l’ordre décroissant et affichez-la. La correction
# Étape 1 : Demander à l'utilisateur d'entrer une série
Entrez une série de nombres : 5 2 9 1 5 6 nombres
Liste d'origine : [5, 2, 9, 1, 5, 6] entree = input("Entrez une série de nombres séparés p
Ordre croissant : [1, 2, 5, 5, 6, 9] espaces : ")
Ordre décroissant : [9, 6, 5, 5, 2, 1] # Étape 2 : Convertir l'entrée en liste d'entiers
liste = [int(x) for x in [Link]()]
Indication # Étape 3 : Afficher la liste d'origine
input() : Permet à l’utilisateur d’entrer des valeurs sous forme de texte. print(f"Liste d'origine : {liste}")
split() : Divise la chaîne en éléments individuels en se basant sur les espaces. # Étape 4 : Trier la liste en ordre croissant
sorted() : Trie la liste : liste_croissant = sorted(liste)
• Par défaut : trie en ordre croissant. print(f"Ordre croissant : {liste_croissant}")
• reverse=True : trie en ordre décroissant.
# Étape 5 : Trier la liste en ordre décroissant
liste_decroissant = sorted(liste, reverse=True)
print(f"Ordre décroissant : {liste_decroissant}")
‣ Les listes (première approche)
Sous Python, on peut définir une liste comme une collection d’éléments séparés par des virgules,
l’ensemble étant enfermé dans des crochets. Exemple :
>>> jour = ['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi']
>>> print(jour)
['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi']
Dans cet exemple, la valeur de la variable jour est une liste.
>>> jour = ['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi']
>>> print(jour[2])
mercredi
>>> print(jour[4])
20.357
‣ Les listes (première approche)
Il est possible de changer les éléments individuels d’une liste :
>>> print(jour) ['lundi', 'mardi', 'mercredi', 1800, 20.357, 'jeudi', 'vendredi']
>>> jour[3] = jour[3] +47
>>> print(jour) ['lundi', 'mardi', 'mercredi', 1847, 20.357, 'jeudi', 'vendredi‘]
On peut donc remplacer certains éléments d’une liste par d’autres, comme ci-dessous :
>>> jour[3] = 'Juillet'
>>> print(jour) ['lundi', 'mardi', 'mercredi', 'Juillet', 20.357, 'jeudi', 'vendredi']
La fonction intégrée len(), que nous avons déjà rencontrée à propos des chaînes,
s’applique aussi aux listes. Elle renvoie le nombre d’éléments présents dans la liste :
>>> print(len(jour))
7
‣ Les listes (première approche)
Une autre fonction intégrée permet de supprimer d’une liste un élément quelconque (à partir de
son index). Il s’agit de la fonction del() 23 :
>>> del(jour[4])
>>> print(jour) ['lundi', 'mardi', 'mercredi', 'juillet', 'jeudi', 'vendredi']
Il est également tout à fait possible d’ajouter un élément à une liste :
>>> [Link]('samedi')
>>> print(jour)
>>> ['lundi', 'mardi', 'mercredi', 'juillet', 'jeudi', 'vendredi', 'samedi']
Fonctions prédéfinies
‣ Affichage : la fonction print()
On manipule les valeurs et les variables qui les référencent en les combinant
avec des opérateurs pour former des expressions. Exemple :
>>> print("Bonjour", "à", "tous", sep ="*") >>> n =0
Bonjour*à*tous >>> while n<6:
>>> print("Bonjour", "à", "tous", sep ="") ... print("zut", end ="")
Bonjouràtous ... n = n+1 ...
zutzutzutzutzut
Fonctions prédéfinies
‣ Interaction avec l’utilisateur : la fonction input()
La plupart des scripts élaborés nécessitent une intervention de l’utilisateur (entrée d’un
paramètre, clic de souris sur un bouton, etc.).
>>> prenom = input("Entrez votre prénom : ")
>>> print("Bonjour,", prenom)
>>> print("Veuillez entrer un nombre positif quelconque : ", end=" ")
>>> ch = input()
>>> nn = int(ch)
>>> print("Le carré de", nn, "vaut", nn**2)
6. Instructions :
Fonction simple sans paramètre
La syntaxe Python pour la définition d’une fonction est Affichage:
la suivante : >>> table7()
7 14 21 28 35 42 49 56 63 70
def nomDeLaFonction (liste de paramètres): >>> def table7triple():
... ... print('La table par 7 en triple exemplaire :')
bloc d'instructions ... table7()
... ... table7()
... table7()
Exemple:
>>> def table7(): Affichage:
... n = 1 >>> table7triple()
... while n <11 : La table par 7 en triple exemplaire :
... print(n * 7, end =' ‘) 7 14 21 28 35 42 49 56 63 70
... n = n +1 7 14 21 28 35 42 49 56 63 70
... 7 14 21 28 35 42 49 56 63 70
Rq: Une première fonction peut donc appeler une deuxième fonction, qui elle-même en appelle une troisieme, etc.
Fonctions avec paramètre :
>>> def table(base): >>> table(13)
... n = 1
... while n <11 :
... print(n * base, end =' ')
... n = n +1
Utilisation d’une variable comme argument:
>>> a = 1
>>> while a <20:
... table(a)
... a = a +1
...
Remarque importante:
Dans l’exemple ci-dessus, l’argument que nous passons à la fonction table() est le contenu de la variable a.
A l’intérieur de la fonction, cet argument est affecté au paramètre base, qui est une toute autre variable.
Notez donc bien des maintenant que le nom d’une variable que nous passons comme argument n’a rien à voir avec le nom du paramètre
correspondant dans la fonction.
Fonctions avec paramètre :
>>> def tableMulti(base, debut, fin):
... print('Fragment de la table de multiplication par', base, ':')
... n = debut
... while n <= fin :
... print(n, 'x', base, '=', n * base)
... n = n +1
>>> tableMulti(8, 13, 17) => Qu’est ce que ca va donner !!!!
Exemple:
>>> t, d, f = 11, 5, 10
>>> while t<21:
... tableMulti(t,d,f)
... t, d, f = t +1, d +3, f +5
...
Variables locales:
La machine nous signale clairement que le symbole base lui est inconnu, alors qu’il était
>>> print(base) correctement imprimé par la fonction tableMulti() elle-même. L’espace de noms qui
Traceback (most recent call last): contient le symbole base est strictement réservé au fonctionnement interne de
File "<stdin>", line 1, in <module> tableMulti(), et il est automatiquement détruit dès que la fonction a terminé son travail.
NameError: name 'base' is not defined
Variables globales:
Exemple :
Les variables définies à l’extérieur d’une >>> def mask(): >>> def monter() :
fonction sont des variables globales. Leur ... p = 20 ... global a
contenu est ≪ visible≫ de l’intérieur d’une ... print(p, q) ... a = a+1
fonction, mais la fonction ne peut pas le >>> p, q = 15, 38 ... print(a)
modifier. >>> mask() >>> a = 15
20 38 >>> monter()
>>> print(p, q) 16
15 38 >>> monter()
17
Exercice 2 : Générer un triangle d’étoiles
Écrivez un programme Python qui demande à l’utilisateur d’entrer un nombre entier positif n. Le programme doit
afficher un triangle d’étoiles ayant n lignes.
• La première ligne doit contenir 1 étoile.
• La deuxième ligne doit contenir 2 étoiles, et ainsi de suite.
• La n-ième ligne doit contenir n étoiles.
Instructions : La correction
1. Demandez à l’utilisateur un nombre entier n. n = int(input("Entrez le nombre de lignes pour le
triangle : "))
2. Générez un triangle d’étoiles ayant n lignes.
# Générer le triangle d'étoiles
for i in range(1, n + 1):
Exercice 3 : Motif en pyramide (triangle centré)
Écrivez un programme Python qui demande à l’utilisateur d’entrer un entier positif n (nombre de lignes). Le programme
doit afficher une pyramide d’étoiles centrée.
La correction
* n = int(input("Entrez le nombre de lignes
*** pour la pyramide : "))
*****
*******
********* for i in range(1, n + 1):
print(" " * (n - i) + "*" * (2 * i - 1))
Exercice 4 : Motif en losange
Écrivez un programme qui génère un losange composé d’étoiles, basé sur un nombre n donné (le nombre de lignes de la
moitié supérieure).
La correction
n = int(input("Entrez le nombre de lignes pour la moitié
* supérieure du losange : "))
***
***** # Partie supérieure
******* for i in range(1, n + 1):
***** print(" " * (n - i) + "*" * (2 * i - 1))
***
* # Partie inférieure
for i in range(n - 1, 0, -1):
print(" " * (n - i) + "*" * (2 * i - 1))
Exercice 5 : gestion d’une bibliothèque
Vous devez développer un programme pour gérer une bibliothèque simple. Voici les fonctionnalités à implémenter :
1. Afficher le menu principal :
Le programme doit afficher un menu pour choisir une action parmi les options suivantes :
• Ajouter un livre.
• Afficher la liste des livres.
• Rechercher un livre par titre.
• Supprimer un livre.
• Quitter le programme.
2. Utiliser une structure de données :
Stockez les informations des livres sous forme de dictionnaire dans une liste :
• Chaque livre aura : titre, auteur, année.
3. Utiliser des fonctions :
Définissez une fonction pour chaque fonctionnalité (ajouter, afficher, rechercher, supprimer, etc.).
4. Utiliser les boucles :
Le menu doit s’afficher tant que l’utilisateur ne choisit pas de quitter.
=== Gestion de Bibliothèque ===
1. Ajouter un livre
2. Afficher la liste des livres
3. Rechercher un livre par titre
4. Supprimer un livre
5. Quitter
Entrez votre choix : 1
Entrez le titre du livre : Python pour les nuls
Entrez l'auteur : John Doe
Entrez l'année de publication : 2020
Livre ajouté avec succès ! Exemple d’exécution
=== Gestion de Bibliothèque ===
1. Ajouter un livre
2. Afficher la liste des livres
3. Rechercher un livre par titre
4. Supprimer un livre
5. Quitter
Entrez votre choix : 2
Liste des livres :
1. Titre : Python pour les nuls | Auteur : John Doe | Année : 2020
# Liste pour stocker les livres
bibliotheque = []
# Fonction pour afficher le menu # Fonction pour rechercher un livre par titre
def afficher_menu(): def rechercher_livre():
print("\n=== Gestion de Bibliothèque ===") titre_recherche = input("Entrez le titre à rechercher : ")
print("1. Ajouter un livre") for livre in bibliotheque:
print("2. Afficher la liste des livres") if livre['titre'].lower() == titre_recherche.lower():
print("3. Rechercher un livre par titre") print(f"Livre trouvé : Titre : {livre['titre']} | Auteur : {livre['auteur']}
print("4. Supprimer un livre") | Année : {livre['annee']}")
print("5. Quitter") return
print("Livre non trouvé.")
# Fonction pour ajouter un livre
def ajouter_livre(): # Fonction pour supprimer un livre par titre
titre = input("Entrez le titre du livre : ") def supprimer_livre():
auteur = input("Entrez l'auteur du livre : ") titre_supprimer = input("Entrez le titre du livre à supprimer : ")
annee = input("Entrez l'année de publication : ") for livre in bibliotheque:
livre = {"titre": titre, "auteur": auteur, "annee": annee} if livre['titre'].lower() == titre_supprimer.lower():
[Link](livre) [Link](livre)
print("Livre ajouté avec succès !") print("Livre supprimé avec succès.")
return
# Fonction pour afficher tous les livres print("Livre non trouvé.")
def afficher_livres():
if not bibliotheque:
print("La bibliothèque est vide.")
else:
print("\nListe des livres :")
for i, livre in enumerate(bibliotheque, start=1):
print(f"{i}. Titre : {livre['titre']} | Auteur : {livre['auteur']} | Année
: {livre['annee']}")
# Fonction principale
def main():
while True:
afficher_menu()
choix = input("Entrez votre choix : ")
if choix == "1":
ajouter_livre()
elif choix == "2":
afficher_livres()
elif choix == "3":
rechercher_livre()
elif choix == "4":
supprimer_livre()
elif choix == "5":
print("Merci d'avoir utilisé le programme. À
bientôt !")
break
else:
print("Choix invalide. Veuillez réessayer.")
# Exécution du programme
if __name__ == "__main__":
main()
Vraies fonctions et procédures:
>>> def cube(w):
... return w*w*w L’instruction « return » définit ce que doit être la valeur renvoyée par la fonction. En
l’occurrence, il s’agit du cube de l’argument qui a été transmis lors de l’appel de la fonction.
Exemple
>>> b = cube(9)
>>> print(b)
729
>>> def table(base):
... resultat = [] # résultat est d’abord une liste vide >>> print(ta9)
... n = 1 [9, 18, 27, 36, 45, 54, 63, 72, 81, 90]
... while n < 11: >>> print(ta9[0])
... b = n * base 9
... [Link](b) # ajout d’un terme à la liste >>> print(ta9[3])
... n = n +1 36
... return resultat >>> print(ta9[2:5])
Test [27, 36, 45]
>>> ta9 = table(9)
Typage des paramètres:
le typage des variables sous Python est un typage dynamique, ce qui signifie que le type d’une
variable est défini au moment où on lui affecte une valeur. Ce mécanisme fonctionne aussi pour les
paramètres d’une fonction. Le type d’un paramètre devient automatiquement le même que celui de
l’argument qui a été transmis à la fonction.
>>> def afficher3fois(arg):
... print(arg, arg, arg) ...
>>> afficher3fois(5)
555
>>> afficher3fois('zut')
zut zut zut
>>> afficher3fois([5, 7])
[5, 7] [5, 7] [5, 7]
>>> afficher3fois(6**2)
36 36 36
Valeur par défaut pour les paramètres :
Dans la définition d’une fonction, il est possible (et souvent souhaitable) de définir un argument
par défaut pour chacun des paramètres.
>>> def politesse(nom, vedette ='Monsieur'):
... print("Veuillez agréer ,", vedette, nom, ", mes salutations cordiales.") ...
>>> politesse('Dupont')
Veuillez agréer , Monsieur Dupont , mes salutations cordiales.
>>> politesse('Durand', 'Mademoiselle')
Veuillez agréer , Mademoiselle Durand , mes salutations cordiales
Valeur par défaut pour les paramètres :
Dans la définition d’une fonction, il est possible (et souvent souhaitable) de définir un argument par
défaut pour chacun des paramètres.
>>> def question(annonce, essais =4, please =’Oui ou non, s.v.p.!’):
while essais >0: ...
reponse = input(annonce) ...
if reponse in ('o', 'oui','O','Oui','OUI'): ...
return 1 ...
if reponse in ('n','non','N','Non','NON'): ...
return 0 ...
print(please) ...
essais = essais-1
... >>>
rep = question('Voulez-vous vraiment terminer ? ')
ou bien :
rep = question('Faut-il effacer ce fichier ? ', 3)
ou même encore :
rep = question('Avez-vous compris ? ', 2, 'Répondez par oui ou par non !')
Classes, objets, attributs :
• Objets :
Les fonctions peuvent utiliser des objets comme paramètres, et elles peuvent également fournir un
objet comme valeur de retour.
>>> def affiche_point(p):
... print("coord. horizontale =", p.x, "coord. verticale =", p.y)
>>> affiche_point(p9)
coord. horizontale = 3.0 coord. verticale = 4.0
Classes, objets, attributs :
• Objets (Similitude et unicité) :
>>> p1 = Point()
>>> p1.x = 3 >>> print(p1)
>>> p1.y = 4 <__main__.Point instance at 00C2CBEC>
>>> p2 = Point() >>> print(p2)
>>> p2.x = 3 <__main__.Point instance at 00C50F9C
>>> p2.y = 4
>>> print(p1 == p2)
False
• Objets comme valeurs de retour d’une fonction
>>> def trouveCentre(box):
... p = Point()
Classes, objets, attributs :
• Attributs :
L’objet que nous venons de créer est juste une coquille vide. Nous allons à présent lui ajouter des
composants, par simple assignation, en utilisant le système de qualification des noms par points
>>> class Point(object): ... "Définition d'un point géométrique"
>>> p9.x = 3.0
>>> p9.y = 4.0
>>> print(p9.x) 3.0
>>> print(p9.x**2 + p9.y**2)
25.0
Méthode
• Définition :
>>> class Time(object):
... "définition d'objets temporels"
>>> instant = Time()
>>> [Link] = 11
>>> [Link] = 34
>>> [Link] = 25
>>> affiche_heure(instant) 11:34:25
>>> def affiche_heure(t): ... print(str([Link]) +":" +str([Link]) +":" +str([Link]))
>>> def affiche_heure(t): ... print("{}:{}:{}".format([Link], [Link], [Link]))
7. Structures de données:
Définition :
‣ Une structure de donnée : c'est une organisation des données permettant de simplifié ou d'organisé
leur traitement. Autrement dit, elle relie entre elles, les données.
Structure de donnée
Structure linéaire Structure non-linéaire
• Les listes • Les arbres
• Les piles • Les graphes
• Les files
