Pouvons-nous avoir de la cession dans une condition?

Pourquoi ne pas essayer?

>>> def some_func():
...   return 2
... 
>>> a = 2
>>> if (a = some_func()):
  File "<stdin>", line 1
    if (a = some_func()):
          ^
SyntaxError: invalid syntax
>>> 

Donc, pas de.

Mise à JOUR - Original de la réponse est près du bas de

Python 3.8 apportera PEP572

Résumé

C'est une proposition pour la création d'un moyen d'affecter à des variables
au sein d'une expression à l'aide de la notation NOM := expr. Une nouvelle exception,
TargetScopeError est ajouté, et il y a un changement à l'évaluation
ordre.

https://lwn.net/Articles/757713/

Le "PEP 572 mess" était le thème d'un 2018 Python Sommet de la Langue
session dirigée par le dictateur bienveillant à vie (BDFL) Guido van Rossum.
PEP 572 cherche à ajouter de la cession des expressions (ou "inline" attributions)
pour la langue, mais il a vu une discussion prolongée sur plusieurs
énorme threads sur le python-dev mailing list—même après plusieurs tours
python-idées. Ces fils étaient souvent controversées et ont été clairement
volumineux au point où de nombreux probablement suffit à l'écoute de l'en sortir. Au
le sommet, Van Rossum a donné un aperçu de la fonction de la proposition, qui
il semble enclin à accepter, mais il voulait aussi discuter de la façon dont
pour éviter ce genre de thread explosion dans l'avenir.

https://www.python.org/dev/peps/pep-0572/#examples-from-the-python-standard-library

Exemples de l'Python standard library

site.py env_base n'est utilisé que sur ces lignes, la mise de son affectation sur le si se déplace comme la "tête" du bloc.

Actuel:

env_base = os.environ.get("PYTHONUSERBASE", None)
if env_base:
    return env_base

Amélioré:

if env_base := os.environ.get("PYTHONUSERBASE", None):
    return env_base
_pydecimal.py

Éviter si imbriquées et supprimer un niveau d'indentation.

Actuel:

if self._is_special:
    ans = self._check_nans(context=context)
    if ans:
        return ans

Amélioré:

if self._is_special and (ans := self._check_nans(context=context)):
    return ans

copy.py Code ressemble de plus en plus réguliers et d'éviter les multiples si imbriquées. (Voir l'Annexe A pour l'origine de cet exemple.)

Actuel:

reductor = dispatch_table.get(cls)
if reductor:
    rv = reductor(x)
else:
    reductor = getattr(x, "__reduce_ex__", None)
    if reductor:
        rv = reductor(4)
    else:
        reductor = getattr(x, "__reduce__", None)
        if reductor:
            rv = reductor()
        else:
            raise Error(
                "un(deep)copyable object of type %s" % cls)

Amélioré:

if reductor := dispatch_table.get(cls):
    rv = reductor(x)
elif reductor := getattr(x, "__reduce_ex__", None):
    rv = reductor(4)
elif reductor := getattr(x, "__reduce__", None):
    rv = reductor()
else:
    raise Error("un(deep)copyable object of type %s" % cls)
datetime.py

tz est seulement utilisé pour des s += tz, le déplacement de son affectation à l'intérieur de l'aide si
pour montrer sa portée.

Actuel:

s = _format_time(self._hour, self._minute,
                 self._second, self._microsecond,
                 timespec)
tz = self._tzstr()
if tz:
    s += tz
return s

Amélioré:

s = _format_time(self._hour, self._minute,
                 self._second, self._microsecond,
                 timespec)
if tz := self._tzstr():
    s += tz
return s

sysconfig.py l'Appel de fp.readline() dans la condition du while et d'appel .match() sur la si les lignes de rendre le code plus compact, sans

le rendant plus difficile à comprendre.

Actuel:

while True:
    line = fp.readline()
    if not line:
        break
    m = define_rx.match(line)
    if m:
        n, v = m.group(1, 2)
        try:
            v = int(v)
        except ValueError:
            pass
        vars[n] = v
    else:
        m = undef_rx.match(line)
        if m:
            vars[m.group(1)] = 0

