क्या पायथन दृढ़ता से टाइप किया गया है?

Question

मुझे लगता है कि पायथन एक जोरदार टाइप की गई भाषा है, लिंक पर आया है।

हालाँकि, मैंने दृढ़ता से टाइप की गई भाषाओं में सोचा था कि आप ऐसा नहीं कर सकते:

bob = 1
bob = "bob"

मुझे लगा कि एक जोरदार टाइप की गई भाषा रन-टाइम में टाइप-चेंजिंग को स्वीकार नहीं करती है। शायद मुझे मजबूत / कमजोर प्रकार की एक गलत (या बहुत सरल) परिभाषा मिली है।

तो, पायथन एक जोरदार या कमजोर टाइप की भाषा है?

Answer 1

अजगर दृढ़ता से, गतिशील रूप से टाइप किया जाता है।

• मजबूत टाइपिंग का मतलब है कि अनपेक्षित तरीकों से मूल्य का प्रकार नहीं बदलता है। केवल अंकों वाला एक स्ट्रिंग जादुई रूप से एक संख्या नहीं बनता है, जैसा कि पर्ल में हो सकता है। हर प्रकार के परिवर्तन के लिए एक स्पष्ट रूपांतरण की आवश्यकता होती है।
• डायनेमिक टाइपिंग का अर्थ है कि रनटाइम ऑब्जेक्ट्स (मान) में एक प्रकार है, जैसा कि स्टैटिक टाइपिंग के विपरीत जहां चर का प्रकार होता है।

अपने उदाहरण के लिए के रूप में

bob = 1
bob = "bob"

यह काम करता है क्योंकि चर का प्रकार नहीं है; यह किसी भी वस्तु का नाम दे सकता है। बाद में bob=1, आपको वह type(bob)रिटर्न मिलेगा int, लेकिन उसके बाद bob="bob", वह वापस आ जाता है str। (ध्यान दें कि typeएक नियमित कार्य है, इसलिए यह उसके तर्क का मूल्यांकन करता है, फिर मूल्य का प्रकार लौटाता है।)

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

मुझे यह जोड़ना चाहिए कि मजबूत बनाम कमजोर टाइपिंग एक बूलियन पसंद की तुलना में एक निरंतरता से अधिक है। C ++ में C की तुलना में अधिक मजबूत टाइपिंग है (अधिक रूपांतरण आवश्यक), लेकिन पॉइंटर कास्ट्स का उपयोग करके टाइप सिस्टम को घटाया जा सकता है।

एक गतिशील भाषा जैसे पायथन में टाइप सिस्टम की ताकत वास्तव में इस बात से निर्धारित होती है कि इसकी प्राइमेटीज और लाइब्रेरी फ़ंक्शंस विभिन्न प्रकारों पर कैसे प्रतिक्रिया देते हैं। जैसे, +अतिभारित ताकि यह दो संख्याओं या दो तारों पर काम करे , लेकिन एक तार और एक संख्या नहीं। यह एक डिज़ाइन पसंद किया +गया है जब इसे लागू किया गया था, लेकिन वास्तव में भाषा के शब्दार्थ से निम्नलिखित आवश्यकता नहीं है। वास्तव में, जब आप +एक कस्टम प्रकार पर अधिभार लगाते हैं, तो आप इसे किसी भी चीज़ को एक संख्या में बदल सकते हैं:

def to_number(x):
    """Try to convert function argument to float-type object."""
    try: 
        return float(x) 
    except (TypeError, ValueError): 
        return 0 

class Foo:
    def __init__(self, number): 
        self.number = number

    def __add__(self, other):
        return self.number + to_number(other)

कक्षा का उदाहरण Fooअन्य वस्तुओं में जोड़ा जा सकता है:

>>> a = Foo(42)
>>> a + "1"
43.0
>>> a + Foo
42
>>> a + 1
43.0
>>> a + None
42

