codes/00_introduction-to-python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "📝 **Author:** Amirhossein Heydari - 📧 **Email:** AmirhosseinHeydari78@gmail.com - 📍 **Linktree:** [linktr.ee/mr_pylin](https://linktr.ee/mr_pylin)\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python\n",
    "\n",
    "## What is Python?\n",
    "   - Created by [Guido van Rossum](https://en.wikipedia.org/wiki/Guido_van_Rossum) and first released in 1991.\n",
    "   - Python is a [high-level](https://en.wikipedia.org/wiki/High-level_programming_language), [interpreted programming language](https://en.wikipedia.org/wiki/Interpreter_%28computing%29) known for its simplicity and readability.\n",
    "   - Python emphasizes code readability and supports multiple [programming paradigms](https://en.wikipedia.org/wiki/Programming_paradigm), including [procedural](https://en.wikipedia.org/wiki/Procedural_programming), [object-oriented](https://en.wikipedia.org/wiki/Object-oriented_programming), and [functional programming](https://en.wikipedia.org/wiki/Functional_programming).\n",
    "\n",
    "## Key Features\n",
    "1. **Easy to Read and Write**:\n",
    "   - Python’s [syntax](https://en.wikipedia.org/wiki/Syntax_%28programming_languages%29) is clear and intuitive, making it an excellent choice for both beginners and experienced programmers.\n",
    "1. **Versatile**:\n",
    "   - Python can be used for a variety of applications, including web development, data analysis, artificial intelligence, scientific computing, and automation.\n",
    "1. **Extensive Standard Library**:\n",
    "   - Python comes with a comprehensive standard library that supports many common programming tasks such as file I/O, system calls, and internet protocols.\n",
    "1. **Cross-Platform**:\n",
    "   - Python is available on various platforms, including Windows, macOS, and Linux (including android!), making it a versatile choice for developing cross-platform applications.\n",
    "1. **Dynamic Typing**:\n",
    "   - Python is [dynamically typed](https://en.wikipedia.org/wiki/Dynamic_programming_language), which means you don’t need to declare variable types explicitly. This makes the language flexible and easy to use.\n",
    "1. **Interpreted Language**:\n",
    "   - Python code is executed line by line, which simplifies debugging and makes it easier to test small chunks of code interactively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Identifiers (aka names)\n",
    "   - Identifiers can include letters (uppercase and lowercase), digits, and underscores (`_`).\n",
    "   - Identifiers must start with a letter (Not just English) or an underscore (_), but they cannot start with a digit.\n",
    "   - Identifiers are case-sensitive, meaning Variable and variable are considered different identifiers.\n",
    "   - Identifiers cannot include special characters such as `@`, `$`, `%`, `&`, `*`, `-`, `+`, `=`, `!`, `#`, etc.\n",
    "   - Identifiers cannot be the same as Python keywords or reserved words.\n",
    "\n",
    "# Python Keywords\n",
    "   - **Hard Keywords**\n",
    "      - Hard keywords are reserved words that have a specific syntactical meaning and cannot be used as identifiers under any circumstances.\n",
    "\n",
    "<table style=\"font-family: monospace; display: flex; justify-content: center;\">\n",
    "    <tr>\n",
    "        <td>False</td>\n",
    "        <td>None</td>\n",
    "        <td>True</td>\n",
    "        <td>and</td>\n",
    "        <td>as</td>\n",
    "        <td>assert</td>\n",
    "        <td>async</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>await</td>\n",
    "        <td>break</td>\n",
    "        <td>class</td>\n",
    "        <td>continue</td>\n",
    "        <td>def</td>\n",
    "        <td>del</td>\n",
    "        <td>elif</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>else</td>\n",
    "        <td>except</td>\n",
    "        <td>finally</td>\n",
    "        <td>for</td>\n",
    "        <td>from</td>\n",
    "        <td>global</td>\n",
    "        <td>if</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>import</td>\n",
    "        <td>in</td>\n",
    "        <td>is</td>\n",
    "        <td>lambda</td>\n",
    "        <td>nonlocal</td>\n",
    "        <td>not</td>\n",
    "        <td>or</td>\n",
    "    </tr>\n",
    "    <tr>\n",
    "        <td>pass</td>\n",
    "        <td>raise</td>\n",
    "        <td>return</td>\n",
    "        <td>try</td>\n",
    "        <td>while</td>\n",
    "        <td>with</td>\n",
    "        <td>yield</td>\n",
    "    </tr>\n",
    "</table>\n",
    "\n",
    "   - **Soft Keywords**\n",
    "       - Soft keywords are reserved words that have a specific meaning only in certain contexts.\n",
    "       - Soft keywords are a relatively recent addition to Python (from v3.10), introduced to allow for certain language features without breaking backward compatibility.\n",
    "\n",
    "<table style=\"font-family: monospace; display: flex; justify-content: center;\">\n",
    "    <tr>\n",
    "        <td>match</td>\n",
    "        <td>case</td>\n",
    "        <td>type</td>\n",
    "        <td>_</td>\n",
    "    </tr>\n",
    "</table>\n",
    "\n",
    "---\n",
    "\n",
    "📝 **Docs**:\n",
    "   - Identifiers: [docs.python.org/3/reference/lexical_analysis.html#identifiers](https://docs.python.org/3/reference/lexical_analysis.html#identifiers)\n",
    "   - Keywords: [docs.python.org/3/reference/lexical_analysis.html#keywords](https://docs.python.org/3/reference/lexical_analysis.html#keywords)\n",
    "\n",
    "🐍 **PEPs**:\n",
    "   - Supporting Non-ASCII Identifiers [[PEP 3131](https://peps.python.org/pep-3131/)]\n",
    "   - Style Guide for Python Code [[PEP 8](https://peps.python.org/pep-0008/#naming-conventions)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "110\n",
      "111\n",
      "3.1415\n"
     ]
    }
   ],
   "source": [
    "num_1 = 110\n",
    "num_2 = 111\n",
    "num_3 = 3.1\n",
    "\n",
    "# log\n",
    "print(num_1)\n",
    "print(num_2)\n",
    "print(num_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python\n",
      "amir\n",
      "black\n"
     ]
    }
   ],
   "source": [
    "name_1 = \"python\"\n",
    "name_2 = \"amir\"\n",
    "fav_color = \"black\"\n",
    "\n",
    "# log\n",
    "print(name_1)\n",
    "print(name_2)\n",
    "print(fav_color)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.1415\n",
      "Yellow\n",
      "Red\n",
      "alphabet\n",
      "alphabet\n",
      "alphabet\n"
     ]
    }
   ],
   "source": [
    "# misc\n",
    "PI = 3.1415\n",
    "color_1, color_2 = \"Yellow\", \"Red\"\n",
    "a = b = c = \"alphabet\"\n",
    "\n",
    "# log\n",
    "print(PI)\n",
    "print(color_1)\n",
    "print(color_2)\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "Hi\n",
      "Bye\n"
     ]
    }
   ],
   "source": [
    "# discouraged - do not use soft keywords as identifiers\n",
    "type = 12\n",
    "match = \"Hi\"\n",
    "case = \"Bye\"\n",
    "\n",
    "# log\n",
    "print(type)\n",
    "print(match)\n",
    "print(case)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid decimal literal (345234044.py, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[13], line 3\u001b[1;36m\u001b[0m\n\u001b[1;33m    2_digit = 23  #\u001b[0m\n\u001b[1;37m     ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid decimal literal\n"
     ]
    }
   ],
   "source": [
    "# SyntaxError\n",
    "pass = 12     # invalid syntax\n",
    "2_digit = 23  # invalid decimal literal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comments `#`\n",
    "   - **Block Comments**:\n",
    "      - Use the `#` symbol at the beginning of each line\n",
    "      - Block comments are used to explain larger sections of code\n",
    "      - They typically span multiple lines and are placed above or beside the block of code they describe\n",
    "   - **Inline Comments**:\n",
    "      - Use the `#` symbol followed by the comment text.\n",
    "      - Inline comments are placed on the same line as a statement and are used to explain or clarify a specific line of code.\n",
    "   - **Documentation Strings** (Docstring):\n",
    "      - Enclosed in triple quotes (`\"\"\"` or `'''`).\n",
    "      - Docstrings are used to document modules, classes, methods, and functions.\n",
    "      - They provide a structured way to describe the purpose, parameters, and return values of a piece of code.\n",
    "\n",
    "---\n",
    "\n",
    "🔊 **Pronunciation**:\n",
    "   - `#`: Hash, Pound, Octothorpe [Hashtag is discouraged⚠️]\n",
    "   - `'`: single quote\n",
    "   - `\"`: double quote\n",
    "\n",
    "📝 **Docs**:\n",
    "   - Comments: [docs.python.org/3/reference/lexical_analysis.html#comments](https://docs.python.org/3/reference/lexical_analysis.html#comments)\n",
    "\n",
    "🐍 **PEPs**:\n",
    "   - Style Guide for Python Code [[PEP 8](https://peps.python.org/pep-0008/#comments)]\n",
    "   - The Zen of Python [[PEP 20](https://peps.python.org/pep-0020/)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Amir\n",
      "I'm 2 years old\n"
     ]
    }
   ],
   "source": [
    "# this cell of codes prints your name and your age [Block comment]\n",
    "name = \"Amir\"  # write your name here [inline comment]\n",
    "age  = 2       # write your age  here [inline comment]\n",
    "\n",
    "# log\n",
    "print(\"My name is\", name)\n",
    "print(\"I'm\", age, \"years old\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "def foo():\n",
    "    \"\"\"if you call this function, it prints Hello\"\"\"\n",
    "    print(\"Hello\")\n",
    "\n",
    "# log\n",
    "foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Beautiful is better than ugly.\n",
    "# Explicit is better than implicit.\n",
    "# Simple is better than complex.\n",
    "# Complex is better than complicated.\n",
    "# Flat is better than nested.\n",
    "# Sparse is better than dense.\n",
    "# Readability counts.\n",
    "# Special cases aren't special enough to break the rules.\n",
    "# Although practicality beats purity.\n",
    "# Errors should never pass silently.\n",
    "# Unless explicitly silenced.\n",
    "# In the face of ambiguity, refuse the temptation to guess.\n",
    "# There should be one-- and preferably only one --obvious way to do it.\n",
    "# Although that way may not be obvious at first unless you're Dutch.\n",
    "# Now is better than never.\n",
    "# Although never is often better than *right* now.\n",
    "# If the implementation is hard to explain, it's a bad idea.\n",
    "# If the implementation is easy to explain, it may be a good idea.\n",
    "# Namespaces are one honking great idea -- let's do more of those!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# print() Function\n",
    "   - The `print()` function outputs text or other data to the console.\n",
    "\n",
    "---\n",
    "\n",
    "📝 **Docs**:\n",
    "   - print(): [docs.python.org/3/library/functions.html#print](https://docs.python.org/3/library/functions.html#print)\n",
    "   - Formatted String Literals: [docs.python.org/3/tutorial/inputoutput.html#formatted-string-literals](https://docs.python.org/3/tutorial/inputoutput.html#formatted-string-literals)\n",
    "   - printf-style String Formatting: [docs.python.org/3/library/stdtypes.html#old-string-formatting](https://docs.python.org/3/library/stdtypes.html#old-string-formatting)\n",
    "\n",
    "🐍 **PEPs**:\n",
    "   - Literal String Interpolation [[PEP 498](https://peps.python.org/pep-0498/)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "# simple use case\n",
    "print(\"Hello, World!\")\n",
    "print(\"Hello\", \"World\")\n",
    "\n",
    "# sep & end parameters\n",
    "print(\"Hello\", \"World\", sep=\"-\")\n",
    "print(\"Hello\", \"World\", sep=\"-\", end=\"!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name: Sara, location: Australia\n",
      "name='Sara', loc='Australia'\n",
      "The value of pi is approximately 3.14\n"
     ]
    }
   ],
   "source": [
    "# formatted string\n",
    "name = 'Sara'\n",
    "loc  = 'Australia'\n",
    "print(f\"name: {name}, location: {loc}\")\n",
    "print(f\"{name=}, {loc=}\")\n",
    "\n",
    "PI = 3.1415\n",
    "print(f\"The value of pi is approximately {PI:.2f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of pi is approximately 3.142\n"
     ]
    }
   ],
   "source": [
    "# old string formatting [discouraged]\n",
    "PI = 3.1415\n",
    "print(\"The value of pi is approximately %.3f\" %PI)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print to file [advanced]\n",
    "with open(\"temp.txt\", \"w\") as file:\n",
    "    print(\"Hello, File!\", file=file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# input() Function\n",
    "   - The `input()` function reads a line of text from the user input.\n",
    "\n",
    "---\n",
    "\n",
    "📝 **Docs**:\n",
    "   - input(): [docs.python.org/3/library/functions.html#input](https://docs.python.org/3/library/functions.html#input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Jerry\n"
     ]
    }
   ],
   "source": [
    "user_input = input(\"Enter your name: \")\n",
    "print(\"Hello,\", user_input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are 99 years old.\n"
     ]
    }
   ],
   "source": [
    "age = input(\"Enter your age: \")\n",
    "print(f\"You are {age} years old.\")"
   ]
  }
 ],
 "metadata": {
  "author_name": "Amirhossein Heydari",
  "author_email": "AmirhosseinHeydari78@gmail.com",
  "author_github": "https://github.com/mr-pylin",
  "origin_repo": "https://github.com/mr-pylin/python-workshop",
  "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.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}