PEP 572 (Zuweisungsausdrücke in Python 3.8)

PEP 572 - Zuweisungsausdrücke

• Anmerkung
• Rechtfertigung
• Syntax und Semantik
• Spezifikationsänderungen während der Implementierung
• Beispiele
• Abgelehnte Alternativen
• Häufige Einwände
• Stilempfehlungen
• Vielen Dank
• Anhang A: Schlussfolgerungen von Tim Peters
• Anhang B: Ein Grobcode-Interpreter für Generatoren
• Anhang C: Keine Änderungen in der Umfangssemantik
• Verweise
• Urheberrechte ©
• Mein Teil

Anmerkung

Rechtfertigung

Die Bedeutung von echtem 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

Syntax und Semantik

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

Ausnahmefällen

• Zuweisungsausdrücke, die nicht in Klammern stehen, sind auf der „oberen“ Ebene verboten:
  
  

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

  
  Diese Regel erleichtert dem Programmierer die Auswahl zwischen einem Zuweisungsoperator und einem Zuweisungsausdruck. Es gibt keine syntaktische Situation, in der beide Optionen gleichwertig sind.
• . :
  
  

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

Relative Priorität: =

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)

Ändern Sie die Reihenfolge der Berechnungen.

• In Wörterbuchgeneratoren {X: Y für ...} wird Y derzeit vor X ausgewertet. Wir empfehlen, dies so zu ändern, dass X vor Y berechnet wird. (In einem klassischen Dikt wie {X: Y} sowie in dikt ((X, Y) für ...) Dies wurde bereits implementiert. Daher müssen Wörterbuchgeneratoren diesen Mechanismus einhalten.)

Unterschiede zwischen Zuweisungsausdrücken und Zuweisungsanweisungen.

• Die kaskadierende Zuweisung wird nicht direkt unterstützt
  
  

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

• Separate "Ziele" werden mit Ausnahme des einfachen Variablennamens NAME nicht unterstützt:
  
  

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

• Funktionalität und Priorität "um" Kommas unterscheiden sich:
  
  

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

• Auspacken und Verpackungswerte haben keine „reine“ Äquivalenz oder werden überhaupt nicht unterstützt
  
  

  # 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

• Inline-Typanmerkungen werden nicht unterstützt:
  
  

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

• Es gibt keine verkürzte Form von Operationen:
  
  

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

Spezifikationsänderungen während der Implementierung

• Um die Konsistenz mit anderen ähnlichen Ausnahmen zu gewährleisten und keinen neuen Namen einzuführen, der für Endbenutzer möglicherweise nicht geeignet ist, wurde die ursprünglich vorgeschlagene Unterklasse von TargetScopeError for SyntaxError entfernt und auf den üblichen SyntaxError reduziert. [3]
• Aufgrund von Einschränkungen beim Parsen der CPython-Zeichentabelle löst die Referenzimplementierung des Zuweisungsausdrucks einen SyntaxError für alle Verwendungen innerhalb von Iteratoren aus. Bisher trat diese Ausnahme nur auf, wenn der Name der zu erstellenden Variablen mit dem bereits im iterativen Ausdruck verwendeten übereinstimmte. Dies kann überarbeitet werden, wenn ausreichend überzeugende Beispiele vorliegen, die zusätzliche Komplexität jedoch für rein „hypothetische“ Anwendungsfälle ungeeignet erscheint.

Beispiele

Beispiele für Python-Standardbibliotheken

site.py

• Aktueller Code:
  

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

• Verbesserter Code:
  

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

_pydecimal.py

• Aktueller Code:
  

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

• Verbesserter Code:
  

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

copy.py

• Aktueller Code:
  

  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)

• Verbesserter Code:
  
  

  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

• Aktueller Code:
  
  

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

• Verbesserter Code:
  
  

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

sysconfig.py

• Aktueller Code:
  
  

  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

• Verbesserter Code:
  
  

  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

Vereinfachen Sie Listengeneratoren

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

Werte in Bedingungen erfassen

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

