Informatique de prépa

1.1

Valeurs, variables, conditions, boucles et fonctions

Notions : types de base, affectation, opérateurs arithmétiques et logiques, conversions, instruction conditionnelle, boucles for et while, range, fonctions, paramètres et valeur de retour, portée des variables, print ou return

Cours

Un programme Python est une suite d'instructions exécutées dans l'ordre. Il manipule des valeurs (des nombres, du texte, des booléens…) que l'on range dans des variables. Tout ce chapitre se teste dans un interpréteur : tape chaque exemple toi-même, c'est la seule façon d'apprendre à programmer.

Valeurs et types

Définition Type d'une valeur

Chaque valeur a un type, que donne type(v). Les types de base du programme sont :

int : les entiers relatifs, sans limite de taille (2**100 est calculé exactement) ;
float : les nombres à virgule flottante, approximations des réels (3.14, 1e-9) ;
bool : les booléens True et False ;
str : les chaînes de caractères, entre apostrophes ou guillemets ('abc', "l'été") ;
NoneType : la seule valeur None, qui signifie « rien ».

Proposition Opérateurs arithmétiques

Sur les nombres : +, -, *, la division / (qui renvoie toujours un flottant), la puissance **, et, sur les entiers, le quotient a // b et le reste a % b de la division euclidienne. Pour $b > 0$ , ils vérifient

a = b \cdot q + r avec q = a // b, r = a, 0 \leq r < b,

y compris pour $a < 0$  : -7 // 2 vaut -4 et -7 % 2 vaut 1.

print(7 / 2, 7 // 2, 7 % 2)      # 3.5 3 1
print(-7 // 2, -7 % 2)           # -4 1
print(2 ** 100)                  # entier exact à 31 chiffres
print(type(4 / 2))               # <class 'float'> : 4 / 2 vaut 2.0

Attention Les flottants sont approchés

0.1 + 0.2 == 0.3 vaut False : les flottants sont stockés en binaire avec 53 bits de précision, et $0, 1$ n'a pas d'écriture binaire finie (chapitre 4). On ne teste jamais l'égalité de deux flottants ; on teste abs(x - y) < eps.

Proposition Booléens et comparaisons

Les comparaisons ==, !=, <, <=, >, >= renvoient un booléen. On les combine avec and, or, not. Ces opérateurs sont paresseux : dans a and b, si a est faux, b n'est pas évalué ; dans a or b, si a est vrai, b n'est pas évalué. Ainsi n != 0 and 10 % n == 0 ne provoque jamais de division par zéro.

Proposition Conversions

int(x), float(x), str(x), bool(x) convertissent une valeur. int(3.9) vaut 3 (troncature vers zéro), int('42') vaut 42, str(42) vaut '42'. La fonction input() renvoie toujours une chaîne, qu'il faut convertir pour calculer.

Variables et affectation

Définition Affectation

L'instruction x = expr évalue d'abord l'expression expr, puis donne le nom x à la valeur obtenue. Ce n'est pas une égalité mathématique : x = x + 1 augmente x de $1$ . Raccourcis : x += 1, x *= 2, etc. L'affectation multiple a, b = b, a + b évalue toute la partie droite avant d'affecter : c'est la bonne façon d'échanger deux variables (a, b = b, a).

Exemple Tableau d'états

Pour comprendre un programme, on suit l'état des variables ligne par ligne.

a, b = 0, 1
for k in range(5):
    a, b = b, a + b
print(a)        # 5 : a parcourt 0, 1, 1, 2, 3, 5 (suite de Fibonacci)

Après chaque tour : $(a, b) = (1, 1), (1, 2), (2, 3), (3, 5), (5, 8)$ .

Instruction conditionnelle

Définition if, elif, else

def signe(x):
    if x > 0:
        return 1
    elif x < 0:
        return -1
    else:
        return 0

Le bloc exécuté est le premier dont la condition est vraie ; else attrape tous les autres cas. Les blocs sont délimités par l'indentation (quatre espaces) : elle fait partie de la syntaxe.

Boucles

Définition Boucle for et range

for x in s: exécute le corps une fois pour chaque élément de s (liste, chaîne, intervalle…). range(n) produit $0, 1, \dots, n - 1$  ; range(a, b) produit $a, \dots, b - 1$  ; range(a, b, p) avance de $p$ en $p$ . La borne de droite est exclue.

s = 0
for k in range(1, 101):
    s += k
print(s)                          # 5050
print(list(range(10, 0, -3)))     # [10, 7, 4, 1]

Définition Boucle while

while cond: répète le corps tant que cond est vraie. On l'utilise quand on ne connaît pas à l'avance le nombre de tours. Il faut s'assurer que la condition finit par devenir fausse, sinon le programme ne s'arrête pas (chapitre 3).

def nb_chiffres(n):
    """Nombre de chiffres de l'entier n >= 1 en base 10."""
    c = 0
    while n > 0:
        n = n // 10
        c += 1
    return c

assert nb_chiffres(7) == 1 and nb_chiffres(2026) == 4

Remarque

break sort immédiatement de la boucle la plus intérieure, continue passe au tour suivant. Dans une fonction, un return placé dans une boucle arrête à la fois la boucle et la fonction : c'est souvent la façon la plus lisible d'écrire une recherche.

Fonctions

Définition Fonction

def moyenne(a, b):
    """Renvoie la moyenne de a et b."""
    return (a + b) / 2

a et b sont les paramètres ; lors de l'appel moyenne(3, 5), ils reçoivent les arguments $3$ et $5$ . L'instruction return termine la fonction et renvoie une valeur. Une fonction sans return renvoie None. La chaîne sous la ligne def est la docstring : elle décrit ce que fait la fonction.

Attention print n'est pas return

print affiche une valeur à l'écran, pour un humain ; return renvoie une valeur au programme, qui peut la réutiliser. Une fonction qui calcule doit renvoyer son résultat. Aux concours, une fonction qui affiche au lieu de renvoyer est comptée fausse.

Proposition Portée des variables

Les variables affectées dans une fonction (et ses paramètres) sont locales : elles n'existent que pendant l'appel et ne modifient pas les variables du même nom à l'extérieur. Une fonction peut lire une variable globale, mais on évite de le faire : tout ce dont la fonction a besoin doit passer par ses paramètres.

x = 10
def f(x):
    x = x + 1
    return x
print(f(3), x)    # 4 10 : le x global n'a pas changé

Vrai ou faux ? Réponds avant d'ouvrir.

7 / 7 est un entier.

Faux. C'est le flottant 1.0 : l'opérateur / renvoie toujours un flottant. Le quotient entier s'écrit 7 // 7.

-7 % 3 vaut 2.

Vrai. Python garantit un reste dans $[0, 3 [$  : $- 7 = 3 \cdot (- 3) + 2$ .

range(1, 10) contient

10

Faux. La borne de droite est exclue : il produit $1, \dots, 9$ .

Une fonction sans return renvoie None.

Vrai. C'est la valeur renvoyée par défaut, ce qui explique les None qui s'affichent quand on a oublié le return.

Après a = 3 puis b = a puis a = 5, b vaut

5

Faux. b = a donne le nom b à la valeur $3$  ; réaffecter a ne change pas b.