In Python, there are multiple ways to create lists, depending on the use case. Below are the most common methods:
1. Direct Initialization (Using Square Brackets [])
The simplest way to create a list is by enclosing elements in square brackets [].
Example:
python
empty_list = [] numbers = [1, 2, 3, 4] mixed_list = [1, "hello", 3.14, [5, 6]]
2. Using the list() Constructor
The list() function can convert other iterables (like tuples, strings, sets, etc.) into a list.
Examples:
python
from_tuple = list((1, 2, 3)) # Output: [1, 2, 3]
from_string = list("hello") # Output: ['h', 'e', 'l', 'l', 'o']
from_range = list(range(5)) # Output: [0, 1, 2, 3, 4]
from_set = list({1, 2, 3}) # Output: [1, 2, 3]
3. List Comprehension (Compact & Efficient)
List comprehensions provide a concise way to create lists based on existing iterables.
Syntax:
python
new_list = [expression for item in iterable if condition]
Examples:
python
squares = [x ** 2 for x in range(5)] # [0, 1, 4, 9, 16] even_numbers = [x for x in range(10) if x % 2 == 0] # [0, 2, 4, 6, 8] nested_list = [[i, j] for i in range(2) for j in range(2)] # [[0,0], [0,1], [1,0], [1,1]]
4. Using * Operator (Repetition)
Creates a list by repeating elements a specified number of times.
Example:
python
repeated_list = [0] * 5 # [0, 0, 0, 0, 0] words = ["hello"] * 3 # ["hello", "hello", "hello"]
⚠ Caution: When used with mutable objects (like nested lists), all elements refer to the same object:
python
matrix = [[0] * 3] * 3 # [[0, 0, 0], [0, 0, 0], [0, 0, 0]] matrix[0][0] = 1 # [[1, 0, 0], [1, 0, 0], [1, 0, 0]] (all sublists change!)
✅ Better way (using list comprehension):
python
matrix = [[0] * 3 for _ in range(3)] # Correctly creates independent rows
5. Using append() or extend() (Dynamic Building)
Lists can be built incrementally using:
append()→ Adds a single element.extend()→ Adds multiple elements from an iterable.
Examples:
python
lst = [] lst.append(1) # [1] lst.extend([2, 3, 4]) # [1, 2, 3, 4] lst.append([5, 6]) # [1, 2, 3, 4, [5, 6]]
6. Using split() (From Strings)
The split() method breaks a string into a list based on a delimiter.
Example:
python
sentence = "Python is awesome"
words = sentence.split() # ['Python', 'is', 'awesome']
csv_data = "1,2,3,4"
numbers = csv_data.split(',') # ['1', '2', '3', '4']
7. Using map() (Apply Function to Elements)
Converts an iterable into a list after applying a function.
Example:
python
str_numbers = ["1", "2", "3"] int_numbers = list(map(int, str_numbers)) # [1, 2, 3]
8. Using copy() or Slicing (Clone a List)
Creates a shallow copy of an existing list.
Examples:
python
original = [1, 2, 3] copy1 = original.copy() # [1, 2, 3] copy2 = original[:] # [1, 2, 3] (slicing)
⚠ Note: For nested lists, use copy.deepcopy() to avoid shared references.
9. Using + Operator (Concatenation)
Combines two or more lists into a new one.
Example:
python
list1 = [1, 2] list2 = [3, 4] combined = list1 + list2 # [1, 2, 3, 4]
10. Using *args (Unpacking Iterables)
Unpacks elements from other iterables into a new list.
Example:
python
numbers = [*range(3), *[4, 5]] # [0, 1, 2, 4, 5]
Summary Table
| Method | Example | Use Case |
|---|---|---|
| Direct Initialization | [1, 2, 3] | Simple list creation |
list() Constructor | list("hello") | Convert iterables to lists |
| List Comprehension | [x**2 for x in range(5)] | Efficient transformations/filtering |
* Operator | [0] * 5 | Repeat elements |
append()/extend() | lst.append(1) | Dynamic list building |
split() | "a b c".split() | Convert strings to lists |
map() | list(map(int, ["1","2"])) | Apply a function to elements |
copy()/Slicing | new = old.copy() | Clone a list |
+ Operator | [1,2] + [3,4] | Concatenate lists |
Unpacking (*args) | [*[1,2], *[3,4]] | Merge iterables |