The World of Python Programming

How to Get List Length in Python: From Basics to NumPy

Data Types & Structures
目次

1. Introduction

Python is a programming language supported by developers worldwide thanks to its simple and easy-to-understand syntax. Among its features, the way to manipulate arrays (lists) is an essential skill for data processing. In particular, the method for obtaining a list’s “number of elements (element count)” is fundamental for handling data correctly and writing efficient programs. In this article, we explain how to get the number of elements in a Python list. We cover everything from basic list definitions and element count retrieval to advanced operations using multidimensional lists and the NumPy library. By doing so, you’ll gain confidence in list manipulation and be able to use it smoothly in real development and data analysis.

2. What Are Python Arrays (Lists)

Basic Definition and Characteristics of Lists

In Python, the data structure often referred to as an “array” is typically used as a “list.” A list is a data structure that stores a collection of items in order, and it can hold any data type—numbers, strings, even other lists—providing great flexibility. Additionally, lists are mutable, meaning you can easily add, remove, or modify elements, which is a major advantage.
# Example of defining a list
my_list = [10, "Python", 3.14, True]
In the example above, integers, strings, floating‑point numbers, and boolean values are stored in the same list. This allows you to handle multiple types of data together in a single list.

Uses and Application Scenarios for Lists

Lists are used in a variety of situations, such as:
  • Data Management: Temporary storage of user input data or data read from files
  • Data Manipulation: Storing multiple calculation results or filtered data
  • Loop Processing: Performing operations on each element during iteration
Lists are often used together with other data structures (such as dictionaries or tuples) and are a fundamental building block in Python programs.

3. How to Get the Number of Elements in a List

In Python, you use the built‑in function len() to get the number of elements in a list. This function returns the length of the list—that is, the number of items—making it the simplest and most intuitive way to obtain an array’s element count.

How to Use the len() Function

The len() function can be used not only with lists but also with strings, tuples, dictionaries, and other sequence types. To get a list’s element count, simply pass the list name to the function and the result is returned.
# Get the number of elements in a list
my_list = [1, 2, 3, 4, 5]
print(len(my_list))  # Output: 5
In the example above, the list my_list contains five elements, and len(my_list) returns the count, which is “5”.

4. Getting the Number of Elements in a Multidimensional List

What Is a Multidimensional List

A multidimensional list is a structure where lists are stored inside other lists. This is extremely useful when representing matrix or tabular data. In particular, a two‑dimensional list organizes data in rows and columns, making it easier to work with.
# Example of a 2D list
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
In the example above, the list matrix is a 3‑by‑3 two‑dimensional list, with elements arranged like rows and columns.

How to Get the Number of Elements in a Multidimensional List

When getting the number of elements in a multidimensional list, you use the len() function for each level. First, you obtain the number of elements in the outer list (rows) and then you can get the number of elements in each inner list (columns).
# Get number of rows
print(len(matrix))  # Output: 3

# Get number of columns (number of elements in the first row)
print(len(matrix[0]))  # Output: 3
In this code, the number of rows of matrix is obtained with len(matrix), and the number of columns is obtained with len(matrix[0]). This kind of multidimensional list structure lets you organize and work with complex data sets.

5. Getting the Number of Elements in a NumPy Array

What is NumPy

NumPy (pronounced “Num-pie”) is a Python library for numerical computing that provides powerful features, especially for array manipulation. NumPy arrays (ndarray) are more memory‑efficient than lists and offer faster numerical operations, making them widely used in scientific computing, data analysis, and machine learning.

How to Install NumPy

To use NumPy, install it with the following command.
pip install numpy

How to Get the Number of Elements in a NumPy Array

To obtain the number of elements in a NumPy array, use the size attribute or the shape attribute.
  • size: returns the total number of elements in the array
  • shape: returns the size of each dimension as a tuple
import numpy as np

# Define a NumPy array
array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Get the total number of elements in the array
print(array.size)  # Output: 9

# Get the shape of the array
print(array.shape)  # Output: (3, 3)
In the example above, array.size returns the total number of elements, “9”, and array.shape returns the shape of the 3‑by‑3 array (3, 3). This makes it easy to check a NumPy array’s shape and element count, enabling efficient data manipulation.

6. Example Applications of Counting Elements

Looping Using the List’s Element Count

You can perform loop processing using the list’s element count. for statements and while statements can specify the list’s element count, allowing you to use the len() function when accessing each element in the list.
# Define the list
fruits = ["apple", "banana", "cherry"]

# Loop using indices
for i in range(len(fruits)):
    print(f"Fruit #{i + 1} is {fruits[i]}")
This code outputs each element in the list in order. By using len(fruits), the loop runs for the number of elements in the list, so it can flexibly handle additions or removals of elements.

Utilizing in Conditional Branching

You can also perform conditional branching using the list’s element count. For example, it is useful for determining whether a list is empty and handling the situation accordingly.
# Define the list
items = []

# Check if the list is empty
if len(items) == 0:
    print("The list is empty")
else:
    print("The list has elements")
In this way, you can perform dynamic processing based on the list’s state, making the program more flexible.

7. Summary

In this article, we covered how to obtain the number of elements in a Python list, ranging from basics to advanced topics.len() We introduced the basic method using functions, how to get element counts for multidimensional lists and NumPy arrays, and also demonstrated loop constructs and conditional branching that leverage list lengths. List manipulation is a fundamental skill in Python programming and is useful across various fields such as data processing, app development, and data analysis. By trying the methods introduced here in practice and further mastering list manipulation, you’ll be able to write more efficient and readable code. We hope this helps you gain confidence in Python list operations and further enhance your applied skills.