PYTHON
BLOCS D'INSTRUCTIONS

Objectif

Il s'agit ici de se familiariser avec les blocs d'instructions. Il peuvent être :

Une structure de choix.
Une structure de répétition.
Ou un sous-programme.

Un bloc d'instructions se matérialise avec une indentation, généralement :

Deux caractères espace.
Ou une tabulation.

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

Comprendre

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.

txt="Bonjour à tous!"
print(txt.split())

Le séparateur, par défaut un espace, est le point dans le cas ci-dessous.

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("Quelle 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("Quelle est l'adresse IPv4? ")
adIP=adIP.split(".")

valide="oui"
for i in range(4) : # i prend les valeurs 0, 1, 2 puis 3
  if int(adIP[i])<0 or int(adIP[i])>255 :
    valide="non";

if valide=="oui" :
  print("L'adresse IPv4 est valide.")
else :
  print("L'adresse IPv4 n'est pas valide!")

Variante :

...
for element in adIP :
  if int(element)<0 or int(element)>255 :
    valide="non";
...

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("Quelle 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))

Pratiquer

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 en notation binaire.
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("Quelle 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, au préalable, la validité de l'adresse IPv4 entrée par l'utilisateur. Afficher un message d'erreur si ce n'est pas le cas.

Approfondir

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