1. Introduction
A string (str) is Python's built-in type for representing text, implemented as an immutable ordered sequence of Unicode characters. Strings can be created using single quotes, double quotes, or triple quotes for multi-line text.
Cricket analogy: A player's name printed on a jersey is fixed once stitched — just as a Python string is an immutable sequence of characters, you can quote a player's name with single, double, or triple quotes for a multi-line bio without changing the name itself.
Because strings behave like sequences, they support indexing, slicing, concatenation, and iteration just like lists and tuples — but unlike lists, a string's characters can never be changed in place once the string is created.
Cricket analogy: You can pick out the third letter of "Kohli" or slice "Sachin Tendulkar" into first and last name pieces just like flipping through a scorecard's fielding positions, but unlike swapping a fielder mid-over, you can never alter a letter in the string itself once printed.
2. Syntax
# Creating strings
s1 = 'hello'
s2 = "world"
s3 = '''multi\nline\nstring'''
# Indexing and slicing
first_char = s1[0]
last_char = s1[-1]
substring = s1[1:4]
reversed_s = s1[::-1]
# Concatenation and repetition
greeting = s1 + ' ' + s2
repeated = s1 * 3
# f-strings (formatting)
name = "Alice"
age = 30
message = f"{name} is {age} years old"3. Explanation
Every string operation that appears to 'modify' a string, such as .upper(), .replace(), or concatenation with +, actually creates and returns a brand-new string object; the original string is left untouched. This is a direct consequence of strings being immutable.
Cricket analogy: Renaming a jersey from "kohli" to "KOHLI" via .upper() doesn't restitch the original jersey — it produces a brand-new jersey object, leaving the original locker room nameplate untouched.
Slicing with s[start:stop:step] is one of the most powerful string features — using a negative step like s[::-1] reverses the string, while omitting start or stop slices from the beginning or to the end respectively.
Cricket analogy: Slicing a full team roster string like players[::-1] reverses the batting order for a reverse-lineup gimmick match, while players[2:5] pulls just the middle-order batters from position three to five.
Strings are immutable: attempting s[0] = 'H' raises TypeError: 'str' object does not support item assignment. To change part of a string, you must build a new string, e.g. s = 'H' + s[1:] or use .replace().
Because strings are immutable, repeatedly concatenating strings in a loop with += is inefficient for very large text (it creates a new string each time); prefer ''.join(list_of_strings) for building large strings.
4. Example
s = "hello"
print("original:", s)
try:
s[0] = 'H'
except TypeError as e:
print("TypeError:", e)
new_s = 'H' + s[1:]
print("new string:", new_s)
print("original unchanged:", s)
print("reversed:", s[::-1])
print("slice[1:4]:", s[1:4])
print("upper:", s.upper())5. Output
original: hello
TypeError: 'str' object does not support item assignment
new string: Hello
original unchanged: hello
reversed: olleh
slice[1:4]: ell
upper: HELLO6. Key Takeaways
- Strings are immutable, ordered sequences of Unicode characters.
- Direct item assignment like
s[0] = 'x'raises a TypeError. - Methods like
.upper(),.replace()always return a NEW string, never modify in place. - Slicing
s[start:stop:step]supports negative indices and negative steps (e.g.,s[::-1]to reverse). - f-strings (
f"{var}") are the modern, preferred way to format strings in Python 3.6+. - For building large strings efficiently, prefer
''.join(parts)over repeated+=concatenation.
Practice what you learned
1. What happens when you run `s = 'hi'; s[0] = 'H'`?
2. What does `s.upper()` do to the original string `s`?
3. What is the output of `'hello'[::-1]`?
4. Which is the most efficient way to build a large string from many small pieces in a loop?
5. What is the output of `'hello'[1:4]`?
6. Why can a string be used as a dictionary key but a list cannot?
Was this page helpful?
You May Also Like
Common String Methods in Python
A practical tour of Python's built-in string methods, grouped by case conversion, search/replace, and split/join, with usage examples.
List Comprehension in Python
A concise Python syntax for building lists from iterables in a single expression, including conditionals and the memory-difference vs generator expressions.
Lists in Python
A mutable, ordered sequence type in Python used to store collections of items, with a deep dive into mutation, aliasing, and common list operations.
Regular Expressions in Python
Pattern matching and text processing using Python's re module -- syntax, key functions, and common pitfalls.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics