PEP 572 (expressions d'affectation en python 3.8)

PEP 572 - Expressions d'affectation

• annotation
• Justification
• Syntaxe et sémantique
• Modifications des spécifications lors de la mise en œuvre
• Exemples
• Alternatives rejetées
• Objections fréquentes
• Recommandations de style
• Merci
• Annexe A: Conclusions de Tim Peters
• Annexe B: Un interpréteur de code approximatif pour les générateurs
• Annexe C: Aucun changement dans la sémantique de la portée
• Références
• droits d'auteur
• Ma partie

annotation

Justification

L'importance du vrai code

match = re.match(data)
group = match.group(1) if match else None

group = re.match(data).group(1) if re.match(data) else None

match1 = pattern1.match(data)
match2 = pattern2.match(data)
if match1:
    result = match1.group(1)
elif match2:
    result = match2.group(2)
else:
    result = None

match1 = pattern1.match(data)
if match1:
    result = match1.group(1)
else:
    match2 = pattern2.match(data)
    if match2:
        result = match2.group(2)
    else:
        result = None

Syntaxe et sémantique

# 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]

Cas exceptionnels

• Les expressions d'affectation non incluses entre parenthèses sont interdites au niveau «supérieur»:
  
  

  y := f(x)  # 
  (y := f(x))  # ,   

  
  Cette règle permettra au programmeur de choisir plus facilement entre un opérateur d'affectation et une expression d'affectation - il n'y aura pas de situation syntaxique dans laquelle les deux options sont équivalentes.
• . :
  
  

  y0 = y1 := f(x)  # 
  y0 = (y1 := f(x))  # ,   

  
  . :
  
  

  foo(x = y := f(x))  # 
  foo(x=(y := f(x)))  # ,     

  
  , .
• . :
  
  

  def foo(answer = p := 42):  # 
      ...
  def foo(answer=(p := 42)):  # Valid, though not great style
      ...

  
  , (. , «» ).
• , . :
  
  

  def foo(answer: p := 42 = 5):  # 
      ...
  def foo(answer: (p := 42) = 5):  # ,  
      ...

  
  : , "=" ":=" .
• -. :
  
  

  (lambda: x := 1) # 
  lambda: (x := 1) # ,  
  (x := lambda: 1) # 
  lambda line: (m := re.match(pattern, line)) and m.group(1) # Valid

  
  - , ":=". . , , () , .
• f- . :
  
  

  >>> f'{(x:=10)}'  # ,  
  '10'
  >>> x = 10
  >>> f'{x:=10}'    # ,  ,  '=10'
  '        10'

  
  , , f-, . f- ":" . , f- . , .

if any((comment := line).startswith('#') for line in lines):
    print("First comment:", comment)
else:
    print("There are no comments")

if all((nonblank := line).strip() == '' for line in lines):
    print("All lines are blank")
else:
    print("First non-blank line:", nonblank)

# Compute partial sums in a list comprehension
total = 0
partial_sums = [total := total + v for v in values]
print("Total:", total)

[[(j := j) for i in range(5)] for j in range(5)] # 
[i := 0 for i, j in stuff]                       # 
[i+1 for i in (i := stuff)]                      # 

[False and (i := 0) for i, j in stuff]     # 
[i for i, j in stuff if True or (j := 1)]  # 

# [.  . - ""   
# ,       
# ,    ,   ]

[i+1 for i in (j := stuff)]                    # 
[i+1 for i in range(2) for j in (k := stuff)]  # 
[i+1 for i in [j for j in (k := stuff)]]       # 
[i+1 for i in (lambda: (j := stuff))()]        # 

class Example:
    [(j := i) for i in range(5)]  # 

Priorité relative: =

x := 0 # 

(x := 0) #  

x = y := 0 # 

x = (y := 0) #  

len(lines := f.readlines()) # 

foo(x := 3, cat='vector') # 

foo(cat=category := 'vector') # 

foo(cat=(category := 'vector')) #  

# Valid
if any(len(longline := line) >= 100 for line in lines):
    print("Extremely long line:", longline)

Modifiez l'ordre des calculs.

• Dans les générateurs de dictionnaire {X: Y pour ...}, Y est actuellement évalué avant X. Nous suggérons de le changer pour que X soit calculé avant Y. (Dans un dict classique tel que {X: Y}, ainsi que dans dict ((X, Y) pour ...) ceci a déjà été implémenté. Par conséquent, les générateurs de dictionnaire doivent respecter ce mécanisme)

Différences entre les expressions d'affectation et les instructions d'affectation.

• L'affectation en cascade n'est pas prise en charge directement
  
  

  x = y = z = 0  # Equivalent: (z := (y := (x := 0)))

• Les "cibles" séparées, à l'exception du nom de variable simple NAME, ne sont pas prises en charge:
  
  

  # No equivalent
  a[i] = x
  self.rest = []

• La fonctionnalité et la priorité des virgules «autour» diffèrent:
  
  

  x = 1, 2  # Sets x to (1, 2)
  (x := 1, 2)  # Sets x to 1

• Les valeurs de déballage et d'emballage n'ont pas d'équivalence «pure» ou ne sont pas du tout prises en charge
  
  

  # Equivalent needs extra parentheses
  loc = x, y  # Use (loc := (x, y))
  info = name, phone, *rest  # Use (info := (name, phone, *rest))
  
  # No equivalent
  px, py, pz = position
  name, phone, email, *other_info = contact

• Les annotations de type en ligne ne sont pas prises en charge:
  
  

  # Closest equivalent is "p: Optional[int]" as a separate declaration
  p: Optional[int] = None

• Il n'y a pas d'opération abrégée:
  
  

  total += tax  # Equivalent: (total := total + tax)

Modifications des spécifications lors de la mise en œuvre

• Pour garantir la cohérence avec d'autres exceptions similaires et pour ne pas introduire un nouveau nom qui pourrait ne pas convenir aux utilisateurs finaux, la sous-classe initialement proposée de TargetScopeError pour SyntaxError a été supprimée et réduite à la SyntaxError habituelle. [3]
• En raison des limitations de l'analyse de la table de caractères CPython, l'implémentation de référence de l'expression d'affectation déclenche une SyntaxError pour toutes les utilisations au sein des itérateurs. Auparavant, cette exception ne se produisait que si le nom de la variable en cours de création coïncidait avec celui déjà utilisé dans l'expression itérative. Ceci peut être révisé s'il existe des exemples suffisamment convaincants, mais la complexité supplémentaire semble inappropriée pour des cas d'utilisation purement «hypothétiques».

Exemples

Exemples de bibliothèques standard Python

site.py

• Code actuel:
  

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

• Code amélioré:
  

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

_pydecimal.py

• Code actuel:
  

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

• Code amélioré:
  

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

copy.py

• Code 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)

