#### Fundamentals of Numpy

H
```{
"cells": [
{
"cell_type": "markdown",
"source": [
"# Fundametal of Numpy"
]
},
{
"cell_type": "markdown",
"source": [
"Numpy is linear algebra library for python .\n",
"this is importent library because all pydata ecosystem rely on numpy."
]
},
{
"cell_type": "code",
"execution_count": 2,
"outputs": [
{
"data": {
"text/plain": [
"[1, 2, 3]"
]
},
"execution_count": 2,
"output_type": "execute_result"
}
],
"source": [
"import numpy as np\n",
"\n",
"arr = [1,2,3]\n",
"arr"
]
},
{
"cell_type": "code",
"execution_count": 2,
"outputs": [
{
"data": {
"text/plain": [
"array([1, 2, 3])"
]
},
"execution_count": 2,
"output_type": "execute_result"
}
],
"source": [
"np.array(arr)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"outputs": [
{
"data": {
"text/plain": [
"[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
]
},
"execution_count": 3,
"output_type": "execute_result"
}
],
"source": [
"my_mat = [[1,2,3],[4,5,6],[7,8,9]]\n",
"\n",
"my_mat\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"outputs": [
{
"data": {
"text/plain": [
"array([[1, 2, 3],\n",
"       [4, 5, 6],\n",
"       [7, 8, 9]])"
]
},
"execution_count": 4,
"output_type": "execute_result"
}
],
"source": [
"np.array(my_mat)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 6,
"output_type": "execute_result"
}
],
"source": [
"my_mat[0][1]"
]
},
{
"cell_type": "markdown",
"source": [
"## Arange"
]
},
{
"cell_type": "code",
"execution_count": 7,
"outputs": [
{
"data": {
"text/plain": [
"array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
]
},
"execution_count": 7,
"output_type": "execute_result"
}
],
"source": [
"# np.arange(start , last , offset)\n",
"\n",
"np.arange(0,10)  "
]
},
{
"cell_type": "code",
"execution_count": 10,
"outputs": [
{
"data": {
"text/plain": [
"array([0, 1, 2, 3, 4])"
]
},
"execution_count": 10,
"output_type": "execute_result"
}
],
"source": [
"np.arange(0,5,1)\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"outputs": [
{
"data": {
"text/plain": [
"array([ 2,  4,  6,  8, 10])"
]
},
"execution_count": 11,
"output_type": "execute_result"
}
],
"source": [
"np.arange(2,12,2)"
]
},
{
"cell_type": "markdown",
"source": [
"## Zeros "
]
},
{
"cell_type": "code",
"execution_count": 12,
"outputs": [
{
"data": {
"text/plain": [
"array([0., 0., 0.])"
]
},
"execution_count": 12,
"output_type": "execute_result"
}
],
"source": [
"# Zeros \n",
"\n",
"np.zeros(3)  # one dimensional"
]
},
{
"cell_type": "code",
"execution_count": 13,
"outputs": [
{
"data": {
"text/plain": [
"array([[0., 0., 0.],\n",
"       [0., 0., 0.],\n",
"       [0., 0., 0.]])"
]
},
"execution_count": 13,
"output_type": "execute_result"
}
],
"source": [
"np.zeros((3,3))  # two dimensional"
]
},
{
"cell_type": "markdown",
"source": [
"## One's"
]
},
{
"cell_type": "code",
"execution_count": 14,
"outputs": [
{
"data": {
"text/plain": [
"array([1., 1., 1., 1., 1.])"
]
},
"execution_count": 14,
"output_type": "execute_result"
}
],
"source": [
"# one's\n",
"\n",
"np.ones(5)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"outputs": [
{
"data": {
"text/plain": [
"array([[1., 1.],\n",
"       [1., 1.]])"
]
},
"execution_count": 15,
"output_type": "execute_result"
}
],
"source": [
"np.ones((2,2))"
]
},
{
"cell_type": "markdown",
"source": [
"## linespace"
]
},
{
"cell_type": "code",
"execution_count": 16,
"outputs": [
{
"data": {
"text/plain": [
"array([0.        , 0.55555556, 1.11111111, 1.66666667, 2.22222222,\n",
"       2.77777778, 3.33333333, 3.88888889, 4.44444444, 5.        ])"
]
},
"execution_count": 16,
"output_type": "execute_result"
}
],
"source": [
"# linspace -> (start , end , how many point u want in between start to end)\n",
"\n",
"np.linspace(0,5,10)"
]
},
{
"cell_type": "markdown",
"source": [
"## eye"
]
},
{
"cell_type": "code",
"execution_count": 17,
"outputs": [
{
"data": {
"text/plain": [
"array([[1., 0., 0.],\n",
"       [0., 1., 0.],\n",
"       [0., 0., 1.]])"
]
},
"execution_count": 17,
"output_type": "execute_result"
}
],
"source": [
"# Diagonal element \n",
"\n",
"np.eye(3)"
]
},
{
"cell_type": "markdown",
"source": [
"## Random Function"
]
},
{
"cell_type": "code",
"execution_count": 22,
"outputs": [
{
"data": {
"text/plain": [
"array([[0.93087129, 0.30534035, 0.2508104 ],\n",
"       [0.05900399, 0.39901502, 0.00206355],\n",
"       [0.10066378, 0.67083509, 0.95297132]])"
]
},
"execution_count": 22,
"output_type": "execute_result"
}
],
"source": [
"# random -> (number of points in between )\n",
"\n",
"np.random.rand(5)\n"
]
},
{
"cell_type": "code",
"execution_count": 23,
"outputs": [
{
"data": {
"text/plain": [
"array([[0.29917792, 0.88770559, 0.0923786 ],\n",
"       [0.33748283, 0.56245829, 0.88557374],\n",
"       [0.88111555, 0.40227034, 0.28943298]])"
]
},
"execution_count": 23,
"output_type": "execute_result"
}
],
"source": [
"np.random.rand(3,3)    "
]
},
{
"cell_type": "code",
"execution_count": 25,
"outputs": [
{
"data": {
"text/plain": [
"array([ 0.65926802, -0.18545583, -0.5672595 ])"
]
},
"execution_count": 25,
"output_type": "execute_result"
}
],
"source": [
"# random based on standard normal distrubution\n",
"\n",
"np.random.randn(3)\n"
]
},
{
"cell_type": "code",
"execution_count": 27,
"outputs": [
{
"data": {
"text/plain": [
"8"
]
},
"execution_count": 27,
"output_type": "execute_result"
}
],
"source": [
"# random number between start to end anything in interger format\n",
"\n",
"np.random.randint(1,20)"
]
},
{
"cell_type": "code",
"execution_count": 29,
"outputs": [
{
"data": {
"text/plain": [
"array([18, 12, 16,  3,  4])"
]
},
"execution_count": 29,
"output_type": "execute_result"
}
],
"source": [
"#  start , end , numbers of points in between \n",
"np.random.randint(1,20,5)"
]
},
{
"cell_type": "markdown",
"source": [
"## Reshape"
]
},
{
"cell_type": "code",
"execution_count": 33,
"outputs": [],
"source": [
"# reshape\n",
"\n",
"# we can reshape the arr into 2 dimesional\n",
"# we can't resize 10 into 2 row and 3 column or anything we have to reshape into row 2 and column 5\n",
"                \n",
"array = np.arange(10)"
]
},
{
"cell_type": "code",
"execution_count": 35,
"outputs": [
{
"data": {
"text/plain": [
"array([[0, 1, 2, 3, 4],\n",
"       [5, 6, 7, 8, 9]])"
]
},
"execution_count": 35,
"output_type": "execute_result"
}
],
"source": [
"array.reshape(2,5)"
]
},
{
"cell_type": "markdown",
"source": [
"## Random "
]
},
{
"cell_type": "code",
"execution_count": 44,
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"17\n",
"2\n",
"0\n",
"2\n"
]
}
],
"source": [
"number = np.random.randint(1,20,5);\n",
"print(number.max())\n",
"print(number.min())\n",
"print(number.argmax())  # return location where max is stored\n",
"print(number.argmin())  # return location where min is stored\n"
]
},
{
"cell_type": "markdown",
"source": [
"## Shape"
]
},
{
"cell_type": "code",
"execution_count": 46,
"outputs": [
{
"data": {
"text/plain": [
"(10,)"
]
},
"execution_count": 46,
"output_type": "execute_result"
}
],
"source": [
" array.shape  #because its one dimesional "
]
},
{
"cell_type": "markdown",
"source": [
"## dtype"
]
},
{
"cell_type": "code",
"execution_count": 49,
"outputs": [
{
"data": {
"text/plain": [
"dtype('int32')"
]
},
"execution_count": 49,
"output_type": "execute_result"
}
],
"source": [
"# type\n",
"array.dtype\n"
]
},
{
"cell_type": "code",
"execution_count": 51,
"outputs": [
{
"data": {
"text/plain": [
"3"
]
},
"execution_count": 51,
"output_type": "execute_result"
}
],
"source": [
"# instead of writing like these -> np.random.randint(1,20)\n",
"from numpy.random import randint\n",
"\n",
"# then we can directly call randint which will return random number in between 3 to 10 \n",
"randint(3,10)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"outputs": [],
"source": [
"arr_1 = np.arange(1,20)"
]
},
{
"cell_type": "markdown",
"source": [
"## mathematical operator"
]
},
{
"cell_type": "code",
"execution_count": 4,
"outputs": [
{
"data": {
"text/plain": [
"array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,\n",
"       18, 19])"
]
},
"execution_count": 4,
"output_type": "execute_result"
}
],
"source": [
"arr_1 "
]
},
{
"cell_type": "code",
"execution_count": 6,
"outputs": [
{
"data": {
"text/plain": [
"array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34,\n",
"       36, 38])"
]
},
"execution_count": 6,
"output_type": "execute_result"
}
],
"source": [
"arr_1 + arr_1"
]
},
{
"cell_type": "code",
"execution_count": 10,
"outputs": [
{
"data": {
"text/plain": [
"array([  1,   4,   9,  16,  25,  36,  49,  64,  81, 100, 121, 144, 169,\n",
"       196, 225, 256, 289, 324, 361])"
]
},
"execution_count": 10,
"output_type": "execute_result"
}
],
"source": [
"arr_1 * arr_1"
]
},
{
"cell_type": "code",
"execution_count": 8,
"outputs": [
{
"data": {
"text/plain": [
"array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])"
]
},
"execution_count": 8,
"output_type": "execute_result"
}
],
"source": [
"arr_1 - arr_1"
]
},
{
"cell_type": "code",
"execution_count": 11,
"outputs": [
{
"data": {
"text/plain": [
"array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
"       1., 1.])"
]
},
"execution_count": 11,
"output_type": "execute_result"
}
],
"source": [
"arr_1 / arr_1"
]
},
{
"cell_type": "code",
"execution_count": 12,
"outputs": [
{
"data": {
"text/plain": [
"array([ 10,  20,  30,  40,  50,  60,  70,  80,  90, 100, 110, 120, 130,\n",
"       140, 150, 160, 170, 180, 190])"
]
},
"execution_count": 12,
"output_type": "execute_result"
}
],
"source": [
"arr_1*10"
]
},
{
"cell_type": "code",
"execution_count": 15,
"outputs": [
{
"data": {
"text/plain": [
"array([  1,   4,   9,  16,  25,  36,  49,  64,  81, 100, 121, 144, 169,\n",
"       196, 225, 256, 289, 324, 361], dtype=int32)"
]
},
"execution_count": 15,
"output_type": "execute_result"
}
],
"source": [
"arr_1**2"
]
},
{
"cell_type": "code",
"execution_count": 21,
"outputs": [
{
"data": {
"text/plain": [
"array([  1,   4,   9,  16,  25,  36,  49,  64,  81, 100, 121, 144, 169,\n",
"       196, 225, 256, 289, 324, 361], dtype=int32)"
]
},
"execution_count": 21,
"output_type": "execute_result"
}
],
"source": [
"np.square(arr_1)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"outputs": [
{
"data": {
"text/plain": [
"19"
]
},
"execution_count": 22,
"output_type": "execute_result"
}
],
"source": [
"np.max(arr_1)"
]
},
{
"cell_type": "code",
"execution_count": 23,
"outputs": [
{
"data": {
"text/plain": [
"array([1.        , 1.41421356, 1.73205081, 2.        , 2.23606798,\n",
"       2.44948974, 2.64575131, 2.82842712, 3.        , 3.16227766,\n",
"       3.31662479, 3.46410162, 3.60555128, 3.74165739, 3.87298335,\n",
"       4.        , 4.12310563, 4.24264069, 4.35889894])"
]
},
"execution_count": 23,
"output_type": "execute_result"
}
],
"source": [
"np.sqrt(arr_1)"
]
},
{
"cell_type": "code",
"execution_count": 25,
"outputs": [
{
"data": {
"text/plain": [
"array([2.71828183e+00, 7.38905610e+00, 2.00855369e+01, 5.45981500e+01,\n",
"       1.48413159e+02, 4.03428793e+02, 1.09663316e+03, 2.98095799e+03,\n",
"       8.10308393e+03, 2.20264658e+04, 5.98741417e+04, 1.62754791e+05,\n",
"       4.42413392e+05, 1.20260428e+06, 3.26901737e+06, 8.88611052e+06,\n",
"       2.41549528e+07, 6.56599691e+07, 1.78482301e+08])"
]
},
"execution_count": 25,
"output_type": "execute_result"
}
],
"source": [
"np.exp(arr_1)"
]
},
{
"cell_type": "code",
"execution_count": 28,
"outputs": [
{
"data": {
"text/plain": [
"array([ 0.84147098,  0.90929743,  0.14112001, -0.7568025 , -0.95892427,\n",
"       -0.2794155 ,  0.6569866 ,  0.98935825,  0.41211849, -0.54402111,\n",
"       -0.99999021, -0.53657292,  0.42016704,  0.99060736,  0.65028784,\n",
"       -0.28790332, -0.96139749, -0.75098725,  0.14987721])"
]
},
"execution_count": 28,
"output_type": "execute_result"
}
],
"source": [
"# mathematical operator\n",
"np.sin(arr_1)"
]
},
{
"cell_type": "code",
"execution_count": 29,
"outputs": [
{
"data": {
"text/plain": [
"array([0.        , 0.69314718, 1.09861229, 1.38629436, 1.60943791,\n",
"       1.79175947, 1.94591015, 2.07944154, 2.19722458, 2.30258509,\n",
"       2.39789527, 2.48490665, 2.56494936, 2.63905733, 2.7080502 ,\n",
"       2.77258872, 2.83321334, 2.89037176, 2.94443898])"
]
},
"execution_count": 29,
"output_type": "execute_result"
}
],
"source": [
"np.log(arr_1)"
]
},
{
"cell_type": "markdown",
"source": [
"## Numpy indexing and selection"
]
},
{
"cell_type": "code",
"execution_count": 31,
"outputs": [],
"source": [
"arr_2d = np.array([+.\n",
"                   [5,10,15],[20,23,45],[78,54,12]])\n"
]
},
{
"cell_type": "code",
"execution_count": 32,
"outputs": [
{
"data": {
"text/plain": [
"array([[ 5, 10, 15],\n",
"       [20, 23, 45],\n",
"       [78, 54, 12]])"
]
},
"execution_count": 32,
"output_type": "execute_result"
}
],
"source": [
"arr_2d"
]
},
{
"cell_type": "code",
"execution_count": 33,
"outputs": [
{
"data": {
"text/plain": [
"10"
]
},
"execution_count": 33,
"output_type": "execute_result"
}
],
"source": [
"arr_2d[0][1]"
]
},
{
"cell_type": "code",
"execution_count": 34,
"outputs": [
{
"data": {
"text/plain": [
"array([[10, 15],\n",
"       [23, 45]])"
]
},
"execution_count": 34,
"output_type": "execute_result"
}
],
"source": [
"#Grab Everything from row 2 which is starting from column 1 to onwords\n",
"arr_2d[:2,1:]\n"
]
},
{
"cell_type": "code",
"execution_count": 42,
"outputs": [
{
"data": {
"text/plain": [
"array([23, 45])"
]
},
"execution_count": 42,
"output_type": "execute_result"
}
],
"source": [
"arr_2d[1,1:]"
]
},
{
"cell_type": "code",
"execution_count": 47,
"outputs": [],
"source": [
"boolean = arr_2d > 30"
]
},
{
"cell_type": "code",
"execution_count": 48,
"outputs": [
{
"data": {
"text/plain": [
"array([[False, False, False],\n",
"       [False, False,  True],\n",
"       [ True,  True, False]])"
]
},
"execution_count": 48,
"output_type": "execute_result"
}
],
"source": [
"boolean"
]
},
{
"cell_type": "code",
"execution_count": 50,
"outputs": [
{
"data": {
"text/plain": [
"array([45, 78, 54])"
]
},
"execution_count": 50,
"output_type": "execute_result"
}
],
"source": [
"arr_2d[boolean]  "
]
},
{
"cell_type": "code",
"execution_count": 51,
"outputs": [
{
"data": {
"text/plain": [
"array([23, 45, 78, 54])"
]
},
"execution_count": 51,
"output_type": "execute_result"
}
],
"source": [
"arr_2d[arr_2d>20]"
]
},
{
"cell_type": "markdown",
"source": []
},
{
"cell_type": "code",
"execution_count": 1,
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"outputs": [],
"source": []
}
],
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.6.8"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
```

# Fundametal of Numpy

Numpy is linear algebra library for python . this is importent library because all pydata ecosystem rely on numpy.

``````import numpy as np

arr = [1,2,3]
arr``````
`[1, 2, 3]`
``np.array(arr)``
`array([1, 2, 3])`
``````my_mat = [[1,2,3],[4,5,6],[7,8,9]]

my_mat
``````
`[[1, 2, 3], [4, 5, 6], [7, 8, 9]]`
``np.array(my_mat)``
```array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])```
``my_mat[0][1]``
`2`

## Arange

``````# np.arange(start , last , offset)

np.arange(0,10)  ``````
`array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])`
``````np.arange(0,5,1)
``````
`array([0, 1, 2, 3, 4])`
``np.arange(2,12,2)``
`array([ 2,  4,  6,  8, 10])`

## Zeros

``````# Zeros

np.zeros(3)  # one dimensional``````
`array([0., 0., 0.])`
``np.zeros((3,3))  # two dimensional``
```array([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])```

## One's

``````# one's

np.ones(5)``````
`array([1., 1., 1., 1., 1.])`
``np.ones((2,2))``
```array([[1., 1.],
[1., 1.]])```

## linespace

``````# linspace -&gt; (start , end , how many point u want in between start to end)

np.linspace(0,5,10)``````
```array([0.        , 0.55555556, 1.11111111, 1.66666667, 2.22222222,
2.77777778, 3.33333333, 3.88888889, 4.44444444, 5.        ])```

## eye

``````# Diagonal element

np.eye(3)``````
```array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])```

## Random Function

``````# random -&gt; (number of points in between )

np.random.rand(5)
``````
```array([[0.93087129, 0.30534035, 0.2508104 ],
[0.05900399, 0.39901502, 0.00206355],
[0.10066378, 0.67083509, 0.95297132]])```
``np.random.rand(3,3)    ``
```array([[0.29917792, 0.88770559, 0.0923786 ],
[0.33748283, 0.56245829, 0.88557374],
[0.88111555, 0.40227034, 0.28943298]])```
``````# random based on standard normal distrubution

np.random.randn(3)
``````
`array([ 0.65926802, -0.18545583, -0.5672595 ])`
``````# random number between start to end anything in interger format

np.random.randint(1,20)``````
`8`
``````#  start , end , numbers of points in between
np.random.randint(1,20,5)``````
`array([18, 12, 16,  3,  4])`

## Reshape

``````# reshape

# we can reshape the arr into 2 dimesional
# we can't resize 10 into 2 row and 3 column or anything we have to reshape into row 2 and column 5

array = np.arange(10)``````
``array.reshape(2,5)``
```array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])```

## Random

``````number = np.random.randint(1,20,5);
print(number.max())
print(number.min())
print(number.argmax())  # return location where max is stored
print(number.argmin())  # return location where min is stored
``````
```17
2
0
2
```

