वेरिएबल और प्रकार

docs.scrimba.com

हर प्रोग्राम को चीजें याद रखनी होती हैं। एक क्विज को खिलाड़ी का नाम चाहिए। एक गेम को वर्तमान स्कोर चाहिए। एक मौसम स्क्रिप्ट को जांचे जाने वाले शहर की जरूरत होती है। Python इसके लिए वेरिएबल का उपयोग करता है: नाम जो आप मानों से जोड़ते हैं ताकि आप उन्हें अपने पूरे प्रोग्राम में उपयोग कर सकें।

वेरिएबल मानों के नाम वाले संदर्भ हैं। Python = के दाईं ओर एक नाम को एक ऑब्जेक्ट से जोड़ता है और आप इसे किसी भी समय पुनः जोड़ सकते हैं। प्रकार नाम पर नहीं, मान पर रहता है।

Python में एक वेरिएबल एक नाम बाइंडिंग है: एक नाम जो एक ऑब्जेक्ट (एक ऑब्जेक्ट कोई भी मान है जो Python मेमोरी में रखता है, जैसे एक स्ट्रिंग या एक संख्या) की ओर इंगित करता है, कभी भी लेबल की गई बॉक्स नहीं जो मान को स्वयं रखता है। प्रकार नाम पर नहीं, ऑब्जेक्ट पर होता है, इसलिए एक नाम एक लाइन पर str की ओर इंगित कर सकता है और अगली लाइन पर int की ओर कोई त्रुटि नहीं। वह स्वतंत्रता गतिशील टाइपिंग कहलाती है: नाम के बारे में कुछ भी सीमित नहीं करता है कि यह किस की ओर इंगित हो सकता है।

player_name = "राज"
score = 0
city = "दिल्ली"

तीन लाइनें, तीन चीजें जो Python अब याद रखता है। प्रत्येक के लिए, Python पहले दाईं ओर का मान निकालता है, फिर इसे बाईं ओर के नाम के तहत संग्रहीत करता है। बाद में उस नाम का उपयोग करें और Python आपको मान वापस देगा।

प्रत्येक लाइन एक बाइंडिंग बनाती है: बाईं ओर का नाम दाईं ओर के ऑब्जेक्ट को संदर्भित करता है। Python पहले दाईं ओर का मूल्यांकन करता है, फिर बाइंडिंग बनाता है।

प्रत्येक असाइनमेंट वर्तमान स्कोप में एक नाम को जोड़ता है (कोड का वह क्षेत्र जहां वह नाम दिखाई देता है, आमतौर पर वह फ़ंक्शन या फ़ाइल जिसमें आप काम कर रहे हैं)। Python हमेशा कुछ भी जोड़ने से पहले पूरी दाईं ओर का काम निकालता है, जो बिल्कुल वही है कि a, b = b, a एक लाइन में दो मानों को क्यों स्वैप करता है: दाईं ओर पूरी तरह से पहले गणना की जाती है, फिर दोनों नाम परिणामों की ओर इंगित होते हैं।

एक मान संग्रहीत करना

= चिन्ह लगभग हर किसी को मैथ क्लास से भ्रमित करता है। Python में, = का अर्थ "बराबर" नहीं है। इसका अर्थ है इस मान को इस नाम के तहत संग्रहीत करें:

city = "दिल्ली"

city को "दिल्ली" मिलता है। आप Python को बता रहे हैं: "दिल्ली" को याद रखें और इसे city लेबल करें।

आप किसी भी समय वेरिएबल का मान बदल सकते हैं। Python सबसे हाल का उपयोग करता है:

score = 0
score = 10   # अब score 10 है
score = 15   # अब score 15 है

= असाइनमेंट है: यह वर्तमान स्कोप में एक नाम को एक ऑब्जेक्ट से जोड़ता है। वेरिएबल को अपडेट करने के लिए एक मानक शॉर्टहैंड ऑग्मेंटेड असाइनमेंट है:

score = 0
score += 10   # जैसा: score = score + 10
score *= 2    # जैसा: score = score * 2

आप एक बार में कई नामों को भी जोड़ सकते हैं:

x, y, z = 1, 2, 3
a = b = 0        # दोनों शून्य से शुरू होते हैं

