Partie 1 — Les bases de Python

Variables et affectation

Une variable stocke une valeur en mémoire. L’affectation se fait avec =.

a = 4
b = 7
c = a + b**5
print(c)

Python affiche en sortie : 16811. En effet, $a + b^5 = 4 + 7^5 = 4 + 16\,807 = 16\,811$ .

Opérations de base :

Opération	Python	Exemple
Addition	`a + b`	`3 + 4` → `7`
Soustraction	`a - b`	`10 - 3` → `7`
Multiplication	`a * b`	`3 * 4` → `12`
Puissance	`a**n`	`2**5` → `32`
Division	`a / b`	`7 / 2` → `3.5`
Quotient entier	`a // b`	`7 // 2` → `3`
Reste (modulo)	`a % b`	`7 % 2` → `1`

Exemple — a = 3, b = 4, c = a**3 + b. Alors $c = 3^3 + 4 = 27 + 4 = 31$ .

Partie 2 — Utiliser les fonctions

Une fonction reçoit des paramètres en entrée et renvoie un résultat avec return.

from math import *

def aire(rayon):
    A = pi * rayon**2
    return(A)

En exécutant aire(12), Python affiche : 452.389… car $A = \pi \times 12^2 \approx 452{,}4$ .

Importer des fonctions mathématiques :

from math import * donne accès à pi, sqrt (racine carrée), cos, sin, etc.

from math import *
a = 5
b = 9
c = a**2 + b**2
c = sqrt(c)
print(c)

Ce programme calcule l’hypoténuse d’un triangle rectangle de côtés 5 et 9 : $c = \sqrt{5^2 + 9^2} = \sqrt{106} \approx 10{,}3$ .

Exemple — def f(x): return(x**2 + 2). En saisissant f(5), on obtient $5^2 + 2 = 27$ .

Partie 3 — L’instruction conditionnelle (Si… alors…)

if / elif / else

from random import *

def jeu():
    dé = randint(1, 6)
    if dé > 4:
        a = 'gagné'
    else:
        a = 'perdu'
    return(dé, a)

randint(1, 6) : nombre aléatoire entier de 1 à 6.
if condition: → s’exécute si la condition est vraie.
else: → s’exécute sinon.

Avec elif (sinon si) :

def note(x):
    if 15 < x <= 20:
        remarque = 'super'
    elif 10 <= x <= 15:
        remarque = 'ca va'
    else:
        remarque = 'ouaip'
    return(remarque)

Opérateurs de comparaison : == (égal), != (différent), <, >, <=, >=

Exemple — def div(n): if n%3==0: N=n/3 else: N=0 return(N). Pour div(24), $24 \div 3 = 8$ , donc N vaut 8. Pour div(41), 41 n’est pas divisible par 3, donc N vaut 0.

Partie 4 — Utiliser les boucles

La boucle « Pour » (for)

La boucle for répète des instructions un nombre déterminé de fois.

def som():
    s = 0
    for k in range(1, 6):
        s = s + k
    return(s)

range(1, 6) signifie que $k$ prend les valeurs 1, 2, 3, 4, 5 (début inclus, fin exclue).

$k$		1	2	3	4	5
$s$	0	1	3	6	10	15

Python affiche : 15. En effet, $1 + 2 + 3 + 4 + 5 = 15$ .

La boucle « Tant que » (while)

La boucle while s’exécute tant que la condition est vraie.

def som():
    s = 0
    k = 1
    while s < 10000:
        s = s + k
        k = k + 1
    return(k - 1)

Ce programme cherche à partir de quel entier $n$ la somme $1 + 2 + \ldots + n$ dépasse 10 000. Résultat : 141.

Exemple — Le programme suivant calcule le produit des 9 premiers entiers ( $9!$ ) :
def prod():
    p = 1
    for k in range(1, 10):
        p = p * k
    return(p)
Attention : il faut initialiser p = 1 (pas p = 0, sinon le produit reste à 0). Résultat : $1 \times 2 \times \ldots \times 9 = 362\,880$ .

Partie 5 — Les listes

Listes par ajouts successifs

L1 = [10]
for i in range(11, 101):
    L1 = L1 + [i]
print(L1)

Ce programme crée la liste des entiers de 10 à 100. On peut aussi utiliser L1.append(i).

len(L) : nombre d’éléments de la liste.
L[0] : premier élément (l’indexation commence à 0).
L.append(x) : ajoute $x$ à la fin de $L$ .

Listes en compréhension

L2 = [x**2 for x in range(1, 21)]
print(L2)

Crée la liste des carrés des entiers de 1 à 20 : [1, 4, 9, 16, 25, …, 400].

Avec condition :

L = [x for x in range(0, 101) if x % 7 == 0]

Liste des multiples de 7 entre 0 et 100.

Exemple — L = [2*x+1 for x in range(5, 10)] donne [11, 13, 15, 17, 19].

Algorithmes en langage naturel

Les algorithmes peuvent aussi être écrits en langage naturel (pseudo-code) :

Affecter à n la valeur 0
Affecter à A la valeur 1
Affecter à B la valeur 1
Tant que n < 6
    Affecter à n la valeur de n + 1
    Affecter à C la valeur de B
    Affecter à B la valeur de A + B
    Affecter à A la valeur de C
    Afficher B
Fin Tant que

Cet algorithme affiche les termes de la suite de Fibonacci : 2, 3, 5, 8, 13, 21.

La traduction en Python :

n = 0
A, B = 1, 1
while n < 6:
    n = n + 1
    C = B
    B = A + B
    A = C
    print(B)

Exemple d’application

Énoncé — On considère la fonction $f$ définie par morceaux :

$f(x) = \begin{cases} x^2 + 3 & \text{si } x < 0 \\ 3 - 5x & \text{si } 0 \leq x < 10 \\ -x^2 + 5x + 3 & \text{si } x \geq 10 \end{cases}$

Écrire un programme Python permettant de calculer l’image d’un nombre par $f$ .
def f(x):
    if x < 0:
        return x**2 + 3
    elif x < 10:
        return 3 - 5*x
    else:
        return -x**2 + 5*x + 3
f(-2) → $(-2)^2 + 3 = 7$

f(5) → $3 - 5 \times 5 = -22$

f(10) → $-100 + 50 + 3 = -47$