Num Py

In [2]: import numpy as np
Create a numpy array

In [2]: np.array([10,20,30,40])
Out[2]: array([10, 20, 30, 40])
In [3]: a = np.array([10,20,30,40])
a.ndim #check dimension of array
Out[3]: 1
In [6]: # what is the type of numpy array

type(a)
Out[6]: numpy.ndarray
In [4]: np.array([[1,2,3],[4,5,6]])
Out[4]: array([[1, 2, 3],

[4, 5, 6]])
In [5]: np.array([[1,2,3],[4,5,6]]).ndim
Out[5]: 2
In [7]: np.array([[[1,2],[3,4]],[[6,7],[8,9]]])
Out[7]: array([[[1, 2],

[3, 4]],
[[6, 7],
[8, 9]]])
In [8]: np.array([[[1,2],[3,4]],[[6,7],[8,9]]]).ndim
Out[8]: 3
Check some properties of an array`

In [9]: ar = np.array([[[1,2],[3,4]],[[6,7],[8,9]]])
ar
Out[9]: array([[[1, 2],

[3, 4]],
[[6, 7],
[8, 9]]])
Heading
In [26]: # check dim
ar.ndim
Out[26]: 3
In [22]: # check total blocks , rows and colums

ar.shape #(2: blocks, 2:rows, 2:columns)
Out[22]: (2, 2, 2)
In [27]: # if i want to check total number of elements

ar.size
Out[27]: 8
In [44]: len(ar)
Out[44]: 2
In [47]: d = np.array([[1,2]])
d
Out[47]: array([[1, 2]])
In [50]: d.shape
Out[50]: (1, 2)
In [51]: len(d)
Out[51]: 1
In [52]: len(d.ravel())
Out[52]: 2
In [30]: #how much bytes alocated to each element

ar.itemsize
Out[30]: 4
In [31]: # check memory address in hex

ar.data
Out[31]: <memory at 0x000002A97A1EE6D0>
In [32]: ar
Out[32]: array([[[1, 2],

[3, 4]],
[[6, 7],
[8, 9]]])
In [33]: print(ar)
[[[1 2]
[3 4]]
[[6 7]
[8 9]]]
In [38]: a = 10
b = 20
print(a)
b
10
Out[38]: 20
Creation of numpy array using numpy functions

In [54]: # array of all 0's
np.zeros(10)
Out[54]: array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
In [55]: # 2D array of 0's

np.zeros((3,3))
Out[55]: array([[0., 0., 0.],

[0., 0., 0.],
[0., 0., 0.]])
In [57]: #lets change dtype

np.zeros((3,3),dtype=int)
Out[57]: dtype('int32')
In [58]: np.zeros((3,3),dtype='int64')
Out[58]: array([[0, 0, 0],

[0, 0, 0],
[0, 0, 0]], dtype=int64)
In [68]: np.zeros((3,3),dtype=np.int32)
Out[68]: array([[0, 0, 0],

[0, 0, 0],
[0, 0, 0]])
In [64]: #check the difference between them

x = np.zeros((3,3),dtype=int)
y = np.zeros((3,3),dtype='int8')
In [60]: x.itemsize
Out[60]: 4
In [61]: x.__sizeof__()
Out[61]: 156
In [65]: y.itemsize
Out[65]: 1
In [66]: y.__sizeof__()
Out[66]: 129
In [69]: # 32 bit consumes more memory than 8 bits
In [70]: # if i want array with all 1's

np.ones(20)
Out[70]: array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1.])
In [71]: np.ones((4,3))
Out[71]: array([[1., 1., 1.],

[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])
In [74]: # if i want array with specified value

np.full(4,fill_value=99)
Out[74]: array([99, 99, 99, 99])
In [75]: np.full((3,3,3),fill_value=99)
Out[75]: array([[[99, 99, 99],

[99, 99, 99],
[99, 99, 99]],
[[99, 99, 99],

[99, 99, 99],
[99, 99, 99]],
[[99, 99, 99],

[99, 99, 99],
[99, 99, 99]]])
In [85]: np.full((3,3,3),fill_value='NA')
# when we have hetro. data or str data its dtype is 'U' unicode
Out[85]: array([[['NA', 'NA', 'NA'],

['NA', 'NA', 'NA'],
['NA', 'NA', 'NA']],
[['NA', 'NA', 'NA'],

['NA', 'NA', 'NA'],
['NA', 'NA', 'NA']],
[['NA', 'NA', 'NA'],

['NA', 'NA', 'NA'],
['NA', 'NA', 'NA']]], dtype='<U2')
arange()
In [77]: # it is same as that of range in python
np.arange(11)
Out[77]: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
In [78]: # start and stop

np.arange(101,111)
Out[78]: array([101, 102, 103, 104, 105, 106, 107, 108, 109, 110])
In [79]: # start and stop , step

np.arange(1,100,2)# odd numbers
Out[79]: array([ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33,
35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67,
69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99])
In [80]: # array with -ve steping

np.arange(110,100,-1)
Out[80]: array([110, 109, 108, 107, 106, 105, 104, 103, 102, 101])
In [82]: #we can use -ve values as well

np.arange(-10,1)
Out[82]: array([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0])
In [83]: # create an array with values -10 to +10

np.arange(-10,11)
Out[83]: array([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2,
3, 4, 5, 6, 7, 8, 9, 10])
In [87]: help(np)
Help on package numpy:
NAME
numpy
DESCRIPTION
NumPy
=====
Provides
1. An array object of arbitrary homogeneous items
2. Fast mathematical operations over arrays
3. Linear Algebra, Fourier Transforms, Random Number Generation
How to use the documentation

----------------------------
Documentation is available in two forms: docstrings provided
with the code, and a loose standing reference guide, available from
`the NumPy homepage <https://www.scipy.org>`_.
In [88]: # if we want information about numpy and its functions
help(np.arange)
Help on built-in function arange in module numpy:
arange(...)
arange([start,] stop[, step,], dtype=None, *, like=None)
Return evenly spaced values within a given interval.
Values are generated within the half-open interval ``[start, stop)``

