Practice Notebook 3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f18d068e-005f-4cbe-9472-50276043072c",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"Hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "28042a25-9bd1-4677-af41-d25e0a4e3ed9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1824d36f-4ecb-40dd-89eb-c8f8692cb6ec",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'str' object has no attribute 'reverse'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[10], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m a\u001b[38;5;241m.\u001b[39mreverse()\n",
      "\u001b[1;31mAttributeError\u001b[0m: 'str' object has no attribute 'reverse'"
     ]
    }
   ],
   "source": [
    "a.reverse()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "61a16105-5cc9-40e1-b48a-d29adf342887",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PAHNAPLSIIGYIR"
     ]
    }
   ],
   "source": [
    "# Python 3 program of the above approach\n",
    "\n",
    "# Function that Prints concatenation of\n",
    "# all rows of str's Zig-Zag fashion\n",
    "def printZigZagConcat(str, n):\n",
    "\n",
    "\t# Corner Case (Only one row)\n",
    "\tif n == 1:\n",
    "\t\tprint(str)\n",
    "\t\treturn\n",
    "\n",
    "\t# Find length of string\n",
    "\tl = len(str)\n",
    "\n",
    "\t# Create an array of\n",
    "\t# strings for all n rows\n",
    "\tarr = [\"\" for x in range(l)]\n",
    "\n",
    "\t# Initialize index for\n",
    "\t# array of strings arr[]\n",
    "\trow = 0\n",
    "\n",
    "\t# Traverse through\n",
    "\t# given string\n",
    "\tfor i in range(l):\n",
    "\n",
    "\t\t# append current character\n",
    "\t\t# to current row\n",
    "\t\tarr[row] += str[i]\n",
    "\n",
    "\t\t# If last row is reached,\n",
    "\t\t# change direction to 'up'\n",
    "\t\tif row == n - 1:\n",
    "\t\t\tdown = False\n",
    "\n",
    "\t\t# If 1st row is reached,\n",
    "\t\t# change direction to 'down'\n",
    "\t\telif row == 0:\n",
    "\t\t\tdown = True\n",
    "\n",
    "\t\t# If direction is down,\n",
    "\t\t# increment, else decrement\n",
    "\t\tif down:\n",
    "\t\t\trow += 1\n",
    "\t\telse:\n",
    "\t\t\trow -= 1\n",
    "\n",
    "\t# Print concatenation\n",
    "\t# of all rows\n",
    "\tfor i in range(n):\n",
    "\t\tprint(arr[i], end=\"\")\n",
    "\n",
    "\n",
    "# Driver Code\n",
    "str = \"PAYPALISHIRING\"\n",
    "N = 3\n",
    "printZigZagConcat(str, N)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b1cee28b-aaab-4ca7-a003-c404ca744d72",
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "7a36997d-31a3-43eb-bb59-d81ac7748b20",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = array([ 10, 15, 20, 25, 30, 35, 40])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "81d003d5-0dea-424d-b05c-ec73f16ff71f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[15 25]\n"
     ]
    }
   ],
   "source": [
    "print(a[1:5:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3d5bf04b-eeb1-44d8-8216-50a9fe747442",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[15, 25]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst = [10, 15, 20, 25, 30, 35, 40]\n",
    "lst[1:5:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "de6674f4-5888-4169-8221-bf8cbc068764",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = array([4.1, 2.4, 8.1], dtype= int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "3e73a313-8923-4e4d-aa7f-850104b3aa7d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 2, 8])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "1db73080-cb38-4373-b0fc-3b38e8769942",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "def outer_fun(a, b):\n",
    "    def inner_fun(c, d):\n",
    "        return c + d\n",
    "    return inner_fun(a, b)\n",
    "\n",
    "res = outer_fun(5, 3)\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "8e5f096c-4cc3-4969-b6a2-565d81fd18dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Functions used as objects: \n",
    "# A function is going to be equaled to a variable \n",
    "# This doesn't call the function; it takes the function \n",
    "# object referenced by shout and creates a second name pointing to yell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "3d744aa8-2d4b-4bea-8dda-035935a6781c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO\n",
      "HELLO\n"
     ]
    }
   ],
   "source": [
    "def shout(text):\n",
    "    return text.upper()\n",
    "    \n",
    "print(shout(\"HELLO\"))\n",
    "\n",
    "yell = shout\n",
    "\n",
    "print(yell(\"HELLO\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "14df3076-de33-456b-b865-72b180bb0392",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HI, I AM CREATED BY A FUNCTION PASSED AS AN ARGUMENT.\n",
      "hi, i am created by a function passed as an argument.\n"
     ]
    }
   ],
   "source": [
    "def shout(text):\n",
    "    return text.upper()\n",
    "\n",
    "def whisper(text):\n",
    "    return text.lower()\n",
    "\n",
    "def greet(func):\n",
    "    greeting = func(\"Hi, I am created by a function passed as an argument.\")\n",
    "    print (greeting) \n",
    "\n",
    "greet(shout)\n",
    "greet(whisper)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "320fbb6a-cd99-4079-abb4-5fed14fe7010",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n"
     ]
    }
   ],
   "source": [
    "def create_adder(x):\n",
    "    def adder(y):\n",
    "        return x+y\n",
    "        \n",
    "    return adder\n",
    "\n",
    "add_15 = create_adder(15)\n",
    "\n",
    "print(add_15(10))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "62f73613-cab2-4acf-a1a8-e6a03733e451",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Above we learn that in order for the notebook to read the code it has to have the correct space between the lines. \n",
    "# si no; no corre el codigo. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1bc132b5-9979-4946-aa14-6e26f4b04024",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Write number here: 8\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hey\n",
      "X is greater than 0.\n"
     ]
    }
   ],
   "source": [
    "# Practicing if statements: \n",
    "\n",
    "x = int(input(\"Write number here:\"))\n",
    "        \n",
    "if x > 0:\n",
    "        print(\"Hey\")\n",
    "        print(\"X is greater than 0.\")\n",
    "\n",
    "elif x == 0:\n",
    "    print(\"X is equal to 0.\")\n",
    "\n",
    "else:\n",
    "    print(\"X is negative.\")\n",
    "\n",
    "\n",
    "\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "81a5df96-ddb7-4b7a-95e5-1f4e578f7a20",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['cherry', 'orange', 'kiwi', 'melon']\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"apple\", \"banana\", \"cherry\", \"orange\", \"kiwi\", \"melon\", \"mango\"]\n",
    "print(fruits[2:6])\n",
    "# Why is the last one included in this?\n",
    "# It talks about 5 th item in the list not inxdex plus kiwi is index 4 but element 5. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "c1a42a53-0438-4a7a-afe5-0e41df3e5c84",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cherry', 'orange', 'kiwi']"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits[2:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e5a78e9f-db1d-43d7-b16d-72db5041535d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 12]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [10, 11, 12, 13, 14]\n",
    "a[1:3]\n",
    "# Obviously the last is not included in this. The last is the 3 index.. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "bdf44c8f-5671-49c1-9e50-beaee38d4971",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "my_function() missing 1 required positional argument: 'x'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[26], line 4\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mmy_function\u001b[39m(x):\n\u001b[0;32m      2\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m x \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m5\u001b[39m\n\u001b[1;32m----> 4\u001b[0m my_function()\n",
      "\u001b[1;31mTypeError\u001b[0m: my_function() missing 1 required positional argument: 'x'"
     ]
    }
   ],
   "source": [
    "def my_function(x):\n",
    "    return x + 5\n",
    "\n",
    "my_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "bbaf571d-fe2a-4a0c-8828-bb14b7d6664a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 3)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa504d4e-4525-43a4-b3ae-cefafa3b4364",
   "metadata": {},
   "source": [
    "# Exercise 2: \n",
    "## Write a python program to count number of even and odd numbers in a series of numbers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "fa5b2405-f786-4f0e-9cc1-4da6167d6566",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of even numbers are 4\n",
      "Number of odd numbers are 5\n"
     ]
    }
   ],
   "source": [
    "a = ( 1, 2, 3, 4, 5, 6, 7, 8, 9)\n",
    "count_even = 0 \n",
    "count_odd = 0\n",
    "for i in a: \n",
    "    if i % 2 == 0: \n",
    "        count_even += 1\n",
    "    else: \n",
    "        count_odd += 1 \n",
    "print(\"Number of even numbers are\", count_even)\n",
    "print(\"Number of odd numbers are\", count_odd) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9284f568-ae0a-40ab-b157-3e9b02087d3c",
   "metadata": {},
   "source": [
    "# Exercise 3\n",
    "## Write a program to calculate the factorial of a given number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "689b3f68-bfca-4fb7-ab8f-5e3c44ca031b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "write number here: 20\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2432902008176640000\n"
     ]
    }
   ],
   "source": [
    "a = int(input(\"write number here:\"))\n",
    "factorial = 1\n",
    "\n",
    "for i in range(1, a+1):\n",
    "    factorial *= i \n",
    "print(factorial)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1207878d-b364-4991-9c57-9a41c2d46b3f",
   "metadata": {},
   "source": [
    "# Exercise 4: \n",
    "## Write a program to check if the given string is palindrome or not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "5ad4b98c-7043-4221-baa5-7b47c60dfa4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "write a word here: civic\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "str = input(\"write a word here:\") \n",
    "\n",
    "if str == str[::-1]:\n",
    "    print(\"True\")\n",
    "else:\n",
    "    print(\"False\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7d5d468-6a31-4c6c-a816-7df71338423b",
   "metadata": {},
   "source": [
    "# Exercise 5: \n",
    "## Ask user to enter the mobile number.Using loops and conditional statements add adjucent numbers and create a new string.Repeat this process until the number comes to a single digit number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "1d349635-b151-4504-8a0d-9627c2ceffa7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "write number here: 9848563625\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5+2+6+3+6+5+8+4+8+9 = 56\n",
      "0 = 9\n"
     ]
    }
   ],
   "source": [
    "def phone_add(): \n",
    "    a = int(input(\"write number here:\"))\n",
    "    sum = 0    \n",
    "    while float(a)/10 > .1:\n",
    "        r = a%10\n",
    "        sum += r\n",
    "        a = a//10\n",
    "        if float(a) / 10 >.1: \n",
    "            print(r, end = \"+\")\n",
    "        else:\n",
    "            print(r, \"=\", sum)\n",
    "            while float(r)/ 10 >.3:\n",
    "                sum = 0\n",
    "                z = r%10 \n",
    "                sum += z \n",
    "                z = z//10 \n",
    "                if float(a) / 10 > .1:\n",
    "                    print(z, end = \"+\")\n",
    "                else: \n",
    "                    print(z, \"=\", sum)\n",
    "                    break\n",
    "\n",
    "\n",
    "phone_add()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "475a022d-6229-48d8-87ae-8d325131e62b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "ae9a56f2-90ab-4313-a359-785bd8ba3bc1",
   "metadata": {},
   "source": [
    "# Review of Lecture 1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87ba515a-2b45-48e7-a6a6-056f8c9ff1f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here we have a variable and this variable is going \n",
    "# to be equaled to a string \n",
    "# a string is a word, phrase, etc.... and then we print the \n",
    "# varialbe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "16d10f79-e86c-425f-a13a-bf20716cceae",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dragons\n",
      "Wyvern\n",
      "Chinese Dragon\n"
     ]
    }
   ],
   "source": [
    "a = \"Dragons\"\n",
    "print(a)\n",
    "b = \"Wyvern\"\n",
    "print(b) \n",
    "c = \"Chinese Dragon\"\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "419b9adf-41ba-4a1b-b67c-3b3723c48d32",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 1\n"
     ]
    }
   ],
   "source": [
    "print(\"a = 1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9e6d8193-b366-49eb-a4cb-c0235c89ef48",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = 2\n"
     ]
    }
   ],
   "source": [
    "print (\"a = 2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "abf829ce-ffc4-4230-9abf-78e438c50c30",
   "metadata": {},
   "outputs": [],
   "source": [
    "# above shows you that you can re-write what a equals to \n",
    "# a variable and it will overwrite it because it's strings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6a06d2b7-9b46-4007-83ba-20f5544bf922",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable               Type        Data/Info\n",
      "--------------------------------------------\n",
      "a                      str         Dragons\n",
      "b                      str         Wyvern\n",
      "c                      str         Chinese Dragon\n",
      "dataframe_columns      function    <function dataframe_colum<...>ns at 0x000002986EE82DE0>\n",
      "dataframe_hash         function    <function dataframe_hash at 0x000002986C230CC0>\n",
      "dtypes_str             function    <function dtypes_str at 0x00000298705DAD40>\n",
      "get_dataframes         function    <function get_dataframes at 0x00000298705DA660>\n",
      "getpass                module      <module 'getpass' from 'C<...>conda3\\\\Lib\\\\getpass.py'>\n",
      "hashlib                module      <module 'hashlib' from 'C<...>conda3\\\\Lib\\\\hashlib.py'>\n",
      "import_pandas_safely   function    <function import_pandas_s<...>ly at 0x000002986EE82C00>\n",
      "is_data_frame          function    <function is_data_frame at 0x000002986EE82FC0>\n",
      "json                   module      <module 'json' from 'C:\\\\<...>\\Lib\\\\json\\\\__init__.py'>\n"
     ]
    }
   ],
   "source": [
    "%whos \n",
    "# this tells you the variable , what the variable equals to, \n",
    "# and what type of data type it is. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "099a160e-30fc-4738-a31a-fea289e8e4c2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Once deleted, variables cannot be recovered. Proceed (y/[n])?  y\n"
     ]
    }
   ],
   "source": [
    "# we can reset the runs in the jupyter notebook. \n",
    "%reset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "55113fdf-144f-4467-bae2-ecbf96e96838",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable               Type        Data/Info\n",
      "--------------------------------------------\n",
      "dataframe_columns      function    <function dataframe_colum<...>ns at 0x00000298705DAC00>\n",
      "dataframe_hash         function    <function dataframe_hash at 0x00000298705DAF20>\n",
      "dtypes_str             function    <function dtypes_str at 0x00000298705DAE80>\n",
      "get_dataframes         function    <function get_dataframes at 0x00000298705DA660>\n",
      "getpass                module      <module 'getpass' from 'C<...>conda3\\\\Lib\\\\getpass.py'>\n",
      "hashlib                module      <module 'hashlib' from 'C<...>conda3\\\\Lib\\\\hashlib.py'>\n",
      "import_pandas_safely   function    <function import_pandas_s<...>ly at 0x00000298705DAD40>\n",
      "is_data_frame          function    <function is_data_frame at 0x00000298705DAAC0>\n",
      "json                   module      <module 'json' from 'C:\\\\<...>\\Lib\\\\json\\\\__init__.py'>\n"
     ]
    }
   ],
   "source": [
    "%whos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "76f48a94-ced4-452e-8d7d-80c9bcb874c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Above you can tell that the variables with strings are \n",
    "# not above "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "79ea2f4b-50a7-4a72-b83e-cf4a5708d0e8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wow\n"
     ]
    }
   ],
   "source": [
    "# in order for a variable to be printed it has to be \n",
    "# defined. \n",
    "c = \"Wow\"\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34babc66-a248-49f9-b4a1-a8d7eb24c260",
   "metadata": {},
   "outputs": [],
   "source": [
    "# we are using import os (operating system) in order \n",
    "# to change, and get, the directory system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "cb4a5448-f9e1-4bc9-8771-181135caa8b3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "23872a8d-27f5-4ab3-bbbe-857c9d111d75",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C:\\\\Users\\\\draco\\\\Downloads\\\\Data Python 3401'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.getcwd()\n",
    "# from here we are getting the directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "8e71024f-68f4-4eef-8560-cedd4256ba65",
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir('C:\\\\Users\\\\draco\\\\Downloads\\\\data3401')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a36777c7-102e-4a1c-a178-5e0c36bbfde0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Above the directory changed from the file Data Python 3401 \n",
    "# To data3401; with this you are supposed to find this file \n",
    "# in the folder of data3401 and such.... \n",
    "# After the os.chdir() we use os.getcwd() in order to get which \n",
    "# directory we are currently using. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "c8506e8f-8fc7-4018-b0b1-c3b3fee33cfd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C:\\\\Users\\\\draco\\\\Downloads\\\\data3401'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "b7abb752-8d7d-4992-9758-b9f308354638",
   "metadata": {},
   "outputs": [],
   "source": [
    "os.chdir('C:\\\\Users\\\\draco\\\\Downloads\\\\Data Python 3401')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "ed9aa41c-e12a-4421-9cbe-c1da254b62a1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C:\\\\Users\\\\draco\\\\Downloads\\\\Data Python 3401'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a54aec6-f0e2-42f7-bceb-43f3b715ad78",
   "metadata": {},
   "outputs": [],
   "source": [
    "# That is how it's done. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "d717c8be-4073-4622-b46a-7e25b0d134eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Volume in drive C is Windows-SSD\n",
      " Volume Serial Number is F2E1-D40F\n",
      "\n",
      " Directory of C:\\Users\\draco\\Downloads\\Data Python 3401\n",
      "\n",
      "07/07/2024  02:49 PM    <DIR>          .\n",
      "07/06/2024  06:40 PM    <DIR>          ..\n",
      "07/06/2024  06:37 PM    <DIR>          .ipynb_checkpoints\n",
      "06/04/2024  10:04 AM            35,676 1st Lecture Data3401 06 03 2024Notes.ipynb\n",
      "06/18/2024  07:42 AM    <DIR>          datascience\n",
      "06/05/2024  11:51 PM            14,596 Lab 06052024.ipynb\n",
      "07/06/2024  09:13 PM            15,295 LAB 3.ipynb\n",
      "06/11/2024  11:25 AM            11,969 LAB-1 -1.ipynb\n",
      "07/03/2024  07:02 PM         4,143,102 LAB-2.ipynb\n",
      "06/27/2024  07:33 PM            47,204 Lecture 2 Data 3401Notes.ipynb\n",
      "06/11/2024  05:37 PM            29,228 Lecture 3 Data 3401 06 10 2024.ipynb\n",
      "06/24/2024  09:20 AM            42,150 Lecture 3 Data 3401Notes.ipynb\n",
      "07/05/2024  02:24 PM            24,864 Lecture 4 Data 3401 Notes.ipynb\n",
      "06/24/2024  04:40 PM            25,864 Lecture 5 Data 3401 Notes.ipynb\n",
      "07/06/2024  05:57 PM            32,351 Lecture 7 Data 3401 06 26 2024.ipynb\n",
      "07/06/2024  05:32 PM            32,684 Lecture 7 Notes 062624.ipynb\n",
      "07/01/2024  07:14 PM           498,165 Lecture 8 - Matplotlib Data 3401 07 01 2024 .ipynb\n",
      "07/06/2024  06:39 PM            14,449 Lecture 8 Data 3401 07 01 2024.ipynb\n",
      "07/01/2024  05:31 PM             4,529 Lecture 8 Notes.ipynb\n",
      "06/24/2024  07:27 PM           568,504 Lecture6 Notes 062424.ipynb\n",
      "06/22/2024  07:36 PM           151,335 Playing with Code.ipynb\n",
      "06/30/2024  05:31 PM            14,307 Practice hw.ipynb\n",
      "06/25/2024  05:41 PM           111,189 Practice Notebook 2.ipynb\n",
      "07/07/2024  02:49 PM            28,011 Practice Notebook 3.ipynb\n",
      "              20 File(s)      5,845,472 bytes\n",
      "               4 Dir(s)  375,459,115,008 bytes free\n"
     ]
    }
   ],
   "source": [
    "%ls\n",
    "# this gives us a list of the directory contents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "264f9b8a-8563-4103-8b1a-a4af269ff15b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'C:\\\\Users\\\\draco\\\\Downloads\\\\Data Python 3401'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ac12009c-835a-4d04-bb1b-01d5324b46bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# if we use the ? at the end of a fucntion and \n",
    "# it tells you what the function is and how it works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "996a5cc0-11cc-4313-b11c-adff441dc468",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1;31mSignature:\u001b[0m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m/\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
       "\u001b[1;31mDocstring:\u001b[0m Return the number of items in a container.\n",
       "\u001b[1;31mType:\u001b[0m      builtin_function_or_method"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "len?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "22b881e4-d1ba-4672-9e8c-2554e9b965b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Object `split` not found.\n"
     ]
    }
   ],
   "source": [
    "split?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "69f71653-00fd-4e69-a800-4a7e759f1d6a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[1;31mSignature:\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0msep\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m' '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mend\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m'\\n'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mfile\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mflush\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mFalse\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
       "\u001b[1;31mDocstring:\u001b[0m\n",
       "Prints the values to a stream, or to sys.stdout by default.\n",
       "\n",
       "sep\n",
       "  string inserted between values, default a space.\n",
       "end\n",
       "  string appended after the last value, default a newline.\n",
       "file\n",
       "  a file-like object (stream); defaults to the current sys.stdout.\n",
       "flush\n",
       "  whether to forcibly flush the stream.\n",
       "\u001b[1;31mType:\u001b[0m      builtin_function_or_method"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "7bf1711e-82a2-4e78-a75f-ba60302db29a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Object `sep` not found.\n"
     ]
    }
   ],
   "source": [
    "sep?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "3bc2d25e-63c2-4817-9d79-a08c7d6c09d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# %his gives you the history of everything that you have \n",
    "# coded so far"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "b5a579e3-c25c-4475-9ed1-94aa1d5e2045",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = \"Dragons\"\n",
      "print(a)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "a = \"Dragons\"\n",
      "print(a)\n",
      "b = \"Wyvern\"\n",
      "print(b) \n",
      "c = \"Chinese Dragon\"\n",
      "print(c)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "print(\"a = 1\")\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "print (\"a = 2\")\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "%whos \n",
      "# this tells you the variable , what the variable equals to, \n",
      "# and what type of data type it is.\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# we can reset the runs in the jupyter notebook. \n",
      "%reset\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "%whos\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# Above you can tell that the variables with strings are \n",
      "# not above\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# in order for a variable to be printed it has to be \n",
      "# defined. \n",
      "c = \"Wow\"\n",
      "print(c)\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "import os\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "os.getcwd()\n",
      "# from here we are getting the directory\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "path\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "os.chdir('C:\\\\Users\\\\draco\\\\Downloads\\\\datascience')\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "os.chdir('C:\\\\Users\\\\draco\\\\Downloads\\\\data3401')\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "os.getcwd()\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "os.chdir('C:\\\\Users\\\\draco\\\\Downloads\\\\Data Python 3401')\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "os.getcwd()\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "%ls\n",
      "# this gives us a list of the directory contents\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "os.getcwd()\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "len?\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "add?\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "import ?\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "split?\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "print?\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "sep?\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "sep=''?\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "sep=?\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "# %his gives you the history of everything that you have \n",
      "# coded so far\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "%his\n",
      "\n",
      "import json\n",
      "import getpass\n",
      "import hashlib\n",
      "\n",
      "def import_pandas_safely():\n",
      "    try:\n",
      "        return __import__('pandas')\n",
      "    except ImportError:\n",
      "        return False\n",
      "\n",
      "\n",
      "__pandas = import_pandas_safely()\n",
      "\n",
      "\n",
      "def is_data_frame(v: str):\n",
      "    obj = eval(v)\n",
      "    if  isinstance(obj, __pandas.core.frame.DataFrame) or isinstance(obj, __pandas.core.series.Series):\n",
      "        return True\n",
      "\n",
      "\n",
      "def dataframe_columns(var):\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return [[df.name, str(df.dtype)]]\n",
      "    return list(map(lambda col: [col, str(df[col].dtype)], df.columns))\n",
      "\n",
      "\n",
      "def dtypes_str(frame):\n",
      "    return str(eval(frame).dtypes)\n",
      "\n",
      "def dataframe_hash(var):\n",
      "    # Return a hash including the column names and number of rows\n",
      "    df = eval(var)\n",
      "    if isinstance(df, __pandas.core.series.Series):\n",
      "        return hashlib.sha256(f\"{var}-{df.name},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "    return hashlib.sha256(f\"{var}-{','.join(df.columns)},{len(df)}\".encode('utf-8')).hexdigest()\n",
      "\n",
      "def get_dataframes():\n",
      "    if __pandas is None:\n",
      "        return []\n",
      "    user = getpass.getuser()\n",
      "    values = %who_ls\n",
      "    dataframes = [\n",
      "        {\n",
      "            \"name\": var,\n",
      "            \"type\": type(eval(var)).__name__,\n",
      "            \"hash\": dataframe_hash(var),\n",
      "            \"cols\": dataframe_columns(var),\n",
      "            \"dtypesStr\": dtypes_str(var),\n",
      "        }\n",
      "        for var in values if is_data_frame(var)\n",
      "    ]\n",
      "    result = {\"dataframes\": dataframes, \"user\": user}\n",
      "    return json.dumps(result, ensure_ascii=False)\n",
      "\n",
      "\n",
      "get_dataframes()\n",
      "%hist\n"
     ]
    }
   ],
   "source": [
    "%hist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6023973f-feeb-4b52-86a8-eae1e1423cac",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Also, different kinds of variables \n",
    "# For example; a string and an integer can't be added together. \n",
    "# But things like integers and floats can be added together\n",
    "# This is because even though one is an irrational fraction and the other is a whole number\n",
    "# Now complex numbers are different. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "f46d26f2-e16f-4f92-bda5-95384369f661",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "c71c5c8d-b601-40d9-a775-8bdd7145251f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.5"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 + 4.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "625cd0de-02db-4f70-9823-fa1099f7bea0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# we are goinng to review how to use latex and write down \n",
    "# equations while using latex ( lab system)\n",
    "# Writting Math Functions "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8bbf1e3-df28-4eb4-bafe-43c898a06151",
   "metadata": {},
   "outputs": [],
   "source": [
    "## Steps \n",
    "#1. write: from IPython.display import Latex\n",
    "#2. write Latex(\"$ $\") and what expression you want inside of it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "98f846cb-caad-4ba1-bddd-b10d4a6f15ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import Latex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a90f420-35f7-4492-bd42-5bfb4a8a4af3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's practice some equations: \n",
    "#1. Pythagorean Theorem \n",
    "#2. Integral\n",
    "#3. Quadratic Equations \n",
    "#4. E = mc^2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "8cfafd9f-4086-43ef-90bd-35678021cea8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$ x^2 + y^2 = z^2$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Latex(\"$ x^2 + y^2 = z^2$\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "4ab39101-76a5-481d-9f75-50f99e2d1ec7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\int_{a}^{b}f(x) dx$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Latex(\"$\\int_{a}^{b}f(x) dx$\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "865f7d03-b317-4969-be74-98eb7f53258f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$ -b + \\sqrt{b^2 -4ac}/2a$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Latex(\"$ -b + \\sqrt{b^2 -4ac}/2a$\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "928fa5b3-806a-4dee-9bed-109105919dde",
   "metadata": {},
   "outputs": [],
   "source": [
    "# for the squareroot equation to have everything under it\n",
    "# you need to use the curly fries brackets . "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "c6611b4c-1889-4e75-a74b-3b832be640b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$E = mc^2$"
      ],
      "text/plain": [
       "<IPython.core.display.Latex object>"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Latex(\"$E = mc^2$\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eb22f204-6761-4838-b682-3b3fff67387a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# now that we have practiced different forms of equations with \n",
    "# Latex let's practive soemthing else. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e5955f9-9c08-4953-875f-4786e291203b",
   "metadata": {},
   "source": [
    "# Lecture 1: Review of Interactive Calculator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "bf15f550-3e9b-4b69-88f3-ea4b0037d2ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "19"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# in order to add two values use the + sign \n",
    "1 + 1 + 8 + 9 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "be07b3d7-ef7a-4cc3-a157-fd22a4586568",
   "metadata": {},
   "outputs": [],
   "source": [
    "# In order to set a variable equal to a number you have to use \n",
    "# the = sign for it \n",
    "a = 7 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "962d4be8-8909-47b0-9fca-1904dc6b0729",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "701456db-812a-42bd-94b4-6f8aa50b4aeb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# In order to check which kind of variable it is \n",
    "# use type()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "6a867e40-8068-41de-b573-0557b37a1b25",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49d35661-5d6a-4ff8-8028-dbeea0ff310a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can use the del to delete variables and what they \n",
    "# are equaled to. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "f06d0614-94bf-42e8-85e2-d35b78271bd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = 9.067"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "b83b34e9-7135-4e48-8c5e-1a047bfbe436",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.067"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "0ba3b3f9-5e90-4a07-b4a2-4c9e05999e2c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "d4ed6f9a-856f-474e-8fee-bdc52919aba3",
   "metadata": {},
   "outputs": [],
   "source": [
    "del c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "99ded629-d584-4981-9927-166f68d168b8",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'c' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[116], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m c\n",
      "\u001b[1;31mNameError\u001b[0m: name 'c' is not defined"
     ]
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4fde903b-a69a-4521-a19d-028800ca1841",
   "metadata": {},
   "outputs": [],
   "source": [
    "# above shows if c is deleted then is not defined. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9302997a-5c6b-4128-90ac-2f0f27a10367",
   "metadata": {},
   "outputs": [],
   "source": [
    "# complex numbers are written with a real number \n",
    "# and are written with an imaginary number who in python \n",
    "# is j. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "7008a49e-bbdf-45a4-8dde-8e2cde606f36",
   "metadata": {},
   "outputs": [],
   "source": [
    "u = 89 + 2.3j"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "41b54653-20be-4fc0-a272-2c4632d78a9f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(u)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "f30881e5-ad83-41ee-b073-490897d166a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(89+2.3j)"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6bbf836c-05f9-4896-80f3-46cb862c5a4d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Arithmetic Operations \n",
    "# here you can combine all the things that we have done iwth the \n",
    "# different mathematics signs and it'll give you a "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "18eaa440-c2c0-44e2-a693-fc95de8249fc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1048582.0"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 2 + ( 8*4/2)**5 + (5-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "db30e413-c3d5-4f34-930e-d9385654ee59",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Now this is exponents \n",
    "5**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "bd4c5492-db4f-4ea9-9dbc-8f5fa9fcc223",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(5)**2 * (5)**3 == (5)**5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "faeffa98-1e2e-4d48-9e46-fe098ef5c520",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now we are going to work with simple math functions \n",
    "# in python\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "1aeb32e4-a0ae-49b2-aa95-c783194cc7bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "89"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(-89)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "67acdc0a-2eae-4805-8587-7849c31487ae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(0, 5, 8, 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "de1110d2-486e-43e1-b2f9-dc2d4638d71c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min( 0, 5, 9, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "b217dfaa-6fe7-4b45-bb68-dd5dc0cbe0e8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9, 5, 3)"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max((9, 5, 3), (0, 2, 6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "be8ab093-2af7-4faf-882c-aab8e9ea9372",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(5, min(10, 3, 4, -5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "4ff78a63-14fc-43f0-8c27-fce1e5613e61",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = max(4, 5)\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "f5e65928-f8bf-4ce6-ba0d-7fe6f6b3f669",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'y' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[156], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(y)\n",
      "\u001b[1;31mNameError\u001b[0m: name 'y' is not defined"
     ]
    }
   ],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "0ab74d61-9ee1-42d8-8f25-bfc4ec3a9245",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'y' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[158], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m y\n",
      "\u001b[1;31mNameError\u001b[0m: name 'y' is not defined"
     ]
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "d3c191ef-52b9-4125-80a9-dc3a8f15253f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Type Conversions \n",
    "# This is how you convert a variable of some type into another\n",
    "# type of data "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "219c3f5b-8ecc-4fba-b92f-6e5ad03a406d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(2.756)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "459ccc41-652f-41cf-ba61-77ac44fca629",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "be587b02-a435-4513-a03c-a37fac648c05",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.65'"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(2.65)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "b24f921b-3f7c-4ef7-95aa-19e7d84c9a0e",
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'lol'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[170], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m \u001b[38;5;28mint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mlol\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[1;31mValueError\u001b[0m: invalid literal for int() with base 10: 'lol'"
     ]
    }
   ],
   "source": [
    "int(\"lol\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "deddda76-815c-4e40-bd73-460426469e24",
   "metadata": {},
   "outputs": [],
   "source": [
    "# strings that can't be numbers like lol can't be an \n",
    "# integer "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "3970e41f-a8af-4c1d-9973-7f799be4b181",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(\"25\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7467f22-e3ab-460f-82de-c780c675e22b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Strings that are numbers are good to transcribed \n",
    "# into integers and floats. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "cbe0875b-89b3-4c50-af78-5c2121304c41",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23.0"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(\"23\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a92ae115-b82b-4f54-a456-7247e107082b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now adding a certain amount by using +=, -=, /=, in different\n",
    "# formats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "8a37b0e4-cbaf-4b1c-86c2-a8065fa79a30",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 90\n",
    "b += 7.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "b9c9d83e-532f-4222-927a-1082df7c8ce8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "97.3\n"
     ]
    }
   ],
   "source": [
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "e0b9dd92-c17e-4b52-9e6d-18f3efa2441f",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = 90 \n",
    "c *=2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "29bf7a9b-eda5-4b8a-be74-1a86f212c1af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "180\n"
     ]
    }
   ],
   "source": [
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "685b7d20-7b19-4e0f-b518-e3a87e3c24d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "g = 90 \n",
    "g /= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "08b9f56c-8621-4f31-8f49-69b3f065ab3e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "45.0\n"
     ]
    }
   ],
   "source": [
    "print(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba9a681a-80d5-47ac-b5eb-404b31f23f41",
   "metadata": {},
   "outputs": [],
   "source": [
    "# So yeah you can use this method of thinking with multiplications, \n",
    "# divisions, etc... "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "430fb1f2-647f-4a38-abe3-1773b46be9ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Modulus ????\n",
    "u =78\n",
    "u %= 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "id": "947d85e1-bd42-4de4-bee2-52e81b45f696",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "print(u)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6dbd01d-3bbf-47bd-8229-4a5eb3c1e3e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# it gave the remainder and it worked with the same \n",
    "# way the method of thinking did with the other signs. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fcd8ce5b-f3f0-46ba-b061-a057d6fe84d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# lets write out an operation with the squareroot formula"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "id": "388227e0-12ec-4229-b2f4-a7c4a8cf5a71",
   "metadata": {},
   "outputs": [],
   "source": [
    "z = (-b +((b**2) - (4*a*c))**(1/2))/(2*a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "id": "5a5c2a27-ca4a-4323-9aa6-feebbc5fdeb7",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "id": "76aac46f-2e2e-4663-9a04-5a91ffca5d57",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "326b7d80-c696-4f4c-9f40-ac272b5214c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "id": "0ae47e8e-29b3-499f-9d81-77943af6adf3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.29843788128357573"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d2a1e62-f797-4630-b490-dd9626a68c75",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "id": "0232a15c-c218-43e6-875f-b4c061eebec5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Review what we talked about before:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecd3ce6d-30cd-426c-ba56-491f715d858a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# So, at first we started that the variables can be equalled to something be it\n",
    "# a string, an integer, a float, etc... \n",
    "# You  can also import latex from IPython.display \n",
    "# We also imported the os to get the cwd() and to also change chdir() \n",
    "# and all of that. \n",
    "# YOu can also use the interactive calculator and create a program to get the out come of it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f803bdb0-85f0-483f-adf4-36ea32285b38",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d5a253dc-ecbc-4a20-9275-3ec5adfda0a8",
   "metadata": {},
   "source": [
    "# Review of Lecture 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "id": "eb209160-1d6a-4c82-89b3-55a96e1f102e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "# Reviewing Strings:\n",
    "s = \"hello world\"\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "id": "6901d1c9-ee8f-4f4e-9655-fdb5ab963691",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello world'"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# String operations works when it's two strings:\n",
    "\"hello\" +' '+ \"world\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "id": "6be164b5-53be-40ae-b691-54ee824fc18e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'oshaoshaoshaoshaoshaosha'"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# you can also write a string multiple times in a row \n",
    "# by multiplying the string with a number\n",
    "\"osha\"*6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "id": "e4ed25af-f296-403f-b5f4-77d867b4cdee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'osha osha osha osha osha osha '"
      ]
     },
     "execution_count": 217,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# in order for there to be a space you can \n",
    "# leave a space \n",
    "\"osha \"*6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "id": "ec13c8f7-8229-4386-bd81-b651fac8f268",
   "metadata": {},
   "outputs": [],
   "source": [
    "# In order to get the length of the string we use len()\n",
    "s = \"12345\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "id": "76cdd60b-93e0-40fb-a500-9d0c134bad86",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1234512345'"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "id": "c489a0c7-6658-4605-9c8f-b4efa614de31",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 223,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2418c1fa-4012-4157-bd63-b0b3f89ed53f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# As you can see above the len of s is equaled to 5\n",
    "# because it is equal to 5 that means the quotation marks \n",
    "# are not equal to 5. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "id": "98287afd-2818-4df8-ad9b-68b25ebe007c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# now we can see that the spaces do count as part of the lenght \n",
    "s1 = \" 12345 \" \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "id": "3bb32d42-5304-47ea-89d9-19ef213543f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' 12345 '"
      ]
     },
     "execution_count": 227,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "id": "97505c5c-ba58-42d2-8cf5-bbb9c48286b7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(s1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "37bc49fb-f0f8-4b18-a783-ac2b0c5be193",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now in order to split a string we use the function \n",
    "# split() \n",
    "# inside the split() you can use sep, and the sep = ',' or anyother thing to help\n",
    "# with the separation and all. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "id": "d969829b-6ac5-4e4e-942f-b6c797cc748a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['The', 'Dinosaurs', 'are', 'going', 'crazy.']"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = \"The Dinosaurs are going crazy.\"\n",
    "p.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "id": "7882a00f-f4e9-4c2f-86dd-eea8c6cfcc45",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['The ', ' Dinosaurs ', ' are ', ' going ', ' crazy.']"
      ]
     },
     "execution_count": 233,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = \"The - Dinosaurs - are - going - crazy.\"\n",
    "p.split(sep = \"-\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "id": "7e149a5f-b42d-4463-81d7-9825a430c20e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['The', ' Dinosaurs', ' are', ' going', ' crazy.']"
      ]
     },
     "execution_count": 237,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = \"The, Dinosaurs, are, going, crazy.\" \n",
    "p.split(sep = \",\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a63ef3b3-0010-426a-abe3-e436f08f97c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# That is how you use the split function and the \n",
    "# separation function inside of it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "5c9e497f-6c5d-46fa-b83b-fb67044d2ac5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now, we can use multiple \"\"\"\" to create a multi-line \n",
    "# string \n",
    "a = \"\"\" Tyrannosaurus \n",
    " Rex \n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "42de23fe-b1d9-4a52-9c72-a4a65fbe840a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Tyrannosaurus \n",
      " Rex \n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "48555dfc-9371-4ea8-8259-ca7da7f5b48a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also use \\n instead of \"\"\"\"\n",
    "b = \"Tyrannosaurus \\nRex\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "bf4717e8-210d-4c1f-9814-6f735c171a63",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tyrannosaurus \n",
      "Rex\n"
     ]
    }
   ],
   "source": [
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91b87fe5-b14a-4e8f-9f14-2b42034bff3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now we are going to replace words in text and also format \n",
    "# which helps with replacing words in text as well. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d8d10161-b4a9-406d-b180-5be2453c9224",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Bye World'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w = \"Hello World\"\n",
    "w.replace(\"Hello\", \"Bye\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d7c69d47-f1ed-4e21-a835-f4c8966ca0e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# we can also combine different things with it; like..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "f67e2961-6d75-4c29-a8ae-fc8b946a0375",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO WORLD'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w.replace(\"Bye\", \"Hello\").upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "78ad7893-cf63-4fff-9066-2247a3b546f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "h = \"{blank} Triceratops is a Dinosaur.\".format(blank = \"The\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "0dc22352-5989-4485-8068-d04b21d6aed9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Triceratops is a Dinosaur.\n"
     ]
    }
   ],
   "source": [
    "print(h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b99084e1-2a28-4b38-b8bd-55306255a6df",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This shit is very cool. This is how you use the format; \n",
    "# The format thing you put in a word and then equate the word\n",
    "# inside of it with the word you want to change it with. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "9b85e617-8885-4852-9766-e0fbcf9e49a4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'THE TRICERATOPS IS A DINOSAUR.'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Now we use upper() and lower() in order to uppercase \n",
    "# and lowercase the words. \n",
    "h.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "0112a943-9e6f-47ad-a0b0-9c0517206491",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'the triceratops is a dinosaur.'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "738d996b-80d5-4575-ad83-8ed5382ca257",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I love Dinosaurs.'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using the strip function, We can also remove spaces from strings. \n",
    "u = \" I love Dinosaurs. \"\n",
    "u.strip()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "2fdad79d-38b5-48e9-b2f2-896410e9dcab",
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is how you use strip() \n",
    "# strip is used to take away unnecessary space from \n",
    "# the words and the !, . , signs. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "a11ab21a-70b1-426b-8f34-23225ab2df3e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'100 is greater than 50'"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Now, we practice using format in order to change and \n",
    "# format the things. \n",
    "'{0} is greater than {1}'.format(100, 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "535d0d71-694b-421a-bc8d-48388b3f1cf6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Above we do not use the equal signs because it is \n",
    "# not strings that we use; those are numbers are above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe30a05d-7a7c-4e7a-b8d7-72dce4652223",
   "metadata": {},
   "outputs": [],
   "source": [
    "# For strings we use the = signs. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "5500d9b4-6205-4737-8083-4cf9791e3149",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Almonte, Rafy'"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"{last}, {first}\".format(first = \"Rafy\", last = \"Almonte\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "770fca17-c975-4e70-adfe-0bbb8024e95a",
   "metadata": {},
   "source": [
    "# List Objects: Review Lecture 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "80b877af-b4ce-4c32-864a-ebb7d835fed3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 6, 89]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List tend to be created with brackets, and they \n",
    "# contain anything from int, str, floats, complex, and other lists. \n",
    "c = [ 1, 4, 6, 89]\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f8b5557-d1d4-4061-b16e-3fb08f12f484",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Above that is a list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "1cf3f03f-aeff-4d73-b5ea-6050f1c33d55",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "b642129f-983e-4565-8086-d0ae1db37425",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 7]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [9]\n",
    "b = [7]\n",
    "a + b \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c92225ed-7abd-4e28-8e13-e7046f62b4d2",
   "metadata": {},
   "outputs": [],
   "source": [
    "# See when you add the list, and when you add the list \n",
    "# it just becomes a longer list. \n",
    "# you can use append and extend it. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "43828f63-0018-4987-a853-b89cf0a5e929",
   "metadata": {},
   "outputs": [],
   "source": [
    "a.append(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "9fa944df-729f-469e-819c-24ab9dd7f962",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, [7]]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "9ef3a651-dd77-44bb-a515-c23beecdbe15",
   "metadata": {},
   "outputs": [],
   "source": [
    "a.extend(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "8040e473-0174-4f46-bb66-108161430a3a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, [7], 7]"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04001c3c-cff8-4adc-a6bd-4a06312deec9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Above you can see that these list tend to be re-written. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "dd4959a0-aae3-44a7-b740-a804e5ffe0d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[38, 90, 38, 90, 38, 90, 38, 90]"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Repeating the elements in the list by using the multiplication \n",
    "# technique that we used for the string. \n",
    "a = [ 38, 90]\n",
    "a*4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30031d30-9600-4e9e-9531-18ad918bb090",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Not only are they repeated, but they are also repeated in \n",
    "# the order that they were made. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "e6da13b7-6076-4386-a9ed-4f35a45b53c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now,  we are going to use the range function \n",
    "# range(start, stop, step) this is what the range function looks like\n",
    "# You can start the list with one number then use a second number \n",
    "# after the comma, and the steps show us by how many increments we want the list \n",
    "# to be. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "fdf83896-b8ab-4e85-b68b-0fcf32ac023e",
   "metadata": {},
   "outputs": [],
   "source": [
    "f = range(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "2a23a5d9-77dc-40ae-9e12-6a891a924728",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 5)"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "505760c5-9799-44e6-9a64-acbe21fe646f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# above you can see that it is not a list but it shows the \n",
    "# 0,5 range \n",
    "# in order to make it a list "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "b7a64856-dc18-48a6-ae84-90fb6e877617",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "f = list(range(5))\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "e3ea99dc-5ce0-4cbe-8bd7-08fecd044e68",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# when the stop number is written the last number is not \n",
    "# shown in the output because the stop number is not inclusive\n",
    "list(range(2, 7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "84a76891-9fe6-4af9-be0c-812b799ed5ea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6]"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# step helsp us with specifying the increments from the list \n",
    "# that we want. \n",
    "list(range(2, 7, 2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "c8fb7be6-0170-4f5e-ae5d-6d9ff2520caa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# in order to find if a number is in the list \n",
    "3 in f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "32129e30-4ab3-4d83-b1dc-e400ff878ea0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 not in f"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9d47eae-b0ae-4aac-9987-ca3b5b079086",
   "metadata": {},
   "source": [
    "# Review of Lecture 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9ff9af9c-6e6d-4c25-8743-477029319127",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3163087-df38-4dbe-ab1d-e13d0a0bc7c0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e64938c-47c3-4404-9492-832a396f7623",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d869922c-e6b5-4430-aca5-72f128826155",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b8cc0b28-80d5-40dd-9f3b-c3d8a626b1b6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5741b3e2-d290-4859-8c76-01e7141bc762",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48fa0edc-bfc4-4b9b-84a4-969857e7f23a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecd08be0-144a-475b-8279-50ff3745604f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}