पायथन में इंडेक्सिंग और स्लाइसिंग एक महत्वपूर्ण अवधारणा है, खासकर जब हम स्ट्रिंग्स का उपयोग करते हैं।

अनुक्रमण:

WKT, स्ट्रिंग और कुछ नहीं बल्कि वर्णों का एक क्रम है।
तो, प्रत्येक वर्ण की एक स्थिति होती है जिसका नाम है index और उस विशेष स्ट्रिंग में उनकी स्थिति तक पहुंच को indexing के रूप में जाना जाता है।

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

उदाहरण के लिए,

>     H E L L O W O R L D
>     0 1 2 3 4 5 6 7 8 9

इसे सकारात्मक अनुक्रमण के रूप में जाना जाता है क्योंकि हमने सूचकांकों को संदर्भित करने के लिए केवल सकारात्मक संख्याओं का उपयोग किया है।

आप पूछ सकते हैं कि "फिर, हमारे पास नकारात्मक संकेत भी हैं??"
ओएफसी, लेकिन यहां हमारे पास पहले स्थान के रूप में शून्य नहीं है क्योंकि यह एक ऋणात्मक संख्या नहीं है।

नकारात्मक अनुक्रमण हमें स्ट्रिंग के अंत से वर्णों तक पहुंचने की अनुमति देता है यानी, अंतिम वर्ण का सूचकांक -1 है, दूसरे अंतिम वर्ण का सूचकांक -2 है, और इसी तरह।

>      H  E  L  L  O  W  O  R  L  D
>    -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

word = "HELLOWORLD"

print(word[0])
print(word[5])

H
W

इसी प्रकार,

print(word[-1])
print(word[-6])

D
0

यह अनुक्रमण के बारे में है।

स्लाइसिंग:

एक स्ट्रिंग को काटने के बारे में सोचें जैसे पूरे केक से केक का एक टुकड़ा काटना। हम निर्दिष्ट कर सकते हैं कि कहां से काटना शुरू करना है (सूचकांक), कहां खत्म करना है (सूचकांक समाप्त करना), और यहां तक ​​कि प्रत्येक टुकड़ा कितना बड़ा होना चाहिए (चरण)। इस तरह, हम केक (या स्ट्रिंग) के छोटे हिस्से बिल्कुल उसी तरह बना सकते हैं जैसे हम उन्हें पसंद करते हैं!

पायथन में, एक स्ट्रिंग को काटने से हम स्ट्रिंग के भीतर कहां से शुरू करना है और कहां समाप्त करना है, यह निर्दिष्ट करके इसके विशिष्ट भागों को पकड़ सकते हैं।
इसलिए, उदाहरण के लिए, यदि संदेश में "हेलोवर्ल्ड" है, तो संदेश [3:7] आपको "LOWO" देता है क्योंकि यह इंडेक्स 3 ('एल') से शुरू होता है और इंडेक्स 7 ('डी') से ठीक पहले समाप्त होता है। इस तरह, हम स्ट्रिंग के किसी भी हिस्से को निकाल सकते हैं जिसकी हमें आवश्यकता है!

- स्लाइसिंग के लिए मूल सिंटैक्स है,

string[start:stop]

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

text = "HappyBirthday"

print(text[0:5])  
print(text[5:13])

Happy
Birthday  

पायथन में एक स्ट्रिंग को स्लाइस करते समय, हम स्ट्रिंग की शुरुआत से या अंत तक स्लाइस करने के लिए स्टार्ट या स्टॉप इंडेक्स को छोड़ सकते हैं।
यह उतना ही सीधा है!

- एक कदम के साथ टुकड़ा करना,

पायथन में एक स्ट्रिंग को काटते समय वर्णों के बीच अंतराल निर्दिष्ट करने के लिए, बस चरण मान के बाद एक कोलन जोड़ें:

string[start:stop:step]

यह नियंत्रित करने की अनुमति देता है कि स्लाइस बनाते समय हम स्ट्रिंग के अक्षरों को कैसे छोड़ना चाहते हैं।

message = "HELLOWORLD"
print(message[1::2])    

EORL

message[1::2] 2 के चरण के साथ इंडेक्स 1 ('ई') से स्ट्रिंग के अंत तक स्लाइस करना शुरू करता है।
इसलिए, इसमें सूचकांक 1, 3, 5, और 7 के अक्षर शामिल हैं, जो हमें "ईओआरएल" देते हैं।

अब तक, हमने सकारात्मक स्लाइसिंग के बारे में देखा और अब आइए नकारात्मक स्लाइसिंग के बारे में जानें।

- नकारात्मक स्लाइसिंग:

• एक नकारात्मक कदम आपको स्ट्रिंग को उल्टे क्रम में काटने की अनुमति देता है।
• आइए दूसरे अंतिम अक्षर से तीसरे अक्षर तक उल्टे क्रम में काटें

message = "HELLOWORLD"
print(message[-2:2:-1])

ROWOL

आइए कुछ प्रश्नों पर गौर करें।

#एक फ़ंक्शन लिखें जो एक स्ट्रिंग लेता है और उसके पहले और अंतिम वर्ण से युक्त एक नई स्ट्रिंग लौटाता है।

word = "Python"
end = word[0] word[5]
print(end)

Pn

#एक फ़ंक्शन लिखें जो किसी दिए गए स्ट्रिंग को उलट देता है।

word = "Python"
print(word[::-1])

nohtyP

#एक स्ट्रिंग दी गई है, तीसरे से 8वें अक्षर (समावेशी) तक एक सबस्ट्रिंग निकालें और वापस करें।

text = "MichaelJackson"
print(text[3:9])

haelJa

#एक ईमेल पता दिया गया है, डोमेन निकालें और वापस करें।

email = "[email protected]"
domain = email[:-10]
print(domain)

hello_world

#एक फ़ंक्शन लिखें जो किसी दिए गए स्ट्रिंग से हर तीसरे अक्षर को लौटाता है।

text = "Programming"
print(text[::3])

Pgmn

#एक फ़ंक्शन लिखें जो हर दूसरे अक्षर को छोड़ देता है और फिर परिणामी स्ट्रिंग को उलट देता है।

text1 = "Programming"
print(text1[::-2])

gimroP

#एक फ़ंक्शन लिखें जो किसी दिए गए स्ट्रिंग से सम सूचकांकों पर वर्ण निकालता है और लौटाता है।

text = "Programming"
print(text[::2])

Pormig

ठीक है, यही यहां की बुनियादी बात है।

...