Python Strings — Immutability, Indexing, Slicing, Methods & f-Strings Explained

The Story That Explains Strings 📿Strings समझाने वाली कहानी 📿一个解释字符串的故事 📿

A string (str) is a sequence of characters inside quotes. Strings hold all text in Python — names, messages, file names, URLs, JSON, HTML. It is the data type you will use most often in real programs.

String (str) quotes के अंदर लिखा characters का क्रम है। Python में सारा text strings में रहता है — नाम, संदेश, file के नाम, URLs, JSON, HTML। असली programs में यही data type आप सबसे ज़्यादा इस्तेमाल करेंगे।

字符串（str）是放在引号里的字符序列。Python 中所有文本都用字符串表示 —— 名字、消息、文件名、URL、JSON、HTML。它是真实程序中你最常用的数据类型。

Creating Strings — Four Ways ✍️Strings बनाना — चार तरीक़े ✍️创建字符串 —— 四种方式 ✍️

Python gives you four ways to write a string. Each has a job. Knowing which to pick is the first sign of a fluent Python programmer.

Python string लिखने के चार तरीक़े देता है। हर एक का अपना काम है। कौन सा चुनना है, यह जानना Python में माहिर होने की पहली निशानी है।

Python 提供四种方式来书写字符串，各有用途。知道何时用哪种，是熟练 Python 程序员的第一个标志。

name = 'Asha'
quote = 'She said "Python is fun"'      # double quotes inside — no escaping
message = "Hello, World!"
apostrophe = "it's a wonderful day"     # apostrophe inside — no escaping

poem = """Roses are red,
Violets are blue,
Python is awesome,
And so are you."""


def greet(name):
    """Return a greeting for the given name."""   # a docstring
    return f"Hello, {name}!"


windows_path = r"C:\Users\Asha\new_folder"      # raw string: backslashes stay
regex_pattern = r"\d+\.\d+"

print(name, message)
print(quote, "|", apostrophe)
print(poem)
print(windows_path, regex_pattern)
print(repr(""), len(""), bool(""))              # the empty string is real, and falsy

Immutability — What It Really Means 🔒Immutability — असल में इसका मतलब 🔒不可变性 —— 真正的含义 🔒

Immutability has a precise meaning: the object's data cannot change after it is created. You can still point the variable name at a different string. That only moves the label to a new object. The old string is unchanged, and Python frees it when nothing uses it any more.

Immutability का एक सटीक मतलब है: बनने के बाद object का data नहीं बदल सकता। आप variable का नाम अब भी किसी दूसरी string की ओर कर सकते हैं। इससे सिर्फ़ label नए object पर जाता है। पुरानी string वैसी ही रहती है, और जब कोई उसे इस्तेमाल नहीं करता तो Python उसे मुक्त कर देता है।

不可变性有精确的含义：对象创建后，其数据不能改变。你仍然可以让变量名指向另一个字符串，这只是把标签挪到了新对象上。旧字符串保持不变，没有任何东西再使用它时，Python 会释放它。

Immutability in Action — See It for YourselfImmutability काम करते हुए — ख़ुद देखिए不可变性实战 —— 亲眼看看

word = "Python"
try:
    word[0] = "J"
except TypeError as err:
    print("TypeError:", err)

original = "hello"
uppercase = original.upper()
print(original, uppercase)
print(original is uppercase)          # two different objects

name = "Asha"
first = id(name)
name = name + " Verma"                # looks like a change…
print(name, id(name) == first)        # …but it is a new object

Mutable vs Immutable — Side by SideMutable बनाम Immutable — आमने-सामने可变 vs 不可变 —— 并排对比

* A tuple is hashable only if everything inside it is hashable. (1, "a") works as a key; (1, [2]) does not.

* Tuple तभी hashable है जब उसके अंदर का सब कुछ hashable हो। (1, "a") key बन सकता है; (1, [2]) नहीं।

* 只有当元组里的所有元素都可哈希时，元组才可哈希。(1, "a") 能作键；(1, [2]) 不能。