असाइनमेंट एक नाम को एक ऑब्जेक्ट की ओर इंगित करता है; यह कभी भी मान को एक नए कंटेनर में कॉपी नहीं करता। इसलिए दो नाम एक ही ऑब्जेक्ट की ओर इंगित कर सकते हैं:

a = "hello"
b = a
print(id(a) == id(b))   # True (दोनों नाम एक ऑब्जेक्ट की ओर इंगित करते हैं)

b = "world"             # b को एक नए ऑब्जेक्ट की ओर पुनः जोड़ा गया
print(id(a) == id(b))   # False
print(a)                # अभी भी "hello": b को पुनः जोड़ने ने a को प्रभावित नहीं किया

id() एक ऑब्जेक्ट की पहचान देता है, एक संख्या जो उस एक ऑब्जेक्ट के लिए जब तक यह मौजूद है अद्वितीय है, इसलिए दो बराबर आईडी का अर्थ है "शाब्दिक रूप से एक ही ऑब्जेक्ट", दो ऑब्जेक्ट नहीं जो होने के लिए होते हैं समान। पॉइंटिंग और कॉपीइंग के बीच का अंतर अब अनदेखा करने के लिए लुभावना है, लेकिन यह मutable ऑब्जेक्ट्स (जो आप जगह में बदल सकते हैं, जैसे सूचियां) के साथ काटता है: दो नामों को एक सूची की ओर इंगित करें, इसे किसी भी नाम के माध्यम से बदलें, और परिवर्तन दोनों में दिखाई देता है। सूचियां और डिक्ट्स बाद के अध्यायों में इसे ठोस बनाते हैं।

एक प्रकार एनोटेशन उस प्रकार को रिकॉर्ड करता है जो आप एक नाम को रखने की अपेक्षा करते हैं। यह उन उपकरणों के लिए एक नोट है जो आपके कोड को इसे चलाए बिना पढ़ते हैं (प्रकार चेकर्स और आपका संपादक), और Python स्वयं इसे अनदेखा करता है जब प्रोग्राम चलता है:

name: str = "राज"
score: int = 0
ratio: float = 0.85

Junoएक मान संग्रहीत करना= मैथ क्लास "बराबर" नहीं है, यह "इस मान को इस नाम के तहत छिपाएं" है। इसे कभी भी बदलें और Python सबसे नए को रखता है। कोई घोषणा नहीं, कोई सेटअप नहीं, आप इसे नाम देते हैं और यह मौजूद है। मुझे इसे ओवरथिंक करना बंद करने में बहुत समय लगा।

Junoएक मान संग्रहीत करना= एक नाम को एक मान की ओर इंगित करता है, और आप इसे किसी भी समय पुनः इंगित कर सकते हैं। नाम लेबल है, मान चीज़ है। बस इतना ही।

Junoएक मान संग्रहीत करना= एक बॉक्स में मान डालता नहीं है, यह एक नाम को एक ऑब्जेक्ट से बांधता है। पुनः असाइन करने से केवल नाम चलता है, पुरानी ऑब्जेक्ट जगह पर रहती है। सूचियां दिखाई देने से पहले इसे याद रखें, या आपके पास दो नाम चुपचाप एक को साझा करेंगे।

अपने वेरिएबल का नाम रखना

आप नाम चुनते हैं। Python के पास कुछ कठोर नियम हैं, और समुदाय ऐसी परंपराओं का पालन करता है जो पहले दिन से अपनाने योग्य हैं। स्पष्ट नाम कोड को सप्ताह बाद पढ़ने योग्य बनाते हैं। क्रिप्टिक नाम दर्द का कारण बनते हैं।

Python एक छोटे से आइडेंटिफायर सिंटैक्स नियमों को लागू करता है। उन से परे, PEP 8 परंपराएं हर Python कोडबेस और उपकरण में डी फैक्टो मानक हैं।

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

नियम Python लागू करता है:

• केवल अक्षर, अंक और अंडरस्कोर। कोई स्पेस या हाइफ़न नहीं।
• एक अक्षर या अंडरस्कोर से शुरू होना चाहिए, कभी अंक से नहीं
• केस-संवेदनशील: score, Score, और SCORE तीन अलग-अलग वेरिएबल हैं

परंपराएं सभी अनुसरण करते हैं (PEP 8):

चीज़	शैली	उदाहरण
वेरिएबल और फंक्शन	snake_case	user_name, total_price
स्थिरांक	UPPER_SNAKE_CASE	MAX_RETRIES, BASE_URL
क्लास	PascalCase	UserAccount, DataLoader

