TP NOTÉ

Longueur d'une chaîne : ⚓

En python, la fonction 'len()' est utile dans de nombreux cas. Vis-à-vis des chaînes de caractères, elle sert à obtenir la longueur de celles-ci.

len("bonjour") #renvoie 7
len("toto") #renvoie  4

Accesseurs aux caractères d'une chaîne : ⚓

On peut obtenir individuellement chaque caractère d'une chaîne grâce à l'opérateur '[]'. Il permet d'accéder à un caractère particulier dans la chaîne grâce à son numéro d'indice. Pour une chaîne de longueur n, les caractères sont numérotés de 0 à n-1.

chaine="bachi-bouzouk"
len(chaine) #renvoie 13
chaine[0] #renvoie 'b'
chaine[1] #renvoie 'a'
chaine[2] #renvoie 'c'
chaine[5] #renvoie '-'
chaine[10] #renvoie 'o'
chaine[12] #renvoie 'k' 
chaine[13] #ERREUR!

Boucle itérant sur une chaîne de caractère : ⚓

Il existe une façon simple de “ boucler ” sur une chaîne de caractère. La boucle

for c in mot :

Permet de programmer une boucle qui itère via la variable 'c' sur chaque caractère de la chaîne de caractère affectée à la variable 'mot'. En d'autre terme on peut lire cela come : “Pour chaque lettre 'c' du mot 'mot'…”.

Exemple d'utilisation :

for c in "papillon" :
    print("lettre lue: " + str( c ))

affiche :

lettre lue: p
lettre lue: a
lettre lue: p
lettre lue: i
lettre lue: l
lettre lue: l
lettre lue: o
lettre lue: n

L'opérateur modulo ⚓

L'opérateur modulo correspont au reste de la division euclydienne. En python, il permet :

4%26 renvoie 4
26%26 renvoie 0
27%26 renvoie 1
28%26 renvoie 2
-1%26 renvoie 25
-2%26 renvoie 24

Caractères et nombres entiers ⚓

En informatique, chaque caractère affiché (en tant que texte) est référencé par un nombre dans une table de caractères.

En python, on peut obtenir le nombre associé à un caractère en utilisant la fonction ' ord() '. Par exemple :

ord('a') renvoie 97

Les lettres de a à z sont référencées successivement dans la table de caractères. Ainsi :

ord('b') renvoie 98
ord('c') renvoie 99
ord('d') renvoie 100
…
ord('y') renvoie 121
ord('z') renvoie 122

Inversement, on peut récupérer un caractère dans la table à partir d'un entier grâce à la fonction chr(). Ainsi :

chr(97) renvoie 'a'
chr(99) renvoie 'c'
chr(122) renvoie 'z'

Les tuples ⚓

En python il existe une structure de données appelé les tuples. Ils permettent de grouper plusieurs variables au sein d'une même structure. Ci-dessous l'exemple d'utilisation d'un tuple regroupant 3 variables:

#variable individu
#-- initialise a un tuple regroupant: age, sexe, et nom
individu= (50, 'M', 'Negan')

#acces au premier champs
age= individu[0]
#acces au deuxieme champs
sexe= individu[1]
#acces au troisieme champs
nom= individu[2]

#genere une erreur
fail= individu[3]

Les tuples ne sont pas limités à 3 champs, il peut y en avoir plus mais au minimum 2

couple=("interstella",5555)
quadruplet= (666.66, True, "Rock", "Evil")

Vous pouvez mettre n'importe quel type dans les tuples... même des tuples!

#tuple regroupant un tuple, un booleen, et un autre tuple
metaTuple= ( ("ok",12), True, ("Money",False, "god") )

Naturellement, les tuples peuvent être initialisés à partir de variables ou d'expressions, et peuvent être affichés:

a= "bonjour"
tuple= ( 5+8, a, (5>4) )
print("mon tuple: "+str(tuple))

Cependant, les tuples sont limités, car leur champs sont constants. Autrement dit, il n'est plus possible de les modifier une fois le tuple créé.

tuple= ("la vie","l'univers","tout le reste", 42)
#erreur
tuple[3]= 7

Attention : ne vous attendez pas à ce que l'utilisation d'opérateurs entre 2 tuples résultent en un tuple dont le contenu est l'application de ces opérateurs entre les champs des tuples opérandes. En d'autres mots:

#l'addition de 2 tuples, n'additionne pas les champs entre eux
#mais concatene simplement les 2 tuples
(4,5,6) + (7,1,2) #renvoie (4,5,6,7,1,2)

#pour additionner les champs de 2 tuples:
a= (4,5,6)
b= (7,1,2)
#renvoie (11,6,8)
(a[0]+b[0], a[1]+b[1], a[2]+b[2])

Dans l'interpréteur python, une documentation, en anglais, sur les tuples, peut-être affichée en tapant:

help(tuple)

Les listes ⚓

Autre structure de donnée implémentée en python: les listes.

Les listes permettent de stocker plusieurs données à la suite. On part d'une liste vide, et on ajoute des nouveaux éléments à la liste, par la fin.

#list l vide:
l= []
#Ajout d'un premier element
l.append(5)
print(str(l))
#ajout d'un 2eme puis 3eme element
l.append(3)
l.append(7)
print(str(l))

Plusieurs opérations de base sur les listes sont possibles : accèder à un élément, modifier un élément, connaître la taille d'une liste (combien d'éléments à l'intérieur), etc. Il est aussi possible de déclarer une liste à partir de plusieurs éléments (sans commencer par une liste vide):

