If we want to represent a group of individual objects as a single entity, where insertion order is preserved and duplicate objects are allowed, then we should use a List.

A list is one of the most commonly used data structures in Python.

It can store multiple values in a single variable and allows different types of data to be stored together.

A Python list has the following characteristics:

• Insertion order is preserved.
• Duplicate objects are allowed.
• Heterogeneous objects are allowed.
• List is dynamic.
• List objects are mutable.

1. Insertion Order is Preserved

The elements are stored in the same order in which they are inserted.

2. Duplicate Objects are Allowed

A list can contain duplicate values.

3. Heterogeneous Objects are Allowed

A list can store different types of data together.

Example:

The above list contains:

• Integer values
• String values
• Duplicate value (10)

4. List is Dynamic

A list is growable.

Based on our requirement, we can increase or decrease its size.

5. List is Mutable

List objects are mutable.

This means we can modify the contents of a list after creating it.

List elements are enclosed within square brackets [].

Each element is separated by a comma (,).

Python uses indexes to access list elements.

Indexes also help us differentiate duplicate elements.

Python supports two types of indexing:

• Positive Index
• Negative Index

Positive Index	Negative Index
Starts from left to right.	Starts from right to left.
First index is 0.	Last index is -1.

Element	10	A	B	20	30	10
Positive Index	0	1	2	3	4	5
Negative Index	-6	-5	-4	-3	-2	-1

No output captured.

There are different ways to create a list in Python.

The split() method returns a list.

List elements can be accessed in two ways:

1. Using Index
2. Using Slice Operator

Python supports both positive and negative indexing.

The slice operator is used to access multiple elements from a list.

Topic	Description
List	Ordered collection of objects
Insertion Order	Preserved
Duplicate Objects	Allowed
Heterogeneous Objects	Allowed
Dynamic	Size can be increased or decreased
Mutable	Elements can be modified
Representation	Square brackets []
Positive Index	Left to Right
Negative Index	Right to Left
Slice Operator	Access multiple elements

• A list represents a group of individual objects as a single entity.
• Lists preserve insertion order.
• Duplicate elements are allowed.
• Different data types can be stored in the same list.
• Lists are dynamic in nature.
• Lists are mutable, so their contents can be modified.
• Python supports both positive and negative indexing.
• List elements can be accessed using indexes or the slice operator.
• An empty list can be created using [].
• The list() function and split() method can also be used to create list objects.

Traversing means accessing every element of a list one by one.

Python provides different ways to traverse a list.

The most commonly used methods are:

• Using for loop
• Using while loop

The for loop is the easiest way to traverse a list.

It automatically reads one element at a time.

The for loop visits every element of the list.

Each element is stored in the variable x and printed.

We can also traverse a list using the while loop.

In this method, we use the index of each element.

len(list) returns the total number of elements.

The variable i is used as the index.

The loop continues until all elements are printed.

Every element in a list has both a positive index and a negative index.

We can display both indexes while traversing the list.

Lists are mutable.

This means we can change their contents after creation.

We can:

• Modify existing elements.
• Add new elements.
• Delete existing elements.

We can update an element by using its index.

• Lists are mutable, so their contents can be changed.
• Elements can be updated using positive or negative indexes.
• Multiple elements can be updated using the slice operator.
• The for loop is the simplest way to traverse a list.
• The while loop is useful when index values are required.
• len() returns the total number of elements in the list.

Topic	Description
Traversing	Accessing every element one by one.
for Loop	Traverses elements directly.
while Loop	Traverses elements using indexes.
Positive Index	Starts from 0.
Negative Index	Starts from -1.
Mutable	Elements can be modified after creation.
Update Element	Use index or slice operator.
len()	Returns the number of elements.

Python provides several methods to add new elements to a list.

The most commonly used methods are:

• append()
• insert()
• extend()

These methods allow us to add one or more elements to an existing list.

The append() method adds a single element at the end of the list.

Syntax:

A list can store different types of objects.

The append() method always adds the new element at the end of the list.

• Adds only one element at a time.
• Always inserts the element at the end of the list.
• The original list is modified.

The insert() method inserts an element at a specified position.

Syntax:

The element is inserted at the specified index.

Existing elements are automatically shifted to the right.

• If the index is greater than the list size, the element is added at the end.
• If the index is negative, Python inserts the element according to the negative index.

The extend() method adds all elements from another iterable to the end of the list.

The iterable can be another list, tuple, set, or any iterable object.

Syntax:

A string is also an iterable.

Therefore, each character is added separately to the list.

append()	extend()
Adds only one element.	Adds multiple elements.
Accepts any object.	Accepts only an iterable.
The object is added as a single element.	Each element of the iterable is added separately.

Method	Purpose
append()	Adds one element at the end.
insert()	Inserts an element at a specified index.
extend()	Adds all elements of another iterable.

• append() always adds one element at the end.
• insert() inserts an element at the specified index.
• extend() adds multiple elements from another iterable.
• append() accepts any object.
• extend() accepts only iterable objects.
• All three methods modify the original list.
• Strings, tuples, lists, and sets can be passed to extend().

Python provides different methods to remove elements from a list.

The most commonly used methods are:

• remove()
• pop()
• clear()

Each method works differently depending on the requirement.

The remove() method removes the specified element from the list.

If duplicate values are present, only the first occurrence is removed.

Syntax:

The remove() method deletes only the first matching element.

Other duplicate elements remain in the list.

• Removes an element by value.
• Only the first matching element is removed.
• If the element is not available, Python raises ValueError.

The pop() method removes an element using its index.

It also returns the removed element.

Syntax:

If no index is specified, pop() removes the last element.

• Removes an element using its index.
• Returns the removed element.
• If no index is given, the last element is removed.
• If the index is invalid, Python raises IndexError.

The clear() method removes all elements from the list.

After using clear(), the list becomes empty.

Syntax:

The list object still exists.

Only its elements are removed.

Method	Description
remove()	Removes an element by value.
pop()	Removes an element by index and returns it.
clear()	Removes all elements from the list.

Feature	remove()	pop()	clear()
Removes by	Value	Index	All Elements
Returns Removed Element	No	Yes	No
Raises Error	ValueError	IndexError	No
List Exists After Operation	Yes	Yes	Yes

These methods are commonly used in:

• Student management systems
• Shopping cart applications
• Employee record management
• Task management applications
• Data processing programs

• remove() removes an element by value.
• remove() deletes only the first matching element.
• pop() removes an element by index.
• pop() returns the removed element.
• If no index is given, pop() removes the last element.
• clear() removes all elements from the list.
• After clear(), the list still exists but becomes empty.

Method	Purpose
remove(value)	Removes the specified element.
pop(index)	Removes and returns an element.
pop()	Removes the last element.
clear()	Removes all elements.

The del statement is used to delete elements or an entire list.

Unlike remove() and pop(), del is a Python keyword.

It can delete:

• A single element
• Multiple elements
• A complete list object

After deleting the entire list, the variable no longer exists.

Trying to access it raises a NameError.

del	clear()
Deletes the list or selected elements.	Removes all elements only.
The list variable can also be removed.	The list variable still exists.
Raises NameError if the deleted list is accessed.	Produces an empty list [].

A Stack is a linear data structure.

It follows the LIFO (Last In, First Out) principle.

The element inserted last is removed first.

Python lists can be used to implement a stack.

Operation	Method
Push	append()
Pop	pop()

The last inserted element is always removed first.

This behavior is called LIFO (Last In, First Out).

Method	Purpose
append()	Add one element at the end.
extend()	Add multiple elements.
insert()	Insert an element at a specified position.
remove()	Remove an element by value.
pop()	Remove an element by index and return it.
clear()	Remove all elements.
del	Delete elements or the complete list.

Method	Removes By	Returns Value
remove()	Element Value	No
pop()	Index	Yes
clear()	All Elements	No
del	Index, Slice or Entire List	No

• del is a Python keyword.
• del can delete a single element, multiple elements, or the complete list.
• clear() removes all elements but keeps the list object.
• A stack follows the LIFO (Last In, First Out) principle.
• append() is used for Push operation.
• pop() is used for Pop operation.
• The last inserted element is removed first in a stack.

Method	Description
append()	Add one element.
extend()	Add multiple elements.
insert()	Insert at specified index.
remove()	Remove by value.
pop()	Remove by index and return element.
clear()	Remove all elements.
del	Delete elements or entire list.

Topic	Remember
append()	Add one element.
extend()	Add multiple elements.
insert()	Insert at index.
remove()	Remove by value.
pop()	Remove by index.
clear()	Empty the list.
del	Delete list or elements.
Stack	LIFO Data Structure.

Python provides several built-in functions and methods to get information about a list.

The most commonly used list information functions are:

• len()
• count()
• index()

These functions help us find the size of a list, count duplicate elements, and locate elements.

The len() function returns the total number of elements present in a list.

Syntax:

The len() function counts every element in the list.

It does not depend on the data type of the elements.

The count() method returns the number of occurrences of a specified element in the list.

Syntax:

If the specified element is not available, the count() method returns 0.

The index() method returns the index of the first occurrence of the specified element.

Syntax:

If duplicate elements are present, the index() method returns the index of the first occurrence only.

The second argument specifies the starting index for the search.

The search begins from that position instead of the beginning of the list.

The third argument specifies the ending position.

The search is performed only within the given range.

count()	index()
Returns the number of occurrences.	Returns the index of the first occurrence.
Returns 0 if the element is not present.	Raises ValueError if the element is not present.
Used to count duplicate values.	Used to locate an element.

Function / Method	Purpose
len()	Returns the number of elements.
count()	Returns the number of occurrences of an element.
index()	Returns the index of the first occurrence.

These functions are commonly used in:

• Searching data
• Finding duplicate records
• Counting student attendance
• Inventory management
• Data validation

• len() returns the total number of elements.
• count() returns how many times an element appears.
• index() returns the index of the first occurrence only.
• count() returns 0 if the element is not found.
• index() raises ValueError if the element is not found.
• index() supports optional start and end positions.

Function / Method	Description
len()	Returns the total number of elements.
count()	Counts the occurrences of an element.
index()	Returns the index of the first occurrence.

Sometimes we need to arrange the elements of a list in a specific order.

Python provides the following methods for ordering list elements:

• reverse()
• sort()
• sorted()

The reverse() method reverses the order of elements in the original list.

It does not create a new list.

The original list is modified.

The first element becomes the last element and the last element becomes the first element.

• The original list is modified.
• No new list is created.
• The order of elements becomes exactly opposite.

The sort() method arranges list elements in ascending order by default.

It modifies the original list.

Strings are sorted in alphabetical order.

Numbers are sorted from smallest to largest.

To sort elements in descending order, use the reverse=True argument.

• The original list is modified.
• Ascending order is the default order.
• Use reverse=True for descending order.
• All elements should be of compatible data types.

The sort() method cannot sort a list containing incompatible data types such as integers and strings together.

The sorted() function returns a new sorted list.

The original list remains unchanged.

The sorted() function returns a new sorted list.

The original list is not modified.

Method / Function	Description
reverse()	Reverses the current order of the list.
sort()	Sorts the original list.
sorted()	Returns a new sorted list.

Feature	reverse()	sort()	sorted()
Creates New List	No	No	Yes
Modifies Original List	Yes	Yes	No
Ascending Order	No	Yes	Yes
Descending Order	No	Yes (reverse=True)	Yes (reverse=True)

Ordering methods are commonly used in:

• Student result systems
• Employee salary reports
• Product price sorting
• Leaderboard applications
• Data analysis projects

• reverse() changes only the current order.
• sort() arranges elements in ascending order by default.
• Use reverse=True for descending order.
• sorted() returns a new sorted list.
• The original list remains unchanged when using sorted().
• Lists containing incompatible data types cannot be sorted.

Method / Function	Purpose
reverse()	Reverse the current order.
sort()	Sort the original list.
sorted()	Create a new sorted list.

Python provides several operators that can be used with lists.

The most commonly used list operators are:

• Concatenation Operator (+)
• Repetition Operator (*)
• Comparison Operators
• Membership Operators

The + operator joins two or more lists.

It creates and returns a new list containing the elements of both lists.

• The original lists are not modified.
• A new list is created.
• Only list objects can be concatenated.

The * operator repeats the elements of a list.

The number specifies how many times the list should be repeated.

The original list is not modified.

A new repeated list is returned.

Lists can be compared using comparison operators.

Python compares the elements one by one from left to right.

Operator	Description
==	Equal to
!=	Not equal to
<	Less than
>	Greater than
<=	Less than or equal to
>=	Greater than or equal to

Python compares list elements one by one.

The comparison stops as soon as a different element is found.

Membership operators are used to check whether an element exists in a list.

Python provides two membership operators:

• in
• not in

The in operator returns True if the element exists.

The not in operator returns True if the element does not exist.

+	*
Joins two lists.	Repeats list elements.
Requires two lists.	Requires a list and an integer.
Creates a larger combined list.	Creates repeated copies of the same list.

Operator	Purpose
+	Join two lists.
*	Repeat list elements.
==	Check equality.
!=	Check inequality.
<, >, <=, >=	Compare list elements.
in	Check whether an element exists.
not in	Check whether an element does not exist.

• The + operator joins two lists.
• The * operator repeats list elements.
• Comparison operators compare elements from left to right.
• The in operator checks whether an element exists.
• The not in operator checks whether an element does not exist.
• The + and * operators create new lists.

Operator	Description
+	Concatenates two lists.
*	Repeats list elements.
==	Checks equality.
!=	Checks inequality.
<, >	Compares list elements.
in	Checks element existence.
not in	Checks element absence.

A list can contain another list as its element.

Such a list is called a Nested List.

Nested lists are useful for representing tables, matrices, and two-dimensional data.

Each element of the main list is itself another list.

Every inner list is called a row.

Individual elements can be accessed using two indexes.

The first index selects the row.

The second index selects the column.

Nested lists are usually traversed using nested loops.

The outer loop processes rows.

The inner loop processes the elements of each row.

A matrix is a collection of rows and columns.

In Python, a matrix can be represented using a nested list.

List Comprehension provides a short and simple way to create a list.

It reduces the number of lines of code.

It is commonly used with loops and conditions.

• Simple and easy to read.
• Requires fewer lines of code.
• Creates lists quickly.
• Can include conditions.
• Improves code readability.

Normal Loop	List Comprehension
Requires multiple lines.	Usually written in one line.
Uses append() repeatedly.	Creates the list directly.
More code.	Less code.
Easy for complex logic.	Best for simple list creation.

• A nested list contains one or more lists as its elements.
• Nested lists are useful for representing matrices and tables.
• Nested loops are commonly used to traverse nested lists.
• List comprehension provides a short way to create lists.
• Conditions can also be used inside list comprehension.
• List comprehension improves code readability and reduces code size.

Topic	Description
Nested List	A list containing one or more lists.
Matrix	Represented using a nested list.
Nested Loop	Used to traverse nested lists.
List Comprehension	Short syntax to create lists.
Condition	Can be used inside list comprehension.