Utiliser des paramètres de la fonction

# Décrit un argument entre Form 
paramètre #: paramètre appelé les paramètres formels définis dans la fonction de phase de définition, appelée paramètre correspondant au nom de la variable 
# DEF FUNC (X, Y):. X = # 1, Y = 2 
# imprimer (X, Y) 

arguments n °: l'appel de fonction appelant la valeur de paramètre réelle passée par étapes, appelé l'argument, ce qui équivaut à la valeur de la variable 
# func (1,2) 

la relation entre la forme argumentation #: 
# 1, dans la phase d'appel, l'argument (valeur variable) sera lié au paramètre (nom variable) 
# 2, cette relation de liaison ne peut être utilisé dans le corps de la fonction 
# 3, la relation de liaison entre la participation effective dans le paramètre formel prend effet lorsque l'appel de fonction après la fin de l'appel de fonction unbind 

valeur d'argument # est transmis, mais la valeur peut être sous la forme 
# forme: 
# FUNC (1,2) 

# deux formes: 
. # a 1 = 
# 2 = B 
# FUNC ( a, b) 

# trois formes: 
# func (int ( » 1' .) 2) 
# FUNC (func1 (1,2,), func2 (2,3), 333) 

# dimorphes arguments liés à l'utilisation spécifique 
# 2.1 paramètres de position: en séquence de gauche à droite en fonction des paramètres définis paramètre la position appelée 
position # paramètre: dans la phase de définition de la fonction, de gauche à droite dans l'ordre défini directement « nom de la variable » 
# Caractéristiques: doivent être livrés valeur, une plus au moins Ni 
# DEF FUNC (le X-, le y-): 
# Imprimer (le X-, le y-) 
# FUNC (2, 3)
FUNC # (1,.) 

Position # paramètres réels: l' appel de la phase de la fonction, de la gauche à la valeur transmise dans un ordre quelconque de 
# Caractéristiques: l'ordre d'un paramètre 

# FUNC (1,2) 
# FUNC (2 , 1) 

# 2.2 mot - paramètre 
# mot - clé arguments: appel de la fonction de phase, entrant sous forme de clé = valeur de la valeur des 
caractéristiques n: par nom pour transmettre une valeur de paramètre, peut se référer à une séquence complètement 
# DEF FUNC (X, Y): 
# impression (X, Y) 

# FUNC (Y = 2, X = 1) 
# FUNC (1,2) 

mélange # souligne 
# 1, doit être placé dans la position de l'argument de l' argument mot - clé avant 
# FUNC (. 1, Y = 2) 
# FUNC (Y = 2,1) 

# 2, ne peut pas être répétée pour les mêmes valeurs de paramètres de transmission 
# FUNC (. 1, Y = 2, X =. 3) 
# FUNC (. 1, 2 ,. 3 X =, Y = 4). 

# 2.3 par défaut des paramètres 
# paramètres par défaut: la phase de définition fonction, a été attribuée à un paramètre, appelé les paramètres par défaut 
# caractéristiques: dans la phase de définition avait été assignée, des moyens dans la phase appel ne peut attribuer une valeur à 
# DEF FUNC (le X-, le y- = 3): 
# impression (le X-, le y-) 
# 
# # FUNC (= X-1) 
# FUNC (= X-1, le y- = 44444)

# Registre Def (nom, âge, sexe = ' M'): 
# Imprimer (nom, âge, sexe) 
# 
# registre ( 'trois armes à feu', 18 est) 
(. 'Artillerie', 19) # registre 
# registre ( » canon '19) 
# registre (' pas d' arme '19,' féminin « ) en 

forme de location-# participer mélange de paramètres par défaut, a souligné: 
# 1, paramètre de position doit être dans le paramètre par défaut sur la gauche 
# def func (y = 2, X): 
# passe 

n ° 2, les valeurs des paramètres par défaut sont affectées dans la phase de définition de la fonction, est spécifiquement affectée valeur d'adresse mémoire 
modèle n ° 1:. 
# 2 = m 
# DEF FUNC (X, Y = m) : # y => adresse de mémoire 2 
# impression (X, Y 
# m = 3333333333333333333 
# FUNC (1). 

# modèle 2: 
# m = [111111] , 
# 
# DEF FUNC (X, Y = m): # Y = > [111111] adresse mémoire 
# Imprimer (X, Y) 
# 
# m.append (3333333) 
# FUNC (. 1) 

#. 3, bien que les valeurs par défaut peuvent être spécifiées comme tout type de données, type de variable mais non recommandé
# Idéal fonction d'état: fonction d' appel a seulement une relation avec la fonction elle - même, ne modifie pas le code externe 
# m = [111111,] 
# 
# DEF FUNC (X, Y = m): 
# Imprimer (X, Y) 
# 
# m.append (3333333) 
# m.append (444444) 
# m.append (5555) 
# 
# FUNC (. 1) 
# FUNC (2) 
# FUNC (. 3) 