Why Immutability Exists — The Design Reasons 🧠Immutability क्यों है — Design के कारण 🧠为什么要不可变 —— 设计原因 🧠

This was not an accident. Python's designers made strings immutable on purpose. Here are four strong reasons. Knowing them helps you decide when to use a string and when to use a list.

यह संयोग नहीं था। Python के designers ने strings को जान-बूझकर immutable बनाया। इसके चार मज़बूत कारण हैं। इन्हें जानकर आप तय कर पाएँगे कि कब string लगानी है और कब list।

这不是偶然。Python 的设计者有意让字符串不可变，背后有四个有力的理由。了解它们能帮你判断什么时候用字符串、什么时候用列表。

Proof: Interning and Hashingसबूत: Interning और Hashing证明：驻留与哈希

a = "hello"
b = "hello"
print(a is b)                  # True: identifier-like literals are interned

c = "hello world"
d = "".join(["hello", " world"])    # built at run time
print(c == d, c is d)          # equal text, different objects — always compare with ==

user_ages = {"asha": 30, "ravi": 25, "meena": 35}
print(user_ages["asha"])       # strings work as dict keys: they are hashable
print(hash("asha") == hash("as" + "ha"))

try:
    bad = {[1, 2, 3]: "value"}
except TypeError as err:
    print("TypeError:", err)

String Indexing — Reading One Character 🔍String Indexing — एक Character पढ़ना 🔍字符串索引 —— 读取单个字符 🔍

A string is a sequence, so every character has a position number (index). Python counts from zero: the first character is at index 0, not 1. You can also use negative indexes to count backwards from the end.

String एक sequence है, इसलिए हर character का एक स्थान-अंक (index) है। Python शून्य से गिनता है: पहला character index 0 पर है, 1 पर नहीं। आप अंत से उल्टा गिनने के लिए negative indexes भी लगा सकते हैं।

字符串是序列，所以每个字符都有一个位置编号（索引）。Python 从零开始数：第一个字符在索引 0，而不是 1。你也可以用负索引从末尾倒着数。

word = "PYTHON"
print(word[0], word[1], word[5])
print(word[-1], word[-2], word[-6])
print(len(word))

name = "Alexander"
print(f"{name} starts with '{name[0]}' and ends with '{name[-1]}'")

try:
    word[10]
except IndexError as err:
    print("IndexError:", err)

String Slicing — Taking a Piece ✂️String Slicing — एक टुकड़ा लेना ✂️字符串切片 —— 取出一段 ✂️

Slicing takes a part of a string. The syntax is s[start:stop:step]. All three parts are optional, so you get a lot of power from very little code.

Slicing string का एक हिस्सा लेती है। Syntax है s[start:stop:step]। तीनों हिस्से वैकल्पिक हैं, इसलिए बहुत थोड़े code से बहुत काम होता है।

切片取出字符串的一部分，语法是 s[start:stop:step]。三个部分都是可选的，用很少的代码就能做很多事。

s = "Python Programming"
print(repr(s[0:6]), repr(s[7:18]))
print(repr(s[:6]), repr(s[7:]), repr(s[:]))
print(repr(s[-11:]), repr(s[:-12]))
print(repr(s[::2]), repr(s[0:6:2]))
print(repr(s[::-1]))
print(repr(s[100:200]))          # slicing never raises IndexError

We print with repr() so you can see the quotes. That makes the last line clear: s[100:200] is the empty string '', not an error.

हम repr() से छापते हैं ताकि quotes दिखें। इससे आख़िरी line साफ़ होती है: s[100:200] empty string '' है, error नहीं।

我们用 repr() 打印，这样能看到引号。最后一行因此一目了然：s[100:200] 是空字符串 ''，而不是错误。

Slicing Cheat SheetSlicing Cheat Sheet切片速查表

String Methods — The Essential Toolkit 🧰String Methods — ज़रूरी औज़ार 🧰字符串方法 —— 必备工具箱 🧰

Python strings come with 47 public methods (count them with [m for m in dir(str) if not m.startswith("_")]). You do not need to memorise them. The groups below cover almost all real work. Remember: a method never changes the original string. It returns a new value.

