1. Python List Definition:
A list in Python is a built-in data structure that stores an ordered collection of items which are mutable and can contain heterogeneous elements.
2. Characteristics of Python List:
Ordered Collection: Elements in a list maintain the order in which they are added. Indexing is based on this order.
Mutable (Changeable): Lists can be modified after creation. You can add, remove, or update elements.
Allows Duplicate Values: Lists can contain repeated values without any restrictions.
Heterogeneous Elements: A single list can contain elements of different data types (e.g., integers, strings, objects, lists, etc.).
Indexed Access: Each element can be accessed via its zero-based index. Supports both positive and negative indexing.
Supports Slicing: You can extract sub-parts (sublists) using slicing syntax:
list[start:stop:step].Dynamic Size: Lists can grow or shrink during runtime as elements are added or removed.
Rich Built-in Methods: Python provides many built-in methods like append(), pop(), sort(), reverse(), etc., for efficient list manipulation.
Iterable: Lists are iterable, which means you can loop through them using for or other iteration tools.
Internally Implemented as Dynamic Arrays: Python lists are implemented using a dynamic array in memory, which grows automatically when needed.
3. Ways to Create Lists in Python:
Python provides multiple ways to create lists depending on the use case:
3.1 Using Square Brackets :
numbers = [1, 2, 3, 4]
mixed = [10, "Python", 3.14, True]
3.2 Using the list() Constructor:
Converts other iterables (like strings, tuples, sets) into a list.
from_string = list("hello") # ['h', 'e', 'l', 'l', 'o']
from_tuple = list((1, 2, 3)) # [1, 2, 3]
from_set = list({10, 20, 30}) # [10, 20, 30]
3.3 Using List Comprehension:
A concise way to generate lists using expressions and conditions.
squares = [x**2 for x in range(5)] # [0, 1, 4, 9, 16]
even = [x for x in range(10) if x % 2 == 0] # [0, 2, 4, 6, 8]
3.4 Using * Operator (Repetition):
Creates a list with repeated elements.
zeros = [0] * 5 # [0, 0, 0, 0, 0]
empty_strings = [""] * 3 # ['', '', '']
3.5 Using range() with list():
nums = list(range(5)) # [0, 1, 2, 3, 4]
3.6 Using a Loop:
Use this method When list logic is complex or not suitable for comprehension.
result = []
for i in range(5):
result.append(i * 2)
# [0, 2, 4, 6, 8]
4. Accessing List Elements:
Python lists allow accessing elements using indexing and slicing. Below are the different ways to access list elements:
4.1 Access by Index (Positive Indexing):
Index starts from 0 for the first element.
fruits = ['apple', 'banana', 'cherry']
print(fruits[0]) # 'apple'
print(fruits[2]) # 'cherry'
4.2 Access by Negative Indexing:
Negative indices access elements from the end of the list.
print(fruits[-1]) # 'cherry'
print(fruits[-2]) # 'banana'
4.3 Access Using a Loop:
To access all items one by one:
for fruit in fruits:
print(fruit)
If index is also needed:
for index, fruit in enumerate(fruits):
print(index, fruit)
4.4 Slicing a List:
Syntax: list[start:stop:step]
Creates a sublist without modifying the original list.
numbers = [0, 1, 2, 3, 4, 5, 6]
print(numbers[1:4]) # [1, 2, 3]
print(numbers[:3]) # [0, 1, 2]
print(numbers[::2]) # [0, 2, 4, 6]
print(numbers[::-1]) # [6, 5, 4, 3, 2, 1, 0] (reversed)
5. Adding Elements into Lists:
Python provides multiple ways to add elements to a list — either individually, at specific positions, or in bulk.
5.1 append() – Add Single Element at the End:
Adds a single item to the end of the list.
fruits = ['apple', 'banana']
fruits.append('cherry')
# ['apple', 'banana', 'cherry']
5.2 insert(index, element) – Add at Specific Position:
Inserts an element at a given index.
fruits.insert(1, 'kiwi')
# ['apple', 'kiwi', 'banana', 'cherry']
5.3 extend(iterable) – Add Multiple Elements:
Appends all elements from another iterable (like list, tuple, set).
fruits.extend(['dates', 'grapes'])
# ['apple', 'kiwi', 'banana', 'cherry', 'dates', 'grapes']
5.4 + Operator – Concatenate Lists:
Combines two or more lists into a new list.
more_fruits = fruits + ['orange', 'pear']
# ['apple', 'kiwi', 'banana', 'cherry', 'dates', 'grapes', 'orange', 'pear']
6. Updating Elements of a List:
Python lists are mutable, which means you can update the value of any element by assigning a new value to an existing index.
6.1 Update Single Element by Index:
fruits = ['apple', 'banana', 'cherry']
fruits[1] = 'kiwi'
# ['apple', 'kiwi', 'cherry']
6.2 Update Multiple Elements Using Slice Assignment:
nums = [10, 20, 30, 40, 50]
nums[1:4] = [21, 31, 41]
# [10, 21, 31, 41, 50]
Slice assignment must match the length or Python will adjust the list size accordingly.
6.3 Update All Elements Using a Loop or Comprehension:
Example: Add 1 to each number
nums = [1, 2, 3]
nums = [x + 1 for x in nums]
# [2, 3, 4]
6.4 Conditional Update Using Loop:
nums = [1, -2, 3, -4]
for i in range(len(nums)):
if nums[i] < 0:
nums[i] = 0
# [1, 0, 3, 0]
7. Removing Elements from a List:
Python provides several methods to remove elements from a list, depending on whether you know the value, index, or want to remove in bulk.
7.1 remove(value) – Remove by Value:
Removes the first occurrence of the specified value.
Raises ValueError if value not found.
fruits = ['apple', 'banana', 'apple']
fruits.remove('apple')
# ['banana', 'apple']
7.2 pop(index) – Remove by Index:
Removes and returns the element at the specified index.
If no index is given, removes the last item.
fruits = ['apple', 'banana', 'cherry']
fruits.pop(1) # Removes 'banana'
# ['apple', 'cherry']
7.3 del Statement – Remove by Index or Slice:
nums = [10, 20, 30, 40]
del nums[2] # Removes 30
del nums[0:2] # Removes first two elements
7.4 clear() – Remove All Elements:
nums = [1, 2, 3]
nums.clear()
# []
8. Iterating Over a List in Python:
Python offers multiple ways to iterate over a list depending on whether you need just the values, indexes, or both.
8.1 Simple for Loop (Most Common):
Use when you only need the elements:
fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
print(fruit)
8.2 Using range() with Index:
Use this when you also need the index (or want to modify elements by index):
for i in range(len(fruits)):
print(i, fruits[i])
8.3 Using enumerate() (Pythonic Way):
Use when you want both index and value:
for index, fruit in enumerate(fruits):
print(f"Index {index}: {fruit}")
8.4 Using while Loop:
Less common, but useful in certain scenarios like custom stepping or conditional iteration.
i = 0
while i < len(fruits):
print(fruits[i])
i += 1
8.5 Iterating Backwards:
Using reversed list or range:
for fruit in reversed(fruits):
print(fruit)
OR using index
for i in range(len(fruits) - 1, -1, -1):
print(fruits[i])
- Use enumerate() for clean, readable code when index is needed.
- Prefer simple for loops when only values are needed.
- Avoid modifying lists while iterating directly — use comprehension or .copy() instead.
9. Sort / Reverse the List:
Python provides in-built ways to sort and reverse lists — both in-place and via returned copies — using list methods and functions.
9.1 sort() – Sort the List In-Place:
Modifies the original list.
Sorts in ascending order by default.
numbers = [4, 1, 3, 2]
numbers.sort()
# [1, 2, 3, 4]
Sort in Descending Order
numbers.sort(reverse=True)
# [4, 3, 2, 1]
Sort with key Parameter
Sort by custom logic (e.g., string length):
words = ['banana', 'fig', 'apple']
words.sort(key=len)
# ['fig', 'apple', 'banana']
9.2 sorted() – Return a Sorted Copy:
Does not modify the original list.
Returns a new sorted list.
numbers = [4, 2, 1]
sorted_list = sorted(numbers)
# [1, 2, 4]
# numbers remains [4, 2, 1]
9.3 reverse() – Reverse the List In-Place:
Reverses the elements without sorting.
nums = [1, 2, 3]
nums.reverse()
# [3, 2, 1]
9.4 Reverse Using Slicing (Creates Copy):
nums = [1, 2, 3]
reversed_copy = nums[::-1]
# [3, 2, 1]
10. Copying a List in Python:
Why We Need to Copy a List?
If you do:
original = [1, 2, 3]
copy = original
This does not create a new list. Instead, both variables point to the same list object in memory.
Any changes made to copy will also affect original — because they refer to the same object.
copy[0] = 99
print(original) # [99, 2, 3]
To avoid this, we must explicitly copy the list. Below are some correct Ways to Copy a List.
10.1 Using list() Constructor:
original = [1, 2, 3]
copy = list(original)
10.2 Using Slicing [:]:
copy = original[:]
10.3 Using .copy() Method (Python 3.3+):
copy = original.copy()
10.4 Using copy Module (for Deep Copies):
Use this when the list contains nested lists or mutable objects.
import copy
original = [[1, 2], [3, 4]]
shallow = original.copy()
deep = copy.deepcopy(original)
shallow[0][0] = 99
print(original) # [[99, 2], [3, 4]]
print(deep) # [[1, 2], [3, 4]] → unaffected
11. Other Useful List Methods: count(), index(), etc.:
Python lists come with some handy methods for querying and working with list contents. Here are a few lesser-known but important ones:
11.1 count(value) – Count Occurrences:
Returns the number of times a value appears in the list.
items = ['apple', 'banana', 'apple', 'cherry']
print(items.count('apple')) # 2
print(items.count('grape')) # 0
11.2 index(value, start, end) – Find First Occurrence:
Returns the index of the first occurrence of the given value.
Raises ValueError if not found.
Optional start and end allow searching within a sub-range.
nums = [10, 20, 30, 20, 40]
print(nums.index(20)) # 1
print(nums.index(20, 2)) # 3
11.3 len(list) – Get Length:
Returns the total number of elements in the list.
len(nums) # 5
(Note: This is a built-in function, not a list method.)
11.4 in Operator – Check Existence:
Returns True if the element exists in the list.
'apple' in items # True
'grape' in items # False
12. List Comprehension in Python:
List comprehension is a concise way to create lists using a single line of code. It's more readable and faster than using a loop in many cases.
12.1 Basic Syntax:
[expression for item in iterable if condition]
- expression: What to do with each item
- iterable: The source to loop over
- condition: (Optional) Filter items
12.2 Examples:
Create a List of Squares:
squares = [x**2 for x in range(5)]
# [0, 1, 4, 9, 16]
Filter Even Numbers:
evens = [x for x in range(10) if x % 2 == 0]
# [0, 2, 4, 6, 8]
Convert Strings to Uppercase:
words = ['apple', 'banana', 'cherry']
uppercased = [word.upper() for word in words]
# ['APPLE', 'BANANA', 'CHERRY']
Create a List of Tuples (with Conditions):
pairs = [(x, y) for x in range(3) for y in range(3) if x != y]
# [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
13. Unpacking the List in Python:
Unpacking means assigning elements of a list to multiple variables in a single line.
It’s a clean and Pythonic way to extract values when the structure and number of elements are known.
13.1 Basic Unpacking:
numbers = [10, 20, 30]
a, b, c = numbers
print(a) # 10
print(b) # 20
print(c) # 30
The number of variables on the left must match the number of elements in the list.
13.2 Using * to Unpack Remaining Elements:
Python allows collecting remaining values using *:
data = [1, 2, 3, 4, 5]
a, *b = data # a = 1, b = [2, 3, 4, 5]
*a, b = data # a = [1, 2, 3, 4], b = 5
a, *b, c = data # a = 1, b = [2, 3, 4], c = 5
This is useful when you need only specific parts of the list.
13.3 Use in Function Arguments (Argument Unpacking):
def add(x, y, z):
return x + y + z
values = [1, 2, 3]
result = add(*values) # Equivalent to add(1, 2, 3)
13.4 Swapping Variables Using Unpacking:
a, b = 5, 10
a, b = b, a
# a = 10, b = 5
Top comments (0)