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

18.1 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

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 :

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

1
1
y

⚠️ 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.

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.

18.2 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`

# 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

42
3.14
2025
['a', 'b', 'c']
(1, 2, 3)
{1, 2, 3}
{'a': 1, 'b': 2}
<class 'float'>
True
True

18.3 `sorted()` vs `sort()`

Rappel du chapitre 5 — 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)

# 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']

[1, 1, 3, 4, 5]
(3, 1, 4, 1, 5) [1, 1, 3, 4, 5]
['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.

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))

['banane', 'fraise', 'kiwi', 'pomme']
['kiwi', 'pomme', 'banane', 'fraise']
['banane', 'fraise', 'pomme', 'kiwi']

key=len veut dire « trier selon la longueur de chaque élément ». On verra d’autres usages de key en Partie 2.

18.4 `reversed()`

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

# 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=" ")

[5, 4, 3, 2, 1]
[1, 2, 3, 4, 5]
['c', 'b', 'a']
cba
30 20 10

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.

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

nohtyp
['n', 'o', 'h', 't', 'y', 'p']

18.5 `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.

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

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

0 : pomme
1 : banane
2 : cerise

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

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

0 : pomme
1 : banane
2 : cerise

Démarrer l’index ailleurs qu’à 0

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

1. Alice
2. Bob
3. Charlie

18.6 `zip()` — associer plusieurs séquences

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

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

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

Alice a 30 ans
Bob a 25 ans
Charlie a 35 ans

Si les longueurs diffèrent

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

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

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

1 x
2 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 :

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

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[14], line 3
      1 a = [1, 2, 3]
      2 b = ["x", "y"]
----> 3 list(zip(a, b, strict=True))

ValueError: zip() argument 2 is shorter than argument 1

Construire un dictionnaire à partir de deux listes

Un idiome Python très courant :

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

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

{'Alice': 30, 'Bob': 25, 'Charlie': 35}

