01_environment.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Notebook 01_Environment\n",
    "\n",
    "Learning objectives for this notebook. \n",
    "The goal of this notebook is to help familarize you with AI supported coding environment. Make sure that by the end of this you know what are: \n",
    "- different parts of Cursor (vscode) \n",
    "- Jupyter notebooks \n",
    "- Kernels / environments / conda \n",
    "- Git \n",
    "- Key libraries (numpy, pandas)\n",
    "- Debugger\n",
    "\n",
    "This notebook is CRITIAL and while it has many boring techincal details, without mastering all the terms here, you will get lost. Ask me as your robot if you are not sure. \n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Overview Cursor/ VScode has:\n",
    "* main editor \n",
    "* left panel (outline, git, search, extensions)\n",
    "* bottom panel (terminal, debug, problems, output)\n",
    "* right panel (your robot chatbox)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Put some thoughts into your files and filenames\n",
    "\n",
    "* Name your notebook in reasonable names. \n",
    "* If you use one of my notebooks as starting point, RENAME IT\n",
    "* If you are using .py files for additional code think of names and file location\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Jupyter Notebooks\n",
    "\n",
    "Jupyter notebooks are an open-source web application that allows you to create and share documents that contain live code, equations, visualizations and narrative text. They are widely used in data cleaning and transformation, numerical simulation, statistical modeling, data visualization, machine learning, and much more."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Jupyter!\n"
     ]
    }
   ],
   "source": [
    "# This is a code cell. You can write and execute Python code here.\n",
    "print(\"Hello, Jupyter!\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If this is the first time you are running this, you will get a pop-up menu asking for environment. Here is what the robot has to say about these: "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environments and Kernels in Jupyter Notebooks\n",
    "\n",
    "In Jupyter notebooks, a **kernel** is a computational engine that executes the code contained in your notebook. When you run a code cell, that code is executed within the kernel and any output is returned back to the cell to be displayed. The kernel maintains the state of a notebook's computations, which means you can think of it as a \"live\" version of your notebook's code.\n",
    "\n",
    "You can have kernels for different programming languages, each of which can be used to execute code in a different language. For example, if you're working in a Python 3 notebook, your kernel is a Python 3 kernel and all of your code is executed as Python 3 code.\n",
    "\n",
    "An **environment** in a Jupyter notebook is a context in which your notebook runs. This context includes the kernel, a set of libraries and modules, and the settings for the notebook. When you create a new notebook, you can choose which environment (and therefore, which kernel and libraries) you want to use.\n",
    "\n",
    "You can manage your environments with conda or virtualenv to create isolated spaces for your projects, which can have their own specific versions of Python and installed packages. This can be useful if different projects require different versions of Python or different libraries."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Restarting a Kernel in Jupyter Notebooks\n",
    "\n",
    "The kernel maintains the state of a notebook's computations. This means it keeps track of the variables and their values, loaded modules, defined functions, and more. When you restart the kernel, you're essentially resetting this computational environment.\n",
    "\n",
    "Here's what happens when you restart a kernel:\n",
    "\n",
    "1. **All variables and functions defined in the notebook are lost**: Since the kernel maintains the state of the notebook's computations, when it's restarted, all Python objects defined in the previous session are lost.\n",
    "\n",
    "2. **The notebook's output remains, but it's no longer connected to the code**: After a kernel restart, the output from cells run in the previous session still appears in the notebook, but it's no longer connected to the code. This means that if you had a cell that displayed the value of a variable, after a kernel restart, the value will still be displayed, but the variable itself will no longer be defined.\n",
    "\n",
    "3. **You start with a clean slate**: After a kernel restart, you're starting with a fresh Python environment. This is equivalent to restarting Python itself.\n",
    "\n",
    "Restarting the kernel can be useful in various situations. For example, if your code is stuck in an infinite loop, or if it's using up too much memory or CPU and you need to stop it, you can restart the kernel to stop the computations. It's also useful when you want to ensure that your code runs correctly from start to finish without relying on any previous computations or variables."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Install conda on your system \n",
    "\n",
    "(you should have done it already!)\n",
    "\n",
    "If you didn't install conda please check: https://docs.conda.io/projects/conda/en/4.6.0/user-guide/install/index.html\n",
    "\n",
    "install miniconda or anaconda: \n",
    "Anaconda comes with more stuff - less stuff to install later, but takes more space\n",
    "Miniconda is minimalistic - less space more stuff to install later"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conda Environments\n",
    "\n",
    "Conda is an open-source package management system and environment management system that runs on Windows, macOS, and Linux. Conda installs, runs, and updates packages and their dependencies. It also allows you to easily create, save, load, and switch between environments on your local computer.\n",
    "\n",
    "A **conda environment** is an isolated directory that contains a specific collection of conda packages (and accordingly, specific versions of Python and other libraries). When you create an environment, you can specify which Python version to use and which packages to install into the environment.\n",
    "\n",
    "This can be very useful if you're working on multiple projects that require different versions of Python or different libraries. By creating a separate conda environment for each project, you can switch between them without any conflicts.\n",
    "\n",
    "Here's an example of how to create a new conda environment:\n",
    "\n",
    "Please note that the next few cells are not a Python but a Shell scripts (I prefer command line for all conda work)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "shellscript"
    }
   },
   "outputs": [],
   "source": [
    "conda create --name myenv python=3.11"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, `myenv` is the name of the new environment, and `python=3.6` specifies that Python version 3.6 should be installed in the environment.\n",
    "\n",
    "To activate the environment, you would use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "shellscript"
    }
   },
   "outputs": [],
   "source": [
    "conda activate myenv"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And to deactivate it, you would use:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "shellscript"
    }
   },
   "outputs": [],
   "source": [
    "conda deactivate"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installing Packages in a Conda Environment\n",
    "\n",
    "Once you've activated a conda environment, you can install additional packages into that environment using the conda install command. For example, to install the numpy package, you would use:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "vscode": {
     "languageId": "shellscript"
    }
   },
   "outputs": [],
   "source": [
    "conda install numpy \n",
    "# or \n",
    "conda install numpy=1.18.1 # if you care about version "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "To check which packages are installed in the current environment, you can use the `conda list` command:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "vscode": {
     "languageId": "shellscript"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# packages in environment at /Users/rwollman/opt/miniconda3/envs/chem269:\n",
      "#\n",
      "# Name                    Version                   Build  Channel\n",
      "appnope                   0.1.3              pyhd8ed1ab_0    conda-forge\n",
      "asttokens                 2.4.0              pyhd8ed1ab_0    conda-forge\n",
      "backcall                  0.2.0              pyh9f0ad1d_0    conda-forge\n",
      "backports                 1.0                pyhd8ed1ab_3    conda-forge\n",
      "backports.functools_lru_cache 1.6.5              pyhd8ed1ab_0    conda-forge\n",
      "blas                      1.0                    openblas  \n",
      "brotli                    1.0.9                h1a28f6b_7  \n",
      "brotli-bin                1.0.9                h1a28f6b_7  \n",
      "bzip2                     1.0.8                h620ffc9_4  \n",
      "ca-certificates           2023.08.22           hca03da5_0  \n",
      "comm                      0.1.4              pyhd8ed1ab_0    conda-forge\n",
      "contourpy                 1.0.5           py311h48ca7d4_0  \n",
      "cycler                    0.11.0             pyhd3eb1b0_0  \n",
      "debugpy                   1.6.7           py311h313beb8_0  \n",
      "decorator                 5.1.1              pyhd8ed1ab_0    conda-forge\n",
      "exceptiongroup            1.1.3              pyhd8ed1ab_0    conda-forge\n",
      "executing                 1.2.0              pyhd8ed1ab_0    conda-forge\n",
      "fonttools                 4.25.0             pyhd3eb1b0_0  \n",
      "freetype                  2.12.1               h1192e45_0  \n",
      "giflib                    5.2.1                h80987f9_3  \n",
      "importlib-metadata        6.8.0              pyha770c72_0    conda-forge\n",
      "importlib_metadata        6.8.0                hd8ed1ab_0    conda-forge\n",
      "ipykernel                 6.25.2             pyh1050b4e_0    conda-forge\n",
      "ipython                   8.16.1             pyh31c8845_0    conda-forge\n",
      "jedi                      0.19.1             pyhd8ed1ab_0    conda-forge\n",
      "jpeg                      9e                   h80987f9_1  \n",
      "jupyter_client            8.4.0              pyhd8ed1ab_0    conda-forge\n",
      "jupyter_core              5.3.0           py311hca03da5_0  \n",
      "kiwisolver                1.4.4           py311h313beb8_0  \n",
      "lcms2                     2.12                 hba8e193_0  \n",
      "lerc                      3.0                  hc377ac9_0  \n",
      "libbrotlicommon           1.0.9                h1a28f6b_7  \n",
      "libbrotlidec              1.0.9                h1a28f6b_7  \n",
      "libbrotlienc              1.0.9                h1a28f6b_7  \n",
      "libcxx                    14.0.6               h848a8c0_0  \n",
      "libdeflate                1.17                 h80987f9_1  \n",
      "libffi                    3.4.4                hca03da5_0  \n",
      "libgfortran               5.0.0           11_3_0_hca03da5_28  \n",
      "libgfortran5              11.3.0              h009349e_28  \n",
      "libopenblas               0.3.21               h269037a_0  \n",
      "libpng                    1.6.39               h80987f9_0  \n",
      "libsodium                 1.0.18               h27ca646_1    conda-forge\n",
      "libtiff                   4.5.1                h313beb8_0  \n",
      "libwebp                   1.3.2                ha3663a8_0  \n",
      "libwebp-base              1.3.2                h80987f9_0  \n",
      "llvm-openmp               14.0.6               hc6e5704_0  \n",
      "lz4-c                     1.9.4                h313beb8_0  \n",
      "matplotlib                3.7.2           py311hca03da5_0  \n",
      "matplotlib-base           3.7.2           py311h7aedaa7_0  \n",
      "matplotlib-inline         0.1.6              pyhd8ed1ab_0    conda-forge\n",
      "munkres                   1.1.4                      py_0  \n",
      "ncurses                   6.4                  h313beb8_0  \n",
      "nest-asyncio              1.5.8              pyhd8ed1ab_0    conda-forge\n",
      "numpy                     1.26.0          py311he598dae_0  \n",
      "numpy-base                1.26.0          py311hfbfe69c_0  \n",
      "openjpeg                  2.3.0                h7a6adac_2  \n",
      "openssl                   3.0.11               h1a28f6b_2  \n",
      "packaging                 23.2               pyhd8ed1ab_0    conda-forge\n",
      "parso                     0.8.3              pyhd8ed1ab_0    conda-forge\n",
      "pexpect                   4.8.0              pyh1a96a4e_2    conda-forge\n",
      "pickleshare               0.7.5                   py_1003    conda-forge\n",
      "pillow                    10.0.1          py311h3b245a6_0  \n",
      "pip                       23.2.1          py311hca03da5_0  \n",
      "platformdirs              3.11.0             pyhd8ed1ab_0    conda-forge\n",
      "prompt-toolkit            3.0.39             pyha770c72_0    conda-forge\n",
      "prompt_toolkit            3.0.39               hd8ed1ab_0    conda-forge\n",
      "psutil                    5.9.0           py311h80987f9_0  \n",
      "ptyprocess                0.7.0              pyhd3deb0d_0    conda-forge\n",
      "pure_eval                 0.2.2              pyhd8ed1ab_0    conda-forge\n",
      "pygments                  2.16.1             pyhd8ed1ab_0    conda-forge\n",
      "pyparsing                 3.0.9           py311hca03da5_0  \n",
      "python                    3.11.5               hb885b13_0  \n",
      "python-dateutil           2.8.2              pyhd8ed1ab_0    conda-forge\n",
      "pyzmq                     25.1.0          py311h313beb8_0  \n",
      "readline                  8.2                  h1a28f6b_0  \n",
      "scipy                     1.11.3          py311hc76d9b0_0  \n",
      "setuptools                68.0.0          py311hca03da5_0  \n",
      "six                       1.16.0             pyh6c4a22f_0    conda-forge\n",
      "sqlite                    3.41.2               h80987f9_0  \n",
      "stack_data                0.6.2              pyhd8ed1ab_0    conda-forge\n",
      "tk                        8.6.12               hb8d0fd4_0  \n",
      "tornado                   6.3.3           py311h80987f9_0  \n",
      "traitlets                 5.11.2             pyhd8ed1ab_0    conda-forge\n",
      "typing-extensions         4.8.0                hd8ed1ab_0    conda-forge\n",
      "typing_extensions         4.8.0              pyha770c72_0    conda-forge\n",
      "tzdata                    2023c                h04d1e81_0  \n",
      "wcwidth                   0.2.8              pyhd8ed1ab_0    conda-forge\n",
      "wheel                     0.41.2          py311hca03da5_0  \n",
      "xz                        5.4.2                h80987f9_0  \n",
      "zeromq                    4.3.4                hc377ac9_0  \n",
      "zipp                      3.17.0             pyhd8ed1ab_0    conda-forge\n",
      "zlib                      1.2.13               h5a0b063_0  \n",
      "zstd                      1.5.5                hd90d995_0  \n",
      "\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "conda list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## this is a title\n",
    "* bullet item 1\n",
    "* bullet ite 2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cells in Jupyter Notebooks\n",
    "\n",
    "A Jupyter notebook is made up of a sequence of cells. Each cell can contain either executable code or formatted text. There are three types of cells in a Jupyter notebook:\n",
    "\n",
    "1. **Code cells**: These cells contain executable code. When you run a code cell, the code is executed by the notebook's kernel and the output is displayed below the cell. The output could be text, a plot, or any other kind of media that the code produces.\n",
    "\n",
    "2. **Markdown cells**: These cells contain text formatted using Markdown, a lightweight markup language. You can use Markdown to create formatted text with headers, links, bullet lists, etc. When you run a Markdown cell, the Markdown code is converted into formatted text.\n",
    "\n",
    "3. **Raw cells**: These cells are not formatted or executed by the notebook. They can be used to write output directly.\n",
    "\n",
    "Under the hood, when you run a cell, Jupyter sends the contents of the cell to the notebook's kernel. The kernel executes the code or formats the text and sends the output back to Jupyter, which displays it below the cell.\n",
    "\n",
    "You can switch between different types of cells using the dropdown menu in the toolbar, or with keyboard shortcuts. By default, new cells are code cells."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jupyter \"Magic\" Commands\n",
    "\n",
    "Jupyter notebooks have special commands known as \"magic\" commands. These are not part of Python - they are commands that the Jupyter notebook software understands. There are two types of magic commands - line magics, which are prefixed by a single `%`, and cell magics, which are prefixed by `%%`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 10.6 ms, sys: 559 µs, total: 11.2 ms\n",
      "Wall time: 10.9 ms\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "499999500000"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "sum(range(1000000))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Libraries and the Import Command in Python\n",
    "\n",
    "In Python, a **library** is a collection of modules, where a module is a file containing Python definitions and statements. Libraries can include functions, classes, and variables that allow you to perform many actions without writing your own code.\n",
    "\n",
    "Python comes with a standard library, and there are many additional libraries available that provide extended functionality for a variety of tasks. Some commonly used Python libraries include numpy for numerical computing, pandas for data manipulation, matplotlib for plotting, and scikit-learn for machine learning.\n",
    "\n",
    "To use a library in your Python code, you need to import it. The import statement allows you to use the functions, classes, and variables defined in the library. Here's an example:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from numpy import *\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, `numpy` is the library being imported, and `np` is an alias we're assigning to it. This alias allows us to use the shorter `np` instead of `numpy` when calling functions from the library. For example, to call the `array` function from `numpy`, we can use `np.array` instead of `numpy.array`."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Git and GitHub\n",
    "\n",
    "**Git** is a distributed version control system that allows multiple people to work on a project at the same time without overwriting each other's changes. It tracks changes to a codebase, keeps a history of all past versions of the project, and allows you to revert back to any previous version if needed. Git is widely used in software development, and it's an essential tool for any developer.\n",
    "\n",
    "**GitHub** is a web-based hosting service for Git repositories. In addition to all of the version control features of Git, GitHub also adds its own features, such as a web-based graphical interface, access control, collaboration features like bug tracking and feature requests, task management, continuous integration, and more.\n",
    "\n",
    "With GitHub, you can host and manage your Git repositories in a user-friendly way. You can also contribute to other people's projects, share your projects with the world, and collaborate with other developers."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using Git: Stage, Commit, Pull, and Push\n",
    "\n",
    "1. **Stage Changes**: Before you can commit changes in Git, you need to stage them. Staging is a way to select which changes you want to commit. To stage changes, you use the git add command followed by the files you want to stage. If you want to stage all changes, you can use git add ..\n",
    "\n",
    "2. **Commit Changes**: Once you've staged your changes, you can commit them to your local repository with the git commit command. This command takes a message describing the changes you're committing. For example: git commit -m \"Your descriptive message here\".\n",
    "\n",
    "3. **Pull Changes**: If you're working with others, you'll want to pull their changes into your local repository so that you're working with the latest version of the project. You can do this with the git pull command. This command fetches changes from the remote repository and merges them into your current branch.\n",
    "\n",
    "4. **Push Changes**: After you've committed your changes, you can push them to the remote repository so that others can see and use your changes. You can do this with the git push command. If you're pushing to a branch for the first time, you'll need to use git push -u origin your-branch-name."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Git Integration in Visual Studio Code\n",
    "\n",
    "Visual Studio Code (VS Code) has built-in support for Git and includes a variety of features that make it easy to use Git within the editor. Here are some of the key features:\n",
    "\n",
    "1. **Source Control View**: VS Code has a dedicated view for source control where you can see all of your changes and commits. You can stage changes, commit them, switch branches, and more, all directly from this view.\n",
    "\n",
    "2. **Diff Viewer**: VS Code has a built-in diff viewer that allows you to see changes between different versions of files. You can easily navigate between changes and see them highlighted in the code.\n",
    "\n",
    "3. **Git Commands in Command Palette**: All Git commands are available in the Command Palette. You can open the Command Palette with Ctrl+Shift+P (or Cmd+Shift+P on macOS) and then type any Git command.\n",
    "\n",
    "4. **Git Status in Status Bar**: The status bar at the bottom of the VS Code window shows the current branch and the number of changes. You can click on these items to quickly access Git features.\n",
    "\n",
    "5. **GitLens Extension**: While not part of VS Code's built-in Git support, the GitLens extension adds many powerful features, such as blame annotations, line and file history, commit searching, and more.\n",
    "\n",
    "With these features, VS Code provides a comprehensive and integrated Git experience that supports a wide range of Git workflows."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Demo git workflow"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction to Numpy and Pandas\n",
    "\n",
    "**Numpy** (Numerical Python) is a powerful Python library that supports large, multi-dimensional arrays and matrices, along with a large collection of high-level mathematical functions to operate on these arrays. It provides an efficient way to handle large amounts of data and perform computations on them.\n",
    "\n",
    "Here's an example of how to use Numpy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "zeeros = np.zeros(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zeeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Create a 1D array\n",
    "a = np.array([1, 2, 3])\n",
    "print(a)\n",
    "\n",
    "b = np.array([[1,2,]])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Pandas** (Python Data Analysis Library) is another powerful Python library used for data manipulation and analysis. It provides data structures and functions needed to manipulate structured data, including functions for reading and writing data in a variety of formats.\n",
    "\n",
    "Pandas introduces two new data structures to Python - Series and DataFrame, both of which are built on top of Numpy.\n",
    "\n",
    "Here's an example of how to use Pandas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   apples  oranges\n",
      "0       3        0\n",
      "1       2        3\n",
      "2       0        7\n",
      "3       1        2\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Create a simple dataframe\n",
    "data = {\n",
    "'apples': [3, 2, 0, 1],\n",
    "'oranges': [0, 3, 7, 2]\n",
    "}\n",
    "purchases = pd.DataFrame(data)\n",
    "print(purchases)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_function(x): \n",
    "    y=x+1\n",
    "    return y\n",
    "\n",
    "z=3\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "u=4\n",
    "v=my_function(u)\n",
    "print(v)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Finally: \n",
    "## <span style='color:orange'>Most of this notebook was generated with a Robot, if you need any more help - ASK YOUR ROBOT!</span>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "chem269",
   "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"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}