ध्यान से देखें कि भले ही दृढ़ता से टाइप किया अजगर प्रकार की वस्तुओं को जोड़ने के साथ पूरी तरह से ठीक है intऔर floatऔर रिटर्न प्रकार का ऑब्जेक्ट float(जैसे, int(42) + float(1)रिटर्न 43.0)। दूसरी ओर, प्रकार के बीच बेमेल के कारण हास्केल शिकायत करता है कि यदि कोई निम्नलिखित प्रयास करता है (42 :: Integer) + (1 :: Float)। यह हास्केल को एक कड़ाई से टाइप की गई भाषा बनाता है, जहां प्रकार पूरी तरह से असंतुष्ट हैं और केवल ओवरलोडिंग का एक नियंत्रित रूप टाइप कक्षाओं के माध्यम से संभव है।

Comments

एक उदाहरण जो मुझे बहुत बार नहीं दिखता है, लेकिन मुझे लगता है कि यह दिखाना महत्वपूर्ण है कि पायथन पूरी तरह से टाइप्ड नहीं है, क्या वह सभी चीजें हैं जो बूलियन का मूल्यांकन करती हैं: docs.python.org/release/2.5.2/lib/truth.html

— gsingh2011 19

यकीन नहीं तो अगर यह एक काउंटर उदाहरण है: चीजें एक बूलियन का मूल्यांकन कर सकती हैं, लेकिन वे अचानक "बूलियन" नहीं बन जाते हैं। यह लगभग वैसा ही है जैसे कि किसी ने कथित रूप से as_boolean (<value>) जैसा कुछ कहा है, जो कि वस्तु के प्रकार ही नहीं बदल रहा है, ठीक है?

— जेंबेलेल

बूलियन संदर्भ में truthy होने के नाते एक प्रति है, क्योंकि कुछ भी नहीं वास्तव में करने के लिए परिवर्तित किया जा रहा है नहीं है Trueया False। लेकिन नंबर प्रमोशन का क्या? 1.0 + 2भले ही "1.0" + 2यह पर्ल या सी में करता है, भले ही पाइथन में काम नहीं करता है। मैं @jbrendel से सहमत हूं कि यह वास्तव में एक अंतर्निहित रूपांतरण नहीं है, यह सिर्फ ओवरलोडिंग है - लेकिन एक ही अर्थ में, पर्ल कोई भी अंतर्निहित रूपांतरण नहीं कर रहा है। यदि फ़ंक्शंस ने पैरामीटर प्रकार घोषित नहीं किए हैं, तो होने वाले रूपांतरणों के लिए कहीं नहीं है।

— अवतरण

मजबूत टाइपिंग के बारे में सोचने का एक बेहतर तरीका यह है कि वेरिएबल पर ऑपरेशन करते समय टाइप करें। यदि प्रकार अपेक्षित नहीं है, तो शिकायत करने वाली भाषा बहुत टाइप की जाती है (अजगर / जावा) और कमजोर टाइप की नहीं है (जावास्क्रिप्ट) डायनामिक टाइप की गई भाषाएं (अजगर) वे हैं जो किसी चर के प्रकार को बदलने की अनुमति देते हैं रनटाइम जबकि वैधानिक रूप से टाइप की गई भाषाएँ (जावा) एक बार घोषित होने के बाद इसे अनुमति नहीं देती हैं।

— काशिफ

@ gsingh2011 सत्यता उपयोगी है और अपने आप में कमजोर टाइपिंग नहीं है , लेकिन एक आकस्मिक if isValid(value) - 1रिसाव हो सकता है। बूलियन को पूर्णांक में ले जाया जाता है, जिसे तब एक सत्य मान के रूप में मूल्यांकन किया जाता है। False - 1सत्य हो जाता है और True - 1झूठा हो जाता है, जिससे एक शर्मनाक मुश्किल से दो-स्तरित ऑफ-बाय-एक त्रुटि डिबग के लिए जाती है। इस अर्थ में, अजगर ज्यादातर दृढ़ता से टाइप किया जाता है; आमतौर पर तार्किक गलतियाँ नहीं होती हैं।

