Objectifs de certification

DEVASC 200-901

  • 1.5 Expliquer les avantages de l’organisation du code en méthodes / fonctions, classes et modules


Programmation Réseau : Python 3, les bases

Introduction

Ce document est une introduction aux concepts de base de la programmation en Python 3 pour un public d’administrateurs réseau et système.

1. Installer un environnement Python3

1.1. Installer Python3

Télécharger Python et l’installer sur son système.

1.2. Installer un IDE

Télécharger Visual Studio Code

Activer l’extension Python dans VS Code.

Installer Jupyter Notebook

1.3. Installer pip

pip est le gestionnaire standard de paquets pour Python. Il vous permet d’installer et de gérer des paquets supplémentaires qui ne font pas partie de la bibliothèque standard de Python.

dnf install python3-pip || apt install python3-pip

1.4. Utiliser les environnements virtuels

Un environnement virtuel Python est un environnement d’exécution isolé (en mode coopératif) qui permet aux utilisateurs de Python et aux applications d’installer et de mettre à jour des paquets sans interférer avec d’autres applications Python fonctionnant sur le même système.1

Le module venv permet de créer des “environnements virtuels” légers avec leurs propres dossiers, éventuellement isolés des dossiers du système. Chaque environnement virtuel a son propre binaire Python (qui correspond à la version du binaire qui a été utilisée pour créer cet environnement) et peut avoir sa propre liste de paquets Python installés dans ses propres dossiers.

Pour créer un environnement virtuel, décidez d’un dossier où vous voulez le placer et exécutez le module venv comme un script avec le chemin du dossier :

mkdir monprojet
cd monprojet/
python -m venv environnement1

La commande python -m venv environnement1 crée le dossier cible environnement1 (en créant tous les dossiers parents qui n’existent pas déjà) et y ajoute un fichier pyvenv.cfg contenant une variable home qui pointe sur l’installation Python depuis laquelle cette commande a été lancée (un nom habituel pour ce dossier cible est .venv). Cela crée également un sous-dossier bin (ou Scripts sous Windows) contenant une copie (ou un lien symbolique) du ou des binaires python (dépend de la plateforme et des paramètres donnés à la création de l’environnement). Elle crée aussi un sous-dossier (initialement vide) lib/pythonX.Y/site-packages (Sous Windows, c’est Lib\site-packages). Si un dossier existant est spécifié, il sera réutilisé.[^creer_venv]

Création d’environnements virtuels

Sous Linux ou MacOS, on peut ensuite activer l’environnement virtuel en “sourçant” le script bin/activate :

source environnement1/bin/activate

L’invite change et apparait ainsi problablement, ce qui vous indique que vous êtes bien dans l’environnement virtuel :

(environnement1) francois@monpc:~/monprojet

Voyez le contenu du dossier environnement1/ :

ls environnement1/
bin  include  lib  lib64  pyvenv.cfg

Pour quitter l’environnement, il suffit d’appeler la fonction deactivate qui est déjà sourcée, c’est-à-dire mise en mémoire :

deactivate

Pour illustrer la singularité d’un environnement virtuel, on propose de créer un environnement virtuel devfun1, de constater avec la commande pip freeze les paquets et modules python3 installés, ici la librairie requests et de créer un fichier de configuration requirements.txt.

python3 -m venv devfun1
source devfun1/bin/activate
pip3 freeze
pip3 install requests
pip3 freeze
pip3 freeze > requirements.txt
deactivate

Ensuite on sortira de cet environnement pour en créer un nouveau appelé devfun2 afin le configurer avec le fichier requirements.txt.

python3 -m venv devfun2
source devfun2/bin/activate
pip3 freeze
pip3 install -r requirements.txt
deactivate

2. Un premier programme

2.1. Lancer le shell interactif

