Les arguments de la fonction (en Python par exemple)

En quelques mots, ils sont des données qui est "passé" dans la fonction pour lui dire quoi faire. Wikipédia a des détails.

http://en.wikipedia.org/wiki/Function_argument

Par exemple, votre hi() fonction pourriez avoir besoin de savoir à qui dire bonjour à:

def hi(person):
    print "Hi there " + person + ", how are you?"

Ou une fonction mathématique pourrait avoir besoin d'une valeur de fonctionner sur:

def square(x):
     return x * x

Ce n'est pas un Python question, mais plutôt une programmation générique question. Très basique.

---

Avant de répondre à la question sur arguments, et compte tenu des autres questions que vous avez posées, il est utile de discuter de la concept de variables.

Une variable est un nom de morceau de la mémoire où l'information d'intérêt pour le sous-programme peuvent être stockées et récupérées. En d'autres termes, c'est un nom symbolique, choisi par le programmeur, qui est associé à son contenu. À l'aide de diverses constructions de langage généralement connu comme affectations, le programmeur peut lire ou écrire le contenu d'une variable.

Il est important de noter que la valeur (le contenu) d'une variable ne doit pas être défini lorsque le programme est écrit. Il est seulement nécessaire au moment de l'exécution. Cela permet au programme de décrire les actions à effectuer sur des éléments symboliques sans connaître exactement la valeur de ces éléments. Considérons cet extrait de code, partie d'un grand programme:

# ... some logic above
ball_volume = 4.0 / 3 * math.pi * ball_radius
if ball_volume > 200:
   print ("Man, that's a big ball")
# ... more logic below

À la fois que le programme est écrit, on n'a pas besoin de connaître la valeur réelle de ball_radius; pourtant, avec l'hypothèse que cette variable contient la valeur numérique d'une hypothétique de la balle, le modèle est capable de décrire comment calculer le ballon de volume. Dans ce mode, lorsque le programme est en cours d'exécution, et en quelque sorte (plus sur cela plus tard) le ball_radius variable a été initialisée avec une certaine valeur appropriée, la variable ball_volume peut aussi être initialisé et utilisé, ici, dans l'instruction conditionnelle (si), et éventuellement ci-dessous. (À un certain point, la variable peut aller hors-de-portée, mais ce concept qui contrôle particulier lorsque les variables sont accessibles à le programme est bien au-delà de cette introduction).

Dans certaines langues, le type de données qui peuvent être associés à une variable particulière doit être explicitement défini et ne peut pas changer. Par exemple, certaines variables peuvent contenir que des valeurs entières, les autres variables de la chaîne de valeurs (texte) etc. En Python il n'y a pas de telles restrictions, une variable peut être affecté et ré-attribuée à n'importe quel type de données, mais bien sûr, le programmeur doit garder la trace de cette par exemple pour éviter de transmettre certaines données de texte à une fonction mathématique.

Les données stockées à l'intérieur de la variable peuvent provenir de sources très différentes. Beaucoup de ces exemples, des tutoriels et de la documentation d'introduction de données provenant de l'entrée de clavier (comme lors de l'utilisation de raw_input comme mentionné dans certains de vos questions). C'est parce qu'elle permet à des tests interactifs, par les gens qui essaient de sortir ces tutoriel extraits. Mais l'utilité des programmes de serait plutôt limité si les variables seulement obtenir leurs données à partir de la saisie utilisateur interactive. Il existe de nombreuses autres sources et c'est ce qui rend la programmation tellement puissant: les variables peuvent être initialisées avec des données de:

• bases de données
• des fichiers texte ou des fichiers divers texte de la base de formats (XML, JSON, CSV..)
• des fichiers binaires avec de divers formats
• connexions internet
• périphériques physiques: caméras, capteurs de température...

---

En un mot, Arguments, également appelé Paramètres, sont variables passé à la fonction qui [généralement] sont utilisés pour fournir de sortie différents et le comportement de la fonction. Par exemple:

>>> def say_hello(my_name):
...    print("Hello,", my_name, "!")

>>> say_hello("Sam")
Hello, Sam !
>>> customer_name = "Mr Peter Clark"    #imagine this info came from a database
>>> # ...
>>> say_hello(customer_name)
Hello, Mr Peter Clark !
>>>

Dans l'exemple ci-dessus, my_name est juste comme n'importe quelle variable locale de la say_hello fonction, ce qui permet à la fonction de définir ce qu'il va faire avec la valeur sous-jacente lorsque la fonction est appelée, au moment de l'exécution.

Au moment de l'exécution, la fonction peut être appelée avec une valeur immédiate (une valeur qui est "codée en dur" dans la logique, comme "Sam" dans l'exemple), ou avec [la valeur] une autre variable (par exemple,customer_name). Dans les deux cas, la valeur de la fonction de my_name variable est affectée de la valeur, "Sam" et "M. Peter Clark", respectivement. Dans ce dernier cas, cette valeur est ce que l' customer_name variable contient. Notez que le noms des variables utilisées dans la fonction (my_name) et lorsque la fonction est appelée (customer_name) n'ont pas besoin d'être le même. (que l'on appelle le "paramètre formel(s)" et "paramètres", respectivement)

Noter que, bien que généralement la plupart des arguments passés comme entrée à une fonction, dans certaines conditions, ils peut être utilisé comme sortie, c'est à dire de fournir de nouveaux/modifiés valeurs au niveau de la logique qui a appelé la fonction. Cela requiert de l'aide, implicitement ou explicitement, la bonne convention d'appel cahier des charges (Voir Argument passing conventions ci-dessous)

---

