Jusqu'à présent, nous avons appris quelques façons d'organiser notre code Python.
La première chose que nous avons bien faite, nous venons d'écrire Python dans un fichier et cela l'organise.
À droite?
Notre code entier a été jusqu'à présent sur un seul fichier.
C'était donc une façon d'organiser notre code.
Ensuite, nous avons appris que les fonctions et les fonctions étaient utilisées comme un moyen pour nous de ne pas écrire de code
que nous répétons encore et encore, nous pourrions écrire des fonctions que nous pouvons utiliser n'importe où dans notre fichier afin que nous
puissions appeler ces fonctions encore et encore et nous pouvons nommer les fonctions de manière appropriée afin que notre code ait
du sens.
Et puis nous avons appris à propos des classes, écrivons ces plans à partir desquels nous pouvons créer des objets.
Nous pouvons instancier de nouveaux types de données Python au-delà de ceux qu'ils viennent de nous donner.
À droite.
Au lieu de simplement avoir des dictionnaires et des listes, nous pouvons créer nos propres listes personnalisées une fois que nos propres listes ont
peut-être des fonctionnalités supplémentaires.
Et nous sommes en mesure d'utiliser des classes pour organiser notre code afin de les mettre en boîte et de donner à chaque classe une certaine
méthode et un certain attribut qui l'emballeront bien pour que nous puissions l'utiliser.
Nous avons également appris la programmation fonctionnelle et comment, contrairement, disons, à la programmation orientée objet,
où nous voyons beaucoup de classes avec de la programmation fonctionnelle, nous utilisons juste beaucoup de fonctions, beaucoup
de fonctions pures.
Et nous avons des données que nous venons de transmettre à ces fonctions et nous organisons les choses en petits morceaux.
Toutes ces choses étaient destinées à nous pour garder notre code propre, rendre notre code plus maintenable, gardant ainsi notre code
organisé, car à mesure que nous écrivons plus de lignes de code, il devient de plus en plus difficile de tout garder
dans votre tête.
Si d'autres personnes se joignent à votre équipe pour travailler sur votre projet, elles ont besoin d'un moyen simple de comprendre comment les choses
fonctionnent.
Mais nous avons toujours un problème, et ce problème est que tout est contenu dans ce seul fichier, toutes les fonctions, toutes
les classes que nous avons écrites ont été sur un seul fichier dot pi.
Mais dans la vraie vie, ce n'est pas le cas.
Nous avons beaucoup plus de code et nous ne pouvons pas avoir qu'un seul fichier avec des millions de lignes de code.
Alors comment rester organisé ?
Bien.
Si nous avions plusieurs fichiers de Python.
Comme ça, parce que notre projet prend de plus en plus d'ampleur.
Cela fonctionnerait-il ?
Existe-t-il un moyen pour nous de lier tous ces fichiers ensemble ?
En fait, il existe et c'est une pratique très courante dans l'ensemble de l'industrie, et nous appelons cette
façon d'organiser les modules de code.
Et les modules sont simplement, eh bien, ces fichiers, chacun de ces fichiers, chaque fichier dot py est un module.
Et en construisant ces modules, un peu comme nous avons construit différentes fonctions, un peu comme nous avons construit
différentes classes, parce qu'à l'intérieur de ces fichiers, nous pouvons avoir des classes, nous pouvons avoir des fonctions, mais nous pouvons aussi
avoir différents fichiers.
Donc une couche plus haute pour diviser notre code.
Et dans cette section, nous allons tout apprendre sur les modules et essayer de les maîtriser et voir comment
nous pouvons écrire du code organisé.
Jetons un coup d'œil, vous pouvez voir ici, si je clique sur philes dans notre Reppel, nous avons un DCPI principal et
chaque fois que je clique sur exécuter cet automne, je cours.
Mais que se passe-t-il si nous avons plus de fichiers ?
Que se passe-t-il si j'ajoute un autre fichier ici et que nous l'appelons utilitaire dot pi ?
Donc, d'après ce que je viens de vous dire, ces deux choses sont ce qu'elles sont le droit du module, le DCPI principal est un
utilitaire de module.
Tappy est un module.
Et lors de l'écriture de modules, nous utilisons les mêmes principes que les variables en Python, qui est la casse du serpent,
c'est-à-dire que s'il s'agit d'espaces, nous utilisons le soulignement, tout est en lettre minuscule.
Alors, comment répartissons-nous ces modules et cela vient avec la pratique lorsque vous débutez, c'est difficile à dire, hé, qu'est-ce qui
entre dans quoi ?
Que se passe-t-il dans quel fichier ?
Mais c'est comme les cours, non ?
Similaire aux fonctions.
Nous voulons diviser notre code en morceaux qui ont du sens.
Encore une fois, disons que nous travaillons chez Netflix.
Nous pourrions avoir un fichier dédié aux vidéos.
Nous pourrions avoir un autre fichier ou module dédié à la connexion d'un utilisateur, peut-être un autre fichier dédié à
l'analyse et à la formulation de recommandations pour les utilisateurs.
Nous voulons regrouper ces classes et fonctions dans un fichier qui a du sens.
Maintenant, l'une des façons les plus courantes d'utiliser un module est quelque chose comme un utilitaire.
Disons que nous voulons créer un module utilitaire qui est un module qui a beaucoup de choses comme une ceinture à
outils, des fonctions très simples que nous pouvons utiliser tout au long de notre projet car nous pouvons imaginer ici
avoir plusieurs fichiers.
Créons donc un exemple très simple.
Je vais dire qu'une fonction de multiplication existe ici.
Et cela prend un nom un et un numéro deux.
Et ici, nous allons simplement ramener Namwon Times engourdi à une fonction très simple et encore une fois, nous aurons
également une fonction de division.
Et oui, c'est un peu inutile car nous pouvons simplement utiliser l'opérande plus ou diviser en Python.
Mais restez avec moi ici et essayez de vous montrer un exemple.
Très bien, donc numéro deux, je vais retourner le numéro un, divisé par le numéro deux, joli et simple.
Donc ça.
C'est notre modèle d'utilité qui a toutes ces fonctions pour nous.
Maintenant, notez ici que nous ne faisons rien dans ce fichier.
Je définis simplement des fonctions, mais je n'exécute aucune des fonctions.
Mais disons que nous avons ce module utilitaire et que je veux l'utiliser dans mon piège principal.
Comment ferions-nous cela?
Eh bien, la façon dont nous communiquons entre ces deux fichiers est assez simple, tout ce que nous avons à faire est d'utiliser
la commande d'importation que nous importons, puis de lui donner le nom de fichier que nous voulons importer.
Que voulons-nous importer ?
Nous voulons importer l'utilitaire juste comme ça.
Et notez que je n'ajoute pas de tarte à points parce que nous supposons que tout ce que nous allons importer
sera un fichier python.
Nous n'avons donc pas besoin de le faire.
Juste le nom, juste comme ça.
Imprimons maintenant l'utilitaire ici.
Si je lance ça.
Whoa, voyez-vous que nous avons un utilitaire de module et qu'il s'agit d'un chemin de fichier que ce site Web génère pour nous, donc
cela n'a pas vraiment d'importance.
Maintenant, il y a quelques choses qui se sont produites ici.
La première est que nous avons généré ce dossier de cache PAE, trait de soulignement, trait de soulignement, cache PAE.
Et oh, mon garçon, c'est quoi ce charabia ?
Hmm, c'est assez déroutant, non ?
Eh bien, cet argent à tarte est créé chaque fois que nous gérons un dossier avec, disons, une approbation.
Ainsi, lorsque nous utilisons des modules.
Vous voyez, ce que fait Pae Cash, c'est quand nous cliquons, courons.
L'interprète va créer ce dossier de podcast et il va dire, hé, j'exécute ce
fichier.
Celui-ci ne peut rien déposer qui ne paie pas les importations de fichiers, disons l'utilitaire.
Dans notre cas, je vais l'encaisser.
Alors voyez comment il est écrit ici point PC.
C'est parce qu'il utilise l'interpréteur C Python.
N'oubliez pas qu'il s'agit du python C, qui est l'interpréteur écrit, et du C, il s'agit donc en fait d'un
fichier compilé afin que la prochaine fois que je clique sur exécuter ici sur mon DCPI principal, rien ne change car ce
qui va se passer est au lieu de charger l'utilitaire Dopy, ça va charger cette version compilée de l'utilitaire car
rien n'a changé et l'utilitaire DCPI.
Et cela rend les choses plus rapides lorsque j'ai essayé de relancer Maeng Pie.
C'est ce qu'est la mise en cache.
La mise en cache est, hé, je vais m'en souvenir, et c'est la version de compilation,
donc je n'ai pas à repasser par l'étape de compilation.
Mais notez que le fichier principal n'est pas compilé car, eh bien, nous l'exécutons à chaque fois.
Maintenant, si nous modifions la fonction utilitaire pour qu'il n'y ait pas de division, je clique sur exécuter et vous ne le remarquez
pas ici.
Mais cela a maintenant été réexécuté car nous avons un fichier différent.
Vous voyez que nous avons multiplié ici, mais pas divisé.
Alors ramenons à nouveau la division.
Revenez ici, cliquez, exécutez.
Et voilà, nous avons une division ici deux maintenant, mais c'est quelque chose que nous ne touchons pas.
Cela vient juste sous le capot avec n'importe quel éditeur que nous utilisons.
Et dans quelques vidéos, nous allons vous montrer comment cela se produit également lorsque vous utilisez quelque chose comme un
camembert.
C'est juste quelque chose que les éditeurs nous permettent de faire juste pour que nos programmes puissent s'exécuter plus rapidement.
J'y ai donc désormais accès.
Faisons cela un peu plus petit.
J'ai maintenant accès à l'utilitaire.
Et voici la partie intéressante.
Si je fais un point ici, regardez ça.
J'ai accès à diviser et multiplier pour pouvoir multiplier les nombres.
Disons deux et trois.
Cliquez sur exécuter.
Et je peux utiliser le module utilitaire dans mon fichier principal, très, très cool si je divise et que je clique sur exécuter.
Je peux aussi l'utiliser.
Très, très cool, et je peux importer autant de fois que je veux si j'avais un fichier différent ici et que je
veux importer autre chose, disons qu'il y a un utilitaire pour archiver.
Eh bien, je peux importer cela et importer autant de choses que je veux et les utiliser dans mes fichiers.
À quel point cela est cool?
Alors maintenant, nous avons un moyen d'organiser notre code et de faire communiquer tous ces fichiers ensemble, car dans la
vraie vie, nous avons de gros projets et ces gros projets vont être travaillés par différentes
équipes, différents programmeurs.
Et nous avons besoin d'un moyen de travailler avec tous ces fichiers.
Et en utilisant les instructions d'importation entre les modules, nous sommes en mesure d'utiliser les fonctionnalités tout comme nous avons
pu utiliser les fonctionnalités que les fonctions nous ont fournies entre différents fichiers.
Et la plupart du temps, si vous travaillez dans une entreprise, les deux premières lignes d'un fichier point
pi sont généralement des instructions d'importation, car vous communiquez généralement avec d'autres fichiers.
Apprenons-en plus dans la prochaine vidéo.