స్ట్రింగ్స్ డీప్ డైవ్ & స్లైసింగ్ (String Mastery)
[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) ఉంటుంది. పైథాన్ రెండు దిశల ఇండెక్సింగ్ను సపోర్ట్ చేస్తుంది:
- పాజిటివ్ ఇండెక్స్: 0 తో ప్రారంభమై ఎడమ నుండి కుడికి వెళ్తుంది (ఉదా:
s[0] -> 'P'). - నెగటివ్ ఇండెక్స్: -1 తో ప్రారంభమై కుడి నుండి ఎడమకు వెళ్తుంది (ఉదా:
s[-1] -> 'N'). చివర ఉన్న అక్షరాన్ని పొందడానికిlen(s) - 1రాయాల్సిన అవసరం లేకుండా నేరుగాs[-1]రాయవచ్చు! - స్ట్రింగ్ ఇమ్మ్యుటబిలిటీ (Immutability): పైథాన్లో స్ట్రింగ్స్ మారవు!
s[0] = 'J'అని రాస్తేTypeError: 'str' object does not support item assignmentవస్తుంది.
3 స్ట్రింగ్ స్లైసింగ్ మాస్టరీ (The [start:stop:step] Formula)
స్ట్రింగ్లోని ఒక భాగాన్ని (Substring) కత్తిరించి తీసుకోవడానికి స్లైసింగ్ (Slicing) సింటాక్స్ను ఉపయోగిస్తాము:
| స్లైసింగ్ సింటాక్స్ | వివరణ & నియమం | ఫలితం (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" |
మీరు s[100] అని పిలిస్తే IndexError వస్తుంది. కానీ s[1:100] అని స్లైసింగ్ చేస్తే ఎర్రర్ రాదు! పైథాన్ తెలివిగా స్ట్రింగ్ ముగింపు వరకే కత్తిరించి (Bound clamping) ఇస్తుంది.
4 కోడ్ డెమో 1: ఇండెక్సింగ్, స్లైసింగ్ & పాలిండ్రోమ్ డిటెక్షన్
ఇండెక్సింగ్, నెగటివ్ స్లైసింగ్ మరియు ఒక పదం ముందుకు చదివినా వెనుకకు చదివినా ఒకేలా ఉండే పాలిండ్రోమ్ (Palindrome) తనిఖీని క్రింది కోడ్లో చూడండి:
# స్ట్రింగ్ ఇండెక్సింగ్ & స్లైసింగ్ డెమో
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)
టెక్స్ట్ కేస్ను మార్చడానికి పైథాన్లో సమగ్రమైన మెథడ్స్ ఉన్నాయి:
s.lower(): అన్ని అక్షరాలను చిన్న అక్షరాలుగా మారుస్తుంది (ఉదా:"HELLO" -> "hello").s.upper(): అన్ని అక్షరాలను పెద్ద అక్షరాలుగా మారుస్తుంది (ఉదా:"python" -> "PYTHON").s.title(): ప్రతి పదం యొక్క మొదటి అక్షరాన్ని పెద్దదిగా చేస్తుంది (ఉదా:"master in python" -> "Master In Python").s.capitalize(): మొత్తం వాక్యంలో మొదటి అక్షరాన్ని మాత్రమే పెద్దదిగా చేస్తుంది.s.casefold(): ఇదిlower()కంటే ఎంతో శక్తివంతమైనది! జర్మన్ (ß -> ss) మరియు అంతర్జాతీయ భాషలలో కేస్-ఇన్సెన్సిటివ్ పోలికల కోసం ప్రొడక్షన్లో ఎల్లప్పుడూ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() ద్వారా సురక్షితమైన సెర్చింగ్ చేసే విధానాన్ని పరిశీలించండి:
# సెర్చింగ్ మరియు ఫైల్ చెకర్ డెమో
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()
యూజర్ ఇన్పుట్స్లోని అనవసరమైన ఖాళీలను తొలగించడానికి మరియు టెక్స్ట్ను రీప్లేస్ చేయడానికి:
s.strip(): ఎడమ మరియు కుడి చివర్లలోని స్పేస్లు,లను తొలగిస్తుంది.s.replace(old, new, count): పాత పదాన్ని కొత్త పదంతో మారుస్తుంది (ఉదా:s.replace("2025", "2026")).
పాత పైథాన్లో "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.split(sep): స్ట్రింగ్ను ఇచ్చిన సెపరేటర్ ఆధారంగా ముక్కలు చేసి లిస్ట్గా ఇస్తుంది (ఉదా:"యాపిల్,అరటి,ద్రాక్ష".split(",")).s.splitlines(): మల్టీ-లైన్ టెక్స్ట్లోని ప్రతి లైన్ను విడగొట్టి లిస్ట్గా ఇస్తుంది.sep.join(list_of_strings): ఒక లిస్ట్లోని అన్ని స్ట్రింగ్స్ను కలిపి ఒకే స్ట్రింగ్గా మారుస్తుంది.
ఉదాహరణ:"-".join(["2026", "11", "02"])ఫలితం:"2026-11-02".
స్ట్రింగ్స్ ఇమ్మ్యుటబుల్ కాబట్టి, లూప్లో పదే పదే 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 డేటాను క్లీన్ చేసి ప్రామాణిక రిపోర్ట్గా మార్చే స్క్రిప్ట్ చూడండి:
# అడ్వాన్స్డ్ స్ట్రింగ్ క్లీనింగ్ & 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 కామన్ బిగినర్స్ మిస్టేక్స్ & ప్రొడక్షన్ బెస్ట్ ప్రాక్టీసెస్
- Mistake 1: స్ట్రింగ్ ఇమ్మ్యుటబిలిటీని మర్చిపోవడం:
text.replace("a", "b")అని రాస్తేtextమారదు! ఎల్లప్పుడూtext = text.replace("a", "b")అని తిరిగి వేరియబుల్కు అసైన్ చేసుకోవాలి. - Mistake 2:
lstrip()తో URL ప్రిఫిక్స్ తీయడం:"http://a.com".lstrip("http://")చేస్తే మొదటి 'a' కూడా ఎగిరిపోవచ్చు! ఎల్లప్పుడూremoveprefix()వాడండి. - Mistake 3:
find()కు బదులుindex()వాడి క్రాష్ అవ్వడం: ఐటెమ్ కచ్చితంగా ఉంటుందో లేదో తెలియనప్పుడుfind()వాడాలి (లేదాinఆపరేటర్తో ముందుగానే చెక్ చేయాలి).
13 రియల్-వరల్డ్ ప్రాజెక్ట్: "Automated Clinical Prescription & Patient Record NLP Parser"
ఈ తొమ్మిదవ అధ్యాయంలో నేర్చుకున్న అన్ని అంశాలను (ఇండెక్సింగ్, స్లైసింగ్, split, join, strip, removeprefix, replace, కేస్ కన్వర్షన్స్) కలగలిపి — ఒక హాస్పిటల్ క్లినికల్ ప్రిస్క్రిప్షన్ టెక్స్ట్ను విశ్లేషించి డిజిటల్ హెల్త్ రికార్డ్ (EHR) గా మార్చే Automated Clinical Prescription NLP Parser ప్రాజెక్ట్ను నిర్మిద్దాం!
# =====================================================================
# చాప్టర్ 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' గా) మార్చి మరింత పక్కాగా కేస్-ఇన్సెన్సిటివ్ పోలికను సాధ్యం చేస్తుంది.
ఈ Clinical Prescription NLP Parser ను లైవ్గా మన కంపైలర్లో రన్ చేయండి!
ఎటువంటి లోకల్ సెటప్ లేకుండా, బ్రౌజర్లోనే Modern Python 3 కంపైలర్లో ఈ కోడ్ను ఎగ్జిక్యూట్ చేసి అవుట్పుట్ తనిఖీ చేయండి.