• Code 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

• Code actuel:
  
  

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

• Code amélioré:
  
  

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

sysconfig.py

• Code 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

• Code 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 générateurs de listes

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

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

Capturer des valeurs dans des conditions

# 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)

Fourchette

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

Alternatives rejetées

Changer la portée des générateurs

Orthographes alternatives

1. EXPR comme NOM:
   
   

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

   
   EXPR as NAME import, except with, (, ).
   
   ( , «with EXPR as VAR» EXPR VAR, EXPR.__enter__() VAR.)
   
   , ":=" :
   
   • , if f(x) as y , ​​ if f x blah-blah, if f(x) and y.
   • , as , , :
     • import foo as bar
     • except Exc as var
     • with ctxmgr() as var
     
     , as if while , as « » .
   • «»
     • NAME = EXPR
     • if NAME := EXPR
     
     .
2. EXPR -> NAME
   
   

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

   
   , R Haskell, . ( , - y < — f (x) Python, - .) «as» , import, except with, . Python ( ), ":=" ( Algol-58) .
3. «»
   
   

   stuff = [[(f(x) as .y), x/.y] for x in range(5)] # with "as"
   stuff = [[(.y := f(x)), x/.y] for x in range(5)] # with ":="

   
   . Python, , .
4. where: :
   
   

   value = x**2 + 2*x where:
       x = spam(1, 4, 7, q)

   
   ( , «»). , «» ( with:). . PEP 3150, ( given: ).
