Introduction au langage python

I- Rappels de syntaxe

Vous avez eu l'occasion lors de l'année de seconde de découvrir le langage python de façon superficielle.
Cette introduction vous permettra de vous les résumer rapidement

Affiche les rappels

Cacher les rappels

1- Variables
Une variable est une "boîte" dans laquelle on va stocker une donnée afin que le programme puisse y accéder au besoin.
Cela peut être le résultat d'un calcul, un numéro de téléphone, du texte, et même des images, de la musique...
Pour affecter la valeur 1789, à la variable revolution, il suffit décrire ceci:
revolution = 1789
2- Types
On l'a vu dans le chapitre précédent, il existe plusieurs façon d'écrire un nombre, selon qu'il soit entier ou décimal.
Ainsi un nombre entier aura le type int tandis qu'un nombre décimal aura le type float. Il est bien entendu possible d'attribuer le type float à un nombre entier, mais l'inverse aboutira à la troncature du nombre décimal :
float(10)
Out[1]: 10.0

int(2.35)
Out[2]: 2
On remarque que le passage d'un type int vers un type float se traduit par l'écriture d'un .0 à la fin du nombre.
C'est ainsi que a=10 affectera automatiquement le type int à a mais que a=10.0 affectera le type float.
Il y a d'autres types, notamment string pour les chaînes de caractère
3- Conditions
Les tests logiques vus au précédent chapitre peuvent être utilisés pour adapter le comportement d'un problème aux données qu'il reçoit.
Cela va se traiter avec la structure conditionnelle
if (condition) :
	...(instructions)
elif (condition) :
	...(instructions)
else :
	...(instructions)
Attention ! Le test d'égalité s'écrit a==b car le simple = est un opérateur d'attribution (il stockera la valeur de droite dans la variable de gauche).
4- Boucles
Lorsque l'on doit executer un certain nombre de fois un travail similaire, on peut utiliser une boucle. Il y a 2 types différents : while (condition): ("tant que") et for i in ... : ("pour").
Généralement, on utilise la boucle while lorsque l'on ne connaît pas à l'avance le nombre d'itérations, et la boucle for pour balayer un ensemble prédéterminé.
Dans les 2 cas, il n'est pas nécessaire que la condition porte sur des nombres.
Exemple :afficher tous les nombres entre 1 et 100
avec while avec for
i=1
while i>101:
	print(i)
	i+=1
for i in range(1,101):
	print(i)

II- Les tuples, les listes et dictionnaires

Cliquer pour voir les activités de présentation :

Affiche tuples et listes

Cacher tuples et listes

1- Tuples et listes

a. Présentation
Ces 2 objets ont un fonctionnement proche : on accède à un élément en utilisant la syntaxe liste[n] et on détermine le nombre d'élément qui le composent avec len(liste).
En revanche un tuple s'écrira mon_tuple=(1,2,3) tandis qu'une liste s'écrira ma_liste=[1,2,3].
Enfin, un tuple est non mutable ce qui signifie que vous ne pourrez pas modifier ses éléments :
mon_tuple=(1,2,3)

mon_tuple[1]=0
Traceback (most recent call last):

  File "", line 1, in 
    mon_tuple[1]=0

TypeError: 'tuple' object does not support item assignment
b. Construire une liste
En dehors de l'attribution, il est possible de construire une liste par concaténation :
a=[1,2,3]+[4,5,6]

a
Out[6]: [1, 2, 3, 4, 5, 6]
Il est également possible d'utiliser .append():
a.append(7)

a
Out[8]: [1, 2, 3, 4, 5, 6, 7]
Il est possible de coupler ces méthodes avec une boucle :
Créer une liste contenant les 100 premiers multiples de 7
concaténation avec .append() en compréhension
multiples=[]
for i in range(100):
	multiples+=[7*i]
multiples=[]
for i in range(100):
	multiples.append(7*i)
multiples=[7*i for i in range(100)]
La dernière méthode est plus courte, mais tout à fait équivalente aux 2 autres.
c. Parcourir une liste/un tuple
Pour ne prendre en compte qu'une partie d'une liste, il suffit de le préciser dans les crochets :
a=[1,2,3,4,5,6,7,8,9]

a[2:7]
Out[12]: [3, 4, 5, 6, 7]

a[:8]
Out[13]: [1, 2, 3, 4, 5, 6, 7, 8]

a[5:]
Out[14]: [6, 7, 8, 9]

a[-3:-1]
Out[15]: [7, 8]

a[::-1]
Out[16]: [9, 8, 7, 6, 5, 4, 3, 2, 1]
La première position correspond au point de départ et la seconde à la position suivant le dernier item. La troisième information indique le sens de lecture de liste, en indiquant [x:y:-1] on indique qu'on lit la liste à l'envers !
Ces commandes fonctionnent également avec les chaînes de caractères "! euqitarp sèrt tse'c te"
d. Effacer un terme
Pour effacer un(des) terme(s) d'une liste (ou la liste entière), on utilise la commande del.
a=[1,2,3,4,5,6,7,8,9]

del a[3]

