Absolutely. Below is a publication-ready, comprehensive blog post designed for beginners through advanced learners. I have structured it for students, engineering/MCA/BCA learners, and readers who want a strong foundation before moving into NumPy-based data science and machine learning. It also includes diagrams, examples, practical tips, and five progressively difficult self-try exercises.

Python NumPy Array Creation: A Complete & Comprehensive Guide

Habbit2Code – Online Coding Classes

NumPy is one of the most important Python libraries for numerical computing, data analysis, scientific computing, artificial intelligence, and machine learning.

At the heart of NumPy is the NumPy array, represented by ndarray.

Whether you are a beginner learning Python or an advanced learner preparing for Data Science, Machine Learning, or AI, understanding how to create NumPy arrays is essential.

In this comprehensive guide, we will learn:

What a NumPy array is
Why NumPy arrays are different from Python lists
Installing and importing NumPy
Creating arrays from Python lists
Creating 1-D, 2-D and multidimensional arrays
arange()
linspace()
zeros()
ones()
full()
eye()
identity()
diag()
Random array creation
Specifying data types using dtype
Creating empty arrays
Reshaping arrays
Important array properties
Common mistakes
Beginner-to-advanced examples
Five self-try exercises

1. What Is NumPy?

NumPy stands for Numerical Python.

It is a Python library designed primarily for efficient numerical and scientific computation.

Before using NumPy, we generally import it using:

import numpy as np

Here, np is the commonly used alias for NumPy.

Example:

import numpy as np

a = np.array([10, 20, 30, 40])

print(a)

Output:

[10 20 30 40]

2. What Is a NumPy Array?

A NumPy array is a data structure that stores elements in an organized structure.

For example:

1-D Array

+----+----+----+----+
| 10 | 20 | 30 | 40 |
+----+----+----+----+
   0    1    2    3

The elements have positions called indices.

Python indexing starts from 0.

Therefore:

a = np.array([10, 20, 30, 40])

print(a[0])
print(a[2])

Output:

10
30

3. NumPy Array Dimensions

NumPy arrays can have different dimensions.

1-D Array

A one-dimensional array looks like a single row:

[10 20 30 40]

Example:

a = np.array([10, 20, 30, 40])

2-D Array

A two-dimensional array contains rows and columns.

        Columns
       0   1   2
     +---+---+---+
Row 0|10 |20 |30 |
     +---+---+---+
Row 1|40 |50 |60 |
     +---+---+---+

Example:

a = np.array([
    [10, 20, 30],
    [40, 50, 60]
])

Its shape is:

2 rows × 3 columns

3-D Array

A three-dimensional array can be visualized as multiple 2-D matrices.

        3-D Array
             |
      +------+------+
      |             |
   Matrix 1       Matrix 2
   [1 2 3]        [7 8 9]
   [4 5 6]        [10 11 12]

Example:

a = np.array([
    [
        [1, 2, 3],
        [4, 5, 6]
    ],
    [
        [7, 8, 9],
        [10, 11, 12]
    ]
])

4. Installing NumPy

If NumPy is not installed, use:

pip install numpy

For a specific Python environment, you may also use:

python -m pip install numpy

Then:

import numpy as np

5. Creating a NumPy Array Using `np.array()`

The simplest way to create an array is using:

np.array()

Example 1: Creating a 1-D array

import numpy as np

a = np.array([10, 20, 30, 40])

print(a)

Output:

[10 20 30 40]

6. Creating a 2-D Array

A list of lists can be converted into a 2-D NumPy array.

import numpy as np

a = np.array([
    [10, 20, 30],
    [40, 50, 60]
])

print(a)

Output:

[[10 20 30]
 [40 50 60]]

Conceptually:

             Columns
          0    1    2
       +----+----+----+
   0   | 10 | 20 | 30 |
       +----+----+----+
   1   | 40 | 50 | 60 |
       +----+----+----+
        Rows

7. Creating a 3-D Array

Example:

import numpy as np

a = np.array([
    [
        [1, 2, 3],
        [4, 5, 6]
    ],
    [
        [7, 8, 9],
        [10, 11, 12]
    ]
])

print(a)

You can check its dimension:

print(a.ndim)

Output:

8. Checking the Dimension Using `ndim`

The ndim attribute tells us the number of dimensions.