# स्पष्ट नाम, एक नज़र में पठनीय
user_name = "राज"
total_price = 49.99
is_logged_in = True
MAX_RETRIES = 3

# आप इन पर एक घंटे में पछताएंगे
x = "राज"
tp = 49.99
b = True

एक जाल जल्दी जानने लायक है: Python बिल्ट-इन जैसे list, input, type, या print के बाद वेरिएबल का नाम न रखें। Python इसे अनुमति देता है, लेकिन आप चुप से बिल्ट-इन को उस स्कोप के बाकी के लिए तोड़ देंगे और परिणामी त्रुटियां ट्रेस करने के लिए कठिन हैं।

Python के बिल्ट-इन को शैडो न करें। list, type, input, print, या str को असाइन करने से कोई चेतावनी के बिना बाकी स्कोप के लिए बिल्ट-इन को अधिलेखित करता है। यह एक चुप बग है जो खोजने के लिए दर्दनाक हो सकता है।

UPPER_SNAKE_CASE एक परंपरा है, लागू नहीं। Python आपको बाद में MAX_RETRIES = 99 को पुनः असाइन करने से नहीं रोकेगा। यह अन्य डेवलपर्स के लिए एक संकेत है, कुछ नहीं।

शैडोइंग एक बिल्ट-इन का अर्थ है अपना नाम बनाना जो एक Python पहले से प्रदान करता है (जैसे list)। जब Python एक नाम की तलाश करता है, तो यह अपने स्थानीय नामों को अपने स्वयं के बिल्ट-इन से पहले जांचता है, इसलिए आपका संस्करण जीतता है और असली list उस बिंदु से छिपा होता है। यह अभी भी builtins.list के रूप में पहुंचने योग्य है, लेकिन साधारण कोड इसे अब नहीं देखता है। स्थिरांकों के लिए, UPPER_SNAKE_CASE केवल एक दृश्य संकेत है; Python इसे खुशी से पुनः असाइन करने देगा। यदि आप एक स्थिरांक चाहते हैं जो एक उपकरण वास्तव में लागू कर सकता है, तो इसे typing.Final के साथ एनोटेट करें, जो नाम को "पुनः असाइन नहीं किया जाना है" के रूप में चिह्नित करता है ताकि यदि आप ऐसा करते हैं तो प्रकार चेकर इसे फ़्लैग करेंगे।

Junoअपने वेरिएबल का नाम रखना अक्षर, संख्या, अंडरस्कोर, और एक अक्षर या अंडरस्कोर से शुरू करें। snake_case के लिए रहें और आप बिल्कुल ठीक हैं। मेरी एक नौसिखिया गलती: किसी वेरिएबल को list या print न कहें। Python इसे अनुमति देता है, फिर बाद में शून्य चेतावनी के साथ सब कुछ विचित्र हो जाता है।

Junoअपने वेरिएबल का नाम रखना नामों के लिए snake_case, स्थिरांकों के लिए UPPER_SNAKE_CASE, हर उपकरण इसकी अपेक्षा करता है। और चीजों को list या print न नाम दें, आप चुप से बिल्ट-इन को ख़त्म कर देंगे।

Junoअपने वेरिएबल का नाम रखना दुभाषिया शायद ही नामकरण को लागू करता है, लेकिन हर लिंटर करता है, इसलिए snake_case से लड़ना केवल आपको दु:ख अर्जित करता है। असली जाल एक बिल्ट-इन को शैडो करना है जैसे list: यह चुप से टूटता है, और जहां आपने इसे किया वहां से दूर।

आप क्या संग्रहीत कर सकते हैं

Python के पास चार प्रकार हैं जिनका आप लगभग हर प्रोग्राम में उपयोग करेंगे। Python यह पता लगाता है कि आप किस प्रकार का अर्थ रखते हैं कि आप मान कैसे लिखते हैं। आप कभी भी एक प्रकार को स्पष्ट रूप से घोषित नहीं करते।

Python शाब्दिक सिंटैक्स से प्रकार को निकालता है। ये चार प्रकार मौलिक मान स्थान को कवर करते हैं; भाषा में बाकी सब कुछ इन पर निर्मित है।

