NumPy provides methods `zeros`, `ones` and `full` for creating arrays containing 0s, 1s or a specified value, respectively. By default, `zeros` and `ones` create arrays containing float64 values. We’ll show how to customize the element type momentarily. The first argument to these functions must be an integer. For an integer, each function returns a one-dimensional array with the specified number of elements:

```import numpy as np

x = np.zeros(5) # x will store: [0.0, 0.0, 0.0, 0.0, 0.0]
```

#### Arrays from Integer Ranges:

NumPy provides optimized functions for creating arrays from ranges. We focus on simple evenly spaced integer and floating-point ranges, but NumPy also supports nonlinear ranges. Let’s use NumPy’s `arange` method to create integer ranges—similar to using built-in function range. In each case, `arange` first determines the resulting array’s number of elements, allocates the memory, then stores the specified range of values in the array:
```import numpy as np
y = np.arange(5) # [0, 1, 2, 3, 4, 5]
z = np.arange(5, 10) # [5, 6, 7, 8, 9]
a = np.arange(10, 1, -2) # [10, 8, 6, 4, 2]
```

#### Arrays from Float Ranges:

You can produce evenly spaced floating-point ranges with NumPy’s `linspace` method. The method’s first two arguments specify the starting and ending values in the range, and the ending value is included in the array. The optional keyword argument `num` specifies the number of evenly spaced values to produce (this argument’s default value is 50):
```import numpy as np
arr = np.linspace(0.0, 1.0, num = 5) # [0.0  ,  0.25,  0.5 ,  0.75,  1.0]
```

#### Reshaping Arrays:

You also can create an array from a range of elements, then use array method `reshape` to transform the one-dimensional array into a multidimensional array. Let’s create an array containing the values from 1 through 20, then reshape it into four rows by five columns:
```import numpy as np
arr1 = np.arange(1, 20)
arr1.reshape(4, 5)

"""
The array looks like this now:
[[1, 2, 3, 4, 5],
[6, 7, 8, 9, 10],
[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20]]
"""

# You can also chain method calls to accomplish the same thing:
arr2 = np.arange(1, 20).reshape(4, 5)
```

Note the chained method calls in the second part of the example above. First, `arange` produces an array containing the values 1–20. Then we call `reshape` on that array to get the 4-by-5 array that was displayed.

You can reshape any array, provided that the new shape has the same number of elements as the original. So a six-element one-dimensional array can become a 3-by-2 or 2- by-3 array, and vice versa, but attempting to reshape a 15-element array into a 4-by-4 array (16 elements) causes a ValueError.