Please support if you like my work by payment through upi: sinhamit@icici or payment by bank
account name: Amit Kumar Sinha,
account number: 2646728782
IFSC code: KKBK0005660
SWIFT: KKBKINBB
Slicing Strings, Lists and Tuples in Category: पाइथन by amit
🕙 Posted on 2023-08-05 at 07:10:14
सूची (list), टुपल, डिक्शनरी और स्लाइसिंग (छांटना)
आपको याद रखना चाहिए कि स्ट्रिंग्स और टुपल्स अपरिवर्तनीय डेटा-प्रकार हैं, यानी वे परिवर्तनशील नहीं हैं। आपने पिछले पृष्ठों में विभिन्न स्ट्रिंग विधियों, संयोजन इत्यादि के बारे में सीखा है। इसका मतलब है कि कोई भी अंतर्निहित फ़ंक्शन, उदाहरण के लिए, len(), कोई भी स्ट्रिंग विधियाँ, स्ट्रिंग शाब्दिक पर लागू संयोजन (concatenation) या एकल वर्ण (single character) का निष्कर्षण (extraction: वेरिएबल नाम या स्ट्रिंग शाब्दिक के ठीक बाद [] वर्ग कोष्ठक का उपयोग करके), मूल मान (value) को नहीं बदलता है।
यदि आप ऐसे ऑपरेशन के परिणाम/print() फ़ंक्शन केवल अपने कोष्ठकों के भीतर मूल्यांकित अभिव्यक्तियों या कथनों का परिणाम प्रदर्शित करता है।
उदाहरण 1
my_string = 'caMelcaSe stRing'
string1 = my_string.title()
string2 = my_string.capitalize()
string3 = my_string.upper()
string4 = my_string.lower()
print( my_string ) # मूल स्ट्रिंग को आउटपुट करता है
अन्य प्रोग्रामिंग भाषाओं के विपरीत, पायथन में स्थिरांक (CONSTANTS) की कोई अवधारणा नहीं है। और इस प्रकार, आप देख सकते हैं कि एक चर (variable) नाम को एक मान (डेटा) के साथ निर्दिष्ट किया जा सकता है या किसी अन्य मान (value) को उस चर को फिर से निर्दिष्ट किया जा सकता है, लेकिन वे मान स्ट्रिंग या टपल डेटा-प्रकार के (शाब्दिक) हो सकते हैं, और इस प्रकार अपरिवर्तनीय (immutable) हो सकते हैं। पायथन बहुत अधिक मेमोरी कुशल है, क्योंकि यह एक विशेष मान (डेटा) को केवल एक मेमोरी स्थान पर संग्रहीत करता है।
हालाँकि, सूची (list) और डिक्शनरी (dictionary) डेटा-प्रकार परिवर्तनशील और बहुत अधिक लचीले हैं और इसलिए, पायथन में स्ट्रिंग्स के बाद सूचियों और डिक्शनरियों का अक्सर उपयोग किया जाता है। आप देख सकते हैं कि स्ट्रिंग डेटा-प्रकार में अन्य डेटा-प्रकारों की तुलना में बहुत अधिक विधियाँ हैं। तीन डेटा-प्रकार, स्ट्रिंग्स, सूचियाँ (lists) और टुपल्स सूचकांक (index) आधारित अनुक्रम (sequence) डेटा-प्रकार हैं। इसका मतलब है कि स्ट्रिंग की तरह, एक सूची या एक टपल में प्रत्येक व्यक्तिगत (individual) आइटम/
उदाहरण 2
my_string = "Hello World"
my_list = [ "H", "e", "l", "l", "o", " ", "W", "o", "r", "l", "d" ]
my_tuple = ( "H", "e", "l", "l", "o", " ", "W", "o", "r", "l", "d" )
print( my_string, len( my_string ), type( my_string ) )
print( my_list, len( my_list ), type( my_list ) )
print( my_tuple, len( my_tuple ), type( my_tuple ) )
print( my_string[-1], my_list[-1], my_tuple[-1] ) # आउटपुट d d d है।
print( my_string[ -len( my_string ) ], my_list[ -len( my_string ) ], my_tuple[ -len( my_string ) ] ) # आउटपुट H H H है।
["H", "e", "l", "l", "o", " ", "W", "o", "r", "l", "d"] 11 <class 'list'>
("H", "e", "l", "l", "o", " ", "W", "o", "r", "l", "d") 11 <class 'tuple'>
d d d
H H H
उपरोक्त उदाहरण में, आप देख सकते हैं कि इन तीन चरों my_string, my_listऔर my_tuple में से प्रत्येक की लंबाई 11 है। इनमें से प्रत्येक वेरिएबल के अंदर एक रिक्त स्थान है, जिसे (my_string के) एक वर्ण (character) या (my_list और my_tuple के) एक वस्तु/
आपको यह भी ध्यान रखना चाहिए कि एक खाली स्ट्रिंग (सिंगल/
उदाहरण 3
my_string = ''
my_list = [ '' ]
my_tuple = ( '', ) # याद रखें: सम्मिलित किए जाने वाले एकल आइटम/
my_dict = { 'empty': '' } # एक डिक्शनरी में कुंजी: मान युग्म होना चाहिए
my_set = { '' } # अन्यथा, यह एक सेट डेटा-प्रकार होगा
print( my_string, len( my_string ), type( my_string ) )
print( my_list, len( my_list ), type( my_list ) )
print( my_tuple, len( my_tuple ), type( my_tuple ) )
print( my_dict, len( my_dict ), type( my_dict ) )
print( my_set, len( my_set ), type( my_set ) )
[''] 1 <class 'list'>
('',) 1 <class 'tuple'>
{'empty': ''} 1 <class 'dict'>
{''} 1 <class 'set'>
उपरोक्त उदाहरण में, प्रत्येक चर my_list, my_tuple, my_dict और my_set में केवल एक आइटम/
हालाँकि, एक डिक्शनरी डेटा-प्रकार के किसी आइटम/
उदाहरण 3 (जारी)
# print( my_string[0] ) # एक खाली स्ट्रिंग शाब्दिक में कोई वर्ण (character) नहीं है।
print( my_list[0], len( my_list[0] ), type( my_list[0] ) )
print( my_tuple[0], len( my_tuple[0] ), type( my_tuple[0] ) )
print( my_dict['empty'], len( my_dict['empty'] ), type( my_dict['empty'] ) )
# print( my_set[0], len( my_set[0] ) ) # आउटपुट TypeError: 'set' object is not subscriptable है।
0 <class 'str'>
0 <class 'str'>
स्ट्रिंग्स, सूचियों और टुपल्स की स्लाइसिंग
आम तौर पर, स्लाइसिंग चर नाम या स्ट्रिंग/[] वर्गाकार कोष्ठक के भीतर दो तर्कों (कोलन प्रतीक द्वारा अलग) के साथ की जाती है। हालाँकि, स्लाइसिंग के लिए सिंटैक्स इस प्रकार है −
string_literal[start:stop:step]
list_literal[start:stop:step]
tuple_literal[start:stop:step]
start स्ट्रिंग शाब्दिक, सूची शाब्दिक, या टपल शाब्दिक की प्रारंभिक सूचकांक संख्या (समावेशी inclusive) है। इसी प्रकार, stop उस शाब्दिक या चर नाम का सूचकांक संख्या (अनन्य exclusive) है, जिसके पहले स्लाइसिंग की जाती है। इसका मतलब यह है कि जब आप [1:4] लिखेंगे तो इंडेक्स नंबर 1 से लेकर 3 तक स्लाइसिंग की जाएगी। तीसरा तर्क step, वह स्थितियाँ हैं जिन्हें पुनरावृत्त किया जाएगा, अर्थात, जब step (डिफ़ॉल्ट रूप से) 1 है, तो कोई भी वर्ण या आइटम/
start और stop तर्क केवल पूर्णांक डेटा मान (सकारात्मक या नकारात्मक सूचकांक संख्या) लेते हैं, लेकिन stepतर्क केवल सकारात्मक पूर्णांक मान लेते हैं। ये तीन तर्क वैकल्पिक हैं, और इन्हें : (कोलन) चिन्ह के पहले और बाद में खाली छोड़ा जा सकता है। जब start को खाली छोड़ दिया जाता है, तो सूचकांक संख्या 0(शून्य) होती है, और जब stop को खाली छोड़ दिया जाता है, तो स्ट्रिंग/
निम्नलिखित तालिका में, आप देख सकते हैं कि प्रत्येक वर्ण (स्ट्रिंग डेटा-प्रकार का), या किसी सूची या टुपल के प्रत्येक आइटम/
| H | e | l | l | o | W | o | r | l | d | |
|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
| -11 | -10 | -9 | -8 | -7 | -6 | -5 | -4 | -3 | -2 | -1 |
उदाहरण 4
आप start और stop तर्कों के लिए नकारात्मक सूचकांक संख्याओं का भी उपयोग कर सकते हैं।
my_string = "Hello World"
my_list = [ "H", "e", "l", "l", "o", " ", "W", "o", "r", "l", "d" ]
my_tuple = ( "H", "e", "l", "l", "o", " ", "W", "o", "r", "l", "d" )
sliced_string = my_string[1:4]
sliced_list = my_list[1:4]
sliced_tuple = my_tuple[1:4]
print( sliced_string, type( sliced_string ) ) # आउटपुट ell <class 'str'> है।
print( sliced_list, type( sliced_list ) ) # आउटपुट ['e', 'l', 'l'] <class 'list'> है।
print( sliced_tuple, type( sliced_tuple ) ) # आउटपुट ('e', 'l', 'l') <class 'tuple'> है।
उदाहरण 5
जब एक स्ट्रिंग/step, प्रयोग किया जाता है। इसलिए, यह स्पष्ट करने के लिए कि दूसरे और चौथे अक्षर/
my_string = "123456789" # यह एक स्ट्रिंग डेटा-प्रकार है।
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9] # इस सुची में नौ आइटम है।
my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9) # इस टुपल में नौ आइटम है।
sliced_string = my_string[0:5:2]
sliced_list = my_list[0:5:2]
sliced_tuple = my_tuple[0:5:2]
print( sliced_string ) # आउटपुट 135 है।
print( sliced_list ) # आउटपुट [1, 3, 5] है।
print( sliced_tuple ) # आउटपुट (1, 3, 5) है।
उदाहरण 6
निम्नलिखित उदाहरण 6 में, स्ट्रिंग शाब्दिक "Hello World", सूची शाब्दिक ["H", "e", "l", "l", "o", " ", "W", "o", "r", "l", "d"], और टपल शाब्दिक ("H", "e", "l", "l", "o", " ", "W", "o", "r", "l", "d") को छांटने के लिए slice() अंतर्निहित फ़ंक्शन का उपयोग तीन तर्कों के साथ किया गया है जो , (अल्पविराम) प्रतीक द्वारा अलग किए जाते हैं। नीचे दिए गए उदाहरण में, पहला 'l' अक्षर (सूचकांक संख्या 2), पहला 'o' अक्षर (सूचकांक संख्या 4) और 'W' अक्षर (सूचकांक संख्या 6) slice( 1, 8, 2 ) प्रत्येक शाब्दिक पर लागू होने पर, छोड़ दिया जाता है।
my_string = "Hello World"
my_list = [ "H", "e", "l", "l", "o", " ", "W", "o", "r", "l", "d" ]
my_tuple = ( "H", "e", "l", "l", "o", " ", "W", "o", "r", "l", "d" )
sliced_string = my_string[slice(1,8,2)]
sliced_list = my_list[slice(1,8,2)]
sliced_tuple = my_tuple[slice(1,8,2)]
print( sliced_string, type( sliced_string ) ) # आउटपुट el o <class 'str'> है।
print( sliced_list, type( sliced_list ) ) # आउटपुट ['e', 'l', ' ', 'o'] <class 'list'> है।
print( sliced_tuple, type( sliced_tuple ) ) # आउटपुट ('e', 'l', ' ', 'o') <class 'tuple'> है।
print( help( slice ) ) # slice() सहायता दस्तावेज़ की कुछ पंक्तियाँ नीचे दिखाई गई हैं:
Help on class slice in module builtins:
class slice(object)
| slice(stop)
| slice(start, stop[, step])
|
| Create a slice object. This is used for extended slicing (e.g. a[0:10:2]).
|
Leave a Comment:
Amit Sinha March 2nd, 2023 at 9:30 PM
😃 😄 😁 😆 😅 😂 😉 😊 😇 😍 😘 😚 😋 😜 😝 😶 😏 😒 😌 😔 😪 😷 😵 😎 😲 😳 😨 😰 😥 😢 😭 😱 😖 😣 😞 😓 😩 😫 😤
Ribhu March 3rd, 2023 at 9:30 PM
🐵 🐒 🐶 🐩 🐺 🐱 🐯 🐅 🐆 🐴 🐎 🐮 🐂 🐃 🐄 🐷 🐖 🐗 🐽 🐏 🐑 🐐 🐪 🐫 🐘 🐭 🐁 🐀 🐹 🐰 🐇
