Les bases de la programmation Python par l’exemple

III. Les fonctions▲

III-A. Définition d'une fonction▲

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.

#!/usr/bin/python3

# ----- Fonction sans argument -----
def greeting():
    print("-----------------------------")
    print("         Hello World         ")
    print("-----------------------------")

greeting()

# ----- Fonction avec arguments -----
def somme_deux_nombres(num1, num2):
    total = num1 + num2
    print("{} + {} = {}".format(num1, num2, total))

somme_deux_nombres(3, 4)

# ----- Fonction avec une valeur de retour -----
def carre(num):
    return num * num

my_num = 3
print(carre(2))
print(carre(my_num))

Le mot-clef def est utilisé pour définir un corps de fonction.
Les fonctions doivent être définies avant tout usage.

Une erreur de syntaxe courante, est l’oubli de : à la fin de l'instruction de définition d'une fonction.
Les blocs (corps) des fonctions, structures de contrôle, etc., sont distingués grâce à l'indentation :
- l'indentation recommandée est de 4 espaces consécutifs ;
- bonnes pratiques de style - documentation Python docs.
Par défaut, la valeur de retour de return (comme son absence) est None.
Comment les variables sont-elles passées aux fonctions en Python.
format est traité dans le sujet suivant.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.

$ ./functions.py 
-----------------------------
         Hello World         
-----------------------------
3 + 4 = 7
4
9

III-B. Valeur par défaut des arguments▲

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

#!/usr/bin/python3

# ----- Fonction avec un argument avec une valeur par défaut -----
def greeting(style_char='-'):
    print(style_char * 29)
    print("Hello World")
    print(style_char * 29)

print("Style par défaut")
greeting()

print("\ncarctère de style  *")
greeting('*')

print("\ncaractère de style =")
greeting(style_char='=')

Les fonctions peuvent fréquemment avoir un comportement par défaut, modifié par le passage d’un argument pertinent si nécessaire.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

$ ./functions_default_arg_value.py 
Style par défaut
-----------------------------
         Hello World         
-----------------------------

Si le style passé est "*"
*****************************
         Hello World         
*****************************

Si le style passé est "=" 
=============================
         Hello World         
=============================

Les triples guillemets de commentaires permettent de décrire l'usage de la fonction et sont généralement repris par l'outil de génération de documentation.
Pour éviter d'alourdir les exemples de ce tutoriel, les docstrings des programmes et de la définition des fonctions ne sont pas repris
voir le chapitre sur les docstrings pour les exemples et discussions à ce propos.

Sélectionnez

1.
2.
3.
4.
5.
6.

def num_square(num):
    """
    returns square of number
    """

    return num * num

III-C. Lectures complémentaires▲

Il y a de nombreuses manières d’appeler une fonction et d’autres types de déclarations ; merci de vous référer aux liens fournis pour davantage d’informations :

III-D. Fonction print▲

Par défaut, la fonction print ajoute systématiquement une ligne à la fin de son retour.
Ce comportement peut être modifié en passant votre propre chaîne de caractères à l’argument end de cette fonction.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.

>>> print("hi")
hi
>>> print("hi", end='')
hi>>> 
>>> print("hi", end=' !!\n')
hi !!
>>>

La fonction help peut être utilisée pour obtenir la documentation par l’interpréteur.
Appuyer sur q pour revenir à l’aide.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

>>> 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.

Plusieurs arguments peuvent être passés à la fonction print grâce au séparateur d’arguments , lors de son appel.
La valeur par défaut de l’argument sep, est un espace simple.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

>>> a = 5
>>> b = 2

>>> print(a+b, a-b)
7 3

>>> print(a+b, a-b, sep=' : ')
7 : 3

>>> print(a+b, a-b, sep='\n')
7
3

Lors de l’affichage de variables, la méthode str est appelée et permet de donner une représentation en chaîne de caractère (représentation humaine).
Ainsi, une conversion explicite n’est pas nécessaire, à moins qu’une concaténation soit requise.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

>>> greeting = 'Hello World'
>>> print(greeting)
Hello World
>>> num = 42
>>> print(num)
42

