पीईपी 572 (अजगर 3.8 में असाइनमेंट एक्सप्रेशन)

पीईपी 572 - असाइनमेंट एक्सप्रेशंस

• टिप्पणी
• औचित्य
• सिंटेक्स और शब्दार्थ
• कार्यान्वयन के दौरान विशिष्टता बदल जाती है
• उदाहरण
• अस्वीकृत विकल्प
• बार-बार आपत्ति
• शैली की सिफारिशें
• धन्यवाद
• परिशिष्ट A: टिम पीटर्स निष्कर्ष
• परिशिष्ट बी: जनरेटर के लिए एक कठिन कोड दुभाषिया
• परिशिष्ट 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 फ़ॉर ...}, Y का मूल्यांकन वर्तमान में X से पहले किया जाता है। हम इसे बदलने का सुझाव देते हैं ताकि X की गणना Y से पहले हो जाए ((जैसे कि एक क्लासिक तानाशाही जैसे {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)

कार्यान्वयन के दौरान विशिष्टता बदल जाती है

• अन्य समान अपवादों के साथ स्थिरता सुनिश्चित करने के लिए, और अंत उपयोगकर्ताओं के लिए सुविधाजनक नहीं हो सकने वाले एक नए नाम को पेश न करने के लिए, सिंटैक्सएयर के लिए मूल रूप से टारगेटस्स्कोप के प्रस्तावित उपवर्ग को हटा दिया गया है और सामान्य रूप से सिंटैक्सएयर में कम कर दिया गया है। [3]
• CPython वर्ण तालिका को पार्स करने में सीमाओं के कारण, असाइनमेंट अभिव्यक्ति का संदर्भ कार्यान्वयन पुनरावृत्तियों के भीतर सभी उपयोगों के लिए एक SyntaxError उठाता है। इससे पहले, यह अपवाद केवल तब होता है जब बनाया जा रहा चर का नाम उसी के साथ मेल खाता है जो पहले से ही पुनरावृत्त अभिव्यक्ति में उपयोग किया जाता है। यदि पर्याप्त रूप से ठोस उदाहरण हैं, तो इसे संशोधित किया जा सकता है, लेकिन अतिरिक्त जटिलता विशुद्ध रूप से "काल्पनिक" उपयोग के मामलों के लिए अनुपयुक्त लगती है।

उदाहरण

पायथन स्टैंडर्ड लाइब्रेरी उदाहरण

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. NAME के ​​रूप में 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)]

   
   इस सिंटेक्स की तुलना में दूसरों के साथ संघर्ष करने की संभावना कम है (जब तक कि आप एक्स के निर्माण से एक्साइज की गिनती नहीं करते हैं), लेकिन अन्यथा उनके साथ तुलनीय हो। लक्ष्य के रूप में 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)]

   
   इस विधि के परिणामस्वरूप लूप और मुख्य अभिव्यक्ति के बीच एक सबएक्प्रेशन होता है। यह एक अतिरिक्त भाषा कीवर्ड भी पेश करता है, जो टकराव पैदा कर सकता है। तीन विकल्पों में से, जहां सबसे साफ और सबसे पठनीय है, लेकिन संभावित संघर्ष अभी भी मौजूद हैं (उदाहरण के लिए, 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. यदि असाइनमेंट एक्सप्रेशन के उपयोग से निष्पादन क्रम में अस्पष्टता आ जाती है, तो क्लासिकल ऑपरेटर का उपयोग करके कोड को फिर से लिखें।

धन्यवाद

परिशिष्ट A: टिम पीटर्स निष्कर्ष

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)

परिशिष्ट 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. असाइनमेंट एक्सप्रेशंस के शब्दार्थ की चर्चा (वीपीएन तंग है लेकिन भरी हुई है)
3. PEP 572 में TargetScopeError की चर्चा (पिछले एक के समान लोड की गई)

कॉपीराइट

मेरा पक्ष

• ताकि लोग कई "शास्त्रीय" स्थानों में शब्दार्थिक द्वंद्व को दूर करने की कोशिश न करें , जहां कोई "=" और ": =" दोनों का उपयोग कर सकता है, इसलिए प्रतिबंध हैं, इसलिए ऑपरेटर :: = अक्सर कोष्ठक में संलग्न होना चाहिए। मूल उपयोग का वर्णन करने वाले अनुभाग में इन मामलों की समीक्षा की जाएगी ।
• असाइनमेंट एक्सप्रेशन की प्राथमिकता कॉमा की तुलना में थोड़ी अधिक है। इसके कारण, असाइनमेंट के दौरान ट्यूपल्स नहीं बनते हैं। किसी फ़ंक्शन के लिए तर्क पास करते समय: = = ऑपरेटर का उपयोग करना भी संभव बनाता है।
• , , , . . lambda , «» .
• : ,
• , .
• / .
• , .