Python pour les débutants

to Advanced
 Python du Débutant à l'Avancé

1. Introduction à Python 4
Commencer avec Python 4
Installation de Python 4
Introduction à Python 7
Langage de haut niveau 7
Interpreted Language 8
Langage à typage dynamique 8
Langage orienté objet 8
Avantages et inconvénients de l'utilisation de Python 8
Avantages de l'utilisation de Python 8
Inconvénients de l'utilisation de Python 9
Mise en place d'un environnement de développement intégré : 9
Écrire le premier code en utilisant l'IDE VS Code : 11
2. Variables et Types de Données en Python 13
Variables en Python 13
Types de données en Python 13
Chambres 13
Entiers 16
Flotteurs 16
Booléen 17
Testons nos connaissances ! 17
3. Tuples, listes, ensembles et dictionnaires en Python 19
Introduction aux tuples, listes, ensembles et dictionnaires en Python 19
Listes en Python 19
Opérations de base avec des listes 19
Les tuples Python 22
Différence entre les tuples et les listes en Python 23
4. Ensembles et dictionnaires Python 23
Ensembles Python 23
Opérations dans les ensembles Python 24
Ajouter un élément dans un ensemble 24
Supprimer un élément d'un ensemble 25
Dictionnaires en Python 26
Différence entre les ensembles et les dictionnaires Python 28
5. Instructions conditionnelles en Python 28
Instructions conditionnelles en Python - que font-elles ? 28
Python input() 28
Instruction if en Python 29
Syntaxe en Python 29
Si sinon en Python 30
6. Boucles en Python 32
Boucles en Python 32
Boucle for en Python 32
Boucles For dans la Liste 33
Itérer un ensemble en utilisant une boucle for 34
Itérer un tuple à l'aide d'une boucle for 35
Itérer un dictionnaire en utilisant une boucle for 35
Boucles imbriquées en Python 35
Boucles While en Python 36
7. Fonctions Python 37
Les fonctions Python en tant qu'objets 39
Stocker des fonctions Python dans des structures de données 41
8. Fonctions avancées en Python 41
Passer des fonctions à d'autres fonctions 41
Utiliser des fonctions à l'intérieur d'une fonction 42
*Args en Python 42
L'opérateur "*" en Python 43
**kwargs en Python 45
9. Classes et objets Python 47
Classes Python – définition 47
Initialisation des classes Python 47
Écrivons notre première classe Python 47
Attributs 48
Comportement de la classe 48
Objets en Python 49
Héritage 51
10. Fichiers en Python 53
Fichiers en Python – définition : 53
Exemples de fichiers binaires en Python : 53
Exemples de fichiers texte en Python : 53
Opérations sur les fichiers en Python 53
Fonctions impliquées dans la lecture de fichiers en Python 55
11. Applications Python en pratique 58
Créer un jeu de devinette de nombres 58
 Python du débutant à avancé

Cet e-book Python vous aidera à comprendre tous les éléments essentiels du langage de programmation Python. Quiconque qui
veut apprendre Python sans aucune expérience préalable en programmation et quiconque souhaite rafraîchir ses connaissances en Python

La connaissance peut lire cet e-book et comprendre les concepts Python largement utilisés.

1. Introduction à Python
Commencer avec Python

Après avoir lu ce livre électronique sur Python, vous serez en mesure d'écrire des programmes en Python, d'utiliser n'importe quelle bibliothèque Python et de développer.

leurs propres paquets en utilisant Python.

La première étape pour apprendre n'importe quel langage de programmation est de configurer l'environnement pour écrire des programmes. Alors que nous allons

À travers un e-book Python, nous commencerons par l'installation de Python sur trois plateformes OS différentes.

Python Installation

.ousde-iconsm
eépsaeinteéselvzeuis,éllatnsiàdjéthonsP
eytisreifiP
vréour

• Appuyez sur Windows + r pour ouvrir l'exécuter.

• Tapez ensuite cmd et appuyez sur entrer.

• Après avoir ouvert l'invite de commandes, vous pouvez vérifier si Python est déjà installé en tapant Python dans l'invite de commandes.

4
Nous pouvons également vérifier la version de Python installée en utilisant des commandes comme démontré ci-dessous.

Maintenant, nous allons passer en revue comment installer Python sur Windows. Des liens sont fournis pour une navigation rapide lors du suivi.

e-book. Depuis le lien web Python pour Windows, la version stable de Python peut être téléchargée avec votre choix entre
Versions de système d'exploitation 64 bits ou 32 bits.

5
Comme nous pouvons le voir, la dernière version disponible pour Python 3 est Python 3.10.0. Maintenant, cliquez sur la dernière version de Python 3 –

Python 3.10.0 et cela vous dirigera vers la page de téléchargement où, si nous faisons défiler vers le bas de la page, nous allons
trouver un tableau comme ci-dessous.

Cliquez maintenant sur l'Installateur Windows (32 bits) ou l'Installateur Windows (64 bits) selon votre choix. Une fenêtre s'ouvrira.
vous demandant de sélectionner le chemin où vous souhaitez télécharger votre installateur. Après avoir téléchargé le fichier exécutable, double-

cliquez sur le fichier pour commencer l'installation.

Vous trouverez ci-dessous les étapes.

• Exécutez le fichier exécutable Python, dans notre cas ce sera [Link].

• When you double-click on the file, a window will open asking do you want to run this file. Click on run to start the
Installation de Python.
• Selon votre choix, sélectionnez si vous souhaitez que Python soit installé pour tous les utilisateurs ou pour un seul utilisateur.

• De plus, sélectionnez la case à cocher ajouter Python 3.10 au PATH.

6
• Alors sélectionnez installer maintenant. Installer maintenant installera Python avec tous les paramètres recommandés, ce qui est une bonne option.

pour les débutants.

• Ensuite, il faudra quelques minutes pour que la configuration soit terminée, et vous serez amené à la prochaine invite de dialogue qui vous demandera

désactiver la limite de longueur de chemin. Cela permettra à Python d'utiliser des noms de chemin longs sans aucun caractère

• limite de 260 qui est activée si la limite de longueur de chemin n'est pas désactivée.

• Pour vérifier si Python est installé, vous pouvez utiliser Python -V ou Python – version ou simplement taper Python dans l'invite de commande.

Félicitations, vous avez installé Python avec succès. Écrivons notre premier programme dans cmd en utilisant Python.

• Dans notre premier programme, nous allons simplement imprimer "Félicitations ! Vous avez installé Python correctement."

• Pour écrire ceci, nous allons utiliser la fonction print de Python.

• Tapez print("Félicitations !!, vous avez installé Python correctement").

• Puis appuyez sur Entrée.

• Vous verrez que l'instruction que nous avons écrite à l'intérieur de l'impression est affichée ci-dessous.

Introduction à Python

Python est un langage de programmation interprété, de haut niveau, à typage dynamique et orienté objet.

Avant de se plonger dans l'écriture de programmes en Python, il est important de comprendre ce que signifient les termes ci-dessus.

Langage de haut niveau

Un langage de haut niveau donne au programmeur la liberté de coder des programmes qui sont indépendants d'un type particulier de
appareil. Ils sont appelés langages de haut niveau car ils sont plus proches des langues humaines. Python est un langage de haut niveau car il n'est pas un

Langage compilé, Python nécessite un autre programme pour exécuter le code contrairement à C qui s'exécute directement sur le processeur local.

7
Langue interprétée
Python est un langage interprété, car le code source du programme Python est converti en code d'octets qui est ensuite exécuté.
dans la machine virtuelle Python, contrairement à C ou C++.

Langage à typage dynamique

Python est un langage à typage dynamique car le type de la variable est vérifié pendant l'exécution. Nous allons apprendre sur
types de données dans les chapitres suivants.

Langage orienté objet

Python est un langage orienté objet car le développeur Python peut utiliser des classes et des objets pour écrire du code propre et

code réutilisable.

Avantages et inconvénients de l'utilisation de Python

Avantages d'utiliser Python

• Comme les syntaxes Python sont plus proches du langage humain, il est plus facile d'apprendre, de comprendre et d'écrire le code.

• C'est à la fois un langage fonctionnel et orienté objet.

• Python bénéficie d'un large soutien communautaire et possède également un grand nombre de modules, bibliothèques et packages.

• En raison de sa simplicité, développer un programme ou une application en Python est plus rapide que dans n'importe quel autre langage comme

Java.
• Python est un choix de langue en science des données, en apprentissage automatique et en intelligence artificielle en raison de sa grande variété de

paquets et bibliothèques d'apprentissage automatique.

• Presque tout peut être développé en utilisant Python, il dispose également d'outils pour le développement d'applications tels que kivy, flask, Django

et beaucoup d'autres.

8
Inconvénients de l'utilisation de Python

• Il n'est pas recommandé pour la communication avec des composants matériels.

• Il n'y a pas d'optimisateurs de temps en Python, donc il est plus lent que la plupart des langages comme C, C++ et Java.

• Le codage basé sur l'indentation rend un peu difficile la transition pour les personnes venant du C, C++ ou Java.
Python.

Configurer un environnement de développement intégré :

Nous utiliserons Visual Studio Code pour écrire du code en Python. Visual Studio Code, abrégé en VS Code, est un logiciel open-source.
éditeur de code source avec de nombreux plugins et extensions. Ces plugins et extensions facilitent l'écriture de code dans VS Code

plus simple et plus intuitif. De plus, VS Code est très léger par rapport à d'autres IDE. Il propose également divers thèmes pour personnaliser le

environnement de développement intéressant pour le développeur.

Installer VS Code sur Windows :

• En utilisant le lien ci-dessous, téléchargez le fichier exécutable de VS code. Lien :[Link]

fenêtres
• Ensuite, double-cliquez sur le fichier téléchargé pour l'exécuter et cliquez sur exécuter. Ensuite, suivez les étapes indiquées dans les images.

en dessous.
• Cliquez sur J'accepte l'accord et cliquez sur suivant.

• Sélectionnez les cases à cocher comme indiqué dans l'image ci-dessous et cliquez sur suivant.

9
• Puis cliquez sur installer et cela prendra quelques minutes pour que la configuration de VS Code soit terminée. Après la fin de la configuration

cliquez sur le bouton terminer.

10
Écriture du premier code en utilisant l'EDI VS Code :

• Open VS Code and you will see a window as shown below.

• Cliquez sur le fichier pour ouvrir le menu de fichiers et cliquez sur nouveau fichier comme indiqué ci-dessous.

• Puis un onglet s'ouvrira dans VS Code nommé Sans titre-1 comme montré ci-dessous.

11
• Cliquez sur sélectionner une langue et la fenêtre ci-dessous s'ouvrira où vous devrez sélectionner Python.

• Puis tapez le code print("Python installé avec succès!!!") comme indiqué ci-dessous.

• Puis allez dans l'onglet Exécuter comme indiqué ci-dessous et sélectionnez Exécuter sans débogage.

