Cet article décrit les paramètres de la fonction Python et piège les paramètres par défaut, la fonction sera divisée en paramètres de texte paramètres obligatoires, les paramètres par défaut, les paramètres variables et paramètres clés sont concernés, à des amis peut se référer à ce qui suit
en C ++ fonction permet de régler les paramètres par défaut, Java ne peut pas, ne peut être atteint par une surcharge de la manière, en python peut également définir les paramètres par défaut, le principal avantage est de réduire la difficulté de la fonction, la définition de fonction est une seule et python est un langage dynamique, en le même espace de nom ne peut pas avoir voulu que le nom de la fonction, s'il y a, il apparaît après avoir couvert l'avant de la fonction.
def power(x, n=2):
s = 1
while n > 0:
n = n - 1
s = s * x
return s
Regardez les résultats:
>>> power(5)
25
>>> power(5,3)
125
Note: Paramètre requis en premier, suivi par les paramètres par défaut, sinon l'interpréteur Python se plaindra.
Recommandation: * Quand il est fonction de plusieurs paramètres, les paramètres mis en face des grands changements, de petits changements dans les paramètres remis en place. De petits changements dans les paramètres peuvent être utilisés comme paramètres par défaut.
Les paramètres par défaut ont fosse, regardez le code suivant pour définir une liste, ajoutez une extrémité arrière:
def add_end(L=[]):
L.append('END')
return L
Appel à voir les résultats:
>>> add_end([1, 2, 3])
[1, 2, 3, 'END']
>>> add_end(['x', 'y', 'z'])
['x', 'y', 'z', 'END']
>>> add_end()
['END']
>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']
Il doit expliquer, fonction Python définie à l'époque, la valeur par défaut du paramètre L a été calculée à partir, à savoir []. A ce stade, L []. Donc, si le contenu de L modifier le contenu du prochain appel n'est plus référencé [] a. Donc, gardez à l'esprit que la définition des paramètres par défaut doit pointer des objets immuables! .
Variable paramètre
la première méthode, le paramètre passé à une liste ou tuple.
def calc(numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
invocation:
>>> calc([1, 2, 3])
14
>>> calc((1, 3, 5, 7))
84
Le deuxième mode de réalisation, une pluralité de paramètres directement dans le fonctionnement interne reçu automatiquement par un tuple.
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
invocation:
>>> calc(1, 2)
5
>>> calc()
0
Si vous voulez cette fois-ci une liste ou tuple dans le transfert de données en compte, il peut être:
>>> nums = [1, 2, 3]
>>> calc(*nums)
14
arguments les mots - clés
les arguments vous permettent passer 0 ou un certain nombre de paramètres , y compris le nom du paramètre, ces paramètres - clés sont assemblés automatiquement dans un dict intérieur de la fonction.
def person(name, age, **kw):
print 'name:', name, 'age:', age, 'other:', kw
Appel:
>>> person('Michael', 30)
name: Michael age: 30 other: {}
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
combinaison de paramètres
définis dans la fonction Python, peut être un paramètre obligatoire, les paramètres par défaut et les paramètres des paramètres variables, ces quatre paramètres peuvent être utilisés ensemble ou seulement quelques - uns, mais veuillez noter que les paramètres de commande sont définis comme ils sont les suivants : paramètres obligatoires, les paramètres par défaut, les paramètres variables et paramètres clés.
fonction récursive
rien de base à parler, et Java / C ++ dans le même, cet appel son propre. Ici se concentrer sur ce que l' optimisation de la récursivité queue. En fait boucle récursive de la queue et l' effet est le même, il est clair que l' un des avantages est que nous pouvons empêcher le débordement de la pile d'appels récursifs.
Définition: se dit lorsque la fonction retourne, et, instruction de retour ne peuvent pas contenir des expressions. Compilateur ou interprète peut faire pour optimiser, peu importe combien de fois appeler, il suffit d' un cadre de pile, le débordement ne se produit pas.
Voici un exemple simple à la fonction factoriel comme exemple:
def fact(n):
if n==1:
return 1
return n * fact(n - 1)
Si le n entrant est grand, il peut déborder, ce qui est dû revenir n * fact (n - 1) introduit une expression de multiplication, ce n'est pas récursion queue. La modification du code:
def fact(n):
return fact_iter(n, 1)
def fact_iter(num, product):
if num == 1:
return product
return fact_iter(num - 1, num * product)
Les paramètres par défaut piège
définition de la fonction Python fournit les paramètres par défaut sont sélectionnés tels que la définition de la fonction et l' utilisation de plus souple, mais aussi apporter une fosse, par exemple, avant un exemple: la
définition de la fonction:
def add_end(L=[]):
L.append('END')
return L
Le résultat de l'appel de la fonction:
>>> add_end([1, 2, 3])
[1, 2, 3, 'END']
>>> add_end(['x', 'y', 'z'])
['x', 'y', 'z', 'END']
>>> add_end()
['END']
>>> add_end()
['END', 'END']
>>> add_end()
['END', 'END', 'END']
Il est clair que la définition ne correspond pas à l'intention initiale de la fonction, une explication de la phrase est:
les valeurs par défaut sont calculés Une fois, alors RÉUTILISÉS.
Pour étudier cette question, nous examinons un autre exemple:
# coding=utf-8
def a():
print "a executed"
return []
def b(x=a()):
print "id(x):", id(x)
x.append(5)
print "x:", x
for i in range(2):
print "不带参数调用，使用默认参数"
b()
print b.__defaults__
print "id(b.__defaults__[0]):", id(b.__defaults__[0])
for i in range(2):
print "带参数调用，传入一个list"
b(list())
print b.__defaults__
print "id(b.__defaults__[0]):", id(b.__defaults__[0])
REMARQUE: expliquer un peu, toutes les valeurs par défaut sont stockés dans __defaults__ objet fonction de la propriété, qui est une liste de chaque élément sont des valeurs de paramètres par défaut.
Jetez un oeil à la sortie:
a executed
不带参数调用，使用默认参数
id(x): 140038854650552
x: [5]
([5],)
id(b.__defaults__[0]): 140038854650552
不带参数调用，使用默认参数
id(x): 140038854650552
x: [5, 5]
([5, 5],)
id(b.__defaults__[0]): 140038854650552
带参数调用，传入一个list
id(x): 140038854732400
x: [5]
([5, 5],)
id(b.__defaults__[0]): 140038854650552
带参数调用，传入一个list
id(x): 140038854732472
x: [5]
([5, 5],)
id(b.__defaults__[0]): 140038854650552
Une simple analyse de la sortie:
ligne 1
dans la définition de la fonction B (), à savoir def ligne de codage exécution de l' instruction def 7 b (x = a ( )): lorsque ces mots en utilisant les paramètres par défaut, définis dans la quand calculera la valeur par défaut du paramètre x, et cette fois -ci appellera un (), imprimez donc une exécution.
6 secondes pour aligner
la première fois à travers la boucle, le code sur la ligne 14 pour appeler B () ne passe pas les paramètres, à l' aide des paramètres par défaut, lorsque x = [], de sorte que , après un seul appel
print b.__defaults__
La sortie est
([5],)
7 à 11 de la rangée
du deuxième cycle, les 14 premières lignes de code pour appeler B () ne passe pas les paramètres, en utilisant des paramètres par défaut.
Remarque: les paramètres par défaut sont comptés qu'une seule fois, ce qui signifie que la zone de mémoire est fixe, mais l'adresse pointée à une liste, le contenu peut être modifié à ce moment parce que le dernier appel x: [5], donc
print b.__defaults__
La sortie est
([5, 5],)
12 à 16 rangées de
la deuxième boucle, la première boucle, la première ligne de code 20 de la liste de réception vide, les paramètres par défaut ne sont pas utilisés, alors x = [], de sorte que
print b.__defaults__
La sortie est
([5],)
21, ligne 18 à
la seconde boucle, le second cycle, la ligne de codage 20 adopté une liste vide, il n'utilise les paramètres par défaut, est toujours le cas x = [], de sorte que
print b.__defaults__
La sortie sera toujours
([5],)
Les fonctions sont des objets, donc quand la définition est exécutée, les paramètres par défaut sont fonction de la propriété, sa valeur peut changer la fonction est appelée. D' autres objets ne sont pas tout à fait vrai?
Gardez à l' esprit: les paramètres par défaut doivent pointer vers les mêmes objets! modifier le code comme suit:
# coding=utf-8
def a():
print "a executed"
return None
def b(x=a()):
print "id(x):", id(x)
if x is None:
x = []
x.append(5)
print "x:", x
for i in range(2):
print "不带参数调用，使用默认参数"
b()
print b.__defaults__
print "id(b.__defaults__[0]):", id(b.__defaults__[0])
for i in range(2):
print "带参数调用，传入一个list"
b(list())
print b.__defaults__
print "id(b.__defaults__[0]):", id(b.__defaults__[0])
Sortie à ce moment pour voir ce que le résultat est le suivant:
a executed
不带参数调用，使用默认参数
id(x): 9568656
x: [5]
(None,)
id(b.__defaults__[0]): 9568656
不带参数调用，使用默认参数
id(x): 9568656
x: [5]
(None,)
id(b.__defaults__[0]): 9568656
带参数调用，传入一个list
id(x): 140725126699632
x: [5]
(None,)
id(b.__defaults__[0]): 9568656
带参数调用，传入一个list
id(x): 140725126699704
x: [5]
(None,)
id(b.__defaults__[0]): 9568656
Je vous écris, pour tout le monde de recommander un très large rassemblement de ressources d'apprentissage python, cliquez pour entrer , il y a un programmeur senior avant d' apprendre à partager des expériences, des notes d'étude, il y a une chance d'expérience en affaires, et pour tout le monde d'organiser soigneusement un zéro python la base des données réelles du projet, python quotidien pour vous sur les dernières technologies, les perspectives, apprendre à laisser un message de petits détails
