LISTS

🔹 Python List Interview Questions and Answers

1. What is a list in Python?

Answer:

In Python, a list is a built-in data structure that allows us to store a collection of items in a
single variable. Lists are ordered, mutable, and allow duplicate elements. Items can be of
any data type, and a list can even contain other lists (nested lists).

Example:

python
CopyEdit
my_list = [1, "apple", 3.14, True]

Lists are defined using square brackets [].

2. How are lists different from tuples in Python?

Answer:

The main differences between lists and tuples are:

Feature List Tuple

Mutability Mutable Immutable
Syntax [] ()
Performance Slightly slower Faster due to immutability
Use case Suitable for data that changes Suitable for fixed data

Example:

python
CopyEdit
# List
l = [1, 2, 3]
l[0] = 100 # Allowed

# Tuple
t = (1, 2, 3)
t[0] = 100 # Raises an error
3. How do you add elements to a list in Python?

Answer:

There are several ways to add elements to a list:

 append(): Adds a single element to the end.

 extend(): Adds multiple elements (iterable) to the end.
 insert(): Inserts an element at a specific index.

Example:

python
CopyEdit
lst = [1, 2]
lst.append(3) # [1, 2, 3]
lst.extend([4, 5]) # [1, 2, 3, 4, 5]
lst.insert(1, 100) # [1, 100, 2, 3, 4, 5]

4. How do you remove elements from a list?

Answer:

Python provides multiple ways:

 remove(value): Removes the first matching value.

 pop(index): Removes element at a given index and returns it.
 del: Deletes element(s) using index or slice.
 clear(): Removes all elements.

Example:

python
CopyEdit
lst = [1, 2, 3, 4]
lst.remove(2) # [1, 3, 4]
lst.pop(0) # Returns 1, list becomes [3, 4]
del lst[1] # [3]
lst.clear() # []

5. What is list comprehension?

Answer:

List comprehension is a concise way to create lists. It is more readable and often faster than
using loops.

Syntax:

python
CopyEdit
[expression for item in iterable if condition]

Example:

python
CopyEdit
# Squares of even numbers from 0 to 9
squares = [x**2 for x in range(10) if x % 2 == 0]

This is equivalent to using a for loop but in a single line.

6. How do you sort a list in Python?

Answer:

There are two main ways:

 sort(): Sorts the list in-place.

 sorted(): Returns a new sorted list.

Both accept key and reverse parameters.

Example:

python
CopyEdit
nums = [3, 1, 4, 2]
nums.sort() # [1, 2, 3, 4] — modifies the original list
sorted_nums = sorted(nums, reverse=True) # [4, 3, 2, 1]

7. What are some common list methods you’ve used?

Answer:

Here are commonly used list methods:

 append(), extend(), insert()

 remove(), pop(), clear()
 index(), count()
 sort(), reverse(), copy()

Example:

python
CopyEdit
lst = [1, 2, 3, 2]
lst.count(2) # 2
lst.index(3) # 2
lst.reverse() # [2, 3, 2, 1]

8. How do you copy a list in Python?

Answer:

There are multiple ways to copy a list:

 copy() method
 Slice notation: [:]
 list() constructor

Example:

python
CopyEdit
original = [1, 2, 3]
copy1 = original.copy()
copy2 = original[:]
copy3 = list(original)

These create a shallow copy. For nested lists, use deepcopy from the copy module.

9. What is the difference between shallow and deep copy in lists?

🧠 Basic Idea

 Shallow copy: Copies the outer list, but not the inner lists (nested elements). So,
both the original and the copy still refer to the same inner lists.
 Deep copy: Copies everything, including nested lists. So, the original and the copy
are completely separate.

🧪 Example to Understand
python
CopyEdit
import copy

lst = [[1, 2], [3, 4]] # A list that contains nested lists

shallow = lst.copy() # Shallow copy

deep = copy.deepcopy(lst) # Deep copy

lst[0][0] = 100 # Change a value inside a nested list

Now let’s see the results:

