Algo & Prog 1 Python : CM séance 01

0. Description de l'UE

Présentation :

UE SMI3U12L - "Algorithmique et Programmation 1 Python"
Responsable : Edouard.Thiel@univ-amu.fr
8 séances : CM 1h30, TP 2h
Site du cours : https://j.mp/py-et

Objectifs :

approfondir la programmation orientée objets en Python 3 ;
interfaces graphiques et dessins avec TkInter ;
programmation d'algorithmes orientés mathématiques.

Comment travailler ce cours ?

prenez beaucoup de notes ;
téléchargez le fichier du cours et annotez-le ;
après chaque séance, complétez le cours avec vos remarques ;
tenez à jour un "pense-bête" avec les points et exemples qui vous semblent importants ;
installez Python3 (sur ordinateur ou tablette) ;
testez chaque instruction, chaque programme, faites des variantes ;
imaginez des petits exercices.

MCCC : ¹

Note finale session 1 = max { ET ; 0.7 ET + 0.3 CC }
À l'examen :
- calculette : non
- document autorisé : un pense-bête personnel sur 1 feuille A4 recto-verso
TP : utilisation d'IAs génératives interdite.
Présence aux CM et TP obligatoire.

1. Rappels de Python 3

1.1. Présentation du langage

Créé par Guido van Rossum (informaticien hollandais) depuis 1989 (soit 35 ans)
objectif = facile à apprendre et puissant

Langage de plus en plus utilisé :

recherche scientifique, applications web, administration système, transactions boursières, prototypage...
enseigné partout (lycées, prépas, écoles, licences, masters...)
idéal pour débutants jusqu'aux développeurs confirmés

Amélioration du langage : communautaire

PEP = Python Enhancement Proposal : document textuel numéroté
https://peps.python.org/
https://peps.python.org/#numerical-index
https://peps.python.org/pep-0008/ - style guide
https://peps.python.org/pep-0020/ - bonnes pratiques

Versions :

2.0 en 2000
2.7 en 2010 - obsolète
3.0 en 2008 - rupture
3.12 en 2023

v 2.7 obsolète depuis 2020, mais encore utilisé dans de nombreux programmes
v >= 3.8 conseillée
versions les plus récentes : améliorations techniques, efficacité

Langage interprété, pas besoin de phase de compilation comme en C ou java. l'interpréteur est python3.

En TP : sous Linux ou WSL

Ouvrir un terminal (par le menu ou CTRL-ALT-T)
Connaître la version installée :
```
$ python3 --version
Python 3.8.10
```

1.2. Modes

Il y a 2 modes : interactif (calculette) et programme (script).

1.2.1. Mode interactif

Utile pour tester des choses, ou faire un petit calcul.

Ouvrir un terminal (CTRL-ALT-T) : le prompt du shell est $, celui de python3 est >>> :

$ python3      # on lance l'interpréteur Python
>>> 5+3.2      # 8.2
>>> 5/3        # 1.6666666666666667
>>> 5//3       # 1
>>> 5**3       # 125
>>> 7**50      # 1798465042647412146620280340569649349251249   : big int
>>> "hip" + "hop"   # hiphop  = concaténation
>>> "hop"*3         # hophophop
>>> True and False  # False

Les commentaires commencent par #

Il existe de nombreux modules, par exemple math pour les réels :

>>> import math
>>> math.factorial(40)     # 815915283247897734345611269596115894272000000000
>>> math.cos(math.pi/4)*2  # 1.4142135623730951

Le module cmath est utile pour les nombre complexes :

>>> a = complex(1,2)
>>> a                      # (1+2j)
>>> a*a.conjugate()        # (5+0j)
>>> import cmath
>>> cmath.sqrt(a)          # (1.272019649514069+0.7861513777574233j)

Pour obtenir l'aide en ligne :

>>> help(math)      # Tout est documenté dans l'interpréteur
: <space>           # page suivante
: /cos              # recherche d'un mot clé
: n ou b            # suivant ou précédent
: q                 # quitter l'aide

On peut aussi taper help() puis un mot clé, ou help('mot clé')

>>> help('if')
>>> q

>>> quit()   # ou Ctrl-D, pour quitter python3

1.2.2. Mode programme

Dès que l'on dépasse quelques lignes de python il vaut mieux les écrire dans un fichier, avec l'extension .py

Ouvrir un terminal (CTRL-ALT-T)

Dans le terminal :

$ mkdir InfoS3                   # on créé un répertoire de travail
$ cd InfoS3                      # on va dans ce répertoire
$ gedit essai1.py &              # on ouvre ou crée essai1.py avec gedit

Dans gedit, taper
```
print ("Hello World!")
```

puis enregistrer ; on peut laisser gedit ouvert.

Dans le terminal, on exécute le programme python :
```
$ python3 essai1.py
```

L'idéal est de laisser les 2 fenêtres côte à côte.