(in other words, the interval including `start` but excluding `stop`).
For integer arguments the function is equivalent to the Python built-in
`range` function, but returns an ndarray rather than a list.
When using a non-integer step, such as 0.1, the results will often not
be consistent. It is better to use `numpy.linspace` for these cases.
Parameters
----------
start : integer or real, optional
Start of interval. The interval includes this value. The default
start value is 0.
stop : integer or real
End of interval. The interval does not include this value, except
in some cases where `step` is not an integer and floating point
round-off affects the length of òut`.
step : integer or real, optional
Spacing between values. For any output òut`, this is the distance
between two adjacent values, `òut[i+1] - out[i]``. The default
step size is 1. If `step` is specified as a position argument,
`start` must also be given.
dtype : dtype
The type of the output array. If `dtype` is not given, infer the data
type from the other input arguments.
like : array_like
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.
.. note::
The ``like`` keyword is an experimental feature pending on
acceptance of :ref:`NEP 35 <NEP35>`.
.. versionadded:: 1.20.0
Returns
-------
arange : ndarray
Array of evenly spaced values.
For floating point arguments, the length of the result is

``ceil((stop - start)/step)``. Because of floating point overflow,
this rule may result in the last element of òut` being greater
than `stop`.
See Also
--------
numpy.linspace : Evenly spaced numbers with careful handling of endpoints.
numpy.ogrid: Arrays of evenly spaced numbers in N-dimensions.
numpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.
Examples
--------
>>> np.arange(3)
array([0, 1, 2])
>>> np.arange(3.0)
array([ 0., 1., 2.])
>>> np.arange(3,7)
array([3, 4, 5, 6])
>>> np.arange(3,7,2)
array([3, 5])
In [90]: np.info(np.arange)

Parameters
----------
start value is 0.
dtype : dtype
like : array_like
.. note::
Returns
-------
arange : ndarray

than `stop`.
See Also
--------
Examples
--------
>>> np.arange(3)
array([0, 1, 2])
>>> np.arange(3.0)
array([ 0., 1., 2.])
>>> np.arange(3,7)
array([3, 4, 5, 6])
array([3, 5])
In [92]: np.arange?
In [ ]: #or use shift + tab
np.linspace
In [ ]: # used to generate linearly spaced values
# with homogeneous spacing
# equal spacing btween 2 consecutive elements
In [94]: '''
start,
stop,
num=50,
endpoint=True,
retstep=False,
dtype=None,
axis=0,
'''
np.linspace(2,11) #default 50 values it will generate
Out[94]: array([ 2. , 2.18367347, 2.36734694, 2.55102041, 2.73469388,

2.91836735, 3.10204082, 3.28571429, 3.46938776, 3.65306122,
3.83673469, 4.02040816, 4.20408163, 4.3877551 , 4.57142857,
4.75510204, 4.93877551, 5.12244898, 5.30612245, 5.48979592,
5.67346939, 5.85714286, 6.04081633, 6.2244898 , 6.40816327,
6.59183673, 6.7755102 , 6.95918367, 7.14285714, 7.32653061,
7.51020408, 7.69387755, 7.87755102, 8.06122449, 8.24489796,
8.42857143, 8.6122449 , 8.79591837, 8.97959184, 9.16326531,
9.34693878, 9.53061224, 9.71428571, 9.89795918, 10.08163265,
10.26530612, 10.44897959, 10.63265306, 10.81632653, 11. ])
In [95]: np.linspace(2,11,num=20)
Out[95]: array([ 2. , 2.47368421, 2.94736842, 3.42105263, 3.89473684,

4.36842105, 4.84210526, 5.31578947, 5.78947368, 6.26315789,
6.73684211, 7.21052632, 7.68421053, 8.15789474, 8.63157895,
9.10526316, 9.57894737, 10.05263158, 10.52631579, 11. ])
In [98]: 2 - 2.47368421
Out[98]: -0.47368421000000005
In [97]: 2.47368421- 2.94736842 #difference value is constant
Out[97]: -0.47368421000000005
In [99]: #u want to check difference

np.linspace(2,11,num=20,retstep=True)
Out[99]: (array([ 2. , 2.47368421, 2.94736842, 3.42105263, 3.89473684,

4.36842105, 4.84210526, 5.31578947, 5.78947368, 6.26315789,
6.73684211, 7.21052632, 7.68421053, 8.15789474, 8.63157895,
9.10526316, 9.57894737, 10.05263158, 10.52631579, 11. ]),
0.47368421052631576)
In [100]: np.linspace(2,11,num=20,retstep=True,endpoint = False) #stop will be exclusive
Out[100]: (array([ 2. , 2.45, 2.9 , 3.35, 3.8 , 4.25, 4.7 , 5.15, 5.6 ,
6.05, 6.5 , 6.95, 7.4 , 7.85, 8.3 , 8.75, 9.2 , 9.65,
10.1 , 10.55]),
0.45)
In [101]: # -10 to +10