python
CopyEdit
print(shallow) # Output: [[100, 2], [3, 4]]
print(deep) # Output: [[1, 2], [3, 4]]

🔍 What Happened?

For shallow = lst.copy():

 Only the outer list is copied.

 The inner lists (like [1, 2]) are shared between lst and shallow.
 So, when you change lst[0][0], it also changes shallow[0][0].

For deep = copy.deepcopy(lst):

 Everything, including the inner lists, is copied.

 So, changing the original list doesn’t affect the deep copy.

📌 Visual Analogy

Imagine a box (lst) with two smaller boxes inside (nested lists):

 Shallow copy: You make a new big box, but you reuse the same small boxes.
 Deep copy: You make a new big box and new small boxes inside it too.

10. How would you remove duplicates from a list?

Answer:

We can use set, but it removes order. If order matters, use a loop or dict.fromkeys().

Example:

python
CopyEdit
# Unordered
unique = list(set([1, 2, 2, 3])) # [1, 2, 3]

# Ordered
lst = [1, 2, 2, 3]
unique_ordered = list(dict.fromkeys(lst)) # [1, 2, 3]

🔹 What is self in Python?

 In Python, when you create a class, self is used to refer to the current object (the
object being used or created).
 It's how you access variables and methods inside the class.

Yield keyword

import time

def follow_log(file_path):

with open(file_path, "r") as f:

f.seek(0, 2) # Move to end of file

while True:

line = f.readline()

if not line:

time.sleep(0.1) # Wait a bit and try again

continue

yield line.strip()
TUPLES
1. What is a tuple in Python?

Answer:
A tuple is an immutable sequence data type in Python. It is similar to a list but unlike lists,
once created, the elements of a tuple cannot be modified. Tuples are defined by placing a
comma-separated collection of values inside parentheses (). For example:

python
CopyEdit
my_tuple = (1, 2, 3, 'a', 'b')

Since tuples are immutable, they provide a guarantee that the data will not be modified,
which makes them a good choice for fixed collections of items.

2. How is a tuple different from a list in Python?

Answer:
The primary difference between a tuple and a list is that tuples are immutable while lists
are mutable. This means that once a tuple is created, its values cannot be changed, whereas
lists allow you to modify, append, and remove elements after creation.

 Tuples are created using parentheses () and are hashable, which allows them to be
used as keys in a dictionary.
 Lists are created using square brackets [] and are more flexible because they allow
changes in data.

Example:

python
CopyEdit
# Tuple
tuple_example = (1, 2, 3)
# List
list_example = [1, 2, 3]

3. How do you create a tuple with a single element?

Answer:
To create a tuple with a single element, a trailing comma is required after the element.
Without it, Python would consider the parentheses as just grouping parentheses, not a tuple.
For example:

python
CopyEdit
single_element_tuple = (5,)
If you omit the comma, you’ll have a regular integer, not a tuple:

python
CopyEdit
not_a_tuple = (5)

4. How can you access elements of a tuple?

Answer:
You can access elements of a tuple using indexing, just like lists. Python indexing starts at 0,
and you can use both positive and negative indices. For example:

python
CopyEdit
my_tuple = (10, 20, 30, 40, 50)

# Accessing by positive index

print(my_tuple[2]) # Output: 30

# Accessing by negative index

print(my_tuple[-1]) # Output: 50

Tuples also support slicing:

python
CopyEdit
print(my_tuple[1:3]) # Output: (20, 30)

5. Can you modify a tuple after it is created?

Answer:
No, tuples are immutable. Once a tuple is created, you cannot modify its elements, append, or
remove items. However, you can create a new tuple based on the old one.

Example of trying to modify:

python
CopyEdit
my_tuple = (1, 2, 3)
# This will raise a TypeError
my_tuple[0] = 5

To modify, you'd need to create a new tuple:

python
CopyEdit
new_tuple = my_tuple[:2] + (5,) + my_tuple[3:]

6. What are some common use cases of tuples in Python?

