స్ట్రింగ్స్ డీప్ డైవ్ & స్లైసింగ్ (String Mastery)

🐍 Modern Python (Python 3.12+) 🎯 Chapter 9 of 25 ⚙️ Phase 02: కంట్రోల్ ఫ్లో, లూప్స్ & స్ట్రింగ్స్ 📅 2026 Edition
📌 Covered in this chapter: Unicode UTF-8 ఆర్కిటెక్చర్ · పాజిటివ్ & నెగటివ్ ఇండెక్సింగ్ · String Slicing [start:stop:step] · ఇమ్మ్యుటబిలిటీ · 25+ బిల్ట్-ఇన్ మెథడ్స్ (casefold, split, join, strip) · Python 3.9+ removeprefix() & removesuffix() · Medical Prescription NLP Parser ప్రాజెక్ట్!
కంప్యూటర్ సైన్స్‌లో అత్యధికంగా ప్రాసెస్ చేయబడే డేటా రూపం టెక్స్ట్ (Text). వెబ్‌సైట్లు, చాట్‌బాట్‌లు, మెసేజ్‌లు, ఫైల్స్, API రెస్పాన్స్‌లు — అన్నీ స్ట్రింగ్స్ రూపంలోనే ఉంటాయి. సాంప్రదాయ C లాంగ్వేజ్‌లో స్ట్రింగ్స్ అంటే నల్-టెర్మినేటెడ్ క్యారెక్టర్ ఎరేలు (Null-terminated char arrays), వాటిని మార్చడం ఎంతో తలనొప్పిగా ఉండేది. కానీ పైథాన్ స్ట్రింగ్ ఆర్కిటెక్చర్ ప్రపంచంలోనే అత్యుత్తమమైనది! పైథాన్‌లో స్ట్రింగ్స్ డిఫాల్ట్‌గా పూర్తి యూనికోడ్ (Unicode UTF-8) కు సపోర్ట్ చేస్తాయి, అంటే తెలుగు అక్షరాలు, సంస్కృతం, చైనీస్ మరియు ఆధునిక ఎమోజీలను నేరుగా ప్రాసెస్ చేయవచ్చు. ఈ తొమ్మిదవ అధ్యాయంలో — స్ట్రింగ్ మెమరీ నిర్మాణం, నెగటివ్ ఇండెక్సింగ్, శక్తివంతమైన [start:stop:step] స్లైసింగ్ ఫార్ములా, 25+ ఇన్-బిల్ట్ స్ట్రింగ్ మెథడ్స్, మరియు వైద్యుల ప్రిస్క్రిప్షన్లను విశ్లేషించే పూర్తి స్థాయి Automated Clinical Prescription & Patient Record NLP Parser ప్రాజెక్ట్ ద్వారా స్ట్రింగ్స్‌పై సంపూర్ణ ఆధిపత్యం సాధిద్దాం!

1 పైథాన్ స్ట్రింగ్ ఆర్కిటెక్చర్ (Unicode, UTF-8 & PEP 393 Memory Model)

పైథాన్ 2 లో సాధారణ స్ట్రింగ్స్ (ASCII) మరియు యూనికోడ్ స్ట్రింగ్స్ వేర్వేరుగా ఉండేవి. కానీ Python 3 లో ప్రతి స్ట్రింగ్ కూడా బై-డిఫాల్ట్ యూనికోడ్ (Unicode)!

అయితే ప్రపంచంలోని అన్ని భాషల అక్షరాలను నిల్వ చేయడానికి చాలా మెమరీ అవసరమవుతుంది. దీనిని ఆప్టిమైజ్ చేయడానికి Python 3.3 లో PEP 393 (Flexible String Representation) ప్రవేశపెట్టబడింది. పైథాన్ స్ట్రింగ్‌లోని అక్షరాల ఆధారంగా 3 రకాల మెమరీ స్ట్రక్చర్లను ఆటోమేటిక్‌గా ఎంచుకుంటుంది:

స్ట్రింగ్ రకం అక్షరాల పరిధి ప్రతి క్యారెక్టర్‌కు మెమరీ ఉదాహరణ
Latin-1 (PyASCIIObject) U+0000 నుండి U+00FF (సాధారణ ఇంగ్లీష్) 1 బైట్ (1 Byte) "Hello World"
UCS-2 (Two-byte string) U+0100 నుండి U+FFFF (తెలుగు, హిందీ, ఆసియా భాషలు) 2 బైట్లు (2 Bytes) "నమస్కారం పైథాన్"
UCS-4 (Four-byte string) U+10000+ (ఎమోజీలు, అరుదైన చిహ్నాలు) 4 బైట్లు (4 Bytes) "హలో 🚀🔥🐍"

