पायथन ट्रांसलेटर समस्याओं और भाषा पर पुनर्विचार के बारे में

- एक प्रोग्रामिंग भाषा को लागू करने के लिए आपको कितने आर्किटेक्ट की आवश्यकता है?
- एक सौ। एक कार्यान्वयन लिख देगा, और 99 कहेंगे कि वे क्या बेहतर कर सकते हैं।

इस लेख में, मैं न केवल भाषा पर, बल्कि CPython और इसके मानक पुस्तकालय के कार्यान्वयन के विवरणों पर भी बात करना चाहता हूं, जो यह सुनिश्चित करते हैं कि आपके पास पायथन एप्लिकेशन को मल्टीथ्रेडेड, तेज़, या आसानी से समर्थित बनाने के लिए कोई आसान तरीका नहीं होगा, और क्यों इतना बनाया गया था। वैकल्पिक कार्यान्वयन (PyPy, Cython, Jython, IronPython, Python for .NET, Parakeet, Nuitka, Stackless, Unladen Swallow), जिनमें से आधे पहले ही मर चुके हैं; और कुछ लोगों ने समझा कि अन्य भाषाओं के खिलाफ जीवित रहने के लिए संघर्ष जीतने का कोई विकल्प क्यों नहीं था। हां, GDScript है, जिसे प्रदर्शन समस्याओं को हल करने के लिए डिज़ाइन किया गया है, निम है, जो सामान्य रूप से सभी प्रकार की समस्याओं को हल करने के लिए उपयोगकर्ता की आवश्यकता के बिना सामान्य रूप से सभी समस्याओं को हल करने के लिए डिज़ाइन किया गया है। हालांकि, उद्योग की भारी जड़ता को देखते हुए, मुझे एहसास है कि अगले 10 वर्षों में, निश्चित रूप से एक महत्वपूर्ण जगह पर नई भाषाओं का कब्जा नहीं होगा। हालांकि, मेरा मानना ​​है कि मूल वाक्य रचना को बनाए रखने वाले अधिकांश भाग के लिए, और नए और पुराने-शैली कोड के बीच बातचीत की संभावना को पूरी तरह से संरक्षित करते हुए, लेखन कोड की शैली को बदलकर अजगर को प्रभावी बनाया जा सकता है। मैं CPython की समस्याओं पर ध्यान केंद्रित करूंगा, न कि इसके निकटतम प्रतिद्वंद्वी PyPy के बाद से, PyPy वास्तव में CPython की सभी समान समस्याओं के आसपास कूदता है।

मैं सात साल के अनुभव वाला एक प्रोग्रामर हूं, जो मुख्य रूप से वेब और मल्टी-थ्रेडेड डेटाबेस पर जोर देने के साथ डेस्कटॉप एप्लिकेशन के विकास में लगा हुआ है। आप पूछते हैं, "एक मिनट प्रतीक्षा करें, लेकिन उपयोगकर्ता इंटरफ़ेस, वेब मोर्चों और मल्टीथ्रेडिंग के साथ अजगर में क्या आम है?" और मैं जवाब दूंगा "यही है - कुछ भी नहीं।" मैंने अपने कार्यों के लिए सी, डेल्फी, जावास्क्रिप्ट और एसक्यूएल का उपयोग किया। मैं इस स्थिति से बहुत खुश नहीं था, और कुछ समय पहले मैंने एरिक स्नो की परियोजना में भाग लेने की कोशिश की थी, जो सीपीथॉन में कई दुभाषियों के लिए समर्थन लागू करने के लिए किया गया था:
https://www.python.org/dev/peps/pep-0554/
https://github.com/ericsnowcurrently/multi-core-python

दुर्भाग्य से, समझ जल्दी आ गई कि:

• सीपीथॉन को इस तरह की लोकप्रिय परियोजना के लिए खराब समर्थन दिया गया है, और पुरानी समस्याओं का एक समूह है जो कार्यान्वयन को फिर से शुरू करने की कोशिश करते समय सामने आता है। नतीजतन, एरिक कई वर्षों से परिवर्तनीय प्रगति के साथ दुभाषिया उठा रहा है;
• कई दुभाषियों के सफल कार्यान्वयन के बाद भी, यह स्पष्ट नहीं है कि आगे समानांतर निष्पादन को कैसे व्यवस्थित किया जाए। पीईपी सरल चैनलों का उपयोग करने का सुझाव देता है, लेकिन यह उपकरण खतरनाक हो जाता है क्योंकि कार्य अधिक जटिल हो जाता है, जिसमें ठंड और अप्रत्याशित व्यवहार के खतरे होते हैं;
• भाषा में ही बड़ी समस्याएं हैं जो दुभाषियों को सीधे डेटा का आदान-प्रदान करने और पूर्वानुमानित व्यवहार की कुछ गारंटी देने से रोकती हैं।

