WEBVTT

00:00:00.000 --> 00:00:03.840


00:00:03.840 --> 00:00:06.240
[THÈME MUSICAL]

00:00:06.240 --> 00:00:10.560


00:00:10.560 --> 00:00:13.200
Bonjour et bienvenue à l'INE.

00:00:13.200 --> 00:00:16.110
Aujourd'hui, dans cette vidéo, nous examinerions les fonctions, conditionnelles,

00:00:16.110 --> 00:00:19.770
et pour la boucle en gros, on ferait un tour de danse.

00:00:19.770 --> 00:00:22.950
Alors jetons un coup d'œil à notre exigence de tâche.

00:00:22.950 --> 00:00:24.575
Maintenant, nous avons appris les fonctions,

00:00:24.575 --> 00:00:25.950
nous avons appris le conditionnement,

00:00:25.950 --> 00:00:28.830
et nous avons également appris la boucle for.

00:00:28.830 --> 00:00:31.590
Mais cette fois, dans cette tâche de laboratoire, nous voudrions essentiellement

00:00:31.590 --> 00:00:33.660
combiner les trois, et je suis

00:00:33.660 --> 00:00:39.480
je vais tester si vous avez compris comment faire,

00:00:39.480 --> 00:00:44.020
et je vais vous tester avec cette tâche de tour.

00:00:44.020 --> 00:00:48.210
Alors jetons un coup d'œil à nos besoins en laboratoire.

00:00:48.210 --> 00:00:53.310
Il dit, créez un fichier nommé devices.py sur atom,

00:00:53.310 --> 00:00:57.600
créer une variable de classe nommée numériquement dev1, qui

00:00:57.600 --> 00:01:04.230
contient la clé et les valeurs définies comme nom d'hôte R1, un système d'exploitation, iOS-XE,

00:01:04.230 --> 00:01:08.250
et l'IP de gestion est 10.1.1.1.

00:01:08.250 --> 00:01:11.790
Créez une autre variable, qui sera appelée dev2,

00:01:11.790 --> 00:01:14.490
et cela aurait des informations sur R2,

00:01:14.490 --> 00:01:18.510
qui aurait le nom d'hôte comme R2, le système d'exploitation comme iOS-XR,

00:01:18.510 --> 00:01:21.720
et l'IP de gestion 10.1.1.2.

00:01:21.720 --> 00:01:24.180
Puis encore une autre variable de nouveau

00:01:24.180 --> 00:01:25.740
cette trois variable, qui va

00:01:25.740 --> 00:01:28.770
être appelé comme dev3 et cela aurait des informations

00:01:28.770 --> 00:01:29.610
à propos de R3.

00:01:29.610 --> 00:01:33.460
Nous créerions donc cinq répertoires distincts,

00:01:33.460 --> 00:01:37.210
so qui contient des informations sur les routeurs individuels.

00:01:37.210 --> 00:01:40.770
Donc deux d'entre eux sont iOS-XE, donc R1 et R3

00:01:40.770 --> 00:01:48.040
sont iOS-EX, et R2 et R4 ils exécutent iOS-XR,

00:01:48.040 --> 00:01:50.460
R5 exécute nexus.

00:01:50.460 --> 00:01:54.210
Maintenant, nous devons créer une variable de liste de classe

00:01:54.210 --> 00:01:57.390
qui va être appelé en tant que liste de soulignement de périphérique, qui

00:01:57.390 --> 00:01:59.010
contient tous ces quartiers.

00:01:59.010 --> 00:02:01.860
Donc, fondamentalement, toutes les distances seraient cartographiées à l'intérieur

00:02:01.860 --> 00:02:05.070
sous forme de liste dans cette variable.

00:02:05.070 --> 00:02:09.479
Ensuite, nous devons créer une fonction nommée device

00:02:09.479 --> 00:02:11.940
soulignement 4, pour afficher l'IP de gestion

00:02:11.940 --> 00:02:14.950
l'adresse de l'appareil en fonction de la plate-forme du système d'exploitation.

00:02:14.950 --> 00:02:17.540


00:02:17.540 --> 00:02:22.030
Et l'exigence suivante dit que l'IP de gestion

00:02:22.030 --> 00:02:25.630
doit être affiché en fonction de la condition suivante.

00:02:25.630 --> 00:02:29.920
Si le système d'exploitation est iOS-XE, il doit imprimer l'IP de gestion

00:02:29.920 --> 00:02:31.900
du nom du routeur--

00:02:31.900 --> 00:02:34.960
exécute iOS-XE est l'IP de gestion,

