Login / Register
Follow Us
0
0
Register Free!
Register Free!
Online Mock Tests & Exam Preparation | Target Exams
Select Medium / माध्यम चुनें:
Eng (English) Hindi (हिन्दी)
CBSE • Class XI • Computer Science • Ch 8
Estimated Time: 45 Mins
Study Progress: In Progress

Strings

In CBSE Class 11 Computer Science, "Strings" provides an authoritative, exhaustive master resource on Unicode textual manipulation in Python. This comprehensive chapter deconstructs string immutability, dual positive and negative indexing geometry, advanced slicing algorithms (`[start:stop:step]`), sequence operations (concatenation, replication, membership testing), lexicographical Unicode comparison, escape sequences, and the complete taxonomy of built-in string transformation, validation, and search methods (`split()`, `join()`, `replace()`, `count()`, `find()`, `strip()`, `isalpha()`, `isdigit()`) aligned with the 2026–27 CBSE curriculum.

Take Chapter CBT Test View All Chapters
Overview Core Concepts Syntax & Core Commands Summary Self Check Take MCQ Test

How Does Search Software Scan Billions of Words in Milliseconds Without Corrupting Text?

Every Google search query, every WhatsApp message, and every AI prompt begins its life as a string—an ordered sequence of Unicode characters in memory. When you edit a 500-page document or search for a keyword, how does your computer slice words, capitalize titles, and replace misspelled phrases without corrupting the surrounding text? Python strings are built on an ingenious design principle: Immutability. Once a string is created in memory, its characters can never be modified, swapped, or deleted in place. Why would language designers deliberately forbid modifying strings, and how does this immutability make Python faster, more thread-safe, and memory-efficient? This chapter masters the art of text manipulation.

Why This Chapter Matters

Text processing is the foundational engine of modern software engineering. From parsing web URLs, scraping financial data, and processing genomic DNA sequences (`ATCG`) to tokenizing text for large language models, strings are ubiquitous. Programmers who master string slicing, formatting, and built-in methods write clean, pythonic code that executes with blazingly fast algorithmic efficiency and avoids costly string concatenation performance bottlenecks.

Before You Begin (Prerequisites)

  • Fundamental Python syntax: variables, data types, and `print()` formatting.
  • ASCII and Unicode character encoding concepts.
  • Flow of control: `for` loops iterating over characters.

What You Will Learn (Core Objectives)

  • Master dual indexing geometry: 0-based positive indexing (left-to-right) and -1-based negative indexing (right-to-left).
  • Execute advanced string slicing expressions: `str[start:stop:step]` including step reversals (`[::-1]`).
  • Demonstrate string immutability and explain why in-place assignment (`s[0] = "X"`) raises a `TypeError`.
  • Apply sequence operators: Concatenation (`+`), Replication (`*`), and Membership (`in`, `not in`).
  • Evaluate lexicographical comparisons using Unicode code points (`ord()`, `chr()`).
  • Master string transformation methods: `upper()`, `lower()`, `title()`, `capitalize()`, `swapcase()`.
  • Execute search and validation methods: `find()`, `index()`, `count()`, `replace()`, `split()`, `join()`, `strip()`, `isdigit()`, `isalpha()`.
  • Construct robust algorithms for palindrome verification, frequency counting, and text sanitization.

Chapter Roadmap & Progression

