Fonctions intégrées (builtins) en Python

🧮 Le cours : les fonctions intégrées

Les builtins sont des fonctions et des types déjà disponibles dans tout programme Python, sans import. Elles servent à mesurer, parcourir, tester, convertir, afficher. À l'épreuve de NSI, on attend surtout que tu les utilises dans un petit programme plutôt que tu les réécrives : savoir qu'elles existent fait gagner beaucoup de temps.

Mesurer : len, min, max, sum

len donne la taille d'une séquence (liste, texte, tuple), d'un dictionnaire ou d'un ensemble. min, max et sum s'appliquent à une suite de nombres ; min et max acceptent aussi key=fonction pour comparer selon un critère, et default= pour éviter l'erreur sur une suite vide. sum(suite, debut) additionne à partir de debut.

notes = [12, 15, 9, 14]
print(len(notes), len("NSI"), len({"a": 1}))
print(min(notes), max(notes), sum(notes))
print(max(["python", "c", "java"], key=len))
print(max([], default=0), sum([[1], [2]], []))
print(sum(notes) / len(notes))

4 3 1
9 15 50
python
0 [1, 2]
12.5

Calculer : abs, round, divmod, pow

abs(x) donne la valeur absolue, round(x, n) arrondit à n décimales (sans n, à l'entier ; un x.5 exact est arrondi au pair), divmod(a, b) renvoie le quotient et le reste d'un coup, pow(a, b) équivaut à a ** b (et pow(a, b, m) calcule a ** b % m efficacement).

print(abs(-7), abs(3.5))
print(round(3.14159, 2), round(2.5), round(7.5), round(1234, -2))
print(divmod(135, 60))
minutes, secondes = divmod(135, 60)
print(f"{minutes} min {secondes} s")
print(pow(2, 10), pow(2, 10, 1000))

7 3.5
3.14 2 8 1200
(2, 15)
2 min 15 s
1024 24

Convertir : int, float, str, bool, list, tuple, dict, set

Chaque type possède une fonction du même nom qui convertit une valeur vers ce type (ou crée une valeur vide sans argument). list, tuple et set acceptent n'importe quelle suite : un texte, un range, un dictionnaire (ses clés)… bin, oct et hex donnent l'écriture d'un entier dans une autre base, ord et chr passent d'un caractère à son code.

print(int("42"), float("2.5"), str(7), bool(""), bool("a"))
print(list("abc"), tuple([1, 2]), set([1, 1, 2]) == {1, 2})
print(dict([("a", 1), ("b", 2)]), list({"x": 1, "y": 2}))
print(bin(10), oct(8), hex(255), int("1010", 2))
print(ord("A"), chr(66), list(range(3)))

42 2.5 7 False True
['a', 'b', 'c'] (1, 2) True
{'a': 1, 'b': 2} ['x', 'y']
0b1010 0o10 0xff 10
65 B [0, 1, 2]

Connaître et tester un type : type, isinstance, callable

type(x) donne le type exact, isinstance(x, type) teste l'appartenance (et accepte un tuple de types : isinstance(x, (int, float))). callable(x) dit si on peut appeler x comme une fonction.

print(type(3), type("a"), type([1]))
print(isinstance(3, int), isinstance(3.0, (int, float)), isinstance("a", int))
print(callable(len), callable(3))

<class 'int'> <class 'str'> <class 'list'>
True True False
True False

Parcourir : range, enumerate, zip, reversed

range, enumerate, zip et reversed fabriquent des suites que l'on parcourt avec for (voir la fiche Boucles). Ils ne construisent pas la liste complète : on enveloppe le résultat dans list(...) pour le voir en entier.

print(list(range(1, 10, 3)), list(reversed([1, 2, 3])))
print(list(enumerate("ab")), list(enumerate("ab", 1)))
print(list(zip([1, 2, 3], "ab")))
print(dict(zip(["a", "b"], [1, 2])))

[1, 4, 7] [3, 2, 1]
[(0, 'a'), (1, 'b')] [(1, 'a'), (2, 'b')]
[(1, 'a'), (2, 'b')]
{'a': 1, 'b': 2}

Trier : sorted et ses options

sorted(suite) renvoie une nouvelle liste triée, quel que soit le type de la suite (liste, texte, dictionnaire, ensemble…). Les options key (la fonction qui donne le critère de tri) et reverse s'appliquent comme avec liste.sort().

print(sorted([3, 1, 2]), sorted("python"), sorted({"b": 1, "a": 2}))
eleves = [("Ada", 18), ("Lin", 15), ("Max", 17)]
print(sorted(eleves, key=lambda e: e[1])[0])
print(sorted(eleves, key=lambda e: e[1], reverse=True)[0])

[1, 2, 3] ['h', 'n', 'o', 'p', 't', 'y'] ['a', 'b']
('Lin', 15)
('Ada', 18)

Appliquer une fonction à tous les éléments : map et filter

map(f, suite) applique f à chaque élément ; filter(f, suite) ne garde que ceux pour lesquels f est vraie. Ils renvoient des itérateurs paresseux, qu'on convertit avec list(...). Une compréhension de liste est souvent plus lisible : [f(x) for x in suite if cond(x)].

nombres = [1, 2, 3, 4, 5, 6]
print(list(map(lambda x: x * x, nombres)))
print(list(filter(lambda x: x % 2 == 0, nombres)))
print(list(map(str.upper, ["a", "b"])), list(map(int, "123")))
print([x * x for x in nombres if x % 2 == 0])

[1, 4, 9, 16, 25, 36]
[2, 4, 6]
['A', 'B'] [1, 2, 3]
[4, 16, 36]

Tester un ensemble de valeurs : any et all

any(suite) est vrai si au moins un élément est vrai ; all(suite) est vrai si tous le sont (et il est vrai sur une suite vide). On les combine avec une expression génératrice pour écrire en une ligne « y a-t-il un élève admis ? » ou « tous les élèves sont-ils admis ? ».

notes = [12, 15, 9, 14]
print(any(n >= 15 for n in notes), all(n >= 10 for n in notes))
print(any([]), all([]))
print(any(mot.startswith("p") for mot in ["java", "python"]))

True False
False True
True

Afficher et lire : print et input

print(a, b, sep="-", end="") affiche plusieurs valeurs : sep règle le séparateur (une espace par défaut) et end ce qui termine la ligne (un retour à la ligne par défaut). input(message) lit une ligne tapée au clavier et la renvoie toujours sous forme de texte.

print("a", "b", "c")
print("a", "b", "c", sep="")
print("un", end=" / ")
print("deux")
print("Total :", 12.5, True, None)

a b c
abc
un / deux
Total : 12.5 True None

Lire et écrire un fichier : open

open(nom, mode) ouvre un fichier : mode "r" pour lire, "w" pour écrire (en effaçant l'ancien contenu), "a" pour ajouter à la fin. On l'écrit presque toujours avec with, qui ferme le fichier automatiquement, même en cas d'erreur. L'encodage se précise avec encoding="utf-8".

with open("notes.txt", "w", encoding="utf-8") as f:
    f.write("Ada;18\n")
    f.write("Lin;17\n")

with open("notes.txt", encoding="utf-8") as f:
    for ligne in f:
        nom, note = ligne.strip().split(";")
        print(nom, int(note) + 1)

with open("notes.txt", encoding="utf-8") as f:
    print(len(f.read().splitlines()))

Ada 19
Lin 18
2

S'aider soi-même : help, dir, vars

Dans la console Python, help(fonction) affiche la documentation d'une fonction, dir(objet) liste ses attributs et méthodes, vars(objet) donne le dictionnaire de ses attributs. Ce sont des outils d'exploration : quand une méthode de liste ou de texte te manque, dir("") ou dir([]) la révèle.

methodes = [m for m in dir("") if not m.startswith("_")]
print(len(methodes) > 40, "upper" in methodes, "split" in methodes)
print("append" in dir([]), "append" in dir(()))

True True True
True False

⚠️ Erreurs fréquentes

Écraser une fonction intégrée avec une variable

Les noms sum, max, min, list, str, len, input, type… sont des noms ordinaires : si tu en fais des variables, la fonction intégrée disparaît dans ton programme. Choisis d'autres noms (somme, maximum, liste_notes).

sum = 0
for x in [1, 2, 3]:
    sum += x
print(sum([4, 5]))

TypeError: 'int' object is not callable

somme = 0
for x in [1, 2, 3]:
    somme += x
print(somme, sum([4, 5]))

6 9

max ou min d'une suite vide

max([]) et min([]) lèvent une ValueError. Teste la suite avant, ou donne une valeur par défaut avec default=.

notes = []
print(max(notes))

ValueError

notes = []
print(max(notes, default="aucune note"))

aucune note

len d'un nombre

len s'applique aux séquences et aux collections, pas aux nombres : pour compter les chiffres d'un entier, passe par str.

print(len(2026))

TypeError: object of type 'int' has no len()

print(len(str(2026)))

4

Additionner des textes avec sum

sum ne sait additionner que des nombres. Pour coller des textes, utilise "".join(...).

print(sum(["a", "b"]))

TypeError: unsupported operand type(s) for +: 'int' and 'str'

print("".join(["a", "b"]))

ab

map, filter, zip et reversed ne donnent pas une liste

Ces fonctions renvoient des itérateurs : on les parcourt une seule fois, et les afficher directement n'est pas lisible. Entoure-les de list(...) pour voir leur contenu — et note qu'un itérateur déjà parcouru est vide.

pairs = filter(lambda x: x % 2 == 0, range(10))
print(list(pairs))
print(list(pairs))

[0, 2, 4, 6, 8]
[]

zip s'arrête à la plus courte

Si les deux suites n'ont pas la même longueur, zip ignore silencieusement les éléments en trop de la plus longue.

prenoms = ["Ada", "Lin", "Max"]
notes = [18, 17]
print(list(zip(prenoms, notes)))

[('Ada', 18), ('Lin', 17)]

int() ne lit pas tous les textes

int("3.5") et int("12 ") posent problème : int n'accepte que l'écriture d'un entier (les espaces autour sont tolérés). Pour un décimal, passe par float.

print(int(" 12 "), int("-3"), int(float("3.5")))

12 -3 3

Oublier de fermer un fichier

Un fichier ouvert sans with doit être fermé explicitement avec close(), sinon son contenu peut ne pas être écrit. Prends l'habitude de with open(...) as f:.

f = open("notes.txt", "w")
f.write("Ada;18")
# f.close() oublié : le fichier peut rester incomplet

with open("notes.txt", "w") as f:
    f.write("Ada;18")
print(open("notes.txt").read())

Ada;18

📋 Aide-mémoire

• min / max / sorted acceptent key=fonction ; sorted accepte reverse=True ; max / min acceptent default= pour une suite vide.
• map, filter, zip, reversed, enumerate renvoient des itérateurs : list(...) pour les voir, un seul parcours.
• round(x) arrondit au pair pour x.5 ; int(x) tronque vers zéro ; divmod(a, b) renvoie (a // b, a % b).
• input() renvoie un texte ; print(..., sep=, end=) règle séparateur et fin de ligne.
• with open(nom, mode, encoding="utf-8") as f: : modes "r", "w", "a" ; la fermeture est automatique.
• Ne donne jamais à une variable le nom d'une fonction intégrée (sum, max, list, str, len…).