np.linspace(-10,10,num = 21)
Out[101]: array([-10., -9., -8., -7., -6., -5., -4., -3., -2., -1., 0.,
1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
In [103]: np.linspace(-10,11,num = 21,endpoint=False)
Out[103]: array([-10., -9., -8., -7., -6., -5., -4., -3., -2., -1., 0.,
1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
In [3]: np.linspace(-10,11,num = 21)
Out[3]: array([-10. , -8.95, -7.9 , -6.85, -5.8 , -4.75, -3.7 , -2.65,

-1.6 , -0.55, 0.5 , 1.55, 2.6 , 3.65, 4.7 , 5.75,
6.8 , 7.85, 8.9 , 9.95, 11. ])
In [4]: np.linspace(-10,11,num = 21).ndim
Out[4]: 1
In [5]: np.linspace(-10,11,num = 21).shape
Out[5]: (21,)
In [6]: type(np.linspace(-10,11,num = 21))
In [7]: np.arange(1,100,2)
Out[7]: array([ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33,
35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67,
69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99])
In [8]: np.arange(2,100,2)
Out[8]: array([ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34,
36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68,
70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98])
In [9]: np.arange(-10,11)
Out[9]: array([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2,
3, 4, 5, 6, 7, 8, 9, 10])
In [ ]:
Create a numpy array

In [2]: np.array([10,20,30,40])
Out[2]: array([10, 20, 30, 40])
In [3]: a = np.array([10,20,30,40])
a.ndim #check dimension of array
Out[3]: 1
In [6]: # what is the type of numpy array

type(a)
In [4]: np.array([[1,2,3],[4,5,6]])
Out[4]: array([[1, 2, 3],

[4, 5, 6]])
In [5]: np.array([[1,2,3],[4,5,6]]).ndim
Out[5]: 2
In [7]: np.array([[[1,2],[3,4]],[[6,7],[8,9]]])
Out[7]: array([[[1, 2],

[3, 4]],
[[6, 7],
[8, 9]]])
In [8]: np.array([[[1,2],[3,4]],[[6,7],[8,9]]]).ndim
Out[8]: 3
Check some properties of an array`

In [9]: ar = np.array([[[1,2],[3,4]],[[6,7],[8,9]]])
ar
Out[9]: array([[[1, 2],

[3, 4]],
[[6, 7],
[8, 9]]])
Heading
In [26]: # check dim
ar.ndim
Out[26]: 3
In [22]: # check total blocks , rows and colums

ar.shape #(2: blocks, 2:rows, 2:columns)
Out[22]: (2, 2, 2)
In [27]: # if i want to check total number of elements

ar.size
Out[27]: 8
In [44]: len(ar)
Out[44]: 2
In [47]: d = np.array([[1,2]])
d
Out[47]: array([[1, 2]])
In [50]: d.shape
Out[50]: (1, 2)
In [51]: len(d)
Out[51]: 1
In [52]: len(d.ravel())
Out[52]: 2
In [30]: #how much bytes alocated to each element

ar.itemsize
Out[30]: 4
In [31]: # check memory address in hex

ar.data
Out[31]: <memory at 0x000002A97A1EE6D0>
In [32]: ar
Out[32]: array([[[1, 2],

[3, 4]],
[[6, 7],
[8, 9]]])
In [33]: print(ar)
[[[1 2]
[3 4]]
[[6 7]
[8 9]]]
In [38]: a = 10
b = 20
print(a)
b
10
Out[38]: 20
Creation of numpy array using numpy functions

In [54]: # array of all 0's
np.zeros(10)
Out[54]: array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
In [55]: # 2D array of 0's

np.zeros((3,3))
Out[55]: array([[0., 0., 0.],

[0., 0., 0.],
[0., 0., 0.]])
In [57]: #lets change dtype

np.zeros((3,3),dtype=int)
In [58]: np.zeros((3,3),dtype='int64')
Out[58]: array([[0, 0, 0],

[0, 0, 0],
[0, 0, 0]], dtype=int64)
In [68]: np.zeros((3,3),dtype=np.int32)
Out[68]: array([[0, 0, 0],

[0, 0, 0],
[0, 0, 0]])
In [64]: #check the difference between them

x = np.zeros((3,3),dtype=int)
y = np.zeros((3,3),dtype='int8')
In [60]: x.itemsize
Out[60]: 4
In [61]: x.__sizeof__()
Out[61]: 156
In [65]: y.itemsize
Out[65]: 1
In [66]: y.__sizeof__()
Out[66]: 129
In [69]: # 32 bit consumes more memory than 8 bits
In [70]: # if i want array with all 1's

np.ones(20)
Out[70]: array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1., 1.])
In [71]: np.ones((4,3))
Out[71]: array([[1., 1., 1.],

[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])
In [74]: # if i want array with specified value

np.full(4,fill_value=99)
Out[74]: array([99, 99, 99, 99])
In [75]: np.full((3,3,3),fill_value=99)
Out[75]: array([[[99, 99, 99],

[99, 99, 99],
[99, 99, 99]],
[[99, 99, 99],

[99, 99, 99],
[99, 99, 99]],
[[99, 99, 99],

[99, 99, 99],
[99, 99, 99]]])
In [85]: np.full((3,3,3),fill_value='NA')
# when we have hetro. data or str data its dtype is 'U' unicode
Out[85]: array([[['NA', 'NA', 'NA'],

['NA', 'NA', 'NA'],
['NA', 'NA', 'NA']],
[['NA', 'NA', 'NA'],

['NA', 'NA', 'NA'],
['NA', 'NA', 'NA']],
[['NA', 'NA', 'NA'],

['NA', 'NA', 'NA'],
['NA', 'NA', 'NA']]], dtype='<U2')
arange()
In [77]: # it is same as that of range in python
np.arange(11)
Out[77]: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
In [78]: # start and stop

np.arange(101,111)
Out[78]: array([101, 102, 103, 104, 105, 106, 107, 108, 109, 110])
In [79]: # start and stop , step

np.arange(1,100,2)# odd numbers
Out[79]: array([ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33,
35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67,
69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99])
In [80]: # array with -ve steping

np.arange(110,100,-1)
Out[80]: array([110, 109, 108, 107, 106, 105, 104, 103, 102, 101])
In [82]: #we can use -ve values as well

np.arange(-10,1)
Out[82]: array([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0])
In [83]: # create an array with values -10 to +10

np.arange(-10,11)
Out[83]: array([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2,
3, 4, 5, 6, 7, 8, 9, 10])
In [87]: help(np)
Help on package numpy:
NAME
numpy
DESCRIPTION
NumPy
=====
Provides
1. An array object of arbitrary homogeneous items
2. Fast mathematical operations over arrays
3. Linear Algebra, Fourier Transforms, Random Number Generation
How to use the documentation

----------------------------
Documentation is available in two forms: docstrings provided
with the code, and a loose standing reference guide, available from
`the NumPy homepage <https://www.scipy.org>`_.
In [88]: # if we want information about numpy and its functions
help(np.arange)
Help on built-in function arange in module numpy:
arange(...)

Parameters
----------
start value is 0.
dtype : dtype
like : array_like
.. note::
Returns
-------
arange : ndarray

than `stop`.
See Also
--------
Examples
--------
>>> np.arange(3)
array([0, 1, 2])
>>> np.arange(3.0)
array([ 0., 1., 2.])
>>> np.arange(3,7)
array([3, 4, 5, 6])
array([3, 5])
In [90]: np.info(np.arange)

Parameters
----------
start value is 0.
dtype : dtype
like : array_like
.. note::
Returns
-------
arange : ndarray

than `stop`.
See Also
--------
Examples
--------
>>> np.arange(3)
array([0, 1, 2])
>>> np.arange(3.0)
array([ 0., 1., 2.])
>>> np.arange(3,7)
array([3, 4, 5, 6])
array([3, 5])
In [92]: np.arange?
In [ ]: #or use shift + tab
np.linspace
In [ ]: # used to generate linearly spaced values
# with homogeneous spacing
# equal spacing btween 2 consecutive elements
In [94]: '''
start,
stop,
num=50,
endpoint=True,
retstep=False,
dtype=None,
axis=0,
'''
np.linspace(2,11) #default 50 values it will generate
Out[94]: array([ 2. , 2.18367347, 2.36734694, 2.55102041, 2.73469388,

2.91836735, 3.10204082, 3.28571429, 3.46938776, 3.65306122,
3.83673469, 4.02040816, 4.20408163, 4.3877551 , 4.57142857,
4.75510204, 4.93877551, 5.12244898, 5.30612245, 5.48979592,
5.67346939, 5.85714286, 6.04081633, 6.2244898 , 6.40816327,
6.59183673, 6.7755102 , 6.95918367, 7.14285714, 7.32653061,
7.51020408, 7.69387755, 7.87755102, 8.06122449, 8.24489796,
8.42857143, 8.6122449 , 8.79591837, 8.97959184, 9.16326531,
9.34693878, 9.53061224, 9.71428571, 9.89795918, 10.08163265,
10.26530612, 10.44897959, 10.63265306, 10.81632653, 11. ])
In [95]: np.linspace(2,11,num=20)
Out[95]: array([ 2. , 2.47368421, 2.94736842, 3.42105263, 3.89473684,

4.36842105, 4.84210526, 5.31578947, 5.78947368, 6.26315789,
6.73684211, 7.21052632, 7.68421053, 8.15789474, 8.63157895,
9.10526316, 9.57894737, 10.05263158, 10.52631579, 11. ])
In [98]: 2 - 2.47368421
Out[98]: -0.47368421000000005
In [97]: 2.47368421- 2.94736842 #difference value is constant
Out[97]: -0.47368421000000005
In [99]: #u want to check difference

np.linspace(2,11,num=20,retstep=True)
Out[99]: (array([ 2. , 2.47368421, 2.94736842, 3.42105263, 3.89473684,

4.36842105, 4.84210526, 5.31578947, 5.78947368, 6.26315789,
6.73684211, 7.21052632, 7.68421053, 8.15789474, 8.63157895,
9.10526316, 9.57894737, 10.05263158, 10.52631579, 11. ]),
0.47368421052631576)
In [100]: np.linspace(2,11,num=20,retstep=True,endpoint = False) #stop will be exclusive
Out[100]: (array([ 2. , 2.45, 2.9 , 3.35, 3.8 , 4.25, 4.7 , 5.15, 5.6 ,
6.05, 6.5 , 6.95, 7.4 , 7.85, 8.3 , 8.75, 9.2 , 9.65,
10.1 , 10.55]),
0.45)
In [101]: # -10 to +10

np.linspace(-10,10,num = 21)
Out[101]: array([-10., -9., -8., -7., -6., -5., -4., -3., -2., -1., 0.,
1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
In [103]: np.linspace(-10,11,num = 21,endpoint=False)
Out[103]: array([-10., -9., -8., -7., -6., -5., -4., -3., -2., -1., 0.,
1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
In [3]: np.linspace(-10,11,num = 21)
Out[3]: array([-10. , -8.95, -7.9 , -6.85, -5.8 , -4.75, -3.7 , -2.65,

-1.6 , -0.55, 0.5 , 1.55, 2.6 , 3.65, 4.7 , 5.75,
6.8 , 7.85, 8.9 , 9.95, 11. ])
In [4]: np.linspace(-10,11,num = 21).ndim
Out[4]: 1
In [5]: np.linspace(-10,11,num = 21).shape
Out[5]: (21,)
In [6]: type(np.linspace(-10,11,num = 21))
In [7]: np.arange(1,100,2)
Out[7]: array([ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33,
35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67,
69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99])
In [8]: np.arange(2,100,2)
Out[8]: array([ 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34,
36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68,
70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98])
In [9]: np.arange(-10,11)
Out[9]: array([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2,
3, 4, 5, 6, 7, 8, 9, 10])
In [ ]:
In [4]: # simplest way to change shape

a = np.arange(2,26)
a
Out[4]: array([ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25])
In [5]: a.shape
Out[5]: (24,)
In [6]: a.shape = (6,4) #inplace
In [7]: a
Out[7]: array([[ 2, 3, 4, 5],

[ 6, 7, 8, 9],
[10, 11, 12, 13],
[14, 15, 16, 17],
[18, 19, 20, 21],
[22, 23, 24, 25]])
Indexing and slicing

In [8]: a
Out[8]: array([[ 2, 3, 4, 5],

[ 6, 7, 8, 9],
[10, 11, 12, 13],
[14, 15, 16, 17],
[18, 19, 20, 21],
[22, 23, 24, 25]])
In [9]: # when ur array is 2D indexing work on rows default

a[0]
Out[9]: array([2, 3, 4, 5])
In [10]: a[-1]
Out[10]: array([22, 23, 24, 25])
In [11]: # i want to change value of an element from a row

# Example 25==> 50
a
Out[11]: array([[ 2, 3, 4, 5],

[ 6, 7, 8, 9],
[10, 11, 12, 13],
[14, 15, 16, 17],
[18, 19, 20, 21],
[22, 23, 24, 25]])
In [16]: #a[5] #access row first
#a[-1][3]
#a[-1][-1]
a[-1,-1]
Out[16]: 25
In [18]: # after accessing element the replace

a[-1,-1] = 50
In [19]: a
Out[19]: array([[ 2, 3, 4, 5],

[ 6, 7, 8, 9],
[10, 11, 12, 13],
[14, 15, 16, 17],
[18, 19, 20, 21],
[22, 23, 24, 50]])
In [20]: # replace elements of any row

# replace all elements by 20
a[3]
Out[20]: array([14, 15, 16, 17])
In [21]: a[3] = 20
In [22]: a
Out[22]: array([[ 2, 3, 4, 5],

[ 6, 7, 8, 9],
[10, 11, 12, 13],
[20, 20, 20, 20],
[18, 19, 20, 21],
[22, 23, 24, 50]])
In [23]: # revert this row of 20 into [1,2,3,4]

a[3]
Out[23]: array([20, 20, 20, 20])
In [24]: a[3] = [1,2,3,4]
In [25]: a
Out[25]: array([[ 2, 3, 4, 5],

[ 6, 7, 8, 9],
[10, 11, 12, 13],
[ 1, 2, 3, 4],
[18, 19, 20, 21],
[22, 23, 24, 50]])
In [26]: # if we try to convert/replace int by str

a[0,0]
Out[26]: 2
In [27]: a[0,0]= 'python'
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
~\AppData\Local\Temp/ipykernel_10588/740517320.py in <module>
----> 1 a[0,0]= 'python'
ValueError: invalid literal for int() with base 10: 'python'
In [28]: a.dtype # as dtype is int hence we are unable to replace int by str
Slicing
In [30]: a
Out[30]: array([[ 2, 3, 4, 5],

[ 6, 7, 8, 9],
[10, 11, 12, 13],
[ 1, 2, 3, 4],
[18, 19, 20, 21],
[22, 23, 24, 50]])
# if we want to work on row + columns as wel then use slicing

# when we want to access multiple elements then we have slicing
In [33]: # all rows and 1st 2 columns

a[:,:2]#[row,column]
Out[33]: array([[ 2, 3],

[ 6, 7],
[10, 11],
[ 1, 2],
[18, 19],
[22, 23]])
In [36]: # fetch last 2 columns with all rows

#a[:,2:]
a[:,-2:]
Out[36]: array([[ 4, 5],

[ 8, 9],
[12, 13],
[ 3, 4],
[20, 21],
[24, 50]])
In [39]: # reverse columns

a[:,::-1]
Out[39]: array([[ 5, 4, 3, 2],

[ 9, 8, 7, 6],
[13, 12, 11, 10],
[ 4, 3, 2, 1],
[21, 20, 19, 18],
[50, 24, 23, 22]])
In [42]: # select columns starting with 2 and 5
a[:,::3]
Out[42]: array([[ 2, 5],

[ 6, 9],
[10, 13],
[ 1, 4],
[18, 21],
[22, 50]])
Now if we want to work on rows and columns together
In [43]: a
Out[43]: array([[ 2, 3, 4, 5],

[ 6, 7, 8, 9],
[10, 11, 12, 13],
[ 1, 2, 3, 4],
[18, 19, 20, 21],
[22, 23, 24, 50]])
In [46]: # access 4,5 and 8,9

a[:2,2:]
Out[46]: array([[4, 5],

[8, 9]])
In [49]: """
[11, 12],
[2, 3],
[19, 20],
"""
a[2:-1,1:-1]
Out[49]: array([[11, 12],

[ 2, 3],
[19, 20]])
In [53]: """
[18, 19]
[22,23]
"""
a[4:,:2]
Out[53]: array([[18, 19],

[22, 23]])
In [58]: """
3, 4,
23,24
"""
a[::5,1:-1]
Out[58]: array([[ 3, 4],

[23, 24]])
In [60]: # access corner elements: 2,5,22,50
a[::5,::3]
Out[60]: array([[ 2, 5],

[22, 50]])
In [61]: a.shape
Out[61]: (6, 4)
In [64]: # now lets try to replace values of an array

# replace all corner elements by 0
a[::5,::3] = 0
In [65]: a
Out[65]: array([[ 0, 3, 4, 0],

[ 6, 7, 8, 9],
[10, 11, 12, 13],
[ 1, 2, 3, 4],
[18, 19, 20, 21],
[ 0, 23, 24, 0]])
In [68]: """
[11, 12, 13],
[2, 3, 4],
------------------
replace
[10,20,30]
[50,40,30]
"""
a[2:-2,1:]
Out[68]: array([[11, 12, 13],

[ 2, 3, 4]])
In [69]: a[2:-2,1:] = [[10,20,30],[50,40,30]]
In [70]: a
Out[70]: array([[ 0, 3, 4, 0],

[ 6, 7, 8, 9],
[10, 10, 20, 30],
[ 1, 50, 40, 30],
[18, 19, 20, 21],
[ 0, 23, 24, 0]])
In [72]: # 3,4,7,8 replace like 1,2,3,4 in anticlockwise direction

a[:2,1:-1]
Out[72]: array([[3, 4],

[7, 8]])
In [73]: a[:2,1:-1] = [[1, 4],[2, 3]]

In [74]: a
Out[74]: array([[ 0, 1, 4, 0],

[ 6, 2, 3, 9],
[10, 10, 20, 30],
[ 1, 50, 40, 30],
[18, 19, 20, 21],
[ 0, 23, 24, 0]])
Interview Questions
In [79]: # i want 5 x 5 array with all values set to True
np.ones((5,5),dtype='bool')
Out[79]: array([[ True, True, True, True, True],

[ True, True, True, True, True],
[ True, True, True, True, True]])
In [77]: int(True)
Out[77]: 1
In [78]: bool(1)
Out[78]: True
In [80]: np.full((5,5),'True')
Out[80]: array([['True', 'True', 'True', 'True', 'True'],

['True', 'True', 'True', 'True', 'True'],
['True', 'True', 'True', 'True', 'True']], dtype='<U4')
In [82]: # I want 4x4 array with all values False

np.zeros((4,4),dtype='bool')
Out[82]: array([[False, False, False, False],

[False, False, False, False],
[False, False, False, False]])
In [84]: np.full((4,4),0,dtype='bool')
Out[84]: array([[False, False, False, False],

[False, False, False, False]])
In [85]: bool(0)
Out[85]: False
In [86]: # i want array with 4x4 :Diagonal elements as True and non diagonal False
np.eye(4)
Out[86]: array([[1., 0., 0., 0.],

[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])
In [4]: a = np.eye(4,dtype='bool')
a
Out[4]: array([[ True, False, False, False],

[False, True, False, False],
[False, False, True, False],
[False, False, False, True]])
In [3]: np.identity(4,dtype='bool')

In [ ]: # I want diagnoal elements False and non diagonal True

In [5]: a.T

In [ ]:
In [2]: np.eye(4)
Out[2]: array([[1., 0., 0., 0.],

[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])
In [3]: np.eye(4,dtype='bool')

In [4]: ~ np.eye(4,dtype='bool')
Out[4]: array([[False, True, True, True],

[ True, False, True, True],
[ True, True, False, True],
[ True, True, True, False]])
Conversion
In [9]: np.arange(4)
Out[9]: array([0, 1, 2, 3])
In [10]: #if i want to change dtype to float

np.arange(4,dtype='float')
Out[10]: array([0., 1., 2., 3.])
In [11]: # after creation of an array if we wwant to convert its data type then??
# use astype() function
a = np.arange(4)
a
Out[11]: array([0, 1, 2, 3])
In [12]: a.dtype
In [14]: #lets convert dtype

b = a.astype('int64')
b
Out[14]: array([0, 1, 2, 3], dtype=int64)
In [15]: b.dtype
In [16]: # Convert numpy into a list
a
Out[16]: array([0, 1, 2, 3])
In [17]: list(a)
Out[17]: [0, 1, 2, 3]
In [18]: a.tolist()
Out[18]: [0, 1, 2, 3]
In [23]: # difference betwee list() and .to_list()

# suppose we have 2D list
c = np.arange(1,11).reshape(2,5)
c
Out[23]: array([[ 1, 2, 3, 4, 5],

[ 6, 7, 8, 9, 10]])
In [21]: #list
list(c)
Out[21]: [array([1, 2, 3, 4, 5]), array([ 6, 7, 8, 9, 10])]
In [25]: c.tolist()
Out[25]: [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]
In [ ]: #Assignment:Differnce between List, array(python), numpy array
Adding element/Removing element

In [26]: a
Out[26]: array([0, 1, 2, 3])
append()
In [27]: np.append(a,100)
Out[27]: array([ 0, 1, 2, 3, 100])
In [29]: np.append(a,[100,400])
Out[29]: array([ 0, 1, 2, 3, 100, 400])
In [34]: np.append(a,'python') # here U mean Unicode
Out[34]: array(['0', '1', '2', '3', 'python'], dtype='<U11')
In [31]: [1,2,3,'python']
Out[31]: [1, 2, 3, 'python']

In [40]: np.array(['a','b','cdyhy'])
Out[40]: array(['a', 'b', 'cdyhy'], dtype='<U5')
In [42]: # perform append on 2D

c
Out[42]: array([[ 1, 2, 3, 4, 5],

[ 6, 7, 8, 9, 10]])
In [43]: np.append(c,[11,12,13,14,15])# it should add one row

# bcz we have nt supplied axis value it converted array to 1D and added
# elements at the end
Out[43]: array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])
In [46]: # but i want to add a row

# add axis=0
np.append(c,[[11,12,13,14,15]],axis=0)
Out[46]: array([[ 1, 2, 3, 4, 5],

[ 6, 7, 8, 9, 10],
[11, 12, 13, 14, 15]])
In [50]: # add column

np.append(c,[[100,-1],[200,-2]],axis=1)
Out[50]: array([[ 1, 2, 3, 4, 5, 100, -1],

[ 6, 7, 8, 9, 10, 200, -2]])
Insert
In [51]: a
Out[51]: array([0, 1, 2, 3])
In [52]: # it is used to insert values in between array using index

# np.insert(arr, obj(index), values, axis=None)
np.insert(a,1,800)
Out[52]: array([ 0, 800, 1, 2, 3])
In [55]: np.insert(a,1,[800,500])
# when we r passing multiple values use [] () any of option
Out[55]: array([ 0, 800, 500, 1, 2, 3])
In [56]: #2D insert

c
Out[56]: array([[ 1, 2, 3, 4, 5],

[ 6, 7, 8, 9, 10]])
In [69]: np.insert(c,2,[10,20,30,40,50],axis=0)
Out[69]: array([[ 1, 2, 3, 4, 5],

[ 6, 7, 8, 9, 10],
[10, 20, 30, 40, 50]])
In [67]: np.insert(c,2,[10,20],axis=1)
Out[67]: array([[ 1, 2, 10, 3, 4, 5],

[ 6, 7, 20, 8, 9, 10]])
Delete()
In [70]: a
Out[70]: array([0, 1, 2, 3])
In [71]: #np.delete(arr, obj, axis=None)

np.delete(a,2)
Out[71]: array([0, 1, 3])
In [72]: #2D array

c
Out[72]: array([[ 1, 2, 3, 4, 5],

[ 6, 7, 8, 9, 10]])
In [73]: np.delete(c,-1,axis=0)
Out[73]: array([[1, 2, 3, 4, 5]])
In [75]: # column
np.delete(c,-1,axis=1)
Out[75]: array([[1, 2, 3, 4],

[6, 7, 8, 9]])
In [79]: # suppose i want to delete multiple columns

np.delete(c,np.s_[-2:],axis=1)
Out[79]: array([[1, 2, 3],

[6, 7, 8]])
In [81]: np.delete(c,[0,2,3,4],axis=1)
Out[81]: array([[2],
[7]])
In [82]: c
Out[82]: array([[ 1, 2, 3, 4, 5],

[ 6, 7, 8, 9, 10]])
In [83]: np.delete(c,0)
Out[83]: array([ 2, 3, 4, 5, 6, 7, 8, 9, 10])
In [84]: # i want to work on columns

np.delete(c,0,axis=1)
Out[84]: array([[ 2, 3, 4, 5],

[ 7, 8, 9, 10]])
In [85]: c
Out[85]: array([[ 1, 2, 3, 4, 5],

[ 6, 7, 8, 9, 10]])
In [86]: np.delete(c,0,axis=0)
Out[86]: array([[ 6, 7, 8, 9, 10]])
In [87]: nm = ['Nilima','Santosh','Pradip','Anu','Rushikesh','Amit']
nm
Out[87]: ['Nilima', 'Santosh', 'Pradip', 'Anu', 'Rushikesh', 'Amit']
In [88]: np.array(nm)
Out[88]: array(['Nilima', 'Santosh', 'Pradip', 'Anu', 'Rushikesh', 'Amit'],

dtype='<U9')
In [91]: data = np.array(nm).reshape(-1,1)

data
Out[91]: array([['Nilima'],
['Santosh'],
['Pradip'],
['Anu'],
['Rushikesh'],
['Amit']], dtype='<U9')
In [93]: import pandas as pd

pd.DataFrame(data).to_csv('batch_17.csv')
In [94]: pd.DataFrame(np.array(nm).reshape(1,-1))
Out[94]: 0 1 2 3 4 5
0 Nilima Santosh Pradip Anu Rushikesh Amit
In [98]: d = pd.DataFrame({'id':['KP123-445-678','KI34-456-678','KP123-445-677']})
d
Out[98]: id
0 KP123-445-678
1 KI34-456-678
2 KP123-445-677
In [103]: ex = d[d['id'].str.startswith('KP')]
ex
Out[103]: id
0 KP123-445-678
2 KP123-445-677
In [107]: ex['id'].str.split('-')
Out[107]: 0 [KP123, 445, 678]

2 [KP123, 445, 677]
Name: id, dtype: object
In [109]: ex.apply(lambda x:ex['id'].str.split('-'))
Out[109]: id
0 [KP123, 445, 678]
2 [KP123, 445, 677]
In [112]: ex['id'].str.split('-',expand=True)[2]
Out[112]: 0 678
2 677
Name: 2, dtype: object
In [114]: ex['number'] = ex['id'].str.split('-',expand=True)[2]
C:\Users\hakim\AppData\Local\Temp/ipykernel_9364/3731713283.py:1: SettingWithCopyWar
ning:
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead
See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/u

ser_guide/indexing.html#returning-a-view-versus-a-copy (https://pandas.pydata.org/pa
ndas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy)
ex['number'] = ex['id'].str.split('-',expand=True)[2]
In [115]: ex
Out[115]: id number
0 KP123-445-678 678
2 KP123-445-677 677
In [119]: r_id = []
for i in ex['id'].str.split('-'):
r_id.append(i[-1])
print(r_id)
['678', '677']
In [120]: ex
Out[120]: id number
0 KP123-445-678 678
2 KP123-445-677 677
In [121]: ex['r_id'] = r_id
C:\Users\hakim\AppData\Local\Temp/ipykernel_9364/1805707212.py:1: SettingWithCopyWar
ning:
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead
See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/u

ser_guide/indexing.html#returning-a-view-versus-a-copy (https://pandas.pydata.org/pa
ndas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy)
ex['r_id'] = r_id
In [122]: ex
Out[122]: id number r_id
0 KP123-445-678 678 678
2 KP123-445-677 677 677
In [ ]:
In [93]: '''
rand(d0, d1, ..., dn)

Random values in a given shape.
'''
np.random.rand(5)
Out[93]: array([0.02797046, 0.27329249, 0.96250308, 0.51102897, 0.91144933])
In [3]: np.random.rand(5,3)
Out[3]: array([[0.75671313, 0.47523686, 0.07657354],

[0.96988545, 0.65884326, 0.07040573],
[0.47972916, 0.08948053, 0.21278647],
[0.06511173, 0.12869076, 0.27115767],
[0.58835437, 0.64445866, 0.68619386]])
In [4]: np.random.rand(3,2,2)
Out[4]: array([[[0.73543576, 0.20194153],

[0.16806944, 0.6655366 ]],
[[0.38388973, 0.79601924],
[0.46872426, 0.35585511]],
[[0.30234907, 0.27425016],
[0.94709762, 0.82155165]]])
In [41]: """
randint(low, high=None, size=None, dtype=int)

Return random integers from `low` (inclusive) to `high` (exclusive).
"""
np.random.randint(4,10,10)
Out[41]: array([5, 7, 4, 8, 9, 7, 8, 5, 6, 9])
In [42]: np.random.randint(4,10,(3,4))
Out[42]: array([[4, 4, 9, 8],

[6, 7, 4, 9],
[6, 6, 4, 9]])
In [43]: """
randn(d0, d1, ..., dn)

Return a sample (or samples) from the "standard normal" distribution.
-1 to +1
-3 to +3
"""
np.random.randn(12)
Out[43]: array([-0.67570659, 0.68119675, 0.11768435, -0.43513966, 0.11973263,

-0.67443269, 0.20239923, -0.20937164, 0.11231898, -0.42571108,
1.2990018 , 0.08392904])
In [74]: """
random(size=None)

Return random floats in the half-open interval [0.0, 1.0).
"""
np.random.random(10)
Out[74]: array([0.60576036, 0.34439086, 0.08917871, 0.11313322, 0.4655056 ,

0.05518852, 0.57738556, 0.32805669, 0.24725062, 0.69677092])
In [103]: a = [12,10,34,56,70,99]
np.random.choice(a,size=2)
Out[103]: array([70, 10])
In [108]: np.random.choice(a,size=(2,2))
Out[108]: array([[10, 12],

[56, 34]])
In [ ]:
In [3]: a = np.arange(24).reshape(2,12)
a
Out[3]: array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],

[12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]])
split()
In [4]: """
signature: np.split(ary, indices_or_sections, axis=0)
Docstring:
Split an array into multiple sub-arrays as views into àry`.
"""
np.split(a,2)
# default axis = 0 means work on rows
Out[4]: [array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]]),

array([[12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]])]
In [7]: # axis=1 work on columns