1 1. String Immutability & Dual Index...
2 2. The Slicing Algorithm: `str[star...
3 3. Sequence Operators & Lexicograph...
4 4. Comprehensive Taxonomy of Built-...

Complete Concept Guide (100% Curriculum Coverage)

1. String Immutability & Dual Indexing Geometry

Understand

In Python, a String is an immutable, ordered sequence of Unicode characters enclosed in quotes (`'...'`, `"..."`, or `'''...'''`):

Dual Indexing Architecture

Every character in a string of length $n$ occupies two dual indices:

Positive Index (Left → Right)012345
CharacterPython
Negative Index (Right → Left)-6-5-4-3-2-1
String Immutability Proof

Strings cannot be altered in-place. Attempting to modify an indexed character raises a runtime error:

s = "Python"
s[0] = "J"  # TypeError: 'str' object does not support item assignment!

# To create a modified string, you must construct a brand-new object:
s = "J" + s[1:]  # s is now bound to "Jython"

2. The Slicing Algorithm: `str[start:stop:step]`

Understand & Deep Dive

String slicing extracts a sub-string from index `start` up to, but excluding, index `stop`, incrementing by `step`:

Default Values When Parameters Are Omitted:
  • If `step > 0`: Default `start = 0`, default `stop = len(s)`.
  • If `step < 0`: Default `start = -1` (end of string), default `stop = -len(s) - 1` (beginning).
Worked Slicing Matrix for `s = "TARGETEXAMS"`:
Slice ExpressionExtracted SubstringAlgorithmic Mechanics
`s[0:6]``"TARGET"`Indices 0, 1, 2, 3, 4, 5 (stops before 6).
`s[6:]``"EXAMS"`From index 6 through the end of the string.
`s[:6]``"TARGET"`From index 0 up to 5.
`s[::2]``"TRETM"`Every 2nd character: indices 0, 2, 4, 6, 8, 10.
`s[::-1]``"SMAXETEGRAT"`String Reversal! Step is -1, walks backward from right to left.
`s[4:1:-1]``"EGR"`Walks backward: indices 4, 3, 2 (stops before 1).

3. Sequence Operators & Lexicographical Comparison

Understand
A. String Sequence Operators
  • Concatenation (`+`): Joins two strings together (`"Data" + "Science"` → `"DataScience"`). Both operands must be strings.
  • Replication (`*`): Multiplies a string by an integer (`"Echo!" * 3` → `"Echo!Echo!Echo!"`).
  • Membership (`in`, `not in`): Checks substring existence (`"gram" in "programming"` evaluates to `True`).
B. Lexicographical Comparison

Relational operators (`<, <=, >, >=, ==, !=`) compare strings character-by-character from left to right using their Unicode code points (`ord()`):

  • `"Apple" < "banana"` evaluates to `True` because uppercase `'A'` (ASCII 65) is numerically smaller than lowercase `'b'` (ASCII 98).
  • `ord(char)` returns the integer Unicode code point (e.g., `ord('A')` → 65).
  • `chr(int)` converts an integer code point back to its character (e.g., `chr(65)` → `'A'`).

4. Comprehensive Taxonomy of Built-in String Methods

Understand & Reference

String methods return brand-new values and never modify the original string:

Method SignatureFunctionalityExample Usage & Return Value
`len(s)`Returns total character count.`len("Code")` → `4`
`s.upper()`, `s.lower()`Converts casing completely.`"Py".upper()` → `"PY"`
`s.title()`, `s.capitalize()`Title cases each word or capitalizes first char.`"hello world".title()` → `"Hello World"`
`s.count(sub[, start, end])`Counts non-overlapping occurrences of `sub`.`"banana".count("an")` → `2`
`s.find(sub)`Returns first index of `sub`; returns `-1` if not found.`"school".find("oo")` → `3`; `"school".find("z")` → `-1`
`s.index(sub)`Same as `find()`, but raises `ValueError` if not found.`"school".index("z")` → raises `ValueError`
`s.replace(old, new)`Replaces occurrences of `old` with `new`.`"hello".replace("l", "r")` → `"herro"`
`s.strip()`, `s.lstrip()`, `s.rstrip()`Removes leading/trailing whitespaces.`" test ".strip()` → `"test"`
`s.split(sep)`Splits string by separator into a list of strings.`"a,b,c".split(",")` → `['a', 'b', 'c']`
`sep.join(iterable)`Joins elements of an iterable string list with `sep`.`"-".join(['2026', '09', '08'])` → `"2026-09-08"`
`s.startswith(p)`, `s.endswith(s)`Checks string prefixes or suffixes (returns bool).`"file.py".endswith(".py")` → `True`
`s.isalpha()`, `s.isdigit()`, `s.isalnum()`Validates if string consists solely of letters, digits, or alphanumeric chars.`"123".isdigit()` → `True`; `"12a".isdigit()` → `False`

Key Programming Syntax, Statements & Translator Rules

Length & Index Relationship
$$0 \le \text{Positive Index} < n, \quad -n \le \text{Negative Index} \le -1$$
Valid index ranges for a string of length n.
String Reversal Slice
s[::-1]
Idiomatic O(n) reversal of a string.

String Indexing & Slicing Architecture

String Dual Indexing & Memory Architecture 0 1 2 3 4 5 6 7 8 9 P R O G R A M M E R -10 -9 -8 -7 -6 -5 -4 -3 -2 -1 Key Slicing Operations on s = "PROGRAMMER": • s[0:4] → "PROG" (start at 0, stop before 4) • s[3:7] → "GRAM" (start at 3, stop before 7) • s[::-1] → "REMMARGORP" (Full String Reversal with step=-1) Immutability Rule s[0] = 'X' causes TypeError Strings can never be modified in-place!

Chapter Summary & 10 Key Takeaways

Takeaway 1
A string in Python is an immutable sequence of Unicode characters enclosed in quotes.
Takeaway 2
Python supports dual indexing: positive indexing starts at 0 from the left; negative indexing starts at -1 from the right.
Takeaway 3
Strings are strictly immutable; modifying an individual character in-place (`s[i] = "x"`) raises a `TypeError`.
Takeaway 4
Slicing syntax `s[start:stop:step]` extracts a substring up to, but excluding, the `stop` index.
Takeaway 5
Negative step slicing traverses backward; `s[::-1]` reverses the entire string in $O(n)$ time.
Takeaway 6
Concatenation (`+`) combines strings; replication (`*`) repeats a string by an integer factor.
Takeaway 7
Relational operators compare strings lexicographically character-by-character using Unicode values (`ord()`).
Takeaway 8
`find()` returns the lowest index of a substring or -1 if absent; `index()` raises `ValueError` if absent.
Takeaway 9
`split(sep)` divides a string into a list of substrings; `sep.join(list)` concatenates a list of strings into a single string.
Takeaway 10
String validation methods (`isalpha()`, `isdigit()`, `isalnum()`, `isspace()`) check character composition and return Boolean values.

Check Your Understanding (Diagnostic Practice Questions)

Diagnostic questions testing core conceptual clarity. Answers are hidden initially — solve each problem first, then click to reveal the step-by-step verified solution.

1
Given the string `s = "CENTRAL BOARD"`, evaluate the output of the following slicing expressions:
(a) `s[0:7]`, (b) `s[8:]`, (c) `s[::3]`, (d) `s[::-1]`, (e) `s[-5:]`.
Reveal Answer & Explanation
Answer: (a) `s[0:7]` → `"CENTRAL"` (indices 0 through 6).
(b) `s[8:]` → `"BOARD"` (index 8 through end).
(c) `s[::3]` → `"CT OA"` (indices 0, 3, 6, 9, 12).
(d) `s[::-1]` → `"DRAOB LARTNEC"` (string reversed).
(e) `s[-5:]` → `"BOARD"` (last 5 characters).
Start at start, stop before stop, step determines jump size.
2
Why does executing `s = "Hello"; s[0] = "M"` cause a runtime error? How do you correctly achieve the desired result in Python?
Reveal Answer & Explanation
Answer: Strings in Python are strictly IMMUTABLE. Their internal character arrays cannot be modified in-place once allocated in memory. Attempting to assign to an indexed location (`s[0] = "M"`) raises a `TypeError: 'str' object does not support item assignment`.
To achieve the desired result, you must construct a brand-new string object using slicing and concatenation:
s = "M" + s[1:] # Creates new string "Mello" and rebinds 's'
Strings are immutable. Slices must be combined to create a new string object.
3
What is the critical difference between the `find()` and `index()` string methods when a substring is not present?
Reveal Answer & Explanation
Answer: Both methods search for the first occurrence of a substring. If the substring is found, both return its 0-based index. However, if the substring is NOT found:
• `find()` returns `-1` gracefully without halting execution.
• `index()` raises a fatal `ValueError: substring not found` exception.
Therefore, `find()` is preferred when checking for optional substrings without needing `try-except` blocks.
find() returns -1 on failure; index() crashes with ValueError.
4
Predict the output of the following string operations:
text = "python,data,ai"
parts = text.split(",")
print(parts)
joined = " - ".join(parts)
print(joined)
Reveal Answer & Explanation
Answer: Output line 1: `['python', 'data', 'ai']`
Output line 2: `python - data - ai`
Explanation: `split(",")` divides the string at each comma delimiter, creating a list of 3 strings. `"- ".join(parts)` concatenates the list elements into a single string separated by `" - "`.
split() returns a list of strings; join() combines a list of strings with the separator.
5
Write a Python function `is_palindrome(s)` that determines whether a given string is a palindrome, ignoring spaces and letter case.
Reveal Answer & Explanation
Answer: 
def is_palindrome(s):
    clean = s.replace(" ", "").lower()
    return clean == clean[::-1]

print(is_palindrome("Race car"))  # True
print(is_palindrome("Python"))    # False

Remove spaces with replace(), convert to lowercase with lower(), and compare against reverse slice [::-1].
6
Explain the difference between `isalpha()`, `isdigit()`, and `isalnum()`. Give an example string for each where only that specific method returns True.
Reveal Answer & Explanation
Answer: • `isalpha()`: Returns `True` if all characters are alphabetic letters ($A-Z, a-z$) and string is non-empty. Example: `"Python".isalpha()` is `True`.
• `isdigit()`: Returns `True` if all characters are numeric digits ($0-9$). Example: `"2026".isdigit()` is `True`.
• `isalnum()`: Returns `True` if all characters are letters OR digits (no spaces or symbols). Example: `"Python3".isalnum()` is `True` (while `isalpha()` and `isdigit()` are both `False` for `"Python3"`).
isalpha for letters only; isdigit for numbers only; isalnum for mixed letters and numbers.
7
Evaluate the following string comparisons and explain why using Unicode values:
(a) `"apple" < "Banana"`, (b) `"100" < "20"`.
Reveal Answer & Explanation
Answer: (a) `"apple" < "Banana"` evaluates to `False`.
Explanation: Comparison is performed character-by-character. First characters are compared: `'a'` has Unicode 97, while `'B'` has Unicode 66. Since $97 > 66$, `"apple"` is greater than `"Banana"`.
(b) `"100" < "20"` evaluates to `True`.
Explanation: Strings are compared lexicographically as text, not numbers. First characters: `'1'` has Unicode 49, while `'2'` has Unicode 50. Since $49 < 50$, `"100"` is smaller than `"20"`.
Compares character Unicode values ord(). Uppercase letters (65-90) are smaller than lowercase (97-122).
8
How do `strip()`, `lstrip()`, and `rstrip()` work? What is the output of `" *Data* ".strip(" *")`?
Reveal Answer & Explanation
Answer: • `lstrip()` removes specified characters (default whitespace) from the left/start.
• `rstrip()` removes specified characters from the right/end.
• `strip()` removes specified characters from both ends.
Output of `" *Data* ".strip(" *")`: `"Data"` (all combinations of leading and trailing spaces and asterisks are stripped).
Strips leading and trailing whitespace or custom characters from strings.
Finished Studying This Chapter?
READY TO PRACTICE?

Timed CBT Practice Tests (Exam Simulator)

Put your concepts to the test with official curriculum-aligned Foundation and Advanced practice tests. Get instant accuracy scores, time metrics, and step-by-step verified explanations.

Foundation Test
15 MCQs • Core Concepts
Advanced Test
15 MCQs • HOTS & Traps

All Class 11 Computer Science Chapters

AI Study Friend

Instant Concept Tutor

Have a doubt in Strings? Ask our AI study tutor for rapid explanations or customized quizzes.