साक्षात्कारों के लिए Python स्ट्रिंग API
पार्सिंग और रूपांतरण वाली साक्षात्कार-समस्याओं में आने वाले split, join, replace, find, ord/chr और स्ट्रिंग फ़ॉर्मैटिंग के तरीकों का अभ्यास कीजिए।
साक्षात्कारों के लिए Python स्ट्रिंग API, CoddyKit पर DSA Interview Prep का एक निःशुल्क पाठ है। यह 4 में से 1वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह DSA Interview Prep सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। DSA Interview Prep पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
पाइथन में स्ट्रिंग अपरिवर्तनीय होती हैं
पाइथन स्ट्रिंग अपरिवर्तनीय होती हैं — आप किसी अक्षर को उसी स्थान पर बदल नहीं सकते। स्ट्रिंग को बदलने वाली प्रतीत होने वाली प्रत्येक क्रिया वास्तव में नई स्ट्रिंग बनाती है। इसलिए s[0] = 'X' से TypeError उत्पन्न होता है। जब आपको स्थान पर परिवर्तन करना हो, तो पहले अक्षरों की सूची में बदलें, अपना काम करें, फिर पुनर्निर्माण के लिए ''.join(chars) का उपयोग करें। स्ट्रिंग में परिवर्तन वाली समस्याओं के लिए साक्षात्कारों में यही मानक प्रतिरूप है।
s = 'hello'
# s[0] = 'H' # TypeError!
# In-place mutation pattern:
chars = list(s)
chars[0] = 'H'
result = ''.join(chars)
print(result) # 'Hello'
# Reversing a string
print(s[::-1]) # 'olleh'
print(''.join(reversed(s))) # 'olleh'split() और join(): पार्सिंग और निर्माण
s.split(sep) किसी विभाजक पर स्ट्रिंग को बाँटता है और उप-स्ट्रिंगों की सूची लौटाता है। sep=None (डिफ़ॉल्ट) किसी भी रिक्त-स्थान पर बाँटता है और खाली स्ट्रिंग हटा देता है — रिक्त-स्थान से अलग किए गए इनपुट को पार्स करने के लिए यह आदर्श है। 'sep'.join(iterable) स्ट्रिंगों के बीच विभाजक रखकर उन्हें जोड़ता है। ' '.join(words) सूची से रिक्त-स्थान द्वारा अलग की गई स्ट्रिंग बनाने का कुशल तरीका है — लूप में कभी भी + का उपयोग न करें।
# split
sentence = ' hello world '
words = sentence.split() # ['hello', 'world']
print(words)
csv = 'a,b,c,d'
parts = csv.split(',') # ['a', 'b', 'c', 'd']
print(parts)
# join
print(' '.join(words)) # 'hello world'
print(','.join(['x','y','z'])) # 'x,y,z'
# Reverse words in a sentence
print(' '.join(sentence.split()[::-1])) # 'world hello'find(), index(), और सदस्यता-जाँच
s.find(sub) sub की पहली उपस्थिति का सूचकांक लौटाता है, या न मिलने पर -1 लौटाता है। s.index(sub) भी यही काम करता है, लेकिन अनुपस्थित होने पर ValueError उत्पन्न करता है — अनियंत्रित अपवादों से बचने के लिए साक्षात्कार के कोड में find को प्राथमिकता दीजिए। स्ट्रिंग के लिए in ऑपरेटर O(n×m) उप-स्ट्रिंग खोज करता है, जो find के समान है। बिना कॉपी बनाए किसी स्लाइस के भीतर खोजने के लिए वैकल्पिक start और end मापदंडों का उपयोग कीजिए।
s = 'abcabcabc'
print(s.find('bc')) # 1 (first occurrence)
print(s.find('bc', 2)) # 4 (search from index 2)
print(s.find('xyz')) # -1 (not found)
print('abc' in s) # True
# Count occurrences manually
count = 0
start = 0
while True:
idx = s.find('bc', start)
if idx == -1: break
count += 1
start = idx + 1
print(count) # 3replace(), strip() और अक्षर-रूप विधियाँ
s.replace(old, new, count=-1) सभी उपस्थिति, या पहली count उपस्थिति, को बदलकर नई स्ट्रिंग लौटाता है। s.strip() आरंभ और अंत के रिक्त-स्थान, या निर्दिष्ट अक्षर, हटा देता है। lower(), upper(), capitalize() और swapcase() जैसी अक्षर-रूप विधियाँ नई स्ट्रिंग बनाती हैं — याद रखिए कि ये मान लौटाती हैं, स्ट्रिंग में बदलाव नहीं करतीं। अक्षर-रूप की तुलना से पहले उसे सामान्य करना अक्षर-रूप-असंवेदनशील समस्याओं के लिए आवश्यक है।
s = ' Hello, World! '
print(s.strip()) # 'Hello, World!'
print(s.strip().lower()) # 'hello, world!'
print('banana'.replace('a', 'o')) # 'bonono'
print('banana'.replace('a', 'o', 2)) # 'bonona'
# Normalise for comparison
def same_ignoring_case(a, b):
return a.lower() == b.lower()
print(same_ignoring_case('Racecar', 'racecar')) # Truestartswith(), endswith(), और isalnum()
शर्त-जाँच वाली स्ट्रिंग विधियाँ बूलियन मान लौटाती हैं और k लंबाई वाले प्रतिरूप के लिए O(k) समय लेती हैं। s.startswith(prefix) और s.endswith(suffix) अनेक विकल्पों के लिए टपल स्वीकार करते हैं। s.isalpha(), s.isdigit(), s.isalnum() और s.isspace() अक्षर-वर्गों की जाँच करते हैं। इनका उपयोग मान्य-पैलिंड्रोम, मान्य-संख्या और यूआरएल-पार्सिंग की साक्षात्कार समस्याओं में किया जाता है।
print('hello'.startswith('hel')) # True
print('hello'.endswith(('lo', 'la'))) # True
# isalnum for palindrome filtering
def clean(s):
return ''.join(c.lower() for c in s if c.isalnum())
print(clean('A man, a plan, a canal: Panama'))
# 'amanaplanacanalpanama'
print(clean('123abc!@#'))
# '123abc'ord(), chr(), और ASCII अंकगणित
ord(c) अक्षर c का यूनिकोड कोड-बिंदु लौटाता है। chr(n) किसी पूर्णांक को फिर से अक्षर में बदलता है। छोटे अक्षरों के लिए ord(c) - ord('a') से 0-25 मिलता है — हैश मानचित्र के बिना निश्चित आकार 26 की आवृत्ति सारणी बनाने का यह साफ़ तरीका है और अंग्रेज़ी वर्णमाला के लिए व्यवहार में अधिक तेज़ है। यह तकनीक विपर्यय और पैलिंड्रोम समस्याओं में दिखाई देती है।
print(ord('a')) # 97
print(ord('z')) # 122
print(chr(65)) # 'A'
# Frequency array for lowercase letters
def char_freq(s):
freq = [0] * 26
for c in s:
freq[ord(c) - ord('a')] += 1
return freq
print(char_freq('anagram')) # [3,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0]
# index 0='a'(3), 6='g'(1), 12='m'(1), 17='r'(1)आउटपुट के लिए स्ट्रिंग स्वरूपण
कोडिंग साक्षात्कारों में कभी-कभी साफ़ आउटपुट भी महत्वपूर्ण होता है। पाइथन तीन स्वरूपण शैलियाँ देता है: प्रतिशत-स्वरूपण (पुराना), .format() (पारंपरिक) और एफ-स्ट्रिंग (आधुनिक, पसंदीदा)। एफ-स्ट्रिंग सबसे अधिक पठनीय होती हैं और सीधे अभिव्यक्तियों का समर्थन करती हैं: f'{value:.2f}' किसी दशमलव संख्या को 2 दशमलव स्थानों तक स्वरूपित करता है। संख्याओं का स्वरूपण करना, स्ट्रिंग में रिक्त स्थान भरना और सारणियाँ शीघ्रता से छापना जानने से दबाव में त्रुटि-निवारण का समय कम होता है।
name = 'Alice'
score = 95.678
# f-string (preferred in interviews)
print(f'{name}: {score:.1f}') # Alice: 95.7
print(f'{name:>10}: {score:05.1f}') # right-align
# Zero-pad an integer
print(f'{42:04d}') # 0042
# Join and format a list
nums = [1, 2, 3, 4]
print(', '.join(str(n) for n in nums)) # '1, 2, 3, 4'join() से कुशल स्ट्रिंग निर्माण
लूप में + से स्ट्रिंग जोड़ने पर हर पुनरावृत्ति में नई स्ट्रिंग बनती है, जिससे n अक्षरों के लिए कुल O(n²) लागत आती है। सही प्रतिरूप यह है: भागों को सूची में जोड़ते जाइए और अंत में ''.join(parts) चलाइए, जिसकी लागत O(n) है। यह पाइथन के प्रदर्शन से जुड़ी सबसे आम गलत प्रथाओं में से एक है। साक्षात्कार में इस समझौते का उल्लेख करने से पता चलता है कि आप पाइथन के स्मृति मॉडल को समझते हैं।
# SLOW: O(n^2) due to repeated string allocation
def build_bad(chars):
s = ''
for c in chars:
s += c # creates a new string each time!
return s
# FAST: O(n)
def build_good(chars):
parts = []
for c in chars:
parts.append(c)
return ''.join(parts) # single allocation
# Or even more concise:
def build_best(chars):
return ''.join(chars)
print(build_best(['h','e','l','l','o'])) # 'hello'स्ट्रिंग से पूर्णांक और दशमलव संख्याएँ पार्स करना
पार्सिंग समस्याओं में स्ट्रिंग और संख्याओं के बीच रूपांतरण मूलभूत है। int(s) और float(s) संख्यात्मक स्ट्रिंग को पार्स करते हैं; अमान्य इनपुट पर वे ValueError उत्पन्न करते हैं। अधिक सुरक्षित पार्सिंग के लिए try-except खंड का उपयोग कीजिए। रूपांतरण से पहले प्रारंभिक जाँच के लिए स्ट्रिंग विधियाँ isdigit() और isnumeric() उपयोगी हैं। स्ट्रिंग से पूर्णांक में बदलने जैसी समस्याओं में आरंभिक रिक्त-स्थान, चिह्न और अतिप्रवाह संभालना आवश्यक होता है।
def my_atoi(s):
s = s.lstrip() # remove leading spaces
if not s: return 0
sign = 1
idx = 0
if s[0] in '-+':
sign = -1 if s[0] == '-' else 1
idx = 1
num = 0
while idx < len(s) and s[idx].isdigit():
num = num * 10 + int(s[idx])
idx += 1
result = sign * num
INT_MAX, INT_MIN = 2**31 - 1, -(2**31)
return max(INT_MIN, min(INT_MAX, result))
print(my_atoi(' -42')) # -42
print(my_atoi('4193 with words')) # 4193एल्गोरिद्म समस्याओं में स्ट्रिंग स्लाइसिंग
स्ट्रिंग स्लाइसिंग का लगातार उपयोग होता है, लेकिन इसकी कुछ छिपी हुई लागतें हैं: s[i:j] j-i लंबाई वाली नई स्ट्रिंग बनाता है और O(j-i) समय लेता है। जब आपको पुनरावर्ती फलनों में उप-स्ट्रिंग भेजनी हो, तो O(n²) आवंटन लागत से बचने के लिए वास्तविक उप-स्ट्रिंग के बजाय सूचकांक (start, end) भेजने पर विचार कीजिए। यह अनुकूलन सबसे लंबी पैलिंड्रोम-स्ट्रिंग जैसी समस्याओं में महत्वपूर्ण है, जहाँ अनेक उप-स्ट्रिंग की जाँच की जाती है।
# Naive: O(n^3) because slicing inside nested loops
def is_palindrome_naive(s):
return s == s[::-1] # O(n) slice + O(n) compare
# Pass indices to avoid allocating substrings
def is_palindrome_range(s, left, right):
while left < right:
if s[left] != s[right]:
return False
left += 1; right -= 1
return True # O(right-left) time, O(1) space
print(is_palindrome_range('racecar', 0, 6)) # True
print(is_palindrome_range('hello', 0, 4)) # Falseस्ट्रिंग साक्षात्कार त्वरित संदर्भ
साक्षात्कारों के लिए इन स्ट्रिंग विधियों को अच्छी तरह याद रखें:
split / join— विभाजित करना और बनानाstrip / lstrip / rstrip— रिक्त स्थान हटानाlower / upper— अक्षरों के रूप को सामान्य करनाfind / index— उप-स्ट्रिंग ढूँढनाreplace— प्रतिस्थापनisalnum / isalpha / isdigit— वर्ण-श्रेणी की जाँचord / chr— निश्चित-वर्णमाला वाली समस्याओं के लिए ASCII अंकगणितstartswith / endswith— उपसर्ग और प्रत्यय की जाँच
# Combining methods: reverse words, preserve spaces
def reverse_words(s):
return ' '.join(reversed(s.split()))
print(reverse_words(' hello world '))
# 'world hello'
# Check anagram using sorted strings
def is_anagram(s, t):
return sorted(s) == sorted(t)
print(is_anagram('anagram', 'nagaram')) # True
print(is_anagram('rat', 'car')) # Falseत्वरित जाँच
इस पाठ में सिखाई गई डेटा संरचनाएँ और एल्गोरिदम — कोडिंग साक्षात्कार की तैयारी से जुड़ी अवधारणाओं की अपनी समझ जाँचिए।
पाठ का पुनरावलोकन
इस पाठ में आपने सीखा: Python की स्ट्रिंग अपरिवर्तनीय होती हैं — उनमें बदलाव करने के लिए उन्हें सूची में बदलना, संशोधित करना और फिर दोबारा जोड़ना पड़ता है, ऑर्ड/सीएचआर छोटे अक्षरों वाली समस्याओं के लिए 26 आकार की निश्चित-आकार वाली आवृत्ति सरणियाँ बनाने में सक्षम करते हैं, जो सीमित वर्णमालाओं के लिए हैश मानचित्रों से तेज़ होती हैं, और लूप में + का उपयोग करके स्ट्रिंग बनाने में O(n²) समय लगता है — हमेशा सूची में तत्व एकत्र करें और अंत में ''.join() का उपयोग करके O(n) समय में स्ट्रिंग बनाएँ। आगे हम उप-स्ट्रिंग समस्याओं के लिए स्लाइडिंग विंडो तकनीक का अध्ययन करेंगे।
एआई शिक्षक के साथ Python सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 30
- पाठ
- 120
अक्सर पूछे जाने वाले प्रश्न
क्या “साक्षात्कारों के लिए Python स्ट्रिंग API” पाठ निःशुल्क है?
हाँ — DSA Interview Prep अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “साक्षात्कारों के लिए Python स्ट्रिंग API” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। DSA Interview Prep पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“साक्षात्कारों के लिए Python स्ट्रिंग API” में मैं क्या सीखूँगा?
पार्सिंग और रूपांतरण वाली साक्षात्कार-समस्याओं में आने वाले split, join, replace, find, ord/chr और स्ट्रिंग फ़ॉर्मैटिंग के तरीकों का अभ्यास कीजिए। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ DSA Interview Prep का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या DSA Interview Prep शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर DSA Interview Prep शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 1वाँ पाठ है।
“साक्षात्कारों के लिए Python स्ट्रिंग API” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस DSA Interview Prep पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर DSA Interview Prep पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- साक्षात्कारों के लिए Python स्ट्रिंग API
- उपस्ट्रिंग के लिए स्लाइडिंग विंडो
- Anagram और अक्षर-आवृत्ति मानचित्र
- स्ट्रिंग एन्कोडिंग, उलटना और Palindrome