2 పాజిటివ్ & నెగటివ్ ఇండెక్సింగ్ (String Indexing Architecture)

పైథాన్‌లో ఒక స్ట్రింగ్‌లోని ప్రతి అక్షరానికి ఒక స్థాన సంఖ్య (Index) ఉంటుంది. పైథాన్ రెండు దిశల ఇండెక్సింగ్‌ను సపోర్ట్ చేస్తుంది:

[పాజిటివ్ vs నెగటివ్ ఇండెక్సింగ్ డయాగ్రామ్] స్ట్రింగ్ క్యారెక్టర్లు : | P | Y | T | H | O | N | పాజిటివ్ ఇండెక్స్ : 0 1 2 3 4 5 (ఎడమ నుండి కుడికి: 0 to len-1) నెగటివ్ ఇండెక్స్ : -6 -5 -4 -3 -2 -1 (కుడి నుండి ఎడమకు: -1 to -len)

3 స్ట్రింగ్ స్లైసింగ్ మాస్టరీ (The [start:stop:step] Formula)

స్ట్రింగ్‌లోని ఒక భాగాన్ని (Substring) కత్తిరించి తీసుకోవడానికి స్లైసింగ్ (Slicing) సింటాక్స్‌ను ఉపయోగిస్తాము:

substring = string[start : stop : step]
స్లైసింగ్ సింటాక్స్ వివరణ & నియమం ఫలితం (s = "PYTHON")
s[1:4] ఇండెక్స్ 1 నుండి మొదలై 4 - 1 = 3 వరకు (stop ఎక్స్‌క్లూజివ్). "YTH"
s[:3] మొదటి నుండి ఇండెక్స్ 2 వరకు. "PYT"
s[2:] ఇండెక్స్ 2 నుండి చివరి వరకు. "THON"
s[:] మొత్తం స్ట్రింగ్ యొక్క కాపీ. "PYTHON"
s[::2] ప్రతి 2వ అక్షరాన్ని తీసుకుంటుంది (Step = 2). "PTO"
s[::-1] పైథాన్ రివర్స్ ట్రిక్: స్ట్రింగ్‌ను తిరగేస్తుంది! "NOHTYP"
💡 స్లైసింగ్ సూపర్-పవర్: No IndexError!

మీరు s[100] అని పిలిస్తే IndexError వస్తుంది. కానీ s[1:100] అని స్లైసింగ్ చేస్తే ఎర్రర్ రాదు! పైథాన్ తెలివిగా స్ట్రింగ్ ముగింపు వరకే కత్తిరించి (Bound clamping) ఇస్తుంది.

4 కోడ్ డెమో 1: ఇండెక్సింగ్, స్లైసింగ్ & పాలిండ్రోమ్ డిటెక్షన్

ఇండెక్సింగ్, నెగటివ్ స్లైసింగ్ మరియు ఒక పదం ముందుకు చదివినా వెనుకకు చదివినా ఒకేలా ఉండే పాలిండ్రోమ్ (Palindrome) తనిఖీని క్రింది కోడ్‌లో చూడండి:

01_indexing_slicing_palindrome.py
# స్ట్రింగ్ ఇండెక్సింగ్ & స్లైసింగ్ డెమో

tech_word = "HYDERABAD"

print(f"మొత్తం పదం : {tech_word}")
print(f"మొదటి అక్షరం (Index 0)  : {tech_word[0]}")
print(f"చివరి అక్షరం (Index -1) : {tech_word[-1]}")
print(f"ముందు 5 అక్షరాలు [:5]    : {tech_word[:5]}")
print(f"చివరి 3 అక్షరాలు [-3:]   : {tech_word[-3:]}")
print(f"రివర్స్ పదం [::-1]       : {tech_word[::-1]}")

# 2. పాలిండ్రోమ్ ఫంక్షన్ (Palindrome Check)
def check_palindrome(word: str):
    clean = word.strip().lower()
    is_pal = (clean == clean[::-1]) # ఒకే ఒక్క లైన్ స్లైసింగ్ మ్యాజిక్!
    status = "✅ పాలిండ్రోమ్ (సరిగ్గా సరిపోయింది)" if is_pal else "❌ పాలిండ్రోమ్ కాదు"
    print(f"పదం: '{word}' ──▶ {status}")

