CodeCow/30-Days-Of-Python
1
0
Fork 0
mirror of https://github.com/Asabeneh/30-Days-Of-Python.git synced 2026-06-12 21:01:48 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
954cf2d680
30-Days-Of-Python/test.ipynb
Asabeneh 954cf2d680 day 24 fixes
2019-12-13 21:04:24 +02:00

2607 lines
96 KiB
Plaintext
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# 📘 Day 24\n",
"\n",
"# Python for Statistical Analysis\n",
"\n",
"## Statistics\n",
"\n",
"Statistics is the discipline that studies the _collection_, _organization_, _displaying_, _analysis_, _interpretation_ and _presentation_ of data.\n",
"Statistics is a branch of mathematics that is recommended to be a prerequisite for data science and machine learning. Statistics is a very broad field but we will focus in this section only on the most relevant part.\n",
"After completing this challenge, you may go to web development, data analysis, machine learning and data science path. Whatever path you may follow, at some point in your career you will get data which you may work on. Having some statistical knowledge will help you to make decision based on data, *data tells as they say*.\n",
"## Data\n",
"\n",
"What is data? Data is any set of characters that is gathered and translated for some purpose, usually analysis. It can be any character, including text and numbers, pictures, sound, or video. If data is not put into context, it doesn't give any sense to a human or computer. To make sense from data we need to work on the data using different tools.\n",
"\n",
"The work flow of data analysis, data science or machine learning starts from data. Data can be provided from some data source or it can be created. There are structured and and unstructure data. \n",
"\n",
"Data can be found as small or big data format. Most of the data types we will get have been covered in the file handling section.\n",
"\n",
"## Statistics Module\n",
"\n",
"The python _statistics_ module provides functions for calculating mathematical statistics of numeric data. The module is not intended to be a competitor to third-party libraries such as NumPy, SciPy, or proprietary full-featured statistics packages aimed at professional statisticians such as Minitab, SAS and Matlab. It is aimed at the level of graphing and scientific calculators.\n",
"\n",
"# NumPy\n",
"\n",
"In the first section we defined python as a great general-purpose programming language on its own, but with the help of other popular libraries (numpy, scipy, matplotlib, pandas etc) it becomes a powerful environment for scientific computing.\n",
"\n",
"Numpy is the core library for scientific computing in Python. It provides a high-performance multidimensional array object, and tools for working with arrays.\n",
"\n",
"So far, we have been using vscode but from now on I would recommend using Jupyter Notebook. To access jupter notebook let's install [anaconda](https://www.anaconda.com/). If you are using anaconda most of the common packages are included and you don't have install packages if you installed anaconda."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"asabeneh@Asabeneh:~/Desktop/30DaysOfPython$ pip install numpy"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Importing NumPy\n",
"\n",
"Jupyter notebook is available if your are in favor of [jupyter notebook](https://github.com/Asabeneh/data-science-for-everyone/blob/master/numpy/numpy.ipynb)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"attributes": {
"classes": [
"py"
],
"id": ""
}
},
"outputs": [],
"source": [
"# How to import numpy\n",
"import numpy as np\n",
"# How to check the version of the numpy package\n",
"print('numpy:', np.__version__)\n",
"# Checking the available methods\n",
"print(dir(np))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Creating numpy array using\n",
"\n",
"### Creating int numpy arrays"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"attributes": {
"classes": [
"py"
],
"id": ""
}
},
"outputs": [],
"source": [
"# Creating python List\n",
"python_list = [1,2,3,4,5]\n",
"\n",
"# Checking data types\n",
"print('Type:', type (python_list)) # <class 'list'>\n",
"# \n",
"print(python_list) # [1, 2, 3, 4, 5]\n",
"\n",
"two_dimensional_list = [[0,1,2], [3,4,5], [6,7,8]]\n",
"\n",
"print(two_dimensional_list) # [[0, 1, 2], [3, 4, 5], [6, 7, 8]]\n",
"\n",
"# Creating Numpy(Numerical Python) array from python list\n",
"\n",
"numpy_array_from_list = np.array(python_list) \n",
"print(type (numpy_array_from_list)) # <class 'numpy.ndarray'>\n",
"print(numpy_array_from_list) # array([1, 2, 3, 4, 5])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Creating float numpy arrays\n",
"Creating a float numpy array from list with a float data type parameter"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"attributes": {
"classes": [
"py"
],
"id": ""
}
},
"outputs": [],
"source": [
"# Python list\n",
"python_list = [1,2,3,4,5]\n",
"\n",
"numy_array_from_list2 = np.array(python_list, dtype=float)\n",
"print(numy_array_from_list2) # array([1., 2., 3., 4., 5.])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Creating boolean numpy arrays\n",
"Creating a boolean a numpy array from list "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"attributes": {
"classes": [
"py"
],
"id": ""
}
},
"outputs": [],
"source": [
"numpy_bool_array = np.array([0, 1, -1, 0, 0], dtype=bool)\n",
"print(numpy_bool_array) # array([False, True, True, False, False])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Creating multidimensional array using numpy\n",
"A numpy array may have one or multiple rors and columns"
]
},
{
"cell_type": "code",
"execution_count": 152,
"metadata": {
"attributes": {
"classes": [
"py"
],
"id": ""
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'numpy.ndarray'>\n",
"[[0 1 2]\n",
" [3 4 5]\n",
" [6 7 8]]\n"
]
}
],
"source": [
"two_dimensional_list = [[0,1,2], [3,4,5], [6,7,8]]\n",
"numpy_two_dimensional_list = np.array(two_dimensional_list)\n",
"print(type (numpy_two_dimensional_list))\n",
"print(numpy_two_dimensional_list)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Converting numpy array to list"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"attributes": {
"classes": [
"py"
],
"id": ""
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'list'>\n",
"one dimensional array: [1, 2, 3, 4, 5]\n",
"two dimensional array: [[0, 1, 2], [3, 4, 5], [6, 7, 8]]\n"
]
}
],
"source": [
"# We can always convert an array back to a python list using tolist().\n",
"np_to_list = numpy_array_from_list.tolist()\n",
"print(type (np_to_list))\n",
"print('one dimensional array:', np_to_list)\n",
"print('two dimensional array: ', numpy_two_dimensional_list.tolist())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Creating numpy array from tuple"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"attributes": {
"classes": [
"py"
],
"id": ""
}
},
"outputs": [],
"source": [
"# Numpy array from tuple\n",
"# Creating tuple in Python\n",
"\n",
"python_tuple = (1,2,3,4,5)\n",
"print(type (python_tuple)) # <class 'tuple'>\n",
"print('python_tuple: ', python_tuple) # python_tuple: (1, 2, 3, 4, 5)\n",
"\n",
"numpy_array_from_tuple = np.array(python_tuple)\n",
"print(type (numpy_array_from_tuple)) # <class 'numpy.ndarray'>\n",
"print('numpy_array_from_tuple: ', numpy_array_from_tuple) # numpy_array_from_tuple: [1 2 3 4 5]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Shape of numpy array\n",
"\n",
"The shape method provide the shape of the array as a tuple. The first is the row and the second is the column. If the array is just one dimensional it returns the size of the array."
]
},
{
"cell_type": "code",
"execution_count": 153,
"metadata": {
"attributes": {
"classes": [
"py"
],
"id": ""
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1 2 3 4 5]\n",
"shape of nums: (5,)\n",
"[[0 1 2]\n",
" [3 4 5]\n",
" [6 7 8]]\n",
"shape of numpy_two_dimensional_list: (3, 3)\n",
"(3, 4)\n"
]
}
],
"source": [
"nums = np.array([1, 2, 3, 4, 5])\n",
"print(nums)\n",
"print('shape of nums: ', nums.shape)\n",
"print(numpy_two_dimensional_list)\n",
"print('shape of numpy_two_dimensional_list: ', numpy_two_dimensional_list.shape)\n",
"three_by_four_array = np.array([[0, 1, 2, 3],\n",
" [4,5,6,7],\n",
" [8,9,10, 11]])\n",
"print(three_by_four_array.shape)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Data type of numpy array\n",
"\n",
"Type of data types: str, int, float, complex, bool, list, None"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"attributes": {
"classes": [
"py"
],
"id": ""
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[-3 -2 -1 0 1 2 3]\n",
"int64\n",
"[-3. -2. -1. 0. 1. 2. 3.]\n",
"float64\n"
]
}
],
"source": [
"int_lists = [-3, -2, -1, 0, 1, 2,3]\n",
"int_array = np.array(int_lists)\n",
"float_array = np.array(int_lists, dtype=float)\n",
"\n",
"print(int_array)\n",
"print(int_array.dtype)\n",
"print(float_array)\n",
"print(float_array.dtype)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Size of a numpy array\n",
"In numpy to know the number of items in a numpy array list we use size"
]
},
{
"cell_type": "code",
"execution_count": 157,
"metadata": {
"attributes": {
"classes": [
"py"
],
"id": ""
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The size: 5\n",
"The size: 9\n"
]
}
],
"source": [
"numpy_array_from_list = np.array([1, 2, 3, 4, 5])\n",
"two_dimensional_list = np.array([[0, 1, 2],\n",
" [3, 4, 5],\n",
" [6, 7, 8]])\n",
"\n",
"print('The size:', numpy_array_from_list.size) # 5\n",
"print('The size:', two_dimensional_list.size) # 3\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Mathematical Operation using numpy\n",
"\n",
"Numpy array is not like exactly like python list. To do mathematical operation in pyhton list we have to loop through the items but numpy can allow to do any mathematical operation without looping.\n",
"Mathematical Operation:\n",
"* Addition (+)\n",
"* Subtraction (-)\n",
"* Multiplication (*)\n",
"* Division (/)\n",
"* Modules (%)\n",
"* Floor Division(//)\n",
"* Exponential(**)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Addition"
]
},
{
"cell_type": "code",
"execution_count": 165,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"original array: [1 2 3 4 5]\n",
"[11 12 13 14 15]\n"
]
}
],
"source": [
"# Mathematical Operation\n",
"# Addition\n",
"numpy_array_from_list = np.array([1, 2, 3, 4, 5])\n",
"print('original array: ', numpy_array_from_list)\n",
"ten_plus_original = numpy_array_from_list + 10\n",
"print(ten_plus_original)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Subtraction"
]
},
{
"cell_type": "code",
"execution_count": 166,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"original array: [1 2 3 4 5]\n",
"[-9 -8 -7 -6 -5]\n"
]
}
],
"source": [
"# Subtraction\n",
"numpy_array_from_list = np.array([1, 2, 3, 4, 5])\n",
"print('original array: ', numpy_array_from_list)\n",
"ten_minus_original = numpy_array_from_list - 10\n",
"print(ten_minus_original)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Multiplication"
]
},
{
"cell_type": "code",
"execution_count": 171,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"original array: [1 2 3 4 5]\n",
"[10 20 30 40 50]\n"
]
}
],
"source": [
"# Multiplication\n",
"numpy_array_from_list = np.array([1, 2, 3, 4, 5])\n",
"print('original array: ', numpy_array_from_list)\n",
"ten_times_original = numpy_array_from_list * 10\n",
"print(ten_times_original)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Division"
]
},
{
"cell_type": "code",
"execution_count": 172,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"original array: [1 2 3 4 5]\n",
"[0.1 0.2 0.3 0.4 0.5]\n"
]
}
],
"source": [
"# Division\n",
"numpy_array_from_list = np.array([1, 2, 3, 4, 5])\n",
"print('original array: ', numpy_array_from_list)\n",
"ten_times_original = numpy_array_from_list / 10\n",
"print(ten_times_original)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Modulous"
]
},
{
"cell_type": "code",
"execution_count": 173,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"original array: [1 2 3 4 5]\n",
"[1 2 0 1 2]\n"
]
}
],
"source": [
"# Modulous; Finding the remainder\n",
"numpy_array_from_list = np.array([1, 2, 3, 4, 5])\n",
"print('original array: ', numpy_array_from_list)\n",
"ten_times_original = numpy_array_from_list % 3\n",
"print(ten_times_original)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Floor Division"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Floor division: the division result without the remainder\n",
"numpy_array_from_list = np.array([1, 2, 3, 4, 5])\n",
"print('original array: ', numpy_array_from_list)\n",
"ten_times_original = numpy_array_from_list // 10\n",
"print(ten_times_original)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Exponential"
]
},
{
"cell_type": "code",
"execution_count": 175,
"metadata": {
"attributes": {
"classes": [
"py"
],
"id": ""
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"original array: [1 2 3 4 5]\n",
"[ 1 4 9 16 25]\n"
]
}
],
"source": [
"# Exponential is finding some number the power of another:\n",
"numpy_array_from_list = np.array([1, 2, 3, 4, 5])\n",
"print('original array: ', numpy_array_from_list)\n",
"ten_times_original = numpy_array_from_list ** 2\n",
"print(ten_times_original)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Checking data types"
]
},
{
"cell_type": "code",
"execution_count": 181,
"metadata": {
"attributes": {
"classes": [
"py"
],
"id": ""
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"int64\n",
"float64\n",
"bool\n"
]
}
],
"source": [
"#Int, Float numbers\n",
"\n",
"numpy_int_arr = np.array([1,2,3,4])\n",
"numpy_float_arr = np.array([1.1, 2.0,3.2])\n",
"numpy_bool_arr = np.array([-3, -2, 0, 1,2,3], dtype='bool')\n",
"\n",
"print(numpy_int_arr.dtype)\n",
"print(numpy_float_arr.dtype)\n",
"print(numpy_bool_arr.dtype)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Converting types\n",
"\n",
"We can convert the data types of numpy array\n",
"1. Int to Float"
]
},
{
"cell_type": "code",
"execution_count": 184,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1., 2., 3., 4.])"
]
},
"execution_count": 184,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"numpy_int_arr = np.array([1,2,3,4], dtype = 'float')\n",
"numpy_int_arr"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"2. Float to Int"
]
},
{
"cell_type": "code",
"execution_count": 185,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 2, 3, 4])"
]
},
"execution_count": 185,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"numpy_int_arr = np.array([1., 2., 3., 4.], dtype = 'int')\n",
"numpy_int_arr"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"3. Int ot boolean"
]
},
{
"cell_type": "code",
"execution_count": 186,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ True, True, False, True, True, True])"
]
},
"execution_count": 186,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.array([-3, -2, 0, 1,2,3], dtype='bool')\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"attributes": {
"classes": [
"py"
],
"id": ""
}
},
"source": [
"4. Int to str\n"
]
},
{
"cell_type": "code",
"execution_count": 190,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array(['1', '2', '3'], dtype='<U21')"
]
},
"execution_count": 190,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"numpy_float_list.astype('int').astype('str')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Multi-dimensional Arrays"
]
},
{
"cell_type": "code",
"execution_count": 191,
"metadata": {
"attributes": {
"classes": [
"py"
],
"id": ""
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'numpy.ndarray'>\n",
"[[1 2 3]\n",
" [4 5 6]\n",
" [7 8 9]]\n",
"Shape: (3, 3)\n",
"Size: 9\n",
"Data type: int64\n"
]
}
],
"source": [
"# 2 Dimension Array\n",
"two_dimension_array = np.array([(1,2,3),(4,5,6), (7,8,9)])\n",
"print(type (two_dimension_array))\n",
"print(two_dimension_array)\n",
"print('Shape: ', two_dimension_array.shape)\n",
"print('Size:', two_dimension_array.size)\n",
"print('Data type:', two_dimension_array.dtype)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Getting items from a numpy array"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"attributes": {
"classes": [
"py"
],
"id": ""
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"First row: [1 2 3]\n",
"Second row: [4 5 6]\n",
"Third row: [7 8 9]\n"
]
}
],
"source": [
"# 2 Dimension Array\n",
"two_dimension_array = np.array([[1,2,3],[4,5,6], [7,8,9]])\n",
"first_row = two_dimension_array[0]\n",
"second_row = two_dimension_array[1]\n",
"third_row = two_dimension_array[2]\n",
"print('First row:', first_row)\n",
"print('Second row:', second_row)\n",
"print('Third row: ', third_row)"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"attributes": {
"classes": [
"py"
],
"id": ""
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"First column: [1 4 7]\n",
"Second column: [2 5 8]\n",
"Third column: [3 6 9]\n",
"[[1 2 3]\n",
" [4 5 6]\n",
" [7 8 9]]\n"
]
}
],
"source": [
"first_column= two_dimension_array[:,0]\n",
"second_column = two_dimension_array[:,1]\n",
"third_column = two_dimension_array[:,2]\n",
"print('First column:', first_column)\n",
"print('Second column:', second_column)\n",
"print('Third column: ', third_column)\n",
"print(two_dimension_array)\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Slicing Numpy array\n",
"\n",
"Slicing in numpy is similar to slicing in python list"
]
},
{
"cell_type": "code",
"execution_count": 193,
"metadata": {
"attributes": {
"classes": [
"py"
],
"id": ""
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[1 2]\n",
" [4 5]]\n"
]
}
],
"source": [
"two_dimension_array = np.array([[1,2,3],[4,5,6], [7,8,9]])\n",
"first_two_rows_and_columns = two_dimension_array[0:2, 0:2]\n",
"print(first_two_rows_and_columns)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### How to reverse the rows and the whole array?"
]
},
{
"cell_type": "code",
"execution_count": 195,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[1, 2, 3],\n",
" [4, 5, 6],\n",
" [7, 8, 9]])"
]
},
"execution_count": 195,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"two_dimension_array[::]\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Reverse the row and column positions"
]
},
{
"cell_type": "code",
"execution_count": 196,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[9, 8, 7],\n",
" [6, 5, 4],\n",
" [3, 2, 1]])"
]
},
"execution_count": 196,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"two_dimension_array = np.array([[1,2,3],[4,5,6], [7,8,9]])\n",
"two_dimension_array[::-1,::-1]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## How to represent missing values and infinite?"
]
},
{
"cell_type": "code",
"execution_count": 42,
"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 55 44]\n",
" [ 7 8 9]]\n"
]
}
],
"source": [
"print(two_dimension_array)\n",
"two_dimension_array[1,1] = 55\n",
"two_dimension_array[1,2] =44\n",
"print(two_dimension_array)"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0, 0, 0],\n",
" [0, 0, 0],\n",
" [0, 0, 0]])"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Numpy Zeroes\n",
"# numpy.zeros(shape, dtype=float, order='C')\n",
"numpy_zeroes = np.zeros((3,3),dtype=int,order='C')\n",
"numpy_zeroes"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[1 1 1]\n",
" [1 1 1]\n",
" [1 1 1]]\n"
]
}
],
"source": [
"# Numpy Zeroes\n",
"numpy_ones = np.ones((3,3),dtype=int,order='C')\n",
"print(numpy_ones)"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {},
"outputs": [],
"source": [
"twoes = numpy_ones * 2"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[1 2 3]\n",
" [4 5 6]]\n",
"[[1 2]\n",
" [3 4]\n",
" [5 6]]\n"
]
}
],
"source": [
"# Reshape\n",
"# numpy.reshape(), numpy.flatten()\n",
"first_shape = np.array([(1,2,3), (4,5,6)])\n",
"print(first_shape)\n",
"reshaped = first_shape.reshape(3,2)\n",
"print(reshaped)\n"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 2, 3, 4, 5, 6])"
]
},
"execution_count": 51,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"flattened = reshaped.flatten()\n",
"flattened"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[5 7 9]\n",
"Horizontal Append: [1 2 3 4 5 6]\n"
]
}
],
"source": [
"## Horitzontal Stack\n",
"np_list_one = np.array([1,2,3])\n",
"np_list_two = np.array([4,5,6])\n",
"\n",
"print(np_list_one + np_list_two)\n",
"\n",
"print('Horizontal Append:', np.hstack((np_list_one, np_list_two)))"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Vertical Append: [[1 2 3]\n",
" [4 5 6]]\n"
]
}
],
"source": [
"## Vertical Stack\n",
"print('Vertical Append:', np.vstack((np_list_one, np_list_two)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Generating Random Numbers"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.018929887384753874"
]
},
"execution_count": 57,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Generate a random float number\n",
"random_float = np.random.random()\n",
"random_float"
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.6661632875670657"
]
},
"execution_count": 58,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"0.6661632875670657"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([0.26392192, 0.35842215, 0.87908478, 0.41902195, 0.78926418])"
]
},
"execution_count": 59,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Generate a random float number\n",
"random_floats = np.random.random(5)\n",
"random_floats"
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"4"
]
},
"execution_count": 61,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Generating a random integers between 0 and 10\n",
"random_int = np.random.randint(0, 11)\n",
"random_int"
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"7"
]
},
"execution_count": 62,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"7"
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([8, 8, 8, 2])"
]
},
"execution_count": 63,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Generating a random integers between 2 and 11, and creating a one row array\n",
"random_int = np.random.randint(2,10, size=4)\n",
"random_int"
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[3, 5, 3],\n",
" [7, 3, 6],\n",
" [2, 3, 3]])"
]
},
"execution_count": 65,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Generating a random integers between 0 and 10\n",
"random_int = np.random.randint(2,10, size=(3,3))\n",
"random_int"
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 89.49990595, 82.06056961, 107.21445842, 38.69307086,\n",
" 47.85259157, 93.07381061, 76.40724259, 78.55675184,\n",
" 72.17358173, 47.9888899 , 65.10370622, 76.29696568,\n",
" 95.58234254, 68.14897213, 38.75862686, 122.5587927 ,\n",
" 67.0762565 , 95.73990864, 81.97454563, 92.54264805,\n",
" 59.37035153, 77.76828101, 52.30752166, 64.43109931,\n",
" 62.63695351, 90.04616138, 75.70009094, 49.87586877,\n",
" 80.22002414, 68.56708848, 76.27791052, 67.24343975,\n",
" 81.86363935, 78.22703433, 102.85737041, 65.15700341,\n",
" 84.87033426, 76.7569997 , 64.61321853, 67.37244562,\n",
" 74.4068773 , 58.65119655, 71.66488727, 53.42458179,\n",
" 70.26872028, 60.96588544, 83.56129414, 72.14255326,\n",
" 81.00787609, 71.81264853, 72.64168853, 86.56608717,\n",
" 94.94667321, 82.32676973, 70.5165446 , 85.43061003,\n",
" 72.45526212, 87.34681775, 87.69911217, 103.02831489,\n",
" 75.28598596, 67.17806893, 92.41274447, 101.06662611,\n",
" 87.70013935, 70.73980645, 46.40368207, 50.17947092,\n",
" 61.75618542, 90.26191397, 78.63968639, 70.84550744,\n",
" 88.91826581, 103.91474733, 66.3064638 , 79.49726264,\n",
" 70.81087439, 83.90130623, 87.58555972, 59.95462521])"
]
},
"execution_count": 67,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Generate random numbers\n",
"# np.random.normal(mu, sigma, size)\n",
"normal_array = np.random.normal(79, 15, 80)\n",
"normal_array\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Numpy and Statistics"
]
},
{
"cell_type": "code",
"execution_count": 69,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(array([2., 0., 0., 0., 1., 2., 2., 0., 2., 0., 0., 1., 2., 2., 1., 4., 3.,\n",
" 4., 2., 7., 2., 2., 5., 4., 2., 4., 3., 2., 1., 5., 3., 0., 3., 2.,\n",
" 1., 0., 0., 1., 3., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 1.]),\n",
" array([ 38.69307086, 40.37038529, 42.04769973, 43.72501417,\n",
" 45.4023286 , 47.07964304, 48.75695748, 50.43427191,\n",
" 52.11158635, 53.78890079, 55.46621523, 57.14352966,\n",
" 58.8208441 , 60.49815854, 62.17547297, 63.85278741,\n",
" 65.53010185, 67.20741628, 68.88473072, 70.56204516,\n",
" 72.23935959, 73.91667403, 75.59398847, 77.27130291,\n",
" 78.94861734, 80.62593178, 82.30324622, 83.98056065,\n",
" 85.65787509, 87.33518953, 89.01250396, 90.6898184 ,\n",
" 92.36713284, 94.04444727, 95.72176171, 97.39907615,\n",
" 99.07639058, 100.75370502, 102.43101946, 104.1083339 ,\n",
" 105.78564833, 107.46296277, 109.14027721, 110.81759164,\n",
" 112.49490608, 114.17222052, 115.84953495, 117.52684939,\n",
" 119.20416383, 120.88147826, 122.5587927 ]),\n",
" <a list of 50 Patch objects>)"
]
},
"execution_count": 69,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import matplotlib.pyplot as plt\n",
"import seaborn as sns\n",
"sns.set()\n",
"plt.hist(normal_array, color=\"grey\", bins=50)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# numpy.asarray()\n",
"# Asarray\n",
"# The asarray()function is used when you want to convert an input to an array.\n",
"# The input could be a lists, tuple, ndarray, etc."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"four_by_four_matrix = np.matrix(np.ones((4,4), dtype=float))"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"four_by_four_matrix"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"matrix([[1., 1., 1., 1.],\n",
" [1., 1., 1., 1.],\n",
" [1., 1., 1., 1.],\n",
" [1., 1., 1., 1.]])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"np.asarray(four_by_four_matrix)[2] = 2\n",
"four_by_four_matrix"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"matrix([[1., 1., 1., 1.],\n",
" [1., 1., 1., 1.],\n",
" [2., 2., 2., 2.],\n",
" [1., 1., 1., 1.]])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# numpy.arange() in Python with Example\n",
"# Whay is Arrange?\n",
"# Sometimes, you want to create values that are evenly spaced within a defined interval.\n",
"# For instance, you want to create values from 1 to 10; you can use numpy.arange() function\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# creating list using range(starting, stop, step)\n",
"lst = range(0, 11, 2)\n",
"lst"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"range(0, 11, 2)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"for l in lst:\n",
" print(l)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"0\n",
" 2\n",
" 4\n",
" 6\n",
" 8\n",
" 10"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Similar to range arange numpy.arange(start, stop, step)\n",
"whole_numbers = np.arange(0, 20, 1)\n",
"whole_numbers"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,\n",
" 17, 18, 19])"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"natural_numbers = np.arange(1, 20, 1)\n",
"natural_numbers"
]
},
{
"cell_type": "code",
"execution_count": 72,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 1, 3, 5, 7, 9, 11, 13, 15, 17, 19])"
]
},
"execution_count": 72,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"odd_numbers = np.arange(1, 20, 2)\n",
"odd_numbers"
]
},
{
"cell_type": "code",
"execution_count": 74,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 2, 4, 6, 8, 10, 12, 14, 16, 18])"
]
},
"execution_count": 74,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"even_numbers = np.arange(2, 20, 2)\n",
"even_numbers"
]
},
{
"cell_type": "code",
"execution_count": 76,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1. , 1.44444444, 1.88888889, 2.33333333, 2.77777778,\n",
" 3.22222222, 3.66666667, 4.11111111, 4.55555556, 5. ])"
]
},
"execution_count": 76,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# numpy.linspace()\n",
"# numpy.logspace() in Python with Example\n",
"# For instance, it can be used to create 10 values from 1 to 5 evenly spaced.\n",
"np.linspace(1.0, 5.0, num=10)"
]
},
{
"cell_type": "code",
"execution_count": 78,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1. , 1.8, 2.6, 3.4, 4.2])"
]
},
"execution_count": 78,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# not to include the last value in the interval\n",
"np.linspace(1.0, 5.0, num=5, endpoint=False)"
]
},
{
"cell_type": "code",
"execution_count": 80,
"metadata": {},
"outputs": [],
"source": [
"# LogSpace\n",
"# LogSpace returns even spaced numbers on a log scale. Logspace has the same parameters as np.linspace.\n",
"\n",
"# Syntax:\n",
"\n",
"# numpy.logspace(start, stop, num, endpoint)"
]
},
{
"cell_type": "code",
"execution_count": 81,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 100. , 464.15888336, 2154.43469003, 10000. ])"
]
},
"execution_count": 81,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.logspace(2, 4.0, num=4)"
]
},
{
"cell_type": "code",
"execution_count": 83,
"metadata": {},
"outputs": [],
"source": [
"# to check the size of an array\n",
"x = np.array([1,2,3], dtype=np.complex128)"
]
},
{
"cell_type": "code",
"execution_count": 84,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1.+0.j, 2.+0.j, 3.+0.j])"
]
},
"execution_count": 84,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x"
]
},
{
"cell_type": "code",
"execution_count": 86,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"16"
]
},
"execution_count": 86,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x.itemsize"
]
},
{
"cell_type": "code",
"execution_count": 87,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"16"
]
},
"execution_count": 87,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"16"
]
},
{
"cell_type": "code",
"execution_count": 88,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[1, 2, 3],\n",
" [4, 5, 6]])"
]
},
"execution_count": 88,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# indexing and Slicing NumPy Arrays in Python\n",
"np_list = np.array([(1,2,3), (4,5,6)])\n",
"np_list\n"
]
},
{
"cell_type": "code",
"execution_count": 90,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"First row: [1 2 3]\n",
"Second row: [4 5 6]\n"
]
}
],
"source": [
"print('First row: ', np_list[0])\n",
"print('Second row: ', np_list[1])\n"
]
},
{
"cell_type": "code",
"execution_count": 92,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"First column: [1 4]\n",
"Second column: [2 5]\n",
"Third column: [3 6]\n"
]
}
],
"source": [
"print('First column: ', np_list[:,0])\n",
"print('Second column: ', np_list[:,1])\n",
"print('Third column: ', np_list[:,2])\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### NumPy Statistical Functions with Example\n",
"\n",
"NumPy has quite useful statistical functions for finding minimum, maximum, mean, median, percentile,standard deviation and variance, etc from the given elements in the array.\n",
"The functions are explained as follows −\n",
"Statistical function\n",
"Numpy is equipped with the robust statistical function as listed below\n",
"\n",
"- Numpy Functions\n",
" - Min np.min()\n",
" - Max np.max()\n",
" - Mean np.mean()\n",
" - Median np.median()\n",
" - Varience\n",
" - Percentile\n",
" - Standard deviation np.std()"
]
},
{
"cell_type": "code",
"execution_count": 94,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"min: 1\n",
"max: 55\n",
"mean: 14.777777777777779\n",
"sd: 18.913709183069525\n"
]
}
],
"source": [
"np_normal_dis = np.random.normal(5, 0.5, 100)\n",
"np_normal_dis\n",
"## min, max, mean, median, sd\n",
"print('min: ', two_dimension_array.min())\n",
"print('max: ', two_dimension_array.max())\n",
"print('mean: ',two_dimension_array.mean())\n",
"# print('median: ', two_dimension_array.median())\n",
"print('sd: ', two_dimension_array.std())"
]
},
{
"cell_type": "code",
"execution_count": 95,
"metadata": {},
"outputs": [],
"source": [
"min: 1\n",
"max: 55\n",
"mean: 14.777777777777779\n",
"sd: 18.913709183069525"
]
},
{
"cell_type": "code",
"execution_count": 96,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[ 1 2 3]\n",
" [ 4 55 44]\n",
" [ 7 8 9]]\n",
"Column with minimum: [1 2 3]\n",
"Column with maximum: [ 7 55 44]\n",
"=== Row ==\n",
"Row with minimum: [1 4 7]\n",
"Row with maximum: [ 3 55 9]\n"
]
}
],
"source": [
"print(two_dimension_array)\n",
"print('Column with minimum: ', np.amin(two_dimension_array,axis=0))\n",
"print('Column with maximum: ', np.amax(two_dimension_array,axis=0))\n",
"print('=== Row ==')\n",
"print('Row with minimum: ', np.amin(two_dimension_array,axis=1))\n",
"print('Row with maximum: ', np.amax(two_dimension_array,axis=1))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### How to create repeating sequences?"
]
},
{
"cell_type": "code",
"execution_count": 98,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Tile: [1 2 3 1 2 3]\n",
"Repeat: [1 1 2 2 3 3]\n"
]
}
],
"source": [
"a = [1,2,3]\n",
"\n",
"# Repeat whole of 'a' two times\n",
"print('Tile: ', np.tile(a, 2))\n",
"\n",
"# Repeat each element of 'a' two times\n",
"print('Repeat: ', np.repeat(a, 2))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### How to generate random numbers?"
]
},
{
"cell_type": "code",
"execution_count": 100,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.6149403282678213\n"
]
}
],
"source": [
"# One random number between [0,1)\n",
"one_random_num = np.random.random()\n",
"one_random_in = np.random\n",
"print(one_random_num)"
]
},
{
"cell_type": "code",
"execution_count": 101,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.4763968133790438"
]
},
"execution_count": 101,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"0.4763968133790438"
]
},
{
"cell_type": "code",
"execution_count": 102,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[0.13031737 0.4429537 0.1129527 ]\n",
" [0.76811539 0.88256594 0.6754075 ]]\n"
]
}
],
"source": [
"# Random numbers between [0,1) of shape 2,3\n",
"r = np.random.random(size=[2,3])\n",
"print(r)"
]
},
{
"cell_type": "code",
"execution_count": 104,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['u' 'o' 'o' 'i' 'e' 'e' 'u' 'o' 'u' 'a']\n"
]
}
],
"source": [
"print(np.random.choice(['a', 'e', 'i', 'o', 'u'], size=10))"
]
},
{
"cell_type": "code",
"execution_count": 105,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['iueoaieuoi']"
]
},
"execution_count": 105,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"['i' 'u' 'e' 'o' 'a' 'i' 'e' 'u' 'o' 'i']"
]
},
{
"cell_type": "code",
"execution_count": 106,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0.97992598, 0.79642484],\n",
" [0.65263629, 0.55763145]])"
]
},
"execution_count": 106,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"## Random numbers between [0, 1] of shape 2, 2\n",
"rand = np.random.rand(2,2)\n",
"rand"
]
},
{
"cell_type": "code",
"execution_count": 108,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 1.65593322, -0.52326621],\n",
" [ 0.39071179, -2.03649407]])"
]
},
"execution_count": 108,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"rand2 = np.random.randn(2,2)\n",
"rand2\n"
]
},
{
"cell_type": "code",
"execution_count": 110,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0, 7, 5],\n",
" [4, 1, 4],\n",
" [3, 5, 3],\n",
" [4, 3, 8],\n",
" [4, 6, 7]])"
]
},
"execution_count": 110,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Random integers between [0, 10) of shape 2,5\n",
"rand_int = np.random.randint(0, 10, size=[5,3])\n",
"rand_int"
]
},
{
"cell_type": "code",
"execution_count": 112,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"min: 3.557811005458804\n",
"max: 6.876317743643499\n",
"mean: 5.035832048106663\n",
"median: 5.020161980441937\n",
"mode: ModeResult(mode=array([3.55781101]), count=array([1]))\n",
"sd: 0.489682424165213\n"
]
}
],
"source": [
"from scipy import stats\n",
"np_normal_dis = np.random.normal(5, 0.5, 1000) # mean, standard deviation, number of samples\n",
"np_normal_dis\n",
"## min, max, mean, median, sd\n",
"print('min: ', np.min(np_normal_dis))\n",
"print('max: ', np.max(np_normal_dis))\n",
"print('mean: ', np.mean(np_normal_dis))\n",
"print('median: ', np.median(np_normal_dis))\n",
"print('mode: ', stats.mode(np_normal_dis))\n",
"print('sd: ', np.std(np_normal_dis))"
]
},
{
"cell_type": "code",
"execution_count": 198,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.hist(np_normal_dis, color=\"grey\", bins=21)\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 116,
"metadata": {},
"outputs": [],
"source": [
"# numpy.dot(): Dot Product in Python using Numpy\n",
"# Dot Product\n",
"# Numpy is powerful library for matrices computation. For instance, you can compute the dot product with np.dot\n",
"\n",
"# Syntax\n",
"\n",
"# numpy.dot(x, y, out=None)"
]
},
{
"cell_type": "code",
"execution_count": 117,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"14"
]
},
"execution_count": 117,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"## Linear algebra\n",
"### Dot product: product of two arrays\n",
"f = np.array([1,2])\n",
"g = np.array([4,5])\n",
"### 1*4+2*5\n",
"np.dot(f, g)"
]
},
{
"cell_type": "code",
"execution_count": 204,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"14"
]
},
"execution_count": 204,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"14"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Linear Algebra\n",
"1. Dot Product"
]
},
{
"cell_type": "code",
"execution_count": 119,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"23"
]
},
"execution_count": 119,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"## Linear algebra\n",
"### Dot product: product of two arrays\n",
"f = np.array([1,2,3])\n",
"g = np.array([4,5,3])\n",
"### 1*4+2*5 + 3*6\n",
"np.dot(f, g)"
]
},
{
"cell_type": "code",
"execution_count": 120,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"23"
]
},
"execution_count": 120,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"23"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### NumPy Matrix Multiplication with np.matmul()"
]
},
{
"cell_type": "code",
"execution_count": 122,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[19, 22],\n",
" [43, 50]])"
]
},
"execution_count": 122,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"### Matmul: matruc product of two arrays\n",
"h = [[1,2],[3,4]]\n",
"i = [[5,6],[7,8]]\n",
"### 1*5+2*7 = 19\n",
"np.matmul(h, i)"
]
},
{
"cell_type": "code",
"execution_count": 124,
"metadata": {},
"outputs": [],
"source": [
"## Determinant 2*2 matrix\n",
"### 5*8-7*6np.linalg.det(i)"
]
},
{
"cell_type": "code",
"execution_count": 125,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"-1.999999999999999"
]
},
"execution_count": 125,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.linalg.det(i)"
]
},
{
"cell_type": "code",
"execution_count": 126,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"-1.999999999999999"
]
},
"execution_count": 126,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"-1.999999999999999"
]
},
{
"cell_type": "code",
"execution_count": 127,
"metadata": {},
"outputs": [],
"source": [
"Z = np.zeros((8,8))\n",
"Z[1::2,::2] = 1\n",
"Z[::2,1::2] = 1"
]
},
{
"cell_type": "code",
"execution_count": 128,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0., 1., 0., 1., 0., 1., 0., 1.],\n",
" [1., 0., 1., 0., 1., 0., 1., 0.],\n",
" [0., 1., 0., 1., 0., 1., 0., 1.],\n",
" [1., 0., 1., 0., 1., 0., 1., 0.],\n",
" [0., 1., 0., 1., 0., 1., 0., 1.],\n",
" [1., 0., 1., 0., 1., 0., 1., 0.],\n",
" [0., 1., 0., 1., 0., 1., 0., 1.],\n",
" [1., 0., 1., 0., 1., 0., 1., 0.]])"
]
},
"execution_count": 128,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"Z"
]
},
{
"cell_type": "code",
"execution_count": 130,
"metadata": {},
"outputs": [],
"source": [
"new_list = [ x + 2 for x in range(0, 11)]"
]
},
{
"cell_type": "code",
"execution_count": 131,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]"
]
},
"execution_count": 131,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"new_list"
]
},
{
"cell_type": "code",
"execution_count": 132,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]"
]
},
"execution_count": 132,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]"
]
},
{
"cell_type": "code",
"execution_count": 209,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])"
]
},
"execution_count": 209,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np_arr = np.array(range(0, 11))\n",
"np_arr + 2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We use linear equation for quatities which have linear relationship. Let's see the example below:"
]
},
{
"cell_type": "code",
"execution_count": 210,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 7, 9, 11, 13, 15])"
]
},
"execution_count": 210,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"temp = np.array([1,2,3,4,5])\n",
"pressure = temp * 2 + 5\n",
"pressure"
]
},
{
"cell_type": "code",
"execution_count": 211,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.plot(temp,pressure)\n",
"plt.xlabel('Temperature in oC')\n",
"plt.ylabel('Pressure in atm')\n",
"plt.title('Temperature vs Pressure')\n",
"plt.xticks(np.arange(0, 6, step=0.5))\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To draw the Gaussian normal distribution using numpy. As you can see below, the numpy can generate random numbers. To create random sample, we need the mean(mu), sigma(standard deviation), mumber of data points."
]
},
{
"cell_type": "code",
"execution_count": 208,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"mu = 28\n",
"sigma = 15\n",
"samples = 100000\n",
"\n",
"x = np.random.normal(mu, sigma, samples)\n",
"ax = sns.distplot(x);\n",
"ax.set(xlabel=\"x\", ylabel='y')\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"# Summery\n",
"\n",
"To summarise, the main differences with python lists are:\n",
"\n",
"1. Arrays support vectorised operations, while lists don’t.\n",
"1. Once an array is created, you cannot change its size. You will have to create a new array or overwrite the existing one.\n",
"1. Every array has one and only one dtype. All items in it should be of that dtype.\n",
"1. An equivalent numpy array occupies much less space than a python list of lists.\n",
"1. numpy arrays support boolean indexing.\n",
"\n",
"## 💻 Exercises: Day 24\n",
"1. Repeat all the examples"
]
}
],
"metadata": {
"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.7.4"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
Reference in New Issue View Git Blame Copy Permalink