• Ensuite, VS Code vous demandera d'enregistrer le fichier. Enregistrez le fichier dans le répertoire de votre choix. Il exécutera le fichier après l'avoir enregistré et

vous montre le résultat comme ci-dessous.

12
2. Variables et types de données en Python
Comme nous l'avons appris dans le chapitre précédent - Python est un langage de haut niveau, interprété, typé dynamiquement et orienté objet.

language. Due to its high-level nature, the language is very easy to learn, and syntax is also simple. There are a variety of
applications de Python dans le monde réel comme pour l'apprentissage automatique, la science des données, le développement de jeux, les applications web, et

beaucoup plus.

Dans le chapitre précédent, nous avons appris comment imprimer du texte en Python. Nous utilisions print("votre texte désiré") comme syntaxe.
Commençons par ce que sont les variables et pourquoi nous utilisons des variables.

Variables en Python
Une variable est une entité qui stocke une valeur. La valeur peut être un nombre, un entier, un nombre réel, un texte ou un caractère. Voyons cela.
quelques exemples de la façon dont vous pouvez utiliser une variable pour stocker des valeurs en Python.

1 # variables
2 x = 1 # stockage d'un entier
3 y = 2.5 # stockage d'un nombre réel

4 z = "chaine"# stocker une chaîne ou du texte

5 n = "a" # stocker un caractère

6 b = True # stocker une valeur booléenne
7 imprimer(x,y,z,n,b)

1 Output:
2 1 2.5 chaîne a Vrai

Nous avons vu comment stocker des variables, maintenant voyons comment afficher leurs valeurs. Vous connaissez déjà la réponse, qui est d'utiliser

print(), que nous avons utilisé dans le premier chapitre pour afficher le texte désiré. De plus, notez que nous utilisons les variables sans utiliser

des guillemets doubles ou simples contrairement à avant. Cela est dû au fait qu'une variable est reconnue par l'impression directement telle qu'elle est

stocké dans la mémoire lorsqu'il est déclaré. Maintenant, imprimons les variables.

Nous pouvons voir que les variables sont imprimées comme souligné dans l'image ci-dessus. Comme nous pouvons le voir, Python prend en charge la plupart des

différents types de données en Python tels que entier, flottant (nombres réels), chaîne (texte ou caractères) et booléen (Vrai ou Faux).

Types de données en Python

Chaînes

13
Quelles opérations peuvent être effectuées avec des chaînes ?

• title()
Cette fonction peut être utilisée pour mettre en majuscule la première lettre de chaque mot dans la chaîne comme le montre ci-dessous, la sortie est mise en évidence.

1 ce blog est incroyable

2 Imprimer([Link]())

Output:

1 Ce blog est génial

• majuscule()
Cette fonction peut être utilisée pour mettre en majuscules tous les mots de la chaîne. L'exemple est illustré dans l'image ci-dessous.

1 ce blog est génial

2 PRINT([Link]())
3
4 Sortie :
5 CE BLOG EST GÉNIAL

• minuscule()
Cette fonction peut être utilisée pour convertir tous les mots de la chaîne en lettres minuscules. L'exemple est illustré dans
l'image ci-dessous.

1 ce blog est génial

2 imprimer([Link]())

1 Output:
2
3 ce blog est génial

• Concaténation de chaînes
Pour combiner deux chaînes différentes, le "+" peut être utilisé. L'exemple est illustré dans l'image ci-dessous.

1 ce blog est génial

2 text2=”for beginners”
3 imprimer(text+text2)

1 Output:
2
3 ce blog est génial pour les débutants

14
• Espaces blancs
Il y a des moments où vous ne voulez pas imprimer le texte sur une seule ligne, mais avoir plusieurs lignes, et parfois vous voulez du texte
avoir un espace de tabulation. Cela peut être fait en Python en utilisant "\n" (nouvelle ligne) et "\t" (espace de tabulation). L'exemple est illustré

below.

1 print("ce blog est \n génial")

2 Ce blog est génial

1 Sortie :
2
3 ceblog est
4 awesome
5 ce blog est génial

• Fonctions de Strip
C'est une fonction en Python qui supprime tout espace blanc dans la chaîne. En utilisant strip, les espaces blancs à gauche et à droite peuvent être

supprimé. Mais parfois, pour les exigences spécifiques concernant la suppression des espaces blancs à gauche, "lstrip()" peut être utilisé et pour la droite

La méthode "rstrip()" peut être utilisée. L'exemple avec le code est illustré ci-dessous.

01 z=" bonjour "

02 print(z)
03 print([Link]())
04 imprimer([Link]())
05 print([Link]())
06 Output:
07 bonjour
08 bonjour
09 bonjour
10 bonjour

• Longueur de chaîne

En utilisant la fonction len(), la longueur d'une chaîne peut être déterminée. L'exemple avec le code est illustré ci-dessous. Vous pouvez voir pour

string “hello”,the output is 5.

1 Z=”awesome”
2 Print(len(Z))

1 Output:
2 5

15
Entiers
Les types de données entiers en Python ne sont utilisés que lorsque des nombres entiers doivent être stockés. Il existe plusieurs opérations,

qui peut être effectué sur des entiers. Apprenons à connaître la fonction type() ici. La fonction type() vous informe sur le
le type de données de la variable. L'exemple pour la fonction type() avec le code est illustré ci-dessous.

1 a=1
2
3 type(a)

1 Output:
2
3 int

Flotteurs
Dans les variables de type de données entier uniquement, des nombres entiers peuvent être stockés, mais pour inclure des nombres réels ou pour stocker des nombres réels, nous

utiliser float. En essence, float est utilisé pour les décimales.

1 a=1.6
2
3 type(a)

1 Output:
2
3 flotte

Opérations sur les floats et les entiers

Dans nos mathématiques de base pendant notre lycée, nous avons appris de nombreuses opérations qui peuvent être effectuées sur
des nombres comme Addition, Soustraction, Multiplication, Division et bien d'autres. Nous pouvons effectuer toutes ces opérations sur des nombres à virgule flottante

et des entiers comme illustré ci-dessous avec le code.

1 # variables
2
3 x = 1 # stockage d'un entier

4 y = 2.5 # stockage d'un nombre réel

5 z =“string”# storing string or text

6 n =“a”# storing a character
7 x = True # stocker une valeur booléenne

imprimez(type(x), type(y), type(z), type(n), type(b))

16
1 Output:
2
3 <classe ‘bool’> <classe ‘float’> <classe ‘str’> <classe ‘str’> <classe ‘bool’>

Boolean
En Python, il y a des moments où un développeur doit savoir si une affirmation est vraie ou fausse. Surtout lors de l'utilisation de conditions,

les booléens sont utilisés. Le booléen se compose de Vrai et de Faux. Notez que Python est sensible à la casse lors de l'utilisation des booléens, d'où

Ils doivent être au format Vrai et Faux uniquement.

Testons nos connaissances !

• Conversion de type
La conversion de type est un processus où vous convertissez une variable de type de données en une autre variable de type de données.

• int()
Cela convertit un nombre qui est sous forme de chaîne ou un flottant en valeur entière. L'exemple est illustré ci-dessous avec le code.

1 a=”6”
2 b=6.5
3 imprimer(int(a), int(b))

1 output:
2
3 66

• Remarque : La fonction int() ne peut convertir que des chiffres sous forme de chaîne en entiers, mais pas des caractères. Si des caractères sont utilisés dans int().

alors cela générera une erreur comme illustré ci-dessous.

1 a=”a”
2
3 imprimer(int(a))

1 output:
2
3 --------------------------------------------------------------------------- ValueError Traceback (most recent call last)
<iPython-input-128-d5a3b8380653> dans <module> 1 a="a" 2 ----> 3 print(int(a)) ValueError : littéral invalide pour
int()avec base 10 : 'a'

• flottant()
Ceci est utilisé pour convertir tout nombre réel sous forme de chaîne ou tout entier en float comme illustré dans le code ci-dessous.

17
1 a=”6.5”
2 b=7
3 print(float(a), float(b))

1 Sortie :
2
3 6,5 7,0

• str()
Cette fonction peut convertir n'importe quelle valeur entière ou flottante en forme de chaîne. L'exemple est illustré ci-dessous.

1 a=6
2 b = 6.7
3 c = Vrai
4
5 print(str(a), str(b), str(c))

1 Output:
2
3 6 6,7 Vrai

• bool()
Cette fonction peut convertir n'importe quel entier, chaîne, valeur flottante en une valeur booléenne.

• Remarque : Si les valeurs en entier ou flottant sont 0, alors bool() renverra False. Pour les chaînes, si la chaîne est vide, alors False.
L'exemple est illustré ci-dessous.

1 a=0
2 b=0
3 c =“”
4
5 print(bool(a), bool(b), bool(c))

FauxFauxFaux

18
3. Tuples, listes, ensembles et dictionnaires Python
Ce chapitre aidera à développer la compréhension des tuples, des listes, des ensembles et des dictionnaires en Python. Nous verrons quelques

exemples de leurs implémentations et de leurs cas d'utilisation pour certaines tâches. La partie codage sera faite dans VS Code. Si vous avez

pas installé VS Code ou souhaitez recommencer à zéro, veuillez consulter le chapitre précédent.

Introduction aux tuples, listes, ensembles et dictionnaires Python

Dans le chapitre précédent, nous avons vu comment nous pouvons utiliser les variables et les types de données en Python. Nous avons également examiné quelques éléments utiles.

fonctions liées aux types de données et aux variables.

Python est un puissant langage de script. Il dispose de nombreuses structures de données intégrées disponibles pour utilisation. Ces structures sont si

puissants dans le traitement des données, mais ils sont simples à mettre en œuvre.

Ces structures de base sont de quatre types : liste, tuple, dictionnaire et ensemble.

Listes en Python
Les listes sont intégrées dans Python. Celles-ci sont mutables, donc des éléments peuvent y être ajoutés ou retirés sans altérer leur origine.
les contenus et les éléments peuvent être accessibles par l'index.

Ils sont si généraux qu'ils peuvent être utilisés pour stocker tout type d'objet, des chaînes de caractères aux nombres, y compris les objets également.

De plus, il n'est pas nécessaire d'avoir tous les éléments du même type. Une liste peut contenir des éléments de différents types.

Pour une liste Touse, vous devez initialiser une variable avec [].

Par exemple :

1 Une liste vide

2 empty_list = []
3 # Liste avec des éléments de même type

4 same_type_list = [‘1’,‘3’,‘7’,‘10’]
5 # Liste avec différents types d'éléments
6 diff_type_list = [‘John’,‘Dev’,1.90, True]

Maintenant, nous savons comment initialiser la variable avec une liste. Voyons quelques opérations de base.

Opérations de base avec des listes

Vous avez déjà voulu parcourir les éléments d'une liste sans les passer un par un ? Python offre plusieurs outils utiles
Les fonctions. Elles vous permettent de les manipuler sans itérer sur la liste ou boucler à travers chaque élément.