— आरोन 3468

Answer 2

कुछ महत्वपूर्ण मुद्दे हैं जो मुझे लगता है कि सभी मौजूदा उत्तर छूट गए हैं।

---

कमजोर टाइपिंग का मतलब अंतर्निहित प्रतिनिधित्व तक पहुंच की अनुमति देना है। C में, मैं वर्णों के लिए एक पॉइंटर बना सकता हूं, फिर संकलक को बताऊंगा कि मैं इसे पूर्णांक के लिए एक पॉइंटर के रूप में उपयोग करना चाहता हूं:

char sz[] = "abcdefg";
int *i = (int *)sz;

32-बिट पूर्णांकों के साथ एक छोटे से एंडियन प्लेटफॉर्म पर, यह iसंख्याओं की एक सरणी में बनाता है 0x64636261और 0x00676665। वास्तव में, आप खुद को पूर्णांक (उपयुक्त आकार के) के लिए संकेत भी दे सकते हैं:

intptr_t i = (intptr_t)&sz;

और निश्चित रूप से इसका मतलब है कि मैं सिस्टम में कहीं भी मेमोरी को ओवरराइट कर सकता हूं। *

char *spam = (char *)0x12345678
spam[0] = 0;

_{* बेशक आधुनिक OS का वर्चुअल मेमोरी और पेज प्रोटेक्शन का उपयोग करते हैं, इसलिए मैं केवल अपनी प्रक्रिया की मेमोरी को ओवरराइट कर सकता हूं, लेकिन C स्वयं के बारे में ऐसा कुछ भी नहीं है जो इस तरह की सुरक्षा प्रदान करता है, जैसा कि कभी भी जिस पर कोडित किया गया हो, कहे, क्लासिक मैक ओएस या Win16 आपको बता सकता है।}

पारंपरिक लिस्प ने हैकरी के समान प्रकार की अनुमति दी; कुछ प्लेटफार्मों पर, डबल-शब्द फ़्लोट्स और कॉन्स सेल एक ही प्रकार के थे, और आप सिर्फ एक फ़ंक्शन को पास कर सकते हैं जो दूसरे की उम्मीद कर रहे हैं और यह "काम" करेगा।

अधिकांश भाषाएं आज सी और लिस्प के रूप में काफी कमजोर नहीं हैं, लेकिन उनमें से कई अभी भी कुछ हद तक टपका हुआ है। उदाहरण के लिए, कोई भी OO भाषा जिसमें "डाउनकास्ट" है, * वह एक प्रकार का रिसाव है: आप अनिवार्य रूप से संकलक को बता रहे हैं "मुझे पता है कि मैंने आपको यह जानने के लिए पर्याप्त जानकारी नहीं दी है कि यह सुरक्षित है, लेकिन मुझे पूरा यकीन है यह है, "जब एक प्रकार की प्रणाली का पूरा बिंदु यह है कि संकलक के पास हमेशा यह जानने के लिए पर्याप्त जानकारी होती है कि क्या सुरक्षित है।

_{* एक चेक डाउनकास्ट भाषा के प्रकार प्रणाली को किसी भी कमजोर नहीं बनाता है क्योंकि यह चेक को रनटाइम में ले जाता है। यदि यह किया है, तो उप-प्रकार बहुरूपता (उर्फ आभासी या पूरी तरह से गतिशील फ़ंक्शन कॉल) टाइप सिस्टम का एक ही उल्लंघन होगा, और मुझे नहीं लगता कि कोई भी ऐसा कहना चाहता है।}