python3
Python 3.9.0 (default, Oct 27 2020, 14:15:17)
[Clang 12.0.0 (clang-1200.0.32.21)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

2.2. Opérations mathématiques de base

OpérationSyntaxe mathématiqueSyntaxe Python
Additiona+ba+b
Soustractiona-ba-b
Multiplicationaxba*b
Divisiona÷ba/b
Exposantsa^ba**b

Dans l’interpréteur Python, veuillez exécuter les opérations mathématiques suivantes :

>>> 240 + 15
255
>>> 255 - 240
15
>>> 15 / 3
5.0
>>> 2 * 4
8
>>> 2 ** 4
16

Python utilise l’ordre suivant pour les opérations mathématiques :

  • Parenthèses
  • Exposants
  • Multiplication et Division
  • Addition et Soustraction

2.3. Imprimer une chaîne de caractère

>>> 'Hello World!'
'Hello World!'
>>> "Hello World!"
'Hello World!'
>>> print("Hello World!")
Hello World!

2.4. Créer un script dans VS Code

Dans VS Code, veuillez créer un nouveau dossier test-python/ dans lequel vous créez un fichier hello-world.py.

Le programme simple contient ceci :

print("Hello World!")

Ensuite veuillez exécuter le script dans VS Code avec le bouton “RUN” :

Hello Word! en Python3 dans VS Code

Remarquez que VS Code crée un environnement virtuel spécifique pour cette exécution.

3. Types de données et de variables

3.1. Types de données de base

NameTypeMutableDescription
IntegerintNonUtilisé pour des nombres entiers (sans décimales), comme 1, 2, 3, et ainsi de suite. Si un entier est entré avec une décimale, l’interpréteur ignore la décimale. Par exemple, 3.75 est interprété comme 3.
FloatfloatNonUtilisé pour des nombres en valeur décimale, comme 3.14159.
BooleanboolNonTout type de données ayant une valeur True ou False.
StringstrNonToute chaîne de caractères tels que des lettres, des chiffres, des symboles ou des signes de ponctuation. On place les valeurs de chaîne entre des guillemets simples ou doubles.
ListlistOuiUne séquence ordonnée d’objets comme [9, "DevNet", 25.6].
TupletupNonUne séquence ordonnée d’objets immutables omme (9, "DevNet", 25.6).
DictionairedictOuiUne collection sans ordre de paires clé:valeur (key:value pairs) comme {"cle1":"valeur1","nom":"R1"}.
SetsetOuiUne collection sans ordre d’objets uniques comme {"a","b"}.

La fonction intégrée type() permet d’identifier le type de valeur (la classe de l’objet) :

>>> type(255)
<class 'int'>
>>> type("255")
<class 'str'>
>>> type("Hello World!")
<class 'str'>
>>> type(False)
<class 'bool'>

3.2. Opérateurs booléens

Les opérateurs booléens permettent de comparer des valeurs et de rendre une réponse booléenne (True ou False).

OpérateurSignification
>Supérieur à
<Inférieur à
==Égal à
!=Différent de
>=Supérieur ou égal à
<=Inférieur ou égal à

Par exemple, on peut évaluer différentes expressions :

>>> 192 == 192
True
>>> 192 <= 128
False
>>> "Hello" == "Hello"
True
>>> "Hello" == "hello"
False
>>> 240 > 224
True

3.3. Affecter des variables

Affecter une variable par une valeur :

>>> base=2
>>> bits=5
>>> base ** bits
32

Dupliquer une chaîne de caractères :

>>> "1 " * bits
'1 1 1 1 1 '

3.4. Concaténer une chaîne de caractères

>>> str1="Hello"
>>> str2="World"
>>> str3="!"
>>> space=" "
>>> print(str1 + space + str2 + str3)
Hello World!

3.5. Les chaines de caractères formatées (f-strings)

Les chaines de caractères formatées (aussi appelées “f-strings”) vous permettent d’inclure la valeur d’expressions Python dans des chaines de caractères en les préfixant avec f ou F et écrire des expressions comme {expression}.2

>>> print(f"{str1} {str2}{str3}")
Hello World!

3.6. Conversion de type de données

Il est parfois nécessaire de convertir des types de données, comme par exemple concaténer une chaîne et un entier.

>>> x=4
>>> print("La valeur de x est : " + x)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

La fonction str() permet de convertir une valeur en chaîne :

>>> print("La valeur de x est : " + str(x))
La valeur de x est : 4

3.7. Réaffecter une variable à un nouveau type de données

>>> type(x)
<class 'int'>
>>> x=str(x)
>>> type(x)
<class 'str'>
>>> print("La valeur de x est : " + x)
La valeur de x est : 4

3.8. Fonction d’entrée input

La fonction input permet valoriser une variable à la suite d’une impression et d’une entrée clavier :

>>> r1_AdresseIP = input("Quelle est l'adresse IP du routeur R1? ")
Quelle est l'adresse IP du routeur R1? 1.1.1.1
>>> print("L'adresse IP du routeur R1 est " + r1_AdresseIP)
L'adresse IP du routeur R1 est 1.1.1.1

4. Conditions

Les instructions conditionnelles vérifient si quelque chose est vrai, si une expression est vraie (if:), puis exécutent des instructions basées sur l’évaluation. Si l’évaluation est fausse (else:), d’autres instructions sont réalisées. Parmi des alternatives, les conditions permettent au programme de faire des choix.

On sera attentif à l’identation :

if <expr>:
    <statement>
else:
    <statement>

Par exemple, en comparant des entiers :

>>> if 3 < 5:
...     print("Ceci est vrai")
...
Ceci est vrai
>>> if 3 < 5 or 5 < 3:
...     print("Ceci est vrai")
...
Ceci est vrai
>>> if 3 < 5 and 5 < 3:
...     print("Ceci est vrai")
...
>>> if 'st' in 'test':
...     print("Ceci est vrai")
...
Ceci est vrai

Opérateurs logiques

Vérification d’une équivalence :

Script check-native-vlan.py :

nativeVLAN = 1
dataVLAN = input("Quel est le numéro de VLAN data? ")
if nativeVLAN == dataVLAN:
    print("Le VLAN natif et le VLAN data sont identiques")
else:
    print("Le VLAN natif et le VLAN data sont différents")

Opérateurs mathématiques :

Script check-acls.py :

aclNum = int(input("Quel est le numéro d'ACL IPv4? "))
if aclNum >= 1 and aclNum <= 99:
    print("C'est une ACL IPv4 Standard")
elif aclNum >=100 and aclNum <= 199:
    print("C'est une ACL IPv4 Etendue")
else:
    print("Ce n'est ni une ACL IPv4 Standard ou une ACL IPv4 Etendue")

5. Listes et dictionnaires

5.1. Créer une liste

Une liste est un type de variable utilisée pour stocker plusieurs éléments d’informations ordonnés, identifiés par un “index” (un indice). On les appelle aussi “tableaux”.

Une liste est créée en Python :

  • entre des crochets,
  • les valeurs sont contenues entre des guillemets !!!
  • et sont séparées par des virgules.
>>> hostnames=["R1","R2","R3","S1","S2"]
>>> type(hostnames)
<class 'list'>
>>> len(hostnames)
5

5.2. Manipuler une liste avec un index

Un élément d’une liste peut être référencé et manipulé à l’aide de son index (ou son indice) dans la liste.

Ici on affiche le premier élément de la liste, le quatrième et le dernier :

>>> print(hostnames)
['R1', 'R2', 'R3', 'S1', 'S2']
>>> hostnames[0]
'R1'
>>> hostnames[3]
'S1'
>>> hostnames[-1]
'S2'

Ici, on modifie la valeur du troisième élément de la liste :

>>> hostnames[2]="RR3"
>>> hostnames[2]
'RR3'

Ici, on utilise la commande del pour retirer le cinquième élément de la liste :

>>> del hostnames[4]
>>> hostnames
['R1', 'R2', 'RR3', 'S1']

5.3. Manipuler une liste avec une fonction ou une méthode ?

Voici un exemple entre une fonction et une méthode intégrées qui sont appliquées à un objet comme notre liste :

  • De manière procédurale, on peut appliquer une fonction sur un objet. Celui-ci ne change pas.
  • A la manière “objet”, on peut utiliser une méthode peut agir sur l’objet. Celui change avec l’opération.

5.4. Trier / inverser une liste

Ici on applique la fonction intégrée sorted() sur la liste ainsi que la méthode intégrée objet.sort(). Voyez la différence opérationnelle.

>>> hostnames=["R1","R2","R3","S1","S2"]
>>> print(hostnames)
['R1', 'R2', 'R3', 'S1', 'S2']
>>> print(sorted(hostnames,reverse=True))
['S2', 'S1', 'R3', 'R2', 'R1']
>>> print(hostnames)
['R1', 'R2', 'R3', 'S1', 'S2']
>>> hostnames.sort(reverse=True)
>>> print(hostnames)
['S2', 'S1', 'R3', 'R2', 'R1']

La documentation des fonctions et méthodes intégrées pour les listes peuvent être consultée avec help(list) dir(list).

5.5. Créer un dictionnaire

Les dictionnaires sont des listes d’objets non ordonnées. Chaque objet contient une paire clé/valeur.

Un dictionnaire est créé avec une collection d’entrées non ordonnées séparées par une virgule entre accolades. Chaque entrée du dictionnaire comprend une clé et une valeur, entre guillemets (ce sont des chaînes), séparées par un deux-points.

Par exemple ce dictionnaire ipAddress avec trois entrées clé/valeur pour préciser l’adresse IP de trois routeurs :

>>> ipAddress={"R1":"10.0.0.1","R2":"10.0.1.1","R3":"10.0.2.1"}
>>> type(ipAddress)
<class 'dict'>

5.6. Manipuler un dictionnaire

Contrairement aux listes, on ne peut pas référencer un objet d’un dictionnaire avec un index. On référence un objet d’un dictionnaire avec une clé.

On désigne la clé entre des guillemets avec des crochets :

>>> ipAddress
{'R1': '10.0.0.1', 'R2': '10.0.1.1', 'R3': '10.0.2.1'}
>>> ipAddress["R1"]
'10.0.0.1'

5.7. Ajouter un élément à dictionnaire

>>> ipAddress["R4"]="10.0.3.1"
>>> ipAddress
{'R1': '10.0.0.1', 'R2': '10.0.1.1', 'R3': '10.0.2.1', 'R4': '10.0.3.1'}

5.8. Objets imbriqués

Les clé/valeur peuvent contenir n’importe quel autre type d’objet en ce compris des listes et des dictionnaires.

Imaginons que le routeur R2 dispose de trois adresses au lieu d’une seule :

>>> ipAddress["R2"]
'10.0.1.1'
>>> ipAddress["R2"]=["10.0.1.1","10.1.1.1","10.2.1.1"]
>>> ipAddress["R2"]
['10.0.1.1', '10.1.1.1', '10.2.1.1']
>>> ipAddress
{'R1': '10.0.0.1', 'R2': ['10.0.1.1', '10.1.1.1', '10.2.1.1'], 'R3': '10.0.2.1', 'R4': '10.0.3.1'}

6. Boucles

6.1. Boucle For

La fonction for est utilisée pour boucler à travers les éléments d’une liste ou effectuer une opération sur une série de valeurs.

Script loop-for.py :

devices=["R1","R2","R3","S1","S2"]
for device in devices:
    print(device)

6.2. Trouver un élément dans une liste

devices=["R1","R2","R3","S1","S2"]
for device in devices:
    if "S" in device:
        print(device)

6.3. Ajouter un élément dans une liste

switches=[]
devices=["R1","R2","R3","S1","S2"]
for device in devices:
    if "S" in device:
        switches.append(device)
print(switches)

6.4. Retirer un élément d’une liste

6.5. Enumérer avec la fonction range()

Fonction range() :

for x in range(3):
    print(x)

6.6. Boucle While

Une boucle while continue d’exécuter un programme tant qu’une expression booléenne reste vraie.

Script loop-while.py :

x=input("Entrez une valeur maximum: ")
x=int(x)
y=1
while True:
    print(y)
    y=y+1
    if y>x:
        break

Ajout d’une fonctionnalité pour sortir du programme :

while True:
    x=input("Entrez une valeur maximum: ")
    if x == 'q' or x == 'quitter':
        break

    x=int (x)
    y=1
    while True:
        print(y)
        y=y+1
        if y>x:
            break

6.7. Itération des dictionnaires à l’aide de boucles for

ipAddress={"R1":"10.0.0.1","R2":"10.0.1.1","R3":"10.0.2.1"}

for routeur, adresse in ipAddress.items():
    print(f"Le routeur {routeur} dispose de l'adresse {adresse}")

6.8. Convertir deux listes en un seul dictionnaire

Pour convertir deux listes en un seul dictionnaire, on peut utiliser le constructeur dict() avec la fonction zip() :

cles = ["R1","R2","R3"]
valeurs = ["10.0.0.1","10.0.1.1","10.0.2.1"]
ipAddress = dict(zip(cles, valeurs))
print(ipAddress)

9. Fonctions, méthodes et classes

Les méthodes et les fonctions s’écrivent toutes en Python en commençant par le mot def.

9.1. En quoi les méthodes et les fonctions sont-elles différentes en Python ?

En quoi les méthodes et les fonctions sont-elles différentes en Python ?3

En général, les méthodes sont des fonctions qui appartiennent à une classe, les fonctions peuvent être sur n’importe quelle autre portée du code, on pourrait donc dire que toutes les méthodes sont des fonctions, mais que toutes les fonctions ne sont pas des méthodes. Par exemple :

class Door:
  def open(self):
    print("hello stranger")

def knock_door():
  a_door = Door()
  Door.open(a_door)

knock_door()

L’exemple présenté montre une classe appelée “Door” qui a une méthode ou une action appelée “open”, elle est appelée méthode parce qu’elle a été déclarée à l’intérieur d’une classe.

Il y a une autre portion de code avec “def” juste en dessous qui définit une fonction. C’est une fonction parce qu’elle n’est pas déclarée à l’intérieur d’une classe. Cette fonction appelle la méthode définie à l’intérieur de la classe et enfin la fonction est appelée par elle-même.

En effet, on peut appeler une fonction n’importe où, mais si on veut appeler une méthode, soit il faut passer un nouvel objet du même type que la classe dans laquelle la méthode est déclarée “(Class.method(object))”, soit il faut invoquer la méthode à l’intérieur de l’objet “(object.Method())”, du moins en python.

Les méthodes sont des choses qu’une seule entité peut faire, donc si on a une classe “Chien”, il serait logique d’avoir une fonction d’aboiement uniquement dans cette classe et ce serait une méthode. Si vous avez aussi une classe “Personne”, il serait logique d’écrire une fonction “nourrir” pour ce qui n’appartient à aucune classe puisque les humains et les chiens peuvent être alimentés et vous pourriez appeler cela une fonction puisqu’elle n’appartient à aucune classe en particulier.

9.2. Qu’est-ce qu’une fonction ?

Une fonction est un bout de code défini indépendamment qui est appelé par son nom. Dans l’exemple suivant, la fonction appelée FunctionName est définie puis appelée. Etant indépendante, la fonction n’est encapsulée dans aucun autre code.

# Définir une fonction
def functionName():
    #bloc de code...
    print("fait quelque chose")

# Appel à une fonction
functionName()
def knock_door():
  print("hello stranger")

knock_door()

9.3. Qu’est-ce qu’une méthode ?

Une méthode ne peut pas être appelée par elle-même. Elle dépend de l’objet dans lequel elle est définie. Dans l’exemple suivant, la classe ClassName est déclarée et trois méthodes sont définies. La classe est instanciée, puis chaque méthode de la classe est appelée.

# Définir une classe
class className:
    # Définir une méthode
    def method1Name(self):
        #bloc de code...
        print("fait une chose")
    # Définir une autre méthode
    def method2Name(self):
        #bloc de code...
        print("fait autre chose")
    # Définir encore une autre méthode
    def method3Name(self):
        #bloc de code...
        print("fait encore autre chose")

# Instancier la classe
myClass = className()

# Appeler l'instanciation et les méthodes associées
myClass.method1Name()
myClass.method2Name()
myClass.method3Name()

9.4. Arguments et paramètres

Une autre caractéristique des méthodes et des fonctions est la possibilité d’exécuter le code en fonction des valeurs des variables transmises lors de l’exécution. Ce sont des arguments. Afin d’utiliser des arguments lors de l’appel d’une méthode ou d’une fonction, la méthode ou la fonction doit être écrite pour accepter ces variables comme paramètres.

# Define the function
def functionName(parameter1,...,parameterN):
  # You can use the parameters just like local variables
  ...blocks of code...
# Call the function
functionName("argument1", 4, {"argument3":"3"})

9.5. Déclarations de retour

Les méthodes et les fonctions effectuent des tâches et peuvent également renvoyer une valeur.

# Define the function
def functionName(parameter1,...,parameterN):
  # You can use the parameters just like local variables
  ...blocks of code...
  someVariable = parameter1 * parameter2
  return someVariable
# Call the function
myVariable = functionName("argument1", 4, {"argument3":"3"})

9.6. Définir une fonction

Script maVille.py

def maVille(ville):
     print("Je vis à " + ville + ".")

maVille("Paris")
maVille("Bruxelles")
maVille("Casablanca")
def maVille(ville):
     print("Je vis à " + ville + ".")

villes=["Paris","Bruxelles","Casablanca"]
for ville in villes:
    maVille(ville)

9.7. Classe

Les classes sont un moyen de grouper les données et les fonctionnalités. Chaque déclaration de classe définit un nouveau type d’objet.

L’encapsulation des fonctionnalités avec le stockage des données dans une structure unique permet également d’obtenir un aspect d’abstraction des données. Les fonctions définies dans une classe sont appelées méthodes de classe.

Les classes peuvent avoir des variables de classe et des variables d’objet. Au fur et à mesure qu’un nouvel objet de classe est créé, de nouveaux membres de données de classe et membres de données d’objet (variables) sont créés.

De nouvelles classes peuvent être définies, en fonction des classes existantes précédemment définies, de sorte qu’elles héritent des propriétés, des membres de données et des fonctionnalités (méthodes).

Comme avec d’autres structures de données et variables en Python, les objets sont instanciés (créés) au fur et à mesure qu’ils sont utilisés pour la première fois, plutôt que d’être prédéclarés. Une classe peut être instanciée (créée) plusieurs fois, et chacune avec ses propres valeurs d’attribut de données spécifiques à l’objet. En dehors de la portée du nom de classe, les méthodes de classe et les attributs de données sont référencés à l’aide de la notation pointée: [class instance].[method name].

9.8. Définir une classe avec des méthodes

Une classe Python est utilisée pour créer des objets qui ont des propriétés et des méthodes. Toutes les classes Python incluent généralement une fonction __init__ () explicitement définie, bien que vous puissiez créer une classe sans en définir une. La fonction __init__ () est toujours initiée lorsqu’une classe est instanciée. Instancier une classe crée une copie de la classe qui hérite de toutes les variables et méthodes de classe.

Remarque : Bien qu’elle soit parfois appelée la “fonction” __init__ (), elle dépend de la classe. Par conséquent, elle est techniquement une méthode.

Script monEndroit.py

# Définir une classe avec des variables pour **nom** et **pays**
# Ensuite, définir une méthode qui appartient à la classe.
# L'objectif de la méthode est d'imprimer une phrase qui utilise les variables.
class Endroit:
    def __init__(self, nom, pays):
        self.nom = nom
        self.pays = pays

    def monEndroit(self):
        print("Salut, mon nom est " + self.nom + " et je vis en " + self.pays + ".")

# Première instanciation de la classe Endroit
endroit1 = Endroit("Francois", "Belgique")
# Appel d'une méthode pour la classe instanciée
endroit1.monEndroit()

# Trois instanciations supplémentaires
# et des appels de méthode pour la classe Endroit
endroit2 = Endroit("Mathieu", "France")
endroit3 = Endroit("Jean", "Congo")
endroit2.monEndroit()
endroit3.monEndroit()
votre_endroit = Endroit("Votre_Nom", "Votre_pays")
votre_endroit.monEndroit()

7. Accès aux fichiers

La fonction open() peut être utilisée pour accéder à un fichier en utilisant la syntaxe suivante :

open(name, [mode])

Le paramètre name est le nom du fichier à ouvrir. Si le fichier se trouve dans un répertoire différent de celui de votre script, vous devrez également fournir des informations sur le chemin d’accès. Les paramètres de mode :

  • r - lire le fichier (mode par défaut si le mode est omis), génère une erreur si le fichier n’existe pas.
  • w - écrire sur le fichier, en remplaçant le contenu du fichier, crée le fichier s’il n’existe pas.
  • a - ajouter au fichier, le crée s’il n’existe pas.
  • x - crée le fichier spécifié, renvoie une erreur si le fichier existe
  • t - texte - Valeur par défaut. Mode texte
  • b - binaire - Mode binaire (par exemple des images)

Créer un fichier devices.txt, en Bash :

cat << EOF > devices.txt
Cisco 819 Router
Cisco 881 Router
Cisco 888 Router
Cisco 1100 Router
Cisco 4321 Router
Cisco 4331 Router
Cisco 4351 Router
Cisco 2960 Catalyst Switch
Cisco 3850 Catalyst Switch
Cisco 7700 Nexus Switch
Cisco Meraki MS220-8 Cloud Managed Switch
Cisco Meraki MX64W Security Appliance
Cisco Meraki MX84 Security Appliance
Cisco Meraki MC74 VoIP Phone
Cisco 3860 Catalyst Switch
EOF
file=open("devices.txt","r")
for line in file:
    print(line)
file.close()
file=open("devices.txt","r")
for line in file:
   line=line.strip()
   print(line)
file.close()
devices=[]
file=open("devices.txt","r")
for line in file:
   line=line.strip()
   devices.append(line)
file.close()
print(devices)

8. Arguments du script

Le module Python sys fournit parmi d’autres possibiltés une manière d’accéder aux arguments de la ligne de commande avec sys.argv qui offre la liste des paramètres. La fonction len(sys.argv) compte le nombre d’arguments. Le premier élément de la liste sys.argv[0].

#!/usr/bin/env python3
if __name__=="__main__":
    import sys
    if len(sys.argv) == 2:
        (adresse, cidr) = sys.argv[1].split('/')
        adresse = [int(x) for x in adresse.split(".")]
        cidr = int(cidr)
        masque = [int((m>>(3-i)*8)&255) for i,m in enumerate([-1<<(32-cidr)]*4)]
    elif len(sys.argv) == 3:
        adresse = [int(x) for x in sys.argv[1].split(".")]
        masque = [int(x) for x in sys.argv[2].split(".")]
        cidr = sum((bin(x).count('1') for x in masque))
    else:
        print(f"Usage: {sys.argv[0]} <adresse/cidr>")
        print(f"       {sys.argv[0]} <adresse> <masque>")
        sys.exit(-1)

    print(f"Adresse: {adresse}")
    print(f"Masque: {masque}")
    print(f"Cidr: {cidr}")

9. Gestion des erreurs

https://docs.python.org/fr/3/tutorial/errors.html

def nombre(nombre):
    print("Nous vérifions un nombre entier comme argument")
    try:
        return int(nombre)
    except:
        print("Une erreur est intervenue.")
    else:
        print("L'argument est bien un nombre entier.")
    finally:
        print("Le programme continue !")

nombre("test")
nombre(5)

10. Modules Python

Les modules sont un moyen de construire des morceaux de code indépendants et autonomes qui peuvent être réutilisés. Les développeurs utilisent généralement des modules pour diviser un grand projet en petites parties. De cette façon, le code est plus facile à lire et à comprendre, et chaque module peut être développé en parallèle sans conflits. Un module est empaqueté sous la forme d’un seul fichier. En plus d’être disponible pour l’intégration avec d’autres modules, il devrait fonctionner indépendamment.

Un module se compose d’un ensemble de fonctions et contient généralement une interface pour d’autres modules à intégrer. Il s’agit essentiellement d’une bibliothèque et ne peut pas être instanciée.

Exemple …

11. Script Python