PEP 572 (تعابير التعيين في بيثون 3.8)

PEP 572 - تعابير التعيين

• حاشية. ملاحظة
• التبرير
• النحو والمعاني
• تغييرات المواصفات أثناء التنفيذ
• أمثلة
• البدائل المرفوضة
• اعتراضات متكررة
• توصيات الاسلوب
• شكر
• الملحق أ: استنتاجات تيم بيترز
• الملحق ب: مترجم الشفرة الخام للمولدات
• الملحق ج: لا تغييرات في دلالات النطاق
• المراجع
• حقوق النشر
• جزئي

حاشية. ملاحظة

التبرير

أهمية الكود الحقيقي

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 ...} ، يتم تقييم Y حاليًا قبل X. نقترح تغيير هذا بحيث يتم حساب X قبل Y. (في إملاء كلاسيكي مثل {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)

تغييرات المواصفات أثناء التنفيذ

• لضمان الاتساق مع الاستثناءات المماثلة الأخرى ، وعدم تقديم اسم جديد قد لا يكون مناسبًا للمستخدمين النهائيين ، تمت إزالة الفئة الفرعية المقترحة أصلاً من TargetScopeError لـ SyntaxError وتم تقليلها إلى 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

copy.py

• الكود الحالي:
  

  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. EXPR كاسم:
   
   

   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 من Excs الإنشاءات) ، لكن بخلاف ذلك تكون قابلة للمقارنة معهم. بدلاً من التوازي مع 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 والتعبير الرئيسي. كما يقدم أيضًا كلمة أساسية إضافية للغة ، والتي يمكن أن تخلق تعارضات. من بين الخيارات الثلاثة ، أين هو الأنظف والأكثر قابلية للقراءة ، ولكن الصراعات المحتملة لا تزال موجودة (على سبيل المثال ، SQLAlchemy و numpy لها طرقها ، وكذلك 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. إذا أدى استخدام تعبيرات التخصيص إلى الغموض في أمر التنفيذ ، فأعد كتابة الشفرة باستخدام عامل التشغيل الكلاسيكي.

شكر

الملحق أ: استنتاجات تيم بيترز

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

الملحق ب: مترجم الشفرة الخام للمولدات

• شفرة المصدر (يستخدم 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)

الملحق ج: لا تغييرات في دلالات النطاق

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. مناقشة TargetScopeError في PEP 572 (تم تحميله بشكل مشابه لما سبق)

حقوق النشر

جزئي

• بحيث لا يحاول الناس إزالة الازدواج الدلالي ، في العديد من الأماكن "الكلاسيكية" حيث يمكن للمرء استخدام كل من "=" و ": =" هناك قيود ، لذلك يجب غالبًا وضع عامل التشغيل :: = بين قوسين. يجب مراجعة هذه الحالات في القسم الذي يصف الاستخدام الأساسي.
• تكون أولوية تعبيرات التخصيص أعلى قليلاً من تلك الموجودة في الفاصلة. ونتيجة لذلك ، لا يتم تشكيل الصفوف أثناء المهمة. كما أنه يجعل من الممكن استخدام عامل التشغيل: = عند تمرير الوسائط إلى دالة.
• , , , . . lambda , «» .
• : ,
• , .
• / .
• , .