## Shape

`` array.shape  #because its one dimesional ``
`(10,)`

## dtype

``````# type
array.dtype
``````
`dtype(&#x27;int32&#x27;)`
``````# instead of writing like these -&gt; np.random.randint(1,20)
from numpy.random import randint

# then we can directly call randint which will return random number in between 3 to 10
randint(3,10)``````
`3`
``arr_1 = np.arange(1,20)``

## mathematical operator

``arr_1 ``
```array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,
18, 19])```
``arr_1 + arr_1``
```array([ 2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34,
36, 38])```
``arr_1 * arr_1``
```array([  1,   4,   9,  16,  25,  36,  49,  64,  81, 100, 121, 144, 169,
196, 225, 256, 289, 324, 361])```
``arr_1 - arr_1``
`array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])`
``arr_1 / arr_1``
```array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,
1., 1.])```
``arr_1*10``
```array([ 10,  20,  30,  40,  50,  60,  70,  80,  90, 100, 110, 120, 130,
140, 150, 160, 170, 180, 190])```
``arr_1**2``
```array([  1,   4,   9,  16,  25,  36,  49,  64,  81, 100, 121, 144, 169,
196, 225, 256, 289, 324, 361], dtype=int32)```
``np.square(arr_1)``
```array([  1,   4,   9,  16,  25,  36,  49,  64,  81, 100, 121, 144, 169,
196, 225, 256, 289, 324, 361], dtype=int32)```
``np.max(arr_1)``
`19`
``np.sqrt(arr_1)``
```array([1.        , 1.41421356, 1.73205081, 2.        , 2.23606798,
2.44948974, 2.64575131, 2.82842712, 3.        , 3.16227766,
3.31662479, 3.46410162, 3.60555128, 3.74165739, 3.87298335,
4.        , 4.12310563, 4.24264069, 4.35889894])```
``np.exp(arr_1)``
```array([2.71828183e+00, 7.38905610e+00, 2.00855369e+01, 5.45981500e+01,
1.48413159e+02, 4.03428793e+02, 1.09663316e+03, 2.98095799e+03,
8.10308393e+03, 2.20264658e+04, 5.98741417e+04, 1.62754791e+05,
4.42413392e+05, 1.20260428e+06, 3.26901737e+06, 8.88611052e+06,
2.41549528e+07, 6.56599691e+07, 1.78482301e+08])```
``````# mathematical operator
np.sin(arr_1)``````
```array([ 0.84147098,  0.90929743,  0.14112001, -0.7568025 , -0.95892427,
-0.2794155 ,  0.6569866 ,  0.98935825,  0.41211849, -0.54402111,
-0.99999021, -0.53657292,  0.42016704,  0.99060736,  0.65028784,
-0.28790332, -0.96139749, -0.75098725,  0.14987721])```
``np.log(arr_1)``
```array([0.        , 0.69314718, 1.09861229, 1.38629436, 1.60943791,
1.79175947, 1.94591015, 2.07944154, 2.19722458, 2.30258509,
2.39789527, 2.48490665, 2.56494936, 2.63905733, 2.7080502 ,
2.77258872, 2.83321334, 2.89037176, 2.94443898])```

## Numpy indexing and selection

``````arr_2d = np.array([+.
[5,10,15],[20,23,45],[78,54,12]])
``````
``arr_2d``
```array([[ 5, 10, 15],
[20, 23, 45],
[78, 54, 12]])```
``arr_2d[0][1]``
`10`
``````#Grab Everything from row 2 which is starting from column 1 to onwords
arr_2d[:2,1:]
``````
```array([[10, 15],
[23, 45]])```
``arr_2d[1,1:]``
`array([23, 45])`
``boolean = arr_2d &gt; 30``
``boolean``
```array([[False, False, False],
[False, False,  True],
[ True,  True, False]])```
``arr_2d[boolean]  ``
`array([45, 78, 54])`
``arr_2d[arr_2d&gt;20]``
`array([23, 45, 78, 54])`