Existe-t-il un moyen de forcer des paramètres de fonction mutuellement exclusifs en python?

En bref: non, vous ne pouvez pas faire ça.

Le plus proche que vous pouvez obtenir pourrait être l'utilisation d'une assertion:

def foobar(foo=None, bar=None):
    assert bool(foo) != bool(bar)

foobar(foo='bar')             # Passes
foobar(bar='foo')             # Passes
foobar(foo='bar', bar='foo')  # Raises an AssertionError
foobar()                      # Raises an AssertionError

La combinaison des conversions bool et du ! = fera un XOR logique.

Attention cependant aux assertions; ils peuvent être désactivés. C'est bien si votre vérification est requise pendant le développement uniquement.

Syntaxiquement non. Cependant, il est relativement facile de le faire en utilisant un décorateur:

>>> @mutually_exclusive('foo', 'bar')
... def foobar(a,b,c, *, foo=None, bar=None, taz=None):
...     print(a,b,c,foo,bar,taz)
... 
>>> foobar(1,2,3, foo=4, taz=5)
1 2 3 4 None 5
>>> foobar(1,2,3, foo=4, bar=5,taz=6)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 7, in inner
TypeError: You must specify exactly one of foo, bar

Utilisé comme:

>>> @mutually_exclusive('foo', 'bar')
... def foobar(*, foo=None, bar=None):
...     print(foo, bar)
... 
>>> foobar(foo=1)
1 None
>>> foobar(bar=1)
None 1
>>> foobar(bar=1, foo=2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 7, in inner
TypeError: You must specify exactly one of foo, bar
>>> foobar()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 7, in inner
TypeError: You must specify exactly one of foo, bar

Le décorateur ignore les positions et les arguments de mots-clés non inclus dans la liste donnée:

from functools import wraps

def mutually_exclusive(keyword, *keywords):
    keywords = (keyword,)+keywords
    def wrapper(func):
        @wraps(func)
        def inner(*args, **kwargs):
            if sum(k in keywords for k in kwargs) != 1:
                raise TypeError('You must specify exactly one of {}'.format(', '.join(keywords)))
            return func(*args, **kwargs)
        return inner
    return wrapper

Si les arguments peuvent être "facultatifs" (c'est-à-dire que vous pouvez spécifier au plus l'un de ces arguments de mot-clé, mais vous pouvez également les omettre tous) remplacez ! = 1 par ou in (0,1) selon vos préférences.

Si vous remplacez 1 avec un nombre k vous généralisez le décorateur pour accepter exactement (ou tout au plus) k des arguments spécifiés de l'ensemble que vous avez fourni. 1 / p>

Cela n'aidera en aucun cas PyCharm. Pour autant que je sache actuellement, il est tout simplement impossible de dire à un IDE ce que vous voulez.

Le décorateur ci-dessus a un petit "bug": il considère foo = None comme si vous avez passé une valeur pour foo car elle apparaît dans la liste kwargs . Habituellement, vous vous attendez à ce que la transmission de la valeur par défaut se comporte de la même manière que si vous ne spécifiez pas du tout l'argument.

Pour corriger cela correctement, il faudrait inspecter func dans wrapper pour rechercher les valeurs par défaut et changer k dans les mots-clés avec quelque chose comme k dans les mots-clés et kwargs [k]! = defaults [k] .

La bibliothèque standard utilise une simple vérification à l'exécution pour cela:

def foobar(*, foo=None, bar=None):
    if (foo is None) == (bar is None):
        raise ValueError('Exactly one of `foo` and `bar` must be provided')

Vous pouvez légèrement refactoriser et prendre deux paramètres non optionnels qui, ensemble, fournissent une valeur:

def foobar(name, value):
    if name == 'foo':
        foo = value
    elif name == 'bar':
        bar = value
    else:
        raise ValueError()

De cette façon, il est impossible de transmettez deux valeurs foo ou bar. PyCharm vous avertirait également si vous ajoutiez des paramètres supplémentaires.