WEBVTT 00:00:00.000 --> 00:00:10.560 00:00:10.560 --> 00:00:12.690 Bonjour et bienvenue à l'INE. 00:00:12.690 --> 00:00:15.540 Aujourd'hui, dans cette vidéo, nous allons nous intéresser à la boucle for. 00:00:15.540 --> 00:00:17.970 Maintenant, la boucle for est, fondamentalement, un mécanisme 00:00:17.970 --> 00:00:21.400 itérer sur une liste d'objets, 00:00:21.400 --> 00:00:22.870 qui peut être à l'intérieur d'une liste. 00:00:22.870 --> 00:00:24.390 Par exemple, disons si vous voulez 00:00:24.390 --> 00:00:27.420 passer par peut-être certaines conditions 00:00:27.420 --> 00:00:31.380 et vous voulez parcourir la liste un par un 00:00:31.380 --> 00:00:34.170 et les parcourir tous, vous pouvez alors utiliser une boucle for. 00:00:34.170 --> 00:00:37.680 Fondamentalement, c'est une condition qui peut être exécutée à plusieurs reprises 00:00:37.680 --> 00:00:39.000 jusqu'à ce qu'il se termine. 00:00:39.000 --> 00:00:41.370 Alors aujourd'hui, dans cette vidéo, nous allons regarder 00:00:41.370 --> 00:00:44.100 à quelques exemples de boucle for et comment nous pouvons réellement configurer 00:00:44.100 --> 00:00:46.690 cela et comment nous pouvons l'utiliser. 00:00:46.690 --> 00:00:48.360 Voyons donc quelques-uns. 00:00:48.360 --> 00:00:49.950 Alors ce que je vais faire, c'est que je vais 00:00:49.950 --> 00:00:53.160 vous montrer quelques exemples de base d'une boucle for 00:00:53.160 --> 00:00:56.200 et comment il peut être utilisé. 00:00:56.200 --> 00:00:59.460 Passons donc à Python. 00:00:59.460 --> 00:01:03.330 Et créons une variable peut-être de type list 00:01:03.330 --> 00:01:05.440 et peut-être avoir des cordes à l'intérieur. 00:01:05.440 --> 00:01:10.590 Alors peut-être que je crée une variable appelée devices equals. 00:01:10.590 --> 00:01:12.090 Et mettons des cordes. 00:01:12.090 --> 00:01:15.250 Disons R1, virgule. 00:01:15.250 --> 00:01:25.410 Disons R2, virgule, R3, virgule, R4, virgule, et disons 00:01:25.410 --> 00:01:27.090 pare-feu 1. 00:01:27.090 --> 00:01:32.820 J'ai donc ces cinq chaînes dans ma liste. 00:01:32.820 --> 00:01:37.230 Maintenant, normalement, si j'étais-- si je voulais imprimer ceci, 00:01:37.230 --> 00:01:41.520 oui, je pourrais faire des périphériques d'impression. 00:01:41.520 --> 00:01:43.447 Je pourrais faire quelque chose comme ça. 00:01:43.447 --> 00:01:45.030 Mais le truc c'est que, oui, ça va 00:01:45.030 --> 00:01:50.700 pour imprimer R1, R2, R3, R4, R5, R4 et le pare-feu 1 sous forme de liste. 00:01:50.700 --> 00:01:54.550 Mais disons que si nous voulions que la sortie soit imprimée... 00:01:54.550 --> 00:01:57.030 donc je veux que la sortie soit imprimée. 00:01:57.030 --> 00:01:59.940 Dans ce cas, je devrais donner quelque chose comme print, 00:01:59.940 --> 00:02:06.880 et je dirais le numéro d'index des appareils 0, et l'imprimer. 00:02:06.880 --> 00:02:08.259 Donc dans ce cas, j'obtiendrais R1. 00:02:08.259 --> 00:02:11.160 Donc, dans ce cas, je devrais donner cinq fois. 00:02:11.160 --> 00:02:13.530 Je devrais donner la déclaration d'impression cinq fois 00:02:13.530 --> 00:02:14.980 pour chaque valeur d'indice. 00:02:14.980 --> 00:02:16.890 Donc, ce que je peux faire, c'est que je peux utiliser une boucle for 00:02:16.890 --> 00:02:20.520 pour parcourir toute la liste et les imprimer-- 00:02:20.520 --> 00:02:22.688 fondamentalement, tous, imprimez-les tous. 00:02:22.688 --> 00:02:23.980 Permettez-moi, en fait, de vous montrer cela. 00:02:23.980 --> 00:02:27.450 Donc, pour faire une boucle for, vous donnez la commande "for" 00:02:27.450 --> 00:02:34.050 et donner un nom de valeur de boucle for, comme an-- 00:02:34.050 --> 00:02:36.630 il pourrait s'agir d'un nom de fonction, comme nous avions... 00:02:36.630 --> 00:02:39.400 pour la fonction, nous avions def et un nom de fonction. 00:02:39.400 --> 00:02:42.430 Donc ici, nous aurions pour et le nom de la boucle. 00:02:42.430 --> 00:02:45.300 Alors donnons n'importe quoi, disons un objet. 00:02:45.300 --> 00:02:50.770 Pour l'élément dans les appareils, qui est mon nom de variable-- 00:02:50.770 --> 00:02:52.320 donc ça peut être n'importe quoi. 00:02:52.320 --> 00:02:55.410 Vous pouvez simplement choisir n'importe quoi pour l'article et les appareils. 00:02:55.410 --> 00:02:59.190 Et puis à l'intérieur de cela, assurez-vous que votre itération est terminée 00:02:59.190 --> 00:03:00.980 correctement, votre-- 00:03:00.980 --> 00:03:03.910 fondamentalement, votre indentation est faite correctement. 00:03:03.910 --> 00:03:05.820 Je vais donc avoir quatre places. 00:03:05.820 --> 00:03:11.830 Et ici, je dirais article imprimé. 00:03:11.830 --> 00:03:14.430 Donc, si je dis l'élément d'impression et que j'appuie sur Entrée, 00:03:14.430 --> 00:03:17.670 vous verriez qu'il imprime essentiellement R1, R2, R3, 00:03:17.670 --> 00:03:20.440 R4 et pare-feu 1 en même temps. 00:03:20.440 --> 00:03:23.460 Vous voyez donc à quel point il devient facile d'utiliser une boucle for où 00:03:23.460 --> 00:03:26.910 Je peux passer en revue chacun des éléments de cette liste 00:03:26.910 --> 00:03:28.840 et imprimez-les. 00:03:28.840 --> 00:03:32.520 Donc, c'était assez simple où nous disons pour, 00:03:32.520 --> 00:03:36.870 un nom dans les appareils, qui est celui-ci, qui est mon nom de variable. 00:03:36.870 --> 00:03:38.160 Et puis je dis article imprimé. 00:03:38.160 --> 00:03:40.310 Donc, il imprime chacun d'eux. 00:03:40.310 --> 00:03:42.660 Il passe par une boucle et imprime chacun d'eux 00:03:42.660 --> 00:03:45.390 jusqu'à ce qu'il se termine. 00:03:45.390 --> 00:03:46.600 Voyons un autre exemple. 00:03:46.600 --> 00:03:48.250 C'était un exemple assez basique. 00:03:48.250 --> 00:03:49.720 Voyons un autre exemple. 00:03:49.720 --> 00:03:54.150 Alors peut-être que cette fois, nous créons une autre variable 00:03:54.150 --> 00:03:56.010 de type liste, qui contient des chaînes. 00:03:56.010 --> 00:03:59.730 Peut-être que nous avons quelques interfaces des routeurs. 00:03:59.730 --> 00:04:04.930 Et combinons peut-être une condition avec cela. 00:04:04.930 --> 00:04:07.980 Donc, dans la boucle for, j'aurais des conditions if. 00:04:07.980 --> 00:04:09.880 Essayons de faire ça. 00:04:09.880 --> 00:04:11.380 Alors créons ça. 00:04:11.380 --> 00:04:15.300 Donc, ce que je vais faire, c'est créer une variable appelée 00:04:15.300 --> 00:04:16.320 comme interfaces. 00:04:16.320 --> 00:04:18.990 Cette variable serait de type list-- 00:04:18.990 --> 00:04:23.670 est donc égal à une liste, qui contient des chaînes. 00:04:23.670 --> 00:04:33.150 Disons que j'ai une chaîne appelée GigabitEthernet 1 par 1. 00:04:33.150 --> 00:04:40.020 Disons que j'en ai un de plus, qui est Loopback0. 00:04:40.020 --> 00:04:48.320 Disons que j'en ai un de plus, qui est GigabitEthernet 1 par 2. 00:04:48.320 --> 00:04:55.430 J'en ai un de plus, qui sera, disons, TenGigabit... 00:04:55.430 --> 00:04:58.870 00:04:58.870 --> 00:05:04.420 peut-être 10GigabitEthernet 1 par 1. 00:05:04.420 --> 00:05:12.320 Et disons que j'ai une interface appelée Vlan100. 00:05:12.320 --> 00:05:16.400 J'ai donc une liste ici, qui essentiellement 00:05:16.400 --> 00:05:21.140 dit que cette interface est égale à certaines chaînes. 00:05:21.140 --> 00:05:24.020 J'ai GigabitEthernet 1 par 1. 00:05:24.020 --> 00:05:26.045 J'ai Loopback0, GigabitEthernet 1 00:05:26.045 --> 00:05:31.650 par 2, 10GigabitEthernet et Vlan100. 00:05:31.650 --> 00:05:33.278 Ce ne sont donc que des chaînes. 00:05:33.278 --> 00:05:34.820 Maintenant, ce que je vais faire, c'est que je vais 00:05:34.820 --> 00:05:38.630 pour créer une boucle for, qui passe par toutes ces chaînes 00:05:38.630 --> 00:05:41.570 et fait peut-être une déclaration d'impression pour moi, qui 00:05:41.570 --> 00:05:46.880 dit le type d'interface de GigabitEthernet 1 par 1 00:05:46.880 --> 00:05:49.580 est Gigabit. 00:05:49.580 --> 00:05:52.970 Peut-être que pour le bouclage, il indique le type d'interface pour Loopback0 00:05:52.970 --> 00:05:53.960 est le bouclage. 00:05:53.960 --> 00:05:55.760 Donc je veux imprimer quelque chose comme ça. 00:05:55.760 --> 00:05:57.650 Maintenant, oui, je pourrais faire chacun d'eux 00:05:57.650 --> 00:05:59.150 individuellement - imprimez les relevés. 00:05:59.150 --> 00:06:02.150 Mais imaginez si j'avais des milliers d'entrées dans ma liste. 00:06:02.150 --> 00:06:04.730 Cela pourrait donc être un problème ou un défi. 00:06:04.730 --> 00:06:06.390 L'évolutivité pourrait être un problème. 00:06:06.390 --> 00:06:08.540 Je peux donc utiliser une boucle for pour parcourir tout 00:06:08.540 --> 00:06:12.810 les éléments à l'intérieur de la liste et imprimez-les tous ensemble. 00:06:12.810 --> 00:06:16.230 Permettez-moi, en fait, de vous montrer comment nous pouvons le faire. 00:06:16.230 --> 00:06:20.870 Donc, une fois que j'ai créé la variable, je créerais-- 00:06:20.870 --> 00:06:22.580 Je ferais une boucle for, ce qui est fait 00:06:22.580 --> 00:06:25.140 avec la commande pour un nom-- 00:06:25.140 --> 00:06:30.110 disons pour l'élément dans les interfaces. 00:06:30.110 --> 00:06:36.800 En cela, je dirais si l'élément point inférieur, qui est, encore une fois, 00:06:36.800 --> 00:06:37.830 une méthode intégrée-- 00:06:37.830 --> 00:06:40.370 donc si l'élément point inférieur, qui est en minuscule-- 00:06:40.370 --> 00:06:45.470 si l'élément point le point inférieur commence par-- 00:06:45.470 --> 00:06:53.870 si ça commence par, disons, gigabit-- 00:06:53.870 --> 00:07:00.510 si ça commence par GIG, alors je veux que tu... 00:07:00.510 --> 00:07:06.300 faisons du côlon-- alors je veux que tu stockes peut-être 00:07:06.300 --> 00:07:08.018 l'information comme une variable. 00:07:08.018 --> 00:07:09.310 Permettez-moi, en fait, de vous montrer cela. 00:07:09.310 --> 00:07:11.280 Alors disons que je dis soulignement de l'interface 00:07:11.280 --> 00:07:15.540 type est égal à GigabitEthernet. 00:07:15.540 --> 00:07:20.270 00:07:20.270 --> 00:07:31.920 Faisons-en un de plus, qui indique si le point inférieur de l'élément commence par 00:07:31.920 --> 00:07:33.930 boucle-- donc boucle-- 00:07:33.930 --> 00:07:40.420 stocker les informations en tant que Loopback. 00:07:40.420 --> 00:07:42.370 Si ça commence par... 00:07:42.370 --> 00:07:45.280 faisons un de plus. 00:07:45.280 --> 00:07:56.880 Si ça commence par peut-être, disons, vlan... 00:07:56.880 --> 00:08:03.450 s'il commence par vlan, stockez-le en tant que VLAN. 00:08:03.450 --> 00:08:07.740 Et puis j'aurais une instruction else pour tout le reste. 00:08:07.740 --> 00:08:13.560 Sinon, vous stockeriez le type d'interface égal à -- 00:08:13.560 --> 00:08:14.445 disons inconnu. 00:08:14.445 --> 00:08:17.340 00:08:17.340 --> 00:08:18.910 Et maintenant, faisons une déclaration d'impression. 00:08:18.910 --> 00:08:21.450 Alors imprimez-- qu'est-ce que je veux imprimer ? 00:08:21.450 --> 00:08:27.690 Je veux imprimer que le type d'interface de l'élément, 00:08:27.690 --> 00:08:34.409 qui est GigabitEthernet 1 par 1, est Gigabit, GigabitEthernet. 00:08:34.409 --> 00:08:37.919 Et le type d'interface pour Loopback0 est loopback. 00:08:37.919 --> 00:08:39.789 Je vais donc utiliser une déclaration d'impression. 00:08:39.789 --> 00:08:41.760 Et si vous vous souvenez de la chaîne de format, 00:08:41.760 --> 00:08:44.550 Je peux utiliser la chaîne de format ou même la méthode de format intégrée 00:08:44.550 --> 00:08:46.470 pour créer réellement la chaîne d'impression. 00:08:46.470 --> 00:08:50.520 Donc je dirais imprimer la chaîne de format 00:08:50.520 --> 00:09:02.420 et dites le type d'interface de, et vos accolades-- 00:09:02.420 --> 00:09:05.630 J'appellerais mon élément de boucle for-- 00:09:05.630 --> 00:09:13.850 est-- et encore une fois, appelez mon type d'interface, qui va 00:09:13.850 --> 00:09:17.090 être INT, trait de soulignement, type. 00:09:17.090 --> 00:09:17.900 C'est ça. 00:09:17.900 --> 00:09:21.080 Donc, ce que nous faisons en réalité, c'est que... tout ce qu'il y a à l'intérieur 00:09:21.080 --> 00:09:25.415 ici, item, va être remplacé par GigabitEthernet 1 00:09:25.415 --> 00:09:29.510 par 1 ou Loopback0 ou GigabitEthernet 1 par 2, 00:09:29.510 --> 00:09:32.720 10GigabitEthernet 1 par 1, VLAN100. 00:09:32.720 --> 00:09:34.550 Et tout ce qui était à l'intérieur va 00:09:34.550 --> 00:09:37.640 à prendre à partir de celui auquel il correspond. 00:09:37.640 --> 00:09:40.730 Alors, en fait, faisons cela comme un autre/si. 00:09:40.730 --> 00:09:45.690 Alors sinon/si, sinon/si, et sinon... 00:09:45.690 --> 00:09:47.790 alors essayons d'imprimer ceci. 00:09:47.790 --> 00:09:48.770 Alors prends ça. 00:09:48.770 --> 00:09:57.870 Retournez à Python et imprimons ceci 00:09:57.870 --> 00:09:59.820 et voir si ma boucle for fonctionne. 00:09:59.820 --> 00:10:01.090 Que devrions-nous obtenir ? 00:10:01.090 --> 00:10:03.900 Nous devrions obtenir la déclaration d'impression plusieurs fois. 00:10:03.900 --> 00:10:05.880 L'élément - la boucle for devrait aller 00:10:05.880 --> 00:10:10.890 parcourez tous les éléments de la liste et imprimez-la pour moi. 00:10:10.890 --> 00:10:11.790 Voyons ça. 00:10:11.790 --> 00:10:14.570 00:10:14.570 --> 00:10:21.370 Donc, une fois que j'ai cliqué sur Imprimer, je vois que le type d'interface est... 00:10:21.370 --> 00:10:23.350 il y a une erreur dans mon code. 00:10:23.350 --> 00:10:27.140 Let's-- oh, ce n'est pas une ficelle. 00:10:27.140 --> 00:10:29.110 Alors revenons. 00:10:29.110 --> 00:10:33.910 J'espère que cette fois, je n'ai pas d'erreur. 00:10:33.910 --> 00:10:38.200 Imprimons et appuyez sur Entrée. 00:10:38.200 --> 00:10:39.530 Que voyons-nous ? 00:10:39.530 --> 00:10:45.280 Nous voyons donc que le type d'interface de GigabitEthernet 1 par 1 00:10:45.280 --> 00:10:46.990 est GigabitEthernet. 00:10:46.990 --> 00:10:50.020 Le type d'interface pour Loopback0 est Loopback0. 00:10:50.020 --> 00:10:52.360 Le type d'interface pour GigabitEthernet 1 par 2 00:10:52.360 --> 00:10:53.650 est GigabitEthernet. 00:10:53.650 --> 00:10:57.910 Et le type d'interface pour 10GigabitEthernet 1 par 1 00:10:57.910 --> 00:11:01.880 est inconnu car je n'ai pas précisé autre chose/si 00:11:01.880 --> 00:11:04.130 pour faire correspondre 10Gigabit. 00:11:04.130 --> 00:11:05.890 Cela correspond donc à l'instruction else. 00:11:05.890 --> 00:11:10.030 Et le type d'interface de Vlan100 est VLAN. 00:11:10.030 --> 00:11:13.120 Donc, vous voyez que j'utilise une boucle for pour parcourir tout 00:11:13.120 --> 00:11:14.740 les éléments à l'intérieur de la liste. 00:11:14.740 --> 00:11:21.130 Et je donne l'action qui, si elle correspond, 00:11:21.130 --> 00:11:24.820 Je crée une variable, qui est égale à une chaîne, 00:11:24.820 --> 00:11:27.860 puis en appelant cette chaîne dans mon instruction d'impression. 00:11:27.860 --> 00:11:30.460 J'ai donc utilisé avec succès une boucle for. 00:11:30.460 --> 00:11:32.410 J'espère que cette vidéo vous a été instructive, 00:11:32.410 --> 00:11:34.845 et merci d'avoir regardé. 00:11:34.845 --> 00:11:35.345