00:02:34.960 --> 00:02:37.730
qui est l'adresse IP extraite du dictionnaire.

00:02:37.730 --> 00:02:40.330
Et si c'est iOS-XR, ça devrait essentiellement

00:02:40.330 --> 00:02:42.040
vous donner le nom d'hôte et la gestion

00:02:42.040 --> 00:02:45.670
IP des appareils exécutant iOS-XR, et s'il s'agit d'un lien

00:02:45.670 --> 00:02:48.310
il devrait vous montrer l'adresse IP de gestion et l'hôte

00:02:48.310 --> 00:02:52.750
nom de l'appareil exécutant l'appareil Nexus.

00:02:52.750 --> 00:02:55.120
Enregistrez la fonction en tant que périphérique undecore

00:02:55.120 --> 00:02:57.490
infor.py dans la machine Ubuntu.

00:02:57.490 --> 00:03:00.370
Assurez-vous que vous pouvez appeler cette fonction en l'important

00:03:00.370 --> 00:03:05.650
depuis la machine Ubuntu et imprimez les informations requises

00:03:05.650 --> 00:03:07.150
quant à la question.

00:03:07.150 --> 00:03:10.240
Maintenant, juste pour le rendre plus difficile, vous avez déjà

00:03:10.240 --> 00:03:14.200
fonctions faites, vous avez déjà fait conditionnel,

00:03:14.200 --> 00:03:19.750
et si vous vous souvenez que nous avons fait du conditionnel avec des fonctions,

00:03:19.750 --> 00:03:23.800
mais nous n'avons jamais combiné pour la boucle et le conditionnel

00:03:23.800 --> 00:03:26.810
et fonctionnent ensemble.

00:03:26.810 --> 00:03:30.290
Je vais donc vous compliquer un peu la tâche.

00:03:30.290 --> 00:03:35.150
Je vais donc revenir en arrière et apporter un changement à la question.

00:03:35.150 --> 00:03:36.400
Faisons en fait cela.

00:03:36.400 --> 00:03:54.170
J'ajouterai que vous devez utiliser la boucle for et le conditionnel

00:03:54.170 --> 00:03:59.910
pour atteindre cette exigence.

00:03:59.910 --> 00:04:03.080
Vous devez donc utiliser une boucle for et vous devez utiliser le conditionnel,

00:04:03.080 --> 00:04:06.230
et évidemment la question dit que nous devons également créer une fonction

00:04:06.230 --> 00:04:09.680
qui doit s'appeler A et B. Alors pensez-y, ce que

00:04:09.680 --> 00:04:12.950
Je suggérerais de mettre la vidéo en pause et d'y réfléchir,

00:04:12.950 --> 00:04:15.860
essayez-le par vous-même, et si vous

00:04:15.860 --> 00:04:17.870
sont bloqués, vous pouvez toujours regarder la vidéo

00:04:17.870 --> 00:04:19.910
et voir comment j'y parviens.

00:04:19.910 --> 00:04:23.380


00:04:23.380 --> 00:04:25.960
Alors maintenant, je vais vous montrer comment je ferais cela.

00:04:25.960 --> 00:04:28.120
Alors permettez-moi en fait d'agrandir l'écran.

00:04:28.120 --> 00:04:33.000
Donc, ce que je vais faire, c'est revenir à...

00:04:33.000 --> 00:04:36.210
permettez-moi en fait d'ouvrir à nouveau cela.

00:04:36.210 --> 00:04:43.597
Et je vais aller sur mon atome et créer le script.

00:04:43.597 --> 00:04:45.180
La première exigence était donc évidemment

00:04:45.180 --> 00:04:47.170
pour créer les répertoires.

00:04:47.170 --> 00:04:51.640
Je vais donc créer ces répertoires.

00:04:51.640 --> 00:04:53.880
Alors faisons du dev--

00:04:53.880 --> 00:04:55.210
Je vais créer une fonction.

00:04:55.210 --> 00:04:59.490
Donc la définition va être--

00:04:59.490 --> 00:05:03.090
quant à la question le nom de la définition

00:05:03.090 --> 00:05:08.040
Je crois que c'était une information de soulignement de l'appareil,

00:05:08.040 --> 00:05:09.000
donc c'est le nom, ça.

00:05:09.000 --> 00:05:12.540
Donc, les informations de soulignement de l'appareil, qui sont le nom de ma définition

00:05:12.540 --> 00:05:15.510
et mon espace réservé temporaire pourrait être n'importe quoi,

00:05:15.510 --> 00:05:18.270
Je vais juste le nommer comme--

