Data Structures

Level: 3 | Version: v1.0 | Author: Meptrasoft

Data Structures at a Glance

A data structure is a way to organize data so a program can store it, access it, update it, and process it easily.

Python provides several built-in data structures. In this module, we will focus on strings, lists, tuples, sets, and dictionaries.

Strings

What is a String?

A string is a sequence of characters used to store text.

student_name = "Arun Kumar"

The value "Arun Kumar" is a string.

Strings can contain:

• Letters
• Numbers
• Spaces
• Special characters

message = "Hello Python!"
student_id = "STU101"

Why Do We Use Strings?

Strings are used to store and process text data.

Real-world examples:

• Student names
• Email addresses
• User input
• Password text
• File names
• API text data
• Log messages
• Resume content

Example:

student_name = "Arun Kumar"

In a real application, we may need to:

• Remove extra spaces
• Convert text to lowercase
• Search for a word
• Replace text
• Split the name
• Validate the input

Python string methods help us perform these operations.

Key Features of Strings

Creating a String

Single Quotes

student_name = 'Arun Kumar'

Double Quotes

student_name = "Arun Kumar"

Both are valid.

Triple Quotes

Triple quotes are used for multi-line strings.

profile = """Arun Kumar
CSE Student
Python Developer"""

Accessing String Characters

Strings support indexing.

student_name = "Arun Kumar"
print(student_name[0])   # A
print(student_name[1])   # r
print(student_name[-1])  # r

• Index 0 → first character
• Index -1 → last character

Positive and negative indexing are covered separately in the Indexing topic.

Strings are Immutable

Strings cannot be changed directly.

student_name = "Arun"
student_name[0] = "K"

Error:

Output:

TypeError: 'str' object does not support item assignment

Correct Approach

Create a new string.

student_name = "Arun"
student_name = "K" + student_name[1:]
print(student_name)

Output:

Krun

Important: String methods usually return a new string because strings are immutable.

String Length

Use len() to count characters.

student_name = "Arun Kumar"
print(len(student_name))

Output:

10

Spaces are also counted as characters.

Cleaning User Input

Consider input received from a form:

student_name = "  Arun Kumar  "

The string contains unwanted spaces.

strip()

Removes spaces from both ends.

student_name = "  Arun Kumar  "
student_name = student_name.strip()
print(student_name)

Output:

Arun Kumar

lstrip()

Removes spaces from the left side.

student_name = "  Arun Kumar  "
student_name = student_name.lstrip()

rstrip()

Removes spaces from the right side.

student_name = "  Arun Kumar  "
student_name = student_name.rstrip()

strip() vs lstrip() vs rstrip()

Changing String Case

Let's use:

student_name = "Arun Kumar"

lower()

Converts text to lowercase.

student_name = "Arun Kumar"
print(student_name.lower())

Output:

arun kumar

upper()

Converts text to uppercase.

student_name = "Arun Kumar"
print(student_name.upper())

Output:

ARUN KUMAR

title()

Converts the first character of each word to uppercase.

student_name = "Arun Kumar"
print(student_name.title())

Output:

Arun Kumar

capitalize()

Converts the first character of the string to uppercase and the remaining characters to lowercase.

message = "python DEVELOPER"
print(message.capitalize())

Output:

Python developer

swapcase()

Changes uppercase to lowercase and lowercase to uppercase.

student_name = "Arun Kumar"
print(student_name.swapcase())

Output:

aRUN kUMAR

String Case Methods

Searching in a String

Let's use a placement skill string.

skills = "Python SQL Java"

find()

Returns the starting index of the first matching text.

skills = "Python SQL Java"
print(skills.find("SQL"))

Output:

7

If the value is not found:

skills = "Python SQL Java"
print(skills.find("C++"))

Output:

-1

index()

Also returns the index of matching text.

skills = "Python SQL Java"
print(skills.index("SQL"))

Output:

7

If the value does not exist, index() raises a ValueError.

find() vs index()

Placement Favorite: Difference between find() and index().

Checking Whether Text Exists

Use in and not in.

skills = "Python SQL Java"
print("Python" in skills)    # True
print("C++" in skills)       # False
print("C++" not in skills)   # True

Replacing Text

Use replace() to replace text.