बहुत कम "स्क्रिप्टिंग" भाषाएं इस अर्थ में कमजोर हैं। Perl या Tcl में भी, आप एक स्ट्रिंग नहीं ले सकते हैं और सिर्फ इसके बाइट्स को एक पूर्णांक के रूप में व्याख्या कर सकते हैं। * लेकिन यह ध्यान देने योग्य है कि CPython में (और इसी तरह कई भाषाओं के लिए कई अन्य दुभाषियों के लिए), यदि आप वास्तव में लगातार हैं, तो आप ctypesलोड करने के लिए उपयोग कर सकते हैं libpython, एक वस्तु idको एक में डाल सकते हैं POINTER(Py_Object), और प्रकार प्रणाली को लीक करने के लिए मजबूर कर सकते हैं। क्या यह प्रकार प्रणाली को कमजोर बनाता है या नहीं, आपके उपयोग के मामलों पर निर्भर करता है - यदि आप सुरक्षा सुनिश्चित करने के लिए इन-लैंग्वेज प्रतिबंधित निष्पादन सैंडबॉक्स लागू करने का प्रयास कर रहे हैं, तो आपको इस प्रकार के पलायन से निपटना होगा ...

_{* आप struct.unpackबाइट्स पढ़ने के लिए एक फ़ंक्शन का उपयोग कर सकते हैं और "सी कैसे इन बाइट्स का प्रतिनिधित्व करेंगे" से एक नया इंट का निर्माण करते हैं, लेकिन यह स्पष्ट रूप से लीक नहीं है; यहां तक ​​कि हास्केल अनुमति देता है।}

---

इस बीच, अंतर्निहित रूपांतरण वास्तव में एक कमजोर या टपका हुआ प्रकार की प्रणाली से एक अलग बात है।

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

और गतिशील भाषाओं के साथ, यह बहुत आसान है। पायथन या पर्ल में "एक फ़ंक्शन जो फ्लोट चाहता है" जैसी कोई चीज नहीं है। लेकिन अतिभारित कार्य हैं जो विभिन्न प्रकारों के साथ अलग-अलग काम करते हैं, और एक मजबूत सहज ज्ञान युक्त भावना है, उदाहरण के लिए, एक स्ट्रिंग को कुछ और से जोड़ना "एक फ़ंक्शन है जो एक स्ट्रिंग चाहता है"। उस अर्थ में, पर्ल, Tcl, और जावास्क्रिप्ट बहुत सारे निहितार्थ रूपांतरण ( "a" + 1आपको देता है "a1") करते हुए दिखाई देते हैं , जबकि पायथन बहुत कम करता है ( "a" + 1एक अपवाद को उठाता है, लेकिन 1.0 + 1आपको 2.0* देता है)। यह केवल औपचारिक शब्दों में रखना कठिन है - ऐसा क्यों नहीं होना चाहिए +जो एक स्ट्रिंग और एक इंट लेता है, जब स्पष्ट रूप से अन्य फ़ंक्शन होते हैं, जैसे कि अनुक्रमण, जो करते हैं?

_{* दरअसल, आधुनिक पायथन में, जिसे OO सबटाइपिंग के संदर्भ में समझाया जा सकता है, क्योंकि isinstance(2, numbers.Real)यह सच है। मुझे नहीं लगता कि 2पर्ल या जावास्क्रिप्ट में स्ट्रिंग प्रकार का कोई उदाहरण है ... हालांकि Tcl में, यह वास्तव में है, क्योंकि सब कुछ स्ट्रिंग का एक उदाहरण है।}

---

अंत में, एक और, पूरी तरह से ऑर्थोगोनल है, "मजबूत" बनाम "कमजोर" टाइपिंग की परिभाषा, जहां "मजबूत" का अर्थ है शक्तिशाली / लचीला / अभिव्यंजक।