a = np.array([10, 20, 30])

print(a.ndim)

Output:

For a 2-D array:

a = np.array([
    [1, 2],
    [3, 4]
])

print(a.ndim)

Output:

9. Checking the Shape Using `shape`

The shape attribute tells us the size of each dimension.

Example:

a = np.array([
    [10, 20, 30],
    [40, 50, 60]
])

print(a.shape)

Output:

(2, 3)

This means:

2 rows
3 columns

Diagram:

       3 columns
   +----+----+----+
   | 10 | 20 | 30 |
   +----+----+----+
   | 40 | 50 | 60 |
   +----+----+----+
        2 rows

10. Checking the Number of Elements Using `size`

The size attribute returns the total number of elements.

a = np.array([
    [10, 20, 30],
    [40, 50, 60]
])

print(a.size)

Output:

Because:

2 × 3 = 6

11. Checking the Data Type Using `dtype`

Every NumPy array has a data type.

a = np.array([10, 20, 30])

print(a.dtype)

Depending on the NumPy/Python environment, you may see an integer dtype such as:

int64

or another integer type.

12. Creating an Array With a Specific Data Type

You can explicitly specify the type using dtype.

a = np.array([10, 20, 30], dtype=float)

print(a)

Output:

[10. 20. 30.]

Another example:

a = np.array([10.5, 20.8, 30.2], dtype=int)

print(a)

Output:

[10 20 30]

Be careful: converting floating-point values to integers removes the fractional part.

13. Creating an Array Using `np.arange()`

One of the most useful array creation functions is:

np.arange()

It works similarly to Python's range() but returns a NumPy array.

Syntax:

np.arange(start, stop, step)

The stop value is generally excluded.

Example:

a = np.arange(1, 10)

print(a)

Output:

[1 2 3 4 5 6 7 8 9]

14. `arange()` With Start and Stop

a = np.arange(5, 11)

print(a)

Output:

[ 5  6  7  8  9 10]

15. `arange()` With Step

a = np.arange(2, 20, 2)

print(a)

Output:

[ 2  4  6  8 10 12 14 16 18]

Conceptually:

Start = 2
        ↓
2 → 4 → 6 → 8 → 10 → 12 → 14 → 16 → 18
                                      ↑
                              Step = 2

16. Using a Decimal Step With `arange()`

You can use a floating-point step:

a = np.arange(0, 1, 0.2)

print(a)

However, floating-point representation can sometimes produce values that are not exactly what you expect.

For generating a specified number of evenly spaced floating-point values, linspace() is often preferable.

17. Creating Arrays Using `np.linspace()`

np.linspace() creates evenly spaced values between two limits.

Syntax:

np.linspace(start, stop, num)

Example:

a = np.linspace(0, 10, 5)

print(a)

Output:

[ 0.   2.5  5.   7.5 10. ]

Notice the difference:

0 ---- 2.5 ---- 5 ---- 7.5 ---- 10
|                                      |
start                                  stop

Here, we requested exactly 5 values.

18. `arange()` vs `linspace()`

This is an important distinction.

Function	Main idea
`arange()`	Specify the step
`linspace()`	Specify the number of values

Example:

np.arange(0, 10, 2)

means:

Start at 0
Stop before 10
Move by 2

Whereas:

np.linspace(0, 10, 6)

means:

Generate exactly 6 evenly spaced values

19. Creating an Array of Zeros

Use:

np.zeros()

Example:

a = np.zeros(5)

print(a)

Output:

[0. 0. 0. 0. 0.]

20. Creating a 2-D Zero Array

a = np.zeros((3, 4))

print(a)

Conceptually:

+---+---+---+---+
| 0 | 0 | 0 | 0 |
+---+---+---+---+
| 0 | 0 | 0 | 0 |
+---+---+---+---+
| 0 | 0 | 0 | 0 |
+---+---+---+---+

Shape:

3 × 4

21. Creating an Array of Ones

Use:

np.ones()

Example:

a = np.ones(5)

print(a)

Output:

[1. 1. 1. 1. 1.]

For a 2-D array:

a = np.ones((2, 3))

print(a)

Output:

[[1. 1. 1.]
 [1. 1. 1.]]

22. Creating an Array Filled With a Specific Value Using `full()`