Les cinq opérations de liste les plus utilisées en Python sont :

1. len(liste) – Il renvoie la longueur de la liste. Il aide également lors de l'itération quand on veut parcourir la liste.

19
Par exemple :

1 Impression de la longueur de la liste

2 some_list = [‘k’,‘u’, ‘m’,‘a’,‘r’]

3 imprimer(len(some_list))
4 Parcours de liste
5 pour i dans range(len(some_list)) :

6 imprimer(some_list[i])

1 # Sortie
2
3 5
4 k
5 u
6 m
7 a
8 r

2. max(liste) – Cela renvoie l'élément de la liste donnée avec la valeur la plus élevée, s'il n'y a pas d'égalité, cela renvoie une erreur.

Par exemple :

1 Impression du maximum du nombre stocké dans la liste

2 num_list = [1, 2, 3, 4, 5, 12, 78, 900, 100]
3 print(max(liste_de_nombres))
4

1 # Sortie
2
3 900

3. min(liste) – cela renvoie l'élément de la liste donnée ayant la plus basse valeur, s'il n'y a pas d'égalité alors cela renvoie une erreur

Par exemple :

1 Impression du minimum du nombre stocké dans la liste

2 num_list = [1,2,3,4,5,12,78,900,100]
3 print(min(liste_num))

1 # Output
2
3 1

20
4. trier(liste) – Cette fonction trie toutes ces données et les met par ordre croissant/décroissant par défaut, mais si une clé
le paramètre est passé, il trie la liste en fonction de l'évaluation de la fonction sur les éléments.

Le paramètre inverser contrôle si la liste triée (ordre croissant) est donnée telle quelle qu'elle est triée, ou si elle est inversée, c'est-à-dire dans

ordre décroissant.

La syntaxe est [Link](reverse=True|False, key= une fonction)

Par exemple :

1 num_list = [1,2,3,4,5,12,78,900,100]
2 imprimer(num_list)
3 num_list.trier()
4 print(num_list)
5 num_list.sort(reverse = True)
6 imprimer(num_list)

1 Sortie :
2
3 [1, 2, 3, 4, 5, 12, 78, 900, 100]
4 [1, 2, 3, 4, 5, 12, 78, 100, 900]
5 [900, 100, 78, 12, 5, 4, 3, 2, 1]

5. map(fonction, séquence) – Cette fonction ici applique une fonction à chaque élément de la liste. La syntaxe est donnée par
map(fun, iter). Ici, 'fun' est la fonction qui est censée être appliquée à chaque élément de 'iter'.

Par exemple :

1 def carré(n):
2 retourne * n
3
4 numbers = [1, 2, 3, 4]
5 result = map(square, numbers)
6 imprimer(list(result))

1 output:
2 [1, 4, 9, 16]

Il existe tellement d'autres fonctions pour les listes. Maintenant, voyons ce que sont les tuples.

21
tuples Python

Ils peuvent être créés en déclarant simplement un tuple entre parenthèses, (), ou en convertissant n'importe quelle séquence en un tuple en utilisant le

constructeur intégré tuple().

1 Créer un tuple vide

2 empty_tuple = ()
3
4 seq_set = {1,2,3}
5 seq_list = [2,3,4,5]
6 print(type(seq))
7 print(type(seq_list))
8 # Conversion d'un ensemble en tuple

9 seq_set_tuple = tuple(seq_set)

01 Output:
02 <classe‘ensemble’> <classe‘liste’>
03 Créer un tuple vide
04 empty_tuple = ()
05
06 seq_set = {1, 2, 3}
07 seq_list = [2, 3, 4, 5]
08 imprimer(type(seq_set))
09 imprimer(type(seq_list))
10 Conversion d'un ensemble en tuple

11 seq_set_tuple = tuple(seq_set)
12 print(type(seq_set_tuple))
13
14 output:
15
16 <classe 'ensemble'> <classe 'liste'> <classe 'tuple'>

Les tuples ressemblent aux listes, avec la différence que les tuples sont immuables. Alors pourquoi utilisons-nous les tuples ?

22
Différence entre les tuples et les listes en Python
Les tuples sont immuables, tandis que les listes sont mutables. Cela signifie que les tuples ne peuvent pas être changés après leur création.
bien que les listes puissent être modifiées pour ajouter ou supprimer des éléments.

Comme une liste, un tuple est également une séquence d'éléments de données, qui ne sont pas nécessairement du même type.

Par exemple :

1 Tuple avec des éléments de même type

2 same_type_list = (‘1’,‘3’,‘7’,‘10’)
3 imprimer(liste_du_même_type)

1 Output:
2
3 ["1","3","7","10"]

1 # Liste avec différents types d'éléments

2 diff_type_list = (‘John’,‘Dev’, 1.90, True)
3 imprimer(diff_type_list)

1 # Sortie
2
3 (‘John’,‘Dev’, 1.9, True)

4. Ensembles et dictionnaires Python

Ce chapitre aidera le lecteur à comprendre les ensembles et dictionnaires Python de base avec quelques applications de base dans le monde réel.

monde. Nous utiliserons Visual Studio Code comme notre éditeur de code. Si vous n'avez pas installé Visual Studio Code, les instructions
sont donnés dans le chapitre précédent.

Ensembles Python

Un ensemble est une collection mutable et non ordonnée d'éléments uniques. Un ensemble est écrit avec des accolades ({}), les éléments étant
séparés par des virgules.

Il peut également être défini avec la fonction intégrée set([itérable]). Cette fonction prend en argument un itérable (c'est-à-dire tout type
de séquence, de collection ou d'itérateur), retournant un ensemble contenant des éléments uniques de l'entrée (les éléments dupliqués sont

supprimé).

Par exemple :

# Créer un ensemble en utilisant

1
2 Une chaîne
3 imprimer(set('Dev'))

23
1 Output:
2 {‘e’,‘v’,‘D’}

1 une liste
2 ["Mayank","Vardhman","Mukesh","Mukesh"]

1 Output:
2 {‘Mayank’,‘Mukesh’,‘Vardhman’}

1 Un tuple
2 ["Lucknow","Kanpur","Inde"]

1 Output:
2 {‘India’,‘Kanpur’,‘Lucknow’}

1 un dictionnaire
2 set({‘Sulphur’: 16,‘Helium’: 2,‘Carbon’: 6,‘Oxygen’: 8})

1 Output:
2 ["Carbone","Hélium","Oxygène","Soufre"]

Maintenant, nous savons comment créer des ensembles. Voyons quelles sont les opérations courantes sur les ensembles.

Opérations sur les ensembles Python

Ajouter un élément dans un ensemble :

La syntaxe pour ajouter un élément est [Link](element).

La méthode fonctionne sur place et modifie l'ensemble et retourne 'Aucun'.

Par exemple :

1 locations = set((‘Lucknow’,’kanpur’,’India’))
2 [Link]('Delhi')
3 imprimer(lieux)

1 Output:
2 {‘India’,‘Delhi’,‘Lucknow’,‘kanpur’}

Dans les ensembles en Python, nous ne pouvons pas insérer un élément à un index particulier car ils ne sont pas ordonnés.

24
Supprimer un élément d'un ensemble :
Il existe trois méthodes par lesquelles vous pouvez effectuer la suppression d'un élément d'un ensemble.

Ils sont donnés ci-dessous :

• [Link](element)
• [Link](element)
• [Link]()

Comprenons cela en regardant un exemple pour chaque mise en œuvre :

[Link](élément)

1 locations = set((‘Lucknow’,‘kanpur’,‘India’))
2 #Supprime Lucknow de l'ensemble
3 [Link]('Lucknow')
4 imprimer(locations)

1 Output:
2 {‘India’,‘kanpur’}

[Link](element)

1 locations = set((‘Lucknow’,‘kanpur’,‘India’))
2 Supprime 'Lucknow' de l'ensemble
3 [Link]('Lucknow')
4 imprimer(locations)

1 Output:
2 {‘India’,‘kanpur’}

Comme vous pouvez le voir, les méthodes 'remove' et 'discard' fonctionnent en place et modifient le même ensemble sur lequel elles sont appliquées.

être appelé. Ils retournent 'Aucun'.

La seule différence entre les fonctions 'remove' et 'discard' est que la fonction 'remove' déclenche une exception.
(KeyError) est levé si 'element' n'est pas présent dans l'ensemble. L'exception n'est pas lancée dans le cas de 'discard'.

[Link]()

1 locations = set((“Lucknow”,‘Kanpur’,‘India’))
2 Supprime 'Lucknow' de l'ensemble
3 removed_location = [Link]()
4 imprimer(locations)
5 imprimer(emplacement_supprimé)

25
1 Output:
2 {‘Kanpur’,‘Lucknow’}
3 Inde

La fonction 'pop' ne prend aucun argument et supprime un élément arbitraire de l'ensemble. Elle fonctionne également en place mais contrairement à

d'autres méthodes, elle renvoie l'élément supprimé.

Donc, nous avons couvert les listes, les tuples et les ensembles Python. Maintenant, enfin, voyons comment les choses fonctionnent dans les dictionnaires Python.

Dictionnaires en Python
Les dictionnaires Python sont un type de donnée fondamental pour le stockage et la récupération des données.

Le dictionnaire est une structure de données intégrée qui stocke des paires clé:valeur et peut être accédé soit par la clé soit par la valeur.
Les dictionnaires Python sont non ordonnés et les clés ne peuvent pas être des entiers négatifs. De plus, bien que les clés doivent être immuables,

les valeurs ne doivent pas être.

La syntaxe pour créer un dictionnaire consiste à placer deux crochets après toute séquence de caractères suivie d'un deux-points.
(e.g., {‘a’: ‘b’}); if you are passing in more than one sequence then you need to put them in separate sets of brackets (e.g., {‘a’:
‘b’, ‘c’: ‘d’}).

Par exemple :

1 Créer un dictionnaire vide

2 Dictionary = {}
3 Dictionnaire vide :
4 imprimer(Dictionnaire)

1 Output:
2 Empty Dictionary: {}

Nous pouvons également créer un dictionnaire en utilisant une fonction intégrée connue sous le nom de 'dict()'.

Voyons comment nous pouvons le créer :

1 # Creating a Dictionary
2 Avec la méthode dict()
3 Dictionary = dict({1:‘Hello’, 2:‘World’, 3:‘!!!’})
4 Dictionnaire en utilisant la méthode dict() :
5 imprimer(Dictionnaire)

1 Output:
2 Dictionnaire en utilisant la méthode dict() :

3 1:‘Hello’, 2:‘World’, 3:‘!!!’}

26
Maintenant, créons le dictionnaire en utilisant une liste de tuples de paires clé-valeur :

1 Créer un dictionnaire
2 Dict = dict([(1,‘Hello’), (2,‘World’)])
3 Dictionnaire en utilisant une liste de tuples de clé et de valeur comme paire :
4 print(Dict)