np.split(a,2,axis=1)
Out[7]: [array([[ 0, 1, 2, 3, 4, 5],

[12, 13, 14, 15, 16, 17]]),
array([[ 6, 7, 8, 9, 10, 11],
[18, 19, 20, 21, 22, 23]])]
In [11]: np.split(a,4,axis=1)
Out[11]: [array([[ 0, 1, 2],

[12, 13, 14]]),
array([[ 3, 4, 5],
[15, 16, 17]]),
array([[ 6, 7, 8],
[18, 19, 20]]),
array([[ 9, 10, 11],
[21, 22, 23]])]
In [12]: # hsplit(): horizontal splitting

a
Out[12]: array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],

[12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]])
In [14]: #Split an array into multiple sub-arrays horizontally (column-wise).

np.hsplit(a,2)
Out[14]: [array([[ 0, 1, 2, 3, 4, 5],

[12, 13, 14, 15, 16, 17]]),
array([[ 6, 7, 8, 9, 10, 11],
[18, 19, 20, 21, 22, 23]])]
In [19]: # vsplit
np.vsplit(a,2)
Out[19]: [array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]]),

array([[12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]])]
Delete array
In [20]: a
Out[20]: array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],

[12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]])
In [21]: np.delete(a,-1)
Out[21]: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,

