PEP 572（Python 3.8中的赋值表达式）

PEP 572-赋值表达式

• 注解
• 理由
• 语法和语义
• 实施过程中的规格变更
• 例子
• 拒绝的选择
• 经常异议
• 风格建议
• 谢谢
• 附录A：Tim Peters的结论
• 附录B：生成器的粗糙代码解释器
• 附录C：范围语义未更改
• 参考文献
• 版权
• 我这边

注解

理由

实代码的重要性

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

语法和语义

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

特殊情况

• 在“上”级别禁止未用括号括起来的赋值表达式：
  
  

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

  
  该规则将使程序员更容易在赋值运算符和赋值表达式之间进行选择-不会出现两个选项都相等的句法情况。
• . :
  
  

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

相对优先级：=

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)

更改计算顺序。

• 在字典生成器{X：Y for ...}中，当前会在X之前评估Y。我们建议更改此值，以便在Y之前计算X。（在经典dict中，例如{X：Y}以及dict （（……的（X，Y））已经实现。因此，字典生成器必须遵守此机制。）

赋值表达式和赋值指令之间的差异。

• 不直接支持级联分配
  
  

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

• 除简单变量名称NAME之外，不支持单独的“目标”：
  
  

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

• 功能和围绕逗号的优先级有所不同：
  
  

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

• 开箱价和装箱价没有``纯''等价物或根本不被支持
  
  

  # 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

• 不支持内联类型注释：
  
  

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

• 没有简化的操作形式：
  
  

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

实施过程中的规格变更

• 为了确保与其他类似异常的一致性，并且不引入可能对最终用户不方便的新名称，最初建议的SyntaxError的TargetScopeError子类已被删除，并减少为通常的SyntaxError。[3]
• 由于解析CPython字符表的限制，赋值表达式的引用实现为迭代器内的所有使用引发SyntaxError。以前，仅当要创建的变量的名称与迭代表达式中已使用的名称一致时，才会发生此异常。如果有足够有说服力的示例，可以对此进行修订，但是对于纯粹的“假设”用例而言，额外的复杂性似乎不合适。

例子

Python标准库示例

site.py

• 当前代码：
  

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

• 改进的代码：
  

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

_pydecimal.py

• 当前代码：
  

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

• 改进的代码：
  

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

复制

• 当前代码：
  

  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)

• 改进的代码：
  
  

  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

• 当前代码：
  
  

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

• 改进的代码：
  
  

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

sysconfig.py

• 当前代码：
  
  

  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

• 改进的代码：
  
  

  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

简化列表生成器

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

在条件下获取价值

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

叉子

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

拒绝的选择

更改生成器的范围

替代拼写

1. 以名称的身份浏览：
   
   

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

   
   这句法不太可能与他人发生冲突比为（除非你从EXC结构加薪EXC），但在其他方面可以媲美他们。该选项不是将expr作为目标的并行：（这可能有用，但也可能造成混淆），该选项根本没有与任何并行的内容，但是令人惊讶的是，它记忆犹新。

条件语句中的特殊情况

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

发电机的特殊情况

1. 在哪里，让，或给定：
   
   

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

   
   此方法在for循环和主表达式之间产生子表达式。它还引入了一个附加的语言关键字，该关键字可能会产生冲突。在这三个选项中，where是最干净，最易读的，但是仍然存在潜在的冲突（例如，SQLAlchemy和numpy拥有其where方法，以及标准库中的tkinter.dnd.Icon）。
2. 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

降低操作员优先级

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

您在右边加上逗号

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

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

总是需要括号

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

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

经常异议

为什么不只将赋值语句转换为表达式？

如果存在分配指令，为什么还要麻烦分配表达式？

为什么不使用本地范围并防止名称空间污染？

风格建议

1. 如果您可以同时使用两个分配选项，请优先选择运算符。他们最清楚地表达了您的意图。
2. 如果使用赋值表达式导致执行顺序不明确，请使用经典运算符重写代码。

谢谢

附录A：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

数值例子

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

附录B：生成器的粗糙代码解释器

• 源代码（EXPR最常使用VAR变量）：
  
  

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

• 转换后的代码（不用担心名称冲突）：
  
  

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

• 资源：
  
  

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

• 转换后的代码：
  
  

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

• 资源：
  
  

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

• 转换后的代码：
  
  

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

• 资源：
  
  

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

• 转换后的代码：
  
  

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

• 资源：
  
  

  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
  

• 转换后的代码：
  
  

  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)

附录C：范围语义未更改

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

参考文献

1. 概念验证的实施
2. 讨论赋值表达式的语义（VPN严格但已加载）
3. 对PEP 572中TargetScopeError的讨论（与上一个类似地加载）

版权

我这边

• 为了避免人们试图消除语义对偶性，在很多可以同时使用“ =”和“：=”的“经典”地方，都有一些限制，因此运算符:: =必须经常放在方括号中。这些情况将必须在描述基本用法的部分中进行审查。
• 赋值表达式的优先级略高于逗号。因此，在分配过程中不会形成元组。将参数传递给函数时，还可以使用：=运算符。
• , , , . . lambda , «» .
• : ,
• , .
• / .
• , .