Python में हर मान एक पूर्ण ऑब्जेक्ट है, यहां तक ​​कि एक literal (कोड में सीधे लिखा गया मान, जैसे 42 या "hi")। एक ऑब्जेक्ट होने का अर्थ है कि मान अपने स्वयं के तरीके (इससे जुड़े फंक्शन) ले जाता है, इसलिए "hi".upper() और (3).bit_length() सीधे शाब्दिक पर काम करते हैं, कुछ भी लपेटने या अनलपेट करने की जरूरत नहीं है। आप शायद ही कभी इसके बारे में सोचते हैं, और यह बात है। नीचे दिए गए चार प्रकार वे हैं जिनका आप लगभग हर प्रोग्राम में उपयोग करते हैं।

पाठ (str)

कोई भी पाठ उद्धरण चिह्नों में जाता है, एकल या दोहरे। उद्धरण चिह्न Python को बताते हैं कि आप शाब्दिक वर्णों का मतलब रखते हैं, न कि एक वेरिएबल नाम। एक बार बनने के बाद, एक स्ट्रिंग को जगह में नहीं बदला जा सकता। स्ट्रिंग्स अध्याय सब कुछ कवर करता है जो आप उनके साथ कर सकते हैं।

player_name = "राज"
city = "दिल्ली"
message = 'खेल खत्म'

यदि आपके पाठ में एक एपोस्ट्रॉफ है, तो इसे से बचने के लिए डबल उद्धरण चिह्नों का उपयोग करें:

note = "यह एक बढ़िया दिन है"
note = 'यह एक बढ़िया दिन है'   # एक एस्केप का उपयोग करके समान परिणाम

स्ट्रिंग्स एकल या दोहरे उद्धरण चिह्नों में कोई भी पाठ रखती हैं। वे अपरिवर्तनीय हैं: कोई भी ऑपरेशन एक स्ट्रिंग को जगह में संशोधित नहीं करता है; हर परिवर्तन एक नया रिटर्न करता है। यह प्रदर्शन के लिए मायने रखता है: एक लूप के अंदर दोहराया + हर कदम पर एक नई स्ट्रिंग ऑब्जेक्ट बनाता है। स्ट्रिंग्स अध्याय कुशल विकल्प को कवर करता है।

player_name = "राज"
city = "दिल्ली"
note = "यह एक बढ़िया दिन है"

एक str यूनिकोड कोड पॉइंट्स का एक अपरिवर्तनीय अनुक्रम है (अपरिवर्तनीय का अर्थ है कि इसे बनाने के बाद कभी भी नहीं बदला जा सकता है; कोड पॉइंट्स स्वयं वर्ण हैं, वे कच्चे बाइट नहीं हैं जो वे संग्रहीत हो जाते हैं), इसलिए len("cafe") 4 है, 5 नहीं। क्योंकि एक स्ट्रिंग नहीं बदल सकती है, यह हैशेबल है और एक शब्दकोश कुंजी या सेट सदस्य (एक मान जो कभी नहीं बदलता है) के रूप में उपयोग किया जा सकता है इसे अपनी सामग्री के द्वारा सुरक्षित रूप से दायर किया जा सकता है। एक नियम जो आप वास्तव में उपयोग करेंगे: == (समान वर्ण) के साथ स्ट्रिंग्स की तुलना करें, कभी is (मेमोरी में एक ही ऑब्जेक्ट) नहीं, क्योंकि क्या दो बराबर स्ट्रिंग्स एक ऑब्जेक्ट साझा करती हैं यह एक कार्यान्वयन विवरण है जिस पर आप भरोसा नहीं कर सकते।

player_name = "राज"
city = "दिल्ली"
note = "यह एक बढ़िया दिन है"

Junoपाठ (str) पाठ उद्धरण चिह्नों में जाता है, एकल या दोहरे, आपकी पसंद। एक बार यह मौजूद होने के बाद आप इसे जगह में नहीं बदल सकते, और यह ठीक है। कुछ भी जो एक स्ट्रिंग को संपादित करते हुए दिखता है वह वास्तव में आपको एक ब्रांड-नई वापस देता है।

Junoपाठ (str) स्ट्रिंग्स अपरिवर्तनीय हैं। कुछ भी उन्हें जगह में संपादित नहीं करता है, आप हमेशा एक नई स्ट्रिंग वापस पाते हैं। आप विधियों को चेन करना शुरू करने के समय यह ध्यान में रखें।

