अजगर - चर प्रकार

वैरिएबल मूल्यों को संग्रहीत करने के लिए आरक्षित मेमोरी स्थानों के अलावा कुछ भी नहीं हैं। इसका मतलब यह है कि जब आप एक चर बनाते हैं तो आप स्मृति में कुछ स्थान आरक्षित करते हैं।

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

चर को मान देना

पायथन चरों को मेमोरी स्पेस आरक्षित करने के लिए स्पष्ट घोषणा की आवश्यकता नहीं है। जब आप किसी वैरिएबल को मान देते हैं तो घोषणा स्वतः ही हो जाती है। समान चिह्न (=) का उपयोग चर को मान निर्दिष्ट करने के लिए किया जाता है।

= ऑपरेटर के बाईं ओर वाला ऑपरेटर चर का नाम है और ऑपरेटर के दाईं ओर का ऑपरेटर = चर में संग्रहीत मूल्य है। उदाहरण के लिए -

#!/usr/bin/python

counter = 100          # An integer assignment
miles   = 1000.0       # A floating point
name    = "John"       # A string

print counter
print miles
print name

यहाँ, 100, 1000.0 और "जॉन" क्रमशः काउंटर , मील और नाम चर के लिए निर्दिष्ट मान हैं। यह निम्न परिणाम उत्पन्न करता है -

100
1000.0
John

एकाधिक असाइनमेंट

अजगर आपको एक साथ कई चर के लिए एक ही मूल्य आवंटित करने की अनुमति देता है। उदाहरण के लिए -

a = b = c = 1

यहां, मान 1 के साथ एक पूर्णांक ऑब्जेक्ट बनाया जाता है, और सभी तीन चर एक ही मेमोरी स्थान पर असाइन किए जाते हैं। आप कई ऑब्जेक्ट्स को कई वेरिएबल्स में भी असाइन कर सकते हैं। उदाहरण के लिए -

a,b,c = 1,2,"john"

यहां, मान 1 और 2 के साथ दो पूर्णांक ऑब्जेक्ट क्रमशः चर और बी को असाइन किए जाते हैं, और मूल्य "जॉन" के साथ एक स्ट्रिंग ऑब्जेक्ट चर सी को सौंपा जाता है।

मानक डेटा प्रकार

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

अजगर के पाँच मानक डेटा प्रकार हैं -

Numbers
String
List
Tuple
Dictionary

पायथन संख्या

संख्या डेटा प्रकार संख्यात्मक मानों को संग्रहीत करते हैं। जब आप उनके लिए कोई मान निर्दिष्ट करते हैं तो नंबर ऑब्जेक्ट बनाए जाते हैं। उदाहरण के लिए -

var1 = 1
var2 = 10

आप डेल स्टेटमेंट का उपयोग करके किसी नंबर ऑब्जेक्ट के संदर्भ को हटा भी सकते हैं। डेल स्टेटमेंट का सिंटैक्स है -

del var1[,var2[,var3[....,varN]]]]

आप डेल स्टेटमेंट का उपयोग करके किसी एकल ऑब्जेक्ट या कई ऑब्जेक्ट को हटा सकते हैं। उदाहरण के लिए -

del var
del var_a, var_b

अजगर चार विभिन्न संख्यात्मक प्रकारों का समर्थन करता है -

int (हस्ताक्षरित पूर्णांक)
लंबे (लंबे पूर्णांक, इन्हें अष्टक और षोडश आधारी में भी दर्शाया जा सकता है)
फ्लोट (अस्थायी बिंदु वास्तविक मूल्य)
जटिल (जटिल संख्या)

उदाहरण

यहां संख्याओं के कुछ उदाहरण दिए गए हैं -

पूर्णांक	लंबा	नाव	जटिल
10	51924361L	0.0	3.14j
100	-0x19323L	15.20	45.j
-786	0122L	-21.9	9.322e-36j
080	0xDEFABCECBDAECBFBAEl	32.3 + E18	.876j
-0490	535633629843L	-90।	-.6545 + 0J
-0x260	-052318172735L	-32.54e100	3E + 26J
0x69	-4721885298529L	70.2-E12	4.53e-7J