1 Output:
2 Dictionnaire en utilisant une liste de tuples de clé et de valeur comme paire :

3 {1:‘Hello’, 2:‘World’}

N'oubliez pas que les clés sont sensibles à la casse.

Voyons brièvement quels sont les méthodes présentes dans le dictionnaire de Python.

27
Différence entre les ensembles et les dictionnaires en Python

Un ensemble est une collection de valeurs, pas nécessairement du même type, tandis qu'un dictionnaire stocke des paires clé-valeur.

Les ensembles en Python sont des collections de données qui n'ont aucun ordre ni clés. Un ensemble ne stocke aucune donnée sur ses membres.

à part leur identité. Les dictionnaires sont des collections qui associent des clés uniques à des valeurs. De plus, les dictionnaires stockent

informations sur leurs membres, y compris la paire clé-valeur.

Ainsi, nous avons établi une compréhension de base des Listes, Tuples, Ensembles et Dictionnaires en Python. Nous avons également examiné certains

fonctions et leurs implémentations.

5. Instructions conditionnelles en Python

Nous avons couvert les types de données de base et les types de données avancés en Python dans le chapitre précédent. Dans ce chapitre, le

Les instructions conditionnelles seront abordées.

Instructions conditionnelles en Python - que font-elles ?

Les instructions conditionnelles en Python régulent le flux de l'exécution du code. En termes très simples, ces instructions sont
used when you want the program to do a task if a condition is satisfied and not to do the same task when the condition is
non rempli.

Python input()
Jusqu'à présent, nous avons simplement imprimé la sortie mais nous n'avons jamais donné d'entrée à notre programme. En Python, input() est utilisé pour

donner une entrée au programme en Python. L'exemple est illustré ci-dessous.

Par exemple :

1 #Prendre l'entrée

2 x=entrée()
3 print(x)

Le code ci-dessus demandera une entrée qui sera stockée dans la variable X pour une utilisation ultérieure.

1 Sortie :
2 5
3 5

L'entrée peut également contenir une requête sous forme de chaîne. L'exemple est illustré ci-dessous.

#Prendre l'entrée
1
2 x=entrée(“veuillez entrer votre âge ?”)

3 imprimer(x)

1 Output:
2 veuillez entrer votre âge. 5

3 5

28
Même l'entrée peut être modifiée à l'aide des fonctions de type utilisées dans le cast d'un type de données. L'exemple est illustré
ci-dessous.

1 #Prendre entrée

2 x=int(input("Veuillez entrer votre âge ?"))

3 y=input(“veuillez entrer votre âge ?”)

4 print(type(x))
5 imprimer(type(y))

1 Output:
2 Veuillez entrer votre âge. 5

3 veuillez entrer votre âge. 5

4 <classe‘int’>
5 <class 'str'>

Dans l'exemple ci-dessus, nous pouvons voir que l'entrée sans aucune fonction de conversion est une valeur de chaîne. Par conséquent, la valeur par défaut pour

l'entrée est une chaîne.

Instruction if en Python
Si un programme n'a qu'une seule décision à prendre, alors une déclaration "if" est utilisée. Prenons un exemple où nous voulons
autoriser une personne uniquement si elle porte un masque.

1 #instruction if
2 mask=True
3 ifmask==True:
4 print(“la personne peut entrer”)

Syntaxe en Python
La syntaxe est assez simple, elle est suivie de la condition et d'une indentation d'un espace de tabulation chaque fois qu'il y a quelque chose dans

l'instruction if. Lorsque nous avons discuté des opérateurs dans le chapitre sur les variables, nous avons discuté des opérateurs de comparaison, logiques

opérateurs et opérateurs mathématiques.

Dans cette condition, à la fois les opérateurs de comparaison et les opérateurs logiques peuvent être utilisés. Dans l'exemple ci-dessus, nous pouvons voir que nous

utilisé l'opérateur "==" pour la comparaison. Dans le programme ci-dessus, si le masque est vrai, la déclaration sera imprimée, sinon
il ne imprimera rien.
Exécutons le programme et examinons la sortie.

1 Output:
2 la personne peut entrer

Que se passera-t-il si nous changeons la valeur de fabrication en False ? La sortie sera comme indiqué ci-dessous. Qui est vide - rien ne sera

imprimé car la condition n'est pas remplie.

29
1 Sortie :

Si sinon en Python
Dans l'exemple ci-dessus, nous avons juste une condition, qui dit que si une personne a un masque, elle peut entrer. Mais il n'y a pas,

Sinon, que faire si la personne n'a pas de masque. Il semble donc que ce soit un programme incomplet. Disons que, si ils
n'ont pas de masque, nous voulons qu'ils obtiennent un masque pour entrer. Pour cela, nous utiliserons une déclaration else qui s'exécute uniquement lorsque

la condition de l'instruction "si" n'est pas remplie.

Un exemple est illustré ci-dessous.

1 #si sinon déclaration

2 mask=True
3 ifmask==Vrai:
4 la personne peut entrer
5 sinon :
6 Veuillez prendre un masque pour entrer.

Maintenant, si nous changeons la valeur du masque à Faux, nous obtiendrons "s'il vous plaît, obtenez un masque pour entrer".

1 #si sinon déclaration

2
3 mask=False
4
5 ifmask==Vrai :
6 la personne peut entrer
7 sinon :
8 Veuillez obtenir un masque pour entrer

1 Output:
2 Veuillez prendre un masque pour entrer

Cela peut également être écrit dans le format ci-dessous.

1 #si sinon déclaration

2
3 mask=False
4
5 ifmask==True:
6 la personne peut entrer
7 Veuillez prendre un masque pour entrer

30
En Python, chaque fois que vous écrivez une instruction après le if sans indentation, elle est considérée comme faisant partie de l'instruction else.

Ajoutons maintenant un cas où si une personne n'a pas de masque mais est prête à en acheter un, elle peut acheter le masque directement auprès du garde.

et entrer. Pour cela, nous allons changer un peu notre code précédent. Nous donnerons des valeurs de chaîne telles que « nobuy », « buy », « yes ». Maintenant nous allons

utilisez-les pour écrire nos instructions if.

Maintenant, selon la valeur du masque, l'exécution sera effectuée. Si la valeur du masque est "nobuy", nous obtiendrons la sortie à être
s'il vous plaît, prenez un masque pour entrer.

1 #si sinon déclaration

2
3 mask=”nobuy”
4
5 ifmask=="oui":
6 la personne peut entrer
7 elif mask=="acheter":

8 la personne a acheté le masque et peut entrer

9 Veuillez prendre un masque pour entrer

1 Output:
2 s'il vous plaît, prenez un masque pour entrer

Même si le masque reçoit une autre valeur, nous obtiendrons le résultat "s'il vous plaît, prenez un masque pour entrer". Cela est dû au-dessus.

deux conditions d'instructions if ne seront pas remplies.

1 #si sinon déclaration

2 mask=”yes”
3
4 ifmask=="oui":
5 la personne peut entrer
elif masque == "acheter":
6
7 la personne a acheté le masque et peut entrer
8 Veuillez porter un masque pour entrer.

1 Output:
2 la personne peut entrer

Pour "acheter" le masque, le résultat sera ("la personne a acheté le masque et peut entrer").

31
1 #si sinon déclaration
2 mask=”yes”
3 ifmask=="oui":
4 la personne peut entrer
5 elif mask=="acheter"

6 la personne a acheté le masque et peut entrer

7 Veuillez prendre un masque pour entrer

1 Output:
2 la personne a acheté le masque et peut entrer

Dans ce chapitre, nous avons couvert quelques bases des instructions conditionnelles en Python, les sujets suivants sur les fonctions seront

couverts dans le prochain chapitre. À partir de ce chapitre, le lecteur recevra quelques questions pratiques.

6. Boucles en Python
Nous avons couvert les types de données de base, les types de données avancés et les instructions conditionnelles en Python dans nos chapitres précédents.

Dans ce chapitre, les boucles seront couvertes. Si vous êtes nouveau en Python, veuillez commencer par le premier chapitre pour mieux comprendre.

compréhension de ce blog.

Boucles en Python
Les boucles sont utilisées lorsqu'il est nécessaire d'effectuer une tâche plus d'une fois. Par exemple, imprimer des nombres de 1 à 100 ou

un meilleur exemple serait de sommer tous les éléments d'une liste ou d'un tableau. Parfois, il est nécessaire d'écrire plus d'un
boucle ou boucle imbriquée. En Python, écrire ces boucles est très simple, et la syntaxe est même facile à comprendre. Comme nous
nous avons vu, en Python nous n'avons pas besoin de déclarer une variable d'abord avant de l'utiliser. La boucle de base commence par la boucle for. Allons-y

comprendre la boucle "for".

Boucle for en Python

Dans une boucle for, nous avons trois choses qui doivent être mentionnées. La première est la valeur initiale de la variable sur laquelle

l'itération doit être effectuée, la condition d'arrêt et la dernière est par combien d'étapes vous souhaitez augmenter ou
décrémenter l'itérateur.

32
Voyons la syntaxe d'une boucle « for » :

1 Boucle For
2
3 pour var dans range(10):
4 imprimer(var)
5
6 pour var dans la plage(0,10,1):

7 imprimer(var)

Dans l'illustration de code ci-dessus, nous pouvons voir que les boucles for donnent le même résultat. La syntaxe à la fin où nous

la fonction range a trois arguments, que nous avons discutés dans le paragraphe précédent. Dans l'exemple ci-dessus le
la plage a 0,10,1 dans laquelle 0 est la valeur initiale de l'itérateur, 10 est la valeur finale, mais la plage itère en fait jusqu'à 10-1
qui est 9 et 1 est l'incrémentation de l'itérateur chaque fois que la boucle s'exécute.

Exécutons le programme ci-dessus.

01 Output:
02 0
03 1
04 2
05 3
06 4
07 5
08 6
09 7
10 8
11 9
12
13 0
14 1
15 2
16 3
17 4
18 5
19 6
20 7
21 8
22 9

Comme nous pouvons le voir dans l'illustration de sortie, cela imprime les nombres de 0 à 9.

Pour les boucles dans la liste

Dans une liste, nous avons une collection d'éléments et ci-dessous se trouve l'illustration sur la façon d'utiliser les boucles for pour parcourir une liste

33
1 X=[1,2,3,4,5,6]
2 foriinX :
3 imprimer(i)

1 Output:
2 Cela affichera tous les éléments de la liste.
3 1,2,3,4,5,6

Pour inclure l'index lors de l'impression, le code est illustré ci-dessous.

1 X=[1,2,3,4,5,6]
2 pour i dans la plage(len(X)):

3 imprimer(i, X[i])

Cela affichera à la fois l'indice et la valeur dans la liste.

Il existe un moyen simple d'obtenir l'index et la valeur en utilisant la fonction enumerate. L'utilisation de la fonction enumerate est illustrée ci-dessous.