a
Out[22]: [1, 2, 3, 5, 6, 7, 8, 9]

del a[3:5]

a
Out[24]: [1, 2, 3, 7, 8, 9]

del a[:]

a
Out[26]: []

del a

a
Traceback (most recent call last):

  File "", line 1, in 
    a

NameError: name 'a' is not defined

2- Les dictionnaires


Affiche les dictionnaires

Cacher les dictionnaires

a. Créer un dictionnaire
Comme vous l'avez découvert dans l'activité d'introduction, un dictionnaire a une structure différente de celle des listes. Les valeurs ne sont plus rangées en fonction d'un indice (valeur numérique entière) mais à l'aide de clés (chaîne de caractère).
Pour créer un dictionnaire, on peut soit le définir directement :
mon_dictionnaire={"age":36,"nom":"Duplant","prénom":"Christophe"}

mon_dictionnaire
Out[30]: {'age': 36, 'nom': 'Duplant', 'prénom': 'Christophe'}
soit ajouter des informations de façon plus classique :
mon_dictionnaire["telephone"]="0601020304"

mon_dictionnaire
Out[32]: 
{'age': 36,
 'nom': 'Duplant',
 'prénom': 'Christophe',
 'telephone': '0601020304'}
b. Parcourir un dictionnaire
Pour accéder à la valeur associée à une clé d'un dictionnaire :
mon_dictionnaire["nom"]
Out[33]: 'Duplant'
Pour avoir la liste de toutes les clés présentes dans un dictionnaire :
mon_dictionnaire.keys()
Out[34]: dict_keys(['age', 'nom', 'prénom', 'telephone'])
Pour afficher toutes les valeurs associées à chaque clé du dictionnaire :
for i in mon_dictionnaire.keys():
    print(i,mon_dictionnaire[i])
    
age 36
nom Duplant
prénom Christophe
telephone 0601020304
Pour savoir si une clé est présente dans le dictionnaire :
"prénom" in mon_dictionnaire.keys()
Out[36]: True

"voiture" in mon_dictionnaire.keys()
Out[37]: False
Faire la fiche 07 : cliquer ici

III- Les modules

1- Présentation

Les modules permettent de réaliser certaines opération par défaut impossible ou d'éviter d'avoir à coder de nouveau certaines fonctions utiles.
On utilise par exemple régulièrement les modules math ou random.
Chaque module contient plusieurs fonctions que l'on pourra utiliser une fois le module importé.
import math

math.sin(math.pi/4)
Out[2]: 0.7071067811865476
Ici, seul le module est importé et il faut alors préciser que l'on appelle la fonction sin() du module math.
from math import sin,pi

sin(pi/4)
Out[4]: 0.7071067811865476
Dans ce cas, seules les fonctions indiquées sont importées, sans avoir à préciser le préfixe math..

Affiche les modules sur la calculatrice

Cacher les modules sur la calculatrice

2- Les modules sur calculatrice Numworks

Afin de pouvoir travailler avec des images, la calculatrice Numworks intègre le module kandinsky (cliquez pour accéder au manuel).
Ce module, très simple, permet de dessiner des points, du texte et des rectangles.
En utilisant votre calculatrice ou l'émulateur officiel, saisir le code suivant et l’exécuter :
from kandinsky import *
for i in range(256):
	for j in range(256):
		set_pixel(i,j,(i,j,511-(i+j)))
  1. En vous basant sur ce script, ainsi que la documentation représenter les drapeaux français, italien et allemand
  2. Utiliser la fonction fill_rect(x,y,largeur,hauteur,(r,v,b)) pour faire la même chose, mais sans avoir à faire de boucle. Que remarquez-vous ?
  3. A l’aide d’une boucle while( ) du type :
    while True :
    ….commandes…
    Dessiner un rectangle dont la couleur oscille du rouge (255,0,0) au vert (0,255,0).
  4. a. Écrire une fonction bouge(vitx,vity) qui dessine un rectangle se déplaçant à l’écran avec une vitesse verticale vity et une vitesse horizontale vitx
    b. La fonction s’arrête lorsque le rectangle sort de l’écran
    c. Le rectangle rebondit lorsqu’il "touche" le bord de l’écran
  5. Utiliser les modules time et ion pour faire bouger le rectangle à l’aide du clavier de la calculatrice
  6. La totalité des fonctions est présente sur mon espace Numworks : Cliquer ici.
    Il vous suffit donc de connecter votre calculatrice à votre ordinateur pour y envoyer toutes les fonctions !

Affiche "Travailler avec des fichiers"

Cacher "Travailler avec des fichiers"

3- Manipuler des fichiers

a. Ouvrir/lire/écrire dans un fichier
On va pouvoir ouvrir un fichier en mode texte à l'aide de la fonction open()
Pour ouvrir le fichier mon_texte.txt se trouvant dans le dossier C:/python :
le_texte=open("C:/python/mon_texte.txt","a",encoding="utf-8")