अब समस्याओं के बारे में अधिक विस्तार से।

परिवर्तनीय वर्ग की परिभाषाएँ

हां, मैं समझता हूं कि अजगर की कक्षा को रनटाइम में घोषित किया जाता है। लेकिन लानत है, क्यों चर में डाल दिया? पुरानी वस्तुओं में नए तरीके क्यों जोड़ें? आप किसी भी जावा में कक्षाओं के बाहर कार्यों और चर की घोषणा नहीं कर सकते हैं, लेकिन अजगर में ऐसा कोई प्रतिबंध नहीं है (और जावा से पहले अजगर बनाया गया था)। इसके अलावा, मैं आपको इस बात पर ध्यान देने के लिए कहता हूं कि ऑब्जेक्ट के समान तरीकों को जोड़ने के लिए आपको कैंसर के साथ कैसे झुकना चाहिए, और वर्ग के लिए नहीं - इसके लिए type.MethodType, function .__ get__, functionalools.partial, और इसी तरह की आवश्यकता होती है।
शुरुआत के लिए, मैं एक अजीब सवाल पूछना चाहता हूं: अजगर को तरीकों की आवश्यकता क्यों है? फ़ंक्शन नहीं, जैसा कि करीब जावास्क्रिप्ट में है, लेकिन क्लास के तरीके। कारकों में से एक: गुइडो कार्यों के संक्षिप्त नाम बनाने के लिए बेहतर तरीके से नहीं आया था (ताकि कोई gtk_button_set_focus_on_click नहीं है), क्योंकि यह स्पष्ट नहीं है कि एक छोटे नाम के साथ समान फ़ंक्शन के गुच्छा से इस विशिष्ट ऑब्जेक्ट के लिए आवश्यक कार्यों का चयन कैसे करें। फिर भी, len, iter, next, isinstance, slice, dict, dir, str, repr, hash, टाइप अजगर में दिखाई दिए - अब ये नाम में अंडरस्कोर के साथ संबंधित वर्ग विधियों के रैपर हैं, और एक बार निर्मित सरल प्रकार नहीं थे कक्षाएं और केवल इन कार्यों के माध्यम से काम किया। व्यक्तिगत रूप से, मैं विधि (ऑब्जेक्ट) और object.method की रिकॉर्डिंग के बीच बहुत अंतर नहीं देखता हूं - खासकर अगर विधि एक स्थिर फ़ंक्शन है, जो सामान्य रूप से ध्यान में नहीं रखता है जो पहले तर्क (स्व) को स्वीकार करता है।
सामान्य मामले में गतिशील वर्ग परिभाषाएँ:

• मॉड्यूलर परीक्षण न दें। परीक्षण में सही ढंग से काम किए गए कोड का एक टुकड़ा पूरी प्रणाली के चलने पर एक त्रुटि दे सकता है, और आपको CPython के भीतर से संरक्षित नहीं किया जाएगा;
• अनुकूलन की महान कठिनाइयों का निर्माण। एक वर्ग घोषणा आपको वर्ग के वास्तविक संचालन की गारंटी नहीं देती है। इस कारण से, PyPy का एकमात्र सफल ऑप्टिमाइज़र प्रोजेक्ट जांच पद्धति द्वारा किए गए कार्यों के वास्तविक अनुक्रम का पता लगाने के लिए ट्रेसिंग का उपयोग करता है;
• समानांतर कोड निष्पादन के साथ डॉक न करें। उदाहरण के लिए, एक ही बहुसंकेतन वर्ग परिभाषाओं की प्रतियों के साथ काम करता है, और अगर, भगवान न करे, किसी एक प्रतियों में कक्षाओं के विवरण को बदल दें, तो आपके आवेदन का जोखिम कम हो जाएगा।

डायनेमिक कक्षाओं का एक अधिक सूक्ष्म संस्करण __getattribute__, __getattr__, और अन्य के माध्यम से विशेषता पहुंच को ओवरराइड कर रहा है। अक्सर उन्हें नियमित रूप से गेटटर-सेटर के रूप में उपयोग किया जाता है, फ़ंक्शंस को एक फील्ड ऑब्जेक्ट में सौंपने के लिए, और कभी-कभी एक डीएसएल को व्यवस्थित करने के लिए। इन सभी कार्यों को अधिक सभ्य तरीके से लागू किया जा सकता है, बिना विवरणों के एक वर्ग में बदलकर, जिनके व्यवहार की गारंटी देना कभी-कभी मुश्किल होता है। वैसे, गेटर्स / सेटर के मामले में, ऐसा तंत्र पहले से मौजूद है - ये विशेषता विवरण हैं: https://www.python.org/dev/peps/pep-0252/#id5

डीबगिंग और सामान्य कोडिंग के लिए कक्षाओं की हॉट स्वैपिंग की आवश्यकता होती है, लेकिन यह अभी भी डेवलपर के लिए एक विशेष उपकरण होना चाहिए, और रनटाइम पर एक विरूपण साक्ष्य नहीं है जिसे समाप्त नहीं किया जा सकता है।

संकलित कक्षाएं केवल एक छोटा कदम है जिसे साइथॉन और नुत्का पहले ही ले चुके हैं, लेकिन अन्य परिवर्तनों के बिना अकेले यह कदम निष्पादन की गति के मामले में भी कोई महत्वपूर्ण प्रभाव पाने के लिए पर्याप्त नहीं है, क्योंकि, उदाहरण के लिए, अजगर गतिशील गतिशील बंधन का व्यापक उपयोग करता है, जो कहीं नहीं है संकलित कोड में दूर नहीं जाता है।

एकाधिक वंशानुक्रम

मुझे लगता है कि यह टोपी परेड का नेता है। यह अजगर और उसके विस्तार के कार्यान्वयन में सी-कार्यों के स्तर पर भी नहीं है। "लेकिन इंटरफेस के बारे में क्या?" आप आपत्ति करते हैं। संकलन में इन प्रोटोकॉल के बाद के स्थैतिक सत्यापन के उद्देश्य से किसी वस्तु की कॉलिंग विधियों के लिए प्रोटोकॉल घोषित करने की भूमिका में C ++ और Java में इंटरफेस की आवश्यकता होती है, साथ ही उन तरीकों के तालिकाओं को उत्पन्न करने के लिए जिन्हें किसी अन्य समय में स्रोत ऑब्जेक्ट के बारे में कुछ भी नहीं पता है। ये भूमिकाएं अजगर में लगभग पूरी तरह से खो जाती हैं, इसलिए उनके अस्तित्व का कोई औचित्य नहीं है। मुझे गो में जिस तरह से इंटरफेस बनाया गया है वह पसंद है - यह अजगर एबीसी के समान है: https://www.python.org/dev/peps/pep-3119

एकाधिक वंशानुक्रम समानांतरकरण और अनुकूलन के लिए एक सीधी समस्या नहीं है, लेकिन कोड की पठनीयता और स्थिरता को जटिल करता है - यह तथाकथित लासगना कोड (स्पेगेटी कोड के साथ सादृश्य द्वारा) है।

जनरेटर

यह GoTo का वास्तव में उपेक्षित मामला है, जब निष्पादन केवल कोड पर अनियंत्रित रूप से कूदता नहीं है - यह ढेर के साथ कूदता है। विशेष रूप से भयंकर खेल तब होता है जब जनरेटर संदर्भ प्रबंधकों (हेलो पीईपी 567) के साथ अंतर करते हैं। यदि जुड़े म्यूटेंट राज्यों की एक तंग गेंद में आवेदन को भ्रमित करने के लिए अजगर में एक सामान्य प्रवृत्ति होती है जो परीक्षण, समानांतरकरण और कार्यक्रम अनुकूलन युद्धाभ्यास के लिए जगह नहीं देते हैं, तो जनरेटर इस केक पर एक चेरी हैं।

आपको क्या लगता है कि कार्यक्रम का परिणाम क्या होगा:

import contextlib
@contextlib.contextmanager
def context_manager():
    try:
        print('')
        yield
    finally:
        print('')

def gen_in_manager():
    m = context_manager()
    with m:
        for i in range(5):
            yield i