17, 18, 19, 20, 21, 22])
In [22]: # last row delete

np.delete(a,-1,axis=0)
Out[22]: array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]])
In [23]: # delete last column

np.delete(a,-1,axis=1)
Out[23]: array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10],

[12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]])
In [24]: a
Out[24]: array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],

[12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]])
suppose i want to delete complete array
In [25]: del a
In [26]: a
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
----> 1 a
NameError: name 'a' is not defined
In [27]: # can we delete a row /column using del

b = np.random.random((4,4))
b
Out[27]: array([[0.09037876, 0.38006424, 0.84639761, 0.55521722],

[0.22892133, 0.06717815, 0.4736258 , 0.49635734],
[0.34956082, 0.73614149, 0.94007037, 0.03976513],
[0.29053554, 0.03616846, 0.20439108, 0.85807609]])
In [28]: b[:2]
Out[28]: array([[0.09037876, 0.38006424, 0.84639761, 0.55521722],

[0.22892133, 0.06717815, 0.4736258 , 0.49635734]])
In [29]: # lets delete 2 rows

del b[:2]
# del is used for to delete complete array/object nt element of array
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
1 # lets delete 2 rows
----> 2 del b[:2]
ValueError: cannot delete array elements
#Q. np.delete and del what is difference????

sort()
In [30]: c = np.array([[12,9,45,89],[0,2,67,4],[11,80,37,21]])
c
Out[30]: array([[12, 9, 45, 89],

[ 0, 2, 67, 4],
[11, 80, 37, 21]])
In [31]: np.sort(c) #sorted rowwise
Out[31]: array([[ 9, 12, 45, 89],

[ 0, 2, 4, 67],
[11, 21, 37, 80]])
In [33]: # sort columnwise

