Les fonctions natives de Python

Python propose des dizaines de fonctions « toujours disponibles » sans aucun import. On les appelle fonctions natives (ou built-ins). Certaines ont déjà été croisées (print, input, len, range, type…) ; ce chapitre fait le tour d'horizon des fonctions essentielles pour le TOSA.

Fonctions sur les nombres

Fonction	Effet
`abs(x)`	Valeur absolue
`round(x)`	Arrondi à l'entier le plus proche
`round(x, n)`	Arrondi à `n` décimales
`pow(x, y)`	`x` à la puissance `y` (équivaut à `x ** y`)
`divmod(a, b)`	Tuple `(a // b, a % b)` en un seul calcul
`min(a, b, …)`	Minimum
`max(a, b, …)`	Maximum
`sum(iterable)`	Somme des éléments d'un itérable

python

print(abs(-5))                 # 5
print(abs(3.14))               # 3.14

print(round(3.7))              # 4
print(round(3.14159, 2))       # 3.14

print(pow(2, 10))              # 1024

print(divmod(17, 5))           # (3, 2) → 17 = 5*3 + 2

min et max fonctionnent aussi avec des arguments séparés ou un itérable :

python

print(min(3, 7, 1, 9))          # arguments séparés
print(min([3, 7, 1, 9]))        # liste
print(max("python"))            # lettre avec le plus grand code ASCII

⚠️ Piège TOSA : round et la règle « banquier »

Python utilise l'arrondi « au pair le plus proche » (banker's rounding), pas l'arrondi scolaire.

python

print(round(0.5))        # 0  (pas 1 !)
print(round(1.5))        # 2
print(round(2.5))        # 2  (pas 3 !)
print(round(3.5))        # 4

C'est surprenant mais mathématiquement plus équilibré à grande échelle. Pour un arrondi scolaire classique, passez par math.floor + + 0.5 ou utilisez une autre approche.

Fonctions de conversion et de test

Fonction	Effet
`int(x)`	Convertit en entier (troncature pour les floats)
`float(x)`	Convertit en flottant
`str(x)`	Convertit en chaîne
`bool(x)`	Convertit en booléen
`list(iter)`	Convertit en liste
`tuple(iter)`	Convertit en tuple
`set(iter)`	Convertit en set
`dict(pairs)`	Crée un dict depuis des paires
`type(x)`	Type de `x`
`len(x)`	Nombre d'éléments
`isinstance(x, T)`	Teste si `x` est de type `T`

python

# Conversions
print(int("42"))
print(float("3.14"))
print(str(2025))
print(list("abc"))
print(tuple([1, 2, 3]))
print(set([1, 2, 2, 3]))
print(dict([("a", 1), ("b", 2)]))    # depuis liste de tuples

# Tests
print(type(3.14))
print(isinstance(3.14, float))        # True
print(isinstance(3.14, (int, float))) # True si l'un OU l'autre

`sorted()` vs `sort()`

Rappel du chapitre 6 (les listes) — deux façons de trier, à ne pas confondre :

	`liste.sort()`	`sorted(iterable)`
Action	Modifie la liste en place	Crée une nouvelle liste triée
Retour	`None`	La nouvelle liste
Sur un tuple/chaîne ?	❌ (tuples immuables)	✅ (accepte tout itérable)

python

# sort() : modifie en place, RENVOIE None
l = [3, 1, 4, 1, 5]
l.sort()
print(l)                    # [1, 1, 3, 4, 5]

# sorted() : renvoie une nouvelle liste
t = (3, 1, 4, 1, 5)
t_trie = sorted(t)
print(t, t_trie)            # tuple inchangé, nouvelle liste triée

# Avec une chaîne
print(sorted("python"))     # ['h', 'n', 'o', 'p', 't', 'y']

Options de tri

sorted() et sort() acceptent deux paramètres utiles :

reverse=True : ordre décroissant.
key=... : fonction qui extrait la clé de tri.

python

mots = ["banane", "kiwi", "pomme", "fraise"]

# Par ordre alphabétique par défaut
print(sorted(mots))

# Par longueur
print(sorted(mots, key=len))

# Par longueur décroissante
print(sorted(mots, key=len, reverse=True))

key=len veut dire « trier selon la longueur de chaque élément ».

Une clé sur mesure : `lambda`

Quand aucune fonction toute faite ne convient, on écrit la clé sur place avec lambda : une fonction d'une seule expression, sans nom. lambda n: abs(n - 12) se lit « à chaque n, associer abs(n - 12) ». min() et max() acceptent le même paramètre key :

python

notes = [12, 15, 9, 17, 11]
# La note la plus éloignée de 12
print(max(notes, key=lambda n: abs(n - 12)))

eleves = [("Alice", 15), ("Bob", 12), ("Charlie", 17)]
# Trier par score (2e élément de chaque tuple), du meilleur au moins bon
print(sorted(eleves, key=lambda e: e[1], reverse=True))