>>> print(greeting + '. We are learning Python')
Hello World. We are learning Python
>>> print(greeting, '. We are learning Python', sep='')
Hello World. We are learning Python

>>> print("She bought " + num + " apples")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't convert 'int' object to str implicitly

>>> print("She bought " + str(num) + " apples")
She bought 42 apples

Comme autre solution, vous pouvez modifier sep avec plusieurs arguments :

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.

>>> print("She bought", num, "apples")
She bought 42 apples

>>> items = 15
>>> print("No. of items:", items)
No. of items: 15

>>> print("No. of items:", items, sep='')
No. of items:15

Pour rediriger le flux d’affichage à stderr au lieu du flux par défaut stdout, il vous suffit de modifier l’argument file.
Voir aussi sys.exit().

Sélectionnez

1.
2.
3.

>>> import sys
>>> print("Error!! Not a valid input", file=sys.stderr)
Error!! Not a valid input

La fonction str.format() peut être utilisée pour mettre en forme les chaînes de caractères et permettre l’utilisation de plusieurs variables, d’une façon plus élégante que la seule concaténation.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

>>> num1 = 42
>>> num2 = 7

>>> '{} + {} = {}'.format(num1, num2, num1 + num2)
'42 + 7 = 49'

# or save formatting in a variable and use wherever needed
>>> op_fmt = '{} + {} = {}'
>>> op_fmt.format(num1, num2, num1 + num2)
'42 + 7 = 49'
>>> op_fmt.format(num1, 29, num1 + 29)
'42 + 29 = 71'

# and of course the expression can be used inside print directly
>>> print('{} + {} = {}'.format(num1, num2, num1 + num2))
42 + 7 = 49

Utilisation d’arguments de type numérique.

Sélectionnez

1.
2.
3.
4.
5.
6.

>>> num1
42
>>> num2
7
>>> print("{0} + {1} * {0} = {2}".format(num1, num2, num1 + num2 * num1))
42 + 7 * 42 = 336

Formatage de nombres – spécification utilisée avec argument optionnel et nombre optionnel, suivi par `:` puis le style de formatage.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

>>> appx_pi = 22 / 7
>>> appx_pi
3.142857142857143

# restricting number of digits after decimal point
# value is rounded off
>>> print("{0:.2f}".format(appx_pi))
3.14
>>> print("{0:.3f}".format(appx_pi))
3.143

# aligning
>>> print("{0:<10.3f} and 5.12".format(appx_pi))
3.143      and 5.12
>>> print("{0:>10.3f} and 5.12".format(appx_pi))
     3.143 and 5.12

# zero filling
>>> print("{0:08.3f}".format(appx_pi))
0003.143

Changement de base.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.

>>> print("42 in binary = {:b}".format(42))
42 in binary = 101010
>>> print("42 in octal = {:o}".format(42))
42 in octal = 52
>>> print("241 in hex = {:x}".format(241))
241 in hex = f1

# add # for 0b/0o/0x prefix
>>> print("42 in binary = {:#b}".format(42))
42 in binary = 0b101010

>>> hex_str = "{:x}".format(42)
>>> hex_str
'2a'

# can also use format built-in function
>>> format(42, 'x')
'2a'
>>> format(42, '#x')
'0x2a'

# converting string to int
>>> int(hex_str, base=16)
42
>>> int('0x2a', base=16)
42

Similaire au préfixe d’affichage brut r, l’utilisation du préfixe f permet la représentation de nombres.
Introduit depuis Python v3.6.
Similaire à str.format(), la variable ou l’expression est spécifiée par {}.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.

>>> num1 = 42
>>> num2 = 7
>>> f'{num1} + {num2} = {num1 + num2}'
'42 + 7 = 49'
>>> print(f'{num1} + {num2} = {num1 + num2}')
42 + 7 = 49

>>> appx_pi = 22 / 7
>>> f'{appx_pi:08.3f}'
'0003.143'

>>> f'{20:x}'
'14'
>>> f'{20:#x}'
'0x14'

Lectures complémentaires :

formatage de chaînes de caractères – documentation Python – pour davantage d’informations ou d’exemples ;
f-string – documentation Python – pour davantage d’exemples et de mises en garde.