np.sort(c,axis=0)
Out[33]: array([[ 0, 2, 37, 4],

[11, 9, 45, 21],
[12, 80, 67, 89]])
copy()
In [34]: c
Out[34]: array([[12, 9, 45, 89],

[ 0, 2, 67, 4],
[11, 80, 37, 21]])
In [36]: x = np.copy(c)
x
Out[36]: array([[12, 9, 45, 89],

[ 0, 2, 67, 4],
[11, 80, 37, 21]])
In [39]: id(c),id(x) # shallow copy
Out[39]: (2848781103344, 2848782912464)
In [40]: y = c #deep copy
In [41]: id(y),id(c)
Out[41]: (2848781103344, 2848781103344)
In [46]: c
Out[46]: array([[12, 9, 45, 89],

[ 0, 2, 67, 4],
[11, 80, 37, 21]])
In [47]: c.reshape(12)#order='C'
Out[47]: array([12, 9, 45, 89, 0, 2, 67, 4, 11, 80, 37, 21])
In [48]: c.reshape(12,order='F')
Out[48]: array([12, 0, 11, 9, 2, 80, 45, 67, 37, 89, 4, 21])
argmax,argmin
In [49]: c
Out[49]: array([[12, 9, 45, 89],

[ 0, 2, 67, 4],
[11, 80, 37, 21]])
In [51]: c.ravel()
Out[51]: array([12, 9, 45, 89, 0, 2, 67, 4, 11, 80, 37, 21])
In [50]: #Returns the indices of the maximum values along an axis.