उदाहरण के लिए, हास्केल आपको एक प्रकार परिभाषित करता है जो एक संख्या, एक स्ट्रिंग, इस प्रकार की एक सूची, या इस प्रकार के तार से एक नक्शा है, जो कि JSON से डिकोड किए जा सकने वाली किसी भी चीज़ का प्रतिनिधित्व करने के लिए एक पूरी तरह से तरीका है। जावा में इस प्रकार को परिभाषित करने का कोई तरीका नहीं है। लेकिन कम से कम जावा में पैरामीट्रिक (जेनेरिक) प्रकार होते हैं, इसलिए आप एक फ़ंक्शन लिख सकते हैं जो T की सूची लेता है और यह जानता है कि तत्व टाइप T के हैं; अन्य भाषाओं, जैसे शुरुआती जावा, ने आपको ऑब्जेक्ट की सूची और डाउनकास्ट का उपयोग करने के लिए मजबूर किया। लेकिन कम से कम जावा आपको अपने स्वयं के तरीकों के साथ नए प्रकार बनाने देता है; C केवल आपको संरचनाएँ बनाने देता है। और BCPL के पास भी ऐसा नहीं था। और इसलिए नीचे विधानसभा में, जहां केवल प्रकार अलग-अलग बिट लंबाई हैं।

तो, उस अर्थ में, हास्केल का प्रकार प्रणाली आधुनिक जावा की तुलना में अधिक मजबूत है, जो कि पहले के जावा की तुलना में अधिक मजबूत है, जो सी की तुलना में अधिक मजबूत है, जो बीसीपीएल से अधिक मजबूत है।

तो, पायथन उस स्पेक्ट्रम में कहां फिट बैठता है? यह थोड़ा मुश्किल है। कई मामलों में, बतख टाइपिंग आपको उन सभी चीजों को अनुकरण करने की अनुमति देता है जो आप हास्केल में कर सकते हैं, और यहां तक ​​कि कुछ चीजें जो आप नहीं कर सकते हैं; यकीन है, संकलन समय के बजाय त्रुटियों को रनटाइम पर पकड़ा जाता है, लेकिन वे अभी भी पकड़े गए हैं। हालांकि, ऐसे मामले हैं जहां बतख टाइपिंग पर्याप्त नहीं है। उदाहरण के लिए, हास्केल में, आप बता सकते हैं कि किलों की एक खाली सूची, किलों की एक सूची है, इसलिए आप यह तय कर सकते हैं कि +उस सूची को कम करके 0 * वापस करना चाहिए; पायथन में, एक खाली सूची एक खाली सूची है; आपको यह तय करने में मदद करने के लिए कोई प्रकार की जानकारी नहीं है कि +इसे क्या करना चाहिए।

_{* वास्तव में, हास्केल आपको ऐसा करने नहीं देता है; यदि आप कम फ़ंक्शन को कहते हैं जो एक खाली सूची पर प्रारंभ मूल्य नहीं लेता है, तो आपको एक त्रुटि मिलती है। लेकिन इसका प्रकार प्रणाली काफी शक्तिशाली है कि आप यह काम कर सकते हैं, और पायथन का नहीं है।}

Comments

यह जवाब शानदार है! एक शर्म की बात है कि यह सूची में सबसे नीचे है।

— सिंह 12

आपके C उदाहरण के लिए थोड़ी सी टिप्पणी: char sz[]char के लिए पॉइंटर नहीं है, यह char की सरणी है, और असाइनमेंट में यह पॉइंटर में कम हो जाता है।

— १

Answer 3

आप 'डायनामिक टाइप' के साथ ' दृढ़ता से टाइप' को भ्रमित कर रहे हैं ।

मैं 1स्ट्रिंग जोड़कर के प्रकार को बदल नहीं सकता '12', लेकिन मैं चुन सकता हूं कि मैं चर में किस प्रकार का संग्रह करूं और कार्यक्रम के चलने के समय में इसे बदलूं।

डायनेमिक टाइपिंग के विपरीत स्टेटिक टाइपिंग है; एक कार्यक्रम के जीवनकाल के दौरान परिवर्तनशील प्रकारों की घोषणा नहीं बदलती है। मजबूत टाइपिंग के विपरीत कमजोर टाइपिंग है; एक कार्यक्रम के जीवनकाल के दौरान मूल्यों का प्रकार बदल सकता है।

Comments

लिंक में विवरण दृढ़ता से टाइप किया गया है: "आम तौर पर, एक जोरदार टाइप की गई भाषा में संकलन समय पर सख्त टाइपिंग नियम होते हैं, जिसका मतलब है कि संकलन के दौरान त्रुटियों और अपवादों की संभावना अधिक होती है।" तात्पर्य पायथन एक कमजोर टाइप की भाषा है ..., क्या विकी गलत है?