00:05:18.270 --> 00:05:22.710
maintenant, je pense que sur la base de la question, nous filtrons en fonction

00:05:22.710 --> 00:05:26.940
sur le nom de la clé en tant que système d'exploitation, je vais donc le mettre en tant que système d'exploitation,

00:05:26.940 --> 00:05:29.700
ou mettons-le en minuscules.

00:05:29.700 --> 00:05:34.140
Donc ça va être mon espace réservé temporaire.

00:05:34.140 --> 00:05:36.600
Je vais donc créer une fonction appelée dev,

00:05:36.600 --> 00:05:40.770
donc l'information de soulignement de l'appareil de définition et dans ma parenthèse

00:05:40.770 --> 00:05:44.280
J'ai un système d'exploitation, c'est juste n'importe quel nom, n'importe quel nom d'espace réservé

00:05:44.280 --> 00:05:49.270
puis j'allais créer des répertoires.

00:05:49.270 --> 00:05:50.890
Alors créons ces répertoires.

00:05:50.890 --> 00:05:55.140
Donc, le premier répertoire était égal à vec1--

00:05:55.140 --> 00:06:04.060
Je crois que nous voulons un nom qui devrait être égal à R1.

00:06:04.060 --> 00:06:09.190
Ensuite, nous voulons un système d'exploitation, donc un système d'exploitation qui devrait

00:06:09.190 --> 00:06:13.510
être égal au soulignement iOS XE.

00:06:13.510 --> 00:06:16.660
Cela pourrait donc être iOS dash XE, pourrait être iOS soulignant XE.

00:06:16.660 --> 00:06:20.000
Je crois que la question dit iOS dash XE,

00:06:20.000 --> 00:06:21.625
nous devrions donc correspondre à cela.

00:06:21.625 --> 00:06:23.620
Donc iOS dash XE--

00:06:23.620 --> 00:06:26.350
laissez-moi en fait agrandir l'écran pour vous afin que vous voyiez mieux.

00:06:26.350 --> 00:06:29.540


00:06:29.540 --> 00:06:34.790
Je vais donc revenir en arrière et ajouter mes paramètres restants,

00:06:34.790 --> 00:06:41.540
donc le suivant était l'adresse IP du tableau de bord MGMT de gestion,

00:06:41.540 --> 00:06:45.980
qui va être 10.1.1.1.

00:06:45.980 --> 00:06:48.750
Et puis fermons mes accolades,

00:06:48.750 --> 00:06:50.930
donc mon dictionnaire est créé.

00:06:50.930 --> 00:06:54.350
Rejetons cela, j'ai donc le nom d'hôte R1,

00:06:54.350 --> 00:06:59.750
Le système d'exploitation est l'IP de gestion iOS-XE est 10.1.1.1.

00:06:59.750 --> 00:07:09.380
Copions ceci et mettons cela comme dev2, cela devrait être R2,

00:07:09.380 --> 00:07:14.450
cela devrait être iOS-XR, et c'est 10.1.1.2.

00:07:14.450 --> 00:07:20.390
Recopions ceci et mettons-le dans la ligne suivante.

00:07:20.390 --> 00:07:25.280
Ce serait dev 3 et dev4, ce

00:07:25.280 --> 00:07:35.450
serait R3, R4, iOS-XE, iOS-XR 3 et 4.

00:07:35.450 --> 00:07:38.270
Ensuite, j'ai besoin d'une entrée supplémentaire pour nexus,

00:07:38.270 --> 00:07:41.330
qui va être mon deV5.

00:07:41.330 --> 00:07:52.370
Donc, le nom d'hôte dev5 est R5 et l'image est nexus--

00:07:52.370 --> 00:07:56.870
en fait, je vois une erreur ici qui

00:07:56.870 --> 00:08:00.380
est-ce accolades, qui ne devrait pas être ici.

00:08:00.380 --> 00:08:06.470


00:08:06.470 --> 00:08:12.370
OK, j'ai donc créé mes cinq répertoires,

00:08:12.370 --> 00:08:15.850
et maintenant je dois créer la liste.

00:08:15.850 --> 00:08:20.620
Alors maintenant, ce que je dois faire, c'est que je devrais créer une liste

00:08:20.620 --> 00:08:23.110
et ajoutez tous ces répertoires à l'intérieur.

00:08:23.110 --> 00:08:25.480
Maintenant en ce qui concerne ma question, ma question

00:08:25.480 --> 00:08:28.960
dit que le nom de ma liste devrait être--

