302_Week_1_values_variables.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "302_Week_1_values_variables.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Milad84/IDCE-302-Python-Programming/blob/main/302_Week_1_values_variables.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KwYvmJqb_kUl"
      },
      "source": [
        "# **Values & Variables**\n",
        "**What is a value?** The basic thing a program works with… letters, numbers, ‘hello world’. Values have different types. Integers (numbers), “floats” (decimals), and strings\n",
        "\n",
        "**What is a variable?** A name that refers to a value. In `n = 17`, “n” is the variable. \n",
        " \n",
        "**What is an operator?** Symbols that represent computation like `+` or `*`. \n",
        "\n",
        "**What is an expression?** A combination of values, variables, and operators. \n",
        "\n",
        "**What is a statement?** A unit of code that a Python interpreter can execute. E.g. in `print(\"Hello World!\")` \"print\" is the Statement and in `my_salary = 250` it is \"my_salary\". \n",
        "\n",
        "**What is an operator?** Symbols that represent computation like `+` or `*`. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SxZn1e8gA2vA"
      },
      "source": [
        "## Exercise\n",
        "1. Assign variables with values\n",
        "2. Check the values of variables\n",
        "3. Check the data type of variables\n",
        "\n",
        "Assign the variables with the following values.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HZZLmQ-U_c_a"
      },
      "source": [
        "# This is a comment\n",
        "message = \"Python version 3 is so much better than version 2.\"\n",
        "n = 17\n",
        "pi = 3.14159"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HAGdFmVEBmUK"
      },
      "source": [
        "Run the code: what happens? \n",
        "Why? \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_FlzDkgHB9BM"
      },
      "source": [
        "## Answer\n",
        "We've assigned variables with values, but we haven't done anything with them. We can use the `print` statement to display them. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BP9rowlKBbrQ"
      },
      "source": [
        "print(message)\n",
        "print(n)\n",
        "print(pi)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S8BGTBsMCKdG"
      },
      "source": [
        "Next we can check the data types for each of our varaibles. This is important when managing data: you need to know what data types you are working with. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VZsLHhtSB17l"
      },
      "source": [
        "type (message)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V4M2R_mvCeLq"
      },
      "source": [
        "type (n)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hNB5XLFECi-C"
      },
      "source": [
        "type (pi)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nAJRzZzUC2pn"
      },
      "source": [
        "# **Good Variable Syntax**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mWNGnYJsDChm"
      },
      "source": [
        "1.   Make it meaningful! Document what the variable is used for.\n",
        "2.   Must be “legal”: cannot use reserved words such as `print`. These are keywords that already have a meaning in Python and can't be reused. [Here are some other keywords](https://docs.python.org/3/reference/lexical_analysis.html#keywords)\n",
        "\n",
        "Follow Python best practices for identifiers: \n",
        "*   Variable names are **CaSE SenSiTIVe!** \n",
        "*   Generaly formatted by starting with a letter A to Z (upper or lower case), an underscore (_) followed by zero or more letters, then underscores and digits (0 to 9)\n",
        "\n",
        "Are these good or bad examples? \n",
        "* `Ru87ChUppaChups90543 = 3.14`\n",
        "* `area_plowed = 17.5`\n",
        "* `distance_traveled_miles = 4`\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-082jw5yEoeF"
      },
      "source": [
        "# **Operators & Strings**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ojn42sK7E1iY"
      },
      "source": [
        "**What's a string?** \n",
        "\n",
        "How does the `+` operator work with strings?\n",
        "A: It concatenates. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1DLJfwX7C8rE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "68ec8b18-5bdf-487d-dc49-576b33a539e5"
      },
      "source": [
        "folder = \"d:/data/ma/\"\n",
        "file_1 = \"roads.shp\"\n",
        "road_layer = folder + file_1\n",
        "print(road_layer)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "d:/data/ma/roads.shp\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LC8AnQFgGBaR"
      },
      "source": [
        "How does the `*` operator work with strings?\n",
        "A: It repeats. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YpbncT1ZFvKt"
      },
      "source": [
        "my_string = \"pointdata\"\n",
        "print(my_string*3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DgBq9MgyGSlb"
      },
      "source": [
        "# **Order of Operations**\n",
        "\n",
        "Remember \"PEDMAS\"\n",
        "\n",
        "Parentheses have the highest precedence. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BQrRKlZ6GL5a"
      },
      "source": [
        "2 * (3-1) "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pv8nJRGSGvSJ"
      },
      "source": [
        "(1+1)*(5-2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uZ9w4vcvHD2m"
      },
      "source": [
        "Exponentiation has the next highest precedence. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jmj8ygvKGw2g"
      },
      "source": [
        "2**1+1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t7sZHodmHPGQ"
      },
      "source": [
        "3*1**3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mk56C0KAHZ_c"
      },
      "source": [
        "Division and multiplication have the same precedence (higher than addition and subtraction).\n",
        "\n",
        "What happens when you have two operators with the same precedence? \n",
        "\n",
        "A: Python works from left to right. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5eBgrlkjHrT_"
      },
      "source": [
        "# **Backslash `(\\)`**\n",
        "`\\` is used to start character sequences which have to be interpreted differently than if the same characters were presented on their own. Examples include: \n",
        "* `\\n` puts things on a new line and \n",
        "* `\\t` creates a tab. \n",
        "\n",
        "This will become important in labs when you need the output of your code to be formatted in a particular way. \n",
        "\n",
        "For Example try the following code and see how `n` is treated differently in each. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ta14gBBtHixn"
      },
      "source": [
        "n = 42\n",
        "print(n)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PGEHbd3oIa5H"
      },
      "source": [
        "print(\"First line \\n Second line\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rn_2iuzmIoJ1"
      },
      "source": [
        "Double backslash `\\\\` are used when you actually want to show slashes! For example, in filenames: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r4_JpPZcIgP3"
      },
      "source": [
        "file_2='d:\\data\\Tanzania\\new_villages.shp'\n",
        "print(file_2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RX54zaYeI36H"
      },
      "source": [
        "What happened and how would you fix it? "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bg5184ElI103"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0DsjhGEmJRdg"
      },
      "source": [
        "`\\` is also important for preserving quotations. We use quotes to signify strings (e.g. `42` versus `\"42\"`) but if you want to keep quotes within quotes... you'll need to use double backslash. Run the code below to see what happens. \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TgP05WWFJ1uC"
      },
      "source": [
        "str1 = \"Have you read \"Things Fall Apart\"?\"\n",
        "print(str1)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7yNjTb6ZJ41p"
      },
      "source": [
        "str2 = \"Have you read \\\"Things Fall Apart\\\"?\"\n",
        "print(str2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1MvzyDHXKdGy"
      },
      "source": [
        "# **Exercise**\n",
        "\n",
        "Create and run a `.py` (Python) script to calculate the area and perimeter of a circle. \n",
        "1. Type code in a new Python Script window or Colab\n",
        "2. Save to local drive using good naming conventions: the file name extension has to be `.py`\n",
        "3. Edit it, add comments \n",
        "4. Check syntax errors \n",
        "5. Run the program \n",
        "6. Save the file to Github!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C5mzG1fXKKjw"
      },
      "source": [
        "pi = 3.14 \n",
        "r = 2.0\n",
        "area = pi *(r**2)\n",
        "perim = 2.0*pi*r \n",
        "print(\"Given r: \", r)\n",
        "print(\"Area is: \", area)\n",
        "print(\"Perimeter is: \", perim)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QHxI0KvWLRWB"
      },
      "source": [
        "So now we have a good working script, but we want to be sure we document our script. We can do this by adding comments using the `#` symbol for \"inline comments\" or putting a \"comment block\" at the top of our could using:\n",
        "` ``` `. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pALFrjcpMHTV"
      },
      "source": [
        "'''\n",
        "This is a comment block. \n",
        "Generally used at the top of a script to explain important info. \n",
        "Inputs / outputs, dependencies, etc.\n",
        "'''\n",
        "\n",
        "my_code = \"Has a comment block.\"\n",
        "print(my_code)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pN4Y6SwdMkjK"
      },
      "source": [
        "my_new_code = \"has inline comments\" # Doesn't make much sense when printed! "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-EpnTO3CM1wm"
      },
      "source": [
        "Here's an ideal way to comment the script we wrote: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QImrPsBCNMsL"
      },
      "source": [
        "\n",
        "\n",
        "\n",
        "pi = 3.14\n",
        "r = 2.0\n",
        "\n",
        "# This line calculates area\n",
        "area = pi *(r**2) \n",
        "\n",
        "# This line calculates perimeter\n",
        "perim = 2.0*pi*r\n",
        "\n",
        "# These lines outputs the results\n",
        "print(\"Given r: \",r)\n",
        "print(\"Area is: \",area)\n",
        "print(\"Perimeter is:\", perim)\n"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}