1 X=[1,2,3,4,5,6]
2 for i, value in enumerate(X):

3 imprimer(i, valeur)

1 Output:
2 0,1
3 1,2
4 2,3
5 3,4
6 4,5
7 5,6

Itérer un ensemble en utilisant une boucle for

Itérer un ensemble est similaire à l'itération d'une liste en utilisant une boucle for. Un exemple est illustré ci-dessous.

1 X={1,2,3,4,5,6}
2 pour i, valeur dans énumérer(X) :

3 imprimer(i, valeur)

1 Output:
2 0,1
3 1,2
4 2,3
5 3,4
6 4,5
7 5,6

34
Itérer un tuple à l'aide d'une boucle for
Itérer un tuple est similaire à l'itération d'une liste en utilisant une boucle for. Un exemple est illustré ci-dessous.

1 X=(1,2,3,4,5,6)
2 pour i, valeur dans énumérer(X):

3 imprimer(i, valeur)

1 Output:
2 0,1
3 1,2
4 2,3
5 3,4
6 4,5
7 5,6

Itérer un dictionnaire en utilisant une boucle for

Itérer un dictionnaire est différent des autres types de données, car le dictionnaire contient des paires clé-valeur. Ainsi, pour obtenir juste
les clés que nous utilisons [Link]() et pour les valeurs nous utilisons [Link](). Un exemple est illustré ci-dessous.

1 X={“1”:1,”2”:2}
2 [Link]és() :
3 imprimer(clé)
pour valeur dans [Link]():
4
5 imprimer(valeur)
pour clé, valeur dans [Link]() :
6
7 print(key,value)

1 Output:
2 1
3 2
4
5 1
6 2
7
8 1,1
9 2,2

Boucles imbriquées en Python

Les boucles imbriquées sont utiles lors de la construction d'une solution par force brute à un problème donné. Elles augmentent la complexité temporelle de

programmer et diminuer la lisibilité.

35
1 a = [1, 2]
2 b = [10, 13]
3 obtenir des nombres dont le produit est 13
4
5 foriina:
6 forjinb
7 ifi*j == 13 :
8 imprimer(i, j)

Dans le bloc de code ci-dessus, nous avons défini 2 listes et chaque liste a une certaine collection de nombres. Le but principal était de trouver ce que

le produit des nombres sera 13 des deux listes et également imprimer ces nombres. À cet effet, nous devons itérer
à travers 2 listes, donc 2 boucles for ont été utilisées.

Solution alternative :

Il existe une fonction dans itertools appelée produit. Cela aide à conserver les boucles for imbriquées si elles sont présentes dans le programme.

lisible. L'exemple est illustré ci-dessous.

de itertools import product

a = [1, 2]
b = [10, 13]
obtenir des nombres dont le produit est 13

pour i, j dans produit(a, b) :

1 si(i*j == 13):
2 imprimer(i, j)

Boucles While en Python

Jusqu'à présent, nous avons juste imprimé la sortie mais n'avons jamais donné d'entrée à notre programme. En Python, la fonction input() est utilisée pour

donner des entrées au programme en Python. L'examen est illustré ci-dessous. La boucle while est utilisée lorsque vous souhaitez exécuter un

programmez si la condition est remplie. Des exemples de boucle while sont illustrés ci-dessous.

Impression de 0 à 9 en utilisant une boucle while :

i=0

1 tant que(i < 10):

2 imprimer(i)
3
4 i += 1

36
Comme vous pouvez le voir, la syntaxe est 'while' suivie d'une condition, et à l'intérieur de la boucle, nous incrémentons l'itérateur en fonction de

nombre désiré.

01 Output:
02 0
03 1
04 2
05 3
06 4
07 5
08 6
09 7
10 8
11 9

Dans ce chapitre, nous avons couvert quelques notions de base des instructions de boucle en Python, les sujets suivants sur les fonctions seront

couvre dans le chapitre suivant. La question à résoudre est donnée ci-dessous.

7. Python

Les fonctions Python sont des objets, ce qui signifie que les fonctions peuvent être utilisées comme valeur de retour d'autres fonctions, peuvent être stockées dans une

variable, peut être stockée dans des structures de données, ou peut être utilisée comme argument dans d'autres fonctions.

Les fonctions Python sont définies à l'aide du mot-clé "def" suivi du nom de la fonction. Ensuite, à l'intérieur de ces parenthèses "()", le

les arguments sont définis. La syntaxe de base des fonctions Python est illustrée ci-dessous.

Par exemple :

1 Créer une fonction

2 # mot-clé
3 définir nomdefonction() :

37
Remarque :

Le nom de la fonction suit également les mêmes normes que la déclaration de variable. Écrivons notre première fonction.

1 # première fonction

2
3 def somme(a,b):
4 retourne a+b

Dans le bloc de code ci-dessus, nous avons écrit une fonction qui nous donne la somme de deux nombres. Comme vous pouvez le voir, nous avons utilisé

Le mot-clé "def", a et b sont les arguments qui, dans notre cas, seraient les nombres pour lesquels nous voulons la somme. Maintenant, nous avons

a utilisé un mot-clé ici appelé "return" qui est utilisé pour renvoyer la valeur ou la chaîne désirée de la fonction après avoir effectué

la tâche souhaitée. Les valeurs retournées en utilisant les mots-clés retournés peuvent être assignées à d'autres variables ou
peut être utilisé dans des fonctions comme argument.

Voyons maintenant comment utiliser cette fonction sur nos nombres souhaités.

1 # première fonction

2
3 def somme(a,b):
4 retourna+b
5
6 somme(6,7)
7
8 x=somme(6,7)
9 imprimer(x)

Comme vous pouvez le voir, si nous utilisons simplement la fonction, la fonction ne montrera aucune valeur, mais lorsque nous stockons le retour de la fonction.

valeur dans une autre variable et l'imprimer, cela donne le résultat souhaité.

Exécutons le programme et voyons le résultat.

1 # Output
2
3 13

Nous avons obtenu le résultat de 13, qui est la somme de 6 et 7. Écrivons une autre fonction qui nous donne le nom complet donné
firstname and lastname.

38
1 # deuxième fonction
2 def nom_complet(prénom, nom):

3 returnfn+ln
4
5 x=fullname(“Python”,”language”)
6 imprimer(x)

Comme vous pouvez le voir, nous venons de définir la fonction fullname et de lui donner les paramètres firstname et lastname. Nous sommes

retourner le nom complet en utilisant “+” qui est un opérateur de concaténation dans une chaîne que nous avons appris dans le chapitre sur les variables.

Explorons la sortie.

1 #Sortie
2
3 langage Python

Les fonctions Python en tant qu'objets

La plupart des données en Python sont représentées sous forme d'objets. En Python, les chaînes, les modules, les fonctions sont tous représentés
sous forme d'objets. Voyons comment nous pouvons utiliser des fonctions comme des objets.

Assignation de fonctions à une variable

Comme une fonction est un objet, elle peut être assignée à une variable. Un exemple est illustré ci-dessous.

1 # première fonction

2
3 def somme(a,b):
4 renvoie a+b
5
6 sumab=sum

Dans l'exemple ci-dessus, nous pouvons voir que l'assigner à une nouvelle variable n'appelle pas la fonction, il l'assigne simplement.
fonction à la variable "sumab". La signification réelle de l'exemple ci-dessus est que la variable "sumab" prend la somme
La fonction objet comme référence, et le "sumab" pointe maintenant vers cet objet. Par conséquent, le sumab peut également être utilisé comme une fonction.

Maintenant. Un exemple est illustré ci-dessous.

1 # Nouvelle fonction

2
3 def somme(a,b):
4 retourne a+b

5
6 sumab=sum
7
8 s=somme(7,8)
9 imprimer(s)

39
Output:

1 #output
2
3 15

Remarque :
Le nom de la fonction que nous donnons dans la déclaration et les objets fonctionnent très différemment. Même si nous supprimons le
le nom de la fonction originale, s'il y a un autre nom pointant vers cet objet de fonction de référence, la fonction fonctionnera toujours. Un
l'exemple est illustré ci-dessous.

01 # Nouvelle fonction

02
03 def somme(a,b):
04 retourne a+b
05
06 sumab=sum
07
08 somme de del

09
10 somme(8,7)

Output:

1 #Sortie
2
3 NameError: “name ‘sum’ is not defined”

Mais lorsque nous utilisons la fonction sumab, le résultat est illustré ci-dessous.

01 # Nouvelle fonction

02
03 déf somme(a,b):
04 retourne a+b

05
06 sumab=sum
07
08 tous les sommes

09
10 sumab(8,7)

Sortie :

15

40
Stockage des fonctions Python dans des structures de données

Comme les fonctions sont des objets en Python, nous pouvons les stocker dans des structures de données de la même manière que nous stockons nos variables et

les constantes. La syntaxe change un peu, mais c'est comme nous avons stocké des éléments dans les types de données.

#fonction de stockage dans des structures de données

1
2
3 Storedfunctionslist=[len,[Link](),[Link](),[Link]()]
4
5 Storedfunctionslist

Itérer à travers les fonctions est similaire à itérer à travers des objets. Exemple illustré ci-dessous.

1 #fonction de stockage dans des structures de données

2
3 Storedfunctionslist=[len,[Link](),[Link](),[Link]()]
4
5 forfuninStoredfunctionslist:
6 imprimer(fun, fun('Bonjour'))

Dans ce chapitre, nous avons couvert quelques fonctions de base en Python, les sujets plus détaillés sur les fonctions seront abordés dans
le prochain chapitre.

8. Fonctions avancées en Python

Ce chapitre aidera le lecteur à continuer à partir du chapitre précédent sur les fonctions Python, ainsi que quelques applications de base.

dans le monde réel. Nous utiliserons Visual Studio Code comme notre éditeur de code. Si vous n'avez pas installé Visual Studio Code, le
les instructions sont données dans le premier chapitre.

Passer des fonctions à d'autres fonctions

Comme discuté dans le blog précédent, les fonctions en Python sont traitées comme des objets. Tout comme les objets en Python, les fonctions peuvent également

être passé en argument à une autre fonction.

Par exemple :

01 def mul(x, y):

02 retourner x*y

03
04
05 def ajouter(mul, y):

06 returnmul+y
07
08
09 x = ajouter(mul(9, 10), 10)

10 imprimer(x)

41
Dans le bloc de code ci-dessus, on peut voir que la fonction mul est passée en argument à la fonction add et est stockée dans
la variable x qui est ensuite imprimée pour vérifier la réponse.

1 100

Utiliser des fonctions à l'intérieur d'une fonction

En Python, nous pouvons définir une fonction à l'intérieur d'une autre fonction. Ces fonctions sont appelées fonctions imbriquées. Mais dans cette utilisation

dans ce cas, la fonction interne ou la fonction imbriquée ne peut pas être appelée séparément. Les deux exemples sont illustrés dans ce qui suit.