18.7 `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

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

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 :

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)

Tous >=10 ? False
Au moins un >15 ? True
False
True

⚠️ all([]) renvoie True !

Par convention mathématique, « tous les éléments d’un ensemble vide sont vrais » → all([]) est True. Contre-intuitif mais à connaître pour le TOSA.

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

🧩 Quiz 6.1 — Les fonctions natives

Question 1

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

10
[1, 2, 3, 4]
4
24

🔍 Réponse

a) 10 — sum additionne tous les éléments.

print(sum([1, 2, 3, 4]))

Question 2

Que renvoie round(2.5) en Python 3 ?

2
3
2.5
2.0

🔍 Réponse

a) 2 — piège ! Python utilise l’arrondi banquier (au pair le plus proche), pas l’arrondi scolaire. 0.5 arrondit à 0, 1.5 à 2, 2.5 à 2, 3.5 à 4.

for x in [0.5, 1.5, 2.5, 3.5, 4.5]:
    print(f"round({x}) = {round(x)}")

round(0.5) = 0
round(1.5) = 2
round(2.5) = 2
round(3.5) = 4
round(4.5) = 4

Question 3

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

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

🔍 Réponse

b) [(1, 'a'), (2, 'b')] — zip s’arrête à la séquence la plus courte. Depuis Python 3.10, on peut forcer la stricte égalité avec zip(..., strict=True).

print(list(zip([1, 2, 3], ["a", "b"])))

[(1, 'a'), (2, 'b')]

Question 4

Que s’affiche-t-il ?

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

0 a / 1 b / 2 c
1 a / 2 b / 3 c
a 1 / b 2 / c 3
Une erreur

🔍 Réponse

b) 1 a / 2 b / 3 c — le paramètre start=1 fait démarrer l’indice à 1 au lieu de 0.

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

1 a
2 b
3 c

Question 5

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

True
False
None
Une erreur

🔍 Réponse

b) False — tous ces éléments sont falsy. any renvoie True s’il y a au moins un élément vrai ; ici il n’y en a aucun.

print(any([0, False, "", None]))

False

Question 6

Que renvoie all([]) ?

True
False
None
Une erreur

🔍 Réponse

a) True — piège TOSA classique ! Par convention mathématique, « tous les éléments d’un ensemble vide vérifient la condition » → True.

print(all([]))    # True
print(any([]))    # False

True
False

Question 7

Que vaut divmod(17, 5) ?

3.4
(3, 2)
[3, 2]
17 // 5

🔍 Réponse

b) (3, 2) — divmod(a, b) renvoie le tuple (a // b, a % b). Ici 17 = 5 × 3 + 2.

print(divmod(17, 5))

(3, 2)

Question 8

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

[1, 2, 3]
[3, 2, 1]
None
[3, 1, 2]

🔍 Réponse

b) [3, 2, 1] — reverse=True trie dans l’ordre décroissant.

print(sorted([3, 1, 2], reverse=True))

[3, 2, 1]

✏️ Exercice 10.1 — Statistiques en une ligne

Soit une liste de notes [12, 15, 9, 17, 11, 14, 8]. Sans boucle explicite, calculez et affichez :

Le minimum, le maximum et la somme.
La moyenne.
La note la plus éloignée de la moyenne (écart absolu maximum).

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

# 1. min, max, somme
...

# 2. moyenne
...

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

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

# 1
print("Min :", min(notes))
print("Max :", max(notes))
print("Somme :", sum(notes))

# 2
moyenne = sum(notes) / len(notes)
print("Moyenne :", round(moyenne, 2))

# 3
la_plus_eloignee = max(notes, key=lambda n: abs(n - moyenne))
print("Plus éloignée :", la_plus_eloignee)

Min : 8
Max : 17
Somme : 86
Moyenne : 12.29
Plus éloignée : 17

max(notes, key=...) : key est la fonction d’évaluation. On prend l’élément qui maximise cette fonction.
La syntaxe lambda sera détaillée en Partie 3 ; à ce stade, on peut l’accepter telle quelle.

notes = [12, 15, 9, 17, 11, 14, 8]
moyenne = sum(notes) / len(notes)

ecart_max = 0
note_la_plus_eloignee = None
for n in notes:
    ecart = abs(n - moyenne)
    if ecart > ecart_max:
        ecart_max = ecart
        note_la_plus_eloignee = n

print("Plus éloignée :", note_la_plus_eloignee)

Plus éloignée : 17

✏️ Exercice 10.2 — Classement numéroté

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

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é

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

# Trier par score décroissant (2e élément du tuple)
classement = sorted(resultats, key=lambda t: t[1], reverse=True)

# Afficher avec enumerate démarrant à 1
for rang, (prenom, score) in enumerate(classement, start=1):
    print(f"{rang}. {prenom} : {score}")

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

key=lambda t: t[1] → « trier par le 2e élément de chaque tuple ».
enumerate(..., start=1) → démarrer le rang à 1 plutôt que 0.
Déballage (prenom, score) directement dans la boucle for.

✏️ Exercice 10.3 — Zippage de trois listes

Voici 3 listes parallèles :

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

Produisez une liste de dictionnaires de la forme :

[
    {"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)

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

personnes = []
for prenom, age, ville in zip(prenoms, ages, villes):
    personnes.append({"nom": prenom, "age": age, "ville": ville})

for p in personnes:
    print(p)

{'nom': 'Alice', 'age': 30, 'ville': 'Paris'}
{'nom': 'Bob', 'age': 25, 'ville': 'Lyon'}
{'nom': 'Charlie', 'age': 35, 'ville': 'Marseille'}

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

personnes = [
    {"nom": p, "age": a, "ville": v}
    for p, a, v in zip(prenoms, ages, villes)
]
print(personnes)

[{'nom': 'Alice', 'age': 30, 'ville': 'Paris'}, {'nom': 'Bob', 'age': 25, 'ville': 'Lyon'}, {'nom': 'Charlie', 'age': 35, 'ville': 'Marseille'}]

Les compréhensions seront vues en Partie 3.

À retenir

Points clés du chapitre

Les fonctions natives sont toujours disponibles (aucun import nécessaire).
Nombres : abs, round, pow, divmod, min, max, sum.
Conversions : int, float, str, bool, list, tuple, set, dict.
Tests : type, isinstance, len.
sorted() → nouvelle liste | liste.sort() → en place, renvoie None.
enumerate() pour boucler avec l’indice — toujours préférer à range(len(...)).
zip() pour parcourir plusieurs séquences en parallèle, s’arrête à la plus courte.
any() / all() testent globalement. Attention : all([]) est True.
round(2.5) = 2 en Python 3 (arrondi banquier).

← Chapitre précédent : Les boucles • TP récapitulatif →

18.1 Fonctions sur les nombres

18.2 Fonctions de conversion et de test

18.3 sorted() vs sort()

Options de tri

18.4 reversed()

18.5 enumerate() — la boucle avec l’index

Démarrer l’index ailleurs qu’à 0

18.6 zip() — associer plusieurs séquences

Si les longueurs diffèrent

Construire un dictionnaire à partir de deux listes

18.7 any() et all()

Cas d’usage typique

18.8 Tableau récapitulatif

🧩 Quiz 6.1 — Les fonctions natives

Question 1

Question 2

Question 3

Question 4

Question 5

Question 6

Question 7

Question 8

✏️ Exercice 10.1 — Statistiques en une ligne

✏️ Exercice 10.2 — Classement numéroté

✏️ Exercice 10.3 — Zippage de trois listes

À retenir

18.3 `sorted()` vs `sort()`

18.4 `reversed()`

18.5 `enumerate()` — la boucle avec l’index

18.6 `zip()` — associer plusieurs séquences

18.7 `any()` et `all()`