type et helptypeTous les objets python ont un type précis décidé automatiquement au moment de leur création.
>>> type(1)
<class 'int'>
>>> type((1, 2))
<class 'tuple'>Il faut bien faire la distinction entre les objets qui sont typés et anonymes et les variables qui ont un nom mais pas de type propre.
>>> type(x)
<class 'int'>
>>> x = (1, 2)
>>> type(x)
<class 'tuple'>Les objets peuvent être identifiés uniquement par leur adresse mémoire que l’on récupère grâce à la fonction id
>>> x = 123456789
>>> y = x
>>> z = 123456789
>>> id(x)
139987301678640
>>> id(y)
139987301678640
>>> id(z)
139987301678832On voit ainsi bien que rien n’empêche plusieurs variables de faire référence au même objet. On voit aussi que plusieurs objects distincts peuvent avoir même valeur.
L’ensemble des associations variable : objet est visualisable en utilisant la fonction locals
>>> locals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}
>>> x = 1
>>> y = (1, 2)
>>> z = (x, y)
>>> locals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'x': 1, 'y': (1, 2), 'z': (1, (1, 2))}D’un point de vue technique la structure renvoyée par locals est un dict (pour dictionnaire). On la verra plus en détails dans quelques séances.
ATTENTION on verra plus tard que locals ne renvoit en fait que les associations de l’espace de nom (namespace) courant. Pour l’instant on ne s’attadera pas sur cet aspect, mais il sera crucial pour comprendre les fonctions et les modules.
helpLa fonction help va comme sont nom l’indique nous fournir de l’aide.
La première façon de l’utiliser est de l’appeler sans argument à l’intérieur de l’interpréteur:
>>> help()
Welcome to Python 3.8's help utility!
If this is your first time using Python, you should definitely check out
the tutorial on the Internet at https://docs.python.org/3.8/tutorial/.
Enter the name of any module, keyword, or topic to get help on writing
Python programs and using Python modules. To quit this help utility and
return to the interpreter, just type "quit".
To get a list of available modules, keywords, symbols, or topics, type
"modules", "keywords", "symbols", or "topics". Each module also comes
with a one-line summary of what it does; to list the modules whose name
or summary contain a given string such as "spam", type "modules spam".
help>On peut constater qu’on atterrit dans une session spécifique: le prompt a changé de >>> à help>.
Plusieurs mots clés sont suggérés: keywords, symbols et topics et modules.
keywords: permet de voir la liste des mots clés du langage.help> keywords
Here is a list of the Python keywords. Enter any keyword to get more help.
False class from or
None continue global pass
True def if raise
and del import return
as elif in try
assert else is while
async except lambda with
await finally nonlocal yield
break for notOn ne peut en particulier pas utiliser ces mots comme variables:
>>> if = 1
File "<stdin>", line 1
if = 1
^
SyntaxError: invalid syntaxsymbols quant à eux représente des caractères ayant un sens particulier pour l’interpréteur.help> symbols
Here is a list of the punctuation symbols which Python assigns special meaning
to. Enter any symbol to get more help.
!= + <= __
" += <> `
""" , == b"
% - > b'
%= -= >= f"
& . >> f'
&= ... >>= j
' / @ r"
''' // J r'
( //= [ u"
) /= \ u'
* : ] |
** < ^ |=
**= << ^= ~
*= <<= _Les modules sont les bibliothèques supplémentaires disponibles dans votre installation python.
Les topics sont des éléments de documentations sur des points précis du langage python.
La deuxième façon d’utiliser la fonction help est de passer en argument un objet (potentiellement via une variable) sur lequel on veut des renseignement.
>>> help(len)ouvre la documentation sur la fonction len:
Help on built-in function len in module builtins:
len(obj, /)
Return the number of items in a container.Ici on voit de manière assez lapidaire la fonctionnalité de len.
Il convient de constater que pour les objets internes de python, l’aide n’est pas toujours très accessible.
>>> help(1)ouvre en effet la documentation sur les entiers (int) on donne un extrait ci-dessous pour comparaison.
Help on int object:
class int(object)
| int([x]) -> integer
| int(x, base=10) -> integer
|
| Convert a number or string to an integer, or return 0 if no arguments
| are given. If x is a number, return x.__int__(). For floating point
| numbers, this truncates towards zero.
|
| If x is not a number or if base is given, then x must be a string,
| bytes, or bytearray instance representing an integer literal in the
| given base. The literal can be preceded by '+' or '-' and be surrounded
| by whitespace. The base defaults to 10. Valid bases are 0 and 2-36.
| Base 0 means to interpret the base from the string as an integer literal.
| >>> int('0b100', base=0)
| 4
|
| Built-in subclasses:
| bool
|
| Methods defined here:
|
| __abs__(self, /)
| abs(self)Le niveau d’aide apportée dépend fortement des librairies utilisée. Ainsi
>>> import numpy as np
>>> help(np.linspace)génère
Help on function linspace in module numpy:
linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
Return evenly spaced numbers over a specified interval.
Returns `num` evenly spaced samples, calculated over the
interval [`start`, `stop`].
The endpoint of the interval can optionally be excluded.
.. versionchanged:: 1.16.0
Non-scalar `start` and `stop` are now supported.
Parameters
----------
start : array_like
The starting value of the sequence.
stop : array_like
The end value of the sequence, unless `endpoint` is set to False.
In that case, the sequence consists of all but the last of ``num + 1``
evenly spaced samples, so that `stop` is excluded. Note that the step
size changes when `endpoint` is False.
num : int, optional
Number of samples to generate. Default is 50. Must be non-negative.
endpoint : bool, optional
If True, `stop` is the last sample. Otherwise, it is not included.
Default is True.
retstep : bool, optional
If True, return (`samples`, `step`), where `step` is the spacing
between samples.
dtype : dtype, optional
The type of the output array. If `dtype` is not given, infer the data
type from the other input arguments.
.. versionadded:: 1.9.0
axis : int, optional
The axis in the result to store the samples. Relevant only if start
or stop are array-like. By default (0), the samples will be along a
new axis inserted at the beginning. Use -1 to get an axis at the end.
.. versionadded:: 1.16.0
Returns
-------
samples : ndarray
There are `num` equally spaced samples in the closed interval
``[start, stop]`` or the half-open interval ``[start, stop)``
(depending on whether `endpoint` is True or False).
step : float, optional
Only returned if `retstep` is True
Size of spacing between samples.
See Also
--------
arange : Similar to `linspace`, but uses a step size (instead of the
number of samples).
geomspace : Similar to `linspace`, but with numbers spaced evenly on a log
scale (a geometric progression).
logspace : Similar to `geomspace`, but with the end points specified as
logarithms.
Examples
--------
>>> np.linspace(2.0, 3.0, num=5)
array([2. , 2.25, 2.5 , 2.75, 3. ])
>>> np.linspace(2.0, 3.0, num=5, endpoint=False)
array([2. , 2.2, 2.4, 2.6, 2.8])
>>> np.linspace(2.0, 3.0, num=5, retstep=True)
(array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25)D’un point de vue technique la fonction help donne en fait accès aux docstrings contenues dans le code. On verra au moment des fonctions, classes et modules la façon de les remplir. Mais insistons déjà fortement sur le fait qu’un bon code doit être correct (on peut fournir une série de test pour cela) documenté (justement avec les docstring) et lisible. On pourra aller voir la correction de la session 2019-2020 pour un exemple. (En particulier pour la libraire auxiliaire)
Après exécution du code suivant
>>> x = 1
>>> y = x
>>> z = 1Déterminer vers combien d’objets distincts pointent les trois variables.
help pour déterminer le rôle de la fonction abs et donner un exemple d’utilisation.sum.Toujours la même question pour min et max.
Pour plus d’informations sur les objets python
>>> help("OBJECTS")Pour plus d’information sur le typage
>>> help("TYPES")On utilise la fonction id:
>>> x = 1
>>> y = x
>>> z = 1
>>> id(x)
93988746992960
>>> id(y)
93988746992960
>>> id(z)
93988746992960On pouvait s’attendre à ce que x et y fasse référence au même objet. Par contre le fait que z pointe aussi vers cet objet commun doit être une surprise. En fait la gestion de la mémoire en python est automatique. Ici pour optimiser l’occupation python utilise un cache pour les petits entiers. La morale de l’histoire est qu’il ne faut jamais essayer d’interférer avec la gestion de la mémoire en python sous peine de très mauvaises surprises.
L’appel
>>> help(abs)génère
Help on built-in function abs in module builtins:
abs(x, /)
Return the absolute value of the argument.Cette fonction calcule la valeur absolue.
>>> abs(5)
5
>>> abs(-5)
5L’appel
>>> help(sum)génère
Help on built-in function sum in module builtins:
sum(iterable, /, start=0)
Return the sum of a 'start' value (default: 0) plus an iterable of numbers
When the iterable is empty, return the start value.
This function is intended specifically for use with numeric values and may
reject non-numeric types.On voit que la fonction renvoit la somme des nombres d’un conteneur. On peut en particulier l’appeler sur les tuples.
>>> x = (1, 2, 3, 4)
>>> sum(x)
10Ici on a un paramètre optionnel supplémentaire start qui permet de décaler la somme
>>> x = (1, 2, 3, 4)
>>> sum(x, start=-10)
0On peut se représenter le fonction de sum dans ce dernier cas de la façon suivante
>>> start = -10
>>> start = start + 1
>>> start = start + 2
>>> start = start + 3
>>> start = start + 4
>>> start
0>>> help(max)génère
Help on built-in function max in module builtins:
max(...)
max(iterable, *[, default=obj, key=func]) -> value
max(arg1, arg2, *args, *[, key=func]) -> value
With a single iterable argument, return its biggest item. The
default keyword-only argument specifies an object to return if
the provided iterable is empty.
With two or more arguments, return the largest argument.Ce qui est nouveau est ici c’est que les premières lignes indique deux façons différentes d’utiliser la fonction. On peut d’abord l’appeler avec comme unique argument un conteneur (en fait quelque chose de plus général un itérable)
>>> x = (1, 2, 5 , -5, 10)
>>> max(x)
10La deuxième façon consiste à passer plusieurs arguments distincts
>>> x = 1
>>> y = 2
>>> u = -5
>>> v = 10
>>> max(x, y, u, v)
10Dans les deux cas on récupère le plus grand élément. Ici on n’a utilisé que des entiers mais on verra plus tard que d’autres types sont aussi acceptés.
La fonction min quant à elle renvoit de manière symétrique le plus petit.