Python में डेटा टाइप्स वास्तव में क्लासेस होते हैं, और वेरिएबल्स उनके उदाहरण या ऑब्जेक्ट होते हैं। चूंकि Python एक डायनामिकली टाइप्ड भाषा है, इसलिए किसी वेरिएबल का डेटा टाइप रनटाइम के दौरान निर्धारित होता है, जो कि उसे दिए गए मान (value) पर आधारित होता है।
सामान्य रूप से, डेटा टाइप्स का उपयोग वेरिएबल के प्रकार को परिभाषित करने के लिए किया जाता है। यह उस प्रकार का प्रतिनिधित्व करता है जो हम वेरिएबल में स्टोर करने जा रहे हैं, और यह निर्धारित करता है कि उस डेटा पर कौन-सी ऑपरेशन्स की जा सकती हैं।
हर प्रोग्रामिंग भाषा की अपनी डेटा आइटम्स की क्लासिफिकेशन होती है। इन डेटा टाइप्स की मदद से हम विभिन्न प्रकार के डेटा मान (values) को स्टोर कर सकते हैं।
उदाहरण: a = 10 (int), b = 10.5 (float), c = 3 + 5j (complex)
उदाहरण: name = “Python”
उदाहरण: my_list = [1, 2, 3, “Python”]
उदाहरण: my_tuple = (1, 2, 3, “Python”)
उदाहरण: my_dict = {“name”: “Python”, “version”: 3.10}
उदाहरण: my_set = {1, 2, 3, 4}
Python में आप एक ही वेरिएबल को किसी भी समय किसी भी प्रकार के डेटा से असाइन कर सकते हैं, और इसका प्रकार तुरंत बदल जाता है:
x = 10 # int x = "Python" # str
इससे Python बहुत फ्लेक्सिबल हो जाता है, क्योंकि आपको वेरिएबल्स को पहले से डिक्लेयर करने की जरूरत नहीं होती।
Python में Numeric Data Type
Python में Numeric Data Types संख्यात्मक मानों को स्टोर करते हैं। नंबर ऑब्जेक्ट तब बनाए जाते हैं जब आप उन्हें कोई मान असाइन करते हैं। उदाहरण के लिए:
var1 = 1 # int data type var2 = True # bool data type var3 = 10.023 # float data type var4 = 10+3j # complex data type
Python चार अलग-अलग न्यूमेरिकल टाइप्स का समर्थन करता है, और इनमें से प्रत्येक Python लाइब्रेरी में निर्मित क्लासेस के रूप में मौजूद है: int, bool, float, और complex। इनके विवरण इस प्रकार हैं:
कम्प्लेक्स संख्या दो भागों से मिलकर बनी होती है – वास्तविक (real) और काल्पनिक (imaginary)। इन्हें ‘+’ या ‘-‘ चिन्ह से अलग किया जाता है, और काल्पनिक भाग में ‘j’ प्रत्यय के रूप में होता है, जो कि काल्पनिक संख्या (√-1) को दर्शाता है। उदाहरण के लिए: 5+6j में 5 वास्तविक भाग है और 6j काल्पनिक भाग है।
उदाहरण:
>>> type(5+6j) <class 'complex'>
Python में कुछ उदाहरण:
int float complex
10 0.0 3.14j
0O777 15.20 45.j
-786 -21.9 9.322e-36j
0x17 -90.0 -.6545+0J
-0x260 -32.54e100 3e+26J
0x69 70.2-E12 4.53e-7j
उदाहरण (Integer, Float, Complex का उपयोग):
# integer variable.
a = 100
print("The type of variable having value", a, "is", type(a))
# float variable.
c = 20.345
print("The type of variable having value", c, "is", type(c))
# complex variable.
d = 10+3j
print("The type of variable having value", d, "is", type(d))
इस उदाहरण में, a एक integer, c एक float, और d एक complex संख्या है।
क या एक से अधिक Unicode कैरेक्टर्स का क्रम होता है, जो single, double, या triple quotation marks (इन्वर्टेड कॉमाज) में संलग्न होते हैं। Python में strings immutable होते हैं, जिसका मतलब है कि जब आप strings पर कोई ऑपरेशन करते हैं, तो आप हमेशा उसी प्रकार की एक नई string object बनाते हैं, न कि मौजूदा string को बदलते हैं।
चाहे single, double, या triple quotes का उपयोग किया जाए, जब तक कैरेक्टर सीक्वेंस वही रहता है, तीनों का परिणाम एक जैसा होता है। उदाहरण के लिए:
>>> 'vistaacademy' 'Vista Academy' >>> "Vista Academy" 'Vista Academy' >>> '''Vista Academy'''
‘Vista Academy
Python में string एक str class का ऑब्जेक्ट होता है। आप इसे type() फ़ंक्शन से सत्यापित कर सकते हैं:
type("Welcome To TutorialsPoint")
String विशेषताएँ:
Non-numeric data type: हम strings पर अंकगणितीय ऑपरेशन नहीं कर सकते।
Immutable: strings में कोई भी बदलाव करने पर एक नई string उत्पन्न होती है।
Slicing और Concatenation: Python की str class string प्रोसेसिंग के लिए कई उपयोगी विधियाँ प्रदान करती है। आप strings का सबसेट slice ऑपरेटर [ ] और [:] का उपयोग करके ले सकते हैं, जिसमें इंडेक्स 0 से शुरू होकर स्ट्रिंग के अंत में -1 तक चलता है।
Slicing: स्ट्रिंग के हिस्से निकालने के लिए
Concatenation (+): स्ट्रिंग जोड़ने के लिए
Repetition (*): स्ट्रिंग को दोहराने के लिए
उदाहरण: String Data Type का उपयोग
str = 'Hello World!' print(str) # पूरी स्ट्रिंग को प्रिंट करता है print(str[0]) # स्ट्रिंग का पहला कैरेक्टर प्रिंट करता है print(str[2:5]) # स्ट्रिंग के 3rd से 5th कैरेक्टर्स को प्रिंट करता है print(str[2:]) # 3rd कैरेक्टर से शुरू होकर अंत तक की स्ट्रिंग प्रिंट करता है print(str * 2) # स्ट्रिंग को दो बार प्रिंट करता है print(str + "TEST") # स्ट्रिंग को जोड़कर प्रिंट करता है
आउटपुट:
Hello World! H llo llo World! Hello World!Hello World! Hello World!TEST महत्वपूर्ण स्ट्रिंग मेथड्स: len(): स्ट्रिंग की लंबाई जानने के लिए upper(): स्ट्रिंग को uppercase में बदलने के लिए lower(): स्ट्रिंग को lowercase में बदलने के लिए split(): स्ट्र
list = ['abcd', 786, 2.23, 'john', 70.2] tinylist = [123, 'john'] print(list) # पूरी list को प्रिंट करता है print(list[0]) # पहला element प्रिंट करता है print(list[1:3]) # दूसरे से तीसरे element को प्रिंट करता है print(list[2:]) # तीसरे से लेकर आखिरी element को प्रिंट करता है print(tinylist * 2) # list को दो बार प्रिंट करता है print(list + tinylist) # दोनों 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']
tuple = ('abcd', 786, 2.23, 'john', 70.2)
tinytuple = (123, 'john')
print(tuple) # पूरी ट्यूपल को प्रिंट करता है
print(tuple[0]) # पहला element प्रिंट करता है
print(tuple[1:3]) # दूसरे से तीसरे element को प्रिंट करता है
print(tuple[2:]) # तीसरे से आखिरी element को प्रिंट करता है
print(tinytuple * 2) # ट्यूपल को दो बार प्रिंट करता है
print(tuple + tinytuple) # दोनों ट्यूपल्स को जोड़कर प्रिंट करता है
for i in range(5):
print(i)
output
0 1 2 3 4
1 3Lists vs Tuples: Lists: Mutable (इनमें बदलाव किया जा सकता है), square brackets [] का इस्तेमाल। Tuples: Immutable (इनमें बदलाव नहीं किया जा सकता), parentheses () का इस्तेमाल। ये तीनों sequence data types Python में ordered और iterable होते हैं, जिनसे आप कई तरह के operations कर सकते हैं।
Python में बाइनरी डेटा टाइप्स वह होते हैं जो डेटा को 0 और 1 के रूप में प्रस्तुत करते हैं। ये कंप्यूटर की एक खास भाषा होती है, जिसे कंप्यूटर बहुत तेजी से समझते हैं और डेटा को स्टोर और प्रोसेस करते हैं।
इस प्रकार के डेटा का उपयोग तब होता है जब हमें फाइल्स, इमेजेज, या किसी ऐसी जानकारी को संग्रहीत करना हो, जिसे दो संभावित मानों (0 और 1) में व्यक्त किया जा सके।
Python हमें बाइनरी डेटा को तीन अलग-अलग तरीकों से प्रस्तुत करने की सुविधा देता है:
bytes
bytearray
memoryview
अब इन तीनों को विस्तार से समझते हैं:
Bytes डेटा टाइप Python में एक बाइट की श्रंखला (sequence) को दर्शाता है। प्रत्येक बाइट 0 से 255 के बीच एक इन्टिजर मान होता है। यह अक्सर इमेजेज, फाइल्स, या नेटवर्क पैकेट जैसे बाइनरी डेटा को स्टोर करने के लिए उपयोग किया जाता है।
Bytes बनाने के लिए हम Python के bytes() फ़ंक्शन का उपयोग कर सकते हैं या सीधी तरीके से किसी स्ट्रिंग के आगे ‘b’ प्रिफिक्स लगाकर इसे क्रिएट कर सकते हैं।
उदाहरण:
# bytes() का उपयोग कर bytes बनाना b1 = bytes([65, 66, 67, 68, 69]) print(b1)
आउटपुट:
b'ABCDE'
यहाँ ‘b’ प्रिफिक्स के साथ भी इसे क्रिएट कर सकते हैं:
b2 = b'Hello' print(b2)
आउटपुट:
b'Hello'
Bytearray डेटा टाइप bytes की तरह ही है, बस इसमें एक अंतर है – यह mutable है, यानी आप इसमें बाद में भी बदलाव कर सकते हैं।
हम bytearray() फ़ंक्शन के माध्यम से इसे कई तरीकों से बना सकते हैं, जैसे किसी integer की श्रृंखला से या किसी स्ट्रिंग को encode करके।
उदाहरण:
# integers की श्रृंखला से bytearray बनाना value = bytearray([72, 101, 108, 108, 111])
print(value)
आउटपुट:
e bytearray(b'Hello')
स्ट्रिंग को UTF-8 में encode करके भी bytearray बना सकते हैं:
val = bytearray("Hello", 'utf-8')
print(val)आउटपुट:
bytearray(b'Hello')
Memoryview Python में एक object होता है, जो डेटा का एक view प्रदान करता है, बिना उसे कॉपी किए। इसे objects, जैसे bytearrays या bytes, के साथ प्रयोग किया जाता है जो बफर प्रोटोकॉल को सपोर्ट करते हैं। यह बड़ी datasets को efficiently handle करने में मदद करता है।
आप memoryview() का उपयोग करके या slicing के माध्यम से memoryview बना सकते हैं।
उदाहरण:
data = bytearray(b'Hello, world!') view = memoryview(data) print(view)
आउटपुट:
Slicing से भी memoryview बना सकते हैं:
data = b'Hello, world!' view = memoryview(data[7:]) print(view)
आउटपुट:
इस प्रकार, बाइनरी डेटा टाइप्स आपको Python में डेटा को ज्यादा efficiently स्टोर और एक्सेस करने की सुविधा देते हैं। चाहे आपको bytes में इमेजेज संभालनी हों या bytearrays में डेटा को modify करना हो, ये टाइप्स आपके लिए काफी उपयोगी होते हैं।
ये संस्करण आपके छात्रों के लिए Python के बाइनरी डेटा टाइप्स को सरल और engaging तरीके से समझाने के लिए तैयार है!
Python में Dictionary, एक प्रकार की हैश टेबल की तरह होती है। Dictionary में keys और values के रूप में डेटा स्टोर किया जाता है। Python में dictionary को हम आसानी से समझ सकते हैं जैसे किसी शब्दकोश में एक शब्द (key) और उसका अर्थ (value) होता है।
Keys आमतौर पर numbers या strings होते हैं, लेकिन वे Python के लगभग किसी भी प्रकार के डेटा हो सकते हैं। दूसरी ओर, values कोई भी Python object हो सकते हैं।
Dictionary को हम इस तरह लिखते हैं:
{1: 'one', 2: 'two', 3: 'three'}
यहाँ पर {} के अंदर key:value के जोड़े होते हैं, जिन्हें : से अलग किया जाता है और प्रत्येक जोड़े को , से अलग किया जाता है।
Python में dictionary एक dict class का object होता है, जिसे हम type() function से चेक कर सकते हैं:
type({1:'one', 2:'two', 3:'three'})
# Output: <class 'dict'>
उदाहरण: Python Dictionary
dict = {}
dict['one'] = "यह पहला है"
dict[2] = "यह दूसरा है"
tinydict = {'name': 'john', 'code': 6734, 'dept': 'sales'}
print(dict['one']) # 'one' key का value प्रिंट करता है
print(dict[2]) # 2 key का value प्रिंट करता है
print(tinydict) # पूरा dictionary प्रिंट करता है
print(tinydict.keys()) # सभी keys प्रिंट करता है
print(tinydict.values()) # सभी values प्रिंट करता है
Output:
यह पहला है
यह दूसरा है
{'name': 'john', 'code': 6734, 'dept': 'sales'}
dict_keys(['name', 'code', 'dept'])
dict_values(['john', 6734, 'sales'])
Python dictionary में keys का कोई positional index नहीं होता, इसलिए slicing (जैसे हम list या string में करते हैं) dictionary में संभव नहीं है। यह एक mutable object है, यानी हम dictionary में items को जोड़, बदल या हटा सकते हैं।
>>> type({2023, "Python", 3.11, 5+6j, 1.23E-4})
<class 'set'>
सेट में केवल immutable ऑब्जेक्ट्स (जैसे कि नंबर, स्ट्रिंग, ट्यूपल) ही स्टोर हो सकते हैं। अगर आप सेट में लिस्ट या डिक्शनरी डालने की कोशिश करेंगे, तो Python TypeError देगा:
>>> {['One', 'Two', 'Three'], 1, 2, 3, (1.0, 2.0, 3.0)}
Traceback (most recent call last):
File "", line 1, in
TypeError: unhashable type: 'list'
यह इसलिए होता है क्योंकि hashing एक ऐसी तकनीक है जो कंप्यूटर की मेमोरी में ऑब्जेक्ट्स को तेज़ी से खोजने के काम आती है। सिर्फ immutable ऑब्जेक्ट्स ही hashable होते हैं।
हालांकि सेट में mutable आइटम्स नहीं होते, लेकिन खुद सेट mutable होता है। इसका मतलब है कि आप इसमें आइटम्स जोड़ सकते हैं, हटा सकते हैं या अपडेट कर सकते हैं। इसके लिए Python में कई इन-बिल्ट methods और operators मौजूद हैं। आगे के चैप्टर्स में इन ऑपरेशंस को विस्तार से समझाया जाएगा।
सेट का उदाहरण
set1 = {123, 452, 5, 6}
set2 = {'Java', 'Python', 'JavaScript'}
print(set1)
print(set2)
इसका आउटपुट कुछ इस प्रकार होगा:
{123, 452, 5, 6}
{'Python', 'JavaScript', 'Java'}
Python में Boolean डेटा टाइप एक बिल्ट-इन डेटा टाइप है, जो दो मानों में से एक को दर्शाता है, यानी True या False। Python की bool() फ़ंक्शन का उपयोग करके आप किसी भी expression का मूल्यांकन कर सकते हैं और यह बताएगा कि वह True है या False।
Boolean नंबर के सिर्फ़ दो मान हो सकते हैं, जो Python में True और False keywords से दर्शाए जाते हैं। ये integer 1 और 0 के बराबर होते हैं:
>>> >>> type(True) <class 'bool'> >>> type(False) <class 'bool'>
a = True # a की वैल्यू दिखाएँ print(a) # a के डेटा टाइप को दिखाएँ print(type(a))इसका आउटपुट होगा:
True <class 'bool'>
# False लौटाएगा क्योंकि a बराबर नहीं है b के a = 2 b = 4 print(bool(a == b)) # यह भी वही प्रिंट करेगा print(a == b) # False लौटाएगा क्योंकि a का मान None है a = None print(bool(a)) # False लौटाएगा क्योंकि a एक खाली sequence है a = () print(bool(a)) # False लौटाएगा क्योंकि a का मान 0.0 है a = 0.0 print(bool(a)) # True लौटाएगा क्योंकि a का मान 10 है a = 10 print(bool(a))
# एक वेरिएबल घोषित करना
# और उसे Null मान (None) असाइन करना
x = None
# इसका मान और प्रकार प्रिंट करना
print("x =", x)
print("x का प्रकार =", type(x))
यह आउटपुट दिखाएगा:
x = None x का प्रकार =
Python में किसी भी वस्तु (object) का डेटा टाइप जानने के लिए, आप type() फ़ंक्शन का उपयोग कर सकते हैं। यह एक बिल्ट-इन फ़ंक्शन है जो दिए गए ऑब्जेक्ट के क्लास को लौटाता है।
उदाहरण:
नीचे दिए गए उदाहरण में हम विभिन्न मानों और वेरिएबल्स का टाइप प्राप्त कर रहे हैं:
# विभिन्न मानों का प्रकार जानना print(type(123)) print(type(9.99)) # वेरिएबल्स का प्रकार जानना a = 10 b = 2.12 c = "नमस्ते" d = (10, 20, 30) e = [10, 20, 30] print(type(a)) print(type(b)) print(type(c)) print(type(d)) print(type(e))
<class 'int'> <class 'float'> <class 'str'> <class 'tuple'> <class 'list'>
# एक वेरिएबल घोषित करना
# और उसे एक पूर्णांक मान असाइन करना
x = 10
# इसका मान और प्रकार प्रिंट करना
print("x =", x)
print("x का प्रकार =", type(x))
# अब, उसी वेरिएबल को एक स्ट्रिंग मान असाइन करना
x = "Hello World!"
# इसका मान और प्रकार प्रिंट करना
print("x =", x)
print("x का प्रकार =", type(x))
x = 10 x का प्रकार =x = Hello World! x का प्रकार =
उपरोक्त डेटा टाइप्स को दो श्रेणियों में विभाजित किया जा सकता है: प्रारंभिक (Primitive) और गैर-प्रारंभिक (Non-Primitive) डेटा टाइप्स।
प्रारंभिक डेटा टाइप्स वे बुनियादी डेटा टाइप्स होते हैं जिनका उपयोग जटिल डेटा संरचनाएँ (complex data structures) बनाने के लिए किया जाता है। मुख्य रूप से चार प्रकार के प्रारंभिक डेटा टाइप्स होते हैं:
गैर-प्रारंभिक डेटा टाइप्स वे होते हैं जो मानों या मानों के संग्रह (collection of values) को स्टोर करते हैं। मुख्य रूप से चार प्रकार के गैर-प्रारंभिक डेटा टाइप्स होते हैं:
print("पूर्णांक (Integer) डेटा टाइप में रूपांतरण")
a = int(1) # a = 1 होगा
b = int(2.2) # b = 2 होगा
c = int("3.3") # c = 3 होगा
print(a)
print(b)
print(c)
print("फ्लोटिंग पॉइंट नंबर में रूपांतरण")
a = float(1) # a = 1.0 होगा
b = float(2.2) # b = 2.2 होगा
c = float("3.3") # c = 3.3 होगा
print(a)
print(b)
print(c)
print("स्ट्रिंग में रूपांतरण")
a = str(1) # a = "1" होगा
b = str(2.2) # b = "2.2" होगा
c = str("3.3") # c = "3.3" होगा
print(a)
print(b)
print(c)
यह आउटपुट दिखाएगा:
पूर्णांक डेटा टाइप में रूपांतरण 1 2 3 फ्लोटिंग पॉइंट नंबर में रूपांतरण 1.0 2.2 3.3 स्ट्रिंग में रूपांतरण 1 2.2 3.3