00:08:28.960 --> 00:08:32.409
Je crois que le nom de la liste est donné quelque part ici, c'est l'appareil

00:08:32.409 --> 00:08:33.770
et c'est ce qu'on appelle la liste.

00:08:33.770 --> 00:08:35.289
Alors créons ça.

00:08:35.289 --> 00:08:39.370
Je vais revenir en arrière et créer ma liste.

00:08:39.370 --> 00:08:43.690
Donc, la prochaine chose est le soulignement de l'appareil

00:08:43.690 --> 00:08:46.990
list est égal à-- si vous vous souvenez de la liste

00:08:46.990 --> 00:08:48.700
se fait à l'aide du support de boîte.

00:08:48.700 --> 00:08:59.110
J'aurais mes dev1, dev2, dev3, dev4, dev5,

00:08:59.110 --> 00:09:04.810
j'ai donc les cinq répertoires dans ma liste.

00:09:04.810 --> 00:09:05.750
Et après?

00:09:05.750 --> 00:09:06.880
De quoi d'autre ai-je besoin ?

00:09:06.880 --> 00:09:09.980
Maintenant, je dois créer une boucle for.

00:09:09.980 --> 00:09:16.120
Alors maintenant, pour y parvenir, ce que je vais faire, c'est...

00:09:16.120 --> 00:09:21.010
Je peux y parvenir de différentes manières cependant,

00:09:21.010 --> 00:09:24.910
Je vais y parvenir en me basant sur...

00:09:24.910 --> 00:09:27.580
ce que je vais faire, c'est que je vais créer une boucle for,

00:09:27.580 --> 00:09:31.390
et dans la boucle for, je vais créer une autre boucle for.

00:09:31.390 --> 00:09:33.250
La raison pour laquelle je vais faire ça

00:09:33.250 --> 00:09:37.730
est parce que je veux que la boucle s'exécute dans la définition.

00:09:37.730 --> 00:09:42.490
Donc tout ce que j'ai vraiment à faire est d'importer la fonction

00:09:42.490 --> 00:09:45.920
et il s'exécute pour moi.

00:09:45.920 --> 00:09:48.190
Une fois que j'appelle la fonction, elle me donne les informations

00:09:48.190 --> 00:09:48.890
ce dont j'ai besoin.

00:09:48.890 --> 00:09:53.000
Sinon, si je fais ma boucle for pas dans la fonction

00:09:53.000 --> 00:09:55.480
dans ce cas, à l'extérieur où...

00:09:55.480 --> 00:09:58.630
chaque fois que je dois exécuter ce script

00:09:58.630 --> 00:10:02.140
Je dois appeler ma fonction, puis créer une boucle for

00:10:02.140 --> 00:10:05.000
pour obtenir essentiellement des informations de cette fonction.

00:10:05.000 --> 00:10:06.430
Alors ce que je vais faire, c'est-à-dire

00:10:06.430 --> 00:10:07.900
va être la meilleure façon de faire

00:10:07.900 --> 00:10:12.260
c'est que je vais appeler ma boucle for dans la fonction.

00:10:12.260 --> 00:10:15.310
Alors permettez-moi en fait de vous montrer comment je vais faire cela.

00:10:15.310 --> 00:10:18.380
Cela semble un peu déroutant, mais une fois que nous avons fait cela,

00:10:18.380 --> 00:10:21.920
vous devriez être en mesure de voir comment cela a du sens.

00:10:21.920 --> 00:10:23.500
Alors faisons ça.

00:10:23.500 --> 00:10:26.500
Je vais à nouveau agrandir mon écran et vous montrer

00:10:26.500 --> 00:10:27.950
comment on peut faire ça.

00:10:27.950 --> 00:10:29.800
Alors revenons en arrière, appuyez sur Entrée.

00:10:29.800 --> 00:10:34.520
Alors maintenant, je vais créer une boucle for.

00:10:34.520 --> 00:10:35.480
Alors faisons ça.

00:10:35.480 --> 00:10:44.740
Donc pour dev-- encore une fois, cela pourrait être n'importe quel nom, alors donnons 4--

00:10:44.740 --> 00:10:50.410
encore une fois, je pourrais peut-être donner ceci comme disons la boucle un.

00:10:50.410 --> 00:10:52.720
La question ne dit pas vraiment quelles informations

00:10:52.720 --> 00:10:54.523
ou quel devrait être mon nom de boucle for,

00:10:54.523 --> 00:10:55.690
donc je peux juste donner n'importe quoi.

00:10:55.690 --> 00:11:01.790
Donc, pour la première boucle de mon dictionnaire dans ma liste,