Python strings में 47 public methods हैं ([m for m in dir(str) if not m.startswith("_")] से गिनें)। इन्हें रटने की ज़रूरत नहीं। नीचे के समूह लगभग सारा असली काम संभाल लेते हैं। याद रखें: method असली string को कभी नहीं बदलता। वह एक नया मान लौटाता है।

Python 字符串有 47 个公开方法（用 [m for m in dir(str) if not m.startswith("_")] 数一数）。不必全部记住，下面几组几乎覆盖了所有实际工作。记住：方法从不修改原字符串，而是返回一个新值。

Case MethodsCase Methods大小写方法

text = "hello WORLD from Python"
print(text.upper())
print(text.lower())
print(text.title())
print(text.capitalize())
print(text.swapcase())
print(text)                          # unchanged!

text.upper()                         # result thrown away…
print(text)                          # …so text is still the same
text = text.upper()                  # keep the result by reassigning
print(text)

Whitespace & Cleaning MethodsWhitespace और सफ़ाई Methods空白与清理方法

messy = "   Hello, World!   \n"
print(repr(messy.strip()))
print(repr(messy.lstrip()))
print(repr(messy.rstrip()))

url = "https://example.com/"
print(url.strip("/"))
print("xxhixyx".strip("xy"))          # the argument is a SET of characters, not a word
print("report.txt".removesuffix(".txt"), "www.site.in".removeprefix("www."))   # 3.9+: remove an exact word

Search & Replace Methodsखोज और बदलाव Methods查找与替换方法

sentence = "Python is great, Python is easy"
print(sentence.find("Python"), sentence.find("Java"), sentence.rfind("Python"))
print(sentence.index("is"))
try:
    sentence.index("Java")
except ValueError as err:
    print("ValueError:", err)
print(sentence.count("Python"), sentence.count(" "))
print(sentence.replace("Python", "Ruby"))
print(sentence.replace("Python", "Ruby", 1))

find() returns -1 when it finds nothing; index() raises ValueError. Use index() when a missing value means a real bug.

कुछ न मिले तो find() -1 लौटाता है; index() ValueError देता है। जब ग़ायब मान असली bug हो तब index() लगाएँ।

找不到时 find() 返回 -1，而 index() 抛出 ValueError。如果找不到意味着真正的 bug，就用 index()。

split() and join() — The Power Couplesplit() और join() — दमदार जोड़ीsplit() 与 join() —— 黄金搭档

csv = "apple,banana,cherry,date"
print(csv.split(","))
print("  hello   world  from    python  ".split())    # no argument: any run of whitespace
print(csv.split(",", 2))
print("line 1\nline 2\nline 3".splitlines())
print("a,,b".split(","), "a  b".split(" "))          # an explicit separator keeps empty pieces

words = ["Python", "is", "awesome"]
print(" ".join(words))
print("-".join(words))
print(", ".join(words))
print("".join(words))

messy = "  hello   world  from    python  "
print(repr(" ".join(messy.split())))

try:
    print(", ".join(["a", 1]))
except TypeError as err:
    print("TypeError:", err)
print(", ".join(str(x) for x in ["a", 1]))

join() is called on the separator, and every item must already be a string. Convert numbers first, as the last line does.

join() separator पर call होता है, और हर item पहले से string होना चाहिए। संख्याओं को पहले बदलें, जैसा आख़िरी line करती है।

join() 是在分隔符上调用的，而且每一项都必须已经是字符串。先把数字转换成字符串，就像最后一行那样。

rsplit() — Splitting from the Rightrsplit() — दाएँ से काटनाrsplit() —— 从右边分割

rsplit() is the mirror image of split(). It starts cutting from the right. Without maxsplit both give the same list. The difference shows only when you limit the number of cuts.

rsplit() split() का आईना है। यह दाएँ से काटना शुरू करता है। maxsplit के बिना दोनों एक ही list देते हैं। फ़र्क़ तभी दिखता है जब आप कटों की संख्या सीमित करते हैं।

rsplit() 是 split() 的镜像，从右边开始切。不给 maxsplit 时两者结果相同，只有限制切分次数时才会看出差别。