print("\n=== PALINDROME CHECKER ===")
check_palindrome("MADAM")
check_palindrome("RACECAR")
check_palindrome("PYTHON")

5 కేస్ కన్వర్షన్ మెథడ్స్ (lower, upper, title, casefold)

టెక్స్ట్ కేస్‌ను మార్చడానికి పైథాన్‌లో సమగ్రమైన మెథడ్స్ ఉన్నాయి:

6 సెర్చింగ్ & కౌంటింగ్ మెథడ్స్ (find, index, count, startswith)

స్ట్రింగ్‌లో ఏదైనా పదం లేదా అక్షరం ఎక్కడ ఉందో వెతకడానికి క్రింది మెథడ్స్ ఉపయోగపడతాయి:

మెథడ్ వివరణ ఐటెమ్ లేకపోతే ఏమి జరుగుతుంది?
s.find(sub) సబ్‌స్ట్రింగ్ యొక్క మొదటి ఇండెక్స్‌ను ఇస్తుంది. -1 ఇస్తుంది (సేఫ్!)
s.index(sub) సబ్‌స్ట్రింగ్ యొక్క మొదటి ఇండెక్స్‌ను ఇస్తుంది. ValueError లేపుతుంది! (క్రాష్ అవుతుంది)
s.count(sub) సబ్‌స్ట్రింగ్ ఎన్నిసార్లు పునరావృతమైందో లెక్కిస్తుంది. 0 ఇస్తుంది.
s.startswith(pre) స్ట్రింగ్ ఆ ప్రిఫిక్స్‌తో మొదలవుతుందో లేదో చెక్ చేస్తుంది. False ఇస్తుంది. టపుల్ ఇవ్వవచ్చు: s.startswith(('http', 'https'))
s.endswith(suf) స్ట్రింగ్ ఆ సఫిక్స్‌తో ముగుస్తుందో లేదో చెక్ చేస్తుంది. False ఇస్తుంది (ఉదా: ఫైల్ ఎక్స్‌టెన్షన్స్: s.endswith('.pdf')).

7 కోడ్ డెమో 2: సెర్చింగ్, ఫైల్ ఎక్స్‌టెన్షన్స్ & సేఫ్ లుకప్స్

క్రాష్ అవ్వకుండా find() మరియు startswith() ద్వారా సురక్షితమైన సెర్చింగ్ చేసే విధానాన్ని పరిశీలించండి:

02_string_searching_and_checks.py
# సెర్చింగ్ మరియు ఫైల్ చెకర్ డెమో

document_files = [
    "annual_report_2026.pdf",
    "employee_salaries.xlsx",
    "architecture_diagram.png",
    "audit_findings.PDF",
    "server_config.yaml"
]

print("=== డాక్యుమెంట్ వెరిఫికేషన్ నివేదిక ===")

for doc in document_files:
    # 1. కేస్-ఫోల్డింగ్ మరియు ఎక్స్‌టెన్షన్ తనిఖీ
    clean_name = doc.casefold()

    if clean_name.endswith((".pdf", ".xlsx")):
        doc_type = "ఆఫీస్ డాక్యుమెంట్"
    elif clean_name.endswith((".png", ".jpg")):
        doc_type = "చిత్రం (Image)"
    else:
        doc_type = "ఇతర కాన్ఫిగరేషన్ ఫైల్"

    # 2. find() ద్వారా ఇయర్ వెతకడం
    year_pos = clean_name.find("2026")
    year_info = f"[2026 సంవత్సరం ఫైల్ - ఇండెక్స్: {year_pos}]" if year_pos != -1 else "[సాధారణ ఫైల్]"

    print(f"ఫైల్: {doc:<28} రకం: {doc_type:<18} {year_info}")

8 మోడిఫికేషన్, ట్రిమ్మింగ్ & Python 3.9+ removeprefix()

యూజర్ ఇన్‌పుట్స్‌లోని అనవసరమైన ఖాళీలను తొలగించడానికి మరియు టెక్స్ట్‌ను రీప్లేస్ చేయడానికి:

🚀 Python 3.9+ కొత్త సూపర్ పవర్: removeprefix() & removesuffix()

పాత పైథాన్‌లో "https://example.com".lstrip("https://") అని రాస్తే ఒక ప్రమాదకరమైన బగ్ ఉండేది: lstrip అనేది ఆ అక్షరాల సెట్ మొత్తం తొలగిస్తుంది (ఉదా: 'e' తో మొదలైనా తీసేస్తుంది!).