00:11:01.790 --> 00:11:06.370
qui s'appelle le trait de soulignement de l'appareil--

00:11:06.370 --> 00:11:09.340
Je crois que c'est la liste de soulignement de l'appareil.

00:11:09.340 --> 00:11:13.660
Donc, pour dev for loop one dans la liste des traits de soulignement de l'appareil,

00:11:13.660 --> 00:11:16.000
Que devrions nous faire?

00:11:16.000 --> 00:11:19.750
Alors je veux-- laissez-moi en fait enregistrer ça d'abord,

00:11:19.750 --> 00:11:23.350
parce que maintenant, sans l'enregistrer en tant que fichier .py,

00:11:23.350 --> 00:11:25.910
ne donne pas vraiment l'indentation automatiquement,

00:11:25.910 --> 00:11:27.880
donc je vais d'abord enregistrer ce fichier.

00:11:27.880 --> 00:11:29.980
Gardons ça sous...

00:11:29.980 --> 00:11:32.430
Je crois que la question était devine.py.

00:11:32.430 --> 00:11:35.230


00:11:35.230 --> 00:11:37.750
Je pense que c'est device.py.

00:11:37.750 --> 00:11:41.510
Oui, device.py, sauvegardons cela.

00:11:41.510 --> 00:11:44.870
Alors maintenant, il fait automatiquement mon indentation pour moi.

00:11:44.870 --> 00:11:51.640
Donc, pour la boucle un dans la liste des appareils, qui est le nom de ma liste dans ce

00:11:51.640 --> 00:11:55.250
Je veux appeler une autre boucle for.

00:11:55.250 --> 00:12:14.110
Donc, pour la clé, valeur dans loop1.items deux-points.

00:12:14.110 --> 00:12:19.450
Je veux donc regarder la clé et la valeur dans loop1 pour les éléments.

00:12:19.450 --> 00:12:22.300
Donc, si vous regardez ma première boucle for, ma première boucle for

00:12:22.300 --> 00:12:25.630
est seulement de parcourir ma liste.

00:12:25.630 --> 00:12:28.870
Donc cette boucle va parcourir la liste,

00:12:28.870 --> 00:12:33.190
et cette boucle for va chercher la clé et les valeurs

00:12:33.190 --> 00:12:34.310
dans cette boucle.

00:12:34.310 --> 00:12:39.130
Donc, fondamentalement, loop1 parcourt tous les éléments

00:12:39.130 --> 00:12:40.240
à l'intérieur de la liste.

00:12:40.240 --> 00:12:43.990
Et dans cette boucle for je cherche la clé et la valeur

00:12:43.990 --> 00:12:46.280
dans cette liste.

00:12:46.280 --> 00:12:51.670
Donc, pour la clé et la valeur dans loop1.items, je vais regarder

00:12:51.670 --> 00:13:15.060
car si la valeur est égale, est égal à iOS c'est-à-dire xz et OS donc OS est égal

00:13:15.060 --> 00:13:37.230
est égal à iOS-XE, alors je devrais imprimer l'IP de gestion pour--

00:13:37.230 --> 00:14:02.680
faisons un nom d'hôte plus, loop1 et plus loop1 MGMt-IP.

00:14:02.680 --> 00:14:05.710


00:14:05.710 --> 00:14:08.760
C'est donc ce que nous devrions imprimer.

00:14:08.760 --> 00:14:11.010
J'expliquerai une fois que nous aurons fait cela, que sommes-nous réellement

00:14:11.010 --> 00:14:14.260
faire ici.

00:14:14.260 --> 00:14:15.120
Appuyons sur Entrée.

00:14:15.120 --> 00:14:19.130


00:14:19.130 --> 00:14:30.010
Sinon, la valeur est égale à IOS-XR,

00:14:30.010 --> 00:14:43.265
et OS est égal à IOS-XR, alors nous devrions imprimer.

00:14:43.265 --> 00:14:46.510


00:14:46.510 --> 00:14:51.190
Ensuite, nous devrions imprimer la même chose.

00:14:51.190 --> 00:14:53.410
Allons-y ici.

00:14:53.410 --> 00:14:59.100
Donc, imprimez l'IP de gestion du nom d'hôte loop1 est--

00:14:59.100 --> 00:15:01.995
Je devrais avoir est ici, est.

00:15:01.995 --> 00:15:15.740


00:15:15.740 --> 00:15:20.480
OK, et prenons une autre instruction elseif.

00:15:20.480 --> 00:15:27.590