csv = "apple,banana,cherry,date"
print(csv.split(","))
print(csv.rsplit(","))
print(csv.split(",", 1))
print(csv.rsplit(",", 1))
print(csv.split(",", 2))
print(csv.rsplit(",", 2))

filename = "my.backup.v2.tar.gz"
print(filename.split(".", 1))
name, ext = filename.rsplit(".", 1)
print(f"Name: {name}, Extension: {ext}")

full_name = "Mary Jane Watson Parker"
first_names, surname = full_name.rsplit(" ", 1)
print(f"First names: {first_names}")
print(f"Surname:     {surname}")

path = "/home/asha/projects/python/hello.py"
folder, file = path.rsplit("/", 1)
print(f"Folder: {folder}")
print(f"File:   {file}")

url = "https://blog.example.com/2026/python/strings-tutorial"
base, slug = url.rsplit("/", 1)
print(f"Slug: {slug}")

Checking Methods and Paddingजाँच Methods और Padding检查方法与填充

filename = "report_2026.pdf"
print(filename.startswith("report"), filename.endswith(".pdf"), filename.endswith((".pdf", ".doc")))
print("12345".isdigit(), "12.34".isdigit(), "hello".isalpha(), "hello123".isalnum())
print("   ".isspace(), "Hello".isupper(), "HELLO".isupper(), "hello".islower())
print("".isdigit(), "४२".isdigit(), "नमस्ते".isalpha())   # empty → False; Devanagari digits count;
# नमस्ते has vowel signs (्, े) that Unicode does not call letters, so isalpha() is False

name = "Asha"
print(name.ljust(15, "."))
print(name.rjust(15, "."))
print(name.center(15, "-"))
print("42".zfill(5), "-42".zfill(5))

Methods ReferenceMethods सूची方法速查

Concatenation, Repetition & Membership ➕जोड़ना, दोहराना और सदस्यता ➕拼接、重复与成员检测 ➕

+ joins two strings, * repeats one, and in / not in check whether one string appears inside another. Note that + only joins str with str.

+ दो strings जोड़ता है, * एक को दोहराता है, और in / not in जाँचते हैं कि एक string दूसरी के अंदर है या नहीं। ध्यान दें कि + सिर्फ़ str के साथ str जोड़ता है।

+ 拼接两个字符串，* 重复一个字符串，in / not in 检查一个字符串是否出现在另一个之中。注意 + 只能拼接 str 与 str。

first, last = "Hello", "World"
print(first + ", " + last + "!")
age = 25
try:
    msg = "I am " + age
except TypeError as err:
    print("TypeError:", err)
print("I am " + str(age))
print("-" * 40)
print("HA" * 3, "> " * 5)

sentence = "The quick brown fox jumps over the lazy dog"
print("fox" in sentence, "cat" not in sentence, "FOX" in sentence)
print("FOX".lower() in sentence.lower())

f-Strings — Modern String Formatting 🪄f-Strings — आधुनिक String Formatting 🪄f-字符串 —— 现代字符串格式化 🪄

Basic f-Stringsबुनियादी f-Strings基本 f-字符串

name, age = "Asha", 30
print(f"Hello, {name}. You are {age} years old.")
print(f"Next year: {age + 1}")
print(f"Loud: {name.upper()}")
print(f"Initial: {name[0]}")
print(f"Full: {name} ({age})")
report = f"""
── User Report ────────────────
  Name: {name}
  Age:  {age}
  Adult: {age >= 18}
"""
print(report)

Format Specifiers — The Real PowerFormat Specifiers — असली ताक़त格式说明符 —— 真正的威力

After a colon inside the braces you can say how to show the value: width, alignment, decimal places, number base and more.

Braces के अंदर colon के बाद आप बता सकते हैं कि मान कैसे दिखे: चौड़ाई, alignment, दशमलव स्थान, संख्या का आधार और भी बहुत कुछ।

在花括号内的冒号之后，你可以指定值如何显示：宽度、对齐、小数位、进制等等。