— बारिश

@ s @e notc̮͔̞ṛ̖̖e̬̣̦t̸͉̥̳̼: यह बिल्कुल निहित नहीं है। संकलन समय में अजगर के सख्त टाइपिंग नियम हैं, बनाई गई प्रत्येक वस्तु का सिर्फ एक प्रकार है। और 'आम तौर पर' कुछ भी मतलब नहीं है, इसका मतलब है कि अजगर इसका अपवाद है।

— मार्टिन पीटर्स

Answer 4

इस विकी पायथन लेख के अनुसार पायथन दोनों गतिशील और दृढ़ता से टाइप किया गया है (एक अच्छी व्याख्या भी प्रदान करता है)।

शायद आप सांख्यिकीय रूप से टाइप की जाने वाली भाषाओं के बारे में सोच रहे हैं, जहां कार्यक्रम निष्पादन के दौरान प्रकार नहीं बदल सकते हैं और संभावित त्रुटियों का पता लगाने के लिए संकलन समय के दौरान प्रकार की जाँच होती है।

यह SO प्रश्न रूचि का हो सकता है: डायनेमिक प्रकार की भाषाएँ बनाम स्थिर प्रकार की भाषाएँ और टाइप सिस्टम पर यह विकिपीडिया लेख अधिक जानकारी प्रदान करता है

Answer 5

TLDR;

पायथन की टाइपिंग डायनामिक है इसलिए आप एक स्ट्रिंग चर को इंट में बदल सकते हैं

x = 'somestring'
x = 50

अजगर टाइपिंग मज़बूत है इसलिए आप प्रकारों का विलय नहीं कर सकते:

'foo' + 3 --> TypeError: cannot concatenate 'str' and 'int' objects

कमजोर टाइप के जावास्क्रिप्ट में ऐसा होता है ...

 'foo'+3 = 'foo3'

---

प्रकार के संबंध में

जावा आपको अपने ऑब्जेक्ट प्रकारों को स्पष्ट रूप से घोषित करने के लिए मजबूर करता है

int x = 50

कोटलिन ने यह महसूस करने के लिए अनुमान का उपयोग किया कि यह एक हैint

x = 50

लेकिन क्योंकि दोनों भाषाएँ स्थैतिक प्रकारों का उपयोग करती हैं, xइसलिए इन्हें बदला नहीं जा सकता int। न तो भाषा की तरह एक गतिशील परिवर्तन की अनुमति होगी

x = 50
x = 'now a string'

Comments

मुझे जावास्क्रिप्ट का विवरण नहीं पता है, लेकिन 'x' + 3हो सकता है कि वह operator+ओवरलोडिंग कर रहा हो और दृश्य के पीछे का प्रकार रूपांतरण कर रहा हो ?

— बारिश हो रही है

वैसे भी, आपका जवाब वास्तव में अधिक संक्षिप्त और समझने में आसान है जो ऊपर वाले की तुलना में है।

— बारिश हो रही है

Answer 6

इसका उत्तर पहले ही कुछ बार दिया जा चुका है, लेकिन पायथन एक जोरदार टाइप की गई भाषा है:

>>> x = 3
>>> y = '4'
>>> print(x+y)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'

जावास्क्रिप्ट में निम्नलिखित:

var x = 3    
var y = '4'
alert(x + y) //Produces "34"

कमजोर टाइपिंग और मजबूत टाइपिंग में यही अंतर है। कमजोर प्रकार संदर्भ के आधार पर स्वचालित रूप से एक प्रकार से दूसरे में बदलने की कोशिश करते हैं (उदाहरण के लिए पर्ल)। मजबूत प्रकार कभी भी रूपांतरित नहीं होते हैं ।

