PEP 572 (Expressões de atribuição no python 3.8)

PEP 572 - Expressões de atribuição

• anotação
• Justificação
• Sintaxe e semântica
• Alterações nas especificações durante a implementação
• Exemplos
• Alternativas rejeitadas
• Objeções frequentes
• Recomendações de estilo
• obrigado
• Apêndice A: Conclusões de Tim Peters
• Apêndice B: Um Intérprete de Código Bruto para Geradores
• Apêndice C: Nenhuma alteração na semântica do escopo
• Referências
• direito autoral
• Minha parte

anotação

Justificação

A Importância do 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

Sintaxe e 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 excepcionais

• Expressões de atribuição que não estão entre parênteses são proibidas no nível "superior":
  
  

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

  
  Essa regra facilitará ao programador escolher entre um operador de atribuição e uma expressão de atribuição - não haverá situação sintática na qual as duas opções sejam 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)]  # 

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

Mude a ordem dos cálculos.

• Nos geradores de dicionário {X: Y para ...}, Y é atualmente avaliado antes de X. Sugerimos alterar isso para que X seja calculado antes de Y. (Em um ditado clássico como {X: Y} e também em dict ((X, Y) para ...) isso já foi implementado. Portanto, os geradores de dicionário devem cumprir esse mecanismo)

Diferenças entre expressões de atribuição e instruções de atribuição.

• A atribuição em cascata não é suportada diretamente
  
  

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

• "Destinos" separados, exceto o nome da variável simples NAME, não são suportados:
  
  

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

• A funcionalidade e as vírgulas prioritárias diferem:
  
  

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

• Os valores de desempacotamento e empacotamento não têm equivalência "pura" ou não são totalmente suportados
  
  

  # 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

• As anotações do tipo embutido não são suportadas:
  
  

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

• Não há forma abreviada de operações:
  
  

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

Alterações nas especificações durante a implementação

• Para garantir consistência com outras exceções semelhantes e não introduzir um novo nome que pode não ser conveniente para os usuários finais, a subclasse originalmente proposta de TargetScopeError para SyntaxError foi removida e reduzida ao SyntaxError usual. [3]
• Devido a limitações na análise da tabela de caracteres CPython, a implementação de referência da expressão de atribuição gera um SyntaxError para todos os usos nos iteradores. Anteriormente, essa exceção ocorria apenas se o nome da variável que estava sendo criada coincidisse com o já usado na expressão iterativa. Isso pode ser revisado se houver exemplos suficientemente convincentes, mas a complexidade adicional parece inadequada para casos de uso puramente "hipotéticos".

Exemplos

Exemplos de biblioteca padrão do Python

site.py

• Código atual:
  

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

• Código aprimorado:
  

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

_pydecimal.py

• Código atual:
  

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

• Código aprimorado:
  

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

copy.py

• Código atual:
  

  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 aprimorado:
  
  

  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 atual:
  
  

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

• Código aprimorado:
  
  

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

sysconfig.py

• Código atual:
  
  

  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 aprimorado:
  
  

  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 geradores 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 em condições

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

Garfo

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

Alternativas rejeitadas

Alterando o escopo para geradores

Ortografia alternativa

1. EXPR como NAME:
   
   

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

   
   É mais provável que essa sintaxe entre em conflito com os outros do que como (a menos que você conte o aumento de Exc das construções Exc), mas, caso contrário, será comparável a eles. Em vez de um paralelo com expr como target: (o que pode ser útil, mas também pode ser confuso), essa opção não tem paralelos com nada, mas é surpreendentemente melhor lembrada.

Casos especiais em declarações condicionais

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

Casos especiais em geradores

1. onde, let ou 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)]

   
   Esse método resulta em uma subexpressão entre o loop for e a expressão principal. Ele também apresenta uma palavra-chave de idioma adicional, que pode criar conflitos. Das três opções, onde é a mais limpa e a mais legível, mas ainda existem conflitos em potencial (por exemplo, SQLAlchemy e numpy têm seus métodos where, além de tkinter.dnd.Icon na biblioteca padrão).
2. com 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

Menor prioridade do operador

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

Você dá vírgulas à direita

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

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

Sempre exigindo suportes

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

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

Objeções frequentes

Por que não transformar as declarações de atribuição em expressões?

Por que se preocupar com expressões de atribuição se existem instruções de atribuição?

Por que não usar o escopo local e evitar a poluição do espaço para nome?

Recomendações de estilo

1. Se você pode usar as duas opções de atribuição, dê preferência aos operadores. Eles expressam mais claramente suas intenções.
2. Se o uso de expressões de atribuição levar a ambiguidade na ordem de execução, reescreva o código usando o operador clássico.

obrigado

Apêndice A: Conclusões 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

Exemplo 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: Um Intérprete de Código Bruto para Geradores

• Código fonte (o EXPR costuma usar a variável VAR):
  
  

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

• O código convertido (não vamos nos preocupar com conflitos de nome):
  
  

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

• Fonte:
  
  

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

• Fonte:
  
  

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

• Fonte:
  
  

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

• Fonte:
  
  

  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: Nenhuma alteração na semântica do escopo

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

Referências

1. Prova de implementação de conceito
2. Discussão da semântica das expressões de atribuição (a VPN é rígida, mas carregada)
3. Discussão do TargetScopeError no PEP 572 (carregado de forma semelhante à anterior)

direito autoral

Minha parte

• Para que as pessoas não tentem remover a dualidade semântica, em muitos lugares "clássicos", onde se pode usar "=" e ": =", existem restrições; portanto, o operador :: = geralmente deve estar entre colchetes. Esses casos deverão ser revistos na seção que descreve o uso básico.
• A prioridade das expressões de atribuição é um pouco maior que a de uma vírgula. Devido a isso, as tuplas não são formadas durante a atribuição. Também possibilita o uso do operador: = ao passar argumentos para uma função.
• , , , . . lambda , «» .
• : ,
• , .
• / .
• , .