Answer:

 Data integrity: Since tuples are immutable, they are used to represent fixed
collections of data that should not be modified. For example, you might store
coordinates or RGB values as tuples.
 Function returns: Tuples are often used to return multiple values from a function.
 Dictionary keys: Because tuples are immutable and hashable, they can be used as
keys in dictionaries.
 Memory efficiency: Tuples, being immutable, can often take up less memory than
lists, making them more efficient for storing large amounts of data that will not be
changed.

7. What is tuple packing and unpacking in Python?

Answer:

 Tuple packing refers to the process of assigning multiple values to a single tuple.
Example:

python
CopyEdit
packed_tuple = 1, 2, 3

 Tuple unpacking is when you assign the elements of a tuple to individual variables.
Example:

python
CopyEdit
x, y, z = packed_tuple
print(x, y, z) # Output: 1 2 3

This feature allows you to easily extract multiple values from a tuple in a single line.

8. How do you concatenate and repeat tuples?

Answer:
You can concatenate two or more tuples using the + operator, and you can repeat a tuple
multiple times using the * operator.

Example of concatenation:

python
CopyEdit
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
concatenated_tuple = tuple1 + tuple2
print(concatenated_tuple) # Output: (1, 2, 3, 4, 5, 6)
Example of repetition:

python
CopyEdit
repeated_tuple = (1, 2) * 3
print(repeated_tuple) # Output: (1, 2, 1, 2, 1, 2)

9. What methods are available for tuples in Python?

Answer:
Since tuples are immutable, they have fewer methods compared to lists. The available
methods are:

 count(): Returns the number of occurrences of a specified value in the tuple.

python
CopyEdit
my_tuple = (1, 2, 2, 3)
print(my_tuple.count(2)) # Output: 2

 index(): Returns the index of the first occurrence of a specified value.

python
CopyEdit
print(my_tuple.index(3)) # Output: 3

10. Can a tuple contain mutable elements like lists or dictionaries?

Answer:
Yes, a tuple can contain mutable elements like lists, dictionaries, or sets. However, while the
tuple itself is immutable, the mutable elements inside it can still be modified.

Example:

python
CopyEdit
my_tuple = ([1, 2, 3], {'key': 'value'})
my_tuple[0][1] = 5 # Modifying the list inside the tuple
my_tuple[1]['key'] = 'new_value' # Modifying the dictionary inside the
tuple
print(my_tuple) # Output: ([1, 5, 3], {'key': 'new_value'})

11. What is the time complexity for accessing an element in a tuple?

Answer:
Accessing an element in a tuple has a time complexity of O(1), meaning it takes constant
time regardless of the size of the tuple. This is because tuples are implemented as contiguous
memory blocks, and Python can directly access the elements based on their index.
DICTIONARIES
1. What is a dictionary in Python?

Answer:
A dictionary in Python is an unordered collection of key-value pairs. It is defined using
curly braces {} and is a mutable, dynamic data structure. Each item in the dictionary has a
unique key, which maps to a corresponding value. Keys are unique, immutable (usually
strings or numbers), and are used to access their associated values.

Example:

python
CopyEdit
my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

In this example, 'name', 'age', and 'city' are the keys, and 'Alice', 25, and 'New York'
are the corresponding values.

2. How are dictionaries different from lists and tuples?

Answer:

 Dictionaries store data in key-value pairs, where each key is unique, and values can
be accessed using their respective keys.
 Lists and tuples are ordered collections, meaning their elements can be accessed by
index (starting from 0), and they store values sequentially. Lists are mutable, while
tuples are immutable.
 Dictionaries are unordered, meaning the order of items is not guaranteed in versions
of Python before 3.7. However, from Python 3.7 onwards, dictionaries maintain the
insertion order.

Example comparison:

python
CopyEdit
# Dictionary
my_dict = {'name': 'Alice', 'age': 25}

# List
my_list = ['Alice', 25]

# Tuple
my_tuple = ('Alice', 25)
3. How do you create a dictionary?

