Loading...
Python

Fonctions

EISTI

Appuyer → pour continuer.

Commandes pour les slides
  • ← et → pour avancer / reculer.
  • espace pour avancer.
  • Ctrl/Command et + or - pour zoomer plus ou moins.
  • N pour afficher / cacher les notes.
  • H pour afficher l'aide.
Fonction
Forme générale
def ‹nomFonction› (‹arguments›) :
        corps de la fonction
        [return ‹valeur›]

  • L'instruction return est optionnelle.
  • Si elle est absente, la fonction retourne None
  • Il ne peut pas y avoir plusieurs return dans une fonction
  • Il est possible de retourner plusieurs valeurs return a, b
  • Les arguments sont passés par valeur
Fonction

Exemple - Affichage
def afficheImpair (liste) :
        for k in liste :
                if (k%2 == 1) :
                        print k
››› liste = [1, 2, 3, 4]
››› afficheImpair(liste)
1
3
Fonction
Exemple - Factorielle
def factorielle (n) :
        res = 1
        if (n != 0) :
                res = n*factorielle(n-1)
        return res
››› print factorielle(6)
24
Fonction
Exemple - Recherche du min et max
def minmax (liste) :
        min = max = liste[0]
        for k in liste :
                if (min > k) :
                        min = k
                elif (max < k) :
                        max = k
        return (min, max)
››› liste1 = [18, 42, 3, 24]
››› min, max = minmax(liste1)
››› print 'Minimum = %d Maximum = %d' % (min, max)
Minimum = 3 Maximum = 42
Variables globales et locales
Variables locales
  • Variable définie à l'intérieur d'une fonction
  • Accessible uniquement dans la fonction

def toto () :
        test = 7
        return test*5
››› print test
Traceback (most recent call last):
  File "‹stdin›", line 1, in ‹module›
NameError: name 'test' is not defined
Variables globales et locales
Variables
  • Les noms de variables sont détectés de manière statique
  • Bien que le langage soit interprété, Python examine au préalable toutes les fonctions et interprète toutes les variables qui sont présentes dans la fonction comme étant locales, sauf si elles sont expressément déclarées comme globales.
››› X = 42
››› def s1() :
...         print X
›››
››› s1()
42
  • Python détecte X comme étant une variable globale
Variables globales et locales
Variables
››› X = 42
››› def s2() :
...         print X
...         X = 121
›››
››› s2()
Traceback (most recent call last):
  File "‹stdin›", line 1, in ‹module›
  File "‹stdin›", line 2, in s1
UnboundLocalError: local variable 'X' referenced before assignment
  • Python détecte X comme étant une variable locale
  • L'affectation se fait après l'affichage
  • Elle n'est pas initialisé avant son initialisation
  • Python détecte une erreur
Variables globales et locales
Variables globales
››› X = 42
››› def s3() :
...         global X
...         print X
...         X = 121
›››
››› s3()
42
››› print X
121

  • Utiliser des noms différents pour les variables locales et globales
  • Initialiser les variables avant leur première utilisation
Paramètre par défaut
Valeur par défaut
  • Définir une valeur par défaut pour chacun des arguments
  • On peut appeler une fonction avec seulement une partie des paramètres attendus

››› def calculTTC(prixHT, taux=0.2) :
...         return (prixHT*(1+taux))
›››
››› calculTTC(10)
12.0
››› calculTTC(20, 0.04)
20.8
Paramètres nommés
Arguments avec étiquettes
  • Les paramètres données doivent être dans le même ordre que lorsqu'ils ont été définis dans la méthode
  • Python autorise de mélanger l'ordre lors de l'appel à condition :
    • de nommer explicitement le nom du paramètre en plus de la valeur
    • si on ne nomme pas tous les paramètres, il doit y avoir des valeurs par défauts pour chaque paramètres
Paramètres nommés
Exemple
››› def histoire(hero='Aladin', animal='singe Abbu', lieu='palais'):
...         print '%s accompagné de son %s se rend au %s'%(hero, animal, lieu)
›››
››› histoire (hero='cid', animal='chocobo', lieu='bord de mer')
cid accompagné de son choco se rend au bord de mer
››› histoire (animal='cid', hero='choco')
choco accompagné de son cid se rend au palais
Arguments implicites
Arguments implicites
  • Appeler une fonction avec autant de paramètres voulu
  • Sans expliciter les paramètres qui seront présents
  • Les valeurs de ces paramètres seront placées dans un dictionnaire
    • clé : nom du paramètre
    • valeur : valeur du paramètre
  • Déclaration : nom du paramètre précédé de **
  • Appel : nom1=valeur1, nom2=valeur2, ...