price = 12345.678
print(f"Price: ₹{price:,.2f}")
pass_rate = 0.847
print(f"Pass rate: {pass_rate:.1%}")

print(f"{'NAME':<10}{'AGE':>5}{'SCORE':>10}")
print(f"{'-' * 25}")
print(f"{'Asha':<10}{30:>5}{95.5:>10.1f}")
print(f"{'Ravi':<10}{25:>5}{88.2:>10.1f}")
print(f"{'Meena':<10}{35:>5}{92.7:>10.1f}")

x = 42
print(f"{x=}")

from datetime import datetime
when = datetime(2026, 10, 29, 14, 23, 45)       # a fixed time so the output is repeatable
print(f"Date: {when:%Y-%m-%d}")
print(f"Time: {when:%H:%M:%S}")
print(f"{3.99:.0f} {1234567:.2e} {10:b} {10:o} {255:X} {42:05d}")

Older Formatting Styles — For Reading Old Codeपुराने Formatting तरीक़े — पुराना Code पढ़ने के लिए旧式格式化 —— 用于阅读旧代码

import timeit
name, age = "Asha", 30
for label, stmt in [("f-string ", 'f"Hi, {name}, {age}"'),
                    (".format()", '"Hi, {}, {}".format(name, age)'),
                    ("% style  ", '"Hi, %s, %s" % (name, age)')]:
    best = min(timeit.repeat(stmt, globals=globals(), number=200_000, repeat=7))
    print(f"{label}: {best * 5:.3f} s per million")   # best of 7 runs

Escape Characters, Raw Strings & Unicode 🔣Escape Characters, Raw Strings और Unicode 🔣转义字符、原始字符串与 Unicode 🔣

Sometimes a string needs a character that would confuse Python: a quote inside quotes, a new line, a tab, or a real backslash. That is what escape sequences are for. They all start with a backslash \.

कभी-कभी string में ऐसा character चाहिए जो Python को उलझा दे: quotes के अंदर quote, नई line, tab, या असली backslash। इसी के लिए escape sequences हैं। ये सब backslash \ से शुरू होते हैं।

有时字符串需要一个会让 Python 困惑的字符：引号里的引号、换行、制表符或真正的反斜杠。这就是转义序列的用途，它们都以反斜杠 \ 开头。

print("Line 1\nLine 2")
print("Name:\tAsha")
print("She said \"hi\"")
print('It\'s fine')
print("C:\\Users\\Asha")
print(r"C:\Users\new_folder")
print("caf\u00e9", "\N{GREEK SMALL LETTER PI}", "\U0001F600")
print(len("C:\new"), repr("C:\new"))     # \n is ONE character (a newline): the path is broken

Look at the last line: "C:\new" has length 5, not 6, because \n became one newline character. The path broke silently. A \U is even worse — Python cannot even read the file:

आख़िरी line देखिए: "C:\new" की length 5 है, 6 नहीं, क्योंकि \n एक newline character बन गया। Path चुपचाप टूट गया। \U तो और बुरा है — Python file पढ़ ही नहीं पाता:

看最后一行："C:\new" 的长度是 5 而不是 6，因为 \n 变成了一个换行符。路径被悄无声息地破坏了。\U 更糟 —— Python 连文件都读不了：

print("C:\Users\new_folder")

Unicode: Every Language Is WelcomeUnicode: हर भाषा का स्वागतUnicode：欢迎所有语言

A Python 3 string is a sequence of Unicode code points, so Hindi, Chinese and emoji work out of the box. len() counts code points, ord() gives a character's number, and chr() turns a number back into a character.

Python 3 की string Unicode code points का क्रम है, इसलिए हिन्दी, चीनी और emoji सीधे काम करते हैं। len() code points गिनता है, ord() किसी character का अंक देता है, और chr() अंक को वापस character बनाता है।

Python 3 的字符串是 Unicode 码位（code point）的序列，所以印地语、中文和 emoji 都能直接使用。len() 统计码位数，ord() 给出字符的编号，chr() 把编号变回字符。

for word in ["Python", "नमस्ते", "你好", "😀"]:
    print(repr(word), "len =", len(word), "| first code point =", ord(word[0]))
