PEP 572 (expresiones de asignación en python 3.8)

PEP 572 - Expresiones de asignación

• anotación
• Justificación
• Sintaxis y Semántica
• La especificación cambia durante la implementación
• Ejemplos
• Alternativas rechazadas
• Objeciones frecuentes
• Recomendaciones de estilo
• Gracias
• Apéndice A: Conclusiones de Tim Peters
• Apéndice B: Un intérprete de código aproximado para generadores
• Apéndice C: Sin cambios en la semántica del alcance
• Referencias
• Derechos de autor
• Mi parte

anotación

Justificación

La importancia del código real

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

Sintaxis y Semántica

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

Casos excepcionales

• Las expresiones de asignación no incluidas entre paréntesis están prohibidas en el nivel "superior":
  
  

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

  
  Esta regla facilitará que el programador elija entre un operador de asignación y una expresión de asignación; no habrá una situación sintáctica en la que ambas opciones sean equivalentes.
• . :
  
  

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

Prioridad relativa: =

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)

Cambiar el orden de los cálculos.

• En los generadores de diccionario {X: Y para ...}, Y se evalúa actualmente antes que X. Sugerimos cambiar esto para que X se calcule antes que Y. (En un dict clásico como {X: Y}, así como en dict ((X, Y) para ...) esto ya se ha implementado. Por lo tanto, los generadores de diccionario deben cumplir con este mecanismo)

Diferencias entre expresiones de asignación e instrucciones de asignación.

• La asignación en cascada no se admite directamente
  
  

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

• No se admiten "objetivos" separados, excepto el nombre de variable simple NAME:
  
  

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

• La funcionalidad y las comas de prioridad "alrededor" son diferentes:
  
  

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

• Los valores de desempaque y desempaque no tienen equivalencia "pura" o no son compatibles
  
  

  # 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

• Las anotaciones de tipo en línea no son compatibles:
  
  

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

• No hay una forma abreviada de operaciones:
  
  

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

La especificación cambia durante la implementación

• Para garantizar la coherencia con otras excepciones similares, y no introducir un nuevo nombre que puede no ser conveniente para los usuarios finales, la subclase propuesta originalmente de TargetScopeError para SyntaxError se ha eliminado y reducido al SyntaxError habitual. [3]
• Debido a las limitaciones en el análisis de la tabla de caracteres CPython, la implementación de referencia de la expresión de asignación genera un SyntaxError para todos los usos dentro de los iteradores. Anteriormente, esta excepción ocurría solo si el nombre de la variable que se estaba creando coincidía con el que ya se usaba en la expresión iterativa. Esto puede revisarse si hay ejemplos suficientemente convincentes, pero la complejidad adicional parece inapropiada para casos de uso puramente "hipotéticos".

Ejemplos

Ejemplos de la biblioteca estándar de Python

site.py

• Código actual:
  

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

• Código mejorado:
  

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

_pydecimal.py

• Código actual:
  

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

• Código mejorado:
  

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

copy.py

• Código actual:
  

  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)

• Código mejorado:
  
  

  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

• Código actual:
  
  

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

• Código mejorado:
  
  

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

sysconfig.py

• Código actual:
  
  

  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

• Código mejorado:
  
  

  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

Simplificar generadores de listas

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

Capturar valores en condiciones

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

Tenedor

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

Alternativas rechazadas

Cambiar el alcance de los generadores

Ortografía alternativa

1. EXPR como NOMBRE:
   
   

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

   
   Es menos probable que esta sintaxis entre en conflicto con otros que como (a menos que cuente las construcciones elevar Exc de Exc), pero de lo contrario sea comparable a ellos. En lugar de un paralelo con expr como objetivo: (que puede ser útil, pero también puede ser confuso), esta opción no tiene paralelos con nada en absoluto, pero sorprendentemente se recuerda mejor.

Casos especiales en declaraciones condicionales

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

Casos especiales en generadores

1. donde, dejar o dado:
   
   

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

   
   Este método da como resultado una subexpresión entre el bucle for y la expresión principal. También introduce una palabra clave de idioma adicional, que puede crear conflictos. De las tres opciones, dónde es la más limpia y legible, pero aún existen conflictos potenciales (por ejemplo, SQLAlchemy y numpy tienen sus métodos where, así como tkinter.dnd.Icon en la biblioteca estándar).
2. con 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

Baja prioridad del operador

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

Da comas a la derecha

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

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

Siempre requiere soportes

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

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

Objeciones frecuentes

¿Por qué no simplemente convertir las declaraciones de asignación en expresiones?

¿Por qué molestarse con las expresiones de asignación si existen instrucciones de asignación?

¿Por qué no usar el alcance local y prevenir la contaminación del espacio de nombres?

Recomendaciones de estilo

1. Si puede usar ambas opciones de asignación, entonces dé preferencia a los operadores. Expresan más claramente sus intenciones.
2. Si el uso de expresiones de asignación genera ambigüedad en el orden de ejecución, reescriba el código con el operador clásico.

Gracias

Apéndice A: Conclusiones 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

Ejemplo numérico

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

Apéndice B: Un intérprete de código aproximado para generadores

• Código fuente (EXPR usa con mayor frecuencia la variable VAR):
  
  

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

• El código convertido (no nos preocupemos por los conflictos de nombres):
  
  

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

• Fuente:
  
  

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

• Código convertido:
  
  

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

• Fuente:
  
  

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

• Código convertido:
  
  

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

• Fuente:
  
  

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

• Código convertido:
  
  

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

• Fuente:
  
  

  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
  

• Código convertido:
  
  

  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)

Apéndice C: Sin cambios en la semántica del alcance

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

Referencias

1. Prueba de implementación del concepto
2. Discusión de la semántica de las expresiones de asignación (VPN está apretada pero cargada)
3. Discusión de TargetScopeError en PEP 572 (cargado de manera similar a la anterior)

Derechos de autor

Mi parte

• Para que las personas no intenten eliminar la dualidad semántica, en muchos lugares "clásicos" en los que podría usar "=" y ": =" existen restricciones, por lo tanto, el operador :: = debe estar entre corchetes. Estos casos deberán revisarse en la sección que describe el uso básico.
• La prioridad de las expresiones de asignación es ligeramente mayor que la de una coma. Debido a esto, las tuplas no se forman durante la asignación. También hace posible usar el operador: = al pasar argumentos a una función.
• , , , . . lambda , «» .
• : ,
• , .
• / .
• , .