#2eme element de la liste
#(la liste est indexee a partir de 0)
deuxieme_elem= l[1]
#modifier le premier elem
l[0]= 1
print( str(l) )
#taille de la liste = nb d'elements
taille= len( l )
#nouvelle liste, contient deja des elements
l2= [4,3,8,0,42,9]

Les listes offrent notament la possibilté de pouvoir lire puis supprimer n'importe quel élément dans la liste.

#suppr. le dernier elem d'une liste
end= l2.pop() #equivalent, ici, à l2.pop(5)
print("elem supprime: "+str(end))
print(l2)
#suppr. le premier element d'une liste
first= l2.pop(0)
print("elem supprime: "+str(first))
print(l2)
#suppr. du 3eme elem d'une liste
ter= l2.pop(2)
print("elem supprime: "+str(ter))
print(l2)

Naturellement, quand on supprime un élément d'une liste, les autres éléments sont ré-indexés. Dans l'exemple ci dessus, lorsque l'on a supprimé le premier élément, l'ancien deuxième élément de la liste est devenu le premier, l'ancien troisème est devenu le deuxième, l'ancien quatrième troisième, etc.

De la même manière qu'avec les chaînes de caractères, il est possible de concaténer 2 listes, grâce à l'opérateur de concaténation associé, désigné par le symbol '+' :

l1= [4,8,9,23]
l2= [8,6,3]
#génère une nouvelle liste: [4,3,9,23,8,6,3]
L= l1+l2

Dans l'interpréteur python, une documentation, en anglais, sur les listes, peut-être affichée en tapant:

help(list)

Exemple : d'un programme qui créé la liste contenant les n premiers entiers au carré :

l= []
n= input("Donnez un entier")
i= 0
while i < n:
    l.append(i*i)
    i= i+1

Exemple : d'un programme qui parcours tous les éléments d'une liste :

for i in range(0,len(l)):
        print("L'element numero "+str(i+1)+" est: "+str(l[i]))

Variante : du programme qui parcours tous les éléments d'une liste :

#cette variante n'est adaptee que pour des fins consultatives
#n'est pas adaptee pour agir sur le contenu d'une liste
for element in l:
        print("Element: "+str(element))

Utilisation d'un module externe ⚓

Pour réaliser ce TP noté, vous devrez utiliser un module externe [◉] qui génèrera un affichage via une page .html.

→ Télécharger le module ←

Pour utiliser ce module avec votre code, il faut utiliser la fonction « import ». Le module devra être présent dans le même répertoire que celui de votre programme. Le module ne contient en fait qu'une fonction à utiliser, « drawLineList() ». Exemple :

#import du module sous le nom 'sld'
import lineListDraw as lld

#genere une page html qui contient un affichage d'un
#ligne qui part de (50,400) jusqu'à (750,50)
lld.drawLineList( [(50,400,750,50)] )

La fonction « drawLineList() » permet de dessiner une liste de lignes. Pour ce faire, elle génère une page .html (par défaut appelée « lineListDraw.html ») dans le répertoire du programme qui appelle la fonction, qui contient l'affichage des lignes de la liste. La signature de la fonction est la suivante:

drawLineList(lineList, width=1000, height=1000, filePath="lineListDraw.html")

Ainsi, les paramètres sont :

lineList : une liste de lignes (voir ci-dessous)
width : un entier représentant la largeur de la zone de dessin (en pixels); optionnel : valeur par défaut = 800
height : un entier représentant la hauteur de la zone de dessin (en pixels); optionnel : valeur par défaut = 800
filePath : une chaîne de caractères représentant le nom du fichier dans lequel on va dessiner nos ligne; optionnel : valeur par défaut = "lineListDraw.html"

Attention : à chaque fois que la fonction est appelée et effectue une génération du fichier .html, sauf si changement de nom, l'ancien fichier généré est écrasé.

Ici, une ligne sera représentée par un quadruplet (tuple à 4 champs) de la façon suivante:

line= (x1,y1,x2,y2)

Suivant cette formalisation, on a donc :

x1 : un entier représentant la coordonnée x (unité : pixels) du point de départ la ligne.
y1 : un entier représentant la coordonnée y (unité : pixels) du point de départ la ligne.
x2 : un entier représentant la coordonnée x (unité : pixels) du point de d'arrivée la ligne.
y2 : un entier représentant la coordonnée y (unité : pixels) du point de d'arrivée la ligne.

Ainsi, grâce au code suivant:

#ligne allant de (50,50) jusqu'a (300,400)
l1= (50,50,300,400)
#2eme ligne allant de (75,350) jusqu'a (350,100)
l2= (75,350,350,100)
#on met les 2 lignes dans une liste
listeLignes= []
listeLignes.append(l1)
listeLignes.append(l2)

#on affiche la liste des lignes
#dans une zone de dessin de 500 px x 500 px
#contenue dans le fichier "exemplePrep.html"
lld.drawLineList(listeLignes,500,500,"exemplePrep.html")

on génère la page « exemplePrep.html », contenant l'affichage suivant (sans les annotations) :

Dans l'interpréteur python, une documentation pour la fonction « drawLineList() », peut-être affichée en tapant :

help(lld.drawLineList)

Environnements de programmation Niv 1 - M1 OTG

- Préparation -