made some progress in the lecture part 1 of numpy

unit-7/lecture-part1.ipynb

@@ -27,6 +27,156 @@
     "  * Iterations"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Numpy\n",
+    "\n",
+    "* **What is Numpy?**\n",
+    "\n",
+    "A Python library for numerical computing that provides efficient operations on large arrays and matrices. The range of functions is similar to matlab\n",
+    "\n",
+    "* **Why Use NumPy Instead of Native Python** <br>\n",
+    "NumPy provides better performance, memory efficiency, and ease of use, making it the preferred choice for numerical computing tasks over native Python. <br>\n",
+    "    * **Why is Numpy faster?** <br>\n",
+    "        NumPy is written in C, a low-level programming language, which allows it to execute operations much faster than Python, which is an interpreted language."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Let's look at some numpy Code!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Numpy Arrays\n",
+    "* A NumPy array is a powerful data structure provided by the NumPy library, designed for numerical and scientific computing. It is similar to Python lists but much more efficient\n",
+    "<br>\n",
+    "<br>\n",
+    "* **Key characteristics of Numpy arrays**\n",
+    "\n",
+    "    * **Fixed Size:**\n",
+    "        Once created, the size of a NumPy array cannot change. This makes it more efficient compared to Python lists.\n",
+    "\n",
+    "    * **Homogeneous Data:**\n",
+    "        All elements in a NumPy array must be of the same data type (e.g., all integers or all floats). This allows NumPy to optimize memory usage and computation.\n",
+    "\n",
+    "    * **N-Dimensional:**\n",
+    "        NumPy arrays support multi-dimensional structures, making them suitable for handling vectors (1D), matrices (2D), or even tensors (3D and beyond)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Creating a NumPy Array\n",
+    "\n",
+    "* first we have to import the numpy library like the other libraries we used before we can do this with the import command ```import numpy as np``` with np beeing the short form of numpy.\n",
+    "\n",
+    "* a basic numpy array can be imported with ```np.array([1,2,3])```  \n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1 3 3 8]\n"
+     ]
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "\n",
+    "test_array = np.array([1,3,3,8])\n",
+    "\n",
+    "print(test_array)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "| **Method**            | **Description**                                | **Example Code**        | **Output**                                           |\n",
+    "| --------------------- | ---------------------------------------------- | ----------------------- | ---------------------------------------------------- |\n",
+    "| **`np.array`**        | Create an array from a Python list or tuple.   | `np.array([1, 2, 3])`   | `[1 2 3]`                                            |\n",
+    "| **`np.zeros`**        | Create an array filled with zeros.             | `np.zeros((2, 3))`      | `[[0. 0. 0.] [0. 0. 0.]]`                            |\n",
+    "| **`np.ones`**         | Create an array filled with ones.              | `np.ones((2, 3))`       | `[[1. 1. 1.] [1. 1. 1.]]`                            |\n",
+    "| **`np.empty`**        | Create an uninitialized array (random values). | `np.empty((2, 2))`      | Random values like `[[0. 0.] [0. 0.]]`               |\n",
+    "| **`np.arange`**       | Create an array with a range of values.        | `np.arange(0, 10, 2)`   | `[0 2 4 6 8]`                                        |\n",
+    "| **`np.linspace`**     | Create evenly spaced values between a range.   | `np.linspace(0, 1, 5)`  | `[0.   0.25 0.5  0.75 1.  ]`                         |\n",
+    "| **`np.eye`**          | Create an identity matrix.                     | `np.eye(3)`             | `[[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]]`                 |\n",
+    "| **`np.random.rand`**  | Create an array with random values (uniform).  | `np.random.rand(2, 3)`  | Random values like `[[0.5 0.7 0.1] [0.3 0.9 0.4]]`   |\n",
+    "| **`np.random.randn`** | Create random values with normal distribution. | `np.random.randn(2, 3)` | Random values like `[[1.2 -0.4 0.8] [-0.7 1.5 0.3]]` |\n",
+    "| **`np.full`**         | Create an array filled with a specific value.  | `np.full((2, 3), 7)`    | `[[7 7 7] [7 7 7]]`                                  |\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "NumPy provides several ways to create arrays. Below are the most common methods:"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Operation with numpy arrays\n",
+    "\n",
+    "* as with all libraries numpy comes with many built in functions let's have a look at the most common functions to manipulate numpy arrays "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "| **Operation** | **Description**                         | **Example Code**                                       | **Output**                                |\n",
+    "| ------------- | --------------------------------------- | ------------------------------------------------------ | ----------------------------------------- |\n",
+    "| **Slice**     | Extract part of an array.               | `arr[1:4]` (from `arr = np.array([1, 2, 3, 4, 5])`)    | `[2 3 4]`                                 |\n",
+    "| **Split**     | Split an array into smaller arrays.     | `np.array_split(np.array([1, 2, 3, 4, 5]), 2)`         | `[array([1, 2, 3]), array([4, 5])]`       |\n",
+    "| **Join**      | Combine multiple arrays into one.       | `np.concatenate((np.array([1, 2]), np.array([3, 4])))` | `[1 2 3 4]`                               |\n",
+    "| **Copy**      | Create a copy of an array.              | `copy = arr.copy()` (from `arr = np.array([1, 2, 3])`) | A new array identical to `arr`: `[1 2 3]` |\n",
+    "| **Search**    | Find index of specific values.          | `np.where(np.array([1, 2, 3, 4]) == 3)`                | `(array([2]),)` (index of value `3`)      |\n",
+    "| **Sort**      | Sort array elements in ascending order. | `np.sort(np.array([3, 1, 2]))`                         | `[1 2 3]`                                 |\n",
+    "| **Filter**    | Extract elements meeting a condition.   | `np.array([1, 2, 3, 4])[np.array([1, 2, 3, 4]) > 2]`   | `[3 4]`                                   |"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2 3 4]\n"
+     ]
+    }
+   ],
+   "source": [
+    "arr = np.array([1, 2, 3, 4, 5])\n",
+    "\n",
+    "print(arr[1:4])"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -34,9 +184,14 @@
     "## Filter"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -74,7 +229,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.5"
+   "version": "3.12.0"
   }
  },
  "nbformat": 4,