Maintenant... au-delà de cette compréhension de base de l'objet de paramètres, les choses deviennent un peu plus compliqué que ça (mais pas beaucoup). Je vais discuter de ces concepts en général et de l'illustrer comme ils s'appliquent à Python.

Valeurs par défaut pour les arguments (aka "option", arguments)

Lorsque la fonction est déclarée, il peut spécifier la valeur par défaut pour certains paramètres. Ces valeurs sont utilisées pour les paramètres qui ne sont pas spécifiés lorsque la fonction est appelée. Pour des raisons évidentes, ces paramètres facultatifs sont offerts à la fin de la liste des paramètres (sinon le compilateur de langage/interprète peut avoir de la difficulté à trouver le paramètre qui est qui...)

>>> def say_hello(dude = "Sir"):
...     print("Hello,", dude, "!")
...
>>> say_hello()
Hello, Sir !
>>> say_hello("William Gates")
Hello, Bill !            #just kidding ;-)
Hello, William Gates !   # but indeed. works as the original function when param
                         # is specified

Nombre Variable de paramètres

Dans certains cas, il peut être utile de définir une fonction de sorte qu'il peut accepter un nombre variable de paramètres. Bien que ces listes de valeurs de paramètre en fin de compte se passait dans une sorte de récipient (liste, tableau, collection...) divers langues propose des façons d'accéder à ces valeurs de paramètre.

>>> def add_many(operand1, *operands):
...    Sum = operand1
...    for op in operands:
...       Sum += op
...    return Sum
...
>>> add_many(1, 3, 5, 7, 20)
36
>>> add_many(1, 3)
4

Arguments Nommés (Mot-Clé Arguments)

Avec Python et quelques autres langues, il est possible explicitement le nom de la arguments lors de l'appel de la fonction. L'argument selon lequel le passage est par défaut basé sur une position de base ("1er argument, 2e argument etc.), Python vous permettra de nommer les arguments et les passer dans n'importe quel ordre. C'est essentiellement syntaxique, finesse, mais peut être utile, en combinaison avec des arguments par défaut pour les fonctions qui acceptent de très nombreux arguments. C'est aussi une belle auto-documentation fonctionnalité.

>>> def do_greetings(greeting, person):
...    print (greeting, "dear", person, "!")
...
>>> do_greetings(person="Jack", greeting="Good evening")
Good evening dear Jack !

En Python, vous pouvez même passer d'un dictionnaire au lieu de plusieurs arguments nommés par exemple, avec do_greetingsas-est, imaginez que vous avez un dictionnaire comme:

>>> my_param_dict = {"greeting":"Aloha", "person":"Alan"}

>>> do_greetings(**my_param_dict)
Aloha dear Alan !

En conclusion, et bien que les drôles de façons de passer des arguments, et la capacité pour des méthodes pour gérer un nombre variable d'arguments, qui sont des fonctions utiles de différentes langues, deux concepts clés doivent être mentionnés:

Argument en passant convention : par valeur ou par référence

Jusqu'à présent, toutes les fonctions que nous avons utilisé n'ai pas modifier la valeur des paramètres passés. On peut imaginer toutefois dans de nombreux cas, les fonctions de cette formation, que ce soit pour effectuer certaines de conversion ou de calcul sur les mêmes valeurs, pour son propre usage interne, ou à un changement de la valeur de la variable de sorte que les modifications sont répercutées au niveau de la logique qui a appelé la fonction. C'est là l'argument en passant des conventions viennent à portée de main...

les arguments qui sont passés en valeur peut être modifié par la fonction que pour ses propres calculs, mais ne sont pas modifiées au niveau de l'appel de la méthode.

les arguments qui sont passés par référence sera de refléter les modifications qui y sont apportées, au niveau de la méthode appelante.

Chaque langue précise les modalités que les arguments sont passés. Typique de la convention est de passer des entiers, numberic valeurs et d'autres types de base par la valeur et passer des objets par référence. La plupart offrent également des mots clés qui permettent la modification de leur défaut de convention.

En python tous les arguments sont passés par référence. Cependant quelques variables, les types sont immuables (nombres, chaînes, tuples...) et ils peuvent donc pas être modifié par la fonction.

Implicite "auto" ou "cet" argument des méthodes de la classe

Dans les langages orientés objets, des méthodes (c'est à dire des fonctions au sein d'une classe) recevoir un argument supplémentaire qui est la valeur de l'objet sous-jacent (l'instance de la classe), permettant la méthode à utiliser les différentes propriétés des membres de la classe dans son calcul et/ou de modifier la valeur de certaines de ces propriétés.

en Python, cet argument est déclaré au niveau de la définition de la méthode, mais il est passé implicitement. D'être déclaré, il peut être nommé plus quelque chose que l'on souhaite, bien que, par convention, ce qui est généralement appelé auto.

>>> class Accumulator:
...   def __init__(self, initialValue = 0):
...        self.CurValue = initialValue
...   def Add(self, x):
...        self.CurValue += x
...        return self.CurValue
...
>>> my_accu = Accumulator(10)
>>> my_accu.Add(5)
15
>>> my_accu.Add(3)
18

Dans votre exemple, ils ne sont pas utilisés.

Si votre fonction doit se comporter différemment selon les arguments que vous donnez, alors que les arguments sont pour.

def hi_name(name):
    print 'Hi ' + name

hi_name("John doe")

Cette affiche "Salut John Doe".

Maintenant, revenons à l'essentiel fonctions.

Fonctions serait inutile si vous ne pouvez pas leur donner des informations qu'ils doivent gérer.

Les Arguments sont de telles informations.

def GiveMeANumberAndIDuplicateIt(x):
    return x * 2

def DontGiveMeAnythingAtAll():
    return None