00:15:27.590 --> 00:15:40.060
Sinon, si c'est NEXUS, alors nous

00:15:40.060 --> 00:15:41.995
devrait commencer à imprimer exactement la même chose.

00:15:41.995 --> 00:15:44.550


00:15:44.550 --> 00:15:53.310
La dernière déclaration va être sinon nous devrions passer.

00:15:53.310 --> 00:15:54.040
C'est ça.

00:15:54.040 --> 00:15:56.140
C'est tout ce dont j'ai besoin.

00:15:56.140 --> 00:15:59.460
Alors laissez-moi, en fait, vous montrer ce que j'ai réellement fait.

00:15:59.460 --> 00:16:02.220
Alors que va-t-il se passer ?

00:16:02.220 --> 00:16:10.620
Donc, une fois que j'importe le périphérique de définition d'appel de fonction

00:16:10.620 --> 00:16:13.350
et demander des informations, si j'importe cette fonction--

00:16:13.350 --> 00:16:16.980
donc cette fonction attend une entrée dans la place temporaire

00:16:16.980 --> 00:16:20.370
titulaire appelé os, qui est en minuscule.

00:16:20.370 --> 00:16:26.560
Et j'ai tous ces appareils, ou mon dictionnaire est créé,

00:16:26.560 --> 00:16:29.070
et j'ai une liste en cours de création.

00:16:29.070 --> 00:16:33.390
Et j'ai une boucle for maintenant appelée loop1,

00:16:33.390 --> 00:16:36.010
qui parcourt cette liste.

00:16:36.010 --> 00:16:39.090
Donc, fondamentalement, il analyse dev1, dev2, dev3, dev4,

00:16:39.090 --> 00:16:42.600
et dev5, qui sont mes dictionnaires.

00:16:42.600 --> 00:16:44.820
Ensuite, j'ai une autre boucle for qui

00:16:44.820 --> 00:16:49.440
recherche la clé et la valeur dans loop1.items.

00:16:49.440 --> 00:16:52.350
Maintenant, qu'y a-t-il à l'intérieur de lop1.items ?

00:16:52.350 --> 00:16:59.070
loop1.items contient dev1, dev2, dev3, dev4 et dev5, donc

00:16:59.070 --> 00:17:01.320
chaque dictionnaire individuel.

00:17:01.320 --> 00:17:04.500
Il va donc rechercher la clé et la valeur dans loop1.

00:17:04.500 --> 00:17:10.440


00:17:10.440 --> 00:17:11.920
Prenons un seul dictionnaire.

00:17:11.920 --> 00:17:14.069
Disons donc s'il scanne via dev1.

00:17:14.069 --> 00:17:22.829
Donc, si la valeur est IOS-XE, qui va être là dans ce

00:17:22.829 --> 00:17:28.380
un, si la valeur est IOS-XE, à laquelle elle correspond, et OS--

00:17:28.380 --> 00:17:29.430
qu'est-ce que le système d'exploitation ?

00:17:29.430 --> 00:17:34.740
OS est l'espace réservé temporaire que j'ai donné ici,

00:17:34.740 --> 00:17:38.280
également égal à IOS-XE, ce qui signifie quel que soit

00:17:38.280 --> 00:17:44.190
entrée je donne dans la fonction, si cela et la valeur

00:17:44.190 --> 00:17:46.740
dans le dictionnaire, s'ils sont identiques,

00:17:46.740 --> 00:17:52.200
puis il correspond à cela et imprime l'adresse IP de gestion pour loop1.

00:17:52.200 --> 00:17:53.280
Qu'est-ce que la boucle1 ?

00:17:53.280 --> 00:17:57.250
loop1 contient le dev1, qui est mon dictionnaire.

00:17:57.250 --> 00:18:02.610
Donc nom d'hôte loop1, donc il tirera le nom d'hôte de dev1

00:18:02.610 --> 00:18:06.780
et extrayez l'IP de gestion de dev1.

00:18:06.780 --> 00:18:09.580
Laissez-moi tester cela pour vous.

00:18:09.580 --> 00:18:13.060
Donc je vais d'abord sauvegarder ça.

00:18:13.060 --> 00:18:18.800
Copions ce fichier sur ma machine Ubuntu.

00:18:18.800 --> 00:18:22.420
Je vais donc retourner sur ma machine Ubuntu.

00:18:22.420 --> 00:18:28.765
Et je crois que je devrais pouvoir me connecter.

00:18:28.765 --> 00:18:37.260


00:18:37.260 --> 00:18:40.790
Faisons pwd, et changeons mon répertoire