III-E. Fonction range▲

Par défaut, les arguments sont les suivants : start=0 et step=1 – vous pouvez donc les utiliser ou ne pas en tenir en compte et passer vos propres arguments :

range(stop) ;
range(start, stop) ;
range(start, stop, step) ;
veuillez noter que le retour de la fonction range n’inclut pas la valeur définie à stop – ce sera toujours l’entier précédent la valeur de stop ;
voir le chapitre sur les listes pour l’introduction et les explications de cette partie ;
ranges – documentation Python – pour davantage d’informations et d’exemples.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

>>> range(5)
range(0, 5)

>>> list(range(5))
[0, 1, 2, 3, 4]

>>> list(range(-2, 2))
[-2, -1, 0, 1]

>>> list(range(1, 15, 2))
[1, 3, 5, 7, 9, 11, 13]

>>> list(range(10, -5, -2))
[10, 8, 6, 4, 2, 0, -2, -4]

III-F. Fonction déterminant le type▲

Cette fonction est utile pour connaître le type de données ou de la variable qui est lui passée en argument.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

>>> type(5)
<class 'int'>

>>> type('Hi there!')
<class 'str'>

>>> type(range(7))
<class 'range'>

>>> type(None)
<class 'NoneType'>

>>> type(True)
<class 'bool'>

>>> arr = list(range(4))
>>> arr
[0, 1, 2, 3]
>>> type(arr)
<class 'list'>

III-G. Portée des variables▲

Sélectionnez

1.
2.
3.
4.
5.
6.
7.

#!/usr/bin/python3

def print_num():
    print("Yeehaw! num is visible in this scope, its value is: " + str(num))

num = 25
print_num()

Les variables définies avant l’appel à la fonction sont également visibles dans la définition de la fonction.
Valeur des arguments par défaut – documentation Python – voir la description pour connaître quand les valeurs par défaut sont évaluées (interprétées).

Sélectionnez

1.
2.

$ ./variable_scope_1.py 
Yeehaw! num is visible in this scope, its value is: 25

Que se passe-t-il lorsqu’une variable déclarée dans un bloc est utilisée en dehors de ce dernier ?

Sélectionnez

1.
2.
3.
4.
5.
6.
7.

#!/usr/bin/python3

def square_of_num(num):
    sqr_num = num * num

square_of_num(5)
print("5 * 5 = {}".format(sqr_num))

Ici sqr_num est déclaré au sein de la fonction square_of_num et n’est pas accessible en dehors.

Sélectionnez

1.
2.
3.
4.
5.

$ ./variable_scope_2.py 
Traceback (most recent call last):
  File "./variable_scope_2.py", line 7, in <module>
    print("5 * 5 = {}".format(sqr_num))
NameError: name 'sqr_num' is not defined

Une des solutions pour contourner un tel comportement est l’utilisation du mot-clef global.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.

#!/usr/bin/python3

def square_of_num(num):
    global sqr_num
    sqr_num = num * num

square_of_num(5)
print("5 * 5 = {}".format(sqr_num))

Désormais, vous pouvez accéder à la variable sqr_num en dehors de la définition de la fonction.

Sélectionnez

1.
2.

$ ./variable_scope_3.py
5 * 5 = 25

Si le nom d’une variable est identique à l’intérieur et à l’extérieur d’une fonction (conflit de nom), le changement de valeur dans un bloc de fonction n’affecte pas la variable extérieure à ce bloc.

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

#!/usr/bin/python3

sqr_num = 4

def square_of_num(num):
    sqr_num = num * num
    print("5 * 5 = {}".format(sqr_num))

square_of_num(5)
print("Whoops! sqr_num is still {}!".format(sqr_num))

Notez que l’utilisation de global sqr_num affectera ici sqr_num, la variable en dehors du bloc définissant la fonction.

Sélectionnez

1.
2.
3.

$ ./variable_scope_4.py 
5 * 5 = 25
Whoops! sqr_num is still 4!

III-H. Lectures complémentaires▲

Exemple de portée – documentation Python.

la déclaration globale – documentation Python.

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2018 Sundeep Agarwal. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.