g1 = gen_in_manager()
next(g1)
print('')

, :

import contextlib
@contextlib.contextmanager
def context_manager():
    try:
        print('')
        yield
    finally:
        print('')

def gen_in_manager():
    m = context_manager()
    with m:
        for i in range(5):
            yield i

def test():
    g1 = gen_in_manager()
    next(g1)

test()
print('')

.
, , : async/await, .

: RPython -. , . , , .

https://stackoverflow.com/questions/530530/python-2-x-gotchas-and-landmines

>>> a = ([42],)
>>> a[0] += [43, 44]
TypeError: 'tuple' object does not support item assignment
>>> a
([42, 43, 44],)
>>> a = ([42],)
>>> b = a[0]
>>> b += [43, 44]
>>> a
([42, 43, 44],)

>>> x = y = [1,2,3]
>>> x = x + [4]
>>> x == y
False
>>> x = y = [1,2,3]
>>> x += [4]
>>> x == y
True

>>> x = [[]]*5
>>> x
[[], [], [], [], []]
>>> x[0].append(0)
>>> x
[[0], [0], [0], [0], [0]]

, «'tuple' object does not support item assignment» : . , , , , . , , x[0].append(0) , CPython , . , .

— [] ? , , . , Clojure , - partial-copy-on-write . , .

? , , . , copy-on-write , : b.append.., b[].., b +=… : , , — , , . , , , , // , .

copy-on-write? , , (), ( ), , .

- . ? , copy-on-write, «({'first': 1, 'second': 2},)», , , , , , «{'first': 1, 'second': 2}».

https://ru.wikipedia.org/wiki/_()
« — »

: https://en.wikipedia.org/wiki/Multiple_dispatch#Use_in_practice
, 13–32% (a.k.a. ), 2.7–6.5% — . : , , , . , , .

, — , . , , . , double char, , double .

float a = 2.0;
float *src = &a;
char *dest = malloc(sizeof(float));
memcpy(dest, src, sizeof(float));
printf("%f", *(double*)dest);

, (, , ) — - , , , .

, ( ) . : «a = b + c», , . ?

• : «if (Py_TYPE(obj) == &PyLong_Type) {long val = PyLong_AsLong...}» type();
• : «PyArg_ParseTuple()» , «this.number = int(param1); this.text = str(param2)» — , . , , ( , );
• // . — .

, . , ? CPython, , , , , . , : . , ? : , / , / . C «a = b + c» ( , ):

def PyNumber_Add(b, c):
  slotb = b.__add__
  if not type(b) is type(c) and c.__add__:
    slotc = c.__add__
    if slotc is slotb:
      slotc = None
  if slotb:
    if slotc and isinstance(c, b.__class__):
      return slotc(b, c)
    else:
      return slotb(b, c)
  else:
    return slotb(b, c)

if isinstance(b, str) and isinstance(c, str):
  a = unicode_concatenate(b, c)
else:
  a = PyNumber_Add(b, c)

, , . « » — , , , , . , , , « », «», «», ; — .

: , . , . : , . , , — .

, . , , . , - , .

, , ( ), ( ), . , , ( ). , , — , ? .

— : , . , , . , , - , , : . , , — MRO:
https://www.python.org/download/releases/2.3/mro/
https://ru.wikipedia.org/wiki/C3-

, 3.4 « » ( Argument — Monty Python ), . « »… , : 3.4 2014, 1991.

. , (trait) Rust ( , , , , ):
https://doc.rust-lang.org/1.8.0/book/traits.html
, , , , , . «». , , . , - , , Rust-. , __iter__ — «». , , , , . , « - , ». , , C++ ranges, , , .
:

from collections.abc import Iterable, Container
from itertools import filterfalse

class MyList(Trait, Iterable, Container):
  pass

def __sub__(a: MyList, b: object):
  return list(filterfalse(lambda x: x == b, a))

def __sub__(a: MyList, b: Container):
  return list(filterfalse(lambda x: x in b, a))

a = MyList([1, 2, 3, 4, 5])
print(a - [2, 5]) #  , print(__sub__(a, b))
# : [1, 3, 4]
print(a - 3)
# : [1, 2, 4, 5]

MyList, Iterable ( __iter__) Container ( __contains__), list, list MyList, MyList list, list MyList. :

from collections.abc import Container
from itertools import filterfalse

