diff --git a/Assignment on Numpy and Pandas_Beatrice Ejeh.ipynb b/Assignment on Numpy and Pandas_Beatrice Ejeh.ipynb new file mode 100644 index 0000000..fb5d7ab --- /dev/null +++ b/Assignment on Numpy and Pandas_Beatrice Ejeh.ipynb @@ -0,0 +1,3240 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d6fd49e1", + "metadata": {}, + "source": [ + "# Built-In Methods in Numpy" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "id": "6ea902fe", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "d7c4382f", + "metadata": {}, + "source": [ + "### 1. `arange()`\n", + "\n", + "* arange() is very much similar to Python function range()
\n", + "* Syntax: arange([start,] stop[, step,], dtype=None)
\n", + "* Return evenly spaced values within a given interval.
" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "id": "6d5183ba", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])" + ] + }, + "execution_count": 84, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Example on 'arange' method\n", + "np.arange(0,10) # similar to range() in Python, not including 10" + ] + }, + { + "cell_type": "markdown", + "id": "607c185f", + "metadata": {}, + "source": [ + "### 2. `linspace(start, end, num_of_points)`\n", + "Return evenly spaced numbers over a specified interval.
" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "id": "34e7e3ed", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 1. , 1.28571429, 1.57142857, 1.85714286, 2.14285714,\n", + " 2.42857143, 2.71428571, 3. , 3.28571429, 3.57142857,\n", + " 3.85714286, 4.14285714, 4.42857143, 4.71428571, 5. ,\n", + " 5.28571429, 5.57142857, 5.85714286, 6.14285714, 6.42857143,\n", + " 6.71428571, 7. , 7.28571429, 7.57142857, 7.85714286,\n", + " 8.14285714, 8.42857143, 8.71428571, 9. , 9.28571429,\n", + " 9.57142857, 9.85714286, 10.14285714, 10.42857143, 10.71428571,\n", + " 11. , 11.28571429, 11.57142857, 11.85714286, 12.14285714,\n", + " 12.42857143, 12.71428571, 13. , 13.28571429, 13.57142857,\n", + " 13.85714286, 14.14285714, 14.42857143, 14.71428571, 15. ])" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Example on 'linspace' method\n", + "np.linspace(1, 15, 50) # start from 1 & end at 15 with 50 evenly spaced points b/w 1 to 15." + ] + }, + { + "cell_type": "markdown", + "id": "01250657", + "metadata": {}, + "source": [ + "### 3. `zeros()`\n", + "\n", + "* This method creates an array with **all zeros**
" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "id": "ebcdf046", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0., 0., 0., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 0.]])" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.zeros((4,6)) #(no_row, no_col) passing a tuple" + ] + }, + { + "cell_type": "markdown", + "id": "71dc670d", + "metadata": {}, + "source": [ + "### 4. `ones()`\n", + "\n", + "* This method creates an array with **all ones**
" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "id": "1c20fb8f", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 1., 1., 1., 1., 1.],\n", + " [1., 1., 1., 1., 1., 1.],\n", + " [1., 1., 1., 1., 1., 1.],\n", + " [1., 1., 1., 1., 1., 1.]])" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.ones((4,6)) #(no_row, no_col) passing a tuple" + ] + }, + { + "cell_type": "markdown", + "id": "d6787265", + "metadata": {}, + "source": [ + "### 5. `eye()` \n", + "This method creates an identity matrix must be a square matrix, which is useful in several linear algebra problems.\n", + "* Returns a 2-D array with **ones on the diagonal and zeros elsewhere.**" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "5ba65d64", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 0., 0.],\n", + " [0., 1., 0.],\n", + " [0., 0., 1.]])" + ] + }, + "execution_count": 88, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.eye(3)" + ] + }, + { + "cell_type": "markdown", + "id": "d4b1d81c", + "metadata": {}, + "source": [ + "### 6. `rand()`\n", + "Create an array of the given shape and populate it with\n", + "random samples from a uniform distribution\n", + "over ``[0, 1)``." + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "id": "c5214014", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.24177062, 0.2614653 , 0.04219702])" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.rand(3)# 1-D array with three elements" + ] + }, + { + "cell_type": "markdown", + "id": "8cdc7859", + "metadata": {}, + "source": [ + "### 7. `randn()`\n", + "\n", + "Returns a sample (or samples) from the \"standard normal\" or a \"Gaussian\" distribution. Unlike rand which is uniform.
\n" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "id": "a3b29daa", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.86516378, 0.70372851])" + ] + }, + "execution_count": 90, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.randn(2) #1-D array with 2 samples" + ] + }, + { + "cell_type": "markdown", + "id": "e692e161", + "metadata": {}, + "source": [ + "### 8. `randint()`\n", + "Return random integers from `low` (inclusive) to `high` (exclusive)." + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "e45ea875", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9" + ] + }, + "execution_count": 91, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.randint(1,100) #returns one random int, 1 inclusive, 100 exclusive" + ] + }, + { + "cell_type": "markdown", + "id": "9339400a", + "metadata": {}, + "source": [ + "### 9. `shape()`\n", + "\n", + "Returns the total number of elements in an array" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "id": "0cbef145", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n", + " 17, 18, 19])" + ] + }, + "execution_count": 92, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Below is an an array of numbers that would be used to explain the next couple of methods\n", + "array_arange = np.arange(20)\n", + "\n", + "array_arange" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "id": "44a58db2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(20,)" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "array_arange.shape" + ] + }, + { + "cell_type": "markdown", + "id": "d0a701bf", + "metadata": {}, + "source": [ + "### 10. `Reshape()`\n", + "Returns an array containing the same data with a new shape." + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "id": "b58f8f84", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 1, 2, 3, 4],\n", + " [ 5, 6, 7, 8, 9],\n", + " [10, 11, 12, 13, 14],\n", + " [15, 16, 17, 18, 19]])" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "array_arange.reshape(4, 5) # any other num will give error" + ] + }, + { + "cell_type": "markdown", + "id": "69600fbf", + "metadata": {}, + "source": [ + "### 11. `max()`\n", + "This method is useful for finding maximum values in an array." + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "986e4d83", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "19" + ] + }, + "execution_count": 95, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "array_arange.max()" + ] + }, + { + "cell_type": "markdown", + "id": "2ba95530", + "metadata": {}, + "source": [ + "### 12. `min()`\n", + "This method is useful for finding minimum values in an array." + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "6b28fff6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "array_arange.min()" + ] + }, + { + "cell_type": "markdown", + "id": "4d46d990", + "metadata": {}, + "source": [ + "### 13. `argmax()`\n", + "This method is used to find the index locations of maximum values in array" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "9586a842", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "19" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "array_arange.argmax()" + ] + }, + { + "cell_type": "markdown", + "id": "9ec3807b", + "metadata": {}, + "source": [ + "### 14. `argmin()`\n", + "This method is used to find the index locations of minimum values in array" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "49adf32a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Example\n", + "array_arange.argmin()" + ] + }, + { + "cell_type": "markdown", + "id": "bcd88ad1", + "metadata": {}, + "source": [ + "### 15. `dtype()`\n", + "This methods tells what the data type of the object in the array is" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "252f44b5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "dtype('int32')" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Example on dtype\n", + "array_arange.dtype" + ] + }, + { + "cell_type": "markdown", + "id": "a39c9907", + "metadata": {}, + "source": [ + "### 16. `append()`\n", + "This method is used to append values to the end of an array" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "acca5c5c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 2 3]\n", + " [4 5 6]]\n", + "[[7 8 9]]\n", + "[[1 2 3]\n", + " [4 5 6]\n", + " [7 8 9]]\n" + ] + } + ], + "source": [ + "nd1 = np.array([[1,2,3],[4,5,6]])\n", + "nd2 = np.array([[7,8,9]])\n", + "\n", + "print(nd1)\n", + "print(nd2)\n", + "print(np.append(nd1,nd2,0))" + ] + }, + { + "cell_type": "markdown", + "id": "7be99867", + "metadata": {}, + "source": [ + "### 17. `log()`\n", + "This method returns an ndarray with each element as the natural logarithm of the corresponding element in an array\n", + "\n", + "**Note:** An ndarray is a multi-dimensional array of items of the same type and size" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "9308b298", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1. 2.71828]\n", + " [2.71828 1. ]]\n", + "[[0. 0.99999933]\n", + " [0.99999933 0. ]]\n" + ] + } + ], + "source": [ + "nd = np.array([[1,2.71828],[2.71828,1]])\n", + "\n", + "print(nd)\n", + "print(np.log(nd))" + ] + }, + { + "cell_type": "markdown", + "id": "ca152078", + "metadata": {}, + "source": [ + "### 18. `transpose`\n", + "This method reverses or permutes the axes of an ndarray" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "e4aded90", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 2 3]\n", + " [4 5 6]]\n", + "[[1 4]\n", + " [2 5]\n", + " [3 6]]\n" + ] + } + ], + "source": [ + "nd1 = np.array([[1,2,3],[4,5,6]])\n", + "\n", + "print(nd1)\n", + "print(np.transpose(nd1))" + ] + }, + { + "cell_type": "markdown", + "id": "5679bb3e", + "metadata": {}, + "source": [ + "### 19. `sum()`\n", + "This method sums the elements of an array over a given axis" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "4c777567", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n", + "[5 7 9]\n", + "[ 6 15]\n" + ] + } + ], + "source": [ + "nd = np.array([[1,2,3],[4,5,6]])\n", + "\n", + "print(np.sum(nd))\n", + "print(np.sum(nd, axis=0))\n", + "print(np.sum(nd, axis=1))" + ] + }, + { + "cell_type": "markdown", + "id": "d190d091", + "metadata": {}, + "source": [ + "### 20. `average()`\n", + "This method is used for calculating the weighted average along the specified axis" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "id": "9a82dd51", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4.5" + ] + }, + "execution_count": 105, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = np.arange(0,10)\n", + "avg = np.average(data)\n", + "\n", + "avg" + ] + }, + { + "cell_type": "markdown", + "id": "243bc4aa", + "metadata": {}, + "source": [ + "# Built-In Methods in Pandas" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "4698d1bb", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "d4c59f0b", + "metadata": {}, + "outputs": [], + "source": [ + "my_index = 'r1 r2 r3 r4 r5 r6 r7 r8 r9 r10'.split()\n", + "my_columns = 'c1 c2 c3 c4 c5 c6 c7 c8 c9 c10'.split()\n", + "array_2d = np.arange(0,100).reshape(10,10)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "2e054812", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['r1', 'r2', 'r3', 'r4', 'r5', 'r6', 'r7', 'r8', 'r9', 'r10']" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# How the index, columns and array_2d look like!\n", + "my_index" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "ea4f2629", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8', 'c9', 'c10']" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "my_columns" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "f24446e1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9],\n", + " [10, 11, 12, 13, 14, 15, 16, 17, 18, 19],\n", + " [20, 21, 22, 23, 24, 25, 26, 27, 28, 29],\n", + " [30, 31, 32, 33, 34, 35, 36, 37, 38, 39],\n", + " [40, 41, 42, 43, 44, 45, 46, 47, 48, 49],\n", + " [50, 51, 52, 53, 54, 55, 56, 57, 58, 59],\n", + " [60, 61, 62, 63, 64, 65, 66, 67, 68, 69],\n", + " [70, 71, 72, 73, 74, 75, 76, 77, 78, 79],\n", + " [80, 81, 82, 83, 84, 85, 86, 87, 88, 89],\n", + " [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]])" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "array_2d" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "7a525850", + "metadata": {}, + "outputs": [], + "source": [ + "# Creating a DataFrame using index, columns and array_2d\n", + "df = pd.DataFrame(data = array_2d, index = my_index, columns = my_columns)" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "2b07e892", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
c1c2c3c4c5c6c7c8c9c10
r10123456789
r210111213141516171819
r320212223242526272829
r430313233343536373839
r540414243444546474849
r650515253545556575859
r760616263646566676869
r870717273747576777879
r980818283848586878889
r1090919293949596979899
\n", + "
" + ], + "text/plain": [ + " c1 c2 c3 c4 c5 c6 c7 c8 c9 c10\n", + "r1 0 1 2 3 4 5 6 7 8 9\n", + "r2 10 11 12 13 14 15 16 17 18 19\n", + "r3 20 21 22 23 24 25 26 27 28 29\n", + "r4 30 31 32 33 34 35 36 37 38 39\n", + "r5 40 41 42 43 44 45 46 47 48 49\n", + "r6 50 51 52 53 54 55 56 57 58 59\n", + "r7 60 61 62 63 64 65 66 67 68 69\n", + "r8 70 71 72 73 74 75 76 77 78 79\n", + "r9 80 81 82 83 84 85 86 87 88 89\n", + "r10 90 91 92 93 94 95 96 97 98 99" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "markdown", + "id": "0f07be94", + "metadata": {}, + "source": [ + "### 1. **`reset_index()`** and **`set_index()`**
\n", + "We can reset the index of our dataframe to numerical index (which is default index), `inplace = True` to make the permanent change. *The existing index will be a new column.*" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "b21d5ecd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
indexc1c2c3c4c5c6c7c8c9c10
0r10123456789
1r210111213141516171819
2r320212223242526272829
3r430313233343536373839
4r540414243444546474849
5r650515253545556575859
6r760616263646566676869
7r870717273747576777879
8r980818283848586878889
9r1090919293949596979899
\n", + "
" + ], + "text/plain": [ + " index c1 c2 c3 c4 c5 c6 c7 c8 c9 c10\n", + "0 r1 0 1 2 3 4 5 6 7 8 9\n", + "1 r2 10 11 12 13 14 15 16 17 18 19\n", + "2 r3 20 21 22 23 24 25 26 27 28 29\n", + "3 r4 30 31 32 33 34 35 36 37 38 39\n", + "4 r5 40 41 42 43 44 45 46 47 48 49\n", + "5 r6 50 51 52 53 54 55 56 57 58 59\n", + "6 r7 60 61 62 63 64 65 66 67 68 69\n", + "7 r8 70 71 72 73 74 75 76 77 78 79\n", + "8 r9 80 81 82 83 84 85 86 87 88 89\n", + "9 r10 90 91 92 93 94 95 96 97 98 99" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.reset_index(inplace = True)\n", + "df" + ] + }, + { + "cell_type": "markdown", + "id": "e673f764", + "metadata": {}, + "source": [ + "### 2. `head()`\n", + "This method returns the first n rows in a data set\n", + "\n", + "**Note:** n = 5 by default" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "d9828d2d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
indexc1c2c3c4c5c6c7c8c9c10
0r10123456789
1r210111213141516171819
2r320212223242526272829
3r430313233343536373839
4r540414243444546474849
\n", + "
" + ], + "text/plain": [ + " index c1 c2 c3 c4 c5 c6 c7 c8 c9 c10\n", + "0 r1 0 1 2 3 4 5 6 7 8 9\n", + "1 r2 10 11 12 13 14 15 16 17 18 19\n", + "2 r3 20 21 22 23 24 25 26 27 28 29\n", + "3 r4 30 31 32 33 34 35 36 37 38 39\n", + "4 r5 40 41 42 43 44 45 46 47 48 49" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head()" + ] + }, + { + "cell_type": "markdown", + "id": "38bd2e99", + "metadata": {}, + "source": [ + "### 3. `tail()`\n", + "This method returns the first n rows in a data set\n", + "\n", + "**Note:** n = 5 by default i.e. if no input is given, it will always show 5 rows\n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "5237d497", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
indexc1c2c3c4c5c6c7c8c9c10
5r650515253545556575859
6r760616263646566676869
7r870717273747576777879
8r980818283848586878889
9r1090919293949596979899
\n", + "
" + ], + "text/plain": [ + " index c1 c2 c3 c4 c5 c6 c7 c8 c9 c10\n", + "5 r6 50 51 52 53 54 55 56 57 58 59\n", + "6 r7 60 61 62 63 64 65 66 67 68 69\n", + "7 r8 70 71 72 73 74 75 76 77 78 79\n", + "8 r9 80 81 82 83 84 85 86 87 88 89\n", + "9 r10 90 91 92 93 94 95 96 97 98 99" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.tail()" + ] + }, + { + "cell_type": "markdown", + "id": "2fc49651", + "metadata": {}, + "source": [ + "### 4. `shape()`\n", + "This method gives a total number of rows and them columns" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "d366ab3d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(10, 11)" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.shape" + ] + }, + { + "cell_type": "markdown", + "id": "e30cc629", + "metadata": {}, + "source": [ + "### 5. `size()`\n", + "This methode returns the number of rows times the number of columns in a dataframe" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "7c05906e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "110" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.size" + ] + }, + { + "cell_type": "markdown", + "id": "c8ca5993", + "metadata": {}, + "source": [ + "### 6. `info()`\n", + "This method helps to give an idea of different information about the dataframe such as rows from RangeIndex, data columns and the data type of each column." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "9d5fcabf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 10 entries, 0 to 9\n", + "Data columns (total 11 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 index 10 non-null object\n", + " 1 c1 10 non-null int32 \n", + " 2 c2 10 non-null int32 \n", + " 3 c3 10 non-null int32 \n", + " 4 c4 10 non-null int32 \n", + " 5 c5 10 non-null int32 \n", + " 6 c6 10 non-null int32 \n", + " 7 c7 10 non-null int32 \n", + " 8 c8 10 non-null int32 \n", + " 9 c9 10 non-null int32 \n", + " 10 c10 10 non-null int32 \n", + "dtypes: int32(10), object(1)\n", + "memory usage: 608.0+ bytes\n" + ] + } + ], + "source": [ + "df.info()" + ] + }, + { + "cell_type": "markdown", + "id": "a13ee2ec", + "metadata": {}, + "source": [ + "### 7. `describe()`\n", + "This method generates descriptive statistics that summarize the central tendency, dispersion and shape of a dataset's distribution, excluding `NaN` values." + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "aefe09d7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
c1c2c3c4c5c6c7c8c9c10
count10.00000010.00000010.00000010.00000010.00000010.00000010.00000010.00000010.00000010.000000
mean45.00000046.00000047.00000048.00000049.00000050.00000051.00000052.00000053.00000054.000000
std30.27650430.27650430.27650430.27650430.27650430.27650430.27650430.27650430.27650430.276504
min0.0000001.0000002.0000003.0000004.0000005.0000006.0000007.0000008.0000009.000000
25%22.50000023.50000024.50000025.50000026.50000027.50000028.50000029.50000030.50000031.500000
50%45.00000046.00000047.00000048.00000049.00000050.00000051.00000052.00000053.00000054.000000
75%67.50000068.50000069.50000070.50000071.50000072.50000073.50000074.50000075.50000076.500000
max90.00000091.00000092.00000093.00000094.00000095.00000096.00000097.00000098.00000099.000000
\n", + "
" + ], + "text/plain": [ + " c1 c2 c3 c4 c5 c6 \\\n", + "count 10.000000 10.000000 10.000000 10.000000 10.000000 10.000000 \n", + "mean 45.000000 46.000000 47.000000 48.000000 49.000000 50.000000 \n", + "std 30.276504 30.276504 30.276504 30.276504 30.276504 30.276504 \n", + "min 0.000000 1.000000 2.000000 3.000000 4.000000 5.000000 \n", + "25% 22.500000 23.500000 24.500000 25.500000 26.500000 27.500000 \n", + "50% 45.000000 46.000000 47.000000 48.000000 49.000000 50.000000 \n", + "75% 67.500000 68.500000 69.500000 70.500000 71.500000 72.500000 \n", + "max 90.000000 91.000000 92.000000 93.000000 94.000000 95.000000 \n", + "\n", + " c7 c8 c9 c10 \n", + "count 10.000000 10.000000 10.000000 10.000000 \n", + "mean 51.000000 52.000000 53.000000 54.000000 \n", + "std 30.276504 30.276504 30.276504 30.276504 \n", + "min 6.000000 7.000000 8.000000 9.000000 \n", + "25% 28.500000 29.500000 30.500000 31.500000 \n", + "50% 51.000000 52.000000 53.000000 54.000000 \n", + "75% 73.500000 74.500000 75.500000 76.500000 \n", + "max 96.000000 97.000000 98.000000 99.000000 " + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.describe()" + ] + }, + { + "cell_type": "markdown", + "id": "add6c917", + "metadata": {}, + "source": [ + "### 8. `isna()`\n", + "This method give the total number of null values in a dataframe" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "06de2ab8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
indexc1c2c3c4c5c6c7c8c9c10
0FalseFalseFalseFalseFalseFalseFalseFalseFalseFalseFalse
1FalseFalseFalseFalseFalseFalseFalseFalseFalseFalseFalse
2FalseFalseFalseFalseFalseFalseFalseFalseFalseFalseFalse
3FalseFalseFalseFalseFalseFalseFalseFalseFalseFalseFalse
4FalseFalseFalseFalseFalseFalseFalseFalseFalseFalseFalse
5FalseFalseFalseFalseFalseFalseFalseFalseFalseFalseFalse
6FalseFalseFalseFalseFalseFalseFalseFalseFalseFalseFalse
7FalseFalseFalseFalseFalseFalseFalseFalseFalseFalseFalse
8FalseFalseFalseFalseFalseFalseFalseFalseFalseFalseFalse
9FalseFalseFalseFalseFalseFalseFalseFalseFalseFalseFalse
\n", + "
" + ], + "text/plain": [ + " index c1 c2 c3 c4 c5 c6 c7 c8 c9 c10\n", + "0 False False False False False False False False False False False\n", + "1 False False False False False False False False False False False\n", + "2 False False False False False False False False False False False\n", + "3 False False False False False False False False False False False\n", + "4 False False False False False False False False False False False\n", + "5 False False False False False False False False False False False\n", + "6 False False False False False False False False False False False\n", + "7 False False False False False False False False False False False\n", + "8 False False False False False False False False False False False\n", + "9 False False False False False False False False False False False" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.isna()" + ] + }, + { + "cell_type": "markdown", + "id": "281c610a", + "metadata": {}, + "source": [ + "### 9. `isna().sum()`\n", + "This method gives the total null values" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "df53cc34", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "index 0\n", + "c1 0\n", + "c2 0\n", + "c3 0\n", + "c4 0\n", + "c5 0\n", + "c6 0\n", + "c7 0\n", + "c8 0\n", + "c9 0\n", + "c10 0\n", + "dtype: int64" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.isna().sum()" + ] + }, + { + "cell_type": "markdown", + "id": "fbf79fb0", + "metadata": {}, + "source": [ + "### 10. `nunique()`\n", + "This method gives all the unique values a variable contains" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "d1500b33", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "index 10\n", + "c1 10\n", + "c2 10\n", + "c3 10\n", + "c4 10\n", + "c5 10\n", + "c6 10\n", + "c7 10\n", + "c8 10\n", + "c9 10\n", + "c10 10\n", + "dtype: int64" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.nunique()" + ] + }, + { + "cell_type": "markdown", + "id": "70ff7011", + "metadata": {}, + "source": [ + "### 11. `Columns`\n", + "This method helps us to know the names of all the variables in a dataframe" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "50add350", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['index', 'c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8', 'c9', 'c10'], dtype='object')" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "df.columns" + ] + }, + { + "cell_type": "markdown", + "id": "06aec48b", + "metadata": {}, + "source": [ + "### 12. `value_counts()`\n", + "This method returns counts of unique values. For example, we can get the unique values of a single variable such as the value_counts for column \"c2\" in the dataframe" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "6b77a0a8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 1\n", + "11 1\n", + "21 1\n", + "31 1\n", + "41 1\n", + "51 1\n", + "61 1\n", + "71 1\n", + "81 1\n", + "91 1\n", + "Name: c2, dtype: int64\n" + ] + } + ], + "source": [ + "print(df.c2.value_counts())" + ] + }, + { + "cell_type": "markdown", + "id": "737e5428", + "metadata": {}, + "source": [ + "### 13. `read_csv()`\n", + "This function helps to read a comma seperated value (csv) file into a pandas dataframe " + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "id": "039a7e02", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Unnamed: 0C1C2C3C4C5C6C7C8C9C10
0R10123.0456789
1R210111213.0141516171819
2R3202122NaN242526272829
3R430313233.0343536373839
4R540414243.0444546474849
5R650515253.0545556575859
6R760616263.0646566676869
7R870717273.0747576777879
8R980818283.0848586878889
9R1090919293.0949596979899
\n", + "
" + ], + "text/plain": [ + " Unnamed: 0 C1 C2 C3 C4 C5 C6 C7 C8 C9 C10\n", + "0 R1 0 1 2 3.0 4 5 6 7 8 9\n", + "1 R2 10 11 12 13.0 14 15 16 17 18 19\n", + "2 R3 20 21 22 NaN 24 25 26 27 28 29\n", + "3 R4 30 31 32 33.0 34 35 36 37 38 39\n", + "4 R5 40 41 42 43.0 44 45 46 47 48 49\n", + "5 R6 50 51 52 53.0 54 55 56 57 58 59\n", + "6 R7 60 61 62 63.0 64 65 66 67 68 69\n", + "7 R8 70 71 72 73.0 74 75 76 77 78 79\n", + "8 R9 80 81 82 83.0 84 85 86 87 88 89\n", + "9 R10 90 91 92 93.0 94 95 96 97 98 99" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df1 = pd.read_csv('Pandas.csv')\n", + "\n", + "df1" + ] + }, + { + "cell_type": "markdown", + "id": "1a0d8120", + "metadata": {}, + "source": [ + "### 14. `memory_usage()`\n", + "This method returns a Pandas series having the memory of each usage of each column in bytes in a Pandas DataFrame.\n", + "\n", + "**By specifying the deep attribute, we can get to know the actual space taken by each column**" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "6de08cd9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index 128\n", + "index 591\n", + "c1 40\n", + "c2 40\n", + "c3 40\n", + "c4 40\n", + "c5 40\n", + "c6 40\n", + "c7 40\n", + "c8 40\n", + "c9 40\n", + "c10 40\n", + "dtype: int64" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.memory_usage(deep=True)" + ] + }, + { + "cell_type": "markdown", + "id": "81c69f36", + "metadata": {}, + "source": [ + "### 15. `astype()`\n", + "\n", + "This method is used to cast a python object to a particular data type.\n", + "\n", + "Can be helpful incase data is not stored in the correct format\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "1d03fe58", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "r1 2\n", + "r2 12\n", + "r3 22\n", + "r4 32\n", + "r5 42\n", + "r6 52\n", + "r7 62\n", + "r8 72\n", + "r9 82\n", + "r10 92\n", + "Name: c3, dtype: category\n", + "Categories (10, int64): [2, 12, 22, 32, ..., 62, 72, 82, 92]" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_c3 = df.c3.astype('category')\n", + "df_c3" + ] + }, + { + "cell_type": "markdown", + "id": "b70642eb", + "metadata": {}, + "source": [ + "### 16. `loc[:]`\n", + "This helps to access a group of rows and columns in a dataset, a slice of the dataset as per requirement" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "eda3cc9d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
c1c2
r101
r21011
\n", + "
" + ], + "text/plain": [ + " c1 c2\n", + "r1 0 1\n", + "r2 10 11" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.loc[['r1','r2'],['c1','c2']]" + ] + }, + { + "cell_type": "markdown", + "id": "c0122b89", + "metadata": {}, + "source": [ + "### 17. `drop_duplicates()`\n", + "\n", + "This returns a Pandas DataFrame with duplicate rows removed" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "765aa6df", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
c1c2c3c4c5c6c7c8c9c10
r10123456789
r210111213141516171819
r320212223242526272829
r430313233343536373839
r540414243444546474849
r650515253545556575859
r760616263646566676869
r870717273747576777879
r980818283848586878889
r1090919293949596979899
\n", + "
" + ], + "text/plain": [ + " c1 c2 c3 c4 c5 c6 c7 c8 c9 c10\n", + "r1 0 1 2 3 4 5 6 7 8 9\n", + "r2 10 11 12 13 14 15 16 17 18 19\n", + "r3 20 21 22 23 24 25 26 27 28 29\n", + "r4 30 31 32 33 34 35 36 37 38 39\n", + "r5 40 41 42 43 44 45 46 47 48 49\n", + "r6 50 51 52 53 54 55 56 57 58 59\n", + "r7 60 61 62 63 64 65 66 67 68 69\n", + "r8 70 71 72 73 74 75 76 77 78 79\n", + "r9 80 81 82 83 84 85 86 87 88 89\n", + "r10 90 91 92 93 94 95 96 97 98 99" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.drop_duplicates(inplace=True)\n", + "df" + ] + }, + { + "cell_type": "markdown", + "id": "231a670c", + "metadata": {}, + "source": [ + "### 18. `sort_values()`\n", + "This is used to sort columns in a Pandas DataFrame by ascending or descending order" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "30d97297", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
c1c2c3c4c5c6c7c8c9c10
r10123456789
r210111213141516171819
r320212223242526272829
r430313233343536373839
r540414243444546474849
r650515253545556575859
r760616263646566676869
r870717273747576777879
r980818283848586878889
r1090919293949596979899
\n", + "
" + ], + "text/plain": [ + " c1 c2 c3 c4 c5 c6 c7 c8 c9 c10\n", + "r1 0 1 2 3 4 5 6 7 8 9\n", + "r2 10 11 12 13 14 15 16 17 18 19\n", + "r3 20 21 22 23 24 25 26 27 28 29\n", + "r4 30 31 32 33 34 35 36 37 38 39\n", + "r5 40 41 42 43 44 45 46 47 48 49\n", + "r6 50 51 52 53 54 55 56 57 58 59\n", + "r7 60 61 62 63 64 65 66 67 68 69\n", + "r8 70 71 72 73 74 75 76 77 78 79\n", + "r9 80 81 82 83 84 85 86 87 88 89\n", + "r10 90 91 92 93 94 95 96 97 98 99" + ] + }, + "execution_count": 69, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.sort_values(by='c1', inplace=True)\n", + "df" + ] + }, + { + "cell_type": "markdown", + "id": "579b1486", + "metadata": {}, + "source": [ + "### 19. `groupby()`\n", + "This is used to group a Pandas DataFrame by 1 or more columns and perform some mathematical operations on them" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "77761c81", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.groupby(by='c3')" + ] + }, + { + "cell_type": "markdown", + "id": "405783bc", + "metadata": {}, + "source": [ + "### 20. `fillna()`\n", + "This helps to replace all NaN values in a DataFrame or Series by imputimg these values with more appropraite values" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "17d3fad0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
c1c2c3c4c5c6c7c8c9c10
r10123456789
r210111213141516171819
r320212223242526272829
r430313233343536373839
r540414243444546474849
r650515253545556575859
r760616263646566676869
r870717273747576777879
r980818283848586878889
r1090919293949596979899
\n", + "
" + ], + "text/plain": [ + " c1 c2 c3 c4 c5 c6 c7 c8 c9 c10\n", + "r1 0 1 2 3 4 5 6 7 8 9\n", + "r2 10 11 12 13 14 15 16 17 18 19\n", + "r3 20 21 22 23 24 25 26 27 28 29\n", + "r4 30 31 32 33 34 35 36 37 38 39\n", + "r5 40 41 42 43 44 45 46 47 48 49\n", + "r6 50 51 52 53 54 55 56 57 58 59\n", + "r7 60 61 62 63 64 65 66 67 68 69\n", + "r8 70 71 72 73 74 75 76 77 78 79\n", + "r9 80 81 82 83 84 85 86 87 88 89\n", + "r10 90 91 92 93 94 95 96 97 98 99" + ] + }, + "execution_count": 81, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df1['C3'].fillna(23, inplace=True)\n", + "df" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Personal_Work_Beatrice_Ejeh .ipynb b/Personal_Work_Beatrice_Ejeh .ipynb new file mode 100644 index 0000000..ec7dc3e --- /dev/null +++ b/Personal_Work_Beatrice_Ejeh .ipynb @@ -0,0 +1,373 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "f3698cc8", + "metadata": {}, + "source": [ + "Question 1: Print all the elements of a list using for loop" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "947f643f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n", + "20\n", + "30\n", + "40\n", + "50\n", + "60\n", + "70\n", + "80\n", + "90\n" + ] + } + ], + "source": [ + "my_list = [10, 20, 30, 40, 50, 60, 70, 80, 90]\n", + "\n", + "for i in my_list:\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "id": "9c178d8c", + "metadata": {}, + "source": [ + "Question 2: Using range(1,101), make two list, one containing all even numbers and\n", + "other containing all odd numbers" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "30ae5844", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Even numbers: [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, 100]\n" + ] + } + ], + "source": [ + "#List of all the even numbers in range (1,101)\n", + "def even_numbers(num):\n", + " even = []\n", + " i = 1\n", + " while i in range(1,101):\n", + " if i % 2 == 0:\n", + " even.append(i)\n", + " i = i+1\n", + " print(\"Even numbers:\", even)\n", + "num =101\n", + "even_numbers(num)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "41946247", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Odd numbers: [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]\n" + ] + } + ], + "source": [ + "#List of all the odd numbers in range (1,101)\n", + "def odd_numbers(num):\n", + " odd = []\n", + " i = 1\n", + " while i in range(1,101):\n", + " if i % 2 != 0:\n", + " odd.append(i)\n", + " i = i+1\n", + " print(\"Odd numbers:\", odd)\n", + "num =101\n", + "odd_numbers(num)" + ] + }, + { + "cell_type": "markdown", + "id": "a3a39f22", + "metadata": {}, + "source": [ + "Question 3: A company decided to give bonus of 5% to employee if his/her year of service is more than 5\n", + "years. Ask user for their salary and year of service and print the net bonus amount" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "781e83ef", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Enter Salary:\n", + "80000\n", + "Enter years of service:\n", + "7\n", + "Bonus is: 4000.0\n" + ] + } + ], + "source": [ + "print('Enter Salary:')\n", + "Salary = int(input())\n", + "print('Enter years of service:')\n", + "years_of_service = int(input())\n", + "\n", + "if years_of_service > 5:\n", + " print('Bonus is:', 0.05*Salary)\n", + "else:\n", + " print('No bonus!')" + ] + }, + { + "cell_type": "markdown", + "id": "66cec1b6", + "metadata": {}, + "source": [ + "Question 4: Take input of age of 3 people by user and determine oldest and youngest among them" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "d28188ba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Enter the age of the Person 1:15\n", + "Enter the age of the Person 2:20\n", + "Enter the age of the Person 3:10\n", + "Person 2 is the oldest\n", + "Person 3 is the youngest\n" + ] + } + ], + "source": [ + "age_1 = int(input('Enter the age of the Person 1:'))\n", + "age_2 = int(input('Enter the age of the Person 2:'))\n", + "age_3 = int(input('Enter the age of the Person 3:'))\n", + "\n", + "if age_1 > age_2 and age_1 > age_3:\n", + " print('Person 1 is the oldest')\n", + " \n", + " if age_2 < age_3:\n", + " print('Person 2 is the youngest')\n", + " else:\n", + " print('Person 3 is the youngest')\n", + "elif age_2 > age_1 and age_2 > age_3:\n", + " print('Person 2 is the oldest')\n", + " \n", + " if age_1 < age_3:\n", + " print('Person 1 is the youngest')\n", + " else:\n", + " print('Person 3 is the youngest')\n", + "else:\n", + " print('Person 3 is the oldest')\n", + " if age_1 < age_2:\n", + " print('Person 1 is the youngest')\n", + " else:\n", + " print('Person 2 is the youngest')" + ] + }, + { + "cell_type": "markdown", + "id": "0fa63093", + "metadata": {}, + "source": [ + "Question 5: A school has following rules for grading system:" + ] + }, + { + "cell_type": "raw", + "id": "71e90a6c", + "metadata": {}, + "source": [ + "a. Below 25 - F\n", + "b. 25 to 45 - E\n", + "c. 45 to 50 - D\n", + "d. 50 to 60 - C\n", + "e. 60 to 80 - B\n", + "f. Above 80 - A" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "ba925378", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Enter the marks obtained in the subject:\n", + "-10\n", + "Invalid Input!\n" + ] + } + ], + "source": [ + "#Ask user to enter marks and print the corresponding grade\n", + "print ('Enter the marks obtained in the subject:')\n", + "mark_obtained = int(input())\n", + "\n", + "if mark_obtained >= 80 and mark_obtained <= 100:\n", + " print('Your grade is A')\n", + "elif mark_obtained >= 60 and mark_obtained < 80:\n", + " print('Your grade is B')\n", + "elif mark_obtained >= 50 and mark_obtained < 60:\n", + " print('Your grade is C')\n", + "elif mark_obtained >= 45 and mark_obtained < 50:\n", + " print('Your grade is D')\n", + "elif mark_obtained >= 25 and mark_obtained < 45:\n", + " print('Your grade is E')\n", + "elif mark_obtained >= 0 and mark_obtained < 25:\n", + " print('Your grade is F')\n", + "else:\n", + " print('Invalid Input!')" + ] + }, + { + "cell_type": "markdown", + "id": "061fc301", + "metadata": {}, + "source": [ + "Question 6: Write a Python script to merge two Python dictionaries" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "ff293f58", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'a': 10, 'b': 20, 'c': 30, 'd': 40, 'w': 50, 'x': 60, 'y': 70, 'z': 80}\n" + ] + } + ], + "source": [ + "dict_1 = {'a': 10, 'b': 20, 'c':30, 'd': 40}\n", + "dict_2 = {'w': 50, 'x': 60, 'y':70, 'z': 80}\n", + "\n", + "dict_3 = dict_1.copy()\n", + "\n", + "for key, value in dict_2.items():\n", + " dict_3[key] = value\n", + "print(dict_3)" + ] + }, + { + "cell_type": "markdown", + "id": "9d55fe8d", + "metadata": {}, + "source": [ + "Question 7: Write a Python program to remove a key from a dictionary" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "3439fdc8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'m': 50, 'n': 100, 'o': 150, 'p': 200}\n", + "{'m': 50, 'o': 150, 'p': 200}\n" + ] + } + ], + "source": [ + "my_dict = {'m': 50, 'n': 100, 'o': 150, 'p':200}\n", + "print(my_dict)\n", + "if 'n' in my_dict:\n", + " del my_dict['n']\n", + "print(my_dict)" + ] + }, + { + "cell_type": "markdown", + "id": "1fbedfb4", + "metadata": {}, + "source": [ + "Question 8: Write a Python program to get the largest number from a list" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "59f77d83", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "75\n" + ] + } + ], + "source": [ + "def largest_num_in_list (list):\n", + " largest = list[0]\n", + " for a in list:\n", + " if a > largest:\n", + " largest = a \n", + " return largest\n", + "print(largest_num_in_list([-10, 20, -5, 60, 75]))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}