आपका भ्रम इस बात की गलतफहमी में है कि पायथन मूल्यों को नामों से कैसे जोड़ते हैं (आमतौर पर जिन्हें चर कहा जाता है)।

पायथन में, नामों के कोई प्रकार नहीं हैं, इसलिए आप निम्न कार्य कर सकते हैं:

bob = 1
bob = "bob"
bob = "An Ex-Parrot!"

और नाम कुछ भी हो सकते हैं:

>>> def spam():
...     print("Spam, spam, spam, spam")
...
>>> spam_on_eggs = spam
>>> spam_on_eggs()
Spam, spam, spam, spam

आगे पढ़ने के लिए:

https://en.wikipedia.org/wiki/Dynamic_dispatch

और थोड़ा संबंधित लेकिन अधिक उन्नत:

http://effbot.org/zone/call-by-object.htm

Comments

कई वर्षों बाद - एक और उपयोगी और प्रासंगिक संसाधन: youtu.be/_AEJHKGk9ns

— वेन वर्नर

मजबूत बनाम कमजोर टाइपिंग का परिणाम प्रकार के साथ कोई लेना-देना नहीं है जैसे 3 + '4'। इस उदाहरण के लिए जावास्क्रिप्ट पाइथन की तरह ही मजबूत है।

— qznc

@qznc Javasript कैसे मजबूत है? मुझे विश्वास नहीं है कि मैंने इरादा किया है कि इसके परिणामस्वरूप कुछ भी करने के लिए कुछ भी नहीं था, वास्तव में मैं स्पष्ट रूप से स्थिति को कमजोर करता हूं स्वचालित रूप से एक प्रकार से दूसरे में बदलने की कोशिश करता हूं ।

— वेन वर्नर

@oneloop यह सच नहीं है, यह सिर्फ इतना है कि तैरने और स्याही के संयोजन के लिए व्यवहार अच्छी तरह से परिभाषित है, और एक फ्लोट में परिणाम है। आप "3"*4अजगर में भी कर सकते हैं । बेशक, का परिणाम है "3333"। आप यह नहीं कहेंगे कि यह या तो बात को बदल रहा है। ज़ाहिर है कि सिर्फ बहस का तर्क दिया जा सकता है।

— वेन वर्नर

@oneloop यह जरूरी नहीं है कि यह सच है क्योंकि पायथन floatके संयोजन से बाहर निकलता है floatऔर intयह इस प्रकार के निहितार्थ को परिवर्तित कर रहा है। फ्लोट और इंट के बीच एक प्राकृतिक संबंध है, और वास्तव में, प्रकार का उत्तराधिकार बाहर है। मुझे लगता है कि आप बहस कर सकते हैं कि जावास्क्रिप्ट विचार करता है '3'+4और 'e'+4दोनों को उसी तरह से अच्छी तरह से परिभाषित संचालन होना चाहिए जिस तरह से पायथन 3.0 + 4को अच्छी तरह से परिभाषित किया जाता है, लेकिन उस समय वास्तव में मजबूत या कमजोर प्रकार की कोई चीज नहीं है, बस (संयुक्त राष्ट्र) संचालन।

— वेन वर्नर

Answer 7

एक पायथन वैरिएबल लक्ष्य ऑब्जेक्ट के लिए एक अनछुए संदर्भ को संग्रहीत करता है जो मूल्य का प्रतिनिधित्व करता है।

किसी भी असाइनमेंट ऑपरेशन का अर्थ है असाइन किए गए ऑब्जेक्ट के अनछुए संदर्भ को असाइन करना - यानी ऑब्जेक्ट को मूल और नए (उलटी गिनती) संदर्भों के माध्यम से साझा किया जाता है।

मान प्रकार लक्ष्य ऑब्जेक्ट के लिए बाध्य है, संदर्भ मान के लिए नहीं। मान (रन टाइम) के साथ एक ऑपरेशन किया जाता है जब (मजबूत) प्रकार की जाँच की जाती है।