class MyList(list):
  def __sub__(self, b):
    if isinstance(b, Container):
      return list(filterfalse(lambda x: x in b, a))
    else:
      return list(filterfalse(lambda x: x == b, a))

a = MyList([1, 2, 3, 4, 5])
print(a - [2, 5])
# : [1, 3, 4]
print(a - 3)
# : [1, 2, 4, 5]

: , «a», . « », -, .

, — , , , . , , .

, , . , , , , , , . - , — - , . :

>>> a = [1, 2, 3]
...
>>> a = '15'
...
>>> for i in map(lambda x: x*2, a):
>>>    print(i)
11
55

2
4
6

.

, , . None — , NoneType. , — , - , . :

>>> class A():
>>>   def __init__(self, value):
>>>     self.val = value
>>>
>>> a = A('2')
>>> a.val = []
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only assign str (not "list") to str
>>> a.myattr = []
>>> a.myattr = 2

A val, . , - (myattr) — , , .

, . — , , . , :

>>> class A():
>>>   def __init__(self, value):
>>>     self.val = value
>>>
>>> def func():
>>>   a = A(None)
>>>   a.val = 2
>>>   print(a.__dict__)
>>>
>>> func()
{'val': 2}

A<None or Int>, . , , .

: , : , , , «-», «». — , ; - , , , , . , , «list», , , list comprehension, , , BUILD_LIST LIST_APPEND ( CPython) — ? , « », « - ».

, - () , «a.val = int(newval)». , , , . , __setattr__ __setattribute__, c 2.2 __set__ ( https://www.python.org/dev/peps/pep-0252/ ). : , , — C++/Java/C#. , : __set__, __get__, __delete__, , :

>>> a = StrictDict({'first': 1 })
>>> a = { 'dummy': 666 }
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StrictDictError: "first" key is missing in the assignment source

, ( « »): copy-on-write , , -, copy-on-write :

>>> a = COWList([1, 2, 3])
>>> b = a
>>> a.append(4)
>>> b.append(5)
>>> a
[1, 2, 3, 4]
>>> b
[1, 2, 3, 5]

, CPython , «»:
https://github.com/python/cpython/blob/master/Objects/typeobject.c#L5074
, __slots__ . , , , , , , , , . ( ) . , : __slots__ , PyHeapTypeObject->ht_slots, __dict__, PyTypeObject->tp_dictoffset. , .

, , . , , , , , « , ; — "", ""», . , , . «<> = new <>()», «var = new <>()». , ReasonML , , — JS , , .

PyPy, V8 JavaScript LuaJIT, , . - , , . AOT , asm.js, WebAssembly, PNaCl.

:

1. Bauer, A.M. and Saal, H.J. (1974). Does APL really need run-time checking? Software — Practice and Experience 4: 129–138.
2. Kaplan, M.A. and Ullman, J.D. (1980). A scheme for the automatic inference of variable types. J. A CM 27(1): 128–145.
3. Borning, A.H. and Ingalls, D.H.H. (1982). A type declaration and inference system for Smalltalk. In Conference Record of the Ninth Annual ACM Symposium on Principles of Programming Languages (pp. 133–141)
4. https://ru.wikipedia.org/wiki/Standard_ML — 1984 .

, Standard ML , , .
, - , . , , — , , ( ), :

1. Frank Pfenning. (1988). Partial polymorphic type inference and higher-order unification. In Proceedings of the 1988 ACM Conference on Lisp and Functional Programming, pp. 153–163
2. Cardelli, Luca; Martini, Simone; Mitchell, John C.; Scedrov, Andre (1994). An extension of system F with subtyping. Information and Computation, vol. 9. North Holland, Amsterdam. pp. 4–56
3. Benjamin C. Pierce, and David N. Turner. (1997). Local type inference. Indiana University CSCI Technical Report #493, pp. 1-25
   
   (1998) Local type inference. POPL '98 Proceedings of the 25th ACM SIGPLAN-SIGACT symposium on Principles of programming languages, pp. 252-265
   
   (2000). Local type inference. ACM Transactions on Programming Languages and Systems (TOPLAS). Vol. 22(1), pp. 1-44

— , Scala, 2001 .

1991 , 1994 — , 1995 — «Matz», . , , . , , — , , , , , ZeroMQ, RabbitMQ, Kafka. , , , , , . , ? . - , Crystal, , .

— . , , .