Tutoriel Python - sommaire

Les fonctions natives et personnelles en Python

Vous avez déjà utilisé de nombreuses fonctions natives de Python : print(), len(), type(), list(), etc.

Les fonctions natives et mots clés

Ci-desssous tableau de toutes les fonctions natives ou génériques ("built-in functions" en anglais) :

Ces fonctions sont toujours disponibles car stockées dans le module de base de Python.
Ci-dessous une série de commandes pour vous familiariser avec les plus importantes de ces fonctions.

>>> maliste =[7,3,5,1,9]
>>> sorted(maliste)
[1, 3, 5, 7, 9]
>>> max(maliste)
9
>>> min(maliste)
1
>>> sum(maliste)
25
>>> int(15.5)
15
>>> eval("15.5")
15.5
>>> chaine_num ="15.5"
>>> int(float(chaine_num))
15
>>>
>>> pow(10,5)
100000
>>> round(17.89,1)
17.9
>>> abs(-10)
10
>>> machaine ="bonjour"
>>> max(machaine)
'u'
>>> min(machaine)
'b'

Ces fonctions sont dites aussi génériques car elles peuvent s'appliquer à différents types de données (à la différence des méthodes de classe qui sont spécifiques à un objet de cette classe).
Ainsi je vous montre que les fonctions min() & max() peuvent avoir pour argument une liste ou une chaine.
La fonction round(nombre décimal,n) arrondit à l'entier le plus proche OU au nombre de décimales si un deuxième argument est précisé.
La fonction pow(x,n ) élève x à la puissance n
eval(chaine numérique) : convertit une chaine en flottant à condition bien sûr que cette chaine ait un format numérique (suite de chiffres avec un point éventuel en guise de séparateur décimal). La fonction float() fait la même chose.

Les mots clés (ou mots réservés) en Python

Ne confondez pas les fonctions natives avec les mots clés.
La liste des mots clés peut être affichée dans la console :

>>> help("keywords")
Here is a list of the Python keywords.  Enter any keyword to get more help.

False               break               for                 not
None                class               from                or
True                continue            global              pass
__peg_parser__      def                 if                  raise
and                 del                 import              return
as                  elif                in                  try
assert              else                is                  while
async               except              lambda              with
await               finally             nonlocal            yield

Vous n'avez pas le droit d'utiliser un mot clé pour définir un identifiant (nom de variable simple, de fonction, de liste, ...).

>>> in = [5,4,3,2]
...
SyntaxError: invalid syntax
>>> del = (5,4,3)
...
SyntaxError: invalid syntax

On ne peut pas nommer une liste, un tuple avec le mot clé "in" ou "del".

Le mot clé "del"

del est aussi une fonction générique !

>>> liste =list(range(2,10))
>>> liste
[2, 3, 4, 5, 6, 7, 8, 9]
>>> del(liste[0])
>>> liste
[3, 4, 5, 6, 7, 8, 9]
>>> del(liste)
>>> liste
...
NameError: name 'liste' is not defined

J'ai supprimé le premier élément de la liste puis toute la liste avec le mot clé del donc la demande d'affichage de cette liste retourne un message d'erreur.

Mais au fait c'est quoi une fonction ?

Une fonction est une portion de code nommée, qui accomplit une tâche spécifique. Les fonctions reçoivent généralement des données en entrée() et retournent généralement en sortie le résultat du traitement opéré par la fonction.

Paramètres et arguments

Définitions

Au propos des fonctions on emploie les termes paramètres et arguments

Les paramètres sont définis lors de la création de la fonction et servent de variables locales à l'intérieur de la fonction.
Les arguments sont les valeurs réelles passées à la fonction lors de son appel et doivent correspondre aux paramètres définis (2 arguments à saisir si deux paramètres obligatoires).

Exemple

>>> divmod(11,3)
(3, 2)
>>> q,r = divmod(11,3)
>>> q
3
>>> r
2
>>>

La fonction générique divmod (division entière) exige deux arguments lors de son appel et retourne deux valeurs.
Elle a donc été définie avec deux paramètres.

Une fonction personnelle