bloc de code.

Écrivons notre première fonction.

1 def mul(x, y):

2
3 m = x*y
4
5 def carre(m):
6 retourm*m
7
8 retourneCarré(m)
9
10
11 x = mul(9, 10)
12
13 print(x)

1 Sortie :
2 8100

Dans le bloc de code ci-dessus, la fonction externe est "mul" qui renvoie la fonction square qui prend un argument "m" qui
la multiplication de deux arguments est donnée à la fonction « mul ». L'exécution du code commence d'abord par appeler la fonction « mul ».

ensuite le produit de "x" et "y" est stocké dans la variable "m". Comme cette fonction retourne une fonction carrée, le "carré"
la fonction est appelée et le produit final qui est le carré de "m" est retourné.

Apprenons quelques choses importantes en Python, qui rendront votre parcours de codage avec Python beaucoup mieux.

*Args en Python
Ce sont les arguments que nous utilisons comme paramètres de fonction. Écrivons une fonction habituelle en utilisant ce que nous avons appris jusqu'à présent.

Nous allons écrire une fonction qui peut nous donner la superficie maximale d'un rectangle donnée 2 superficies de rectangles comme paramètres.

la fonction.

42
01 def maxarea(a, b):
02 ifa > b:
03 le rectangle a a une plus grande superficie qui est {a}
04 sinon :
05 le rectangle a a plus de surface qui est {b}
06
07
08 x = maxarea(100, 60)
09 print(x)
10

1 Output:
2 le rectangle A a la plus grande superficie qui est de 100

Cette fonction est bonne pour 2 paramètres ou arguments, mais que faire si nous devons comparer plus de 2 zones ? Une approche
resseraient une liste de domaines dans la fonction.

01 def maxarea(lis):
02
03 max = 0
04 foriinlis:
05 ifi > max:
06 max = i
07
08 le rectangle qui a la plus grande superficie est {max}
09
10
11 x = maxsurface([100, 60, 50])
12 imprimer(x)

1 Output:
2 Le rectangle qui a la plus grande surface est 100

Cette approche est bonne, mais nous devrions connaître le nombre de paramètres ou d'arguments à donner à l'avance. Dans le code en temps réel.

l'exécution, ce serait un casse-tête. Par conséquent, pour faciliter la vie des programmeurs, Python utilise *args et **kwargs.

"*" opérateur en Python

Cet opérateur est un opérateur de déballage qui est généralement utilisé pour passer un nombre non spécifié de paramètres ou d'arguments.

Déballer des arguments dans un tuple en utilisant l'opérateur *

Comme nous l'avons vu, l'opérateur "*" est utilisé pour déballer des valeurs. L'exemple est illustré ci-dessous.

43
1 x = [1, 2, 3, 4]
2 y = [5, 6, 7, 8]
3
4 z = *x, *y
5
6 print(type(z))
7 imprimer(z)

1 Output:
2 <class 'tuple'>
3 (1, 2, 3, 4, 5, 6, 7, 8)

Comme nous pouvons le voir, l'opérateur de déballage a déballé la liste x et la liste y dans un tuple qui est z. Nous pouvons également voir que le résultat est un

tuple.

Écrivons la même fonction en utilisant *Args.

01 def maxarea(*lis) :
02
03 max = 0
04 foriinlis:
05 ifi > max:
06 max = i
07
08 le rectangle qui a la plus grande surface est {max}
09
10
11 x = maxarea(100, 60, 50, 200)
12 y = maxarea(100, 60, 50, 200, 9000)
13 z = maxarea(100, 60, 50, 20, 90)
14 imprimer(x)
15 print(y)
16 imprimer(z)

1 Output:
2 Le rectangle qui a la plus grande surface est de 200.

3 le rectangle qui a la plus grande superficie est de 9000

4 le rectangle qui a la plus grande superficie est de 100

Dans ce bloc de code, nous pouvons voir que les arguments sont maintenant dynamiques, nous pouvons ajouter n'importe quel nombre d'arguments qui seront

déballé dans la fonction maxarea pour nous donner le résultat souhaité. De plus, nous pouvons comparer n'importe quel nombre d'aires dans ce contexte.

44
**kwargs en Python
Les kwargs sont comme les args, mais ils acceptent des arguments positionnels. Ils utilisent l'opérateur ** qui a certaines caractéristiques comme le déballage.

Arguments positionnels multiples de n'importe quelle longueur, peuvent également décompresser des dictionnaires, peuvent également être utilisés pour combiner deux dictionnaires.

Fusionner des dictionnaires

01 a = {“h”: 1,“n”: 2}
02 b = {“m”: 5,“l”: 10}
03
04 c = {**a, **b}
05
06 imprimer(type(c))
07 imprimer(c)
08
09
10
11 Nouspouvonsvoirdanslecodeci-dessusquenousavons2dictionnairesaetbquisontfusionnésàla' idedelo' pérateur**pourdonnerunautredictionnaire.

12
13 Output:
14 <classe 'dict'>
15 {‘h’: 1,‘n’: 2,‘m’: 5,‘l’: 10}

Lorsque nous utilisons l'opérateur * au lieu de l'opérateur **, le code pour ce cas est illustré ci-dessous.

1 a = {“h”: 1,“n”: 2}
2 b = {“m”: 5,“l”: 10}
3
4 c = {*a, *b}
5
6 imprimer(type(c))
7 imprimer(c)

1 Output:
2 <classe‘ensemble’>
3 {‘n’,‘l’,‘m’,‘h’}

Ainsi, lorsque l'opérateur * est utilisé sur deux dictionnaires pour fusionner, le résultat sera un ensemble contenant uniquement les clés de la

dictionnaire.

La fonction maxarea utilisant **kwargs est illustrée dans le bloc de code ci-dessous.

45
01 def maxarea(**lis):
02
03 max = 0
04 [Link]()
05 ifi > max:
06 max = i
07
08 retournez "le rectangle qui a la plus grande surface est {max}"

09
10
11 x = maxaire(a=1, b=2, c=3)
12 y = maxsurface(a=1, b=2)
13 z = maxarea(a=1, b=2, c=3, d=9)
14 imprimer(x)
15 imprimer(y)
16 print(z)

1 Sortie:
2 le rectangle qui a la plus grande surface est 3

3 le rectangle qui a la plus grande aire est 2

4 le rectangle qui a la plus grande superficie est 9

Dans ce chapitre sur les fonctions avancées en Python, nous avons abordé des sujets comme le passage de fonctions à d'autres fonctions, l'utilisation

fonctions à l'intérieur d'une fonction, *Args en Python, opérateur "*" en Python, **kwargs en Python, et plus encore. Les sujets suivants qui

include classes will be covered in the next chapter. Homework regarding advanced functions in Python is given below.

46
9. Classes et objets Python
Ce chapitre aidera le lecteur à comprendre les classes de base en Python ainsi que certaines applications de base dans le monde réel.

Comme nous l'avons discuté dans le premier chapitre, Python est un langage de programmation orienté objet. Il y a trois phrases.
qui sont très importants lors de la discussion sur la programmation orientée objet en Python. Le premier est la classe, le deuxième

un objet, le troisième serait l'héritage. Commençons par ce qu'est une classe.

Classes Python - définition

Une classe est un modèle ou un programme extensible qui aide à la création d'objets. Une classe se compose de comportement et d'état.
Le comportement d'une classe est démontré à travers des fonctions à l'intérieur de la classe, qui sont appelées méthodes. L'état de la classe
est démontré en utilisant les variables à l'intérieur de la classe, qui sont appelées attributs.

Initialisation des classes Python

Une classe peut être initialisée en utilisant la syntaxe suivante.

Une classe en Python est définie en utilisant le mot-clé "class" suivi du nom de la classe. La syntaxe de base d'une fonction Python est

illustré ci-dessous.

For Example:

1 <img src=[Link]
hauteur="600"classe="alignnone taille-moyenne wp-image-21409 img-fluide"/>
2 Créer une fonction
3 # classe Singe
4 classclassname:

Note: class name is also having the same norms as the variable declaration.

Écrivons notre première classe Python

1 première classe

2
3 classAnimals:
4 passer
5

Voyons maintenant comment ajouter des composants à la classe des animaux. Mais avant cela, apprenons à propos du constructeur "__init__()".
Les constructeurs sont utilisés pour l'instanciation d'objets. Ici, le __init__() est utilisé pour l'instanciation d'objets. Le constructeur peut être

par défaut avec seulement self comme argument ou paramétré avec des arguments requis.

47
Attributs
Il existe deux types différents d'attributs, les premiers sont des variables de classe et les seconds sont des variables d'instance.
Les variables de classe sont les variables appartenant à la classe. De plus, ces variables sont disponibles pour toutes les instances de la
classe. Par conséquent, leur valeur ne changera pas même si l'instance change.

1 # variables de classe

2
3 classAnimals:
4 type=”mammals”

Les variables d'instance sont les variables qui appartiennent aux instances elles-mêmes. Par conséquent, elles changeront de valeur au fur et à mesure que

changements d'instance.

1 # class variables
2
3 classAnimals:
4 def __init__(self, jambes):
5 [Link]=legs
6

Remarque : Les variables d'instance ne sont pas accessibles en utilisant le nom de la classe, car elles changent en fonction de l'objet.

y accéder.

Faisons un programme qui a à la fois des variables de classe et des variables d'instance déclarées.

1 classAnimals:
2 type=”mammals”
3 def __init__(self, nom, jambes):

4 [Link]=name
5 [Link]= jambes
6
7

In the above program, we have used both instance and class variables. So, these variables form attributes of the class.

Comportement de la classe
Comme discuté, le comportement de la classe est défini par les méthodes à l'intérieur de la classe. Mais avant de passer à la discussion sur

comportement, nous devons commencer à discuter du paramètre « self », que nous avons utilisé dans le __init__().

Self:
En des termes très simples, chaque fois que nous attachons quelque chose à self, cela signifie que la variable ou la fonction appartient à cette classe. Aussi,

Avec "self", les attributs ou méthodes de la classe peuvent accéder.

48
Méthodes :
Les méthodes de classe sont des fonctions à l'intérieur de la classe qui auront comme premier argument "self". Une méthode à l'intérieur de la classe est

défini en utilisant le mot clé "def".

01 classAnimals:
02 type=”mammals”
03 def __init__(self, nom, pattes):
04 [Link]=name
05 [Link]=legs
06 def aboyer(self):
07 [Link]=="chien":
08 imprimer("ouaf ouaf !!!")

09 sinon :
10 print("pas un chien")
11

Dans la méthode ci-dessus "aboyer", comme nous utilisons la variable nom, qui est une variable d'instance, nous y accédons en utilisant "self".

et cette fonction afficherait « ouaf ouaf !!! », uniquement si le nom fourni à l'objet est chien.

Nous avons discuté de la plupart des composants d'une classe, mais vous vous demandez peut-être comment vérifier si la classe fonctionne.