पायथन आपको लंबे समय तक एक लोअरकेस एल का उपयोग करने की अनुमति देता है, लेकिन यह अनुशंसा की जाती है कि आप संख्या के साथ भ्रम से बचने के लिए केवल एक अपरकेस एल का उपयोग करें। पायथन एक अपरकेस एल के साथ लंबे पूर्णांक प्रदर्शित करता है।
एक जटिल संख्या में x + yj द्वारा निरूपित वास्तविक फ्लोटिंग-पॉइंट संख्याओं का एक आदेशित युग्म होता है, जहाँ x और y वास्तविक संख्याएँ हैं और j काल्पनिक इकाई है।

पायथन स्ट्रिंग्स

पायथन में स्ट्रिंग्स की पहचान उद्धरण चिह्नों में दर्शाए गए पात्रों के एक आकस्मिक सेट के रूप में की जाती है। अजगर एकल या दोहरे उद्धरणों के जोड़े के लिए अनुमति देता है। स्ट्रिंग की शुरुआत में 0 से शुरू होने वाले और अंत में -1 से अपने तरीके से काम करने वाले इंडेक्स वाले स्लाइस ऑपरेटर ([] और [:]) का उपयोग करके स्ट्रिंग्स के सबस्क्रिप्शन लिए जा सकते हैं।

प्लस (+) चिन्ह स्ट्रिंग कॉन्फेंशन ऑपरेटर है और तारांकन चिह्न (*) दोहराव ऑपरेटर है। उदाहरण के लिए -

#!/usr/bin/python

str = 'Hello World!'

print str          # Prints complete string
print str[0]       # Prints first character of the string
print str[2:5]     # Prints characters starting from 3rd to 5th
print str[2:]      # Prints string starting from 3rd character
print str * 2      # Prints string two times
print str + "TEST" # Prints concatenated string

यह निम्नलिखित परिणाम का उत्पादन करेगा -

Hello World!
H
llo
llo World!
Hello World!Hello World!
Hello World!TEST

पायथन लिस्ट्स

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

सूची में संग्रहीत मानों को स्लाइस ऑपरेटर ([] और [:]) के साथ सूची की शुरुआत में 0 पर शुरू होने वाले इंडेक्स के साथ एक्सेस किया जा सकता है और -1 को समाप्त करने के लिए अपने तरीके से काम कर सकता है। प्लस (+) चिह्न सूची संघनक ऑपरेटर है, और तारांकन चिह्न (*) दोहराव ऑपरेटर है। उदाहरण के लिए -

#!/usr/bin/python

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']

print list          # Prints complete list
print list[0]       # Prints first element of the list
print list[1:3]     # Prints elements starting from 2nd till 3rd 
print list[2:]      # Prints elements starting from 3rd element
print tinylist * 2  # Prints list two times
print list + tinylist # Prints concatenated lists

यह निम्न परिणाम उत्पन्न करता है -

['abcd', 786, 2.23, 'john', 70.2]
abcd
[786, 2.23]
[2.23, 'john', 70.2]
[123, 'john', 123, 'john']
['abcd', 786, 2.23, 'john', 70.2, 123, 'john']

पायथन टुपल्स

एक ट्यूपल एक अन्य अनुक्रम डेटा प्रकार है जो सूची के समान है। टुपल में अल्पविराम द्वारा अलग किए गए मानों की संख्या होती है। हालांकि, सूचियों के विपरीत, टुपल्स कोष्ठक के भीतर संलग्न हैं।

सूचियों और टुपल्स के बीच मुख्य अंतर हैं: सूची कोष्ठक ([]) में संलग्न हैं और उनके तत्वों और आकार को बदला जा सकता है, जबकि ट्यूपल्स कोष्ठक ()) में संलग्न हैं और उन्हें अपडेट नहीं किया जा सकता है। टुपल्स के बारे में सोचा जा सकता हैread-onlyसूचियों। उदाहरण के लिए -

#!/usr/bin/python

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2  )
tinytuple = (123, 'john')

print tuple               # Prints the complete tuple
print tuple[0]            # Prints first element of the tuple
print tuple[1:3]          # Prints elements of the tuple starting from 2nd till 3rd 
print tuple[2:]           # Prints elements of the tuple starting from 3rd element
print tinytuple * 2       # Prints the contents of the tuple twice
print tuple + tinytuple   # Prints concatenated tuples

यह निम्न परिणाम उत्पन्न करता है -