00:18:40.790 --> 00:18:45.050
au cd Desktop, cd rohit.

00:18:45.050 --> 00:18:51.671
Et je n'ai pas ce fichier en ce moment, device.py.

00:18:51.671 --> 00:18:55.730
Je vais donc vérifier mon chemin.

00:18:55.730 --> 00:19:04.230
Allons sur ma machine, ma machine locale.

00:19:04.230 --> 00:19:07.740
Faites pwd ici.

00:19:07.740 --> 00:19:11.640
Faisons un cd Desktop, cd rohit.

00:19:11.640 --> 00:19:14.730
J'ai donc ce fichier stocké localement sur ma machine locale

00:19:14.730 --> 00:19:16.620
appelé device.py.

00:19:16.620 --> 00:19:21.210
Je vais faire un SFTP sur mon rack, sur ma machine Ubuntu.

00:19:21.210 --> 00:19:26.430


00:19:26.430 --> 00:19:30.130
Je crois que mon mot de passe est Cisco.

00:19:30.130 --> 00:19:31.455
Et mettons ce fichier.

00:19:31.455 --> 00:19:41.580


00:19:41.580 --> 00:19:42.750
Je crois que c'est device.py.

00:19:42.750 --> 00:19:57.938


00:19:57.938 --> 00:19:59.855
Il me semble que la connexion est longue.

00:19:59.855 --> 00:20:05.853


00:20:05.853 --> 00:20:06.520
Essayons encore.

00:20:06.520 --> 00:20:13.080


00:20:13.080 --> 00:20:13.990
OK, je suis connecté.

00:20:13.990 --> 00:20:17.620
Mettons device.py.

00:20:17.620 --> 00:20:21.490
Alors placez ce fichier sur ma machine Ubuntu dans la ligne de dossier hit.

00:20:21.490 --> 00:20:26.410
Alors maintenant, si je retourne sur ma machine Ubuntu et que je fais ls,

00:20:26.410 --> 00:20:30.670
Je devrais avoir ce fichier appelé device.py.

00:20:30.670 --> 00:20:36.880
Alors maintenant, si je vais à Python 3 et que je dis à partir de l'appareil,

00:20:36.880 --> 00:20:38.080
qui est mon nom de fichier--

00:20:38.080 --> 00:20:39.880
Je n'ai pas à spécifier .py.

00:20:39.880 --> 00:20:46.770
Donc, à partir de l'appareil, je dirais l'importation de l'appareil.

00:20:46.770 --> 00:20:51.840
Je crois que mon nom de fonction était device_info, donc

00:20:51.840 --> 00:20:56.010
importer device_info.

00:20:56.010 --> 00:21:01.740
Je vois donc qu'il y a une erreur dans mon script.

00:21:01.740 --> 00:21:04.410
Je dois donc revenir en arrière et vérifier.

00:21:04.410 --> 00:21:08.090
Oui, je n'avais pas le signe plus, donc plus.

00:21:08.090 --> 00:21:11.840
Revenons en arrière, ajoutons le plus.

00:21:11.840 --> 00:21:18.920
Et enregistrons ceci et recopions ce fichier.

00:21:18.920 --> 00:21:21.520
Remettons donc à nouveau ce fichier.

00:21:21.520 --> 00:21:28.040


00:21:28.040 --> 00:21:31.760
Et si je retourne maintenant à ma machine

00:21:31.760 --> 00:21:37.340
et dire de import device_info, il

00:21:37.340 --> 00:21:40.730
a maintenant importé cette fonction.

00:21:40.730 --> 00:21:43.230
Maintenant, il ne me reste plus qu'à tester.

00:21:43.230 --> 00:21:44.390
Comment tester ça ?

00:21:44.390 --> 00:21:50.430
Je dirais device_info et fournirai les informations,

00:21:50.430 --> 00:21:53.810
qui va être IOS-XE.

00:21:53.810 --> 00:21:58.220
si je dis IOS-XE, qui est l'entrée que je fournis,

00:21:58.220 --> 00:22:03.410
vous devriez voir qu'il doit exécuter cela, et il me donne,

00:22:03.410 --> 00:22:08.840
l'IP de gestion pour R1 est 10.1.1.1,

00:22:08.840 --> 00:22:11.870
et l'IP de gestion pour R3 est 10.1.1.3.

00:22:11.870 --> 00:22:13.820
Encore une fois, j'ai des problèmes d'espacement.

00:22:13.820 --> 00:22:16.490
Je peux revenir à mon script et mettre

00:22:16.490 --> 00:22:26.630
que, alors mettez un espace ici, et mettez un espace ici, est,