దీనిని సరిచేయడానికి Python 3.9 లో వచ్చిన removeprefix() కేవలం ఖచ్చితమైన ఆ ప్రిఫిక్స్‌ను మాత్రమే సురక్షితంగా తొలగిస్తుంది:
url = "https://www.ourcompiler.com"
clean_url = url.removeprefix("https://") # Result: "www.ourcompiler.com"

9 స్ప్లిటింగ్ & జాయినింగ్ మెథడ్స్ (split, splitlines & join)

టెక్స్ట్ ప్రాసెసింగ్‌లో మరియు CSV ఫైల్స్ హ్యాండ్లింగ్‌లో split() మరియు join() జంట అత్యంత కీలకమైనవి:

⚡ పెర్ఫార్మెన్స్ టిప్: లూప్‌లలో s += text వాడకండి!

స్ట్రింగ్స్ ఇమ్మ్యుటబుల్ కాబట్టి, లూప్‌లో పదే పదే result += line అని రాస్తే ప్రతిసారీ కొత్త మెమరీ అలొకేట్ అయి $O(N^2)$ టైమ్ పడుతుంది! ప్రొడక్షన్ బెస్ట్ ప్రాక్టీస్: ముందుగా అన్ని ముక్కలను లిస్ట్‌లోకి అపెండ్ చేసి (lines.append(x)), చివరగా ఒక్కసారి "".join(lines) పిలవండి. ఇది 100 రెట్లు వేగంగా $O(N)$ లో పూర్తవుతుంది!

10 క్యారెక్టర్ టెస్టింగ్ & వాలిడేషన్ మెథడ్స్ (isalpha, isdigit, isalnum)

యూజర్ నమోదు చేసిన సమాచారాన్ని ధృవీకరించడానికి (Input Validation):

మెథడ్ షరతు (ఎప్పుడు True ఇస్తుంది?) ఉదాహరణ True ఉదాహరణ False
isalpha() అన్నీ కేవలం అక్షరాలు మాత్రమే ఉంటే. "Python" "Python3" (నంబర్ ఉంది)
isdigit() అన్నీ కేవలం సంఖ్యలే (0-9) అయితే. "987654" "₹ 500" (కరెన్సీ సింబల్)
isalnum() అక్షరాలు మరియు అంకెలు మాత్రమే ఉంటే (స్పేస్‌లు ఉండకూడదు). "User101" "User 101" (స్పేస్ ఉంది)
isspace() కేవలం ఖాళీలు (Spaces, Tabs, Newlines) మాత్రమే ఉంటే. " \n\t " " a "

11 కోడ్ డెమో 3: CSV శానిటైజేషన్, removeprefix & join() మాస్టరీ

ఈ పద్ధతులన్నింటినీ ఉపయోగించి కలుషితమైన CSV డేటాను క్లీన్ చేసి ప్రామాణిక రిపోర్ట్‌గా మార్చే స్క్రిప్ట్ చూడండి:

03_csv_string_sanitizer.py
# అడ్వాన్స్‌డ్ స్ట్రింగ్ క్లీనింగ్ & CSV ప్రాసెసింగ్ డెమో

raw_csv_record = "   SKU-90812 ;  స్మార్ట్ వాచ్ ప్రో  ; ₹ 3,499.00 ; IN_STOCK   \n"

# 1. strip() మరియు split()
clean_record = raw_csv_record.strip()
fields = [f.strip() for f in clean_record.split(";")]

sku_raw, item_title, raw_price, stock_status = fields

# 2. removeprefix() ద్వారా SKU ఐడిని శుభ్రం చేయడం (Python 3.9+)
sku_id = sku_raw.removeprefix("SKU-")

# 3. ధర నుండి సింబల్స్ తొలగించి ఫ్లోట్‌గా మార్చడం
clean_price = float(raw_price.replace("₹", "").replace(",", "").strip())

print("=== శానిటైజ్ చేయబడిన ప్రొడక్ట్ ఆబ్జెక్ట్ ===")
print(f"SKU కోడ్       : {sku_id}")
print(f"ఉత్పత్తి పేరు   : {item_title}")
print(f"శుద్ధ ధర        : ₹ {clean_price:,.2f}")
print(f"స్టాక్ స్థితి   : {stock_status}")

# 4. join() ద్వారా స్టాండర్డ్ పైప్ డీలిమిటెడ్ ఫార్మాట్ లోకి మార్చడం
output_line = " | ".join([sku_id, item_title, f"₹{clean_price:.2f}", stock_status])
print(f"\nస్టాండర్డ్ ఫార్మాట్ : {output_line}")

12 కామన్ బిగినర్స్ మిస్టేక్స్ & ప్రొడక్షన్ బెస్ట్ ప్రాక్టీసెస్

13 రియల్-వరల్డ్ ప్రాజెక్ట్: "Automated Clinical Prescription & Patient Record NLP Parser"

ఈ తొమ్మిదవ అధ్యాయంలో నేర్చుకున్న అన్ని అంశాలను (ఇండెక్సింగ్, స్లైసింగ్, split, join, strip, removeprefix, replace, కేస్ కన్వర్షన్స్) కలగలిపి — ఒక హాస్పిటల్ క్లినికల్ ప్రిస్క్రిప్షన్ టెక్స్ట్‌ను విశ్లేషించి డిజిటల్ హెల్త్ రికార్డ్ (EHR) గా మార్చే Automated Clinical Prescription NLP Parser ప్రాజెక్ట్‌ను నిర్మిద్దాం!

04_clinical_prescription_nlp_parser.py
# =====================================================================
# చాప్టర్ 09 మినీ ప్రాజెక్ట్: Automated Clinical Prescription NLP Parser
# కాన్సెప్ట్స్: Slicing, removeprefix(), splitlines(), split(), join(),
#             Sanitization, Table Formatting & Case Normalization
# =====================================================================

raw_prescription_note = """
PATIENT_ID: PID-98421
NAME: డా. సునీత వర్మ
AGE: 42 | GENDER: Female
DIAGNOSIS: Acute Bronchitis & Viral Fever
MEDICINES:
- Tab. Paracetamol 650mg ; Twice a day ; 5 Days
- Syp. Ambroxol Cough ; 10ml Thrice a day ; 7 Days
- Cap. Amoxicillin 500mg ; Morning & Night ; 5 Days
DOCTOR_ID: DOC-APX-880
"""

def parse_clinical_prescription(raw_text: str):
    """
    అస్తవ్యస్తమైన క్లినికల్ టెక్స్ట్‌ను విశ్లేషించి ప్రామాణిక డిశ్చార్జ్ సమ్మరీని ముద్రిస్తుంది.
    """
    print("\n" + "=" * 74)
    print(f"{'🏥 అపోలో కేర్ మల్టీ-స్పెషాలిటీ హాస్పిటల్ — డిజిటల్ ప్రిస్క్రిప్షన్':^74}")
    print("=" * 74)

    lines = [line.strip() for line in raw_text.strip().splitlines() if line.strip()]

    patient_id = ""
    patient_name = ""
    diagnosis = ""
    medicines = []
    doctor_code = ""

    for line in lines:
        if line.startswith("PATIENT_ID:"):
            patient_id = line.removeprefix("PATIENT_ID:").strip().removeprefix("PID-")
        elif line.startswith("NAME:"):
            patient_name = line.removeprefix("NAME:").strip()
        elif line.startswith("DIAGNOSIS:"):
            diagnosis = line.removeprefix("DIAGNOSIS:").strip().title()
        elif line.startswith("DOCTOR_ID:"):
            doctor_code = line.removeprefix("DOCTOR_ID:").strip()
        elif line.startswith("-"):
            # మందుల వివరాలు స్ప్లిట్ చేయడం
            med_entry = line.removeprefix("-").strip()
            parts = [p.strip() for p in med_entry.split(";")]
            medicines.append(parts)

    print(f"రోగి గుర్తింపు నం (PID): #{patient_id:<18} వైద్యుల కోడ్: {doctor_code}")
    print(f"రోగి పూర్తి పేరు       : {patient_name}")
    print(f"క్లినికల్ రోగనిర్ధారణ : {diagnosis}")
    print("-" * 74)
    print(f"{'క్ర.సం':<6} {'మందుల పేరు & డోసేజ్':<30} {'వాడే సమయం':<20} {'కాలపరిమితి':>12}")
    print("-" * 74)

    for idx, med in enumerate(medicines, start=1):
        name = med[0] if len(med) > 0 else "N/A"
        frequency = med[1] if len(med) > 1 else "N/A"
        duration = med[2] if len(med) > 2 else "N/A"
        print(f"{idx:<6} {name:<30} {frequency:<20} {duration:>12}")

    print("=" * 74)
    print(f"{'⚠️ దయచేసి మందులను డాక్టర్ సలహా మేరకే వేసుకోండి. సంపూర్ణ ఆరోగ్యం మీ హక్కు!':^74}")
    print("=" * 74 + "\n")

