Week_1/Python_Basics_02_-_Syntax_And_Basic_Statements.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href='https://www.learntocodeonline.com/'><img src=\"../IMGs/learn-to-code-online.png\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Need to go back to Week 1?_ Click **[here](../Week_1)**!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Code Blocks, Suites, And Headers\n",
    "\n",
    "A **code block** is a block of code that does some action.\n",
    "\n",
    "A **suite** is a group of individual statements that make up code blocks.\n",
    "\n",
    "The **header line** is either the beginning of a function or logic statement.\n",
    "\n",
    "Here's a pseudo code example using logic statements as the header lines:\n",
    "\n",
    "```python\n",
    "# beginning of code block\n",
    "if expression:    # header line\n",
    "    suite\n",
    "elif expression:\n",
    "    suite\n",
    "else:\n",
    "    suite\n",
    "# end of code block\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Indentation\n",
    "\n",
    "Unlike **[Java](https://docs.oracle.com/javase/8/docs/technotes/guides/language/index.html)**, pythonic blocks of code are denoted by line indentation instead of curly braces or semicolons.\n",
    "\n",
    "```python\n",
    "x = 1\n",
    "if x == 1:\n",
    "    print('x is 1')\n",
    "```\n",
    "\n",
    "All statements within a **code block** MUST be indented the same amount with 4 spaces per indentation! (Unless it's a code block within a code block - then you just add 4 more spaces per sub-block.)\n",
    "\n",
    "```python\n",
    "a = 1\n",
    "if a < 2:\n",
    "    print('less than 2')\n",
    "    if a > 0:\n",
    "        print('greater than 0')\n",
    "    else:\n",
    "        print('negative number')\n",
    "```\n",
    "\n",
    "Tabs are also acceptable, but be sure to review [PEP 8](https://www.python.org/dev/peps/pep-0008) - the style guide for python code. Or more specifically, the section on [tabs vs spaces](https://www.python.org/dev/peps/pep-0008/#tabs-or-spaces)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multi-Line Statements\n",
    "\n",
    "Typically python code ends a new line with a new line character. But it does provide the ability for [Multi-Line Statements](http://www.tutorialspoint.com/python3/python_basic_syntax.htm).\n",
    "\n",
    "1. Using `\\` will allow a really long line (80 or more characters) to be split into multiple lines.\n",
    "\n",
    "```python\n",
    "temp = item1 + \\\n",
    "    item2 +\\\n",
    "    item3\n",
    "```\n",
    "\n",
    "2. Statements contained in `[]`, `{}`, or `()`\n",
    "\n",
    "```python\n",
    "temp = [item1, item2,\n",
    "    item3]\n",
    "```\n",
    "\n",
    "[PEP 8](https://www.python.org/dev/peps/pep-0008) also discusses things like:\n",
    "- [max line length](https://www.python.org/dev/peps/pep-0008/#maximum-line-length) (79 characters)\n",
    "- [line breaks before/after operators](https://www.python.org/dev/peps/pep-0008/#should-a-line-break-before-or-after-a-binary-operator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [Comments](https://www.python.org/dev/peps/pep-0008/#comments)\n",
    "\n",
    "A **comment** is a single line of code that is basically ignored when you run a python program.\n",
    "\n",
    "There is **only one way** to comment - using a `#` will make a line a comment.\n",
    "\n",
    "Some people say you can use triple quotes:\n",
    "- `'''something here'''`\n",
    "- `\"\"\"something here\"\"\"`\n",
    "\n",
    "In order to comment - this is **not** the case. This is only used to create documentation (or [docstrings](https://www.python.org/dev/peps/pep-0257)). This creates a **[string object](https://docs.python.org/3/tutorial/introduction.html#strings)** so therefore it _does not_ create a comment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [Print](https://docs.python.org/3/library/functions.html#print) Statements\n",
    "\n",
    "**Print statements** allow you to print data. This can be any data type, but be aware of how you need to print said data.\n",
    "\n",
    "`print(some_info)`\n",
    "\n",
    "And you can also do some pretty cool [string formatting](https://docs.python.org/3/tutorial/inputoutput.html) with this, but that will come later.\n",
    "\n",
    "[Here](https://realpython.com/python-string-formatting/) are some suggested best practices for string formatting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hello World\n",
    "\n",
    "This is where you will be able to create your very first program:  `Hello World!`\n",
    "\n",
    "In every programming language, this is generally the very first thing you must do in order to ensure you can make even more extensive programs.\n",
    "\n",
    "When you are able to successfully do this, you know you have properly installed everything you need for the time being.\n",
    "\n",
    "And how do you confirm this in Python?\n",
    "\n",
    "<div class=\"alert alert-success\">\n",
    "<b>Try this!</b>\n",
    "\n",
    "```python\n",
    "print('Hello World!')\n",
    "```\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Things To Know About print()\n",
    "\n",
    "After every print statement, a newline character is added.\n",
    "\n",
    "<div class=\"alert alert-success\">\n",
    "<b>Try this!</b>\n",
    "\n",
    "```python\n",
    "print('Line 1\\nThis is a new line!')\n",
    "print()    # prints \"\\n\" (newline)\n",
    "print('Line 3')\n",
    "```\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The **print** function can pass in 0 or more expressions, however you need to have a `,` in between.\n",
    "\n",
    "If using the comma, it will print each piece of data on the same line separated by a space.\n",
    "\n",
    "<div class=\"alert alert-success\">\n",
    "<b>Try this!</b>\n",
    "\n",
    "```python\n",
    "print(1, \"two\")\n",
    "```\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "    <i>If <a href=\"https://jakevdp.github.io/WhirlwindTourOfPython/03-semantics-variables.html#:~:text=Python%20is%20an%20object%2Doriented,Python%20everything%20is%20an%20object.&text=In%20Python%20everything%20is%20an%20object%2C%20which%20means%20every%20entity,accessed%20via%20the%20dot%20syntax.\">everything is an object</a>, can you pass in a function? What do you think will be returned? - This will be covered in bootcamp week 2!</i>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Final Thoughts\n",
    "\n",
    "In **_python2_** the **print** function did not require parentheses.\n",
    "\n",
    "_python2_:  `print \"This line will be printed\"`\n",
    "<br>_python3_:  `print(\"This line will be printed\")`\n",
    "\n",
    "By doing this, **python3** was able to move towards a better representation to show that print was a function - something that we will cover later on.\n",
    "\n",
    "<hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [Memory Management](https://docs.python.org/3/c-api/memory.html) In Python\n",
    "\n",
    "There are plenty of articles out there to help provide more clarity on memory management with python like with [this article from Real Python](https://realpython.com/python-memory-management/) or [this one from Towards Data Science](https://towardsdatascience.com/memory-management-in-python-6bea0c8aecc9). But here's a high leel of what you should consider:\n",
    "\n",
    "1. Generally, when your program ends the built in garbage collector cleans up after you.\n",
    "2. Every time you create a new object, imagine a pointer that points to a particular section of data on your harddrive.\n",
    "3. It is best practice to delete (*free up*) objects when you know you no longer need them (*e.g.:  temporary data*)\n",
    "4. If not mindful of your data management, you could be setting yourself up for failure. (*e.g.:  memory leaks*)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignment Statements\n",
    "\n",
    "These kinds of statements are assigning a label (or variable name) to a set of data.\n",
    "\n",
    "In other words, a **variable** name (*a.k.a. label*) points to a *specific section of memory* that holds some data.\n",
    "\n",
    "A **label** is simply a way to refer to that **variable**.\n",
    "\n",
    "One thing to keep in mind? Python, like several other programming languages, reads information starting from right to left.\n",
    "\n",
    "For example:  `a = 1`\n",
    "\n",
    "The above statement reads as:<br>\n",
    "*`int` 1 is assigned to the variable name (label) `a`*\n",
    "\n",
    "\n",
    "## Easily Create New Tuples!\n",
    "\n",
    "If you add a comma to multiple items on the right side, Python will convert the data to a tuple.\n",
    "\n",
    "<div class=\"alert alert-success\">\n",
    "<b>Try this!</b>\n",
    "\n",
    "```python\n",
    "a = 1, 2    # this is an assignment statement\n",
    "print(a)\n",
    "a           # this is just to show you what is in 'a'\n",
    "```\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "<b>NOTE:</b>  Did you notice the difference in outputs above? Why do you think it looks this way?\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "<b>Try this!</b>\n",
    "\n",
    "```python\n",
    "b = \"this\"\n",
    "c = \"that\"\n",
    "a = a, b, c\n",
    "a\n",
    "```\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Single Assignment Statements\n",
    "\n",
    "These are the ones you will normally see in most code. It's clean and precise.\n",
    "\n",
    "<div class=\"alert alert-success\">\n",
    "<b>Try this!</b>\n",
    "\n",
    "```python\n",
    "variableName = \"This is of variable type: \\t string.\"\n",
    "print(variableName)    # this is a print statement\n",
    "variableName           # this is not a print statement\n",
    "```\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "<i>Seem familiar?</i>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple Assignment Statements\n",
    "\n",
    "There are 2 different ways you can utilize multiple assignment statement options.\n",
    "\n",
    "### One Variable, Multiple Labels\n",
    "\n",
    "In this instance, \"variable\" refers to a memory location. And \"label\" refers to the name that references that location.\n",
    "\n",
    "<div class=\"alert alert-success\">\n",
    "<b>Try this!</b>\n",
    "\n",
    "```python\n",
    "a = b = c = 1    # labels a, b, c point to memory location where int 1 is at on run time\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "```\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "<b>Try this!</b>\n",
    "\n",
    "```python\n",
    "print(a==b)\n",
    "```\n",
    "</div>\n",
    "\n",
    "**NOTE:** We will learn more about [comparisons](Python_Basics_04_-_Operators.ipynb) later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "<b>Try this!</b>\n",
    "\n",
    "```python\n",
    "print(a is b)     # meaning this points to the same memory location\n",
    "```\n",
    "</div>\n",
    "\n",
    "[This is a great article from GeeksForGeeks](https://www.geeksforgeeks.org/difference-operator-python/) that covers the difference between a comparison operator and checking if the memory location is the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Multiple Assignment Statements\n",
    "\n",
    "### Each Label Is Assigned To A Different Memory Location (Variable)\n",
    "\n",
    "Pretty straight forward but might look something like this ...\n",
    "\n",
    "<div class=\"alert alert-success\">\n",
    "<b>Try this!</b>\n",
    "\n",
    "```python\n",
    "a, b, c = 1, 2, \"John\"\n",
    "print(a, \" \\t\", type(a))\n",
    "print(b, \" \\t\", type(b))\n",
    "print(c, \" \\t\", type(c))\n",
    "```\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "<b>Try this!</b>\n",
    "\n",
    "```python\n",
    "_, a, _ = 1, 2, \"John\"\n",
    "print(a, \" \\t\", type(a))\n",
    "print(_, \" \\t\", type(_))\n",
    "```\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "Consider reviewing <a href=\"https://www.datacamp.com/community/tutorials/role-underscore-python\">this</a> on the role of the underscore in python. Great reading for later.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\">\n",
    "<b>Try this!</b> (tuple or star unpacking)\n",
    "\n",
    "```python\n",
    "a, *b = 1, 2, \"John\"\n",
    "print(a, \" \\t\", type(a))\n",
    "print(b, \" \\t\", type(b))\n",
    "```\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "Consider checking out star unpacking in <a href=\"https://github.com/ProsperousHeart/TrainingUsingJupyter/blob/master/Python/Recipes/Data%20Structures%20And%20Algorithms%2000%20-%20Unpacking%20And%20Deque.ipynb\">this Jupyter notebook</a> (it's suggested you download and run from your machine). Or just read up on <a href=\"https://www.python.org/dev/peps/pep-3132/\">PEP 3132</a>\n",
    "</div>"
   ]
  }
 ],
 "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.10.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}