Junoपाठ (str) एक अपरिवर्तनीय यूनिकोड का रन, इसलिए `len("cafe")` 4 है और स्ट्रिंग्स डिक्ट कुंजी के रूप में काम करती हैं। बिट जो आप वास्तव में उपयोग करेंगे: `==` के साथ तुलना करें, कभी `is` नहीं।

पूर्ण संख्याएं (int)

पूर्ण संख्याएं बिना उद्धरण चिह्न या दशमलव बिंदु के जाती हैं। Python उन्हें पूर्णांक कहता है। वे जितनी बड़ी हो सकती हैं; Python आपकी ओर से कोई विशेष प्रयास किए बिना मनमाने ढंग से बड़ी संख्याओं को संभालता है।

score = 0
age = 28
population = 8_100_000_000   # अंडरस्कोर केवल पठनीयता के लिए हैं

पूर्णांक बिना उद्धरण चिह्न या दशमलव बिंदु के लिखे गए हैं। Python पूर्णांक मनमाने सटीकता हैं: वे किसी भी मान को रखने के लिए बढ़ते हैं, C या Java में 32- या 64-बिट फिक्स्ड-साइज़ पूर्णांकों के विपरीत। संख्यात्मक literals में अंडरस्कोर कॉस्मेटिक हैं और Python द्वारा अनदेखा किए जाते हैं।

score = 0
age = 28
population = 8_100_000_000

दो चीजें ध्यान देने योग्य हैं। पहला, Python का int मनमाना-सटीकता है: यह किसी भी पूर्ण संख्या को रखने के लिए बढ़ता है जो आपका RAM फिट कर सकता है, इसलिए कोई ओवरफ़्लो (रैप-अराउंड या त्रुटि जो आप फिक्स्ड-साइज़ पूर्णांकों के साथ भाषाओं में मारते हैं) नहीं है। दूसरा, == (समान मान) के साथ संख्याओं की तुलना करें, कभी is (एक ही ऑब्जेक्ट) नहीं। क्या दो बराबर ints एक ऑब्जेक्ट हैं यह एक कार्यान्वयन विवरण है: CPython (मानक Python) छोटे पूर्णांकों को पुनः उपयोग करता है, इसलिए id(1) == id(1) True है, लेकिन यह बड़ी संख्याओं के लिए शांति से रोकता है, इसलिए कभी भी इसके ऊपर निर्माण न करें।

score = 0
age = 28
population = 8_100_000_000

Junoपूर्ण संख्याएं (int) पूर्ण संख्याएं, कोई उद्धरण नहीं, कोई दशमलव बिंदु नहीं। सर्वश्रेष्ठ भाग, Python ints जितना बड़ा चाहते हैं कोई विचित्र ओवरफ़्लो के साथ बढ़ते हैं। 8_100_000_000 में अंडरस्कोर केवल इसलिए हैं ताकि आप इसे पढ़ सकें।

Junoपूर्ण संख्याएं (int) Ints मनमाना-सटीकता हैं, इसलिए ओवरफ़्लो के बारे में चिंता न करें। संख्याओं में अंडरस्कोर कॉस्मेटिक हैं, कुछ भी अंक के साथ उपयोग करते हैं।

Junoपूर्ण संख्याएं (int) Ints तब तक बढ़ते हैं जब तक आप RAM से बाहर न निकलें, इसलिए ओवरफ़्लो एक गैर-समस्या है। एक आदत जिसे रखने लायक है: `==` के साथ संख्याओं की तुलना करें, `is` नहीं। पहचान एक कैशिंग तरकीब है, इस पर न झुकें।

दशमलव संख्याएं (float)

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

price = 4.99
temperature = 36.6

0.1 + 0.2   # 0.30000000000000004

रोज़मर्रा के काम के लिए यह शायद ही कभी मायने रखता है। वित्तीय गणनाओं के लिए जहां सेंट के अंश गिनते हैं, Python के पास एक decimal मॉड्यूल है जो इसे सही ढंग से संभालता है। यह नंबर्स अध्याय में कवर किया गया है।