5. TARGET from EXPR:
   
   

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

   
   Cette syntaxe est moins en conflit avec les autres qu'en tant que (sauf si vous comptez l'augmentation des constructions Exc), mais sinon elle est comparable à elles. Au lieu d'un parallèle avec avec expr comme cible: (ce qui peut être utile, mais cela peut aussi prêter à confusion), cette option n'a aucun parallèle avec quoi que ce soit, mais elle est étonnamment mieux mémorisée.

Cas particuliers dans les déclarations conditionnelles

if re.search(pat, text) as match:
    print("Found:", match.group(0))

Cas particuliers dans les générateurs

1. où, loué ou donné:
   
   

   stuff = [(y, x/y) where y = f(x) for x in range(5)]
   stuff = [(y, x/y) let y = f(x) for x in range(5)]
   stuff = [(y, x/y) given y = f(x) for x in range(5)]

   
   Cette méthode entraîne une sous-expression entre la boucle for et l'expression principale. Il introduit également un mot-clé de langue supplémentaire, qui peut créer des conflits. Des trois options, où est la plus propre et la plus lisible, mais des conflits potentiels existent toujours (par exemple, SQLAlchemy et numpy ont leurs méthodes where, ainsi que tkinter.dnd.Icon dans la bibliothèque standard).
2. avec NAME = EXPR:
   
   

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

   
   , , with. . , «» for. C, , . : « «with NAME = EXPR:» , ?»
3. with EXPR as NAME:
   
   

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

   
   , as, . , for. with

Priorité inférieure de l'opérateur

pos = -1
while pos := buffer.find(search_term, pos + 1) >= 0:
    ...

Vous donnez des virgules à droite

(point := (x, y))
(point := x, y)

foo (x: = 1, y)
foo (x: = (1, y))

Toujours besoin de supports

# Top level in if
if match := pattern.match(line):
    return match.group(1)

# Short call
len(lines := f.readlines())

Objections fréquentes

Pourquoi ne pas simplement transformer les instructions d'affectation en expressions?

Pourquoi s'embêter avec des expressions d' affectation s'il existe des instructions d' affectation?

Pourquoi ne pas utiliser la portée locale et éviter la pollution de l'espace de noms?

Recommandations de style

1. Si vous pouvez utiliser les deux options d'affectation, privilégiez les opérateurs. Ils expriment le plus clairement vos intentions.
2. Si l'utilisation d'expressions d'affectation entraîne une ambiguïté dans l'ordre d'exécution, réécrivez le code à l'aide de l'opérateur classique.

Merci

Annexe A: Conclusions de Tim Peters

i = j = count = nerrors = 0

i = j = 0
count = 0
nerrors = 0

mylast = mylast[1]
yield mylast[0]

yield (mylast := mylast[1])[0]

while True:
    old = total
    total += term
    if old == total:
        return total
    term *= mx2 / (i*(i+1))
    i += 2

while total != (total := total + term):
    term *= mx2 / (i*(i+1))
    i += 2
return total

result = solution(xs, n)
if result:
    # use result

if result := solution(xs, n):
    # use result

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(shallow)copyable object of type %s" % cls)

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(shallow)copyable object of type %s" % cls)

diff = x - x_base
if diff:
    g = gcd(diff, n)
    if g > 1:
        return g

if (diff := x - x_base) and (g := gcd(diff, n)) > 1:
    return g

Exemple numérique