Sometimes we want every element to contain the same value.

Use:

np.full()

Example:

a = np.full(5, 7)

print(a)

Output:

[7 7 7 7 7]

For a matrix:

a = np.full((3, 4), 25)

print(a)

Output:

[[25 25 25 25]
 [25 25 25 25]
 [25 25 25 25]]

23. Creating an Identity Matrix Using `np.eye()`

An identity-like matrix contains 1s along the main diagonal and 0s elsewhere.

a = np.eye(4)

print(a)

Output:

[[1. 0. 0. 0.]
 [0. 1. 0. 0.]
 [0. 0. 1. 0.]
 [0. 0. 0. 1.]]

Diagram:

1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
↑
Main diagonal

Identity matrices are important in linear algebra, machine learning, numerical methods, and matrix operations.

24. `np.identity()`

Another way of creating a square identity matrix is:

a = np.identity(3)

print(a)

Output:

[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

For a square matrix, np.identity(n) is specifically designed to create an n × n identity matrix.

25. Creating Diagonal Arrays Using `np.diag()`

np.diag() can create a matrix with specified diagonal values.

Example:

a = np.diag([10, 20, 30])

print(a)

Output:

[[10  0  0]
 [ 0 20  0]
 [ 0  0 30]]

Diagram:

10  0   0
 0  20  0
 0   0  30

26. Creating Random Arrays

Random arrays are heavily used in:

Machine Learning
Data Science
Simulations
Statistics
Testing
Numerical experiments

NumPy provides random-number generation functionality through np.random.

For example:

a = np.random.rand(5)

print(a)

This generates 5 random floating-point values in the range:

0 ≤ value < 1

27. Creating Random Integers

Use:

np.random.randint()

Example:

a = np.random.randint(1, 101, size=10)

print(a)

This generates 10 random integers from 1 through 100.

Example output:

[12 87 34 56 91 23 76 45 10 68]

The exact output changes because the values are random.

28. Creating a Random 2-D Array

a = np.random.randint(1, 10, size=(3, 4))

print(a)

Possible output:

[[3 7 1 8]
 [5 2 9 4]
 [6 8 3 1]]

Here:

Minimum = 1
Maximum possible value = 9
Shape = 3 × 4

29. Reproducible Random Arrays

Random values can be made reproducible using a seed.

Modern NumPy code can use:

rng = np.random.default_rng(42)

a = rng.integers(1, 101, size=5)

print(a)

Using the same seed allows you to reproduce the same sequence of generated values.

This is particularly useful in:

Machine learning experiments
Testing
Debugging
Educational demonstrations

30. Creating an Empty Array

NumPy provides:

np.empty()

Example:

a = np.empty(5)

print(a)

Important:

np.empty() does not initialize the array elements to zero.

The values are whatever happens to be present in the allocated memory.

Therefore, do not use empty() when you require initialized zeros.

If you need zeros, use:

np.zeros()

31. `zeros()` vs `empty()`

Function	Initializes values?	Typical purpose
`np.zeros()`	Yes, to 0	Known zero initialization
`np.ones()`	Yes, to 1	Known one initialization
`np.full()`	Yes, to specified value	Constant initialization
`np.empty()`	No	Allocation when you intend to fill values yourself

32. Creating Arrays With Different Data Types

NumPy supports many numerical data types.

Examples include:

int
float
bool
complex

Example:

a = np.array([1, 2, 3], dtype=np.float64)

print(a)
print(a.dtype)

Example output:

[1. 2. 3.]
float64

Boolean array:

a = np.array([True, False, True])

print(a)

33. Complex Number Arrays

NumPy also supports complex numbers.

a = np.array([1+2j, 3+4j])

print(a)

Output:

[1.+2.j 3.+4.j]

This is useful in scientific and engineering applications.

34. Creating Arrays From Tuples

NumPy arrays can also be created from tuples.

a = np.array((10, 20, 30, 40))

print(a)

Output:

[10 20 30 40]

35. Creating an Array From a Python Range

You can combine Python's range() with np.array():

a = np.array(range(1, 6))

print(a)

Output:

[1 2 3 4 5]

However, for directly creating numerical sequences, np.arange() is generally more natural.

36. Reshaping an Array

Array creation becomes even more powerful when combined with reshape().

Example:

a = np.arange(1, 13)

print(a)

Output:

[ 1  2  3  4  5  6  7  8  9 10 11 12]

Now reshape it:

b = a.reshape(3, 4)

print(b)

Output:

[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]

Diagram:

1-D

1  2  3  4  5  6  7  8  9  10  11  12
                |
                | reshape(3,4)
                ↓

2-D

1   2   3   4
5   6   7   8
9  10  11  12

37. Important Rule When Using `reshape()`

The total number of elements must remain the same.

For example:

12 elements

can be reshaped into:

3 × 4 = 12
2 × 6 = 12
4 × 3 = 12
1 × 12 = 12

But not:

5 × 3 = 15

because 15 ≠ 12.

Example:

a = np.arange(1, 13)

b = a.reshape(3, 4)

Correct.

But:

b = a.reshape(5, 3)

raises an error because the element count does not match.

38. Using `-1` With `reshape()`

NumPy can automatically determine one dimension.

Example:

a = np.arange(1, 13)

b = a.reshape(3, -1)

print(b)

NumPy determines that:

12 ÷ 3 = 4

Therefore the resulting shape is:

3 × 4

Another example:

b = a.reshape(-1, 4)

NumPy determines:

12 ÷ 4 = 3

Result:

3 × 4

39. A Complete Array-Creation Cheat Sheet

Method	Purpose	Example
`np.array()`	Create from existing data	`np.array([1,2,3])`
`np.arange()`	Create sequence using step	`np.arange(1,10,2)`
`np.linspace()`	Create evenly spaced values	`np.linspace(0,10,5)`
`np.zeros()`	Array filled with zeros	`np.zeros((3,3))`
`np.ones()`	Array filled with ones	`np.ones((2,4))`
`np.full()`	Array filled with a value	`np.full((2,3),7)`
`np.eye()`	Diagonal ones	`np.eye(4)`
`np.identity()`	Square identity matrix	`np.identity(3)`
`np.diag()`	Diagonal values	`np.diag([1,2,3])`
`np.empty()`	Uninitialized array	`np.empty((2,3))`
`np.random.rand()`	Random floats	`np.random.rand(5)`
`np.random.randint()`	Random integers	`np.random.randint(1,10,5)`

40. Understanding the Array-Creation Decision Process

When creating a NumPy array, ask yourself:

                 What data do I need?
                        |
          +-------------+-------------+
          |             |             |
     Existing data   Sequence     Constant values
          |             |             |
     np.array()     +----+----+      +---+---+
                    |         |      |   |   |
                arange()  linspace() zeros ones
                                      |
                                    full()

For random data:

                Need random values?
                       |
              +--------+--------+
              |                 |
          Random floats     Random integers
              |                 |
        np.random.rand()   np.random.randint()

41. Practical Example: Student Marks

Suppose we have marks of five students:

import numpy as np

marks = np.array([78, 85, 92, 67, 88])

print("Marks:", marks)
print("Average:", np.mean(marks))
print("Highest:", np.max(marks))
print("Lowest:", np.min(marks))

NumPy makes numerical operations concise and efficient.

42. Practical Example: Creating a Matrix

Suppose an application requires a 4 × 4 matrix initially filled with zeros.

matrix = np.zeros((4, 4))

print(matrix)

Later, values can be assigned.

matrix[0, 0] = 10
matrix[1, 1] = 20
matrix[2, 2] = 30
matrix[3, 3] = 40

print(matrix)

Result:

10  0  0  0
 0 20  0  0
 0  0 30  0
 0  0  0 40

43. Practical Example: Creating Data for Machine Learning

Suppose we need 100 observations with 4 features.

A random integer matrix can be created using:

rng = np.random.default_rng(42)

X = rng.integers(0, 100, size=(100, 4))

print(X.shape)

Output:

(100, 4)

This means:

100 observations
       ×
4 features

Conceptually:

          Feature 1 Feature 2 Feature 3 Feature 4
Sample 1      25       67       12       88
Sample 2      43       21       76       34
Sample 3      91       54       28       61
  ...
Sample 100    17       83       45       72

This kind of structure is commonly encountered in data science and machine learning.

44. Common Mistakes Beginners Make

Mistake 1: Forgetting to import NumPy

Incorrect:

a = np.array([1, 2, 3])

Correct:

import numpy as np

a = np.array([1, 2, 3])

Mistake 2: Confusing `arange()` and `linspace()`

Remember:

arange()   → control the step
linspace() → control the number of values

Mistake 3: Forgetting that `stop` is normally excluded in `arange()`

np.arange(1, 5)

produces:

1 2 3 4

not:

1 2 3 4 5

Mistake 4: Incorrect reshape dimensions

If an array has 12 elements:

a = np.arange(12)

then:

a.reshape(3, 4)

works.

But:

a.reshape(5, 3)

does not.

Mistake 5: Assuming `np.empty()` creates zeros

It does not.

Use:

np.zeros()

when you need zero-initialized values.

45. Beginner → Intermediate → Advanced Learning Path

Beginner Level

Start with:

np.array()
np.zeros()
np.ones()
np.full()

Then learn:

ndim
shape
size
dtype
indexing

Intermediate Level

Move to:

np.arange()
np.linspace()
np.eye()
np.identity()
np.diag()
reshape()

Then practice:

2-D arrays
3-D arrays
array slicing
mathematical operations

Advanced Level

Explore:

np.random
dtype management
broadcasting
vectorization
memory layout
views vs copies
structured arrays
advanced indexing

These concepts become particularly important when NumPy is used with:

Pandas
Matplotlib
Scikit-learn
SciPy
TensorFlow
PyTorch

46. Key Takeaways

After completing this tutorial, you should be able to explain and use the major NumPy array-creation techniques.

Remember these core functions:

np.array()
np.arange()
np.linspace()
np.zeros()
np.ones()
np.full()
np.eye()
np.identity()
np.diag()
np.empty()
np.random

And remember these important array properties:

array.ndim
array.shape
array.size
array.dtype

The most important distinction to remember is:

np.arange()     → sequence based on step
np.linspace()   → sequence based on number of values

np.zeros()      → fill with 0
np.ones()       → fill with 1
np.full()       → fill with chosen value

np.eye()        → diagonal 1s
np.diag()       → specified diagonal values

np.array()      → convert existing data into an array

47. Self-Try Exercises

Exercise 1 – Beginner

Create a NumPy array containing the first 10 natural numbers.

Then display:

The array
Number of dimensions
Shape
Number of elements
Data type

Hint:

np.arange()

Exercise 2 – Beginner to Intermediate

Create a 4 × 5 NumPy array containing only the value 25.

Then:

Display the array.
Display its shape.
Change the element at row 2, column 3 to 100.
Display the modified array.

Hint:

np.full()

Remember that NumPy indexing starts from 0.

Exercise 3 – Intermediate

Create the following matrix using NumPy:

1   2   3   4
5   6   7   8
9  10  11  12

Do not manually type the entire matrix.

Instead:

Create a sequence from 1 to 12.
Reshape it into a 3 × 4 matrix.
Display its shape, size, and ndim.

Challenge:

Try solving it using only:

np.arange()
reshape()

Exercise 4 – Intermediate to Advanced

Generate 20 evenly spaced values between 0 and 100.

Then find:

The array
Number of elements
Difference between consecutive values
Mean of the generated values
Maximum value
Minimum value

Use:

np.linspace()

Do not use np.arange().

Exercise 5 – Advanced Challenge

Create a dataset containing:

100 students
5 subjects

Each mark should be a random integer between 0 and 100.

Your program should:

Generate a 100 × 5 NumPy array.
Use a reproducible random generator.
Display the shape.
Calculate the average mark of each student.
Calculate the average mark of each subject.
Find the student with the highest overall average.
Find the subject with the highest average.
Display the highest and lowest marks in the complete dataset.

Hint:

Start with:

rng = np.random.default_rng(42)

Then think about how NumPy's axis parameter can help you calculate row-wise and column-wise averages.

48. Final Challenge for Students

Without looking at the examples above, write a program that creates:

A 5 × 5 matrix

with:

Try to solve it using:

np.diag()

Then create the same matrix using another NumPy approach.

This exercise will help you understand how different NumPy array-creation techniques can solve the same problem.

Conclusion

NumPy arrays are the foundation of numerical computing in Python.

Learning only how to write:

np.array([1, 2, 3])

is not enough. A strong NumPy programmer should understand how to efficiently generate sequences, matrices, constant arrays, identity matrices, random datasets, and multidimensional structures.

The progression is:

Python Lists
     ↓
np.array()
     ↓
Array Dimensions
     ↓
shape / size / ndim / dtype
     ↓
arange() / linspace()
     ↓
zeros() / ones() / full()
     ↓
eye() / identity() / diag()
     ↓
Random Arrays
     ↓
reshape()
     ↓
Indexing & Slicing
     ↓
Vectorization & Broadcasting
     ↓
Data Science / Machine Learning

Once these fundamentals are clear, you have a strong foundation for learning NumPy operations, Pandas, Data Analysis, Machine Learning, and Artificial Intelligence with Python.

PYTHON - Numpy Part 1The Complete Guide to NumPy Array Creation

Python NumPy Array Creation: A Complete & Comprehensive Guide

1. What Is NumPy?

2. What Is a NumPy Array?

3. NumPy Array Dimensions

1-D Array

2-D Array

3-D Array

4. Installing NumPy

5. Creating a NumPy Array Using np.array()

Example 1: Creating a 1-D array

6. Creating a 2-D Array

7. Creating a 3-D Array

8. Checking the Dimension Using ndim

9. Checking the Shape Using shape

10. Checking the Number of Elements Using size

11. Checking the Data Type Using dtype

12. Creating an Array With a Specific Data Type

13. Creating an Array Using np.arange()

14. arange() With Start and Stop

15. arange() With Step

16. Using a Decimal Step With arange()

17. Creating Arrays Using np.linspace()

18. arange() vs linspace()

19. Creating an Array of Zeros

20. Creating a 2-D Zero Array

21. Creating an Array of Ones

22. Creating an Array Filled With a Specific Value Using full()

23. Creating an Identity Matrix Using np.eye()

24. np.identity()

25. Creating Diagonal Arrays Using np.diag()

26. Creating Random Arrays

27. Creating Random Integers

28. Creating a Random 2-D Array

29. Reproducible Random Arrays

30. Creating an Empty Array

31. zeros() vs empty()

32. Creating Arrays With Different Data Types

33. Complex Number Arrays

34. Creating Arrays From Tuples

35. Creating an Array From a Python Range

36. Reshaping an Array

37. Important Rule When Using reshape()

38. Using -1 With reshape()

39. A Complete Array-Creation Cheat Sheet

40. Understanding the Array-Creation Decision Process

41. Practical Example: Student Marks

42. Practical Example: Creating a Matrix

43. Practical Example: Creating Data for Machine Learning

44. Common Mistakes Beginners Make

Mistake 1: Forgetting to import NumPy

Mistake 2: Confusing arange() and linspace()

Mistake 3: Forgetting that stop is normally excluded in arange()

Mistake 4: Incorrect reshape dimensions

Mistake 5: Assuming np.empty() creates zeros

45. Beginner → Intermediate → Advanced Learning Path

Beginner Level

Intermediate Level

Advanced Level

46. Key Takeaways

47. Self-Try Exercises

Exercise 1 – Beginner

Exercise 2 – Beginner to Intermediate

Exercise 3 – Intermediate

Exercise 4 – Intermediate to Advanced

Exercise 5 – Advanced Challenge

48. Final Challenge for Students

Conclusion

Comments

Post a Comment

5. Creating a NumPy Array Using `np.array()`

8. Checking the Dimension Using `ndim`

9. Checking the Shape Using `shape`

10. Checking the Number of Elements Using `size`

11. Checking the Data Type Using `dtype`

13. Creating an Array Using `np.arange()`

14. `arange()` With Start and Stop

15. `arange()` With Step

16. Using a Decimal Step With `arange()`

17. Creating Arrays Using `np.linspace()`

18. `arange()` vs `linspace()`

22. Creating an Array Filled With a Specific Value Using `full()`

23. Creating an Identity Matrix Using `np.eye()`

24. `np.identity()`

25. Creating Diagonal Arrays Using `np.diag()`

31. `zeros()` vs `empty()`

37. Important Rule When Using `reshape()`

38. Using `-1` With `reshape()`

Mistake 2: Confusing `arange()` and `linspace()`

Mistake 3: Forgetting that `stop` is normally excluded in `arange()`

Mistake 5: Assuming `np.empty()` creates zeros