Answer:
A dictionary can be created using curly braces {}, with key-value pairs separated by a colon
:. You can also use the dict() constructor to create a dictionary.

Example 1: Using curly braces:

python
CopyEdit
my_dict = {'name': 'John', 'age': 30}

Example 2: Using the dict() constructor:

python
CopyEdit
my_dict = dict(name='John', age=30)

Both methods will produce the same result.

4. How do you access values in a dictionary?

Answer:
Values in a dictionary are accessed using the corresponding keys. You can access values
using the key inside square brackets [], or you can use the .get() method.

 Using square brackets:

python
CopyEdit
my_dict = {'name': 'Alice', 'age': 25}
print(my_dict['name']) # Output: Alice

This will raise a KeyError if the key is not found.

 Using the .get() method:

python
CopyEdit
print(my_dict.get('name')) # Output: Alice

This returns None if the key doesn't exist, and you can also provide a default value:

python
CopyEdit
print(my_dict.get('address', 'Not available')) # Output: Not
available

5. How do you add, update, and delete items in a dictionary?

Answer:

 Adding or updating items: You can add a new key-value pair or update an existing
one by directly assigning a value to the key.

python
CopyEdit
my_dict = {'name': 'John'}
my_dict['age'] = 30 # Adds a new key-value pair
my_dict['name'] = 'Alice' # Updates the existing key 'name'

 Deleting items: You can delete a key-value pair using the del keyword or the .pop()
method.

python
CopyEdit
del my_dict['age'] # Deletes the 'age' key-value pair
# Or using pop()
name = my_dict.pop('name') # Removes 'name' and returns the value

6. What are some common methods available for dictionaries in Python?

Answer:
Python dictionaries provide a variety of built-in methods for common operations:

 .keys(): Returns a view of all keys in the dictionary.

python
CopyEdit
my_dict = {'name': 'Alice', 'age': 25}
print(my_dict.keys()) # Output: dict_keys(['name', 'age'])

 .values(): Returns a view of all values in the dictionary.

python
CopyEdit
print(my_dict.values()) # Output: dict_values(['Alice', 25])

 .items(): Returns a view of all key-value pairs as tuples.

python
CopyEdit
print(my_dict.items()) # Output: dict_items([('name', 'Alice'),
('age', 25)])

 .get(): Returns the value for the given key, or a default value if the key is not found.

python
CopyEdit
print(my_dict.get('name')) # Output: Alice

 .pop(): Removes and returns the value for the given key.
 python
CopyEdit
age = my_dict.pop('age') # Removes 'age' and returns its value

 .clear(): Removes all items from the dictionary.

python
CopyEdit
my_dict.clear() # Empties the dictionary

 .update(): Updates the dictionary with another dictionary or key-value pairs.

python
CopyEdit
my_dict.update({'age': 26, 'city': 'New York'})

7. Can dictionary keys be mutable objects?

Answer:
No, dictionary keys must be immutable. This is because dictionaries rely on the hash value
of the key to quickly look up the associated value. Immutable objects like strings, numbers,
and tuples can be hashed, while mutable objects like lists, sets, or other dictionaries cannot.

Example of invalid dictionary key:

python
CopyEdit
my_dict = {[1, 2]: 'value'} # This will raise a TypeError

8. How do you merge two dictionaries?

Answer:
You can merge dictionaries using the .update() method or by using the ** unpacking
operator (Python 3.5+).

 Using .update():

python
CopyEdit
dict1 = {'name': 'Alice'}
dict2 = {'age': 25}
dict1.update(dict2) # Updates dict1 with the contents of dict2
print(dict1) # Output: {'name': 'Alice', 'age': 25}

 Using the ** unpacking operator:

python
CopyEdit
dict1 = {'name': 'Alice'}
dict2 = {'age': 25}
merged_dict = {**dict1, **dict2}
print(merged_dict) # Output: {'name': 'Alice', 'age': 25}
9. What is the time complexity for accessing and updating values in a
dictionary?

