Python Arrays in Python

A list stores references to objects. Each number in a list is a full Python object with its own type information, and the list can mix types freely: [12, "offline", 14.5, None].

An array.array stores raw numeric values of a single type, packed side by side, like an array in C. That uses much less memory for large amounts of numbers, typically a quarter to an eighth of the list's size, and it guarantees every element has the same type.

A NumPy ndarray also stores packed values of one type, but adds multiple dimensions (rows and columns), and vectorised operations that apply arithmetic to every element at once in fast compiled code.

The word "array" means different things in different contexts. In tutorials for other languages it means a fixed-size typed block; in JavaScript it means something like a Python list; in data science it nearly always means a NumPy array. Check which one a piece of documentation is talking about.

When you create an array.array, the first argument is a type code, a single character that fixes the element type:

from array import array
levels = array("d", [1.82, 1.79, 1.95])
print(levels.typecode, levels.itemsize)   # d 8

Sizes for some codes depend on the platform and compiler, which is why itemsize exists. Values must fit the type: array("B", [300]) raises OverflowError because an unsigned byte holds 0 to 255. Use "d" for decimals unless memory is very tight, since "f" loses precision.

Arrays support the operations you know from lists: indexing, slicing, len(), in, iteration, append(), extend(), insert(), pop(), remove(), index() and count(). Built-ins such as sum(), min(), max() and sorted() also work.

from array import array
readings = array("i", [12, 15, 11])
readings.append(14)
print(readings[1:3])        # array('i', [15, 11])
print(max(readings))        # 15
readings.append("high")     # TypeError: 'str' object cannot be interpreted as an integer

The type is enforced on every insertion, which catches bad data early. Arrays also offer conversions that lists don't: tobytes(), frombytes(), tofile() and fromfile() read and write raw binary data efficiently, and tolist() turns the array back into a list. Arrays don't have a sort() method; use sorted(), which returns a list.

For calculations, NumPy is the standard choice. It's a separate package (pip install numpy) and its arrays support arithmetic on every element at once:

import numpy as np
levels = np.array([1.82, 1.79, 1.95])
print(levels * 100)           # [182. 179. 195.]
print(levels.mean().round(2)) # 1.85

With a list, * means repetition, not multiplication: [1, 2] * 3 is [1, 2, 1, 2, 1, 2]. To scale every value in a list you need a loop or comprehension, [x * 100 for x in levels], while NumPy does it in one fast operation.

A simple rule for choosing: use a list for general collections and mixed data; use array.array when you hold many numbers of one type, want low memory use, and don't need maths on the whole collection; use NumPy for numerical work, matrices and anything heading towards data analysis.

Task: store compatible measurements in an array and explain when a list or NumPy array is preferable. Create a "d" array of water levels, add a reading, and print the average.

from array import array

levels = array("d", [1.82, 1.79, 1.95])
levels.append(1.88)
average = sum(levels) / len(levels)
print(f"{len(levels)} readings, average {average:.2f} m")   # 4 readings, average 1.86 m

A list would be better if some readings were text such as "offline"; NumPy would be better if you needed to convert every level to centimetres or calculate statistics over thousands of values. For the worked check, the values allowed in an array.array are restricted by its selected type code.

The array module documentation lists every type code and method, and the NumPy quickstart introduces ndarrays. Continue with collection methods and the NumPy lesson. Practise with the Python exercises and Python quiz.