np.argmax(c)
Out[50]: 3
In [52]: #but i want rowwise and columnwise max_index

np.argmax(c,axis=0)
Out[52]: array([0, 2, 1, 0], dtype=int64)
In [53]: np.argmax(c,axis=1)
Out[53]: array([3, 2, 1], dtype=int64)
In [54]: # create an empty array

np.empty(4)
Out[54]: array([2.22520967e-307, 1.61323372e-307, 4.67296746e-307, 1.69121096e-306])

In [55]: np.empty((4,4))
Out[55]: array([[0.09037876, 0.38006424, 0.84639761, 0.55521722],

[0.22892133, 0.06717815, 0.4736258 , 0.49635734],
[0.34956082, 0.73614149, 0.94007037, 0.03976513],
[0.29053554, 0.03616846, 0.20439108, 0.85807609]])
In [56]: # i have c array, and

# want to create a new EMPTY array with same dimension as that of c
np.empty_like(c)
Out[56]: array([[12, 0, 11, 9],

[ 2, 80, 45, 67],
[37, 89, 4, 21]])
In [58]: b
Out[58]: array([[0.09037876, 0.38006424, 0.84639761, 0.55521722],

[0.22892133, 0.06717815, 0.4736258 , 0.49635734],
[0.34956082, 0.73614149, 0.94007037, 0.03976513],
[0.29053554, 0.03616846, 0.20439108, 0.85807609]])
In [59]: np.empty_like(b)
Out[59]: array([[0.09037876, 0.38006424, 0.84639761, 0.55521722],

[0.22892133, 0.06717815, 0.4736258 , 0.49635734],
[0.34956082, 0.73614149, 0.94007037, 0.03976513],
[0.29053554, 0.03616846, 0.20439108, 0.85807609]])
In [60]: np.empty_like(np.empty((3,4)))
Out[60]: array([[1.40745969e-311, 2.81617418e-322, 0.00000000e+000,

0.00000000e+000],
[1.11260619e-306, 2.92966904e-033, 5.20651174e-090,
5.64053562e-062],
[9.98705260e-048, 1.54574045e+185, 6.48224660e+170,
4.93432906e+257]])
cumsum/cumprod
In [61]: c
Out[61]: array([[12, 9, 45, 89],

[ 0, 2, 67, 4],
[11, 80, 37, 21]])
In [62]: #Return the cumulative sum of the elements along a given axis.

