numpy
April 19, 2025
[1]: import numpy
[2]: import xyz
---------------------------------------------------------------------------
ModuleNotFoundError Traceback (most recent call last)
Cell In[2], line 1
----> 1 import xyz
ModuleNotFoundError: No module named 'xyz'
[ ]: ModuleNotFoundError:
1. Spelling
2. Case sensitive
3. Install this module
[ ]: 1. Go to website pypi
2. Search for numpy
3. Find the code pip install numpy
4. Use ! before the command and install in your code
[4]: !pip install numpy
Requirement already satisfied: numpy in c:\users\admin\anaconda3\lib\site-
packages (1.26.4)
[ ]: # ! opens terminal( heart of your code ) from there it executes
[ ]: to pass parameters to a function we use: ()
list : []
numpy.array() # we should pass a parameter called list/tuple
[5]: import numpy
[6]: ar1 = numpy.array([1,2,3,4,5])
ar1
1
[6]: array([1, 2, 3, 4, 5])
[7]: list1 = [1,2,3,4,5]
[i**2 for i in list1]
[7]: [1, 4, 9, 16, 25]
[8]: ar1 ** 2
[8]: array([ 1, 4, 9, 16, 25])
[ ]:
[9]: import numpy as np
ar1 = np.array([1,2,3,4,5])
[12]: ar1 **3
[12]: array([ 1, 8, 27, 64, 125], dtype=int32)
[ ]: int32/64: integer
float32/64: float
[11]: ar1.dtype # data type
# array 1 has integers --> int32
[11]: dtype('int32')
[13]: np.zeros([3,2]) # shape : [3,2] --> 3 rows and 2 columns
# creates an array filled with zeros
# 0. --> 0
[13]: array([[0., 0.],
[0., 0.],
[0., 0.]])
[15]: help(np.zeros)
Help on built-in function zeros in module numpy:
zeros(…)
zeros(shape, dtype=float, order='C', *, like=None)
Return a new array of given shape and type, filled with zeros.
Parameters
----------
shape : int or tuple of ints
2
Shape of the new array, e.g., ``(2, 3)`` or ``2``.
dtype : data-type, optional
The desired data-type for the array, e.g., `numpy.int8`. Default is
`numpy.float64`.
order : {'C', 'F'}, optional, default: 'C'
Whether to store multi-dimensional data in row-major
(C-style) or column-major (Fortran-style) order in
memory.
like : array_like, optional
Reference object to allow the creation of arrays which are not
NumPy arrays. If an array-like passed in as ``like`` supports
the ``__array_function__`` protocol, the result will be defined
by it. In this case, it ensures the creation of an array object
compatible with that passed in via this argument.
.. versionadded:: 1.20.0
Returns
-------
out : ndarray
Array of zeros with the given shape, dtype, and order.
See Also
--------
zeros_like : Return an array of zeros with shape and type of input.
empty : Return a new uninitialized array.
ones : Return a new array setting values to one.
full : Return a new array of given shape filled with value.
Examples
--------
>>> np.zeros(5)
array([ 0., 0., 0., 0., 0.])
>>> np.zeros((5,), dtype=int)
array([0, 0, 0, 0, 0])
>>> np.zeros((2, 1))
array([[ 0.],
[ 0.]])
>>> s = (2,2)
>>> np.zeros(s)
array([[ 0., 0.],
[ 0., 0.]])
>>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
array([(0, 0), (0, 0)],
3
dtype=[('x', '<i4'), ('y', '<i4')])
[26]: np.zeros([3,2])
[26]: array([[0., 0.],
[0., 0.],
[0., 0.]])
[25]: np.random.random([3,2]) # shape --> [3,2] --> 3 rows and 2 columns
# creates a random array with values from 0 to 1
[25]: array([[0.65644003, 0.74442908],
[0.54061825, 0.61104814],
[0.51349282, 0.24717018]])
[ ]:
Array Initialization
[28]: np.full([3,2], 10) # 2 parameters --> shape , value
# create an array with 3,2 and fill the entire array with value 10
[28]: array([[10, 10],
[10, 10],
[10, 10]])
[29]: list(range(1,5))
[29]: [1, 2, 3, 4]
[30]: list(range(1,10,2))
[30]: [1, 3, 5, 7, 9]
[31]: np.arange(1,10,2) # start , end-1, step
# array + range --> output will be in array
[31]: array([1, 3, 5, 7, 9])
[37]: help(np.linspace)
Help on _ArrayFunctionDispatcher in module numpy:
linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)
Return evenly spaced numbers over a specified interval.
Returns `num` evenly spaced samples, calculated over the
4
interval [`start`, `stop`].
The endpoint of the interval can optionally be excluded.
.. versionchanged:: 1.16.0
Non-scalar `start` and `stop` are now supported.
.. versionchanged:: 1.20.0
Values are rounded towards ``-inf`` instead of ``0`` when an
integer ``dtype`` is specified. The old behavior can
still be obtained with ``np.linspace(start, stop, num).astype(int)``
Parameters
----------
start : array_like
The starting value of the sequence.
stop : array_like
The end value of the sequence, unless `endpoint` is set to False.
In that case, the sequence consists of all but the last of ``num + 1``
evenly spaced samples, so that `stop` is excluded. Note that the step
size changes when `endpoint` is False.
num : int, optional
Number of samples to generate. Default is 50. Must be non-negative.
endpoint : bool, optional
If True, `stop` is the last sample. Otherwise, it is not included.
Default is True.
retstep : bool, optional
If True, return (`samples`, `step`), where `step` is the spacing
between samples.
dtype : dtype, optional
The type of the output array. If `dtype` is not given, the data type
is inferred from `start` and `stop`. The inferred dtype will never be
an integer; `float` is chosen even if the arguments would produce an
array of integers.
.. versionadded:: 1.9.0
axis : int, optional
The axis in the result to store the samples. Relevant only if start
or stop are array-like. By default (0), the samples will be along a
new axis inserted at the beginning. Use -1 to get an axis at the end.
.. versionadded:: 1.16.0
Returns
-------
samples : ndarray
There are `num` equally spaced samples in the closed interval
5
``[start, stop]`` or the half-open interval ``[start, stop)``
(depending on whether `endpoint` is True or False).
step : float, optional
Only returned if `retstep` is True
Size of spacing between samples.
See Also
--------
arange : Similar to `linspace`, but uses a step size (instead of the
number of samples).
geomspace : Similar to `linspace`, but with numbers spaced evenly on a log
scale (a geometric progression).
logspace : Similar to `geomspace`, but with the end points specified as
logarithms.
:ref:`how-to-partition`
Examples
--------
>>> np.linspace(2.0, 3.0, num=5)
array([2. , 2.25, 2.5 , 2.75, 3. ])
>>> np.linspace(2.0, 3.0, num=5, endpoint=False)
array([2. , 2.2, 2.4, 2.6, 2.8])
>>> np.linspace(2.0, 3.0, num=5, retstep=True)
(array([2. , 2.25, 2.5 , 2.75, 3. ]), 0.25)
Graphical illustration:
>>> import matplotlib.pyplot as plt
>>> N = 8
>>> y = np.zeros(N)
>>> x1 = np.linspace(0, 10, N, endpoint=True)
>>> x2 = np.linspace(0, 10, N, endpoint=False)
>>> plt.plot(x1, y, 'o')
[<matplotlib.lines.Line2D object at 0x…>]
>>> plt.plot(x2, y + 0.5, 'o')
[<matplotlib.lines.Line2D object at 0x…>]
>>> plt.ylim([-0.5, 1])
(-0.5, 1)
>>> plt.show()
[34]: np.linspace(1,20,11) # start , end , no.of digits
# Generate 11 numbers between 1 to 20 with equal interval( difference )
[34]: array([ 1. , 2.9, 4.8, 6.7, 8.6, 10.5, 12.4, 14.3, 16.2, 18.1, 20. ])
6
[35]: 2.9-1
[35]: 1.9
[36]: 14.3 - 12.4
[36]: 1.9000000000000004
[ ]:
[ ]:
[ ]:
[ ]:
[ ]:
