# Python में स्ट्रिंग: split, replace, strip, join, स्लाइस और f-strings

URL: https://skillaria.top/hi/guides/python/stroki-python

Python की स्ट्रिंग (str टाइप) बदली न जा सकने वाली यूनिकोड अक्षरों की श्रृंखला है। split() स्ट्रिंग को सूची में तोड़ता है, join() सूची को वापस जोड़ता है, replace() हिस्सा बदलता है, strip() किनारों से स्पेस हटाता है; हर मेथड नई स्ट्रिंग लौटाता है। मान जोड़ने का सबसे सुविधाजनक तरीका f-string है: f"{name}: {price:.2f}"।

Python की स्ट्रिंग हर प्रोग्राम में मिलती है: उपयोगकर्ता का इनपुट, फ़ाइलों के नाम, CSV की पंक्तियाँ, API के जवाब। `str` टाइप टेक्स्ट को यूनिकोड में रखता है, इसलिए हिंदी, कन्नड़ या इमोजी बिना किसी सेटिंग के चलते हैं। सबसे ज़्यादा इस्तेमाल होने वाले मेथड `split`, `replace`, `strip` और `join` हैं, और मान दिखाने के लिए f-strings सबसे सुविधाजनक हैं। इन सबको उदाहरणों से समझते हैं।

## Python में स्ट्रिंग कैसे बनती है

स्ट्रिंग एकल या दोहरे उद्धरण चिह्नों में लिखी जाती है — इनमें कोई फ़र्क नहीं: `'कॉफ़ी'` और `"कॉफ़ी"` एक जैसी हैं। तीन उद्धरण चिह्नों से बनी स्ट्रिंग कई लाइनों की होती है, जिसमें नई लाइनें जैसी हैं वैसी ही रहती हैं।

```
name = "कॉफ़ी"
note = """पहली लाइन
दूसरी लाइन"""
print(len(name))  # 5 — अक्षरों की संख्या
```

स्ट्रिंग की सबसे अहम खूबी यह है कि वह बदली नहीं जा सकती। मेथड स्ट्रिंग को नहीं बदलता, बल्कि नई स्ट्रिंग लौटाता है। इसलिए `s.replace("a", "b")` बिना असाइनमेंट के कुछ नहीं बदलता — लिखना होता है `s = s.replace("a", "b")`। नए छात्रों की यह सबसे आम गलती है।

### विशेष अक्षर, नई लाइन और raw स्ट्रिंग

नई लाइन `\n` से लिखी जाती है, टैब `\t` से, और बैकस्लैश `\\` से। `r` उपसर्ग स्ट्रिंग को «raw» बना देता है: उसमें बैकस्लैश को विशेष अर्थ नहीं मिलता। यह Windows के पथों और रेगुलर एक्सप्रेशन में काम आता है।

```
print("कुल:\n350 ₹")
path = r"C:\new\table.csv"   # \n और \t विशेष अक्षर नहीं बनेंगे
```

लंबे व्यंजन को कोड में अगली लाइन पर ले जाने के लिए उसे कोष्ठक में लिखें: कोष्ठक के भीतर आसपास की स्ट्रिंग लिटरल Python खुद जोड़ देता है।

## split: स्ट्रिंग को सूची में तोड़ना

`split()` स्ट्रिंग को विभाजक से तोड़कर सूची लौटाता है। बिना तर्क के यह किसी भी खाली स्थान पर तोड़ता है और दोहराए गए स्पेस को अनदेखा करता है — कमांड पार्स करने के लिए यह सुविधाजनक है।

```
"add  कॉफ़ी 250".split()        # ['add', 'कॉफ़ी', '250']
"2026-10-16".split("-")        # ['2026', '10', '16']
"a,b,,c".split(",")            # ['a', 'b', '', 'c']
"key=value=x".split("=", 1)    # ['key', 'value=x']
```

ध्यान दें: साफ़ विभाजक दिए जाने पर खाली टुकड़े बचे रहते हैं। दूसरा तर्क `maxsplit` कटों की संख्या सीमित करता है, और `rsplit()` दाईं ओर से काटता है। टेक्स्ट को पंक्तियों में बाँटने के लिए `splitlines()` लें: यह `\n` और `\r\n` दोनों समझता है और अंत में खाली तत्व नहीं छोड़ता।

```
text = "कॉफ़ी\nटैक्सी\n"
text.split("\n")     # ['कॉफ़ी', 'टैक्सी', '']
text.splitlines()    # ['कॉफ़ी', 'टैक्सी']
```

## join: सूची को स्ट्रिंग में जोड़ना

`join()` उलटा काम करता है। इसे विभाजक वाली स्ट्रिंग पर बुलाया जाता है, और तर्क में स्ट्रिंगों की सूची दी जाती है:

```
items = ["कॉफ़ी", "टैक्सी", "भोजन"]
print(", ".join(items))   # कॉफ़ी, टैक्सी, भोजन
print("\n".join(items))   # हर आइटम नई लाइन पर
```

सभी तत्व स्ट्रिंग होने चाहिए, वरना `TypeError: sequence item 0: expected str instance, int found` आएगा। पहले संख्याओं को बदलें: `", ".join(str(x) for x in amounts)`।

### स्ट्रिंग जोड़ना (कॉन्केटनेशन)

दो स्ट्रिंग `+` से जोड़ी जा सकती हैं, और `*` से दोहराई जा सकती हैं: `"-" * 20`। लेकिन लूप में `+=` से सैकड़ों टुकड़े जोड़ना धीमा है, क्योंकि हर बार नई स्ट्रिंग बनती है। टुकड़ों को सूची में रखें और एक `join()` से जोड़ें। स्ट्रिंग और संख्या को सीधे नहीं जोड़ा जा सकता: `"कुल: " + 5` `TypeError` देगा, इसके लिए `str()` या f-string चाहिए।

## replace: हिस्सा बदलना

`replace(old, new)` उप-स्ट्रिंग के सभी हिस्से बदलता है। तीसरा तर्क बदलावों की संख्या सीमित करता है।

```
price = "1 250,50"
price = price.replace(" ", "").replace(",", ".")
print(float(price))                  # 1250.5

"अ-ब-स".replace("-", "+", 1)         # 'अ+ब-स'
```

यह मेथड अक्षरों के आकार (केस) का फ़र्क करता है और सिर्फ़ हू-ब-हू मेल खोजता है। पैटर्न से बदलाव (जैसे «सभी अंक») के लिए मॉड्यूल `re` और `re.sub()` लगते हैं।

## strip, lstrip, rstrip: स्ट्रिंग के किनारे काटना

`strip()` दोनों किनारों से स्पेस, टैब और नई लाइन हटाता है। `lstrip()` सिर्फ़ बाईं ओर, `rstrip()` सिर्फ़ दाईं ओर साफ़ करता है। उपयोगकर्ता के इनपुट और फ़ाइल की पंक्तियों के साथ सबसे पहले यही करें।

```
raw = "  कॉफ़ी \n"
raw.strip()       # 'कॉफ़ी'
raw.rstrip()      # '  कॉफ़ी'
"xxकॉफ़ीxx".strip("x")   # 'कॉफ़ी'
```

तर्क अक्षरों का समूह है, पूरी उप-स्ट्रिंग नहीं: `"abcटेक्स्टcba".strip("abc")` किनारों से किसी भी क्रम में सारे a, b और c हटा देगा। सिर्फ़ उपसर्ग या प्रत्यय हटाने के लिए `removeprefix()` और `removesuffix()` लें (Python 3.9 से)।

## स्ट्रिंग के अन्य उपयोगी मेथड

| मेथड | क्या करता है | उदाहरण → परिणाम |
| --- | --- | --- |

| `lower()`, `upper()` | अक्षरों का आकार | `"Coffee".lower()` → `'coffee'` |

| `startswith()`, `endswith()` | शुरुआत और अंत की जाँच | `"a.csv".endswith(".csv")` → `True` |

| `find()` | उप-स्ट्रिंग की स्थिति या -1 | `"कॉफ़ी".find("फ़")` → `3` |

| `count()` | कितनी बार आया | `"banana".count("a")` → `3` |

| `isdigit()` | सिर्फ़ अंक हैं? | `"250".isdigit()` → `True` |

| `zfill()` | आगे शून्य भरना | `"7".zfill(3)` → `'007'` |

यह जाँचने के लिए कि स्ट्रिंग में कोई उप-स्ट्रिंग है या नहीं, `in` ऑपरेटर सबसे आसान है: `if "कॉफ़ी" in text.lower():`। स्ट्रिंगों की तुलना `==` से अक्षर-दर-अक्षर और केस के फ़र्क के साथ होती है; बिना केस के तुलना के लिए दोनों को `casefold()` से बदलें।

## स्ट्रिंग के स्लाइस

स्ट्रिंग एक श्रृंखला है, इसलिए अक्षरों तक शून्य से शुरू होने वाले इंडेक्स से पहुँचा जा सकता है, और ऋणात्मक इंडेक्स अंत से गिनता है। स्लाइस `s[start:stop:step]` उप-स्ट्रिंग लौटाता है; दाईं सीमा शामिल नहीं होती।

```
s = "Python"
s[0]      # 'P'
s[-1]     # 'n'
s[0:3]    # 'Pyt'
s[2:]     # 'thon'
s[::2]    # 'Pto'
s[::-1]   # 'nohtyP' — स्ट्रिंग को उल्टा करना
```

सीमा से बाहर जाने पर स्लाइस त्रुटि नहीं देता: `s[0:100]` पूरी स्ट्रिंग लौटा देगा। पर `s[100]` `IndexError` देगा। किसी इंडेक्स का अक्षर बदला नहीं जा सकता (`s[0] = "J"` — `TypeError`), इसके लिए नई स्ट्रिंग बनानी होती है: `"J" + s[1:]`।

## Python में f-strings

स्ट्रिंग से पहले `f` का मतलब है कि कर्ली ब्रैकेट के भीतर के व्यंजनों का मान निकालकर टेक्स्ट में डाला जाएगा। Python 3.6 से यह स्ट्रिंग फ़ॉर्मेट करने का मुख्य तरीका है: `format()` से छोटा और पुराने `%` ऑपरेटर से तेज़।

```
item = "कॉफ़ी"
price = 250
print(f"{item}: {price} ₹")              # कॉफ़ी: 250 ₹
print(f"छूट के बाद: {price * 0.9} ₹")    # छूट के बाद: 225.0 ₹
print(f"{item=}")                         # item='कॉफ़ी' — डिबगिंग के लिए सुविधाजनक
```

### संख्याओं का फ़ॉर्मेट और संरेखण

ब्रैकेट के भीतर कोलन के बाद फ़ॉर्मेट स्पेसिफ़ायर लिखा जाता है। इससे गोलाई, अंकों के बीच विभाजक, चौड़ाई और संरेखण तय होते हैं:

| लिखावट | परिणाम | अर्थ |
| --- | --- | --- |

| `f"{3.14159:.2f}"` | `3.14` | 2 अंकों तक गोलाई |

| `f"{1250000:,}"` | `1,250,000` | अंकों का विभाजक |

| `f"{1250000:_}"` | `1_250_000` | कॉमा की जगह अंडरस्कोर |

| `f"{0.256:.1%}"` | `25.6%` | प्रतिशत |

| `f"{'कॉफ़ी':<10}|"` | `कॉफ़ी |` | बाईं ओर, चौड़ाई 10 |

| `f"{250:>8}"` | ` 250` | दाईं ओर |

| `f"{7:03d}"` | `007` | शून्य से भरना |

संरेखण टर्मिनल की तालिकाओं के लिए काम का है: `f"{name:<12}{amount:>10.2f}"` कॉलम सीधे लाइन में लगा देगा। ध्यान रहे, फ़ॉर्मेटिंग सिर्फ़ छापते समय होती है। पैसे को पूर्णांक (पैसों में) या `Decimal` में रखें, `float` में नहीं: `0.1 + 0.2` का परिणाम `0.30000000000000004` आता है।

### f-string के भीतर उद्धरण और नई लाइन

Python 3.12 (PEP 701) से f-strings का औपचारिक व्याकरण बना है: कर्ली ब्रैकेट के भीतर बाहर वाले जैसे ही उद्धरण चिह्न, बैकस्लैश और नई लाइनें इस्तेमाल हो सकती हैं, और नेस्टिंग की सीमा नहीं रही। ब्रैकेट के भीतर की गलती अब सटीक जगह बताती है। पुराने वर्ज़न पर भीतर अलग प्रकार के उद्धरण लिखें: `f"{d['key']}"`, और नई लाइन के लिए अलग वेरिएबल या `chr(10)` लें।

कई लाइनों वाले टेक्स्ट के लिए तीन उद्धरण चिह्नों वाली f-string ठीक है: `f"""कुल: {total}\nआइटम: {count}"""`।

### format() और % — पुराने तरीके

पुराने कोड में `"{}: {}".format(item, price)` और `"%s: %d" % (item, price)` मिलेंगे। `format()` के स्पेसिफ़ायर वही हैं जो f-strings के। `format()` आज भी उपयोगी है, जब टेम्पलेट डेटा से अलग रखा जाए, जैसे किसी कॉन्फ़िग फ़ाइल में।

## स्ट्रिंग पार्स करना: व्यावहारिक उदाहरण

अब सारे मेथड एक साथ। मान लें फ़ाइल से पंक्तियाँ आती हैं जैसे `"  2026-10-16; कॉफ़ी ; 250,50 \n"`, और हमें तारीख़, नाम और पैसे पैसों (पैसे की छोटी इकाई) में चाहिए। क्रम सामान्य है: किनारे साफ़ करें, विभाजक से काटें, हर हिस्से को साफ़ करें, फिर प्रकार बदलें।

```
line = "  2026-10-16; कॉफ़ी ; 250,50 \n"

date, item, raw_amount = [p.strip() for p in line.strip().split(";")]
amount_kop = round(float(raw_amount.replace(",", ".")) * 100)

print(date, item, amount_kop)            # 2026-10-16 कॉफ़ी 25050
print(f"{item:10.2f}")
```

