Partie 1 — Apprendre les bases de Python

Variables et affectation

Une variable stocke une valeur en memoire. L’affectation se fait avec le signe =.

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$ .

Operations de base

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

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

Types de variables

Type	Python	Exemple
Entier	`int`	`x = 5`
Decimal	`float`	`x = 3.14`
Chaine de caracteres	`str`	`x = 'bonjour'`
Booleen	`bool`	`x = True`

Astuce — La fonction type(x) permet de connaitre le type d’une variable.

Afficher et saisir

print(x) : affiche la valeur de x dans la console.
input("Message") : demande une saisie a l’utilisateur (renvoie toujours une chaine str).

x = 10
y = 20
z = x * y
z = z + x
print(z)

Python affiche : 210. En effet, $z = 10 \times 20 = 200$ , puis $z = 200 + 10 = 210$ .

Partie 2 — Utiliser les fonctions

Une fonction recoit des parametres en entree et renvoie un resultat avec return.

from math import *

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

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

Importer des fonctions mathematiques

from math import * donne acces a pi, sqrt (racine carree), cos, sin, etc.

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

Ce programme calcule l’hypotenuse d’un triangle rectangle de cotes 5 et 9 : $c = \sqrt{5^2 + 9^2} = \sqrt{106} \approx 10{,}3$ .

Fonctions simples

def f(x):
    return(x**2 + 2)

En saisissant f(5), on obtient $5^2 + 2 = 27$ .

def fonction(a):
    reponse = a / 3
    return(reponse)

fonction(12) donne $12 \div 3 = 4{,}0$
fonction(33) donne $33 \div 3 = 11{,}0$

Exemple — Calculer le volume d’un cylindre :
from math import *
hauteur = 5
rayon = 4
base = pi * rayon**2
volume = base * hauteur
print(volume)
Resultat : $V = \pi \times 4^2 \times 5 = 80\pi \approx 251{,}3$ .

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

if / else

from random import *

def jeu():
    de = randint(1, 6)
    if de > 4:
        a = 'gagne'
    else:
        a = 'perdu'
    return(de, a)

randint(1, 6) : nombre aleatoire entier de 1 a 6.
if condition: s’execute si la condition est vraie.
else: s’execute 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)

note(16) donne 'super' (car $15 < 16 \leq 20$ )
note(15) donne 'ca va' (car $10 \leq 15 \leq 15$ )
note(9) donne 'ouaip'

Operateurs de comparaison

Operateur	Signification
`==`	egal a
`!=`	different de
`<`	strictement inferieur
`>`	strictement superieur
`<=`	inferieur ou egal
`>=`	superieur ou egal

Exemple — Tester la divisibilite :
def div(n):
    if n % 3 == 0:
        N = n / 3
    else:
        N = 0
    return(N)
div(24) donne $24 \div 3 = 8{,}0$ . div(41) donne $0$ (car 41 n’est pas divisible par 3).

Partie 4 — Utiliser les boucles

La boucle “Pour” (for)

La boucle for repete des instructions un nombre determine 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 (debut 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$ .

Exemple — Afficher les entiers de 1 a 4 :
for k in range(1, 5):
    print(k)
Affiche : 1, 2, 3, 4.

Exemple — Calculer $p = 2k$ pour $k$ de 1 a 3 :
for k in range(1, 4):
    p = 2 * k
    print(p)
Affiche : 2, 4, 6.

Concatenation de chaines dans une boucle

def com():
    c = 'on est au '
    for k in range(3):
        c = c + 'top '
    return(c)

com() renvoie 'on est au top top top '. La boucle for k in range(3) s’execute 3 fois ( $k$ va de 0 a 2).

Le produit des entiers

def prod():
    p = 1
    for k in range(1, 10):
        p = p * k
    return(p)

Ce programme calcule $1 \times 2 \times 3 \times \ldots \times 9 = 362\,880$ .

Attention : il faut initialiser p = 1 (pas p = 0, sinon le produit reste toujours a 0 !).

La boucle “Tant que” (while)

La boucle while s’execute tant que la condition est vraie.

n = 0
while n < 10:
    print(n)
    n = n + 1

Affiche les entiers de 0 a 9. La boucle s’arrete quand $n = 10$ (la condition $n < 10$ devient fausse).

Recherche de seuil

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

Ce programme cherche a partir de quel entier $n$ la somme $1 + 2 + \ldots + n$ depasse $10\,000$ . Resultat : 141.

Exemple — Trouver la plus petite valeur de $n$ telle que $2^n > 1\,000$ :
def seuil():
    n = 1
    while 2**n <= 1000:
        n = n + 1
    return(n)
seuil() renvoie 10, car $2^{10} = 1\,024 > 1\,000$ .

Algorithme en langage naturel

Un algorithme peut etre ecrit en langage naturel avant d’etre traduit en Python.

Exemple — Suite de Fibonacci :

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

Traduction en Python :

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

$n$	0	1	2	3	4	5	6
$A$	1	1	2	3	5	8	13
$B$	1	2	3	5	8	13	21
$C$		1	1	2	3	5	8