Remarque :

En mode script, python n'affiche pas la valeur des expression, il faut utiliser print.

Exemple dans gedit :

3+5                         # n'affichera rien
print (3+5)                 # affichera 8

Transformer un fichier python en script Unix

Rajouter en première ligne
```
#! /usr/bin/env python3
```
donner les droits d'exécution
```
$ chmod +x toto.py
```
on peut maintenant faire
```
$ ./toto.py
```

→ plus besoin d'invoquer python3

1.3. Variables et types

1.3.1. Variables

Pas de déclaration, variable créée par affectation :

$ python3
>>> a = 5
>>> a         # 5
>>> a+3       # 8
>>> a = a*2
>>> a         # 10
>>> a++       # SyntaxError
>>> a += 1
>>> a         # 11

Nom de variable : 1 lettre + 0 ou plusieurs {lettre,chiffre} :

a, x1, couleur, nb_formes, nombreFormes

Sensible à la casse, lettres accentuées possibles → gare aux confusions :

>>> cafe = "froid" ; Cafe = "chaud" ; café = "moulu"
>>> cafe ; Cafe ; café      # 'froid' 'chaud' 'moulu'

Bon usage : éviter de commencer les variables avec majuscule ou _

1.3.2. Typage dynamique

Les valeurs ont un type :

>>> type(2)                 # <class 'int'>
>>> type(2.5)               # <class 'float'>
>>> type("salut")           # <class 'str'>   chaînes délimitées par "" ou ''
>>> type(True)              # <class 'bool'>
>>> type(None)              # <class 'NoneType'>   équiv NULL en C

Type d'une variable selon sa valeur courante : typage dynamique

>>> a = 2 ; type(a)         # <class 'int'>
>>> a = 2.5 ; type(a)       # <class 'float'>

Vérification de types :

>>> a = 5 ; type(a) == int          # True

idem avec float, bool, str (mais pas NoneType)

Exemple d'utilisation :

a = ...
if type(a) == int :
    print("c'est un entier")

On peut aussi faire :

a = ...
est_réel = type(a) == float   # expression booléenne valant True ou False
if est_réel :
    print("c'est un réel")

Il y a beaucoup d'autres types (vus plus tard) : tuples, listes, ensembles, dictionnaires, tableaux, classes...

1.3.3. Manipulation de types

Transformations de types :

>>> str(5)          # '5'
>>> int("5")        # 5
>>> int(2.5)        # 2
>>> float("3.14")   # 3.14
>>> int(True)       # 1
>>> bool(0)         # False
>>> int("toto")     # ValueError

Mélanges de types :

>>> type(2+3.14)    # <class 'float'> : type plus général
>>> type(2+True)    # <class 'int'>
>>> type(2+"toto")  # TypeError: unsupported operand type(s) for +: 'int' and 'str'
>>> type(2*"hop")   # <class 'str'>

1.3.4. Chaînes de caractères

Opérations sur les str :

>>> s = "Je mange un {légume} et un {fruit}"
>>> len(s)          # 34
>>> s[:8]           # 'Je mange'
>>> s[13:19]        # 'légume'
>>> s.format(fruit="kiwi", légume="concombre")
'Je mange un concombre et un kiwi'

Les f-strings (python 3.6) sont plus concis que la méthode format :

>>> fruit = "abricot" ; légume = "radis"
>>> f"Je mange un {légume} et un {fruit}"
'Je mange un radis et un abricot'

Les f-strings permettent aussi d'afficher un calcul avec une précision :

>>> x = 5 ; y = 7
>>> f"Le résultat de {x} divisé par {y} est {x/y:.3}"
'Le résultat de 5 divisé par 7 est 0.714'

1.3.5. Références

Qu'est-ce qu'une variable en python ?

C'est une référence (une adresse) vers un objet en mémoire.

Quand on écrit

>>> x = 1.4142

alors Python crée un objet de type float en mémoire, stocke la valeur 1.4142 dans l'objet, puis mémorise dans la variable x l'adresse de l'objet.

On peut obtenir l'adresse de l'objet avec la fonction id().

>>> id(x)
140630251125296         # adresse de l'objet de type float qui stocke la valeur

Une affectation dans une variable est une copie de la référence, pas du contenu de l'objet.

>>> y = x
>>> id(y)
140630251125296         # même adresse

L'opérateur is permet de savoir si deux variables désignent le même objet :

>>> x is y
True

Quand on demande le type d'une variable, on obtient en réalité le type de l'objet référencé :

>>> type(x)
<class 'float'>

Lorsqu'on fait une affectation avec une variable qui existe déjà, on remplace simplement la référence mémorisée par une autre :

>>> id(x)
140630251125296
>>> x = 'foo'       # un nouvel objet de type str est créé pour stocker 'foo'
>>> id(x)
140630272263024

Si plus aucune variable ne connait l'objet précédemment mémorisé, l'objet est détruit automatiquement par le ramasse-miette (uk : garbage collector).

