Comment passer un paramètre vide pour une fonction python?

Voici le code de travail:

def g(y=10):
    return y**2

def f(x,y=10):
    return x*g(y)

print(f(5)) #->500

Cependant, supposons que nous ne voulons pas nous en souvenir et de copier une valeur par défaut du mot de paramètre y à la définition de la fonction externe (surtout si il y a plusieurs couches de fonctions externes). Dans l'exemple ci-dessus, cela signifie que nous voulons utiliser le paramètre, déjà définis dans g.

Une façon de le faire:

def f(x,y=None):
    if y==None: return x*g()
    else: return x*g(y)

Mais est-il une manière plus propre à faire de même?
Quelque chose comme:

def f(x,y=empty()):
    return x*g(y)

OriginalL'auteur Nik | 2016-04-15

python python-3.x

4

Question intéressante! Voici une autre possibilité, toutefois, cela exige de la remise dans le deuxième paramètre comme un paramètre nommé.
```
>>> def g(y=10):
...     return y**2
... 
>>> def f(x, **kwargs):
...     return x * g(**kwargs)
... 
>>> f(5)
500
>>> f(5, y=0)
0
```
OriginalL'auteur dorian
4

Une limitation de signatures telles que def f(x, y=None) ou def f(x, **kwargs) est que les lecteurs ont à creuser dans le code source ou de la documentation pour savoir ce qu'il se passe avec y. Tenir à quelque chose de simple et directe:
```
DEFAULT_Y = 10
def g(y=DEFAULT_Y): ...
def f(x, y=DEFAULT_Y): ...
```
OriginalL'auteur Alex Hall
4

C'est possible:
```
def g(y=10):
    return y**2

def f(x, y=g.__defaults__[0]):
    return x * g(y)
```
Mais il est sans doute moins clair que ce que vous aviez à l'origine (défaut y à None).

Une option qui permet de ne pas limiter la définition de l'ordre de f et g, et devrait continuer à travailler si la fonction par défaut de g est modifié dynamiquement:
```
def f(x, y=None):
    kwargs = {}
    if y is None:
        kwargs['y'] = y
    return x * g(**kwargs)
```
Pour python 3.x: __defaults__ est utilisé à la place de func_defaults
Que faire si vous voulais pour passer y=None à la fonction?
Dans ce cas, cela n'aurait aucun sens, car None**2 va augmenter. Mais dans le cas général, si vous voulez passer None à la fonction, ce que vous pouvez faire est d'initialiser une sentinelle default_y = object() à l'extérieur de la portée, puis de contre-vérifier que dans le conditionnel. Il est garanti que tout ce qui est passé ne sera pas accidentellement être identique à default_y.

OriginalL'auteur wim

Je voudrais commencer par dire que si les arguments ont été les mots clés de ce serait donc facile:

def f(*, x="x", y= "y",z="z"):
    print(x,y,z)

def g(*, x,y,z):
    print(x,y,z,"from g!!")

if g.__kwdefaults__ is None: #completely override defaults
    g.__kwdefaults__ = f.__kwdefaults__
else: #if there are already some defaults then update
    g.__kwdefaults__.update(f.__kedefaults__)

g()

si vous utilisez des arguments positionnels il n'est pas aussi facile bien que votre exemple est un cas spécifique qui fonctionne de la même manière:

def g(y=10): #last argument is y
    return y**2

def f(x,y): #last argument is y
    return x*g(y)
f.__defaults__ = g.__defaults__ #copies the end of the defaults to f

print(f(5)) #->500

Mais c'est un cas très spécifique:

Les arguments pour hériter les paramètres par défaut doivent être dans le même ordre que l'original.
Il ne doit pas être tout les arguments de position après ceux qui ont hérité d'un défaut
Il ne doit pas être tous les autres arguments avec des valeurs par défaut (ou remplacé)

La solution générique nécessite un peu de code, mais permet tout de signature à être fusionnés en un autre, par exemple:

def f(x,y,z=0,reverse=True):
    pass

@copy_defaults(f)
def g(a,b, #arguments for g
      x,y,z, #arguments to forward to f
      c=None, d="test", #some optional arguments for g
      *,reverse): #only take reverse as a keyword
    pass

>>> inspect.signature(g)
<Signature (a, b, x, y, z=0, c=None, d='test', *, reverse=True)>

Ce qui peut être obtenu avec le code suivant (je ne peux pas trouver un moyen plus simple de faire ce qui fonctionne avec des cas ci-dessus)

import inspect
def copy_defaults(original_f):
"creates wrapper for DefaultArgs(original_f).copy_defaults(dest_f)"
def wrapper(dest_f):
return DefaultArgs(original_f).copy_defaults(dest_f)
return wrapper
class DefaultArgs(dict):
def __init__(self,func):
spec = inspect.getfullargspec(func)
if spec.defaults:
dict.__init__(self,
zip(reversed(spec.args),
reversed(spec.defaults)
))
else:
dict.__init__(self) #I'm not sure this is necessary
if spec.kwonlydefaults:
self.update(spec.kwonlydefaults)
def get_kwdefaults(self,keywords):
return {k:v for k,v in self.items() if k in keywords}
def gen_pos_defaults(self,args,defaults=None):
if defaults is None:
defaults = ()
found_default = False
for i,arg in enumerate(args,start=len(defaults)-len(args)):
if arg in self:
yield self[arg]
found_default = True
elif i>=0:
yield defaults[i]
elif found_default: #if an argument does not have a default but is after one that does
raise TypeError("non-default argument %r follows default argument"%arg)
def copy_defaults(self,func):
spec = inspect.getfullargspec(func)
new_kwargs = self.get_kwdefaults(spec.kwonlyargs)
if func.__kwdefaults__ is not None:
func.__kwdefaults__.update(new_kwargs)
else:
func.__kwdefaults__ = new_kwargs
func.__defaults__ = tuple(self.gen_pos_defaults(spec.args,spec.defaults))
return func

OriginalL'auteur Tadhg McDonald-Jensen

Si vous pouvez modifier g, alors cela fonctionne:

def g(y=None):
if y is None:
y = 10
return y**2
def f(x,y=None):
return x*g(y)

OriginalL'auteur BallpointBen

Vous devez vous connecter pour publier un commentaire.