Gabel

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

Abgelehnte Alternativen

Ändern des Bereichs für Generatoren

Alternative Schreibweisen

1. EXPR als 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)]

   
   Es ist weniger wahrscheinlich, dass diese Syntax mit anderen in Konflikt steht als as (es sei denn, Sie zählen die Erhöhung von Exc aus Exc-Konstrukten), sie ist jedoch ansonsten mit diesen vergleichbar. Anstelle einer Parallele mit mit expr als Ziel: (was nützlich sein kann, aber auch verwirrend sein kann), weist diese Option überhaupt keine Parallelen zu irgendetwas auf, wird aber überraschenderweise besser in Erinnerung behalten.

Sonderfälle in bedingten Aussagen

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

Sonderfälle bei Generatoren

1. wo, lassen oder gegeben:
   
   

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

   
   Diese Methode führt zu einem Unterausdruck zwischen der for-Schleife und dem Hauptausdruck. Außerdem wird ein zusätzliches Sprachschlüsselwort eingeführt, das zu Konflikten führen kann. Von den drei Optionen, wo ist die sauberste und lesbar, aber potenzielle Konflikte existieren nach wie vor (zum Beispiel SQLAlchemy und numpy ihre wo Methoden sowie tkinter.dnd.Icon in der Standardbibliothek).
2. mit 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

Niedrigere Bedienerpriorität

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

Sie geben rechts Kommas

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

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

Immer Klammern erforderlich

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

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

Häufige Einwände

Warum nicht einfach die Zuweisungsanweisungen in Ausdrücke verwandeln?

Warum mit Mühe Zuweisung Ausdrücke , wenn Zuordnung Anweisungen existieren ?

Warum nicht den lokalen Bereich nutzen und die Verschmutzung von Namespaces verhindern?

Stilempfehlungen

1. Wenn Sie beide Zuweisungsoptionen verwenden können, bevorzugen Sie Operatoren. Sie drücken Ihre Absichten am deutlichsten aus.
2. Wenn die Verwendung von Zuweisungsausdrücken zu Mehrdeutigkeiten in der Ausführungsreihenfolge führt, schreiben Sie den Code mit dem klassischen Operator neu.

Vielen Dank

Anhang A: Schlussfolgerungen von 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

Numerisches Beispiel

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

Anhang B: Ein Grobcode-Interpreter für Generatoren

• Quellcode (EXPR verwendet am häufigsten die VAR-Variable):
  
  

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

• Der konvertierte Code (machen wir uns keine Sorgen um Namenskonflikte):
  
  

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

• Quelle:
  
  

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

• Konvertierter Code:
  
  

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

• Quelle:
  
  

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

• Konvertierter Code:
  
  

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

• Quelle:
  
  

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

• Konvertierter Code:
  
  

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

• Quelle:
  
  

  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
  

• Konvertierter Code:
  
  

  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)

Anhang C: Keine Änderungen in der Umfangssemantik

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

Verweise

1. Nachweis der Konzeptumsetzung
2. Diskussion der Semantik von Zuweisungsausdrücken (VPN ist eng aber geladen)
3. Diskussion von TargetScopeError in PEP 572 (ähnlich wie im vorherigen geladen)

Urheberrechte ©

Mein Teil

• Damit die Menschen nicht versuchen , die semantische Dualität zu entfernen, gibt es an vielen „klassischen“ Stellen, an denen sowohl „=“ als auch „: =“ verwendet werden können, Einschränkungen. Daher sollte der Operator :: = häufig in Klammern gesetzt werden. Diese Fälle müssen im Abschnitt über die grundlegende Verwendung überprüft werden .
• Die Priorität von Zuweisungsausdrücken ist etwas höher als die eines Kommas. Aus diesem Grund werden während der Zuweisung keine Tupel gebildet. Es ermöglicht auch die Verwendung des Operators: =, wenn Argumente an eine Funktion übergeben werden.
• , , , . . lambda , «» .
• : ,
• , .
• / .
• , .