03. Variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Variables\n",
    "\n",
    "![chickens](https://apmonitor.com/che263/uploads/Begin_Python/chickens.png)\n",
    "\n",
    "Variables store information and are objects in Python. For example, if you wanted to keep a set temperature for an egg, you would type ```egg = 37.5``` (°C) or ```egg = 99.5``` (°F). The first part tells what the variable will be called, and the value after the ```=``` tells what is being stored. \n",
    "\n",
    "[Python Playlist on YouTube](https://www.youtube.com/watch?v=q6QOsauDyPg&list=PLLBUgWXdTBDi3J05aMVG1knUpqRhkbc46)",
    "\n",
    "[![Variable Types](https://apmonitor.com/che263/uploads/Begin_Python/BeginPython03.png)](https://www.youtube.com/watch?v=q6QOsauDyPg&list=PLLBUgWXdTBDi3J05aMVG1knUpqRhkbc46 \"Variable Types\")\n",
    "\n",
    "### Types of Variables\n",
    "\n",
    "![idea](https://apmonitor.com/che263/uploads/Begin_Python/idea.png)\n",
    "\n",
    "There are many types of value types but for now, we’ll just go through the basics. You can run the code, but in this case the computer won't tell you anything, because it is only storing values. \n",
    "\n",
    "While you can run a program by clicking the run button towards the top of the screen, a better way to run cells individually is to click a cell, then type ```Ctrl``` and ```Enter```. Running this way means you're running one cell at a time, instead of all cell. Jupyter Notebooks can also have the run button to the left of the program cell."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Integers\n",
    "Integers, or ```int```, are the value of a basic, whole number like ```99```. You can use the function `int(99.5)` to convert a number to an integer `99` as it removes any numbers after the decimal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "temp = 99"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Floats\n",
    "Floating point numbers, or ```float```, are also numbers, but with decimals like ```4.72```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "price = 34.09"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Strings\n",
    "Strings, or ```str```, are words or text, usually typed like ```\"hi\"```. You can use double ```\"\"``` or single ```''``` quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greeting = \"hi\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Boolean\n",
    "Boolean, or ```bool```, is a ```True``` or ```False``` value. They both need to start with a capital letter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "answer = True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comments \n",
    "Comments are ignored by Python and are words in a program to explain the code. They are created with the ```#``` symbol and can appear to the right of a statement or on a separate line."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "variable = \"random\" # This is a comment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rules of Variables\n",
    "\n",
    "![list](https://apmonitor.com/che263/uploads/Begin_Python/list.png)\n",
    "\n",
    "#### Variable Naming\n",
    "In order to properly name a variable, it can only start with a __letters__ or an __underscore__. After the first character you can use __letters, __numbers__, and __underscores__. \n",
    "\n",
    "##### Python variables can start with:\n",
    "\n",
    "```_``` or **letters** (Recommended to start with lowercase)\n",
    "\n",
    "##### And are continued with:\n",
    "\n",
    "**Numbers** ```0-9``` ,**letters**, and __underscores__. Example:\n",
    "\n",
    "```python\n",
    "_this_is_a_variable_27 = \"Incubator Temperature Control\"```\n",
    "\n",
    "If you want to check your understanding, run incorrect variables and then fix the variable names to whatever you want. Make sure the variable name follows the naming rules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "375 = \"Important Egg Data\"  # Can't start with a number, change it to something else\n",
    "\n",
    "badtemp$ = 6 # Look for the symbol, delete it"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable Properties\n",
    "Variables can be assigned a value such as a string, integer, or float. If you assign them again later in the code it simply changes to that new assignment. For example, the code below would first use ```3``` for ```test```, but after would use ```egg``` instead. Unlike other programming languages, Python variables are mutable (can change type). You can see the variable type with `type(test)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test = 3\n",
    "test = \"egg\"\n",
    "type(test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable Usage\n",
    "Variables can be used in math or when you are trying to show a result, which is very useful but they do have restrictions. Different types of values typically can't be added together, such as ```5 + \"degC\"```. This can be fixed if you need __5degC__ to be output. Change the value type of ```5``` manually into a __string__, ```str(5) + \"degC\"```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "combined_str = \"right\" + 'left'\n",
    "combined_int = 4 + 2\n",
    "combined_int_str = str(5) + \"degC\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Activity\n",
    "\n",
    "![expert](https://apmonitor.com/che263/uploads/Begin_Python/expert.png)\n",
    "\n",
    "Make one variable for every variable type, string, integer, float, and boolean.\n",
    "\n",
    "(The ```#``` symbol makes the text behind it a comment. Those words are just for discribing the program, they don't do anything to the code.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = \n",
    "integer = \n",
    "float1 =      # \"float\" in code is already assigned so it's changed to something else, to avoid errors\n",
    "boolean = "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try making your own variable to store your chicken's name. Make sure to change the assignment name from ```yourVariable``` to what the information is about so you remember. \n",
    "\n",
    "Then combine the variables, ```x``` and ```y```, below by changing their types to __strings__. If you get stuck, the example just above changes ```integer``` 5 into a string. Use the same code on x and y."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ChickenName = \n",
    "x = True             # This is a Boolean\n",
    "y = 236.4            # This is a float\n",
    "combined = x + y     # Make x and y strings"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}