Arguments implicites
Exemple
def boissons (** boisson ) : #Association personnes et boissons
        print 'Il y a eu %d boissons' % len(boisson)
        print 'Liste des boissons : %s' % ''.join(boisson.values())
        print 'Noms des buveurs : %s' % ''.join(boisson.keys())
        for buveur in boisson :
                print'%s : %s ' % (buveur , boisson[buveur])

››› boissons(toto="lait",koko="biere",lolo="the",momo="vin")
Il y a eu 4 boissons
Liste des boissons : biere the vin lait
Noms des buveurs : koko lolo momo toto
koko : biere
lolo : the
momo : vin
toto : lait
Arguments arbitraires
Arguments arbitraires
  • Similaire aux arguments implicites
  • Ils ne sont pas nommés
  • Les valeurs de ces paramètres seront placées dans un tuple
  • Déclaration : nom du paramètre précédé de *
Arguments arbitraires
Exemple
def somme (* val ) :
        r = 0
        for i in val :
                r += i
        return r

››› elt = [1, 2, 4, 5, 8]
››› somme(*elt)
20
Commenter une fonction
Commentaires
def somme (* val ) :
        """Calcul de la somme d'un nombre qq de valeurs
                        passees en argument arbitraire"""
        r = 0
        for i in val :
                r += i
        return r

››› somme.__doc__
"Calcul de la somme d'un nombre qq de valeurs \n passees en argument arbitraire"
Fonction anonyme
Forme générale
lambda ‹arguments› : corps de la fonction

  • Définir une fonction anonyme avec le mot clé lambda
  • Dispose que d'une ligne de traitement
››› f1 = lambda x : x**3
››› f1(4)
64
››› f2 = lambda x,y : x**y
››› f2(2,8)
256
Map
Forme générale
map(function, iterable, ...)

  • Applique une fonction à chacun des éléments de la structure de donnée itérable, et le traitement est fait en parallèle
  • Retourne le résultat sous forme de liste
  • Peut prendre plusieurs éléments itérables
    • La fonction de avoir autant de paramètres que d'éléments itérables
    • Si un élément itérable est plus court, il est complété avec la valeur None
Map
Exemple
››› a = [1,2,3,4]
››› b = [17,12,11,10]
››› c = [-1,-4,5,9]
››› map(lambda x,y:x+y, a,b)
[18, 14, 14, 14]
››› map(lambda x,y,z:x+y+z, a,b,c)
[17, 10, 19, 23]
››› map(lambda x,y,z:x+y-z, a,b,c)
[19, 18, 9, 5]
Reduce
Forme générale
reduce(function, iterable[, initializer])

  • La fonction a 2 paramètres
  • Reduce applique la fonction aux éléments deux par deux, de gauche à droite, afin de réduire l'itérable à une seule valeur
  • Exemple : reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calcule ((((1+2)+3)+4)+5)
  • Le paramètre x est le cumulateur, et y est la valeur de l'itérable à appliquer
  • Le paramètre initializer est optionnel, et est placé avant les éléments itérables. Il peut servir de valeur par défaut dans le cas d'un itérable vide
Reduce
Exemple
# calcul la somme des nombres allant de 1 à 100
››› reduce(lambda x, y: x+y, range(1,101))
5050


# Détermine le minimum d'une liste
››› f = lambda a,b: a if (a > b) else b
››› reduce(f, [47,11,42,102,13])
102
Filter
Forme générale
filter(function, iterable)

  • Construit une liste à partir des éléments pour lesquels la fonction retourne vrai
  • Si l'élément itérable est une chaîne de caractères ou un tuple, le résultat de filter est le même
  • Si la méthode est None, la fonction identitée est appliquée, ce qui fait que tous les éléments faux sont retirés
  • filter(function, iterable) est équivalent à [item for item in iterable if function(item)]
Filter
Exemple
# garde tous les éléments impairs de la suite de fibonacci
››› fib = [0,1,1,2,3,5,8,13,21,34,55]
››› result = filter(lambda x: x % 2 == 1, fib)
››› print result
[1, 1, 3, 5, 13, 21, 55]


# affiche les ages acceptés par la réduction JEUNE de la SNCF
››› ages = range(30)
››› majeurs = filter(lambda x: x ›= 12 and x ‹= 27, ages)
››› print(majeurs)
[12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27]