le_texte
Out[2]: <_io.TextIOWrapper name='C:/python/mon_texte.txt' mode='a' encoding='utf-8'>
A partir de ce moment, le fichier mon_texte.txt est accessible par la variable le_texte.
Cependant on ne peut pas imprimer le texte ainsi. On peut l'afficher ligne par ligne :
le_texte=open("C:/python/mon_texte.txt","r",encoding="utf-8")

for i in le_texte:
    print(i,end="")
le_texte.close()    
On termine toujours par la fermeture du fichier. La seonde option "r" signifie que l'on a ouvert le fichier en lecture : on ne pourra pas le modifier. S'il s'agit d'un fichier sensible, cela évite de faire des erreurs !
L'option "a" (append) permet d'ajouter du texte à la suite de ce qui est déjà présent dans le document. Enfin, l'option "w" efface le fichier et écrit les modifications
Le fichier mon_texte.txt contient la fable Le corbeau et le renard de Jean de La Fontaine. Une fois téléchargé et enregistré dans le répertoire c:\python, on souhaite éditer le texte et écrire toutes les voyelles en majuscule.

4- Se simplifier la vie avec le module tkinter

Il est parfois difficile ou rébarbatif d'écrire le chemin d'accès complet au fichier.
Cette fonction, utilisant le module tkinter pour faire apparaître une fenêtre de sélection vous simplifiera la vie !
from tkinter import filedialog,Tk

def fichier(action):
    popup=Tk()
    if action=="ouvrir":
        chemin_fichier =  filedialog.askopenfilename(initialdir = "./",title = "Select file")
    elif action=="enregistrer":
        chemin_fichier =  filedialog.asksaveasfilename(initialdir = "./",title = "Select file")
    else:
        chemin_fichier=False
    popup.destroy()
    return chemin_fichier
la fonction fichier(action) vous permet donc d'ouvrir ou de choisir où enregistrer votre fichier.
Pour l'exercice précédent (la fable du corbeau et du renard), il suffit donc d'écrire :

Affiche "Traiter des images"

Cacher "Traiter des images"

5- Traiter les images avec le module pillow

a. Charger une image
Remarque : Toute la partie sera traitée avec cette image. Enregistrez-là pour avoir les mêmes résultats que moi. (une barre de chocolat à qui en identifie le lieu).
Toute image est stockée numériquement sous forme binaire. Chaque format d'image a une façon particulière de s'écrire. Pour simplifier leur prise en charge, le module pillow va ouvrir l'image et l'interpréter sous la forme d'un tableau (x,y) dans lequel la couleur correspondant à chaque pixel sera présente. Pour l'utiliser avec la fonction fichier(action) écrite précédemment :
from PIL import Image

mon_image=Image.open(fichier("ouvrir"))

mon_image.size
Out[13]: (3968, 2976)

mon_image.getpixel((200,200))
Out[14]: (145, 150, 169)
mon_image.size donne les dimensions (x,y) de l'image, mon_image.getpixel((x,y)) indique le code couleur du pixel indiqué.
Enfin, mon_image.putpixel((x,y),(r,v,b)) coloriera le pixel de coordonnées (x,y) à la couleur (r,v,b).
mon_image.show() affichera l'image et mon_image.save("dossier/image.jpg") permettra de l'enregistrer. C'est l'extension (jpg,bmp,png) qui permettra à PIL de connaître la norme d'encodage dans laquelle il doit l'enregistrer, n'oubliez donc pas que jpg enregistre à perte !
b. Créer une image
PIL permet également de créer une image, en indiquant ses dimensions (largeur,longueur) ainsi que le type de couleur :
  • "1" pour une image en noir et blanc, chaque pixel prenant la valeur 0 ou 1.
  • "L" pour une image en niveaux de gris, chaque pixel prenant une valeur entière entre 0 (noir) et 255 (blanc)
  • "RGB" pour une image en couleur, chaque pixel prenant un tuple (r,v,b) chaque composante étant un nombre entier compris entre 0 et 255.
Pour créer une image en couleur de 1024 pixels de large par 768 pixels de haut, il faut écrire :
nouvelle_image=Image.new("RGB",(1024,768))
b. Modifier une image
Une fois l'image chargée par PIL, il est possible de la modifier en créant les fonctions dont vous avez besoin.
Dans tous les cas suivants, la fonction sera lancée avec fonction(Image.open(fichier("ouvrir")),arguments_supplémentaires).
  1. a. Ecrire une fonction rectangle(image,x,y,largeur,hauteur,couleur) qui dessine un rectangle dont le coin supérieur gauche est aux coordonnées [x,y], des dimensions indiquées et de la couleur sous la forme d'un tuple (r,v,b).

    b. Prendre en compte le fait que les dimensions puissent dépasser les dimensions de l'image. Trouver le moyen de ne pas faire planter le programme dans ce cas.

    c. Sur le même modèle, écrire une fonction cercle(image,x,y,rayon,couleur)

  2. Ecrire une fonction niveaux_de_gris(image) qui convertit une image en niveaux de gris

  3. Ecrire une fonction redim(image,facteur) qui redimensionne une image d'un facteur donné.
    Ainsi redim(image,4) pour une image ayant une définition de 1024x768 retournerait une image de 1024/4=256px par 768/4=192px.