कोई भी संख्या जिसमें दशमलव बिंदु है एक float बन जाता है। Python floats दोहरी-सटीकता हैं: लगभग 15 से 17 महत्वपूर्ण अंक, बाइनरी में संग्रहीत। वह बाइनरी स्टोरेज प्रसिद्ध पकड़ है: 0.1 + 0.2 0.30000000000000004 है, एक Python बग नहीं बल्कि इसका परिणाम है कि बाइनरी दशमलव का प्रतिनिधित्व कैसे करता है। पैसे के लिए, या कहीं भी सटीक दशमलव मायने रखता है, Python के decimal मॉड्यूल तक पहुंचें, नंबर्स अध्याय में कवर किया गया।

price = 4.99
temperature = 36.6

Floats बाइनरी (बेस 2) में संग्रहीत होते हैं, और अधिकांश दशमलव अंश, कुछ भी जिसका भाजक दो की शक्ति नहीं है (जैसे 1/10), बाइनरी में बिल्कुल नहीं लिखा जा सकता। 0.1 + 0.2 0.30000000000000004 के रूप में आने से यही आता है। नियम जो उत्पादन में मायने रखता है: पैसे के लिए कभी float का उपयोग न करें, या कुछ भी जिसे आप सटीक समानता के लिए जांचेंगे। सटीक बेस-10 अंकगणित की जरूरत होने पर decimal.Decimal तक पहुंचें, या सटीक अनुपातों के लिए fractions.Fraction। दोनों Python के मानक पुस्तकालय (Python के साथ बंडल किए गए उपकरण) के साथ आते हैं, मॉड्यूल्स अध्याय में कवर किया गया।

price = 4.99
temperature = 36.6

Junoदशमलव संख्याएं (float) एक दशमलव बिंदु इसे एक float बनाता है, और वे रोज़मर्रा की चीजों के लिए ठीक हैं। शास्त्रीय गॉचा जो हर कोई एक बार मारता है: 0.1 + 0.2 0.30000000000000004 देता है। एक बग नहीं, यह बाइनरी है। पैसे के लिए, decimal.Decimal तक पहुंचें।

Junoदशमलव संख्याएं (float) Floats बाइनरी हैं, इसलिए कुछ दशमलव बिल्कुल नहीं हो सकते, 0.1 + 0.2 काफी 0.3 नहीं है। अधिकांश मैथ के लिए ठीक है, पैसे के लिए कभी नहीं। सटीक होने की जरूरत होने पर decimal.Decimal का उपयोग करें।

Junoदशमलव संख्याएं (float) Floats बहते हैं, इसलिए 0.1 + 0.2 टूटा दिखता है। नियम: पैसे या सटीक-समानता जांच के लिए कोई floats नहीं। सटीक बेस-10 के लिए decimal.Decimal, अनुपातों के लिए fractions.Fraction।

सच या गलत (bool)

कुछ चीजें चालू या बंद होती हैं। Python इसके लिए booleans का उपयोग करता है: बिल्कुल दो मान, True और False। वे इस चरण में मामूली दिखते हैं, लेकिन आपके प्रोग्राम में हर स्थिति और शाखा एक बूलियन पर चलती है।

is_logged_in = True
has_errors = False

Python कुछ मानों को भी इलाज करता है जैसे कि वे False थे जब किसी स्थिति में उपयोग किए गए हों: 0, 0.0, "", और None (Python का "कोई मान नहीं") सभी False की तरह व्यवहार करते हैं। बाकी सब कुछ True की तरह व्यवहार करता है। यह नियंत्रण प्रवाह अध्याय में उपयोगी हो जाता है।

bool बिल्कुल True या False रखता है। इसे तुलनाओं द्वारा रिटर्न किया जाता है और शर्तों द्वारा खपत किया जाता है। Python के पास truthy और falsy मानों का एक व्यापक समूह है: शून्य मान, खाली कंटेनर, और None falsy हैं; बाकी सब कुछ truthy है। एक उपयोगी विवरण: bool एक int का एक उपवर्ग है, इसलिए True + True 2 का मूल्यांकन करता है।

is_logged_in = True
has_errors = False

bool int के शीर्ष पर बनाया गया है (यह इसे subclasses, इसका मतलब है कि यह एक विशेष तरह का int है), और True और False केवल दो bool ऑब्जेक्ट हैं जो कभी भी मौजूद हैं, क्रमशः 1 और 0 के लायक। एक शर्त में, falsy मान (जो गलत के रूप में गिनते हैं) हैं: शून्य (0, 0.0), खाली कंटेनर ("", [], (), {}), None, और False स्वयं। बाकी सब कुछ truthy है। आपकी स्वयं की क्लासें __bool__ या __len__ (विशेष "dunder" विधियां, दोहरी अंडरस्कोर के साथ नाम, जो Python हां-या-नहीं उत्तर की जरूरत होने पर कॉल करता है) को परिभाषित करके अपनी truthiness तय कर सकती हैं। और क्योंकि bool एक int है, isinstance(True, int) True है, जो कोड में आप जो प्रकार जांचते हैं उसे पकड़ सकता है।

is_logged_in = True
has_errors = False

Junoसच या गलत (bool) दो मान, True और False, और वे हर if के पीछे हैं जो आप कभी लिखेंगे। मजेदार बिट: 0, "", [] और None सभी False के रूप में गिनते हैं, बाकी सब कुछ True के रूप में गिनता है।

Junoसच या गलत (bool)bool तुलनाओं से True/False है। Python के पास truthy और falsy भी है: खाली सामान, शून्य और None falsy हैं। यही कारण है कि if my_list: इतना अच्छा पढ़ता है।

Junoसच या गलत (bool)bool चुपचाप एक `int` है, इसलिए `isinstance(True, int)` `True` है, जो एक दिन प्रकार की जांच में आपको आश्चर्य देगा। Falsy शून्य, खाली है और `None`। कस्टम ऑब्जेक्ट्स __bool__ या __len__ के साथ अपनी truthiness चुनते हैं।

प्रकार की जांच और रूपांतरण

जब आप निश्चित नहीं हैं कि किसी मान का प्रकार क्या है, तो type() आपको बताता है। यह जांचने के लिए कि क्या कोई मान एक विशिष्ट प्रकार है, isinstance() अधिक विश्वसनीय उपकरण है:

print(type("hello"))   # <class 'str'>
print(type(42))        # <class 'int'>
print(type(3.14))      # <class 'float'>
print(type(True))      # <class 'bool'>

isinstance(42, int)    # True
isinstance("hi", str)  # True

type() किसी ऑब्जेक्ट के सटीक प्रकार को रिटर्न करता है। अपने स्वयं के कोड में प्रकार की जांच के लिए, isinstance() पसंद किया जाता है: यह विरासत को संभालता है, जो type() तुलना नहीं करती है।

print(type(42))          # <class 'int'>
isinstance(True, int)    # True   (bool int का एक उपवर्ग है)
type(True) == int        # False  (सटीक मिलान केवल, कोई उपवर्ग नहीं)

type(x) आपको x का सटीक प्रकार देता है। isinstance(x, T) अधिक करता है: यह MRO (method resolution order, classes की क्रमबद्ध सूची जिसे Python विरासत श्रृंखला के ऊपर खोज करता है, पैरेंट प्रकारों की लाइन एक वर्ग जो x.__class__.__mro__ के रूप में उजागर होता है) को चलाता है, इसलिए यह पैरेंट प्रकारों के लिए भी True रिटर्न करता है। यह कारण है कि isinstance(True, int) True है (एक bool एक तरह का int है) जबकि type(True) == int False है (एक सटीक-मिलान जांच)। वास्तविक कोड में, isinstance() आपके प्रकार गार्ड के लिए पहुंचें, वह जांच जो पुष्टि करती है कि एक मान वह प्रकार है जो आप इसे उपयोग करने से पहले अपेक्षा करते हैं।

isinstance(True, int)    # True
type(True) == int        # False

Python प्रकारों को स्वचालित रूप से मिश्रण नहीं करता। एक स्ट्रिंग और एक संख्या को जोड़ना एक TypeError उठाता है:

score = 42
print("आपका स्कोर है " + score)        # TypeError
print("आपका स्कोर है " + str(score))   # काम करता है

प्रकार नाम का उपयोग करके स्पष्ट रूप से परिवर्तित करें एक फंक्शन के रूप में:

कॉल	परिणाम
str(42)	"42"
int(3.9)	3 (ट्रंकेट करता है, गोल नहीं करता)
float("3.14")	3.14
int("3.14")	ValueError: एक दशमलव स्ट्रिंग को सीधे int में परिवर्तित नहीं किया जा सकता है
int(float("3.14"))	3 (पहले float में बदलें, फिर int में)
bool(0) / bool("")	False

Junoप्रकार की जांच और रूपांतरणtype() बताता है कि कुछ क्या है, isinstance() जांचता है कि क्या यह दिया गया प्रकार है। और Python एक स्ट्रिंग और एक संख्या को एक साथ गोंद नहीं देगा, इसलिए पहले `str()` या `int()` से परिवर्तित करें। हर कोई एक बार इस पर ठोकर खाता है।

Junoप्रकार की जांच और रूपांतरण `type() ==` पर `isinstance()` तक पहुंचें, यह विरासत का सम्मान करता है। रूपांतरण हमेशा स्पष्ट होते हैं, इसलिए एक स्ट्रिंग और एक संख्या को जोड़ने से पहले परिवर्तित करें।

Junoप्रकार की जांच और रूपांतरण `isinstance()` आपका प्रकार गार्ड है, यह वर्ग के पेड़ का अनुसरण करता है जहां `type(x) == T` केवल बिल्कुल मेल खाता है। रूपांतरण उद्देश्य पर स्पष्ट रहते हैं, `int("3.14")` बजाय अनुमान लगाने के बजाय उठाने के लिए पसंद करता है, इसलिए पहले `float` के माध्यम से जाएं।

व्यावहारिक रूप से

सभी चार प्रकार एक छोटी स्क्रिप्ट में एक साथ काम करते हैं। आउटपुट लाइनें f-strings का उपयोग करती हैं पाठ में मान एम्बेड करने के लिए: उद्घाटन उद्धरण से पहले f रखें और किसी भी वेरिएबल को {} में लपेटें। Python इसे वेरिएबल के वास्तविक मान से बदल देता है। आप उन्हें अगले अध्याय में ठीक से सीखेंगे।

player_name = "राज"
level = 3
accuracy = 0.94
is_premium = True

print(f"{player_name} स्तर {level} पर है {accuracy:.0%} सटीकता के साथ।")
print(f"प्रीमियम खाता: {is_premium}")

प्रकार मायने रखते हैं क्योंकि level + 1 काम करता है और player_name + 1 नहीं करता है। हर वेरिएबल बिल्कुल एक तरह की चीज़ रखता है; Python आपके लिए चुपचाप उन्हें मिश्रण नहीं करेगा।

सभी चार प्रकारों के साथ एक यथार्थवादी कॉन्फ़िग ब्लॉक, रनटाइम राज्य से अलग स्थिरांक। f"..." सिंटैक्स एक f-string है: {} के अंदर कोई भी अभिव्यक्ति रनटाइम पर मूल्यांकन की जाती है और आउटपुट में एम्बेड की जाती है। आउटपुट और इनपुट अध्याय में पूरी तरह से कवर किया गया।

BASE_URL = "https://api.example.com"
MAX_RETRIES = 3
DEBUG = False

user_name = "राज"
request_count = 0
last_response = None

request_count += 1
print(f"[{request_count}] {BASE_URL} | debug={DEBUG}")

None "कोई मान अभी तक नहीं" के लिए मानक प्लेसहोल्डर है। इसका प्रकार NoneType है और यह शर्तों में falsy के रूप में व्यवहार करता है। इसे वेरिएबल के लिए डिफ़ॉल्ट के रूप में उपयोग करें जो प्रोग्राम में बाद तक अर्थपूर्ण नहीं हैं।

समान कॉन्फ़िग, अब इनलाइन प्रकार एनोटेशन के साथ। एक एनोटेशन उस प्रकार को रिकॉर्ड करता है जो आप एक नाम को रखने की अपेक्षा करते हैं। यह प्रकार चेकर्स और आपके संपादक (IDE) के लिए मौजूद है, और Python इसे अनदेखा करता है जब प्रोग्राम चलता है:

BASE_URL: str = "https://api.example.com"
MAX_RETRIES: int = 3
DEBUG: bool = False

user_name: str = "राज"
request_count: int = 0
last_response: str | None = None

str | None एक union प्रकार है, Python 3.10 में जोड़ा गया: यह कहता है कि मान या तो एक स्ट्रिंग या None है। पुराने संस्करणों पर आप typing मॉड्यूल से आयातित Optional[str] के रूप में एक ही चीज़ लिखते हैं। str | None फॉर्म है कि आधुनिक Python में पसंद करना है जब भी आपका न्यूनतम संस्करण इसे अनुमति देता है।