('abcd', 786, 2.23, 'john', 70.2)
abcd
(786, 2.23)
(2.23, 'john', 70.2)
(123, 'john', 123, 'john')
('abcd', 786, 2.23, 'john', 70.2, 123, 'john')

निम्नलिखित कोड tuple के साथ अमान्य है, क्योंकि हमने एक tuple को अपडेट करने का प्रयास किया, जिसकी अनुमति नहीं है। सूचियों के साथ भी ऐसा ही मामला संभव है -

#!/usr/bin/python

tuple = ( 'abcd', 786 , 2.23, 'john', 70.2  )
list = [ 'abcd', 786 , 2.23, 'john', 70.2  ]
tuple[2] = 1000    # Invalid syntax with tuple
list[2] = 1000     # Valid syntax with list

पायथन शब्दकोश

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

शब्दकोश घुंघराले ब्रेसिज़ ({}) से घिरे होते हैं और मानों को वर्ग ब्रेसिज़ ([]) का उपयोग करके सौंपा और एक्सेस किया जा सकता है। उदाहरण के लिए -

#!/usr/bin/python

dict = {}
dict['one'] = "This is one"
dict[2]     = "This is two"

tinydict = {'name': 'john','code':6734, 'dept': 'sales'}


print dict['one']       # Prints value for 'one' key
print dict[2]           # Prints value for 2 key
print tinydict          # Prints complete dictionary
print tinydict.keys()   # Prints all the keys
print tinydict.values() # Prints all the values

यह निम्न परिणाम उत्पन्न करता है -

This is one
This is two
{'dept': 'sales', 'code': 6734, 'name': 'john'}
['dept', 'code', 'name']
['sales', 6734, 'john']

शब्दकोशों में तत्वों के बीच क्रम की कोई अवधारणा नहीं है। यह कहना गलत है कि तत्व "ऑर्डर से बाहर" हैं; वे बस अनियंत्रित हैं।

डेटा प्रकार रूपांतरण

कभी-कभी, आपको अंतर्निहित प्रकारों के बीच रूपांतरण करने की आवश्यकता हो सकती है। प्रकारों के बीच कनवर्ट करने के लिए, आप केवल फ़ंक्शन के रूप में टाइप नाम का उपयोग करते हैं।

एक डेटा प्रकार से दूसरे में रूपांतरण करने के लिए कई अंतर्निहित कार्य हैं। ये फ़ंक्शन परिवर्तित मान का प्रतिनिधित्व करते हुए एक नई वस्तु लौटाते हैं।

अनु क्रमांक।	समारोह विवरण
1	int(x [,base]) X को पूर्णांक में परिवर्तित करता है। आधार को निर्दिष्ट करता है यदि x एक स्ट्रिंग है।
2	long(x [,base] ) एक्स को एक लंबे पूर्णांक में परिवर्तित करता है। आधार को निर्दिष्ट करता है यदि x एक स्ट्रिंग है।
3	float(x) X को एक फ्लोटिंग-पॉइंट संख्या में परिवर्तित करता है।
4	complex(real [,imag]) एक जटिल संख्या बनाता है।
5	str(x) ऑब्जेक्ट x को एक स्ट्रिंग प्रतिनिधित्व में परिवर्तित करता है।
6	repr(x) ऑब्जेक्ट एक्स को एक अभिव्यक्ति स्ट्रिंग में परिवर्तित करता है।
7	eval(str) एक स्ट्रिंग का मूल्यांकन करता है और एक वस्तु देता है।
8	tuple(s) धर्मान्तरित एक tuple के लिए।
9	list(s) एक सूची में धर्मान्तरित।
10	set(s) एक सेट पर धर्मान्तरित।
1 1	dict(d) एक शब्दकोश बनाता है। d (कुंजी, मान) टुपल्स का एक अनुक्रम होना चाहिए।
12	frozenset(s) धर्मान्तरित सेट पर परिवर्तित होता है।
13	chr(x) किसी वर्ण को पूर्णांक देता है।
14	unichr(x) एक पूर्णांक को एक यूनिकोड वर्ण में परिवर्तित करता है।
15	ord(x) किसी एकल वर्ण को उसके पूर्णांक मान में परिवर्तित करता है।
16	hex(x) एक पूर्णांक को हेक्साडेसिमल स्ट्रिंग में परिवर्तित करता है।
17	oct(x) एक पूर्णांक को एक अष्टक स्ट्रिंग में परिवर्तित करता है।