Fonctions et méthodes

Les fonctions et les méthodes sont des moyens d'effectuer des opérations sur les objets ou de créer de nouveaux objets. La puissance d'un langage de programmation vient aussi du fait des nombreuses fonctions et méthodes mises à la dispositions de ses utilisateurs.

Fonctions

Une fonction est un type d'objet pouvant être exécuté. Par exemple la fonction print.

C'est un objet :

>>> type(print)
<class 'builtin_function_or_method'>

On exécute l'objet en faisant suivre son nom de parenthèses :

>>> print()

L'exécution de la fonction print à produit un retour à la ligne.

nom_de_la_fonction(paramètre1, paramètre2, ..., paramètre_n)

Prenons par exemple la fonction print de python :

>>> print("coucou", "les gens", "!")
coucou les gens !

L'exécution de la fonction print avec les trois paramètres "coucou", "les gens" et "!" affichera à l'écran les 3 paramètres espacé d'un caractère (séparé par un caractère espace " ") puis ira à la ligne.

Toutes les fonctions de python sont documentées. On peut y accéder :

• via le site de python. L'aide de la fonction print est là : https://docs.python.org/fr/3/library/functions.html#print
• en console en utilisant la fonction help : help(print) donne l'aide de print

>>> help(print)
Help on built-in function print in module builtins:

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
    
    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

Paramètres d'une fonction

En regardant la documentation de la fonction print, on remarque que les premiers paramètres sont sans noms (value, ...) puis les paramètres ont des noms (sep, end, file, flush) suivi d'une valeur. Ce sont des paramètres qui ont une valeur par défaut (par défaut sep vaut " ").

On cependant bien sur utiliser, en le nommant, un paramètre ayant une valeur par défaut :

>>> print("coucou", "les gens", "!", sep="***")
coucou***les gens***!

Ordre des paramètres

Expérimentons ça sur un exercice.

Paramètres entre crochets dans une définition

On pourra parfois voir des paramètres entre crochet dans la définition de fonction. Par exemple : complex([real[, imag]]) (documentation de la classe complex).

C'est un raccourci d'écriture, ce n'est pas une structure python. Cela signifie que l'on peut écrire la définition avec ou sans les crochets. Ceci permet d'écrire plusieurs définitions possible en une seule fois. Ainsi la définition complex([real[, imag]]) correspond à trois écritures possibles :

1. crochets extérieurs absents : complex()

   >>> complex()
   0j
   

   On vient de créer le complexe nul.

2. crochets extérieurs présents : complex(real[, imag]). On a à nouveau deux choix :

   1. crochets absents : complex(real)

      >>> complex(1)
      (1+0j)
      

   2. crochets présents : complex(real, imag)

      >>> complex(1, 2)
      (1+2j)
      

Fonctions usuelles

Certaines sont plus utiles que d'autres. Nous allons en citer certaines, parmi les plus utilisées.

Fonction print

Affiche à l'écran ses paramètres.

Fonction type

Donne le type d'un objet.

Fonction len

Rend le nombre d'éléments d'une chaîne de caractères (et plus généralement d'un conteneur que l'on verra plus tard).

>>> len("anticonstitutionnellement")
25

Nom d'une classe comme fonction

int, float, complex, str et bool permettent de créer des objets du nom du type.

On a déjà vu cette possibilité dans la partie objets types et types d'objets, c'est très utile pour changer un objet de classe. Mais utilisons ce qu'on a vu maintenant pour aller plus loin :

>>> int("1001100011", base=2)
611

Allez, un dernier pour la route :

>>> len(str(2 ** 44497 - 1))
13395

Fonction input

Permet de demander une chaîne de caractère à un utilisateur. Par exemple :

>>> x = input()
23
>>> x
'23'

On demande à l'utilisateur de taper quelque chose puis d'appuyer sur la touche entrée. Ce qu'à taper l'utilisateur est rendu sous la forme d'une chaîne de caractère.

Méthodes

Les méthodes sont un autre moyen d'agir sur un objet. On les utilise de cette façon :

objet.méthode(paramètre 1, paramètre 2, ..., paramètre n)

On applique méthode à objet en utilisant les paramètres de la méthode.

Prenez le temps de regarder les différentes méthodes des classes de base de python. Souvent elle vous permettent de faire rapidement une opération compliquée. C'est en particulier vrai pour les chaînes de caractères et les listes.

Méthodes des chaînes de caractères

Chaque classe vient avec des méthodes. Si les nombre et booléens ont peu de méthodes, les chaines de caractères par exemple en ont tout un tas.

Essayons de les apprendre avec ces petits exercices :

>>> x = str(2 ** 44497 - 1)

>>> x.count("0")
1332

>>> y = int(x.replace("2", "7"))

>>> mot.count("ou")
2
>>> mot.index("e")
9
>>> mot.rindex("e")
16

On peut chaîner les méthodes, la sortie d'une méthode devenant l'entrée de la prochaine. Par exemple, avec 2 méthodes :

objet.méthode_1().méthode_2()

Signifie que méthode2() est appliquée à l'objet résultat de objet.méthode_1()

Et avec $n$ méthodes :

objet.méthode_1().méthode_2(). ... .méthode_n()

Signifie que méthode_n() est appliquée au résultat de objet.méthode_1(). ... .méthode_n-1()

str(2 ** 44497 - 1).replace("2","x").replace("7","2").replace("x","7")

Fonctions vs. méthodes

Ne confondez pas fonctions et méthodes. Une fonction s'exécute toute seule alors qu'une méthode a besoin d'un objet sur lequel elle s'applique (celui avant le .). Vous pouvez voir ça comme un 1er paramètre indispensable à l'exécution d'une méthode. Considérez le programme suivant :

>>> ma_chaîne = "coucou !"
>>> en_majuscules = ma_chaîne.upper()
>>> print(en_majuscules)
COUCOU !

La première ligne crée une chaîne de caractères. La seconde instruction est une méthode (upper) qui s'applique à l'objet de nom ma_chaîne et qui n'a pas de paramètre.

Attributs d'une classe

C'est plus rare, mais certaines classes possèdent des également des attributs en plus des méthodes. Ce sont des valeurs associées à l'objet.

Par exemple les objets de la classe complex qui possède les attributs real et imag pour rendre la partie réelle et imaginaire d'un complexe.

>>> (1+2j).real
1.0
>>> (1+2j).imag
2.0