|
Getting your Trinity Audio player ready...
|
When working with data, mathematical operations, or machine learning, one of the most important things you’ll need to handle is — arrays.
NumPy makes creating and managing arrays extremely simple and efficient.
In this post, you’ll learn all the possible ways to create NumPy arrays — from scratch, from Python lists, using built-in functions, and even random number generators.
What is a NumPy Array?
A NumPy array is a grid of values (all of the same type) indexed by a tuple of nonnegative integers.
You can think of it as a container that holds numbers in rows and columns, just like a spreadsheet or a table.
NumPy arrays are stored in contiguous memory, making them much faster and more memory-efficient than Python lists.
How to Import NumPy
Before we start, make sure you have NumPy installed.
pip install numpy
Then, import it in your Python code:
import numpy as np
1. Creating Arrays from Python Lists or Tuples
The simplest way to create a NumPy array is by converting a Python list or tuple using the np.array() function.
import numpy as np
# 1D array
arr1 = np.array([1, 2, 3, 4, 5])
print("1D Array:", arr1)
# 2D array
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
print("\n2D Array:\n", arr2)
✅ Output:
1D Array: [1 2 3 4 5]
2D Array:
[[1 2 3]
[4 5 6]]
You can check its type and dimensions:
print(type(arr1)) # <class 'numpy.ndarray'>
print(arr2.ndim) # 2 (two-dimensional)
2. Using np.arange()
np.arange() is similar to Python’s built-in range() function — but it returns a NumPy array instead of a list.
arr = np.arange(0, 10, 2)
print(arr)
✅ Output:
[0 2 4 6 8]
Syntax:
np.arange(start, stop, step)
Example:
np.arange(5) # [0 1 2 3 4]
np.arange(3, 8) # [3 4 5 6 7]
np.arange(1, 10, 3) # [1 4 7]
Also Read: Introduction to NumPy
3. Using np.linspace()
np.linspace() creates an array of evenly spaced values between a start and stop value.
arr = np.linspace(0, 1, 5)
print(arr)
✅ Output:
[0. 0.25 0.5 0.75 1. ]
Syntax:
np.linspace(start, stop, num_of_values)
Example:
arr = np.linspace(10, 20, 4)
print(arr)
✅ Output:
[10. 13.3333 16.6667 20.]
👉 Use Case: Perfect for generating values for charts or simulations.
4. Using np.zeros() and np.ones()
These are used to create arrays filled entirely with 0s or 1s.
zeros_array = np.zeros((3, 4))
ones_array = np.ones((2, 3))
print("Zeros Array:\n", zeros_array)
print("\nOnes Array:\n", ones_array)
✅ Output:
Zeros Array:
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
Ones Array:
[[1. 1. 1.]
[1. 1. 1.]]
You can also specify the data type:
np.zeros((2,2), dtype=int)
np.ones((3,3), dtype=float)
5. Using np.full()
If you want an array filled with a specific constant, use np.full().
arr = np.full((2, 3), 7)
print(arr)
✅ Output:
[[7 7 7]
[7 7 7]]
6. Using np.eye() – Identity Matrix
np.eye() creates a square identity matrix, which has 1s on the diagonal and 0s elsewhere.
arr = np.eye(4)
print(arr)
✅ Output:
[[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]
[0. 0. 0. 1.]]
👉 Use Case: Very useful in linear algebra and matrix operations.
7. Creating Arrays with Random Values
NumPy’s random module allows you to generate arrays with random numbers.
from numpy import random
# Random integers between 1 and 10
arr1 = random.randint(1, 10, size=(2, 3))
# Random floats between 0 and 1
arr2 = random.rand(3, 3)
print("Random Integers:\n", arr1)
print("\nRandom Floats:\n", arr2)
✅ Output:
Random Integers:
[[5 2 8]
[1 7 9]]
Random Floats:
[[0.23 0.67 0.89]
[0.13 0.49 0.90]
[0.77 0.28 0.46]]
8. Using np.empty()
np.empty() creates an array without initializing entries (i.e., contains garbage values).
arr = np.empty((3, 3))
print(arr)
✅ Output:
[[1.39069238e-309 1.39069238e-309 1.39069238e-309]
[1.39069238e-309 1.39069238e-309 1.39069238e-309]
[1.39069238e-309 1.39069238e-309 1.39069238e-309]]
👉 Note: The values are random garbage from memory, so this is faster than zeros() or ones() — but should only be used when you’ll overwrite the array later.
9. Creating Arrays from Existing Data
You can create arrays by copying or referencing another array.
arr1 = np.array([1, 2, 3, 4, 5])
copy_arr = arr1.copy()
view_arr = arr1.view()
arr1[0] = 100
print("Original:", arr1)
print("Copy:", copy_arr)
print("View:", view_arr)
✅ Output:
Original: [100 2 3 4 5]
Copy: [1 2 3 4 5]
View: [100 2 3 4 5]
👉 copy() creates an independent array,
while view() shares the same data memory as the original.
10. Converting Python Range to NumPy Array
If you already have a Python range(), you can easily convert it.
arr = np.fromiter(range(5), dtype=int)
print(arr)
✅ Output:
[0 1 2 3 4]
11. Creating Arrays with Conditional Logic
Use list comprehension-like logic to create arrays dynamically.
arr = np.array([x**2 for x in range(1, 6)])
print(arr)
✅ Output:
[ 1 4 9 16 25]
12. Using np.fromfunction()
Creates an array by applying a function to each coordinate.
def formula(x, y):
return x + y
arr = np.fromfunction(formula, (3, 3), dtype=int)
print(arr)
✅ Output:
[[0 1 2]
[1 2 3]
[2 3 4]]
Real-Life Example: Generating Sensor Data
Let’s simulate data from a temperature sensor for 10 readings.
import numpy as np
# Simulate temperature readings (in Celsius)
temperatures = np.random.randint(25, 40, size=10)
print("Temperature Data:", temperatures)
# Calculate average temperature
avg_temp = np.mean(temperatures)
print("Average Temperature:", avg_temp)
✅ Output Example:
Temperature Data: [33 28 29 37 26 31 35 27 38 30]
Average Temperature: 31.4
Summary Table — NumPy Array Creation Functions
| Function | Description | Example |
|---|---|---|
np.array() | Create array from list/tuple | np.array([1,2,3]) |
np.arange() | Create array with range of values | np.arange(0,10,2) |
np.linspace() | Evenly spaced numbers | np.linspace(0,1,5) |
np.zeros() | All zeros | np.zeros((2,3)) |
np.ones() | All ones | np.ones((3,3)) |
np.full() | Fill with custom value | np.full((2,2), 7) |
np.eye() | Identity matrix | np.eye(3) |
np.empty() | Uninitialized array | np.empty((2,2)) |
np.random.randint() | Random integers | np.random.randint(1,100,(2,2)) |
np.fromfunction() | Build from function | np.fromfunction(lambda i,j:i+j,(3,3)) |
Final Thoughts
NumPy provides dozens of efficient ways to create and initialize arrays.
Whether you need arrays filled with zeros, random numbers, or based on mathematical functions — NumPy has a built-in function for it.
When you master array creation, you’ll find that the rest of data manipulation and analysis becomes much easier and faster.
This foundation is essential before moving on to more complex topics like Array Operations, Indexing, and Broadcasting, which we’ll cover next.