00:22:26.630 --> 00:22:29.510
et de l'espace ici aussi.

00:22:29.510 --> 00:22:33.575
Donc une fois que j'ai fait ça, ça devrait aller.

00:22:33.575 --> 00:22:40.580


00:22:40.580 --> 00:22:51.190
Alors sauvegardons ça, et sortons.

00:22:51.190 --> 00:22:52.540
Recopiez ce fichier.

00:22:52.540 --> 00:22:59.730


00:22:59.730 --> 00:23:05.010
Et maintenant, si je retourne à ma machine, Python 3,

00:23:05.010 --> 00:23:09.000
et dire, à partir de l'appareil, qui est mon nom de fichier,

00:23:09.000 --> 00:23:15.060
importer ma fonction appelée en tant que device_info,

00:23:15.060 --> 00:23:21.660
et puis je dis device_info, je suis maintenant

00:23:21.660 --> 00:23:24.900
en fournissant votre entrée en tant qu'IOS-XR.

00:23:24.900 --> 00:23:26.940
Et vous verriez qu'il fondamentalement

00:23:26.940 --> 00:23:29.130
me donne l'IP de R2 et R4.

00:23:29.130 --> 00:23:32.340
Donc vous voyez, j'utilise la fonction, et j'utilise le conditionnel.

00:23:32.340 --> 00:23:35.880
Et j'appelle ma fonction, et j'utilise une boucle for

00:23:35.880 --> 00:23:39.420
pour parcourir en boucle tous mes dictionnaires dans la liste

00:23:39.420 --> 00:23:42.810
et obtenir les informations dont j'ai besoin.

00:23:42.810 --> 00:23:45.660
Avec cela, nous avons terminé notre tâche avec succès.

00:23:45.660 --> 00:23:48.700
Le dernier à tester serait de tester NEXUS.

00:23:48.700 --> 00:23:52.390


00:23:52.390 --> 00:23:55.420
Cela me donne donc l'IP de R5.

00:23:55.420 --> 00:23:57.790
L'adresse IP indique 10.1.1.4.

00:23:57.790 --> 00:23:59.380
Revenons en arrière et vérifions mon script.

00:23:59.380 --> 00:24:00.010
Est-ce que j'ai changé ?

00:24:00.010 --> 00:24:01.270
Je n'ai pas changé cela.

00:24:01.270 --> 00:24:05.320
C'est pourquoi il nous montre toujours 10.1.1.4.

00:24:05.320 --> 00:24:11.250
Mais je peux rapidement copier cela.

00:24:11.250 --> 00:24:13.260
Alors copions cela en retour.

00:24:13.260 --> 00:24:15.930


00:24:15.930 --> 00:24:20.010
Et si je réimporte-- donc si je redonne la commande

00:24:20.010 --> 00:24:24.990
à partir de l'appareil, il doit réimporter cela,

00:24:24.990 --> 00:24:32.850
et je devrais obtenir mon nouveau fichier.

00:24:32.850 --> 00:24:33.350
Allons

00:24:33.350 --> 00:24:36.890
Revenez en arrière et testez le NEXUS.

00:24:36.890 --> 00:24:38.900
Donc je dois sortir, en fait.

00:24:38.900 --> 00:24:39.530
Sortez.

00:24:39.530 --> 00:24:42.260
Revenons à Python 3.

00:24:42.260 --> 00:24:51.290
Réimportons ceci et tapons device nexus.

00:24:51.290 --> 00:24:53.240
Cela devrait me donner 10.1.1.5.

00:24:53.240 --> 00:24:54.840
Avec cela, nous avons satisfait aux exigences.

00:24:54.840 --> 00:24:58.100
Voici donc mon dernier script que j'ai

00:24:58.100 --> 00:25:03.350
avoir ici, c'est là que je crée

00:25:03.350 --> 00:25:07.250
une fonction qui a une boucle for pour parcourir la liste.

00:25:07.250 --> 00:25:09.920
Il y a une autre boucle for à l'intérieur

00:25:09.920 --> 00:25:13.250
pour parcourir les valeurs et l'entrée

00:25:13.250 --> 00:25:15.210
que je donnerais dans la fonction.

00:25:15.210 --> 00:25:20.390
Et si cela correspond, il exécutera l'instruction d'impression.

00:25:20.390 --> 00:25:22.280
J'espère que cette vidéo vous a été instructive,

00:25:22.280 --> 00:25:25.060
et merci d'avoir regardé.

00:25:25.060 --> 00:25:26.000