Lesson_00_B - Introduction to Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d3e128f1-06c0-435e-ad60-bb03787705b5",
   "metadata": {},
   "source": [
    "# Lesson 00 - Introduction to Python 🐍"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af177b89-7b81-4845-b5e3-78b6890a5a35",
   "metadata": {},
   "source": [
    "To start, I am just going to show you some basic Python code. Please read it and see if you can get an intuitive grasp of what might be happening.\n",
    "\n",
    "I expect that if you have previous programming experience, the intuition may come quickly. If you do not have prior programming experience, I expect that just the simplicity of the Python language will allow you to come to a similar intuitive grasp of what the code does.\n",
    "\n",
    "Afterwards, I will break-down what is happening so we can all have a common understanding."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49d29b11-ac19-460c-a8aa-8ae0447784a2",
   "metadata": {},
   "source": [
    "## Example Python code\n",
    "\n",
    "> Note: I am intentionally using long variable names to prevent any confusion between different symbol conventions. e.g. In Canada we use the symbols S and Z to refer to the elastic section modulus and plastic modulus respectively. Whereas in Australia, I believe they use the opposite (Z is for the elastic modulus). In Europe, I think it is common to use W for the elastic modulus. So, I kept things simple by spelling out what I mean for each variable name."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bb4030c-8958-44c6-ac17-8c34127dc6bd",
   "metadata": {},
   "source": [
    "```python\n",
    "rectangular_section_width = 200 # mm\n",
    "rectangular_section_height = 800 # mm\n",
    "phi = 0.9\n",
    "yield_strength = 400 # MPa\n",
    "\n",
    "rectangular_section_area = rectangular_section_width * rectangular_section_height\n",
    "rectangular_section_modulus = rectangular_section_width * rectangular_section_height**2 / 6\n",
    "\n",
    "tension_resistance = phi * rectangular_section_area * yield_strength\n",
    "moment_resistance = phi * rectangular_section_modulus * yield_strength\n",
    "\n",
    "print(f\"The tensile resistance of the section is {tension_resistance}.\")\n",
    "print(f\"The moment resistance of the section is {moment_resistance}.\")\n",
    "```\n",
    "\n",
    "> After you have read through the code above and are confident on your understanding, copy and paste the code into the cell below (you can highlight it from Command Mode and use regular Ctrl+c and Ctrl+v). After you have pasted it, type `Shift+Enter` to run the cell and see the result.\n",
    ">\n",
    "> Try changing some of the values and re-running the cell with `Shift+Enter`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f0a1eb8-9577-4442-ae44-7d6bbd0b8d04",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b6e005ed-7652-4a07-95dc-f868251b19d8",
   "metadata": {},
   "source": [
    "## Breakdown"
   ]
  },
  {
   "attachments": {
    "75b0ff3a-96c8-4ddf-8d54-4727e13eeaf7.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "27b04061-a680-4fb7-87d2-3161aa3b2e0f",
   "metadata": {},
   "source": [
    "Ok, this was fairly simple, do you agree? But I want to bring your attention to **five** things:\n",
    "\n",
    "### 1. Variable assignment\n",
    "\n",
    "`=` is known as the \"assignment operator\". We use it _define a variable_ and, at the same time, _assign a value_ to that variable. Python is different than some other programming languages because we do not have to say what _type_ of data is going to be in the variable. For example, in Visual Basic for Applications (VBA), we might define a variable like this:\n",
    "```vba\n",
    "dim rectangular_section_width Integer\n",
    "rectangular_section_width = 200\n",
    "```\n",
    "In VBA, we have to say, upfront, that the variable `rectangular_section_width` is going to be an integer. **However, in Python, we do not have to make this kind of type declaration. We simply define the variable with whatever data we want.**\n",
    "\n",
    "> This characteristic of Python is called _dynamic typing_ and is in contrast to _static typing_ like we saw in the VBA example.\n",
    "\n",
    "### 2. Comments\n",
    "\n",
    "Do you see where the `# mm` is? In Python, `#` is a character to denote when a comment starts. A comment is text that is not as interpreted as code. In other words, the Python interpreter essentially stops reading the line once it sees that character. Any text after the `#` will not be interpreted as Python code and can be used to communicate our intentions to the reader of the code (i.e. another human).\n",
    "\n",
    "> In some other programming languages, it is common to do things like add a comment for every line of code to explain what it does.\n",
    "> \n",
    "> **This is not necessary in Python and should not be done.**\n",
    "> \n",
    "> Why? The Python language is designed to be easy to read and understand because it does not contain very many symbols (by comparison). Comments _are_ used frequently in Python but they are used more sparingly and to communicate _reasoning_, _intention_, or _assumptions_,  that are not apparent in the code itself, as opposed to explaining what the code does.\n",
    "\n",
    "### 3. Arithmetic operators\n",
    "\n",
    "`*` used as a multiplication operator is common amongst programming languages, including spreadsheets. However, what does `**` mean? In Python, `**` is used for exponentiation, raising to a power. Here are all of the arithmetic operators in Python:\n",
    "\n",
    "```python\n",
    "+ # Addition\n",
    "- # Subtraction\n",
    "* # Multiplication\n",
    "** # Exponentiation\n",
    "/ # Division (\"True division\")\n",
    "// # Floor division\n",
    "% # Modulo\n",
    "```\n",
    "\n",
    "#### How do floor division and modulo work?\n",
    "\n",
    "![image.png](attachment:75b0ff3a-96c8-4ddf-8d54-4727e13eeaf7.png)\n",
    "\n",
    "_Source: https://blog.teclado.com/pythons-modulo-operator-and-floor-division/_\n",
    "\n",
    "* Floor division returns the integer quotient\n",
    "* Modulo returns the returns the remainder\n",
    "\n",
    "> Both floor division and modulo are important for programming so make a mental note of what they do. We will be using them in later lessons.\n",
    "\n",
    "#### Why can't Python use `^` for exponentiation like a _normal_ programming language?!\n",
    "\n",
    "Python does use `^` but is assigned to a different operation. It is called a \"bitwise\" operation and `^` is used for \"symmetric difference\", also-known-as \"XOR\". We will also be using this in a later lesson when we look at sets and set operations."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "920986b2-76e7-48c5-8e1c-b4b0c030a772",
   "metadata": {},
   "source": [
    "## 4. Function calls\n",
    "\n",
    "Do you see where we _call_ the `print` function? It's on the last two lines.\n",
    "\n",
    "Much of this course is based upon using functions. Briefly, a function is a pre-defined process that is assigned a name. In this case, we are using the built-in function called `print`. `print` is its name. Think of it as being a variable that is pre-defined in Python to represent the internal process that outputs to the screen. \n",
    "\n",
    "To _call_ the function, or to utilize it, we must use parentheses `()` after the name. When Python sees the parentheses immediately after a variable name, it tries to \"call\" it or \"execute\" it.\n",
    "\n",
    "Try copy and pasting each line of code separately into the code cell below and running it to see what happens.\n",
    "\n",
    "```python\n",
    "print\n",
    "```\n",
    "\n",
    "Then try running:\n",
    "\n",
    "```python\n",
    "print \"column\"\n",
    "```\n",
    "\n",
    "Now try running:\n",
    "\n",
    "```python\n",
    "print(\"column\")\n",
    "```\n",
    "\n",
    "Last, try running:\n",
    "\n",
    "```python\n",
    "rectangular_section_width(\"column\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "81ba7c1c-e1e5-4dbe-a3f4-9a69098a794d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "04e7ee85-d93b-404a-9ce5-9dd43783b4b4",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0590b40d-037b-41dc-94de-f556417a4d05",
   "metadata": {},
   "source": [
    "Do you see the difference? In the first line, you are telling Python to \"return\" to you the variable `print` as the output of the cell. As a result, it tells you that `print` is the function called \"print\".\n",
    "\n",
    "In the second line, you are using incorrect Python syntax. You are simply refering to the `print` function and then typing some text beside it (text data is known as \"string\" data, for \"string of characters\"). In other words, the two things are not connected in anyway. Python even tells you that this is incorrect syntax and offers a suggestion.\n",
    "\n",
    "In the third line, you are using parentheses to _call_ the function `print` _and_ you are _passing arguments_ (data) for it to use during the execution. With the input of `\"column\"`, you see the text of `column` in the output cell.\n",
    "\n",
    "In the last line, you are trying to treat the variable named `rectangular_section_width`, which currently represents the integer `200`, as a function by trying to call it. Naturally, this does not work because `rectangular_section_width` is currently assigned the value of `200`, which is an integer and not a function and cannot be called. Therefore, `TypeError: 'int' object is not callable`.\n",
    "\n",
    "> See **Addendum** (below) for a list of all Python built-in functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bb5a84e-7fa6-44d7-9cdc-2cb063c5b90d",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20f242f1-66f9-4668-8aab-bed4cda5035b",
   "metadata": {},
   "source": [
    "## 5. Naming and capitalization conventions\n",
    "\n",
    "In Python, we follow these conventions:\n",
    "\n",
    "* Variable and function names are in \"snake_case\" (all lower case with underscores separating words)\n",
    "* Class names are in \"TitleCase\" (combination of upper and lower case using capitalization at the beginning of each word; underscores are not used)\n",
    "     * You will be introduced to classes and class names in Lesson 05     \n",
    "\n",
    "Many other programming languages use \"camelCase\", where the first word is lower case and the following words are capitalized. We do not use this in Python. Why not? Because snake_case_is_more_natural_to_read_as_common_language and because camelCaseIsHarderBothToReadAndToType.\n",
    "\n",
    "So, if you are coming from another programming language and are in the habit of writing in camelCase, I recommend trying to switch to snake_case while you are programming Python. If you have little or no programming experience, then_it_should_be_fairly_easy_to_pick_up_snake_case.\n",
    "\n",
    "> These conventions have been formalized in the document known as \"PEP 8\" (Python Enhancment Proposal #8: Python style guide) and it contains recommendations on what your Python code should generally look like. https://peps.python.org/pep-0008/. **NOTE**: Don't read this. Just scroll through it skimmingly to get the general idea in about 60 seconds. If you _really_ want to read it though, I won't stop you. (Yes, I have read it)\n",
    "\n",
    "> **Another Note:** Toward the end of the course, I will introduce you to a tool that _automatically_ reformats your code to comply with PEP8 conventions for things like spaces and line breaks. However it won't affect your variable naming so please try to follow the above naming conventions for readability and consistency."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d96151e-1438-414a-b7a1-1a5e4fa27889",
   "metadata": {},
   "source": [
    "# Your turn!\n",
    "\n",
    "In the code cell below, try writing some simple Python code similar to the above example to determine the deflection of a simply supported beam with the well-known formula:\n",
    "\n",
    "$$\n",
    "\\Delta = \\frac{5qL^4}{384EI}\n",
    "$$\n",
    "\n",
    "Create variables for `q`, `L`, `E`, and `I`. Then create a variable for the delta and calculate it. Be sure to add comments to describe your assumptions on the units used for inputs. \n",
    "\n",
    "Last, use the `print` function to output the value of your calculated delta. Try and copy/apply the technique I used in the above example to output my calculated value in a sentence (even though I did not explain it to you; I will talk about it in detail in Lesson 01).\n",
    "\n",
    "If you get a `SyntaxError`, see if you can spot your error and fix it. If you try but cannot fix it, THAT'S OK! You will get more practice with this (we are just in Lesson 00, after all)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24b38f0c-d104-4f6b-a75f-294b72f1a1b9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "60fe0edf-3564-4aef-aee9-da04b82ecb0b",
   "metadata": {},
   "source": [
    "# Next steps: PyNiteFEA Tutorial\n",
    "\n",
    "Please proceed to \"Lesson 00 - PyNiteFEA Tutorial\". There will be _additional_ Python syntax in this tutorial (notably, the use of braces `{}` and square brackets `[]`) that is largely going to be _unexplained_ for now. I will explain this additional syntax in Lesson 01 but I want you to try using Python to do something productive even though you may not fully understand what's going on. \n",
    "\n",
    "In the tutorial I do a bunch of handwaving and say things like, \"just do this\". Do not worry, I will explain _everything_ in time, most of it will be in Lesson 01.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbda4bd3-3817-42b0-8f1f-a1dd2eea75c3",
   "metadata": {},
   "source": [
    "# Addendum: Python built-in functions\n",
    "\n",
    "Just like Microsoft Excel, Python comes with several built-in functions. You don't have to memorize all of these (really, you don't; we tend to learn them as we need them and then remember them as we use them). The function names worth remembering right now are the ones that I have **bolded**. If you are curious about what any of the other ones do, you can use `help` to find out! :)\n",
    "\n",
    "* **`help`** - Use `help` to learn how any _object_ in Python works, e.g. `help(print)` or `help(rectangular_section_width)`\n",
    "* **`print`** - Output the given data to the screen (\"the screen\" is also known as \"standard out\" or \"stdout\")\n",
    "* **`dir`** - Use `dir` to learn the names of an object's attributes and methods e.g. `dir(rectangular_section_width)`. More on this \"attributes and methods\" business later.\n",
    "* **`max`** - Find the maximum value in an array of values\n",
    "* **`min`** - Find the minimum value in an array of values\n",
    "* **`round`** - Round a scalar to n number of decimal places\n",
    "* **`abs`** - Return the absolute value of a scalar\n",
    "* **`sum`** - Return the sum of the values in an array\n",
    "* **`len`** - Return the number of elements in an array\n",
    "* **`open`** - Open a file on disk and return a FileHandler object (more on this in Lesson 01)\n",
    "* **`float`** - Convert a Python object to a floating point number (i.e. a decimal number), if possible (e.g. `float(\"23.4\")` will return the number `23.4`)\n",
    "* **`int`** - Similar to the above but convert to an integer if possible (e.g. `int(\"23\")` will return the number `23`)\n",
    "* `all`\n",
    "* `any`\n",
    "* `ascii`\n",
    "* `bin`\n",
    "* `bool`\n",
    "* `breakpoint`\n",
    "* `bytearray`\n",
    "* `bytes`\n",
    "* `callable`\n",
    "* `chr`\n",
    "* `classmethod`\n",
    "* `compile`\n",
    "* `complex`\n",
    "* `copyright`\n",
    "* `credits`\n",
    "* `delattr`\n",
    "* `dict`\n",
    "* `display`\n",
    "* `divmod`\n",
    "* `enumerate`\n",
    "* `eval`\n",
    "* `exec`\n",
    "* `execfile`\n",
    "* `filter`\n",
    "* `format`\n",
    "* `frozenset`\n",
    "* `getattr`\n",
    "* `globals`\n",
    "* `hasattr`\n",
    "* `hash`\n",
    "* `hex`\n",
    "* `id`\n",
    "* `input`\n",
    "* `isinstance`\n",
    "* `issubclass`\n",
    "* `iter`\n",
    "* `license`\n",
    "* `list`\n",
    "* `locals`\n",
    "* `map`\n",
    "* `memoryview`\n",
    "* `next`\n",
    "* `object`\n",
    "* `oct`\n",
    "* `ord`\n",
    "* `pow`\n",
    "* `property`\n",
    "* `range`\n",
    "* `repr`\n",
    "* `reversed`\n",
    "* `round`\n",
    "* `runfile`\n",
    "* `set`\n",
    "* `setattr`\n",
    "* `slice`\n",
    "* `sorted`\n",
    "* `staticmethod`\n",
    "* `str`\n",
    "* `super`\n",
    "* `tuple`\n",
    "* `type`\n",
    "* `vars`\n",
    "* `zip`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d0513a7-14aa-4515-bc9d-b8b908e7579c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10 (pfse)",
   "language": "python",
   "name": "pfse"
  },
  "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}