Answer:
The time complexity for both accessing and updating values in a dictionary is O(1) on
average. This means that looking up a value by key, or updating a key-value pair, takes
constant time. However, in the case of hash collisions, the performance might degrade, but
this is a rare case and the operation is still expected to be fast.

10. Can you iterate over a dictionary?

Answer:
Yes, you can iterate over the keys, values, or both (key-value pairs) of a dictionary using a
for loop. By default, iterating over a dictionary will give you the keys.

Example 1: Iterating over keys:

python
CopyEdit
my_dict = {'name': 'Alice', 'age': 25}
for key in my_dict:
print(key) # Output: 'name' 'age'

Example 2: Iterating over values:

python
CopyEdit
for value in my_dict.values():
print(value) # Output: 'Alice' 25

Example 3: Iterating over key-value pairs:

python
CopyEdit
for key, value in my_dict.items():
print(key, value) # Output: 'name' 'Alice', 'age' 25

These questions and answers should cover the fundamental concepts of Python dictionaries,
and they're ideal for preparing for a Python-related interview. Let me know if you need
further clarification on any of these topics!
Sets
✅ Q1: What is a set in Python?

Answer:

In Python, a set is an unordered collection of unique elements. It is defined using curly braces
{} or the built-in set() function. Sets are mutable, meaning you can add or remove elements
after the set is created. However, the elements themselves must be immutable (like numbers,
strings, or tuples).

For example:

python
CopyEdit
my_set = {1, 2, 3, 4}

The key characteristics of a set are:

 No duplicates: If you add duplicate values, they will be automatically removed.

 Unordered: The elements don’t maintain insertion order (prior to Python 3.7).
 Mutable: You can add or remove elements.
 Efficient membership testing: Using in is very fast in sets.

✅ Q2: How do you create a set in Python?

Answer:

You can create a set in two main ways:

1. Using curly braces:

python
CopyEdit
my_set = {1, 2, 3}

2. Using the set() constructor:

python
CopyEdit
my_set = set([1, 2, 3])

Note that if you want to create an empty set, you must use set(), because {} will create an
empty dictionary.

Example:
python
CopyEdit
empty_set = set() # Correct
empty_dict = {} # This is a dictionary, not a set

✅ Q3: What are some common set operations in Python?

Answer:

Python provides a rich set of operations for set manipulation:

 Union: Combines elements from both sets.

python
CopyEdit
a | b or a.union(b)

 Intersection: Common elements between two sets.

python
CopyEdit
a & b or a.intersection(b)

 Difference: Elements in a but not in b.

python
CopyEdit
a - b or a.difference(b)

 Symmetric Difference: Elements in either set, but not in both.

python
CopyEdit
a ^ b or a.symmetric_difference(b)

These operations are useful in data analysis, filtering, and eliminating duplicates.

✅ Q4: Can a set contain duplicate elements? Why or why not?

Answer:

No, a set cannot contain duplicate elements. This is by design, as sets are meant to
represent collections of distinct elements. If you try to add a duplicate, Python will silently
ignore it.

Example:

python
CopyEdit
s = {1, 2, 2, 3}
print(s) # Output: {1, 2, 3}

This property is extremely useful for tasks like removing duplicates from a list.

✅ Q5: How do you add or remove elements from a set?

Answer:

You can use the following methods:

 Adding elements:
o add(elem): Adds a single element.

python
CopyEdit
s.add(10)

o update(iterable): Adds multiple elements.

python
CopyEdit
s.update([20, 30])

 Removing elements:
o remove(elem): Removes an element; raises KeyError if not present.
o discard(elem): Removes an element; does not raise error if not found.
o pop(): Removes and returns a random element.
o clear(): Removes all elements.

Example:

python
CopyEdit
s = {1, 2, 3}
s.remove(2) # s becomes {1, 3}
s.discard(4) # No error even though 4 is not in the set

✅ Q6: What is the difference between remove() and discard() in sets?

Answer:

The key difference is how they handle missing elements:

 remove(elem) will raise a KeyError if the element is not found.

 discard(elem) will do nothing if the element is not found.

So discard() is safer if you're not sure whether the element exists.

Example:

python
CopyEdit
s = {1, 2, 3}
s.remove(4) # Raises KeyError
s.discard(4) # Does nothing

✅ Q7: Can you explain how sets are different from lists and tuples?

Answer:

Yes, here’s a quick comparison:

Feature List Tuple Set

Ordered Yes (ordered) Yes (ordered) No (unordered)
Mutable Yes No Yes
Allows Duplicates Yes Yes No
Syntax [1, 2] (1, 2) {1, 2}
Use case Collections of items Fixed data Unique elements

Sets are best used when you need to ensure uniqueness and perform mathematical set
operations efficiently.

✅ Q8: How do you remove duplicates from a list using a set?

Answer:

You can convert the list into a set, which will automatically remove duplicates. Then, if
needed, convert it back to a list.

Example:

python
CopyEdit
my_list = [1, 2, 2, 3, 4, 4, 5]
unique_list = list(set(my_list))
print(unique_list) # Output: [1, 2, 3, 4, 5]

Note that this may not preserve the original order, since sets are unordered.

✅ Q9: Are sets hashable? Can sets be used as dictionary keys?

Answer:
No, normal sets are not hashable because they are mutable. Therefore, they cannot be used
as dictionary keys.

However, Python provides a special immutable version of set called a frozenset. Frozensets
are hashable and can be used as dictionary keys.

Example:

python
CopyEdit
fs = frozenset([1, 2, 3])
my_dict = {fs: "value"} # This is valid

✅ Q10: What is a frozenset in Python? How is it different from a set?

Answer:

A frozenset is an immutable version of a set. Once created, you cannot add or remove
elements. This makes it hashable, so it can be used as a key in dictionaries or elements in
other sets.

Key differences:

 set is mutable; frozenset is immutable.

 set is not hashable; frozenset is.

Example:

python
CopyEdit
fs = frozenset([1, 2, 3])
# fs.add(4) → Error: 'frozenset' object has no attribute 'add'

____________
STRINGS

1. What is a String in Python?

