Chapter 1 - Intro to Python/Lesson_2_Handling_Data.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e1aac98d-25d8-4aea-ba7c-868e47ec633a",
   "metadata": {},
   "source": [
    "# Lesson 2: Data Handling "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bfcd796f-9d1d-4eac-9733-302b327bb57b",
   "metadata": {},
   "source": [
    "## Data Manipulation & Storage 💽\n",
    "Storing and manipulating data in Python involves working with different data types and structures to store, organize, and modify information.\n",
    "Although the foundations of storing data are simple, there are a handful of caveats you should be aware of in order to develop effective aerospace programs using Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2622fde9-61c1-4693-bf8f-4eea3a4fe2e7",
   "metadata": {},
   "source": [
    "## Typecasting 🔄 \n",
    "Typecasting, also known as type conversion, is the process of converting a value from one data type to another.\n",
    "It allows you to change the type of a variable or value temporarily to perform operations that are valid for the new data type.\n",
    "To show the significance of typecasting, suppose we have a int variable named `num` and we want to print it out:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f2cbba40-e07d-4bf4-b6a6-d05600eff68d",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[3], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m num \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m10\u001b[39m\n\u001b[0;32m----> 2\u001b[0m result \u001b[38;5;241m=\u001b[39m \u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mThe number is: \u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mnum\u001b[49m  \u001b[38;5;66;03m# This will cause a TypeError!!!\u001b[39;00m\n",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "num = 10\n",
    "result = \"The number is: \" + num  # This will cause a TypeError!!!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4976638d-a508-4f5b-a2c2-e42b2bfdd432",
   "metadata": {},
   "source": [
    "This code will result in a TypeError because you cannot concatenate a string with an integer directly.\n",
    "\n",
    "To solve this problem, you can use **type casting** to convert the integer num into a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0488cfba-4fbc-499f-b34f-61afd831146a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number is: 10\n"
     ]
    }
   ],
   "source": [
    "num = 10\n",
    "result = \"The number is: \" + str(num)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "255c0807-4a04-485e-a161-a2843d63024f",
   "metadata": {},
   "source": [
    "Typecasting is also useful for numerical applications.\n",
    "Let's say you want to have an `int` be interpreted as a `float`. Type casting will let us do that!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5f052691-aba9-4d80-9b93-3ee788746801",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "20.0\n"
     ]
    }
   ],
   "source": [
    "num_2 = 20\n",
    "\n",
    "# Convert integer to float\n",
    "num_float = float(num_2)\n",
    "\n",
    "print(num_2)\n",
    "print(num_float)  # Output: 20.0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f811fe3-9232-45b3-899d-cd19b716bd96",
   "metadata": {},
   "source": [
    "How about the other way around? We can interpret a `float` to be an `int`.\n",
    "However, this will cause the decimal values to disappear from the number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "72675c37-baaa-49d4-9517-fd27007d0514",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "num_float = 3.14\n",
    "\n",
    "# Convert float to integer\n",
    "num_int = int(num_float)\n",
    "\n",
    "print(num_int)  # Output: 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89984e06-ee93-4a79-aae7-1624b96e5949",
   "metadata": {},
   "source": [
    "Python allows us to easily know the data type of a specific variable by using the `type` command"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7f25cc86-50bd-4888-be5f-b5add874e05f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "print(type(num_float)) # # Output: <class 'float'>\n",
    "print(type(num_int)) # # Output: <class 'int'>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "869bbacf-909f-47ca-ae1e-a4c47e4290e7",
   "metadata": {},
   "source": [
    "### Exercise 1: Having Fun with Typecasts ✨\n",
    "\n",
    "#### Objective: \n",
    "- Typecast `fuel_remaining` (float) into an `int`\n",
    "- Typecast `oxygen_levels` (int) into a `float`\n",
    "- Print out the outputs to look like the following:\n",
    "```\n",
    "Fuel Remaining: 33 L\n",
    "Oxygen Levels: 21.0 kPa\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "122d25fa-5a6c-4407-b179-7e79462a3c06",
   "metadata": {},
   "outputs": [],
   "source": [
    "fuel_remaining = 33.42\n",
    "oxygen_levels = 21"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e32c74ea-b170-4cd6-9615-3b5591cc4597",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "086d04ad-7418-4826-8553-123aa2f499bd",
   "metadata": {},
   "source": [
    "## Arrays & Lists 📦\n",
    "Arrays and lists are the fundamental data types within Python that allow us to store a wide range of data values using a single line.\n",
    "Despite their striking similarities, there are a number of nuances that distinguish lists from arrays.\n",
    "\n",
    "### Lists:\n",
    "- Lists are a built-in data structure in Python.\n",
    "- They can store elements of different data types\n",
    "- Lists can dynamically grow and shrink in size\n",
    "- Lists support various operations like appending, inserting, removing, and slicing elements\n",
    "- Lists are part of the Python standard library and are widely used for storing collections of items\n",
    "\n",
    "Example of a list:\n",
    "`my_list = [1, 2, 3, 4, 5]`\n",
    "\n",
    "### Arrays:\n",
    "- Arrays are not built-in data structures in Python but are available through external libraries like numpy.\n",
    "- Arrays are homogeneous collections (they can store elements of the same data type).\n",
    "- Arrays have a fixed size once initialized, making them more memory efficient for numerical computations.\n",
    "- Arrays support vectorized operations, making them suitable for mathematical operations.\n",
    "\n",
    "Example of a list:\n",
    "```\n",
    "import numpy as np\n",
    "\n",
    "my_array = np.array([1, 2, 3, 4, 5])\n",
    "```\n",
    "\n",
    "NOTE: in the example above, we are using a library called numpy to give us an array. We will dive into libraries later, but for now consider it an external codebase that gives us additional functionality (in this case, arrays!)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad9a9fc2-7ff8-4605-98dd-1889f2efdb0b",
   "metadata": {},
   "source": [
    "## Indexing 🗂️\n",
    "Within arrays and lists, each item is given a positional value called an \"index\".\n",
    "The number 0 is given to the first value, 1 to the second, and so forth for all the values.\n",
    "For example, the indexes for the list `numbers` is displayed below:\n",
    "```\n",
    "numbers = [2, 4, 6, 8, 10]\n",
    "           |  |  |  |  |\n",
    "index:     0  1  2  3  4\n",
    "```\n",
    "\n",
    "Let's say you want to access the value `2` from the array. You can do so by using brackets and placing the index associated with the value inside like so:\n",
    "\n",
    "`numbers[0]`\n",
    "\n",
    "This results in the output:\n",
    "\n",
    "`2`\n",
    "\n",
    "You can also index out characters from a string via indexing. \n",
    "\n",
    "```\n",
    "name = \"John\"\n",
    "print(name[2])\n",
    "```\n",
    "\n",
    "This results in the output:\n",
    "\n",
    "`h`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "ff0f909c-baab-4350-b022-45b890b544ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "h\n"
     ]
    }
   ],
   "source": [
    "numbers = [2, 4, 6, 8, 10]\n",
    "print(numbers[0])\n",
    "name = \"John\"\n",
    "print(name[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2711c8ba-57eb-402c-a5a1-b5169eb80803",
   "metadata": {},
   "source": [
    "## Slicing 🔪\n",
    "Instead of indexing out only one value from an array, you can use `slice` to get a range of values from an array.\n",
    "For example, consider the array `numbers` below. Let's say you want the values `4, 6, 8`. \n",
    "\n",
    "```\n",
    "numbers = [2, 4, 6, 8, 10]\n",
    "sliced_numbers = numbers[1:3]\n",
    "```\n",
    "\n",
    "Notice when you slice from an array, you put the index of the starting item alongside the index of the ending item separated by a colon.\n",
    "\n",
    "```\n",
    "array[start_index:end_index]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e4fe91ef-d43c-4e1b-a219-7313bb29feaf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 6]\n"
     ]
    }
   ],
   "source": [
    "numbers = [2, 4, 6, 8, 10]\n",
    "sliced_numbers = numbers[1:3]\n",
    "print(sliced_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "beffe892-6fd7-4d38-b06e-7262812144c5",
   "metadata": {},
   "source": [
    "You can also use shorthand notations for slicing methods.\n",
    "For example, the following code:\n",
    "```\n",
    "sliced_numbers = numbers[0:2]\n",
    "```\n",
    "Is equivalent to:\n",
    "```\n",
    "sliced_numbers = numbers[:2]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "7d9be4b5-c946-4178-a745-4e12026cfa01",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4]\n",
      "[2, 4]\n"
     ]
    }
   ],
   "source": [
    "sliced_numbers = numbers[0:2]\n",
    "print(sliced_numbers)\n",
    "sliced_numbers = numbers[:2]\n",
    "print(sliced_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52a6136a-d317-4b3a-8cf2-d2e96ebd717b",
   "metadata": {},
   "source": [
    "Another handy shorthand notation helps you deal with getting index slices from very large arrays\n",
    "\n",
    "```\n",
    "numbers[1:]\n",
    "```\n",
    "\n",
    "Which will return:\n",
    "\n",
    "```\n",
    "[4, 6, 8, 10]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b9c2b86-ad1b-4571-a202-3c640a7c2118",
   "metadata": {},
   "source": [
    "Array slicing can also work in the backward direction by using negative indices. Where -1 represents the last element in the array, -2 represents the second to last element, and so forth.\n",
    "For example:\n",
    "\n",
    "```\n",
    "numbers[-3:-1]\n",
    "```\n",
    "\n",
    "Will return the following:\n",
    "\n",
    "```\n",
    "[6, 8]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "df3e9350-5da4-4e6c-99e6-ccc23b31462a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 8]\n"
     ]
    }
   ],
   "source": [
    "sliced_numbers = numbers[-3:-1]\n",
    "print(sliced_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b9cadce-39a2-4683-89ea-df19a52cd88c",
   "metadata": {},
   "source": [
    "You can also slice from 2D arrays like the following:\n",
    "\n",
    "```\n",
    "twod_array = [[1, 2, 3],\n",
    "              [4, 5, 6],\n",
    "              [7, 8, 9]]\n",
    "value_1 = twod_array[0][1]\n",
    "value_2 = twod_array[2][2]\n",
    "```\n",
    "The general structure looks like the following:\n",
    "\n",
    "```\n",
    "array[row_index, col_index]\n",
    "```\n",
    "\n",
    "The value_1 variable should equal `2`\n",
    "The value_2 variable should equal `9`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "b097260d-94aa-4672-a7d6-522dcd3e5fa3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 9\n"
     ]
    }
   ],
   "source": [
    "twod_array = [[1, 2, 3],\n",
    "              [4, 5, 6],\n",
    "              [7, 8, 9]]\n",
    "value_1 = twod_array[0][1]\n",
    "value_2 = twod_array[2][2]\n",
    "print(value_1, value_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "980643f0-2016-4f65-a817-dcba60c610a4",
   "metadata": {},
   "source": [
    "## Modifying Arrays & Lists 🚜\n",
    "\n",
    "You can directly modify a value within an array by reassigning an item at an index to another value.\n",
    "For example:\n",
    "\n",
    "```\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "numbers[1] = 7\n",
    "print(numbers)\n",
    "```\n",
    "\n",
    "The code above should output:\n",
    "```\n",
    "[1, 7, 3, 4, 5]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "984605a5-b864-4b30-afbd-59e57ed70316",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 7, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "numbers[1] = 7\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9ab2d6c-5ef8-4059-bd38-bf590d486dfb",
   "metadata": {},
   "source": [
    "You can delete items from an array like so:\n",
    "```\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "del(numbers[2])\n",
    "```\n",
    "\n",
    "The above removes the third element in the array and shifts the index values of all the items."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c3285831-abde-4583-b190-5326f905a894",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "del(numbers[2])\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe126699-1ad1-4a49-a49f-815d02c03e21",
   "metadata": {},
   "source": [
    "You can append items onto an array like so:\n",
    "```\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "numbers.append(6)\n",
    "```\n",
    "\n",
    "The above adds the number 6 to the end of the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "4cba51d2-f7d3-45d3-9a19-b478b8ee5e0f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "numbers.append(6)\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25d11f1b-9cc1-48b7-a6b6-9cf08006a7ce",
   "metadata": {},
   "source": [
    "Finally, an array can also be reflected meaning you can reverse the order of the elements.\n",
    "```\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "reflected = numbers[::-1]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c3301df0-1479-45b0-a9f2-94577a0bf448",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "reflected = numbers[::-1]\n",
    "print(reflected)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a9e7c31-4d2f-446b-aae8-5269f45f6897",
   "metadata": {},
   "source": [
    "### Exercise 2: Array Manipulation ⚡️\n",
    "\n",
    "#### Objective: \n",
    "Using the `values` array below, run the following steps in order.\n",
    "1. Delete the last item\n",
    "2. Set the second element to the number 8\n",
    "3. Flip the array\n",
    "4. Append the numbers 5 and 9 to the array\n",
    "5. Print out the array\n",
    "\n",
    "#### HINT: the output should be the following:\n",
    "\n",
    "```\n",
    "[4,3,8,1,5,9]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "1433503d-31b7-44c2-bd96-2691015df8a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "values = [1, 2, 3, 4, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c2dda98-4ff0-459b-afa6-50d785f7fcd2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "895af02c-f18e-4662-b781-c047114087bc",
   "metadata": {},
   "source": [
    "## Getting User Input 🔎\n",
    "The `input` command in Python allows your program to interactively receive data from the user during runtime.\n",
    "The following code asks the user for their favorite color and then prints it.\n",
    "\n",
    "```\n",
    "fav_color = input(\"What is your favorite color?\")\n",
    "print(\"Favorite Color: \" + fav_color)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "a938c3af-93da-4176-830e-5008c188dd1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "What is your favorite color? blue\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Favorite Color: blue\n"
     ]
    }
   ],
   "source": [
    "fav_color = input(\"What is your favorite color?\")\n",
    "print(\"Favorite Color: \" + fav_color)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "642ace57-898a-4d20-9f32-cb719adf71a9",
   "metadata": {},
   "source": [
    "### Exercise 3: Rocket Engine Performance Calculator 🚀\n",
    "You are an aerospace engineer tasked to create a computer program to calculate the engine performance of a rocket engine.\n",
    "The calculator must meet the following specifications:\n",
    "\n",
    "#### Objective: \n",
    "- Calculator must ask the user for the *thrust* and *mass flow rate of the propellant*\n",
    "- Typecast the values as `float` variables \n",
    "- Calculate the specific impulse of the rocket engine\n",
    "- Calculate the exhaust velocity of the rocket\n",
    "- Print out the values as strings\n",
    "\n",
    "#### HINT: you can use the below equations\n",
    "```\n",
    "Specific Impulse = Thrust / (Mass Flow Rate * 9.81)\n",
    "Exhaust Velocity = Specific Impulse * 9.81\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "83c0b073-aab1-45dd-aea4-44a33d0b547e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e251df23-648d-483a-ba5f-65541a407f34",
   "metadata": {},
   "source": [
    "Congratulations! You made it through another lesson!\n",
    "Blast off to the next lesson about control structures!"
   ]
  }
 ],
 "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}