01_python/python_basic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3df9101b",
   "metadata": {},
   "source": [
    "# Python introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e664b88",
   "metadata": {},
   "source": [
    "This is a limited introduction of primary types and operators."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b3f5895",
   "metadata": {},
   "source": [
    "## Integer numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8893b028",
   "metadata": {},
   "source": [
    "Here are some examples of integer numbers: `0`, `1`, `-1`.\n",
    "Another example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8527d044",
   "metadata": {},
   "outputs": [],
   "source": [
    "-37"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8150c468",
   "metadata": {},
   "source": [
    "For easier reading the underscore symbol `_` may be used:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e844ac76",
   "metadata": {},
   "outputs": [],
   "source": [
    "37_000_037"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7c4db32",
   "metadata": {},
   "source": [
    "Integer numbers can be very large (not limited to a few bytes of memory only) and they are kept without any rounding:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7314f204",
   "metadata": {},
   "outputs": [],
   "source": [
    "123_456_789_012_345_678_901_234_567_890"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73c91a44",
   "metadata": {},
   "source": [
    "The function `type(...)` allows checking types of objects.\n",
    "For an integer number it returns:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a56d3b57",
   "metadata": {},
   "outputs": [],
   "source": [
    "type( -37 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bad1968a",
   "metadata": {},
   "outputs": [],
   "source": [
    "type( 123_456_789_012_345_678_901_234_567_890 )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cfcc663",
   "metadata": {},
   "source": [
    "## Real numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59abad6b",
   "metadata": {},
   "source": [
    "Once a dot `.` appears in a number it is no longer interpreted as an integer. It is a real number (`float`):\n",
    "- The dot separates the whole from the fractional part of a number.\n",
    "- Note the `.` printed in the output.\n",
    "- The comma symbol `,` cannot be used to separate the whole from the fractional part."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de8dcaf2",
   "metadata": {},
   "outputs": [],
   "source": [
    "-37.     # no longer an integer number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2fb2110c",
   "metadata": {},
   "outputs": [],
   "source": [
    "3.141592 # an approximation of pi\n",
    "         # whatever is after # it is treated as a comment (ignored by Python)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9723c4e",
   "metadata": {},
   "source": [
    "Real numbers are kept up to a certain precision:\n",
    "- Study the output below (compare to the integer above).\n",
    "- What is the interpretation of `e+29`?\n",
    "- Note, the underscore can be also used in real numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90527aed",
   "metadata": {},
   "outputs": [],
   "source": [
    "123_456_789_012_345_678_901_234_567_890."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8597b15",
   "metadata": {},
   "source": [
    "Real numbers have the following type:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "443a7491",
   "metadata": {},
   "outputs": [],
   "source": [
    "type( -37. )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8aa0c028",
   "metadata": {},
   "outputs": [],
   "source": [
    "type( -0.1e-3 ) # what is this number?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08fd9cad",
   "metadata": {},
   "source": [
    "## Arithmetics and simple calculations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "543b39a9",
   "metadata": {},
   "source": [
    "Addition, subtraction, multiplication are natural. `(` and `)` are used to enforce the order of calculation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c65d859f",
   "metadata": {},
   "outputs": [],
   "source": [
    "3*2+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1cde761f",
   "metadata": {},
   "outputs": [],
   "source": [
    "3*(2+1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bba88959",
   "metadata": {},
   "source": [
    "`/` denotes division in real domain and may lead to a noninteger result:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d01baa54",
   "metadata": {},
   "outputs": [],
   "source": [
    "10/7"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e06ec710",
   "metadata": {},
   "source": [
    "`//` is the floor division operator. It divides the first argument by the second and rounds the result down to the nearest whole number (integer)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cfd46a62",
   "metadata": {},
   "outputs": [],
   "source": [
    "13//5 # try also -13//5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8089a4cf",
   "metadata": {},
   "source": [
    "`%` is the `modulo` operator. It returns the rest from the floor division."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91815d92",
   "metadata": {},
   "outputs": [],
   "source": [
    "13%5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a765896b",
   "metadata": {},
   "source": [
    "Finally, `**` is the power operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f851a62b",
   "metadata": {},
   "outputs": [],
   "source": [
    "2**5 # the fifth power of 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbc57a5e",
   "metadata": {},
   "source": [
    "## Texts (strings)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "933b8965",
   "metadata": {},
   "source": [
    "Texts which fit in one line are writen between single `'`...`'` or double quotes `\"`...`\"`. The same symbol must be used at the beginning and at the end of the text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8702e590",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Statistics and Data Science\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7043aac9",
   "metadata": {},
   "outputs": [],
   "source": [
    "'Statistics and Data Science'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e438d1a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "'\"Statistics\" and \"Data Science\"'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78bae64f",
   "metadata": {},
   "source": [
    "Multi-line texts are written between matching triple single `'''`...`'''` or double `\"\"\"`...`\"\"\"` quotes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4bb90b4b",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Statistics\n",
    "and\n",
    "Data Science\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e27fa046",
   "metadata": {},
   "source": [
    "Note special characters in the above output: `\\n` denotes a new line. You may also use `\\\"` or `\\'` to put these quotes into the text. Or `\\\\` to put a single backslash."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0090813",
   "metadata": {},
   "source": [
    "The type of a text is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dca4f11f",
   "metadata": {},
   "outputs": [],
   "source": [
    "type( \"Data Science\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94ed7f1d",
   "metadata": {},
   "source": [
    "The `+` operator can be used to concatenate (merge) texts:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cdc793e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Statistics\" + \" \" + 'and' + ' ' + \"Data Science\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db562806",
   "metadata": {},
   "source": [
    "And the `*` operator can be used to concatenate a text given number of times:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2de1929",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Data!\" * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7adf23ff",
   "metadata": {},
   "source": [
    "## Variables, assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ef62788",
   "metadata": {},
   "source": [
    "A value is **assigned** to a variable with the assignment operator `=`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b30dce8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "grpName = \"Statistics and Data Science\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fff0042",
   "metadata": {},
   "source": [
    "Use the `print(...)` function to show the value of the variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ca23a50",
   "metadata": {},
   "outputs": [],
   "source": [
    "print( grpName )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e643be09",
   "metadata": {},
   "source": [
    "When used inside a Python interpreter, it is enough to type the variable name to print the value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d13fa83c",
   "metadata": {},
   "outputs": [],
   "source": [
    "grpName"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bea07742",
   "metadata": {},
   "source": [
    "Variable names are build of small/capital letters, digits and `_` character. A digit cannot start a name of a variable. Variable names are case sensitive (`xvar`, `xVar`, `XVar` and `XVAR` are different variables). "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0bd9b22f",
   "metadata": {},
   "source": [
    "It is possible to perform multiple assignments in one statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "889f249d",
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y, z = 1, \"b\", 3*7e2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "105c3192",
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a437988",
   "metadata": {},
   "outputs": [],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0983d2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a06e2619",
   "metadata": {},
   "source": [
    "Note, that this notation can be used to swap two variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58482eab",
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = y, x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a768b6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3078f0ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1c8be59",
   "metadata": {},
   "source": [
    "Here is an example of **add-and-assign operator** `+=` which can be used to add the right side value to an already existing value of the left side variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f529d22a",
   "metadata": {},
   "outputs": [],
   "source": [
    "v = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1735292f",
   "metadata": {},
   "outputs": [],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0b37d44",
   "metadata": {},
   "outputs": [],
   "source": [
    "v += 3                # Equivalent to: v = v + 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3d7394b",
   "metadata": {},
   "outputs": [],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f7f18cb",
   "metadata": {},
   "source": [
    "There are more similar operators, e.g. `-=`, `*=`, `/=`."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f58f21f",
   "metadata": {},
   "source": [
    "The `type(...)` function may be used to find the type of the value stored in a variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53aed059",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db1c4aef",
   "metadata": {},
   "source": [
    "*Note:* `dir()` function can be used to list all variables in the current scope."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88173edb",
   "metadata": {},
   "source": [
    "## Boolean values, logical and comparison operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0216f723",
   "metadata": {},
   "source": [
    "There are two logical constants `True` and `False`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "98deb644",
   "metadata": {},
   "outputs": [],
   "source": [
    "True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1110fa2a",
   "metadata": {},
   "source": [
    "The type of a logical value is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72c25a81",
   "metadata": {},
   "outputs": [],
   "source": [
    "type( False )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "38d5f3d7",
   "metadata": {},
   "source": [
    "Logical values are returned by comparison operators. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "71a49de3",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 8               # Assign value 8 to variable x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6ea147b",
   "metadata": {},
   "outputs": [],
   "source": [
    "x == 8              # Is x equal to 8?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1fc6813b",
   "metadata": {},
   "outputs": [],
   "source": [
    "x != 8              # Is x not equal to 8?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58299b58",
   "metadata": {},
   "outputs": [],
   "source": [
    "x < 8               # Is x smaller than 8?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4eb14a8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "x <= 8              # Is x smaller or equal to 8?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "496b39b5",
   "metadata": {},
   "source": [
    "More complex logical conditions can be built with logical operators:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d483c67",
   "metadata": {},
   "outputs": [],
   "source": [
    "x > 7 and x <= 9    # Are both True?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71eeb0ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "x <= 7 or x > 9     # Is any True?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b200ec6",
   "metadata": {},
   "outputs": [],
   "source": [
    "not ( x == 8 )      # Negation (the opposite)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "EfDS",
   "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.13.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}