# DEF FUNC (X, Y, Z, L = None) : 
# EST L IF None: 
# L = [] 
# l.append (X) 
# l.append (Y) 
# l.append (Z) 
# impression (L) 

# FUNC (l, 2,3) 
# FUNC ( 4,5,6) 

# new_l = [111222] 
# FUNC (l, 2,3, new_l) 

# 2.4 paramètre de longueur variable (* et ** usage) 
# moyens de longueur variable lorsque l'appel de fonction, le nombre de valeurs entrantes (argument) n'est pas fixe 
argument # est utilisé pour l'affectation des paramètres, les correspondants, les paramètres réels pour le dépassement doit être reçu paramètre correspondant 

# 2.4.1 longueur variable paramètres de position
I #: Nom du paramètre *: position de débordement pour recevoir des arguments, la position du trop - plein * participants réels sont enregistrés en tant que format tuple alors attribué le nom de paramètre immédiatement après 
# * talon peut être un nom, Cependant, la convention devrait args 

# DEF FUNC (X, Y, Z *): # Z = (3,4,5,6) 
# Imprimer (X, Y, Z) 

# FUNC (1,2,3,4,5 , 6). 

# DEF my_sum (* args): 
# RES = 0 
# args dans le numéro: 
# = RES + Point 
# retour RES 
# 
# my_sum RES = (1,2,3,4) 
# Imprimer (RES) 

# II : * peut être utilisé dans les arguments, l'argument par *, la valeur du premier argument * brisé en position 
# DEF FUNC (X, Y, Z): 
# impression (X, Y, Z) 
# 
# # FUNC (* [11,22,33]) # FUNC (11,22,33) 
# # FUNC (* [11,22]) # FUNC (11,22) 
# 
# L = [11,22,33] 
# FUNC (L *) 

# III: Les types de paramètres réels sont avec * 
# DEF FUNC (X, y, * args): # args = (3,4,5,6) 
# Imprimer (X, y, args)

FUNC # (1,2, [3,4,5,6]) 
# FUNC (1,2, * [3,4,5,6]) # FUNC (1,2,3,4,5,6) 
FUNC # (* 'Bonjour') FUNC # ( 'H', 'E', 'L', 'L', 'O') 

# 2.4.2 longueur variable paramètres clés 
# I: nom du paramètre ** : recevoir un trop - plein d'arguments - clés, mots - clés ** débordera arguments enregistrés dans un format dictionnaire, puis assignés à suivi de près par le nom du paramètre 
peut être un nom # ** talon, mais la convention devrait quels kwargs 
# DEF func (X, Y, kwargs **): 
# impression (X, Y, kwargs) 
# 
# FUNC (.. 1, Y = 2, A = 1, B = 2, C = 3.) 

# II: * * peut être utilisé dans l'argument (** talon que le dictionnaire), avec les arguments *, ** valeur du premier argument divisé en catégories 
# DEF FUNC (X, Y, Z): 
# Imprimer (X, Y, Z) 

# FUNC (* { 'X' :. 1, 'Y': 2, 'Z' :. 3}) # FUNC ( 'X', 'Y', 'Z') 
# FUNC ( {** 'X' :. 1, 'Y' 2, 'Z':}... 3) FUNC # (X = 1, Y = 2, Z = 3) 

# erreur 
# func (** { 'x' : 1 , 'y': 2,} ) # func (x = 1,2 = Y) 
# FUNC ({** 'X' :. 1, 'A': 2, 'Z':}.. 3) FUNC # (X = 1, A = 2, Z = 3). 

# III: Types de réelle à la fois en référence **
DEF FUNC # (X, Y, kwargs **): 
# impression (X, Y, kwargs) 

# func (Y = 222, X = 111, A = 333, B = 444) 
# FUNC (** { 'Y' : 222, 'X': 111, 'A': 333, 'B': 4444}) 

# mélange * et **: * args doit kwargs avant ** 
# DEF FUNC (X, * args, ** kwargs) : 
# impression (args) 
# impression (kwargs) 
# 
# FUNC (.. 1,2,3,4,5,6,7,8, X = 1, Y = 2, Z = 3) 

N ° de DEF (X, Y , Z): 
# Imprimer ( 'index = >>>', X, Y, Z) 

# warpper DEF (* args, ** kwargs): args = # (1,) = {kwargs' Z ':.. 3,' Y ': 2} 
index # (* args, ** kwargs) 
    Index # (de * (1,), ** {.' Z '3,' Y « : 2}) 
    index # (1 ,. 3 = Z, Y. 2 =) 

wrapper # (. 1 ,. 3 = Z, Y = 2) paramètre # est transmise à l'enveloppe avec un indice 
# --- format original "récapitulatif -----" aiguillon