अगर हिस्से तीन से अलग निकले, तो अनपैकिंग `ValueError: not enough values to unpack` या `too many values to unpack` के साथ गिरेगी। असली कोड में ऐसी पंक्तियाँ पहले से जाँचें या अपवाद पकड़ें। असली CSV फ़ाइलों के लिए, जिनमें उद्धरण चिह्न और एस्केप होते हैं, `split` की जगह स्टैंडर्ड मॉड्यूल `csv` लें।

### स्ट्रिंग की आम गलतियाँ

- **मेथड का परिणाम सहेजा नहीं गया**: बिना असाइनमेंट के `s.strip()` कुछ नहीं बदलता।
- **संख्याओं की सूची पर join** — `TypeError`; पहले `map(str, ...)`।
- **strip में उप-स्ट्रिंग देना**: तर्क अक्षरों का समूह है; उपसर्ग के लिए `removeprefix()`।
- **केस के फ़र्क वाली तुलना**: `"कॉफ़ी" == "कॉफ़ी "` — `False`, और `"Coffee" == "coffee"` भी `False`।
- **Windows के पथ में बैकस्लैश** `r` उपसर्ग के बिना विशेष अक्षर बन जाते हैं।

## t-strings: तैयार टेक्स्ट की जगह टेम्पलेट

Python 3.14 में t-strings आए। देखने में ये f-strings जैसी हैं, बस उपसर्ग `t` है, पर परिणाम अलग है: तैयार स्ट्रिंग की जगह `string.templatelib.Template` ऑब्जेक्ट। इसमें टेक्स्ट के टुकड़े (`.strings`) और डाले गए मान (`.values`) अलग-अलग रहते हैं।

```
name = ""
tpl = t"नमस्ते, {name}!"
print(tpl.strings)   # ('नमस्ते, ', '!')
print(tpl.values)    # ('',)
```

यह किसलिए है: लाइब्रेरी जोड़ने से पहले मान ले सकती है और उन्हें संभाल सकती है — जैसे HTML में कोणीय ब्रैकेट एस्केप करना, या SQL क्वेरी में पैरामीटर सही तरीके से भेजना। f-string को यह मौका नहीं मिलता, क्योंकि वह सब कुछ पहले ही जोड़ चुकी होती है। सामान्य छपाई के लिए अब भी f-strings ही लें।

## निष्कर्ष

रोज़मर्रा के काम के लिए Python की स्ट्रिंग के थोड़े-से औज़ार काफ़ी हैं: `split()` और `join()` टेक्स्ट को तोड़ते और जोड़ते हैं, `strip()` इनपुट साफ़ करता है, `replace()` हिस्से बदलता है, स्लाइस उप-स्ट्रिंग काटते हैं, और f-strings मान सही फ़ॉर्मेट में दिखाते हैं। एक बात याद रखें: स्ट्रिंग बदली नहीं जाती, मेथड नई स्ट्रिंग लौटाता है, उसे सहेजना होता है। स्ट्रिंग, संख्याओं और f-strings को ख़र्च ट्रैकर के उदाहरण पर कोर्स के Python लेक्चर में व्यवहार में समझाया गया है।

## FAQ

**Python में स्ट्रिंग की लंबाई कैसे पता करें?**

फ़ंक्शन len(s) अक्षरों की संख्या लौटाता है। हिंदी और इमोजी के लिए यूनिकोड अक्षर गिने जाते हैं, बाइट नहीं; बाइट में आकार len(s.encode("utf-8")) से मिलता है।

**संख्या को स्ट्रिंग में और वापस कैसे बदलें?**

str(250) से '250' मिलता है, और int("250") व float("2.5") उल्टा करते हैं। अगर स्ट्रिंग संख्या जैसी न हो, तो int() ValueError देगा, इसलिए इनपुट जाँचें।

**मेरी स्ट्रिंग को replace क्यों नहीं बदल रहा?**

स्ट्रिंग बदली नहीं जा सकती, replace नई स्ट्रिंग लौटाता है। परिणाम को असाइन करें: s = s.replace("a", "b")।

**यह कैसे जाँचें कि स्ट्रिंग खाली है?**

खाली स्ट्रिंग गलत मानी जाती है, इसलिए if not s: काफ़ी है। अगर स्ट्रिंग में सिर्फ़ स्पेस हो सकते हैं, तो if not s.strip(): जाँचें।

**t-string और f-string में क्या फ़र्क है?**

f-string तुरंत तैयार str लौटाती है, जबकि t-string (Python 3.14+) अलग-अलग टुकड़ों और मानों वाला Template ऑब्जेक्ट है। इससे HTML और SQL के लिए डेटा सुरक्षित तरीके से एस्केप किया जा सकता है।


---
Source: Skillaria.Top (https://skillaria.top)