while a > (d := x // a**(n-1)):
    a = ((n-1)*a + d) // n
return a

while True:
    d = x // a**(n-1)
    if a <= d:
        break
    a = ((n-1)*a + d) // n
return a

Annexe B: Un interpréteur de code approximatif pour les générateurs

• Code source (EXPR utilise le plus souvent la variable VAR):
  
  

  def f():
      a = [EXPR for VAR in ITERABLE]

• Le code converti (ne nous inquiétons pas des conflits de noms):
  
  

  def f():
      def genexpr(iterator):
          for VAR in iterator:
              yield EXPR
      a = list(genexpr(iter(ITERABLE)))

• La source:
  
  

  def f():
      a = [TARGET := EXPR for VAR in ITERABLE]
  

• Code converti:
  
  

  def f():
      if False:
          TARGET = None  # Dead code to ensure TARGET is a local variable
      def genexpr(iterator):
          nonlocal TARGET
          for VAR in iterator:
              TARGET = EXPR
              yield TARGET
      a = list(genexpr(iter(ITERABLE)))

• La source:
  
  

  def f():
      global TARGET
      a = [TARGET := EXPR for VAR in ITERABLE]
  

• Code converti:
  
  

  def f():
      global TARGET
      def genexpr(iterator):
          global TARGET
          for VAR in iterator:
              TARGET = EXPR
              yield TARGET
      a = list(genexpr(iter(ITERABLE)))

• La source:
  
  

  def g():
      TARGET = ...
      def f():
          nonlocal TARGET
          a = [TARGET := EXPR for VAR in ITERABLE]
  

• Code converti:
  
  

  def g():
      TARGET = ...
      def f():
          nonlocal TARGET
          def genexpr(iterator):
              nonlocal TARGET
              for VAR in iterator:
                  TARGET = EXPR
                  yield TARGET
          a = list(genexpr(iter(ITERABLE)))

• La source:
  
  

  def f():
      a = [[TARGET := i for i in range(3)] for j in range(2)]
      # I.e., a = [[0, 1, 2], [0, 1, 2]]
      print(TARGET)  # prints 2
  

• Code converti:
  
  

  def f():
      if False:
          TARGET = None
      def outer_genexpr(outer_iterator):
          nonlocal TARGET
          def inner_generator(inner_iterator):
              nonlocal TARGET
              for i in inner_iterator:
                  TARGET = i
                  yield i
          for j in outer_iterator:
              yield list(inner_generator(range(3)))
      a = list(outer_genexpr(range(2)))
      print(TARGET)

Annexe C: Aucun changement dans la sémantique de la portée

a = 42
def f():
    # `a` is local to `f`, but remains unbound
    # until the caller executes this genexp:
    yield ((a := i) for i in range(3))
    yield lambda: a + 100
    print("done")
    try:
        print(f"`a` is bound to {a}")
        assert False
    except UnboundLocalError:
        print("`a` is not yet bound")

>>> results = list(f()) # [genexp, lambda]
done
`a` is not yet bound
# The execution frame for f no longer exists in CPython,
# but f's locals live so long as they can still be referenced.
>>> list(map(type, results))
[<class 'generator'>, <class 'function'>]
>>> list(results[0])
[0, 1, 2]
>>> results[1]()
102
>>> a
42

Références

1. Mise en œuvre de la preuve de concept
2. Discussion de la sémantique des expressions d'affectation (VPN est serré mais chargé)
3. Discussion de TargetScopeError dans PEP 572 (chargé de manière similaire à la précédente)

droits d'auteur

Ma partie

• Pour que les gens n'essaient pas de supprimer la dualité sémantique, dans de nombreux endroits «classiques» où vous pouvez utiliser à la fois «=» et «: =», il y a des restrictions, donc l'opérateur :: = doit souvent être placé entre crochets. Ces cas devront être examinés dans la section décrivant l'utilisation de base.
• La priorité des expressions d'affectation est légèrement supérieure à celle d'une virgule. Pour cette raison, les tuples ne sont pas formés pendant l'affectation. Il permet également d'utiliser l'opérateur: = lors du passage d'arguments à une fonction.
• , , , . . lambda , «» .
• : ,
• , .
• / .
• , .