Amélioré:

while line := fp.readline():
    if m := define_rx.match(line):
        n, v = m.group(1, 2)
        try:
            v = int(v)
        except ValueError:
            pass
        vars[n] = v
    elif m := undef_rx.match(line):
        vars[m.group(1)] = 0

Simplifier les interprétations de la liste Une compréhension de liste pouvez mapper et de filtrer efficacement par la capture de l'état:

results = [(x, y, x/y) for x in input_data if (y := f(x)) > 0]

De même, une sous-expression peut être réutilisée dans l'expression principale,
en lui donnant un nom à la première utilisation:

stuff = [[y := f(x), x/y] for x in range(5)]

Noter que dans les deux cas, la variable y est lié dans le contenant
champ d'application (c'est à dire au même niveau que les résultats ou les choses).

La capture des valeurs de condition de l'Affectation des expressions peuvent être utilisés à bon escient dans l'en-tête d'un si ou pendant l'instruction:

# Loop-and-a-half
while (command := input("> ")) != "quit":
    print("You entered:", command)

# Capturing regular expression match objects
# See, for instance, Lib/pydoc.py, which uses a multiline spelling
# of this effect
if match := re.search(pat, text):
    print("Found:", match.group(0))
# The same syntax chains nicely into 'elif' statements, unlike the
# equivalent using assignment statements.
elif match := re.search(otherpat, text):
    print("Alternate found:", match.group(0))
elif match := re.search(third, text):
    print("Fallback found:", match.group(0))

# Reading socket data until an empty string is returned
while data := sock.recv(8192):
    print("Received data:", data)

En particulier avec la boucle while, ce peut éliminer le besoin d'avoir un
boucle infinie, d'une cession, et une condition. Il crée également un
lisse parallèle entre une boucle qui utilise simplement un appel de fonction, comme
son état, et qui l'utilise comme son état, mais utilise également
la valeur réelle.

Fourche Un exemple de bas-niveau monde UNIX:

if pid := os.fork():
    # Parent code
else:
    # Child code

Réponse originale à cette question

http://docs.python.org/tutorial/datastructures.html

Noter qu'en Python, à la différence de C,
affectation ne peut pas se produire à l'intérieur
les expressions. C programmeurs peuvent grogner
à ce sujet, mais il évite la commune
classe de problèmes rencontrés dans la C
programmes: taper = dans une expression
lorsque == était destiné.

voir aussi:

http://effbot.org/pyfaq/why-can-t-i-use-an-assignment-in-an-expression.htm

Oui, mais seulement à partir de Python 3.8 et au-delà.

PEP 572 propose Affectation des Expressions et a déjà été accepté.

Citant le La syntaxe et de la sémantique partie de la PEP:

# Handle a matched regex
if (match := pattern.search(data)) is not None:
    # Do something with match

# A loop that can't be trivially rewritten using 2-arg iter()
while chunk := file.read(8192):
   process(chunk)

# Reuse a value that's expensive to compute
[y := f(x), y**2, y**3]

# Share a subexpression between a comprehension filter clause and its output
filtered_data = [y for x in data if (y := f(x)) is not None]

Dans votre cas particulier, vous serez en mesure d'écrire

if a := some_func():
    # Use a

Grâce à Python 3.8 nouvelle fonctionnalité il sera possible de faire une telle chose à partir de cette version, bien que n'utilisant pas = mais Ada-comme opérateur d'affectation :=. Exemple de la doc:

# Handle a matched regex
if (match := pattern.search(data)) is not None:
    # Do something with match

Une des raisons pour lesquelles les affectations sont illégales dans des conditions est qu'il est plus facile de faire une erreur et l'attribuer Vrai ou Faux:

some_variable = 5

# This does not work
# if True = some_variable:
#   do_something()

# This only works in Python 2.x
True = some_variable

print True  # returns 5

En Python 3 True et False sont des mots-clés, donc pas de risques.