Cahier Bleu à Paulo

Fonctions avec un nombre fixé de paramètre :
- paramètre par défaut
- paramètre non nommé
- ordre des paramètres

def truc(a, b , c=2 , d=3):
...

truc(0, 1) retourne a=0, b=1, c=2, d=3
#
truc(0, 1, 4) retourne a=0, b=1, c=4, d=3
#
truc(0,1, 4, 5) retourne a=0, b=1, c=4, d=5
#

Jusque là, rien de bien neuf.
Par contre, ou python devient intéressannt :

Fonctions avec un nombre non fixé de paramètre :
- *args qui contient un tuple des paramètres passés
- **kwargs contiendra un dictionnaire des param (par contre, les paramètres doivent etre passés sous forme de dico)
 

def truc(*args):
...
truc(1, 2,  'salut') retourne (1, 2, 'salut')

def truc(**kwargs):
...
truc(i=1, j=2,  chaine='salut') retourne {('i': 1, 'j': 2, 'chaine': 'salut')}
truc(1, 2, 'salut') ne retourne rien !

Exemple d'un script qui prend (ou pas) un/deux paramètres (user et/ou password) :
 

#!/usr/bin/python
import sys 
import pexpect

def pam(username='default', password='changeme'):
   '''Accepts user/password and tried to use PAM'''
   print "user : ", username
   print "pass : ", password
      try:
         ...
      except Exception as err:
         return False
      else:
         print ("Authentication succeeded for user %s."%(username))
         return True

def main(args):
   print pam(*args)

if __name__ == '__main__':
   main(sys.argv[1:])

En résumé, voici une fonction qui accepte toute forme et toute quantité de parametres (nommés ou non) :

def maFonction(*args, **kwargs):
    print args
    print kwargs

maFonction(5,6)
   (5, 6)
    {}

maFonction(10, a=10, chat='minou', chien='medor')
    (10)
    {'a': 10, 'chien': 'medor', 'chat': 'minou'}
 

Récuperation x parametres et appel fonction :

...

def readDB(*kargs, **kwargs):
    print(kargs)
    print(kwargs)
    ...

def main(argv):
    if len(argv) == 1:
        param = dict({'annee': argv[0] })
    elif len(argv) == 3:
        param=dict({'annee': argv[0], 'mois': argv[1], 'departement': argv[2] })
      else:
        print('Nombre d\'arguments non valable !!!!!')
        exit(1)
    #appel de la fonction avec le dictionnaire
   readDB(**param) 

Fonction qui accepte n'importe quel type de paramètres, nommés ou non, dans n'importe quel ordre, dans n'importe quelle quantité :

#
>>> def fonction_inconnue(*en_liste, **en_dictionnaire):
>>> fonction_inconnue('5','test',truc, prout='moche')
>>>
J'ai reçu en paramètres nommés : {'prout': 'moche'}.
J'ai reçu en paramètres non nommés : ('5', 'test', <function truc at 0x7eff71c977d0>)

Nb : https://openclassrooms.com/courses/apprenez-a-programmer-en-python/les-dictionnaires-2