skills = "Python SQL Java"
skills = skills.replace("Java", "C++")
print(skills)

Output:

Python SQL C++

The original string is not modified directly. replace() returns a new string.

Counting Text

Use count() to count occurrences.

skills = "Python SQL Python Java"
print(skills.count("Python"))

Output:

2

Splitting a String

Real applications often receive data as text.

skills = "Python,SQL,Java"

Use split() to convert the string into a list.

skills = "Python,SQL,Java"
skill_list = skills.split(",")
print(skill_list)

Output:

['Python', 'SQL', 'Java']

Joining Strings

Use join() to combine multiple strings.

skill_list = ["Python", "SQL", "Java"]
skills = ", ".join(skill_list)
print(skills)

Output:

Python, SQL, Java

split() vs join()

"Python,SQL,Java"
        ↓ split()
["Python", "SQL", "Java"]
        ↓ join()
"Python, SQL, Java"

Very Important in Real Projects: API data processing, CSV-like text, form data, and file processing.

Checking String Content

Python provides methods to validate text.

isalpha()

name = "Arun"
print(name.isalpha())  # True

name = "Arun123"
print(name.isalpha())  # False

isdigit()

student_id = "101"
print(student_id.isdigit())  # True

isalnum()

student_id = "STU101"
print(student_id.isalnum())  # True

Real-Time Input Validation

Consider a student registration form.

student_name = "Arun"
age = "21"
student_id = "STU101"
print(student_name.isalpha())  # True
print(age.isdigit())           # True
print(student_id.isalnum())    # True

These methods are useful for basic input validation.

Checking Start and End

startswith()

Checks whether a string starts with specific text.

student_id = "STU101"
print(student_id.startswith("STU"))

Output:

True

endswith()

Checks whether a string ends with specific text.

resume_file = "arun_resume.pdf"
print(resume_file.endswith(".pdf"))

Output:

True

Real-Time Use

resume_file = "arun_resume.pdf"
if resume_file.endswith(".pdf"):
    print("Valid resume format")

Useful for:

• File extension checking
• URL checking
• ID prefix validation
• Email/domain checks

String Concatenation

Strings can be combined using +.

first_name = "Arun"
last_name = "Kumar"
full_name = first_name + " " + last_name
print(full_name)

Output:

Arun Kumar

String Repetition

Use * to repeat a string.

symbol = "-"
print(symbol * 20)

Output:

--------------------

String Formatting with f-Strings

Consider student placement data:

student_name = "Arun Kumar"
cgpa = 8.5
skill = "Python"

Using an f-string:

skill = 'Sample'
cgpa = 8.5
student_name = "Arun Kumar"
message = f"{student_name} has a CGPA of {cgpa} and knows {skill}."
print(message)

Output:

Arun Kumar has a CGPA of 8.5 and knows Sample.

F-strings make formatted output clean and readable.

Escape Characters

Escape characters represent special characters inside strings.

New Line

print("Name: Arun\nSkill: Python")

Output:

Name: Arun
Skill: Python

Tab

print("Name\tCGPA")
print("Arun\t8.5")

Common String Methods

Common Fresher Mistakes

Practical Example — Cleaning Placement Form Data

student_name = "  arun kumar  "
skills = "Python,SQL,Java"
resume_file = "arun_resume.pdf"
student_name = student_name.strip().title()
skill_list = skills.split(",")
print("Student:", student_name)
print("Skills:", skill_list)
if resume_file.endswith(".pdf"):
    print("Valid Resume")

Output:

Student: Arun Kumar
Skills: ['Python', 'SQL', 'Java']
Valid Resume

This is similar to text cleaning and validation performed in real applications.

Placement Quick Points

• A string is a sequence of characters.
• Strings are ordered and immutable.
• Strings support indexing and slicing.
• String indexing starts from 0.
• String methods return new strings.
• strip() removes characters from both ends; with no argument, it removes surrounding whitespace.
• find() returns -1 when text is not found.
• index() raises ValueError when text is not found.
• split() converts a string into a list.
• join() combines an iterable of strings into a string.
• replace() returns a new string.
• in checks whether text exists.
• f-strings are used for clean string formatting.
• startswith() and endswith() are useful for validation.

Interview Questions

What is a string in Python?

A string is an immutable sequence of characters.

Are strings mutable or immutable?

Immutable.

Can strings be indexed?

Yes.

What is the difference between find() and index()?

find() returns -1 when the value is missing. index() raises a ValueError.

What does strip() do?

It removes leading and trailing whitespace by default. If characters are provided, it removes those characters from both ends.

What is the difference between split() and join()?

split() converts a string into a list. join() combines an iterable of strings into a string.

Do string methods modify the original string?

No. Strings are immutable.

How do you check whether a string contains only digits?

value.isdigit().

What is an f-string?

A readable way to insert expressions into a formatted string.

What does find() return if the value is not found?

-1.

Can we change a character using an index?

No. Strings do not support item assignment.

What does join() require?

An iterable containing strings.

Practice

Use:

student_name = "  arun kumar  "
skills = "Python,SQL,Java"
student_id = "STU101"
resume_file = "arun_resume.pdf"

1. Remove extra spaces from student_name.
2. Convert the student name to title case.
3. Convert the name to uppercase.
4. Find the index of "SQL" in skills.
5. Replace "Java" with "C++".
6. Convert skills into a list.
7. Join the skill list using " | ".
8. Check whether student_id starts with "STU".
9. Check whether resume_file ends with ".pdf".
10. Check whether "Python" exists in skills.
11. Count how many times "Python" appears.
12. Explain the difference between find() and index().
13. Find the error:

student_name = "  arun kumar  "
student_name[0] = "A"

14. Predict the output:

text = "Python"
print(text.find("Java"))

15. Explain why this causes an error:

",".join([10, 20, 30])

Lists

What is a List?

A list is a collection used to store multiple values under one name.

skills = ["Python", "SQL", "Java"]

Instead of creating multiple variables:

skill1 = "Python"
skill2 = "SQL"
skill3 = "Java"

We can store all values in one list.

skills = ["Python", "SQL", "Java"]

Why Do We Use Lists?

Lists help us store, access, update, and manage multiple values together.

marks = [85, 90, 78, 92]

Real-world examples:

• Student marks
• Product names
• Employee records
• File names
• API results
• Model predictions

Key Features of Lists

Creating a List

Empty List

numbers = []

List with Values

numbers = [10, 20, 30]

Mixed Data Types

data = [10, "Python", 3.14, True]

Duplicate Values

numbers = [10, 20, 20, 30]

Lists allow duplicate values.

Nested List

A list can contain another list.

data = [10, [20, 30], 40]

Accessing List Elements

List elements are accessed using an index.

skills = ["Python", "SQL", "Java"]
print(skills[0])   # Python
print(skills[1])   # SQL
print(skills[-1])  # Java

• Index 0 → first element
• Index -1 → last element

Positive and negative indexing are covered separately in the Indexing topic.

Updating List Elements

Lists are mutable, so their elements can be changed.

skills = ["Python", "SQL", "Java"]
skills[2] = "C++"
print(skills)

Output:

['Python', 'SQL', 'C++']

Adding Elements

append()

Adds one item to the end of the list.

skills = ["Python", "SQL"]
skills.append("Java")
print(skills)

Output:

['Python', 'SQL', 'Java']

extend()

Adds multiple elements from an iterable.

skills = ["Python", "SQL"]
skills.extend(["Java", "C++"])
print(skills)

Output:

['Python', 'SQL', 'Java', 'C++']

insert()

Adds an element at a specific index.

skills = ["Python", "Java"]
skills.insert(1, "SQL")
print(skills)

Output:

['Python', 'SQL', 'Java']

append() vs extend()

Example:

a = [1, 2]
a.append([3, 4])
print(a)

Output:

[1, 2, [3, 4]]

a = [1, 2]
a.extend([3, 4])
print(a)

Output:

[1, 2, 3, 4]

Placement Favorite: append() vs extend().

Removing Elements

remove()

Removes the first matching value.

numbers = [10, 20, 30, 20]
numbers.remove(20)
print(numbers)

Output:

[10, 30, 20]

pop()

Removes and returns an element.

numbers = [10, 20, 30]
removed = numbers.pop()
print(removed)  # 30
print(numbers)  # [10, 20]

Remove using an index:

numbers = [10, 20, 30]
numbers.pop(1)

clear()

Removes all elements.

numbers = [10, 20, 30]
numbers.clear()
print(numbers)  # []

remove() vs pop()

numbers = [10, 20, 30]
numbers.remove(20)  # Remove value
numbers.pop(0)      # Remove by index

Searching and Counting

index()

Returns the index of the first matching value.

numbers = [10, 20, 30]
print(numbers.index(20))  # 1

count()

Counts how many times a value appears.

numbers = [10, 20, 20, 30]
print(numbers.count(20))  # 2

Membership Operators

Use in and not in to check whether a value exists.

skills = ["Python", "SQL"]
print("Python" in skills)      # True
print("Java" not in skills)    # True

Sorting a List

sort()

Sorts the original list.

numbers = [40, 10, 30, 20]
numbers.sort()
print(numbers)

Output:

[10, 20, 30, 40]

Descending order:

numbers = [40, 10, 30, 20]
numbers.sort(reverse=True)

sort() vs sorted()

numbers = [30, 10, 20]
result = numbers.sort()
print(result)  # None

Using sorted():

numbers = [30, 10, 20]
result = sorted(numbers)
print(result)   # [10, 20, 30]
print(numbers)  # [30, 10, 20]

Common Placement Question: Why does list.sort() return None? Because it modifies the original list in place.

Reversing a List

The reverse() method reverses the original list.

numbers = [10, 20, 30]
numbers.reverse()
print(numbers)

Output:

[30, 20, 10]

Useful Built-in Functions

marks = [80, 90, 70, 85]
print(len(marks))  # 4
print(max(marks))  # 90
print(min(marks))  # 70
print(sum(marks))  # 325

Copying a List

Consider this code:

a = [10, 20, 30]
b = a
b.append(40)
print(a)

Output:

[10, 20, 30, 40]

Why did a change? Because a and b refer to the same list object.

Use copy() to create a separate shallow copy.

a = [10, 20, 30]
b = a.copy()
b.append(40)
print(a)  # [10, 20, 30]
print(b)  # [10, 20, 30, 40]

Shallow copy and deep copy are covered separately in the Copying Objects topic.

Common List Methods

Common Fresher Mistakes

Practical Example — Student Marks

marks = [75, 85, 60, 90]
marks.append(80)
print("Marks:", marks)
print("Highest:", max(marks))
print("Lowest:", min(marks))
print("Total:", sum(marks))
print("Average:", sum(marks) / len(marks))

Output:

Marks: [75, 85, 60, 90, 80]
Highest: 90
Lowest: 60
Total: 390
Average: 78.0

Placement Quick Points

• A list stores multiple values.
• Lists are ordered and mutable.
• Lists allow duplicate values.
• Lists can store different data types.
• List indexing starts from 0.
• append() adds one item.
• extend() adds elements from an iterable.
• remove() removes by value.
• pop() removes by index and returns the removed item.
• sort() modifies the original list.
• sorted() returns a new sorted list.
• b = a does not create a copy.
• Use copy() to create a shallow copy.

Interview Questions

What is a list in Python?

A list is an ordered and mutable collection of elements.

Can a list contain duplicate values?

Yes.

Can a list store different data types?

Yes.

What is the difference between append() and extend()?

append() adds one item, while extend() adds elements from an iterable.

What is the difference between remove() and pop()?

remove() removes by value. pop() removes by index and returns the removed item.

What is the difference between sort() and sorted()?

sort() changes the original list. sorted() returns a new sorted list.

Is a list mutable or immutable?

Mutable.

Does b = a copy a list?

No. Both names refer to the same list.

How do you create a shallow copy of a list?

b = a.copy().

What does list.sort() return?

None.

Practice

16. Create a list of five student marks.
17. Add a new mark using append().
18. Add three marks using extend().
19. Insert a mark at index 2.
20. Remove a value using remove().
21. Remove the last element using pop().
22. Find how many times 10 appears in a list.
23. Sort a list in ascending and descending order.
24. Find the maximum, minimum, and sum of a numeric list.
25. Explain the output:

a = [1, 2, 3]
b = a
b.append(4)
print(a)

26. Find the error:

data = [10, 20]
data.extend(30)

27. Explain why this prints None:

numbers = [3, 1, 2]
result = numbers.sort()
print(result)

Tuples

What is a Tuple?

A tuple is a collection used to store multiple values under one name.

skills = ("Python", "SQL", "Java")

A tuple is similar to a list, but it is immutable.

Immutable means tuple elements cannot be replaced, added, or removed after creation.

Why Do We Use Tuples?

Tuples are useful when the collection structure should remain fixed and unchanged.

coordinates = (10, 20)

Real-world examples:

• Coordinates
• RGB color values
• Date values
• Database records
• Fixed configuration values
• Function return values

Key Features of Tuples

Creating a Tuple

Empty Tuple

data = ()

Tuple with Values

numbers = (10, 20, 30)

Mixed Data Types

data = (10, "Python", 3.14, True)

Duplicate Values

numbers = (10, 20, 20, 30)

Tuples allow duplicate values.

Nested Tuple

A tuple can contain another tuple.

data = (10, (20, 30), 40)

Creating a Single-Element Tuple

A single-element tuple must contain a comma.

data = (10,)

Without the comma:

data = (10)
print(type(data))

Output:

<class 'int'>

With the comma:

data = (10,)
print(type(data))

Output:

<class 'tuple'>

Placement Favorite: The comma creates a single-element tuple, not the parentheses alone.

Accessing Tuple Elements

Tuple elements are accessed using an index.

skills = ("Python", "SQL", "Java")
print(skills[0])   # Python
print(skills[1])   # SQL
print(skills[-1])  # Java

• Index 0 → first element
• Index -1 → last element

Positive and negative indexing are covered separately in the Indexing topic.

Tuple is Immutable

Tuple elements cannot be replaced after creation.

skills = ("Python", "SQL", "Java")
skills[1] = "C++"

Error:

Output:

TypeError: 'tuple' object does not support item assignment

This is the main difference between a list and tuple.

Can We Add or Remove Tuple Elements?

No.

Tuples do not support methods such as:

append()
extend()
insert()
remove()
pop()
clear()

These methods change the collection, but tuples are immutable.

Tuple Methods

Tuples have only two commonly used methods.

count()

Counts how many times a value appears.

numbers = (10, 20, 20, 30)
print(numbers.count(20))  # 2

index()

Returns the index of the first matching value.

numbers = (10, 20, 30)
print(numbers.index(20))  # 1

Membership Operators

Use in and not in to check whether a value exists.

skills = ("Python", "SQL", "Java")
print("Python" in skills)      # True
print("C++" not in skills)     # True

Useful Built-in Functions

marks = (80, 90, 70, 85)
print(len(marks))  # 4
print(max(marks))  # 90
print(min(marks))  # 70
print(sum(marks))  # 325

Important: sorted() Returns a List

numbers = (30, 10, 20)
result = sorted(numbers)
print(result)
print(type(result))

Output:

[10, 20, 30]
<class 'list'>

sorted() does not return a tuple.

Tuple Packing

Storing multiple values in a tuple is called tuple packing.

student = ("Arun", 21, 8.5)

Python also allows packing without parentheses.

student = "Arun", 21, 8.5
print(type(student))

Output:

<class 'tuple'>

Tuple Unpacking

Assigning tuple elements to multiple names is called tuple unpacking.

student = ("Arun", 21, 8.5)
name, age, cgpa = student
print(name)
print(age)
print(cgpa)

Output:

Arun
21
8.5

The number of names and values should match.

student = ("Arun", 21, 8.5)
name, age = student

This causes a ValueError.

Swapping Using Tuple Unpacking

Python uses packing and unpacking while swapping values.

a = 10
b = 20
a, b = b, a
print(a, b)

Output:

20 10

Tuple with Mutable Elements

A tuple itself is immutable, but it can contain a mutable object such as a list.

data = (10, [20, 30], 40)
data[1].append(50)
print(data)

Output:

(10, [20, 30, 50], 40)

Why Did the Tuple Change?

The tuple still refers to the same list object.

We did not replace the tuple element. We modified the list stored inside it.

data = (10, [20, 30], 40)
data[1] = [100, 200]  # Error

Replacing a tuple element is not allowed.

Interview Important: Tuple immutability does not automatically make every object inside the tuple immutable.

List vs Tuple

Converting List and Tuple

List to Tuple

numbers = [10, 20, 30]
result = tuple(numbers)
print(result)

Output:

(10, 20, 30)

Tuple to List

numbers = (10, 20, 30)
result = list(numbers)
print(result)

Output:

[10, 20, 30]

How to Modify a Tuple?

A tuple cannot be modified directly.

If modification is required:

28. Convert tuple to list
29. Modify the list
30. Convert it back to tuple

numbers = (10, 20, 30)
data = list(numbers)
data.append(40)
numbers = tuple(data)
print(numbers)

Output:

(10, 20, 30, 40)

Common Fresher Mistakes

Practical Example — Student Record

student = ("Arun", 21, 8.5)
name, age, cgpa = student
print("Name:", name)
print("Age:", age)
print("CGPA:", cgpa)

Output:

Name: Arun
Age: 21
CGPA: 8.5

A tuple is suitable here when the record values are treated as fixed data.

Placement Quick Points

• A tuple stores multiple values.
• Tuples are ordered and immutable.
• Tuples allow duplicate values.
• Tuples can store different data types.
• Tuple indexing starts from 0.
• A single-element tuple requires a comma.
• Tuples have count() and index() methods.
• Tuple packing stores multiple values together.
• Tuple unpacking assigns values to multiple names.
• sorted(tuple) returns a list.
• A tuple can contain mutable objects.
• Tuple immutability prevents replacing its elements.

Interview Questions

What is a tuple in Python?

A tuple is an ordered and immutable collection of elements.

What is the main difference between a list and a tuple?

A list is mutable, while a tuple is immutable.

How do you create a single-element tuple?

data = (10,).

Why is (10) not a tuple?

Parentheses alone do not create a single-element tuple. The comma is required.

What methods are available for tuples?

count() and index().

Can a tuple contain duplicate values?

Yes.

Can a tuple contain different data types?

Yes.

What is tuple packing?

Storing multiple values together as a tuple.

What is tuple unpacking?

Assigning tuple values to multiple names.

Can a tuple contain a list?

Yes.

Can the list inside a tuple be modified?

Yes, because the list itself is mutable.

What does sorted() return when used with a tuple?

A list.

Practice

31. Create a tuple containing five numbers.
32. Create a single-element tuple.
33. Access the first and last elements of a tuple.
34. Count how many times 10 appears.
35. Find the index of 20.
36. Check whether "Python" exists in a tuple.
37. Find the maximum, minimum, and sum of a numeric tuple.
38. Pack a student's name, age, and CGPA into a tuple.
39. Unpack the student tuple into three variables.
40. Convert a list into a tuple.
41. Convert a tuple into a list.
42. Predict the output:

data = (10)
print(type(data))

43. Find the error:

numbers = (10, 20, 30)
numbers.append(40)

44. Explain the output:

data = (10, [20, 30])
data[1].append(40)
print(data)

Indexing

Indexing means accessing an element using its position number, called an index.

numbers = [10, 20, 30, 40, 50]

Python supports two types of indexing:

• Positive Indexing — starts from 0
• Negative Indexing — starts from -1

Positive and Negative Indexing

Positive Indexing

Positive indexing starts from 0 and moves from left to right.

numbers = [10, 20, 30, 40, 50]
print(numbers[0])  # 10
print(numbers[2])  # 30
print(numbers[4])  # 50

Important

The first element is at index 0, not 1.

numbers = [10, 20, 30, 40, 50]
numbers[0]  # First element
numbers[1]  # Second element

Negative Indexing

Negative indexing starts from -1 and accesses elements from right to left.

numbers = [10, 20, 30, 40, 50]
print(numbers[-1])  # 50
print(numbers[-2])  # 40
print(numbers[-5])  # 10

-1 always refers to the last element.

Positive vs Negative Indexing

The same element can be accessed using either a positive or negative index.

numbers = [10, 20, 30, 40, 50]
print(numbers[0])   # 10
print(numbers[-5])  # 10
print(numbers[4])   # 50
print(numbers[-1])  # 50

Index Range

For a list containing 5 elements:

numbers = [10, 20, 30, 40, 50]

General Rule

For a collection with n elements:

• Positive index: 0 to n - 1
• Negative index: -1 to -n

IndexError

Accessing an index outside the valid range causes an IndexError.

numbers = [10, 20, 30, 40, 50]
print(numbers[5])   # IndexError
print(numbers[-6])  # IndexError

Valid indexes are:

Output:

Positive:  0, 1, 2, 3, 4
Negative: -1, -2, -3, -4, -5

Indexing Different Data Types

Indexing is not limited to lists. It can also be used with other ordered sequence types.

String

name = "Python"
print(name[0])   # P
print(name[-1])  # n

List

skills = ["Python", "SQL", "Java"]
print(skills[0])   # Python
print(skills[-1])  # Java

Tuple

numbers = (10, 20, 30)
print(numbers[1])   # 20
print(numbers[-1])  # 30

Common Fresher Mistakes

Useful Access Patterns

numbers = [10, 20, 30, 40, 50]
print(numbers[0])   # First element
print(numbers[-1])  # Last element
print(numbers[1])   # Second element
print(numbers[-2])  # Second last element

Placement Quick Points

• Indexing is used to access an element by its position.
• Positive indexing starts from 0.
• Negative indexing starts from -1.
• 0 represents the first element.
• -1 represents the last element.
• For n elements, the last positive index is n - 1.
• For n elements, the first negative index is -n.
• An invalid index raises IndexError.
• Strings, lists, and tuples support indexing.

Interview Questions

What is indexing in Python?

Indexing is accessing an element using its position number.

What is the index of the first element?

0.

What is the index of the last element?

-1 or len(collection) - 1.

What happens when an invalid index is accessed?

Python raises an IndexError.

What is the valid positive index range for 5 elements?

0 to 4.

What is the valid negative index range for 5 elements?

-1 to -5.

Do dictionaries support positional indexing?

No. Dictionaries are accessed using keys, not positional indexes.

Practice

Use:

numbers = [10, 20, 30, 40, 50]

45. Access the first element.
46. Access the last element using negative indexing.
47. Access 30 using both positive and negative indexing.
48. Access the second-last element.
49. What happens with numbers[5]?
50. What happens with numbers[-6]?
51. Find the output:

numbers = [10, 20, 30, 40, 50]
print(numbers[-len(numbers)])

Slicing

Slicing means accessing a portion of a sequence, instead of a single element.

numbers = [10, 20, 30, 40, 50]
numbers = [10, 20, 30, 40, 50]
numbers = [10, 20, 30, 40, 50]
numbers = [10, 20, 30, 40, 50]
print(numbers[1:4])  # [20, 30, 40]

Slicing works on any ordered sequence, such as strings and lists.

Basic Syntax

sequence[start:stop]

• start — the index where the slice begins (included)
• stop — the index where the slice ends (excluded)

The element at stop is not part of the result.

numbers = [10, 20, 30, 40, 50]
print(numbers[1:4])  # [20, 30, 40]

Here the slice starts at index 1 (20) and stops before index 4 (50).

Omitting start or stop

If start is omitted, the slice begins at the start of the sequence. If stop is omitted, the slice runs to the end of the sequence.

numbers = [10, 20, 30, 40, 50]
print(numbers[:3])   # [10, 20, 30]
print(numbers[2:])   # [30, 40, 50]
print(numbers[:])    # [10, 20, 30, 40, 50]

numbers[:] returns all the elements.

Slicing Strings

Strings support slicing in the same way.

name = "Python"
print(name[0:3])  # Pyt
print(name[3:])   # hon
print(name[:2])   # Py

A common use is skipping the first character:

student_name = "Aarav"
print(student_name[1:])  # arav

Negative Indices in Slicing

Slicing also works with negative indices, counting from the right.

numbers = [10, 20, 30, 40, 50]
print(numbers[-3:])   # [30, 40, 50]
print(numbers[:-2])   # [10, 20, 30]

name = "Python"
print(name[-3:])  # hon

The step Value

Slicing can take a third value, called the step.

sequence[start:stop:step]

The step decides how many positions to move for each element.

numbers = [10, 20, 30, 40, 50]
print(numbers[0:5:2])  # [10, 30, 50]

Here the slice takes every second element.

Reversing with Slicing

A step of -1 reverses the sequence.

sequence[::-1]

numbers = [10, 20, 30, 40, 50]
print(numbers[::-1])  # [50, 40, 30, 20, 10]

name = "Python"
print(name[::-1])     # nohtyP

Slicing vs Indexing