Vous pouvez être appelé à créer vos propres fonctions si vous n'avez pas trouvé votre bonheur dans la liste impressionnante des fonctions proposées par Python : dans le module de base, dans les modules à importer, etc.

Déclaration et appel de la fonction perso.

>>> # déclaration d'une fonction
>>> def carre(x):
...     return x**2
...
>>> carre(5)
25
>>> carre(1000)
1000000

Ci-dessus j'ai défini une fonction perso nommée "carre" avec un paramètre.
Puis j'ai appelé cette fonction deux fois avec d'abord comme argument "5" puis "1000".
La fonction appelée retourne ici une valeur : le carré du nombre saisi en argument.

Syntaxe

Une fonction personnelle en Python doit être écrite sur au moins sur deux lignes :
• une ligne pour la nommer et indiquer le(s) paramètre(s)
• N lignes pour la description de la fonction (ce qu'elle fait)

L'appel d'un fonction native ou perso. c'est toujours une seule commmande : nomFonction(arg1,arg2, ...)

Le nombre de paramètres peut être variable

La syntaxe de la fonction range() est : range([start],stop,[step]). Ce qui veut dire qu'il peut y avoir trois arguments à saisir lors de son appel mais un seul est obligatoire (stop). Dans la syntaxe une paire de crochets indique un paramètre optionnel.

>>> liste1 = list(range(10))
>>> liste1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> liste2 = list(range(1,10,2))
>>> liste2
[1, 3, 5, 7, 9]
>>>

J'ai appelé deux fois la fonction range() pour créer deux listes : premier appel avec un argument ; deuxième appel avec trois arguments.

À propos de la fonction print()

Un ou plusieurs arguments

La fonction native la plus importante est print().

>>> nom ='Marchand'
>>> prenom ='leon'
>>> age = 22
>>> print(nom, prenom, age, " ans")
Marchand leon 22  ans
>>> print(nom,prenom,age,' ans', sep ='-')
Marchand-leon-22- ans
>>> print(nom,prenom,age,'ans', sep ='')
Marchandleon22ans
>>>

La fonction print() peut être argumentée avec plusieurs expressions (variables, chaines, numériques) séparées par une virgule. Par défaut chaque expression est séparée de la précédente avec un espace.
Mais vous pouvez modifier le type de séparateur voir le supprimer avec le mot clé sep

Saut de ligne ou pas

>>> maliste = list(range(1,11,2))
>>> for ele in maliste :
...     print(ele)
...
1
3
5
7
9
>>> for ele in maliste :
...     print(ele,end ="-")
...
1-3-5-7-9->>>

Par défaut il y a un saut de ligne après l'instruction print() saut si on emploie comme argument le mot clé end = ' '. Il faut préciser le type de séparateur dans les quotes.

Des fonctions personnelles

Je vous propose maintenant de créer vos propres fonctions.

Fonction qui ne retourne aucune valeur

L'instruction return est facultative dans une fonction.
Ci-dessous je définis une fonction qui permet d'afficher une table de multiplication.
Le nombre de données produites est trop important pour être retournées par la fonction. Celle-ci se contente d'afficher les données sous forme d'un tableau grâce à une boucle FOR.

>>> def table(nombre,ligne):
...     for i in range(1,ligne+1):
...             print(f" {i} * {nombre} = {i * nombre}")
...
>>> table(9,10)
 1 * 9 = 9
 2 * 9 = 18
 3 * 9 = 27
 4 * 9 = 36
 5 * 9 = 45
 6 * 9 = 54
 7 * 9 = 63
 8 * 9 = 72
 9 * 9 = 81
 10 * 9 = 90

Cette fonction nommée "table" comprend une boucle for mais pas le mot clé "return"
La syntaxe de la commande "print()" est particulière ; J'y reviendrai plus tard.
Appel de la fonction : j'ai tapé table(9,10) ce qui signifie que je demande l'affichage de la table par 9 et les dix premières lignes.

L'emploi d'une fonction de cette nature dans un programme n'est pas conseillée.
En effet dans un programme on appelle une fonction pour qu'elle retourne une valeur à la routine principale.

Fonction sans paramètre

Il est possible de définir une fonction sans paramètre donc sans passage d'argument lors de son appel.

>>> def instant_present():
...     import time
...     return time.localtime()
...
>>> instant_present()
time.struct_time(tm_year=2024, tm_mon=1, tm_mday=3, tm_hour=12, 
tm_min=7, tm_sec=28, tm_wday=2, tm_yday=3, tm_isdst=0)
>>>

L'instant présent (date et heure) est retourné par la fonction "instant_present" avec moultes détails : année, rang du mois, rang du jour, heure, minutes et secondes.

J'ai définis une fonction "instant_present" qui n'exige aucun argument à passer lors de son appel.

Cette fonction perso. est construite à partir de la fonction localtime() du module time. Voir le chapitre 9.

Fonction sans paramètre et sans valeur retournée

>>> def date_courante():
...     import time
...     print("date du jour : " + time.strftime("%A %d %B %Y"))
...
>>> date_courante()
date du jour : Wednesday 03 January 2024
>>>

La fonction "date_courante" n'exige aucun argument lors de son appel et se contente d'afficher la date du jour. Elle ne retourne aucune valeur que je pourrais récupérer dans une variable en vue d'un traitement ultérieur ...

Création de fonctions "normales"

Entendons par "normale" une fonction perso. qui exige un ou plusieurs arguments lors de son appel et retourne une ou plusieurs valeurs.

La fonction parabole(x)

Création d'une fonction perso. basée sur l'équation : f(x) = x² + 10 puis appel trois fois de cette fonction.

>>> def  parabole(x):
...     y = pow(x,2)+10
...     return y
...
>>> parabole(-10)
110
>>> parabole(0)
10
>>> parabole(10)
110

pow(x,2) élève à la puissance 2 le contenu de la variable x.
Le bloc d'instructions de cette fonction comprend deux lignes ; toutes deux doivent être indentées par rapport à la ligne "def ..."

Fonction qui retourne plusieurs valeurs

>>> def cercle(r):
...     aire = r * r * 3.14
...     circonference = r*2 * 3.14
...     return aire,circonference
...
>>> a,c = cercle(10)
>>> a
314.0
>>> c
62.8
>>>

La fonction perso nommmée "cercle" reçoit le rayon en argument et retourne la surface et la circonférence du cercle.

Fonction complexes

Je reviens sur les fonctions au chapitre 12.

Dans ce chapitre j'évoque entre autres :
• fonction avec argument optionnel
• fonction avec un nombre variable d'argument
• fonction récursive
• fonction écrite sur une seule ligne

>>> sqrt(25)
...
NameError: name 'sqrt' is not defined

>>> import math
>>> math.sqrt(25)
5.0
>>> math.ceil(18.9)
19
>>> math.floor(18.9)
18
>>>

>>> dir(math)
'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh',
'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e',
 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 
'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 
'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm',
'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter',
 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder',
'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
>>>

>>> import random as rand
>>> alea = rand.random()
>>> alea
0.6545422177112703
>>> car_retenu = rand.choice(['a','b','c', 'd'])
>>> car_retenu
'c'
>>> entier = rand.randint(5,25)
>>> entier
8
>>>

>>> import math
>>> math.gcd(14,35)
7
>>> math.gcd(60,50,40,30)
10

>>> ord('a')
97
>>> chr(97)
'a'
>>> bin(64)
'0b1000000'
>>> oct(64)
'0o100'
>>> hex(64)
'0x40'
>>> hex(192)
'0xc0'
>>> divmod(10,3)
(3, 1) # quotient et reste de la division de 10 par 3
>>> y =float("10000.55")
>>> y
10000.55

>>> nom ="Dubuis"
>>> age = 22
>>> print(nom + " est âge de " + age + " ans")
...
TypeError: can only concatenate str (not "int") to str
>>> print(nom, "est âgé de :" , age, " ans")
Dubuis est âgé de : 22  ans
>>> print(f"{nom} est âgé de {age} ans")
Dubuis est âgé de 22 ans