A string is a sequence of characters enclosed in single quotes ('), double quotes ("), or triple
quotes (''' or """). Characters can include letters, numbers, symbols, spaces, or even Unicode
characters (e.g., emojis). Strings are used to store and manipulate text, such as names,
sentences, or even complex data like JSON.

 Immutable: You cannot modify a string in place (e.g., changing a single character).
Any operation that seems to modify a string creates a new string.
 Sequence Type: Strings support sequence operations like indexing, slicing, and
iteration, similar to lists or tuples.
 Unicode Support: Python 3 strings are Unicode by default, allowing representation
of characters from virtually any language or symbol set.

Example:

python
CollapseWrapRun
Copy
name = "Alice"
sentence = 'Hello, World!'
unicode_str = "Hello, 世界!" # Includes Chinese characters

2. Creating Strings

Strings can be created in several ways:

a. Using Single or Double Quotes

Single (') and double quotes (") are interchangeable for simple strings, as long as the start and
end quotes match.

python
CollapseWrapRun
Copy
str1 = 'Hello'
str2 = "World"

Use double quotes if the string contains single quotes (or vice versa) to avoid escaping:

python
CollapseWrapRun
Copy
str3 = "Don't worry" # No need to escape single quote
str4 = 'He said, "Hi!"' # No need to escape double quote

b. Using Triple Quotes

Triple quotes (''' or """) are used for multiline strings or strings containing both single and
double quotes without escaping.

python
CollapseWrapRun
Copy
multiline = """This is a
multiline string
with 'single' and "double" quotes."""
print(multiline)

Output:

text
CollapseWrap
Copy
This is a
multiline string
with 'single' and "double" quotes.

c. Using str() Constructor

The str() function converts other data types (e.g., integers, lists) to strings.

python
CollapseWrapRun
Copy
num = str(42) # Converts integer 42 to string "42"
lst = str([1, 2, 3]) # Converts list to string "[1, 2, 3]"

d. Raw Strings

Raw strings (prefixed with r) treat backslashes (\) as literal characters, useful for regular
expressions or file paths.

python
CollapseWrapRun
Copy
raw_str = r"C:\Users\Alice" # Backslash not treated as escape
print(raw_str) # Output: C:\Users\Alice
e. F-strings (Formatted String Literals)

F-strings (Python 3.6+) allow embedding expressions inside string literals using curly braces
{}.

python
CollapseWrapRun
Copy
name = "Bob"
age = 30
f_str = f"My name is {name} and I'm {age} years old."
print(f_str) # Output: My name is Bob and I'm 30 years old.

3. String Operations

Strings support a variety of operations for manipulation and querying.

a. Concatenation

Join strings using the + operator:

python
CollapseWrapRun
Copy
str1 = "Hello"
str2 = "World"
result = str1 + " " + str2 # Output: Hello World

b. Repetition

Repeat a string using the * operator:

python
CollapseWrapRun
Copy
str3 = "Hi" * 3 # Output: HiHiHi

c. Indexing

Access individual characters using zero-based indexing:

python
CollapseWrapRun
Copy
text = "Python"
print(text[0]) # Output: P
print(text[-1]) # Output: n (negative index counts from end)

d. Slicing

Extract a substring using [start:end:step]:

python
CollapseWrapRun
Copy
text = "Python"
print(text[1:4]) # Output: yth (from index 1 to 3)
print(text[::-1]) # Output: nohtyP (reverse string)

e. Membership Testing

Check if a substring exists using in or not in:

python
CollapseWrapRun
Copy
text = "Hello, World!"
print("World" in text) # Output: True
print("Python" not in text) # Output: True

f. Length

Get the number of characters using len():

python
CollapseWrapRun
Copy
text = "Hello"
print(len(text)) # Output: 5

4. Common String Methods

Python provides a rich set of built-in methods for string manipulation. Here are some
commonly used ones:

a. Case Conversion

 str.lower(): Convert to lowercase.

 str.upper(): Convert to uppercase.
 str.title(): Capitalize first letter of each word.
 str.capitalize(): Capitalize first letter of the string.
python
CollapseWrapRun
Copy
text = "hello WORLD"
print(text.lower()) # Output: hello world
print(text.upper()) # Output: HELLO WORLD
print(text.title()) # Output: Hello World
print(text.capitalize()) # Output: Hello world

b. Stripping Whitespace

 str.strip(): Remove leading/trailing whitespace.

 str.lstrip(): Remove leading whitespace.
 str.rstrip(): Remove trailing whitespace.

python
CollapseWrapRun
Copy
text = " Hello "
print(text.strip()) # Output: Hello

c. Searching and Replacing

 str.find(sub): Return index of first occurrence of sub or -1 if not found.

 str.index(sub): Like find(), but raises ValueError if not found.
 str.replace(old, new): Replace all occurrences of old with new.
 str.count(sub): Count occurrences of sub.

python
CollapseWrapRun
Copy
text = "Hello, Hello, World!"
print(text.find("Hello")) # Output: 0
print(text.index("World")) # Output: 13
print(text.replace("Hello", "Hi")) # Output: Hi, Hi, World!
print(text.count("Hello")) # Output: 2

d. Splitting and Joining

 str.split(sep): Split string into a list based on separator sep.

 str.join(iterable): Join elements of an iterable into a string using str as separator.

python
CollapseWrapRun
Copy
text = "apple,banana,orange"
fruits = text.split(",") # Output: ['apple', 'banana', 'orange']
new_text = "-".join(fruits) # Output: apple-banana-orange

e. Checking Properties

 str.isalpha(): True if all characters are alphabetic.

 str.isdigit(): True if all characters are digits.
 str.isalnum(): True if all characters are alphanumeric.
 str.startswith(prefix): True if string starts with prefix.
 str.endswith(suffix): True if string ends with suffix.

python
CollapseWrapRun
Copy
text = "Python3"
print(text.isalnum()) # Output: True
print(text.startswith("Py")) # Output: True
print("123".isdigit()) # Output: True

f. Formatting Methods

 str.center(width): Center string within width characters.

 str.ljust(width): Left-justify string.
 str.rjust(width): Right-justify string.

python
CollapseWrapRun
Copy
text = "Hi"
print(text.center(10, "*")) # Output: ****Hi****

5. String Formatting

Python offers multiple ways to format strings, combining variables and text.

a. F-strings (Python 3.6+)

Fast and readable, f-strings embed expressions directly:

python
CollapseWrapRun
Copy
name = "Alice"
age = 25
print(f"{name} is {age} years old.") # Output: Alice is 25 years old.
b. str.format()

Uses placeholders {} with the format() method:

python
CollapseWrapRun
Copy
print("My name is {} and I'm {}.".format("Bob", 30)) # Output: My name is
Bob and I'm 30.

c. %-formatting (Legacy)

Older style using % operator:

python
CollapseWrapRun
Copy
print("My name is %s and I'm %d." % ("Charlie", 40)) # Output: My name is
Charlie and I'm 40.

d. Alignment and Precision in F-strings

F-strings support advanced formatting:

python
CollapseWrapRun
Copy
num = 3.14159
print(f"Pi is {num:.2f}") # Output: Pi is 3.14
print(f"{'Left':<10}") # Output: Left

6. Escape Sequences

Special characters are included using a backslash (\):

 \n: Newline
 \t: Tab
 \\: Literal backslash
 \" or \': Include quotes

python
CollapseWrapRun
Copy
text = "Line1\nLine2\tTabbed\\Quote\""
print(text)
Output:

text
CollapseWrap
Copy
Line1
Line2 Tabbed\Quote"

7. String Immutability

Strings are immutable, so operations like replace() or slicing create new strings:

python
CollapseWrapRun
Copy
text = "Hello"
text[0] = "J" # Error: TypeError: 'str' object does not support item
assignment
new_text = "J" + text[1:] # Creates new string: Jello

8. Unicode and Encoding

Python 3 uses Unicode for strings, supporting characters from any language. You can
encode/decode strings to/from bytes:

python
CollapseWrapRun
Copy
text = "Hello, 世界!"
encoded = text.encode("utf-8") # Convert to bytes
decoded = encoded.decode("utf-8") # Back to string
print(encoded) # Output: b'Hello, \xe4\xb8\x96\xe7\x95\x8c!'
print(decoded) # Output: Hello, 世界!

9. String Iteration

Strings are iterable, allowing looping over characters:

python
CollapseWrapRun
Copy
for char in "Python":
 print(char)

Output:

text
CollapseWrap
Copy
P
y
t
h
o
n

10. Common Use Cases

 Text Processing: Parsing, cleaning, or analyzing text data (e.g., CSV files, logs).
 User Input: Handling input from users via input().
 File I/O: Reading/writing text files.
 Regular Expressions: Using the re module for advanced string matching.

python
CollapseWrapRun
Copy
import re
text = "Contact: [email protected]"
email = re.search(r'\w+@\w+\.\w+', text).group() # Output:
[email protected]

11. Performance Considerations

 Immutability: String operations like concatenation in a loop can be slow for large
strings. Use str.join() instead:

python

CollapseWrapRun

Copy

# Inefficient

result = ""
 for i in range(1000):

result += "a" # Creates new string each time

# Efficient

result = "".join("a" for i in range(1000))

 String Interning: Python interns some strings (e.g., short identifiers) for memory
efficiency, but don’t rely on it for large strings.

12. Tips and Best Practices

 Use f-strings for readable and efficient formatting.

 Prefer str.join() over + for concatenating many strings.
 Use raw strings (r"...") for regular expressions or file paths.
 Validate user input to avoid issues with malformed strings.
 Be cautious with encoding when working with files or external systems.