The World of Python Programming

Python Array Initialization: List Comprehensions & NumPy

Data Types & Structures
目次

1. Basics of Initializing Arrays (Lists) in Python

Python lists (arrays) are flexible data structures that can store elements of different data types, and they are a fundamental building block in Python programming. In this article, we will explain how to initialize arrays (lists) in Python.

What is a Python list?

A list is a data structure used to group elements of various data types, such as numbers and strings, and serves as Python’s “array.” It can contain elements of different types, and you can freely add or remove elements after initialization.
example_list = [1, "Hello", True]
print(example_list)
# Output: [1, "Hello", True]

Initializing an Empty List

To create an empty list, use [] or list(). This method is ideal when you plan to add elements later or want to reserve a variable.
empty_list1 = []
empty_list2 = list()
print(empty_list1)  # Output: []
print(empty_list2)  # Output: []

Initializing a List with a Specific Number of Elements

In Python, you can easily create a list with a specific number of elements. For example, you can create a list initialized with five zeros as follows.
initial_list = [0] * 5
print(initial_list)  
# Output: [0, 0, 0, 0, 0]
This method is useful for creating a list filled with a uniform value.

Initializing a List Using the list Function

The list() function is useful for generating a list from other data types. For example, you can convert a string to a list or convert a tuple to a list.
char_list = list("Python")
tuple_list = list((1, 2, 3))
print(char_list)  
# Output: ['P', 'y', 't', 'h', 'o', 'n']
print(tuple_list)  
# Output: [1, 2, 3]

2. Initialize a List with List Comprehension

List comprehensions are a handy syntax that lets you write Python code concisely and efficiently. They’re especially useful for initializing lists based on conditions.

Basic List Comprehension

The example below initializes a list containing the integers from 0 to 9 using a list comprehension.
numbers = [i for i in range(10)]
print(numbers)  
# Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Conditional List Comprehension

You can also create a list with conditions. For example, you can write a list that extracts only even numbers as shown below.
even_numbers = [i for i in range(10) if i % 2 == 0]
print(even_numbers)  
# Output: [0, 2, 4, 6, 8]

3. Initializing a Two-Dimensional List

Python lists can represent multidimensional arrays by containing lists within lists. This allows you to work with data structures such as tables or matrices.

How to Initialize a Two-Dimensional List

Here’s an example of initializing a 3 × 3 two-dimensional list using a list comprehension. This approach ensures each sublist is independent, preventing unintended changes through shared references.
matrix = [[0 for _ in range(3)] for _ in range(3)]
print(matrix)  
# Output: [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

Caution: Reference Issues When Initializing a Two-Dimensional List

If you write it like [[0] * 3] * 3, each row references the same object, so a change in one place will be reflected in the other rows. Using a list comprehension generates each row as an independent list.

4. Array Operations: Adding Elements and Concatenation

Python lists can dynamically add or remove elements and merge with other lists even after initialization. This section explains the basic operations.

Adding Elements: append Method

Using append(), you can add an element to the end of a list.
my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  
# Output: [1, 2, 3, 4]

Inserting Elements: insert Method

insert() inserts an element at a specified position in the list. By specifying an index, you can insert at any location.
my_list = [1, 2, 3]
my_list.insert(1, 'new')
print(my_list)  
# Output: [1, 'new', 2, 3]

List Concatenation: + Operator

To concatenate multiple lists, use the + operator.
list1 = [1, 2, 3]
list2 = [4, 5]
combined_list = list1 + list2
print(combined_list)  
# Output: [1, 2, 3, 4, 5]

5. Other Initialization Methods: array Module and NumPy

Python includes a array module specialized for numerical computing and the NumPy library, allowing array initialization using data structures other than lists.

Initialization Using the array Module

Python’s array module can store arrays of the same data type efficiently, resulting in low memory usage.
import array
int_array = array.array('i', [0] * 5)
print(int_array)  
# Output: array('i', [0, 0, 0, 0, 0])

Initializing Multidimensional Arrays with NumPy

With the NumPy library, you can efficiently handle large multidimensional arrays, and it is frequently used in scientific computing and data analysis.
import numpy as np
numpy_array = np.zeros((3, 3))
print(numpy_array)
# Output:
# [[0. 0. 0.]
#  [0. 0. 0.]
#  [0. 0. 0.]]
NumPy arrays are highly computationally efficient and are better suited for large-scale data processing compared to Python’s built-in lists.

6. Comparison of Array Initialization Methods in Python

In this article, we comprehensively explain how to initialize lists and arrays in Python. By understanding the advantages of each initialization method and choosing the best one for your use case, you can write more efficient code.
  • Creating an empty list: Simple initialization with [] and list().
  • List comprehensions: Easily create a list of elements based on conditions.
  • Multidimensional lists: Represented as lists of lists, with important considerations.
  • Adding and concatenating elements: Flexibly manipulate using the append(), insert(), and + operators.
  • array and NumPy: Data structures suited for numeric types and multidimensional data processing.
By understanding the characteristics of each method and library and using them at the right time, you can master Python list initialization.