print(chr(65), chr(2350), chr(20320))
print("apple" < "banana", "Zebra" < "apple", ord("Z"), ord("a"))
print(sorted(["banana", "apple", "Cherry"]))
print(sorted(["banana", "apple", "Cherry"], key=str.lower))

Iterating Over Strings 🔁Strings पर Loop 🔁遍历字符串 🔁

A string is a sequence, so a for loop walks through it one character at a time. Use enumerate() when you also need the index.

String एक sequence है, इसलिए for loop उसमें एक-एक character चलता है। Index भी चाहिए तो enumerate() लगाएँ।

字符串是序列，所以 for 循环会逐个字符遍历它。还需要索引时，用 enumerate()。

word = "Python"
for letter in word:
    print(letter, end=" ")
print()
for i, letter in enumerate(word):
    print(f"Index {i}: {letter}")

sentence = "The quick brown fox jumps"
vowels = "aeiouAEIOU"
count = 0
for char in sentence:
    if char in vowels:
        count += 1
print(f"Vowel count: {count}")
print(f"Vowel count: {sum(1 for c in sentence if c in vowels)}")

The last line does the same count in one line with sum() and a generator. Both ways print 6.

आख़िरी line वही गिनती sum() और generator से एक line में करती है। दोनों तरीक़े 6 छापते हैं।

最后一行用 sum() 加生成器在一行里完成同样的计数，两种方式都输出 6。

Complete Practice Program — String Toolkit 🛠️पूरा अभ्यास Program — String Toolkit 🛠️完整练习程序 —— 字符串工具箱 🛠️

This program uses every idea from the lesson — creation, indexing, slicing, methods, iteration and f-strings — in one working script. The output below is a real run.

यह program lesson का हर विचार — बनाना, indexing, slicing, methods, iteration और f-strings — एक चलती script में इस्तेमाल करता है। नीचे का output असली run है।

这个程序在一个可运行的脚本里用到了本课的所有概念 —— 创建、索引、切片、方法、遍历和 f-字符串。下面的输出是真实运行结果。

# string_toolkit.py — All string concepts in one program

def analyse_text(text):
    """Analyse a string and return a report dictionary."""
    return {
        "length":      len(text),
        "words":       len(text.split()),
        "upper":       text.upper(),
        "lower":       text.lower(),
        "reversed":    text[::-1],
        "first_word":  text.split()[0] if text.strip() else "",
        "last_word":   text.split()[-1] if text.strip() else "",
        "vowels":      sum(1 for c in text.lower() if c in "aeiou"),
        "digits":      sum(1 for c in text if c.isdigit()),
        "spaces":      text.count(" "),
    }

def format_report(text, stats):
    """Build a nicely formatted report using f-strings."""
    line = "═" * 50

    return f"""
{line}
  STRING ANALYSIS REPORT
{line}

  Input:      "{text[:40]}{'...' if len(text) > 40 else ''}"

  Length:     {stats['length']:>5} characters
  Words:      {stats['words']:>5}
  Vowels:     {stats['vowels']:>5}
  Digits:     {stats['digits']:>5}
  Spaces:     {stats['spaces']:>5}

  First word: {stats['first_word']}
  Last word:  {stats['last_word']}

  Uppercase:  {stats['upper'][:40]}
  Reversed:   {stats['reversed'][:40]}
{line}
"""

def main():
    # Sample text — try changing this!
    sample = "Python is a POWERFUL programming language, released in 1991."

    # Analyse and display
    stats = analyse_text(sample)
    print(format_report(sample, stats))

    # Bonus: check some properties using string methods
    print(f"  Contains 'Python'? {'Python' in sample}")
    print(f"  Starts with 'Py'?  {sample.startswith('Py')}")
    print(f"  Ends with '.'?     {sample.endswith('.')}")

    # Clean and rebuild sentence — the split+join pattern
    normalised = " ".join(sample.lower().split())
    print(f"\n  Normalised: {normalised}")

if __name__ == "__main__":
    main()

Golden Rules 🏆सुनहरे नियम 🏆黄金法则 🏆