np.cumsum(c)
Out[62]: array([ 12, 21, 66, 155, 155, 157, 224, 228, 239, 319, 356, 377],
dtype=int32)
In [63]: np.cumsum(c,axis=0)
Out[63]: array([[ 12, 9, 45, 89],

[ 12, 11, 112, 93],
[ 23, 91, 149, 114]], dtype=int32)
In [ ]: #cumprod() #cummulative product
In [64]: a = [[1, 0],

[0, 1]]

b = [[4, 1],
[2, 2]]
np.dot(a, b)
Out[64]: array([[4, 1],

[2, 2]])
In [65]: np.multiply(a,b)
Out[65]: array([[4, 0],

[0, 2]])
In [1]: np.add()
np.subtract()
np.divide()
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
Input In [1], in <cell line: 1>()
----> 1 np.add()
2 np.subtract()
3 np.divide()
NameError: name 'np' is not defined
In [ ]:

Num Py

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Num Py

Uploaded by

Copyright:

Available Formats

In [2]: import numpy as np

Create a numpy array

Out[2]: array([10, 20, 30, 40])

In [6]: # what is the type of numpy array

Out[4]: array([[1, 2, 3],

Out[7]: array([[[1, 2],

Check some properties of an array`

Out[9]: array([[[1, 2],

In [22]: # check total blocks , rows and colums

In [27]: # if i want to check total number of elements

Out[47]: array([[1, 2]])

In [30]: #how much bytes alocated to each element

In [31]: # check memory address in hex

Out[31]: <memory at 0x000002A97A1EE6D0>

Out[32]: array([[[1, 2],

Creation of numpy array using numpy functions

In [55]: # 2D array of 0's

Out[55]: array([[0., 0., 0.],

In [57]: #lets change dtype

Out[58]: array([[0, 0, 0],

Out[68]: array([[0, 0, 0],

In [64]: #check the difference between them

In [69]: # 32 bit consumes more memory than 8 bits

In [70]: # if i want array with all 1's

Out[71]: array([[1., 1., 1.],

In [74]: # if i want array with specified value

Out[74]: array([99, 99, 99, 99])

Out[75]: array([[[99, 99, 99],

[[99, 99, 99],

[[99, 99, 99],

Out[85]: array([[['NA', 'NA', 'NA'],

[['NA', 'NA', 'NA'],

[['NA', 'NA', 'NA'],

Out[77]: array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

In [78]: # start and stop

In [79]: # start and stop , step

In [80]: # array with -ve steping

In [82]: #we can use -ve values as well

In [83]: # create an array with values -10 to +10

Help on package numpy:

How to use the documentation

Return evenly spaced values within a given interval.

Values are generated within the half-open interval ``[start, stop)``

For floating point arguments, the length of the result is

Return evenly spaced values within a given interval.

Values are generated within the half-open interval ``[start, stop)``

For floating point arguments, the length of the result is

In [ ]: #or use shift + tab

Out[94]: array([ 2. , 2.18367347, 2.36734694, 2.55102041, 2.73469388,

Out[95]: array([ 2. , 2.47368421, 2.94736842, 3.42105263, 3.89473684,

In [97]: 2.47368421- 2.94736842 #difference value is constant

In [99]: #u want to check difference

Out[99]: (array([ 2. , 2.47368421, 2.94736842, 3.42105263, 3.89473684,

In [101]: # -10 to +10

In [103]: np.linspace(-10,11,num = 21,endpoint=False)

In [3]: np.linspace(-10,11,num = 21)

Out[3]: array([-10. , -8.95, -7.9 , -6.85, -5.8 , -4.75, -3.7 , -2.65,

In [4]: np.linspace(-10,11,num = 21).ndim

In [5]: np.linspace(-10,11,num = 21).shape

In [6]: type(np.linspace(-10,11,num = 21))

Create a numpy array

Out[2]: array([10, 20, 30, 40])