La réponse à cela est que tant que nous ne créons pas un objet de la classe, nous ne pourrons pas voir ce que fait la classe. Maintenant, définissons

et créez un objet de la classe.

Objets en Python
Un objet est une instance de la classe. Une classe n'est qu'un plan, mais l'objet est une instance de la classe qui a une réalité.
valeurs.

Le code pour définir ou créer un objet est illustré ci-dessous.

01 classAnimals:
02 type=”mammals”
03 def __init__(self, nom, jambes):
04 [Link]=name
05 [Link]=jambes
06 def aboyer(self):
07 si [Link]=="chien":
08 imprimer("ouaf ouaf !!!")

09 sinon :
10 print("pas un chien")
11
12 dog=Animals(“dog”,4)
13

49
Pour créer un objet, la syntaxe est objectname=classname(arguments). Donc ici, nous donnons le nom du
animal à être un chien et nombre de pattes à être 4. Maintenant, l'objet de la classe est créé, la prochaine étape est d'utiliser l'objet pour
accéder à ses attributs. Pour accéder aux attributs d'une classe en utilisant l'objet, rappelez-vous que seules les variables d'instance peuvent être

accédé en utilisant l'objet. Les variables d'instance de notre classe sont nom et jambes.

01 classAnimals:
02 type=”mammals”
03 def __init__(self, nom, pattes):
04 [Link]=nom
05 [Link]=legs
06 def aboyer(self):
07 si [Link] == "chien":

08 imprime("ouaf ouaf !!!")

09 sinon :
10 pas un chien
11
12 dog=Animals(“dog”,4)
13 print([Link])
14 imprimer([Link])
15

Comme nous pouvons le constater, nous sommes en mesure d'accéder aux variables d'instance en utilisant la notation par points.

Explorons la sortie.

1 #Sortie
2
3 chien
4 4
5

Toaccess the functions inside the class or methods, we will be using the dot notation. The example is illustrated below.

50
01 classAnimals:
02 type=”mammals”
03 def __init__(self, nom, pattes):
04 [Link]=name
05 [Link]=legs
06 def aboyer(self):
07 si [Link] == "chien":

08 imprimer("ouaf ouaf !!!")

09 sinon:
10 print("pas un chien")
11
12 dog=Animals(“dog”,4)
13 imprimer([Link])
14 print([Link])
15 print([Link]())

1 #Sortie
2
3 chien
4 4
5 ouaf ouaf !!!

Dans l'exemple ci-dessus, nous pouvons voir que nous accédons à la méthode de classe "bark" en utilisant l'objet chien que nous avons créé. Nous pouvons

notez que nous n'utilisons pas le paramètre "self" dans les arguments de la fonction. Cela est dû au fait que nous n'avons pas besoin d'utiliser "self".

en dehors de la classe puisque l'objet lui-même agit comme self.

Héritage
L'héritage est un processus par lequel les attributs et méthodes de la classe peuvent être transmis à une classe enfant. La classe de

où la classe enfant hérite de la classe parente. La syntaxe pour l'héritage est illustrée ci-dessous.

1 Héritage
2
3 parentclasse
4
5 classeEnfant(parent):
6

D'après l'illustration ci-dessus, nous pouvons voir que pour la syntaxe d'héritage, nous plaçons le nom de la classe parente comme un

argument à la classe enfant. Utilisons la classe Animaux et créons une classe enfant appelée chien. Cela est illustré ci-dessous.

51
01 classAnimals:
02 type=”mammals”
03 def __init__(self, nom, jambes):
04 [Link]=name
05 [Link]=legs
06 def aboyer(self):
07 [Link]=="chien":
08 print("ouaf ouaf!!!")
09 sinon :
10 print("pas un chien")
11
12 classChien(Animaux):
13 def __init__(self, nom, pattes, race):
14 Animaux.__init__(self,nom,jambes)
15 [Link]=breed

Dans l'exemple de code ci-dessus, nous avons créé une classe chien qui étend la classe animaux que nous avons créée auparavant. Nous sommes

also using the parameters from the Animals using the Animals.__init__(arguments) which has name and legs which will be
hérité de la classe chien. Ensuite, nous créons un attribut d'instance pour la classe chien qui est la race.
Maintenant, créons un objet pour la classe chien et accédons aux attributs et méthodes de la classe animaux.

01 classAnimals:
02 type=”mammals”
03 def __init__(self, nom, pattes):
04 [Link]=name
05 [Link]=legs
06 def aboyer(self):
07 si [Link] == "chien" :

08 imprimer("ouaf ouaf !!!")

09 sinon :
10 print("pas un chien")

11
12 classChien(Animaux):
13 def __init__(self, nom, jambes, race):
14 Animaux.__init__(self,name,jambes)
15 [Link]=breed
16
17
18 pug=Dog(“dog”,4,”pug”)
19 [Link]
20 [Link]
21 [Link]
22 [Link]()

52
1 #Sortie
2
3 carlin
4 chien
5 4
6 ouaf ouaf !!!

Comme nous pouvons le voir dans la sortie, les attributs et méthodes de la classe parente sont accessibles par l'objet de la classe enfant.

Dans ce chapitre, nous avons couvert quelques notions de base sur les classes en Python. Dans le prochain chapitre, nous aborderons le sujet des fichiers.

handling.

10. Fichiers en Python

Ce chapitre aidera le lecteur à comprendre les fichiers Python de base et la gestion des fichiers ainsi que quelques applications de base dans

monde réel.

Fichiers en Python – définition :

Un fichier est une entité qui stocke des informations. Ces informations peuvent être de tout type, comme du texte, des images, des vidéos ou de la musique.

Python, il existe des fonctions intégrées qui peuvent être utilisées pour effectuer des opérations sur des fichiers.

Exemples de fichiers binaires en Python :

• Fichiers de document : .pdf, .doc, .xls, etc.

• Fichiers image : .png, .jpg, .gif, .bmp, etc.

• Fichiers vidéo : .mp4, .3gp, .mkv, .avi, etc.

• Fichiers audio : .mp3, .wav, .mka, .aac, etc.

• Fichiers de base de données : .mdb, .accde, .frm, .sqlite, etc.

• Fichiers d'archive : .zip, .rar, .iso, .7z, etc.

• Fichiers exécutables : .exe, .dll, .class, etc.

Exemples de fichiers texte en Python :

• Normes web : html, XML, CSS, JSON, etc.

• code source : c, application, js, py, java, etc.

• Documents : txt, tex, RTF, etc.

• Données tabulaires : csv, tsv, etc.
• Configuration : ini, cfg, reg, etc

Opérations sur les fichiers en Python

Ouvrir un fichier en Python :

La fonction open() en Python est utilisée pour ouvrir des fichiers. Cette fonction prend deux arguments, l'un est le nom du fichier et le

l'autre est le mode d'ouverture. Il existe de nombreux modes d'ouverture tels que le mode lecture, le mode écriture, et d'autres.

53
Explorons la syntaxe :

1 # Ouverture de fichiers en Python

2
3 Fichier=open("nom_de_fichier", "mode")
4

Modes d'ouverture de fichier :

• « r » : – ceci est utilisé pour ouvrir un fichier en mode lecture.

• « w » : – ceci est utilisé pour ouvrir un fichier en mode écriture.

• “x”:– this is used for exclusive file creation. If the file is not present, it fails.
• “a”:– this is used when you want to append a file without truncating the file. If the file is not present, then this creates
un nouveau fichier.

• « t » : – cela est utilisé pour ouvrir un fichier en mode texte.

• « b » : – ceci est utilisé pour ouvrir un fichier en mode binaire.

• “+”:– this is used when the user wants to update a file.

Remarque :
Les opérations pour les fichiers binaires sont les suivantes.

54
Ouvrons un fichier en utilisant les méthodes discutées ci-dessus. Le code est illustré ci-dessous. Comme nous n'avons pas de fichier, nous allons en créer un.

et ensuite l'ouvrir.

1 ouverture de nouveau fichier

2
3 avec open("new", "w") comme f :

4 [Link](x)

Dans le code ci-dessus, nous créons une variable de chaîne x qui contient le texte « nouvelle ouverture de fichier », cette variable de chaîne est en cours de

écrit dans un fichier "new" en utilisant la méthode write. Nous utilisons "avec" ici car cela gère la fermeture du fichier. Donc, nous ouvrons un
fichier en format d'écriture et écriture de la chaîne x dans le fichier.

Maintenant, lisons le même fichier.

1 ouverture de nouveau fichier écriture de nouveau fichier

2
3 avec open("new", "r") comme f:

4 imprimer([Link]())

Dans le code ci-dessus, nous ouvrons le fichier new que nous avons écrit dans le code précédent et nous l'ouvrons en format lecture. Note

Nous utilisons la fonction read() pour lire le fichier. Exécutons et voyons la sortie.

1 #output
2
Nouveau fichier en cours d'ouverture
3
4

Fonctions impliquées dans la lecture de fichiers en Python

Il y a trois fonctions impliquées dans l'opération de lecture effectuée sur les fichiers.

Lire() :
Cette fonction est utilisée lorsque l'utilisateur souhaite lire toutes les informations à l'intérieur du fichier.

1 nouveau fichier ouvert écriture du nouveau fichier

2
3 avec open("new", "r") comme f:

4 imprimer([Link]())

Lireligne() :
Cette fonction est utilisée lorsque l'utilisateur souhaite lire le fichier ligne par ligne.

1 ouverture de nouveau fichier écriture de nouveau fichier

2
3 avec open("nouveau", "r") comme f :

4 imprimer([Link]())

55
Lire les lignes() :
Cette fonction lit toutes les lignes mais de manière ligne par ligne, ce qui augmente son efficacité dans la gestion de la mémoire.

1 ouverture de nouveau fichier écriture de nouveau fichier

2
3 avec open("new", "r") comme f:

4 print([Link]())

Ajouter un fichier :
Comme discuté ci-dessus, nous ouvrirons un fichier en mode ajout, qui est "a+" pour l'ajout. Le code est illustré ci-dessous.

1 ouverture de nouveau fichier

2
3 avec open("new", "a+") comme f:

4
5 [Link]("Bonjour le monde")

1 Lecture du fichier pour voir la ligne ajoutée :

2 ouverture de nouveau fichier

3
4 avec open("nouveau", "r") comme f:

5
6 imprimer([Link]())
7

Explorons le résultat :

nouveau fichier ouvertureBonjour le monde

1

Renommer un fichier :

Pour renommer un fichier, nous utiliserons les méthodes présentes dans le module « os » de Python. Le code est illustré ci-dessous.

1 importos
2
3 [Link]("[Link]","[Link]")

Dans le code ci-dessus, nous importons le module « os » et utilisons la méthode « rename » pour renommer le fichier que nous créons à partir de « new ».

exemple

Suppression d'un fichier :

Pour supprimer des fichiers, nous utiliserons le même module "os" que nous avons utilisé pour renommer le fichier. L'exemple de la
Le code est illustré ci-dessous.

