Python — Imports, objets et surcharge des opérateurs
1) Les imports : utiliser du code existant
Python possède une bibliothèque standard très riche, ainsi que des milliers de bibliothèques externes.
Pour y accéder, on utilise import.
Exemple : importer math
import math
print("C'est math ! Son type est :", type(math))
Sortie
C'est math ! Son type est : <class 'module'>
Un module est simplement une collection de variables et de fonctions.
Avec dir(), vous pouvez explorer son contenu :
print(dir(math))
Sortie
['doc', 'file', 'loader', 'name', 'package', 'spec', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']
Constantes et fonctions
print("pi to 4 significant digits = {:.4}".format(math.pi))
print(math.log(32, 2))
Sortie
pi to 4 significant digits = 3.142 5.0
Bien sûr, si nous ne savons pas ce que fait math.log, nous pouvons appeler help() dessus :
help(math.log)
Sortie
Help on built-in function log in module math: log(x, base=math.e) Return the logarithm of x to the given base. If the base not specified, returns the natural logarithm (base e) of x.
Nous pouvons également appeler help() sur le module lui-même. Cela nous fournira la documentation complète de toutes les fonctions et valeurs du module (ainsi qu'une description détaillée du module). Cliquez sur le bouton « Sortie » pour afficher la page d'aide mathématique complète.
help(math)
Sortie
Help on module math: NAME math
MODULE REFERENCE https://docs.python.org/3.7/library/math
The following documentation is automatically generated from the Python source files. It may be incomplete, incorrect or include features that are considered implementation detail and may vary between Python implementations. When in doubt, consult the module reference at the location listed above.
DESCRIPTION This module provides access to the mathematical functions defined by the C standard.
FUNCTIONS acos(x, /) Return the arc cosine (measured in radians) of x.
acosh(x, /) Return the inverse hyperbolic cosine of x.
asin(x, /) Return the arc sine (measured in radians) of x. asinh(x, /) Return the inverse hyperbolic sine of x.
atan(x, /) Return the arc tangent (measured in radians) of x.
atan2(y, x, /) Return the arc tangent (measured in radians) of y/x.
Unlike atan(y/x), the signs of both x and y are considered.
atanh(x, /) Return the inverse hyperbolic tangent of x.
ceil(x, /) Return the ceiling of x as an Integral.
This is the smallest integer >= x.
copysign(x, y, /) Return a float with the magnitude (absolute value) of x but the sign of y.
On platforms that support signed zeros, copysign(1.0, -0.0) returns -1.0.
cos(x, /) Return the cosine of x (measured in radians).
cosh(x, /) Return the hyperbolic cosine of x.
degrees(x, /) Convert angle x from radians to degrees.
erf(x, /) Error function at x.
erfc(x, /) Complementary error function at x.
exp(x, /) Return e raised to the power of x.
expm1(x, /) Return exp(x)-1.
This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.
fabs(x, /) Return the absolute value of the float x.
factorial(x, /) Find x!.
Raise a ValueError if x is negative or non-integral.
floor(x, /) Return the floor of x as an Integral.
This is the largest integer <= x.
fmod(x, y, /) Return fmod(x, y), according to platform C.
x % y may differ.
frexp(x, /) Return the mantissa and exponent of x, as pair (m, e).
m is a float and e is an int, such that x = m * 2.**e. If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0.
fsum(seq, /) Return an accurate floating point sum of values in the iterable seq.
Assumes IEEE-754 floating point arithmetic.
gamma(x, /) Gamma function at x.
gcd(x, y, /) greatest common divisor of x and y
hypot(x, y, /) Return the Euclidean distance, sqrt(xx + yy).
isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0) Determine whether two floating point numbers are close in value.
2) Variantes d’import
Alias
Si nous savons que nous utiliserons fréquemment des fonctions en mathématiques, nous pouvons les importer sous un alias plus court pour économiser de la saisie (bien que dans ce cas, « math » soit déjà assez court).
import math as mt
print(mt.pi)
Sortie
3.141592653589793
C’est courant avec numpy et pandas :
import numpy as np
import pandas as pd
Import sélectif
from math import log, pi
print(pi, log(32, 2))
Exemple :
from math import *
from numpy import *
print(log(32, 2)) # ❌ numpy.log a écrasé math.log
Sortie
TypeError Traceback (most recent call last) /tmp/ipykernel_19/3018510453.py in <module> 1 from math import * 2 from numpy import * ----> 3 print(pi, log(32, 2))
TypeError: return arrays must be of ArrayType
3) Sous-modules
Un module peut contenir d’autres modules ! Ce sont les sous-modules.
Exemple avec numpy :
import numpy
print("numpy.random est un :", type(numpy.random))
print("Il contient des noms tels que :", dir(numpy.random)[-15:])
Sortie
numpy.random est un : <class 'module'> Il contient des noms tels que : ['seed', 'set_state', 'shuffle', 'standard_cauchy', 'standard_exponential', 'standard_gamma', 'standard_normal', 'standard_t', 'test', 'triangular', 'uniform', 'vonmises', 'wald', 'weibull', 'zipf']
Ainsi, appeler une fonction dans le sous-module random nécessitera deux points :
# Lancer 10 dés
rolls = numpy.random.randint(low=1, high=6, size=10)
print(rolls)
Sortie
[3 4 3 4 5 5 2 1 3 3]
4) Explorer des objets inconnus
En travaillant avec des bibliothèques externes (numpy, pandas, matplotlib…), vous rencontrerez de nouveaux types d’objets (ex. DataFrame, Series, ndarray).
En utilisant diverses bibliothèques pour des tâches spécialisées, vous constaterez qu'elles définissent leurs propres types, qu'il vous faudra apprendre à manipuler. Par exemple, si vous utilisez la bibliothèque graphique matplotlib, vous serez confronté à des objets qu'elle définit et qui représentent des sous-graphiques, des figures, des graduations et des annotations. Les fonctions pandas vous donneront des DataFrames et des Series.
Dans cette section, je souhaite partager avec vous un guide pratique pour travailler avec des types étranges.
Trois outils essentiels pour explorer ces objets :
1️⃣ type() (qu'est-ce que c'est ?)
type(rolls)
Sortie
<class 'numpy.ndarray'>
2️⃣ dir() (que puis-je en faire ?)
print(dir(rolls))
Sortie
['T', 'abs', 'add', 'and', 'array', 'array_finalize', 'array_function', 'array_interface', 'array_prepare', 'array_priority', 'array_struct', 'array_ufunc', 'array_wrap', 'bool', 'class', 'complex', 'contains', 'copy', 'deepcopy', 'delattr', 'delitem', 'dir', 'divmod', 'doc', 'eq', 'float', 'floordiv', 'format', 'ge', 'getattribute', 'getitem', 'gt', 'hash', 'iadd', 'iand', 'ifloordiv', 'ilshift', 'imatmul', 'imod', 'imul', 'index', 'init', 'init_subclass', 'int', 'invert', 'ior', 'ipow', 'irshift', 'isub', 'iter', 'itruediv', 'ixor', 'le', 'len', 'lshift', 'lt', 'matmul', 'mod', 'mul', 'ne', 'neg', 'new', 'or', 'pos', 'pow', 'radd', 'rand', 'rdivmod', 'reduce', 'reduce_ex', 'repr', 'rfloordiv', 'rlshift', 'rmatmul', 'rmod', 'rmul', 'ror', 'rpow', 'rrshift', 'rshift', 'rsub', 'rtruediv', 'rxor', 'setattr', 'setitem', 'setstate', 'sizeof', 'str', 'sub', 'subclasshook', 'truediv', 'xor', 'all', 'any', 'argmax', 'argmin', 'argpartition', 'argsort', 'astype', 'base', 'byteswap', 'choose', 'clip', 'compress', 'conj', 'conjugate', 'copy', 'ctypes', 'cumprod', 'cumsum', 'data', 'diagonal', 'dot', 'dtype', 'dump', 'dumps', 'fill', 'flags', 'flat', 'flatten', 'getfield', 'imag', 'item', 'itemset', 'itemsize', 'max', 'mean', 'min', 'nbytes', 'ndim', 'newbyteorder', 'nonzero', 'partition', 'prod', 'ptp', 'put', 'ravel', 'real', 'repeat', 'reshape', 'resize', 'round', 'searchsorted', 'setfield', 'setflags', 'shape', 'size', 'sort', 'squeeze', 'std', 'strides', 'sum', 'swapaxes', 'take', 'tobytes', 'tofile', 'tolist', 'tostring', 'trace', 'transpose', 'var', 'view']
Exemple d’utilisation :
# Moyenne des lancers de dés
rolls.mean()
Sortie
3.3
# Convertir en liste
rolls.tolist()
Sortie
[3, 4, 3, 4, 5, 5, 2, 1, 3, 3]
3️⃣ help() (dis moi plus)
help(rolls.ravel)
Sortie
Help on built-in function ravel:
ravel(...) method of numpy.ndarray instance a.ravel([order])
Return a flattened array.
Refer to
numpy.ravelfor full documentation.See Also
numpy.ravel : equivalent function
ndarray.flat : a flat iterator on the array.
5) Surcharge des opérateurs
Python permet aux bibliothèques de redéfinir le comportement d’opérateurs (+, <=, ==, etc.)
selon leurs types.
Exemple : liste Python
[3, 4, 1] + 10
Sortie
TypeError Traceback (most recent call last) /tmp/ipykernel_19/2144087748.py in <module> ----> 1 [3, 4, 1, 2, 2, 1] + 10
TypeError: can only concatenate list (not "int") to list
Exemple : tableau NumPy
rolls + 10
Sortie
[13 14 13 14 15 15 12 11 13 13]
Ici, l’addition est appliquée élément par élément, ce qui est très pratique.
Comparaison avec des opérateurs
On pourrait penser que Python contrôle strictement le comportement de certains éléments de sa syntaxe de base, tels que +, <, in, == ou les crochets pour l'indexation et le découpage. En réalité, son approche est très passive. Lorsque vous définissez un nouveau type, vous pouvez choisir le fonctionnement de l'addition, ou la signification de l'égalité d'un objet de ce type avec un autre.
Les concepteurs de listes ont décidé que leur addition à des nombres était interdite. Les concepteurs de tableaux numpy ont adopté une approche différente (ajoutant le nombre à chaque élément du tableau).
Voici quelques exemples supplémentaires illustrant comment les tableaux numpy interagissent de manière inattendue avec les opérateurs Python (ou du moins différemment des listes).
rolls <= 3
Sortie
array([ True False True False False False True True True True])
Cela retourne un tableau de booléens,
indiquant les indices où la condition est vraie.
Surcharge avancée des opérateurs
La bibliothèque NumPy est spécialisée dans les tableaux multi-dimensionnels.
Elle définit sa propre logique pour l’indexation :
import numpy
xlist = [[1, 2, 3], [2, 4, 6]]
x = numpy.asarray(xlist)
print("xlist =", xlist, "\nx =\n", x)
print("Dernier élément de la 2ᵉ ligne du tableau NumPy :", x[1, -1])
print("Dernier élément de la 2ᵉ sous-liste Python :", xlist[1][-1])
Sortie
xlist = [[1, 2, 3], [2, 4, 6]] x = [[1 2 3] [2 4 6]] Dernier élément de la 2ᵉ ligne du tableau NumPy : 6 Dernier élément de la 2ᵉ sous-liste Python : 6
👉 Avec une liste Python imbriquée, l’indexation xlist[1, -1] lève une erreur :
xlist[1, -1]
Sortie
TypeError: list indices must be integers or slices, not tuple
Exemple avec TensorFlow
Certaines bibliothèques vont encore plus loin.
Avec TensorFlow, l’opérateur + ne donne pas un nombre, mais un objet symbolique.
import tensorflow as tf
a = tf.constant(1)
b = tf.constant(1)
print(a + b)
Sortie
<tf.Tensor: shape=(), dtype=int32, numpy=2>
Le résultat n’est pas directement 2, mais un objet Tensor : une référence symbolique à une opération.
Exemple avec pandas
Quand vous aurez manipulé des DataFrames, vous verrez des expressions comme :
df[(df['population'] > 10**6) & (df['continent'] == 'South America')]
C’est lisible et pratique ✅
Mais attention : en coulisses, cette ligne fait intervenir 5 opérateurs surchargés (>, ==, &, [], etc.) !
Derrière la surcharge d’opérateurs se cachent les méthodes spéciales en Python.
Exemple :
print(dir(list)[:15])
Sortie (extrait)
['add', 'class', 'contains', 'delattr', 'delitem', 'dir', 'doc', 'eq', 'format', 'ge', 'getattribute', 'getitem', 'gt', 'hash']
Par exemple :
x in [1, 2, 3]appelle en réalité la méthode spéciale__contains__.[1, 2] + [3, 4]appelle__add__.
Toutes ces méthodes « dunder » (double underscore) donnent aux développeurs le pouvoir de définir comment leurs objets réagissent aux opérateurs.
🚀 Conclusion
- Les imports permettent d’accéder à une immense richesse de bibliothèques Python.
type(),dir(),help()sont des outils précieux pour explorer des objets inconnus.- La surcharge d’opérateurs rend certains objets très puissants et intuitifs… mais parfois surprenants !