String methods — upper, lower, strip, split, join, replace, find, format

1.2.12 · Coding › Introduction to Programming (Python)

WHAT each method does (aur HOW karta hai)

Definition Aath kaam ke ghode

s.upper() / s.lower() ::: ek copy return karta hai jisme saare letters upar/neeche case ho jaate hain. Non-letters untouched rehte hain.
s.strip() ::: ek copy return karta hai jisme leading & trailing whitespace hata di jaati hai (strip(chars) unke bajaaye un chars mein se koi bhi hata deta hai).
s.split(sep) ::: string ko pieces ki ek list mein kaat deta hai, har sep par break karke. Koi sep nahi → whitespace ke kisi bhi run par split karo.
sep.join(list) ::: split ka ulta — strings ki ek iterable ko sep unke beech rakhke joD deta hai.
s.replace(old, new) ::: ek copy return karta hai jisme old ki har occurrence ko new se swap kar diya jaata hai.
s.find(sub) ::: sub ki pehli occurrence ka index return karta hai, ya -1 agar absent ho.
"...{}...".format(x) ::: {} placeholders mein values insert karke ek string build karta hai.

Behaviour ko first principles se derive karna

Tumhe yeh memorise karne ki zaroorat nahi — tum inhe reconstruct kar sakte ho. String characters ki ek sequence hoti hai jो 0,1,2,... index hoti hai. Har method bas un characters pe ek loop hai:

Formula

find scratch se (Python internally kya karta hai) Substring t ko s ke andar find karne ke liye, len(t) lambaai ki ek window ko s ke across slide karo: $find (s, t) = min {i : s [i : i + ∣ t ∣] = t} or - 1 if no such i$

def my_find(s, t):
    n, m = len(s), len(t)
    for i in range(n - m + 1):     # last valid start = n-m
        if s[i:i+m] == t:
            return i
    return -1

n - m + 1 kyun? Agar t ki length m hai, toh aakhri position jahan woh abhi bhi fit ho sakta hai index n-m se shuru hoti hai. range(n-m+1) us index ko inclusive banata hai.

Formula

join split ka ulta hai Ek separator c ke liye jisme koi special meaning nahi: $c . join (s . split (c)) = s (if s has no leading/trailing/edge issues)$ Conceptually join list ko walk karta hai aur consecutive pieces ke beech piece + sep likhta hai:

def my_join(sep, parts):
    out = ""
    for i, p in enumerate(parts):
        if i > 0:
            out += sep        # sep goes BETWEEN, not after the last
        out += p
    return out

if i > 0 kyun? Separator items ke beech baithta hai, isliye len(parts)-1 separators hote hain, len(parts) nahi.

Figure — String methods — upper, lower, strip, split, join, replace, find, format

Worked examples

Worked example 1 — Ek messy username clean karo

raw = "   Alice@Example.COM  \n"
clean = raw.strip().lower()
# -> "alice@example.com"

strip() pehle kyun? Invisible spaces aur \n ko hatao taaki woh email mein survive na karein.
lower() kyun? Emails case-insensitive hote hain; normalise karne se == comparisons reliably kaam karti hain.
Chain kyun? strip() ek string return karta hai, isliye hum turant us result par .lower() call kar sakte hain.

Worked example 2 — Ek CSV line parse karo aur use rebuild karo

line = "id,name,city"
fields = line.split(",")          # ['id', 'name', 'city']
rebuilt = " | ".join(fields)      # 'id | name | city'

split(",") kyun? Ek flat string ko ek aise list mein badle jise hum index/loop kar sakein.
join kyun, + nahi? join "between only" spacing automatically handle karta hai aur kaafi pieces ke liye bahut tez hai.

Worked example 3 —

replace vs find

text = "the cat sat"
text.find("cat")          # 4  (index where 'cat' starts)
text.find("dog")          # -1 (absent → sentinel, NOT an error)
text.replace("cat","dog") # 'the dog sat'

-1 kyun, crash nahi? Ek sentinel tumhe if text.find(x) != -1: test karne deta hai bina exception handling ke.
replace sab kyun change karta hai? Yeh har match replace karta hai; count limit karne ke liye ek 3rd arg pass karo: s.replace("a","b",1).

Worked example 4 — Report line build karne ke liye

format

name, score = "Bob", 0.8736
msg = "{} scored {:.1%}".format(name, score)
# -> 'Bob scored 87.4%'

{:.1%} kyun? Format spec 100 se multiply karta hai aur 1 decimal + % dikhata hai. Spec kyun? Yeh value ko presentation se alag karta hai.

Common mistakes (Steel-manned)

Active recall

Recall Peek karne se pehle try karo

s.strip() ke baad reassign kyun karna padta hai?
Substring missing hone par find kya return karta hai?
split() aur split(' ') mein kya fark hai?
join likho jo ['a','b','c'] ke beech - rakhe.

Recall Ek 12-saal ke bacche ko explain karo (Feynman)

Socho ek string super-glued LEGO letters ki ek row hai — tum kabhi nahi original row ko rearrange kar sakte. Isliye har "tool" aslmein tumhare liye ek fresh copy banata hai. upper ek chillane wali copy banata hai, strip ek copy banata hai jiske khaali edges katey hue hain, split row ko chhoti rows ki ek basket mein har comma par snap kar deta hai, aur join ek basket ko ek row mein vapas joD deta hai beech mein ek chosen sticker rakhke. Kyunki yeh sab tumhe ek nayi row dete hain, tumhe use rakhna hoga (name = ...) warna woh ud jaayegi.

Flashcards

Are Python strings mutable or immutable?

Immutable — har method ek NAYA string return karta hai.

s.upper() digits/symbols ke saath kya karta hai?

Kuch nahi; sirf letters case hote hain.

s.strip() kya remove karta hai?

Leading aur trailing whitespace (ya strip(chars) mein koi bhi chars).

Difference: "a b".split() vs "a b".split(' ')?

['a','b'] (collapse karta hai) vs ['a','','b'] (empty rakhta hai).

sep.join(list) kya karta hai?

List items ko ek string mein joD deta hai sep unke beech rakhke (split ka ulta).

join n items ke liye kitne separators insert karta hai?

n − 1 (sirf items ke beech).

s.replace("a","b") kya replace karta hai?

HAR occurrence (limit karne ke liye count arg add karo).

s.find("x") kya return karta hai agar "x" absent ho?

-1 (ek sentinel, error nahi).

if s.find("a"): buggy kyun hai?

Index 0 par match falsy hai; != -1 use karo ya in operator.

"{:.1%}".format(0.5) kya deta hai?

'50.0%' (×100, 1 decimal, percent sign).

Length-n string mein length-m sub find karte waqt last valid start index?

n − m.

name.strip() ke baad reassign kyun karo?

Original unchanged hai; cleaned copy return value hai.

Connections

Strings — indexing and slicing (find s[i:i+m] par rely karta hai)
Lists (split ek list produce karta hai, join ek consume karta hai)
Immutability in Python
f-strings (.format ka modern alternative)
Boolean truthiness (kyun 0/-1 traps find ke saath hote hain)
User input and validation