56
1 importos
2
3 [Link]("[Link]")

Copier un fichier :

Pour copier le fichier, nous utiliserons le même module « os » que nous avons utilisé pour renommer et supprimer un fichier.
un exemple de code est illustré ci-dessous.

1 importos
2
3 [Link]("cp exemple exemple1")

Déplacer un fichier :

Pour déplacer le fichier, nous utiliserons le même module "os" que nous avons utilisé ci-dessus. L'exemple du code est illustré
en dessous.

1 importos

2
3 [Link]("mv source destination")

Dans ce chapitre, nous avons abordé quelques bases concernant les fichiers en Python. Dans le chapitre suivant, nous allons utiliser tout le

connaissance acquise en pratique.

57
11. Applications Python en pratique
Dans ce chapitre, nous aiderons le lecteur à utiliser les apprentissages de tous les chapitres précédents pour réaliser un mini-projet. Vous allez

découvrir les applications de Python en pratique.

Créer un jeu de devinette de nombres

Ce mini-projet sera passionnant pour apprendre comment nous pouvons utiliser des fonctions et la plupart des autres choses que nous avons apprises dans

les chapitres précédents. Ce mini-projet de jeu génère un nombre aléatoire de 1 à 1000 ou si vous voulez que ce soit facile, vous
peut réduire la portée et l'utilisateur qui joue au jeu doit deviner le nombre. Ça a l'air excitant, n'est-ce pas ? Que va-t-il
Rendre cela plus excitant, c'est que nous pouvons donner à l'utilisateur des indices s'il devine le nombre faux afin qu'il puisse deviner le

nombre correctement.

Faisons un plan pour le jeu avec des applications Python en pratique.

58
Commande d'introduction :
Dans la ligne de commande d'introduction, nous demanderons à l'utilisateur de deviner un numéro. Nous demanderons son nom et son âge. Ensuite, nous lui demanderons s'il...

veut jouer au jeu ou non. Faisons cela dans le code.

1 # Panneau d'introduction Ligne de commande

2
3 print("Bienvenue dans le guessnum")
4
5 nom=input(“comment vous appelez-vous?”)
6 print(f"Bonjour {name}")

1 Output:
2 Bienvenue dans le guessnum
3 Bonjour John

Comme on peut le voir, nous avons d'abord présenté notre jeu à l'utilisateur, puis nous lui avons demandé son nom. Nous l'avons accueilli en utilisant

le nom enregistré. Demandons maintenant à l'utilisateur son âge.

Panneau d'introduction Ligne de commande

1
2
3 print("Bienvenue dans le guessnum")
4
5 name=input(“what is your name?”)
6 âge=int(input(f"Bonjour {name}, quel est votre âge ?"))
7 print(f"Bonjour {name}")

1 Sortie :
2 Bienvenue dans le guessnum

3 Bonjour John

Ici, nous voyons fstring, c'est une alternative à format, si nous écrivons f suivi d'une chaîne, nous pouvons utiliser nos variables stockées.
à l'intérieur des "{}" directement.

Maintenant, nous pouvons voir la majeure partie du panneau d'introduction. Demandons maintenant à l'utilisateur s'il veut jouer au jeu et s'il veut jouer au

jeu, demandons-lui de deviner un nombre, afin que nous puissions dire si c'est juste ou non. Mais avant de demander à l'utilisateur de deviner le nombre,

nous devons avoir le numéro du programme prêt.

Voyons comment cela se fait dans le code.

59
01 # Panneau d'introduction Ligne de commande

02
03 print("Bienvenue dans le guessnum")
04
05 name=input(“what is your name?”)
06 âge=int(input(f"Bonjour {name}, quel est votre âge ?"))
07 choice=input(f”Hello {name}, would you like to play the game? y/n”)
08
09 si choix=="y":
10 pass
11 sinon :
12 impression("sortie")
13 sortie
14

Maintenant, nous créons un autre message qui demandera à l'utilisateur s'il veut jouer au jeu, et nous utiliserons le
les conditionnels que nous avons appris dans le chapitre précédent pour continuer s'il dit oui et si c'est non, pour quitter le jeu.

Continuons maintenant à développer notre jeu et demandons à l'utilisateur le numéro, mais avant cela faisons en sorte que notre code en sélectionne un.

nombre aléatoire.

# Panneau d'introduction Ligne de commande

01
02 importer random

03 print("Bienvenue dans le guessnum")

04
05 nom=entrée(« quel est votre nom ? »)
06 âge=int(input(f"Bonjour {name}, quel est votre âge?"))
07 choix=input(f"Bonjour {name}, aimeriez-vous jouer au jeu ? o/n")
08
09 si choix == "y":
10 nombre=int([Link](1,5))
11 deviner=int(input("Veuillez saisir votre supposition"))
12 print(f"votre estimation est {guess}")
13 sinon :
14 imprimer("sortie")
15 sortie
16
17

1 Output:
2 Bienvenue dans le guessnum
3 votre estimation est 2

60
Nous avons maintenant ajouté un module connu sous le nom de random, qui sélectionne un nombre aléatoire dans une plage donnée.

La fonction est [Link](début, fin). Ensuite, nous demandons à notre utilisateur de deviner le nombre et nous imprimons le résultat de notre utilisateur.

hypothèses.

Imprimons aussi la supposition de notre programme.

# Panneau d'Introduction Ligne de commande

01
02 importer aléatoire

03 print("Bienvenue dans le devine numéro")

04
05 name=input(“what is your name?”)
06 âge=int(input(f"Bonjour {name}, quel est votre âge ?"))
07 choice=input(f”Hello {name}, would you like to play the game? y/n”)
08
09 ifchoice==”y”:
10 number=int([Link](1,5))
11 deviner=int(input("Veuillez entrer votre devinette"))
12 print(f"votre supposition est {guess} et la supposition du programme est {number}")
13 sinon :
14 print("sortie")
15 sortie
16
17

1 Output:
2 Bienvenue dans le guessnum

3 votre estimation est 2 et l'estimation du programme est 5

Donc, nous pouvons voir que nous sommes presque à mi-chemin, nous avons la supposition du programme et la supposition de l'utilisateur.

Maintenant, nous pouvons simplement comparer et imprimer si l'utilisateur a raison ou non.

61
01 # Panneau d'introduction Ligne de commande

02 importer le hasard

03 print("Bienvenue dans le jeu de devinette de nombres")

04
05 nom=input("quel est votre nom ?")
06 âge=int(input(f"Bonjour {name}, quel est votre âge?"))
07 choice=input(f”Hello {name}, would you like to play the game? y/n”)
08
09 si choix == "y":
10 nombre=int([Link](1,5))
11 devine=int(input(“Veuillez entrer votre supposition”))
12
13 si devine == nombre :

14 tu as deviné juste !!!

15
16
17
18 votre estimation est {guess} et l'estimation du programme est {number}. Désolé !!! votre estimation est incorrecte
19
20 sinon :
21 impression("sortie")
22 sortie
23
24

1 Output:
2 Bienvenue dans le guessnum
3 votre supposition est 2 et la supposition du programme est 1. Désolé !!! votre supposition est fausse

Comme vous pouvez le voir, j'ai mal deviné, mais peut-être que vous pouvez deviner juste ? Ce jeu peut devenir plus intéressant en ajoutant

le facteur de score.

Now let’s code for the score factor.

62
01 # Panneau de commande Intro
02 importer le hasard

03 print("Bienvenue dans le devinernum")

04
05 nom=input("Quel est votre nom ?")
06 âge=int(input(f"Bonjour {name}, quel est votre âge ?"))
07 choice=input(f”Hello {name}, would you like to play the game? y/n”)
08 correct=0
09
10
11
12
13 tant(choix=="y"):
14 nombre=int([Link](1,5))
15 deviner=int(input("Veuillez entrer votre supposition"))
16
17 si le devinement == nombre :

18 vous avez deviné juste!!!

19 correct+=1
20 choice=input(f”Hello {name}, would you like to continue the game? y/n”)
21
22
23
24
25
26 votre supposition est {guess} et la supposition du programme est {number}. Désolé !!! votre supposition est incorrecte
27 choice=input(f”Hello {name}, would you like to continue the game? y/n”)
28
29
30
31 sinon :
32 imprime(f"votre score est {correct}")
33 impression("sortie")
34 sortie
35
36

63
01 output:
02 Bienvenue dans le guessnum
03 votre supposition est 1 et la supposition du programme est 5.

04 Désolé !!! Votre supposition est incorrecte, votre supposition est 2 et la supposition du programme est 3.

05 Désolé !!! votre supposition est incorrecte, votre supposition est 3 et la supposition du programme est 2.

06 Désolé !!! Votre estimation est incorrecte, votre estimation est 4 et l'estimation du programme est 3.

07 Désolé !!! Votre estimation est incorrecte, votre estimation est 1 et l'estimation du programme est 2.

08 Désolé !!! Votre supposition est incorrecte, votre supposition est 2 et celle du programme est 5.

09 Désolé !!! Votre supposition est incorrecte, votre supposition est 3 et la supposition du programme est 4.

10 Désolé !!! Votre supposition est incorrecte, votre supposition est 3 et la supposition du programme est 2.

11 Désolé !!! Votre supposition est fausse, votre supposition est 3 et la supposition du programme est 5.

12 Désolé !!! Votre supposition est incorrecte, votre supposition est 4 et la supposition du programme est 2.

13 Désolé !!! Votre supposition est fausse. Votre supposition est 3 et celle du programme est 1.

14 Désolé !!! Votre réponse est incorrecte, votre réponse est 4 et la réponse du programme est 5.

15 Désolé !!! Votre supposition est incorrecte, votre supposition est 2 et la supposition du programme est 2.

16 tu as deviné juste!!!
17 Désolé !!! Votre estimation est erronée, votre score est de 1 sortant

Comme vous pouvez le voir, nous avons utilisé des boucles while, et nous avons utilisé une nouvelle variable appelée correct, qui nous donne le score de l'utilisateur.

Que nous imprimons à la sortie.

64
 Félicitations !

Maintenant, vous savez comment mettre en pratique des applications Python, et vous avez officiellement terminé.
le livre électronique : Cours de Python du débutant à l'avancé en 11 articles de blog.

Rendez-vous sur notreblog pour explorer notre deuxième cours :Cours de JavaScript.

Obtenez une perspective à 360° de tous vos projets informatiques

Nous sommes les créateurs deFirmbee: unlogiciel de gestion de projet tout-en-unqui gère votre
entrepriseles problèmes de, finances, soutientà distancetravail d'équipeetProcessus RH.

Avec notre outil, les équipes informatiques, les freelances, les propriétaires d'entreprise et les personnes de différentes industries peuvent

atteindre une productivité maximale et faire avancer le projet de manière planifiée et organisée.

Suivez-nous sur les réseaux sociaux pour du contenu similaire :

65