Les lambda ont leur propre chapitre en Partie 3. Pour l'instant, retenez cette forme : key=lambda x: <ce qui sert à comparer x>.

`reversed()`

Inverse l'ordre d'une séquence. Renvoie un itérateur — souvent converti en liste.

python

# Sur une liste
l = [1, 2, 3, 4, 5]
print(list(reversed(l)))    # [5, 4, 3, 2, 1]
print(l)                     # inchangé

# Sur une chaîne
print(list(reversed("abc")))
print("".join(reversed("abc")))   # 'cba'

# Dans une boucle
for x in reversed([10, 20, 30]):
    print(x, end=" ")

reversed() vs [::-1]

Les deux inversent une séquence :

[::-1] → fonctionne sur séquences indexables (liste, tuple, str), renvoie du même type.
reversed(...) → fonctionne sur tout itérable, renvoie un itérateur.

python

print("python"[::-1])             # 'nohtyp' (str)
print(list(reversed("python")))   # ['n', 'o', 'h', 't', 'y', 'p']

`enumerate()` — la boucle avec l'index

Une des fonctions les plus utilisées en Python. Permet de parcourir une séquence en ayant à la fois l'indice et la valeur.

python

fruits = ["pomme", "banane", "cerise"]

for i, fruit in enumerate(fruits):
    print(i, ":", fruit)

Équivalent non idiomatique avec range(len(...)) :

python

# ❌ À éviter (moins lisible)
for i in range(len(fruits)):
    print(i, ":", fruits[i])

Démarrer l'index ailleurs qu'à 0

python

# Démarrer à 1 (pour afficher un classement par exemple)
for rang, nom in enumerate(["Alice", "Bob", "Charlie"], start=1):
    print(f"{rang}. {nom}")

`zip()` — associer plusieurs séquences

zip() combine plusieurs itérables en paires (ou tuples). Très utile pour parcourir deux listes en parallèle.

python

prenoms = ["Alice", "Bob", "Charlie"]
ages = [30, 25, 35]

for prenom, age in zip(prenoms, ages):
    print(f"{prenom} a {age} ans")

Si les longueurs diffèrent

zip() s'arrête à la plus courte séquence, sans erreur :

python

a = [1, 2, 3, 4, 5]
b = ["x", "y"]

for x, y in zip(a, b):
    print(x, y)

Depuis Python 3.10 : zip(strict=True)

Python 3.10 introduit un paramètre strict=True qui lève une erreur si les longueurs diffèrent. Utile pour détecter les bugs silencieux :

python

a = [1, 2, 3]
b = ["x", "y"]
list(zip(a, b, strict=True))

Construire un dictionnaire à partir de deux listes

Un idiome Python très courant :

python

prenoms = ["Alice", "Bob", "Charlie"]
ages = [30, 25, 35]

personnes = dict(zip(prenoms, ages))
print(personnes)

`any()` et `all()`

Ces deux fonctions testent globalement un itérable de booléens :

Fonction	Renvoie `True` si...
`any(iter)`	Au moins un élément est vrai
`all(iter)`	Tous les éléments sont vrais

python

print(any([False, False, True]))     # True (au moins un True)
print(any([False, False, False]))    # False

print(all([True, True, True]))       # True (tous True)
print(all([True, False, True]))      # False

Cas d'usage typique

Ces fonctions sont parfaites combinées à une expression génératrice (vue en Partie 3), mais même sans, elles sont utiles :

python

notes = [12, 15, 14, 8, 17]

# Tous les élèves ont-ils la moyenne ?
tous_ok = all(n >= 10 for n in notes)
print("Tous >=10 ?", tous_ok)

# Au moins un élève a-t-il plus de 15 ?
au_moins_un = any(n > 15 for n in notes)
print("Au moins un >15 ?", au_moins_un)

# Collection vide : cas particulier
print(any([]))    # False : pas d'élément vrai
print(all([]))    # True ! (pas de contre-exemple)

Au-delà des fonctions natives : importer un module

Les fonctions natives sont toujours disponibles. Beaucoup d'autres sont rangées dans des modules de la bibliothèque standard, qu'on charge avec import :

python

import math
print(math.sqrt(16))    # 4.0
print(math.pi)          # 3.141592653589793

from random import randint
print(randint(1, 6))    # un entier entre 1 et 6

import math donne accès à tout le module, dont on préfixe chaque fonction par math. ; from random import randint n'importe qu'une fonction, utilisable directement. Les modules les plus utiles sont détaillés en Partie 2.

Tableau récapitulatif

Voici les fonctions natives à maîtriser pour le niveau Basique :

