PYTHON
BLOCS D'INSTRUCTIONS

Introduction

L'objectif principal de ce TP est d'étudier les blocs d'instructions :

Ils se matérialisent avec l'indentation, généralement deux caractères espace ou une tabulation.
Ils peuvent être une structure de choix, de répétition ou un sous-programme.

Les lignes de code seront écrites avec l'EDI (environnement de développement intégré) EduPython.

Expérimenter

La méthode split()

Tester le programme ci-dessous. Il présente la méthode split() qui sectionne une chaîne de caractères pour former une liste. Chaque élément de la liste est une chaîne de caractères. Le séparateur, par défaut un espace, est le point dans le cas présent.

adIP="192.168.34.17"
adIP=adIP.split(".")
print("Adresse IP convertie en liste : ", adIP)
print("Nombre d'éléments de la liste : ", len(adIP))
print("Premier élément de la liste : ", adIP[0])
print("Dernier élément de la liste : ", adIP[3])

Le choix : if ... else ...

Une interface réseau d'ordinateur connecté à internet reçoit au moins une adresse IP. Il en existe deux sortes :

IPv4 : Codée sur 4 octets, première version toujours d'actualité.
IPv6 : Codée sur 16 octets, version qui se généralise.

Une adresse IPv4 s'écrit avec 4 nombres entiers séparés par un point. Chaque nombre est compris entre 0 et 255.
Exemple : 200.172.10.20

Vérifier l'adresse IPv4 en testant la taille de la liste avec la fonction len(). Elle doit être égale à 4.

adIP=input("Quel est l'adresse IPv4? ")
adIP=adIP.split(".")
if len(adIP)==4 :
  print("L'adresse IPv4 est valide.")  
else :
  print("L'adresse IPv4 n'est pas valide!")

La répétition : for ... in ...

Vérifier l'adresse IPv4 en testant chaque élément de la liste. Ils doivent être compris entre 0 et 255.

adIP=input("Quel est l'adresse IPv4? ")
adIP=adIP.split(".")
valide="oui"
for element in adIP :
  if int(element)<0 or int(element)>255 :
    valide="non";
if valide=="oui" :
  print("L'adresse IPv4 est valide.")
else :
  print("L'adresse IPv4 n'est pas valide!")

Sous-programmes : def ...

Tester à la fois la taille et les éléments de la liste. Les sous-programmes, ici deux fonctions, rendent le code plus lisible.

def nombre_elements(adIP) :
  if len(adIP)!=4 :
    return False
  return True

def valeurs_elements(adIP) :
  for element in adIP :
    if int(element)<0 or int(element)>255 :
      return False
  return True

adIP=input("Quel est l'adresse IPv4? ")
adIP=adIP.split(".")
if nombre_elements(adIP) and valeurs_elements(adIP) : 
  print("L'adresse IPv4 est valide.")
else :
  print("L'adresse IPv4 n'est pas valide!")

Evolution d'une fonction

Souvent, une fonction s'améliore au fil du temps. La fonction Binaire() ci-dessous :

Reçoit en paramètre un nombre entier nb devant être compris entre 0 et 255.
Retourne l'octet correspondant.

def Binaire(nb) :
  a=b=c=d=e=f=g=h="0"
  if nb>=128:
    a="1"
    nb=nb-128
  if nb>=64:
    b="1"
    nb=nb-64
  if nb>=32:
    c="1"
    nb=nb-32
  if nb>=16:
    d="1"
    nb=nb-16
  if nb>=8:
    e="1"
    nb=nb-8
  if nb>=4:
    f="1"
    nb=nb-4
  if nb>=2:
    g="1"
    nb=nb-2
  h=str(nb)
  return a+b+c+d+e+f+g+h

print(Binaire(45))

Plus simple avec la fonction bin()

La fonction bin() prend un nombre entier en paramètre et retourne :

Une chaîne de caractères.
Commençant par 0b, signifiant qu'il s'agit d'un nombre binaire.
Suivie du nombre en notation binaire.

Exemple :

txt=bin(45)
print(txt)
print(type(txt))

La fonction Binaire() modifiée :

Utilise la fonction bin() pour effectuer la conversion.
Retire les deux premiers caractères 0b.
Ajoute les zéros manquants pour former un octet.

def Binaire(nb) :
  txt=bin(nb)
  txt=txt[2:]
  # txt=txt[2:len(txt)]
  if len(txt)==1:
    txt="0000000"+txt
  if len(txt)==2:
    txt="000000"+txt
  if len(txt)==3:
    txt="00000"+txt
  if len(txt)==4:
    txt="0000"+txt
  if len(txt)==5:
    txt="000"+txt
  if len(txt)==6:
    txt="00"+txt
  if len(txt)==7:
    txt="0"+txt
  return txt

print(Binaire(45))

Encore plus simple

En réunissant les lignes 2 et 3 en une seule ligne et en notant que le nombre de zéros à ajouter vaut 8-len(txt) :

def Binaire(nb) :
  txt=bin(nb)[2:]
  return (8-len(txt))*"0"+txt

print(Binaire(45))

Programmer

Conversion décimal-binaire pour un octet

En utilisant la fonction Binaire(), écrire un programme :
- Demandant d'entrer un nombre entier compris entre 0 et 255.
- Retournant ensuite l'octet correspondant.
Compléter ce programme pour vérifier que la valeur entrée par l'utilisateur est bien comprise entre 0 et 255 (afficher un message d'erreur si ce n'est pas le cas).

Conversion décimal-binaire pour une adresse IPv4

1. Ecrire un programme :

Demandant d'entrer une adresse IPv4 (en notation décimale pointée).
Retournant l'adresse IPv4 en notation binaire, chaque octet étant séparé par le caractère espace.

La fonction Binaire() sera appelée à quatre reprises. Vous pouvez vous inspirer du code ci-dessous.

def Binaire(nb):
  ...

adIP=input("Quel est l'adresse IPv4? ")
adIP=adIP.split(".")
resultat=""
for element in adIP:
  ...
  
print("L'adresse IP en notation binaire est : ",resultat)

2. Compléter ce programme pour vérifier la validité de l'adresse IPv4 entrée par l'utilisateur (afficher un message d'erreur si ce n'est pas le cas).

Pour aller plus loin

1. Réaliser le programme :

Entrée : Un octet en notation binaire.
Sortie : Le nombre correspondant en notation décimale.

2. Modifier le programme pour vérifier :

Que l'octet entré par l'utilisateur comporte bien 8 caractères.
Que les caractères ne prennent que les deux valeurs 0 ou 1.

Exemple de conversion binaire-décimal

1010 0111 =
2⁷ + 2⁵ + 2² + 2¹ + 2⁰ (en décimal) =
128 + 32 + 4 + 2 + 1 =
167