1.4. Entrées sorties

Affichage dans le terminal :

>>> print("bonjour")
>>> a = 2 ; b = 3
>>> print("mangez", a, "pommes et", b, "poires")
>>> print("mangez", a, "pommes et", b, "poires", sep="--")   # par défaut " "
>>> print("mangez", a, "pommes et", b, "poires", end="++")   # par défaut "\n"
>>> help(print)

Saisie dans le terminal :

>>> a = input()
>>> b = input("poires : ")
>>> type(b)                         # str : input() renvoie toujours un str
>>> b = int(input("poires : "))
>>> type(b)                         # int

Exemple : programme fruits.py

a = input("pommes : ")
b = input("poires : ")
n = a+b
print("Il y a", n, "fruits")

Exécution :

$ python3 toto.py
pommes : 3
poires : 5
Il y a 35 fruits

Oups ! a et b sont des str, donc a+b concatène les chaînes
→ a = int(input(...)) et idem pour b

Compléments : écriture et lecture dans un fichier

>>> f = open("toto.txt", "w")
>>> f.write("salut")  # ou print("salut", file=f)
>>> f.close()
>>> 
>>> f = open("toto.txt", "r")
>>> s = f.read()
>>> f.close()
>>> s                   # 'salut\n'

1.5. Blocs d'instructions

Blocs d'instructions non délimités par { } ou begin end comme en C, java, Pascal

Blocs définis par l'indentation :
    des lignes qui se suivent avec la même indentation forment un bloc
    une instruction nécessitant un sous-bloc est terminé par :
        un sous-bloc a une indentation plus grande
        en général on indente de 4 espaces
le premier bloc a une indentation de 0

Structures de contrôle nécessitant un sous-bloc : conditionnelle, boucle, fonction

Possibilités de mettre une instruction sur plusieurs lignes :

on peut découper une instruction en mettant un \
    à la fin d'une ligne pour dire qu'elle a une suite.

on peut aussi revenir à la ligne lorsqu'une (
    est ouverte), ou un [
    pour les listes ou les ensembles], ou encore un {
    pour les dictionnaires}.

L'indentation des suites de lignes n'est pas obligatoire, mais conseillée.

1.5.1. Conditionnelle

if condition1 :
    bloc1

if condition1 :
    bloc1
else :
    bloc2

if condition1 :
    bloc1
elif condition2 :
    bloc2
...
else :
    blocN

Exemple :

nb_pommes = 5
fruit = input("Entrez un fruit : ")
if fruit == "pomme" :
    nb_pommes += 1
    print("Il y a", nb_pommes, "pommes.")
else :
    print("Je ne connais pas ce fruit.")

Remarque : un sous-bloc doit comporter au moins une instruction, sinon pass

if x % 2 == 0 :
    pass
else :
    print("x est impair")

On aurait pu écrire plus simplement

if not (x % 2 == 0) :
    print("x est impair")

Remarque : depuis v3.10 il y a l'équivalent d'un switch en python : match,case

1.5.2. Boucle while

while condition1 :
    bloc1

Exemple : calculer la somme des entiers de 1 à n

i = 1 ; n = 10 ; somme = 0
while i <= n :
    somme += i
    i += 1          # en mode interactif sauter 1 ligne pour sortir du bloc
print ("Le résultat est", somme)

Vus plus tard :

on peut contrôler la boucle avec : break, continue, else
il y a aussi une boucle for, différente du C et java

1.5.3. Fonction

Déclarer une fonction :

def nom_fonction (paramètre1, paramètre2, ...) :
    bloc1

Étant donné que en Python toutes les variables sont des références, le passage de paramètres à une fonction est toujours un passage par référence.

Appeler la fonction :

résultat = nom_fonction (valeur1, valeur2,...)
nom_fonction (valeur1, valeur2,...)             # résultat ignoré

Dans le bloc principal de la fonction :

return valeur
return          # renvoie None

→ sort immédiatement de la fonction

Exemple : somme des entiers de 1 à n

def calculer_somme (n) :
    if n <= 0 :
        return 0        # sortie immédiate, "early return"
    i = 1 ; somme = 0
    while i <= n :
        somme += i
        i += 1
    return somme

# Programme principal
n = int(input("Entrez n : "))
s = calculer_somme (n)
print ("Le résultat pour n =", n, "est", s)

Portée des variables (scope) :

Les paramètres et variables internes à la fonction sont locales
→ hors de la fonction pas d'accès à n, i, somme

Vus plus tard : variables globales, paramètres nommés, optionnels, etc

Très important : bonne structuration dans un fichier python pour faciliter la relecture :

# 1) Les imports

# 2) Les fonctions

# 3) Le programme principal

MCCC = Modalités de contrôle des connaissances et des compétences ; ET = Examen Terminal ; CC = Contrôle Continu. ↩