दूसरे शब्दों में, चर (तकनीकी रूप से) का कोई प्रकार नहीं है - यह चर प्रकार के संदर्भ में सोचने का कोई मतलब नहीं है अगर कोई सटीक होना चाहता है। लेकिन संदर्भ स्वचालित रूप से संदर्भित हैं और हम वास्तव में लक्ष्य वस्तु के प्रकार के संदर्भ में सोचते हैं।

Answer 8

"मजबूत टाइपिंग" शब्द की कोई निश्चित परिभाषा नहीं है।

इसलिए, इस शब्द का उपयोग इस बात पर निर्भर करता है कि आप किसके साथ बोल रहे हैं।

मैं किसी भी भाषा पर विचार नहीं करता, जिसमें एक प्रकार का चर या तो स्पष्ट रूप से घोषित नहीं किया गया है, या सांख्यिकीय रूप से दृढ़ता से टाइप किया गया है।

मजबूत टाइपिंग केवल रूपांतरण को रोकती नहीं है (उदाहरण के लिए, "स्वचालित रूप से" पूर्णांक से स्ट्रिंग में परिवर्तित करना)। यह असाइनमेंट को रोकता है (यानी, एक चर के प्रकार को बदलना)।

यदि निम्न कोड संकलित करता है (व्याख्या करता है), भाषा मजबूत टाइप नहीं है:

फू = 1 फू = "1"

एक जोरदार टाइप की गई भाषा में, एक प्रोग्रामर एक प्रकार की "गणना" कर सकता है।

उदाहरण के लिए, यदि कोई प्रोग्रामर घोषणा देखता है,

UINT64 kZarkCount;

और वह जानता है कि 20 पंक्तियों के बाद, kZarkCount अभी भी एक UINT64 है (जब तक कि यह एक ही ब्लॉक में होता है) - बिना हस्तक्षेप कोड की जांच के।

Answer 9

मैंने इसे याद करने के लिए एक शानदार संक्षिप्त तरीका खोजा:

गतिशील / स्थिर टाइपिंग विस्तार; दृढ़ता से / कमजोर टाइप किए गए मूल्य।

Answer 10

मुझे लगता है, यह सरल उदाहरण आपको मजबूत और गतिशील टाइपिंग के बीच के अंतर की व्याख्या करना चाहिए:

>>> tup = ('1', 1, .1)
>>> for item in tup:
...     type(item)
...
<type 'str'>
<type 'int'>
<type 'float'>
>>>

जावा:

public static void main(String[] args) {
        int i = 1;
        i = "1"; //will be error
        i = '0.1'; // will be error
    }

Comments

आपका अजगर कोड डायनामिक टाइपिंग प्रदर्शित करता है जबकि जावा स्टैटिक टाइपिंग प्रदर्शित करता है। एक बेहतर उदाहरण $ var = '2' + 1 // परिणाम 3

— erichlf

@ivleph मैं सहमत हूँ। यह भी कुछ इस तरह से लिखना संभव है: "a" * 3 == "आ"

— दिमित्री ज़गोरुलकिन

Answer 11

class testme(object):
    ''' A test object '''
    def __init__(self):
        self.y = 0

def f(aTestMe1, aTestMe2):
    return aTestMe1.y + aTestMe2.y




c = testme            #get a variable to the class
c.x = 10              #add an attribute x inital value 10
c.y = 4               #change the default attribute value of y to 4

t = testme()          # declare t to be an instance object of testme
r = testme()          # declare r to be an instance object of testme

t.y = 6               # set t.y to a number
r.y = 7               # set r.y to a number

print(f(r,t))         # call function designed to operate on testme objects

r.y = "I am r.y"      # redefine r.y to be a string

print(f(r,t))         #POW!!!!  not good....

ऊपर एक लंबे समय की अवधि में एक बड़ी प्रणाली में अचूक कोड का एक बुरा सपना पैदा करेगा। जिसे आप चाहते हैं उसे कॉल करें, लेकिन एक चर प्रकार को "गतिशील रूप से" बदलने की क्षमता सिर्फ एक बुरा विचार है ...