Fonction	Famille	Usage principal
`print()`	Sortie	Afficher à l'écran
`input()`	Entrée	Lire au clavier (toujours `str`)
`len()`	Taille	Nombre d'éléments
`type()`	Type	Connaître le type
`isinstance()`	Type	Tester le type
`int`, `float`, `str`, `bool`, `list`, `tuple`, `set`, `dict`	Conversion	Convertir un type en un autre
`range()`	Séquence	Générer une plage de nombres
`abs()`, `round()`, `pow()`, `divmod()`	Nombres	Calculs arithmétiques
`min()`, `max()`, `sum()`	Nombres	Statistiques de base
`sorted()`	Séquence	Nouvelle liste triée
`reversed()`	Séquence	Itérateur inversé
`enumerate()`	Séquence	Boucle avec indice
`zip()`	Séquence	Parcours parallèle
`any()`, `all()`	Booléens	Test global

Apprenez ce tableau par cœur — toutes ces fonctions apparaissent au TOSA.

Exercices

quiz 01.10.q1réponse unique

Que renvoie sum([1, 2, 3, 4]) ?

a4
b10
c24
d[1, 2, 3, 4]

quiz 01.10.q2réponse unique

Que renvoie round(2.5) en Python 3 ?

a2.5
b2
c3
d2.0

quiz 01.10.q3réponse unique

Que renvoie list(zip([1, 2, 3], ["a", "b"])) ?

a[1, 2, 3, 'a', 'b']
bUne erreur (longueurs différentes)
c[(1, 'a'), (2, 'b')]
d[(1, 'a'), (2, 'b'), (3, None)]

quiz 01.10.q4réponse unique

Que s'affiche-t-il ?

for i, c in enumerate("abc", start=1):
    print(i, c)

aUne erreur
ba 1 / b 2 / c 3
c0 a / 1 b / 2 c
d1 a / 2 b / 3 c

quiz 01.10.q5réponse unique

Que renvoie any([0, False, "", None]) ?

aUne erreur
bNone
cFalse
dTrue

quiz 01.10.q6réponse unique

Que renvoie all([]) ?

aUne erreur
bNone
cTrue
dFalse

quiz 01.10.q7réponse unique

Que vaut divmod(17, 5) ?

a17 // 5
b(3, 2)
c3.4
d[3, 2]

quiz 01.10.q8réponse unique

Que renvoie sorted([3, 1, 2], reverse=True) ?

aNone
b[1, 2, 3]
c[3, 1, 2]
d[3, 2, 1]

exercice 01.10.x1à faire

Soit la liste de notes notes = [12, 15, 9, 17, 11, 14, 8]. Sans boucle explicite, calculez et affichez, en rangeant chaque résultat dans la variable indiquée :

note_min, note_max et somme : le minimum, le maximum et la somme.
moyenne : la moyenne.
la_plus_eloignee : la note la plus éloignée de la moyenne (écart absolu maximum).

notes = [12, 15, 9, 17, 11, 14, 8]

# 1. min, max, somme
note_min = ...
note_max = ...
somme = ...

# 2. moyenne
moyenne = ...

# 3. note la plus éloignée de la moyenne
la_plus_eloignee = ...

exercice 01.10.x2à faire

Soit la liste resultats de tuples (prenom, score). Affichez le classement numéroté du meilleur au moins bon, sous la forme :

text

1. Charlie : 17
2. Alice : 15
3. Bob : 12

resultats = [("Alice", 15), ("Bob", 12), ("Charlie", 17)]

# Trier par score décroissant, puis afficher numéroté

exercice 01.10.x3à faire

Voici 3 listes parallèles :

python

prenoms = ["Alice", "Bob", "Charlie"]
ages = [30, 25, 35]
villes = ["Paris", "Lyon", "Marseille"]

Produisez une liste de dictionnaires de la forme :

python

[
    {"nom": "Alice", "age": 30, "ville": "Paris"},
    {"nom": "Bob", "age": 25, "ville": "Lyon"},
    ...
]

prenoms = ["Alice", "Bob", "Charlie"]
ages = [30, 25, 35]
villes = ["Paris", "Lyon", "Marseille"]

# Construire une liste de dicts avec zip + boucle
personnes = []
...
print(personnes)

Fonctions sur les nombres

Fonctions de conversion et de test

sorted() vs sort()

Options de tri

Une clé sur mesure : lambda

reversed()

enumerate() — la boucle avec l'index

Démarrer l'index ailleurs qu'à 0

zip() — associer plusieurs séquences

Si les longueurs diffèrent

Construire un dictionnaire à partir de deux listes

any() et all()

Cas d'usage typique

Au-delà des fonctions natives : importer un module

Tableau récapitulatif

Exercices

À retenir

`sorted()` vs `sort()`

Une clé sur mesure : `lambda`

`reversed()`

`enumerate()` — la boucle avec l'index

`zip()` — associer plusieurs séquences

`any()` et `all()`