# లైవ్ రన్ టెస్ట్
parse_clinical_prescription(raw_prescription_note)

★ ఈ అధ్యాయంపై ప్రాక్టీస్ క్విజ్ (Knowledge Check)

1. s[::-1] సింటాక్స్ స్ట్రింగ్‌ను ఎలా రివర్స్ చేస్తుంది?
సమాధానం: స్లైసింగ్ ఫార్ములా [start:stop:step] లో start మరియు stop ఇవ్వనప్పుడు మొత్తం స్ట్రింగ్‌ను తీసుకుంటుంది. step = -1 అని ఇవ్వడం వల్ల కుడి వైపు చివరి అక్షరం నుండి ఎడమ వైపు మొదటి అక్షరం వరకు వెనుకకు అడుగులు వేస్తూ మొత్తం స్ట్రింగ్‌ను రివర్స్ చేస్తుంది.
2. find() కి మరియు index() కి మధ్య వ్యత్యాసం ఏమిటి?
సమాధానం: మనం వెతుకుతున్న సబ్‌స్ట్రింగ్ లేనప్పుడు find() ఎర్రర్ రాకుండా సురక్షితంగా -1 ఇస్తుంది. కానీ index() నేరుగా ValueError ను లేపుతుంది, దీనివల్ల ప్రోగ్రామ్ క్రాష్ అయ్యే ప్రమాదం ఉంది.
3. Python 3.9 లో వచ్చిన removeprefix() పాత lstrip() కంటే ఎందుకు మెరుగైనది?
సమాధానం: lstrip("abc") అనేది 'a', 'b', 'c' లలో ఏ అక్షరం మొదట్లో ఉన్నా తొలగిస్తుంది, ఇది కొన్నిసార్లు మనం తొలగించకూడదనుకున్న అక్షరాలను కూడా తొలగించే బగ్‌ను కలిగిస్తుంది. కానీ removeprefix("abc") కేవలం ఖచ్చితంగా "abc" అనే పదం మొదట్లో ఉన్నప్పుడు మాత్రమే దాన్ని తొలగిస్తుంది.
4. లూప్‌లో 's += text' రాసే బదులు join() వాడటం ఎందుకు శ్రేయస్కరం?
సమాధానం: స్ట్రింగ్స్ ఇమ్మ్యుటబుల్ కాబట్టి += చేసిన ప్రతిసారీ పాత స్ట్రింగ్ కాపీ అయి కొత్త మెమరీ అలొకేట్ అవుతుంది ($O(N^2)$ టైమ్). కానీ లిస్ట్‌లోకి అపెండ్ చేసి ఒకేసారి "".join(list) పిలిస్తే అవసరమైన మొత్తం మెమరీని ముందుగానే లెక్కించి ఒకేసారి కలుపుతుంది ($O(N)$ వేగం).
5. casefold() మెథడ్ lower() కంటే ఎందుకు శక్తివంతమైనది?
సమాధానం: lower() కేవలం ప్రాథమిక ASCII అక్షరాలను మాత్రమే మారుస్తుంది. కానీ casefold() పూర్తి యూనికోడ్ ప్రమాణాల ఆధారంగా అంతర్జాతీయ భాషల ప్రత్యేక అక్షరాలను (ఉదా: జర్మన్ 'ß' ను 'ss' గా) మార్చి మరింత పక్కాగా కేస్-ఇన్‌సెన్సిటివ్ పోలికను సాధ్యం చేస్తుంది.
← మునుపటి అధ్యాయం: 8. లూప్ కంట్రోల్ (break, continue, else) తర్వాతి అధ్యాయం: 10. రెగ్యులర్ ఎక్స్‌ప్రెషన్స్ (Regex) →

ఈ Clinical Prescription NLP Parser ను లైవ్‌గా మన కంపైలర్‌లో రన్ చేయండి!

ఎటువంటి లోకల్ సెటప్ లేకుండా, బ్రౌజర్‌లోనే Modern Python 3 కంపైలర్‌లో ఈ కోడ్‌ను ఎగ్జిక్యూట్ చేసి అవుట్‌పుట్ తనిఖీ చేయండి.