Python_Basics_for_SNA_Student_by_Hamidreza_Seddighi.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/PICOTERMS/Algolab/blob/main/Python_Basics_for_SNA_Student_by_Hamidreza_Seddighi.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Python Basics for SNA Students\n",
        "\n",
        "by: Hamidreza Seddighi"
      ],
      "metadata": {
        "id": "s81dA9sIrAB_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## What is *Python*?\n",
        "Python is an **interpreted**, object-oriented, **high-level** programming language with dynamic semantics. Its high-level built in data structures, combined with dynamic typing and dynamic binding, make it very attractive for Rapid Application Development, as well as for use as a scripting or glue language to connect existing components together. Python's simple, easy to learn syntax emphasizes readability and therefore reduces the cost of program maintenance. Python supports modules and packages, which encourages program modularity and code reuse. The Python interpreter and the extensive standard library are available in source or binary form without charge for all major platforms, and can be freely distributed. (https://www.python.org/doc/essays/blurb/)\n",
        "\n",
        "Interpreted: An interpreted language is a language in which the implementations execute instructions directly without earlier compiling a program into machine language. (Interpreted vs. Compiled)\n",
        "\n",
        "High-level: A high-level language (HLL) is a programming language that allows a programmer to develop programmes that are independent of the type of machine they are running on. all these languages are classified as high-level because they are more comparable languages than machine languages."
      ],
      "metadata": {
        "id": "jVOIJUDktcp1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Python Versions\n",
        "\n",
        "It is recommended to use latest version of Python. To download latest version: https://www.python.org/downloads/\n",
        "\n",
        "You can check your Python version by running `python --version`\n",
        "\n",
        "Please check Python version on your device in Command Prompt (cmd). Then run the code below.\n",
        "\n",
        "To run you can use: **Shift + Enter**"
      ],
      "metadata": {
        "id": "KDhuIN-mvY3s"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "M1WBV4L-q2Zw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2245e4fb-3d67-443e-9782-64db701b3878"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Python 3.10.12\n"
          ]
        }
      ],
      "source": [
        "!python --version"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## My First Line of Code in Python\n",
        "\n",
        "To start coding in Python let's use the `print()` syntax. Type anything you like between 2 quotation marks (' or \") and then run."
      ],
      "metadata": {
        "id": "Qlh-DaDOyeZr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print (\"Hello World!\")"
      ],
      "metadata": {
        "id": "KJ_PvZF6yfAK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## How to Define a Variable?\n",
        "\n",
        "Variables are containers for storing data values.\n",
        "A variable is created the moment you first assign a value to it."
      ],
      "metadata": {
        "id": "rdRCR6VINMLe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "number = 2\n",
        "print (number)\n",
        "\n",
        "my_name = \"Hamidreza\"\n",
        "print (my_name)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d1MFBxTiRXNQ",
        "outputId": "a543b7e2-24de-40c0-a218-ba85957755b6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "Hamidreza\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Python Basic Data Types\n",
        "\n",
        "There are 4 basic data types in Python: **Integers**, **Floats**, **Strings** and **Booleans**."
      ],
      "metadata": {
        "id": "IhDGz-s6zlOS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Numbers in Python\n",
        "\n",
        "Integers and Floats are used for numeric data."
      ],
      "metadata": {
        "id": "r5aOe_gKz96z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 5\n",
        "print (type(x))  # integer - int\n",
        "print (x)\n",
        "print (x + 3) #Addition\n",
        "print (x - 3) #Subtraction\n",
        "print (x * 2) #Multiplication\n",
        "print (x / 2) #Division\n",
        "print (x ** 2) #Exponentiation\n",
        "print (x // 2) #[Floor-Division] (قطع شده‌ی تقسیم بر عدد سمت راست)\n",
        "print (x % 2) #Modulo (باقیمانده‌ی تقسیم بر عدد سمت راست)\n",
        "\n",
        "x = x + 2\n",
        "print (x)\n",
        "x += 1    #x = x + 1\n",
        "print (x)\n",
        "\n",
        "y = 1.5\n",
        "print (type(y)) # float - float"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cnYMIt1VNkbB",
        "outputId": "b852d9ca-8c9e-49e1-c854-42ee425a95ab"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'int'>\n",
            "5\n",
            "8\n",
            "2\n",
            "10\n",
            "2.5\n",
            "25\n",
            "2\n",
            "1\n",
            "7\n",
            "8\n",
            "<class 'float'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Booleans\n",
        "\n",
        "`True` and `False` are booleans in Python.\n",
        "\n",
        "![and-or.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "agvzEMiv0NtS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "t = True\n",
        "f = False\n",
        "print (type (t)) # boolean - bool\n",
        "print (t and f) #logical AND\n",
        "print (t or f) #logical OR\n",
        "print (not t) #logical NOT\n",
        "print (not f) #logical NOT"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Wo8iDdXbRr0H",
        "outputId": "d315b8a4-fa38-49f7-d484-c2f7d2689f67"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'bool'>\n",
            "False\n",
            "True\n",
            "False\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Strings\n",
        "\n",
        "String is a collection of alphabets, words or other characters. string are **immutable** which means they cannot be changed after they are created. Anything between 2 quotation marks (' or \") is a string."
      ],
      "metadata": {
        "id": "jO9Y4lqqTAEe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_name = \"Hamidreza\"\n",
        "print (type(my_name)) #String - str\n",
        "print (my_name)\n",
        "print (len(my_name)) #String Length\n",
        "my_age = \"28\"\n",
        "print (my_name + \" \" + my_age) #Concatenation\n",
        "\n",
        "# Strings Methods\n",
        "my_job = \"stuDent\"\n",
        "print (my_job.capitalize())\n",
        "print (my_job.upper())\n",
        "print (my_job.lower())\n",
        "print (my_job.upper())\n",
        "print (my_job.replace(\"D\",\"ll\"))\n",
        "print (my_job.rjust(13))\n",
        "print (my_job.center(13))\n",
        "print (my_name.isalphe())\n",
        "print (my_age.isnumeric())\n",
        "\n",
        "# .isupper() , .islower() - Checks if all characters are UPPERCASE , lowercase\n",
        "# .title() - Makes first letter of each word CAPITAL\n",
        "\n",
        "my_language = \"     Persian    \"\n",
        "print (my_language)\n",
        "print (len(my_language))\n",
        "print (my_language.strip())\n",
        "print (len(my_language.strip()))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZB4NCDp1TBff",
        "outputId": "173766a0-7227-46f8-9244-8fcc908226b8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'str'>\n",
            "Hamidreza\n",
            "9\n",
            "Hamidreza 28\n",
            "Student\n",
            "STUDENT\n",
            "student\n",
            "STUDENT\n",
            "stullent\n",
            "      stuDent\n",
            "   stuDent   \n",
            "     Persian    \n",
            "16\n",
            "Persian\n",
            "7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Casting\n",
        "\n",
        "If you want to specify the data type of a variable, this can be done with casting.\n",
        "Explicit Type Conversion is also called Type Casting, the data types of objects are converted using predefined functions by the user. In Type Casting, loss of data may occur as we enforce the object to a specific data type."
      ],
      "metadata": {
        "id": "6WX7YsqnYXjt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = int(2)\n",
        "b = int(\"3\")\n",
        "c = int(4.5)\n",
        "print (a , b , c)\n",
        "\n",
        "e = float(2)\n",
        "f = float(\"3\")\n",
        "g = float(4.5)\n",
        "print (e , f , g)\n",
        "\n",
        "h = str(a)  #Remember -a- was defind as an integer variable\n",
        "i = str(\"3\")\n",
        "j = str(4.5)\n",
        "print (h , i , j)\n",
        "\n",
        "k = int(True)\n",
        "l = int(False)\n",
        "m = bool(1)\n",
        "n = bool(0)\n",
        "print (k , l , m , n)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V8nQGA-NflXi",
        "outputId": "5bc40d25-6fa5-476f-c7d7-41e9ccd97803"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2 3 4\n",
            "2.0 3.0 4.5\n",
            "2 3 4.5\n",
            "1 0 True False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Python Containers\n",
        "\n",
        "There are 4 built-in containers in Python: **Lists**, **Dictionaries**, **Sets** and **Tuples**."
      ],
      "metadata": {
        "id": "wDkksVHInxJ_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Lists\n",
        "\n",
        "Lists are used to store multiple items in a single variable. List items are ordered, changeable, and allow duplicate values. List items are indexed, the first item has index [0], the second item has index [1].\n",
        "\n",
        "**Hint**: The last item has index [-1].\n"
      ],
      "metadata": {
        "id": "5jKrPiYLoBN4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "students = [\"Ali\", \"Nader\", \"Reza\", \"Nima\" , \"Ali\"]\n",
        "print (students)\n",
        "print (len(students)) #How many items are in the list?\n",
        "print (students[0])\n",
        "print (students[1:4]) #Selecting 2nd,3rd and 4th items (index 1,2,3)\n",
        "print (students[3] , students[-1]) # Last item has index [-1]\n",
        "students[2] = \"Emad\" #Changing an item in list\n",
        "print (students)\n",
        "students.append(\"Sajjad\") #Adding an item to last index\n",
        "print (students)\n",
        "students.pop() #Deleting last item\n",
        "print (students)\n",
        "students.pop(2) #Deleting index [2] (3rd item)\n",
        "print (students)\n",
        "\n",
        "print (students.index(\"Nima\")) #Getting index of an item\n",
        "print (students.count(\"Ali\")) #Count an item (How mant \"Ali\"s are in the list?)\n",
        "students.remove (\"Nima\") #Deleting exact item from list\n",
        "print (students)\n",
        "students.insert(1 , \"Hamid\") #Adding an item to specific index\n",
        "print (students)\n",
        "\n",
        "students.reverse() #Reverse the list\n",
        "print (students)\n",
        "students.sort() #Sorting the list (Alphabetical or Ascending)\n",
        "print(students)\n",
        "del(students[0:2]) #Deleting a range of items from list (selected by index)\n",
        "print (students)\n",
        "\n",
        "list_of_numbers = [[0, 2, 4],[1, 3, 5]] #lists can include lists\n",
        "print (list_of_numbers[0][1]) #Selecting a subset from list"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ex4nGebiowyY",
        "outputId": "d1083601-3a81-42d4-bb07-483ebff6baaf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['Ali', 'Nader', 'Reza', 'Nima', 'Ali']\n",
            "5\n",
            "Ali\n",
            "['Nader', 'Reza', 'Nima']\n",
            "Nima Ali\n",
            "['Ali', 'Nader', 'Emad', 'Nima', 'Ali']\n",
            "['Ali', 'Nader', 'Emad', 'Nima', 'Ali', 'Sajjad']\n",
            "['Ali', 'Nader', 'Emad', 'Nima', 'Ali']\n",
            "['Ali', 'Nader', 'Nima', 'Ali']\n",
            "2\n",
            "2\n",
            "['Ali', 'Nader', 'Ali']\n",
            "['Ali', 'Hamid', 'Nader', 'Ali']\n",
            "['Ali', 'Nader', 'Hamid', 'Ali']\n",
            "['Ali', 'Ali', 'Hamid', 'Nader']\n",
            "['Hamid', 'Nader']\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Dictionaries\n",
        "\n",
        "Dictionaries are used to store data values in pairs. A dictionary is a collection which is ordered, changeable and do not allow duplicates. Pairs are stored `key:value` format."
      ],
      "metadata": {
        "id": "VboDMFvqtA1_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_ID = {\"name\": \"Hamidreza\" , \"age\": 28 , \"nationality\" : \"Iranian\"}\n",
        "print (my_ID)\n",
        "print (len(my_ID))\n",
        "print(my_ID[\"name\"]) #Getting the value of a key\n",
        "my_ID [\"Height\"] = 174 #Adding new key and value to dictionary\n",
        "print (my_ID)\n",
        "print (my_ID.get(\"age\"))\n",
        "print (my_ID.get(\"weight\")) #There is no \"weight\" in keys"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DpNOxzfrxwNE",
        "outputId": "0f2f65a4-82d7-4abf-9358-04aa2cdd5aae"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'name': 'Hamidreza', 'age': 28, 'nationality': 'Iranian'}\n",
            "Hamidreza\n",
            "{'name': 'Hamidreza', 'age': 28, 'nationality': 'Iranian', 'Height': 174}\n",
            "28\n",
            "None\n",
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Sets\n",
        "\n",
        "Sets are used to store multiple items in a single variable. A set is a collection which is unordered, unchangeable, and unindexed. Sets cannot have two items with the same value."
      ],
      "metadata": {
        "id": "AOnx2fh972_5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "animals = {\"Dog\" , \"Horse\" , \"Cat\", \"Monkey\"}\n",
        "print (animals)\n",
        "print (len(animals))\n",
        "animals.add(\"Mouse\") #Adding an element to set\n",
        "print (animals)\n",
        "animals.remove(\"Cat\") #Deleting an element from set\n",
        "print (animals)\n",
        "animals.pop() #Deleting first element !!!\n",
        "print (animals)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "slyTWGCTyVer",
        "outputId": "09c3c9c8-0fb4-4b3e-c60b-391e35dbb938"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Horse', 'Monkey', 'Cat', 'Dog'}\n",
            "4\n",
            "{'Horse', 'Monkey', 'Cat', 'Dog', 'Mouse'}\n",
            "{'Horse', 'Monkey', 'Dog', 'Mouse'}\n",
            "{'Monkey', 'Dog', 'Mouse'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Tuples\n",
        "\n",
        "Tuples are used to store multiple items in a single variable. Tuple items are ordered, unchangeable, and allow duplicate values."
      ],
      "metadata": {
        "id": "z4gDvJkW-L0o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "fruits = (\"Apple\" , \"Banana\" , \"Orange\" , \"Apple\")\n",
        "print (fruits)\n",
        "print (len(fruits))\n",
        "print (fruits[2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vgwjVUei-mEI",
        "outputId": "d4e85f4b-11bf-4cdd-8b01-cd3584571928"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "('Apple', 'Banana', 'Orange', 'Apple')\n",
            "4\n",
            "Orange\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Conditionals in Python\n",
        "\n",
        "Conditional statements (`if`, `else`, and `elif`) are fundamental programming constructs that allow you to control the flow of your program based on conditions that you specify. They provide a way to make decisions in your program and execute different code based on those decisions.\n",
        "\n",
        "Equals: `a == b`\n",
        "\n",
        "Not Equals: `a != b`\n",
        "\n",
        "Less than: `a < b`\n",
        "\n",
        "Less than or equal to: `a <= b`\n",
        "\n",
        "Greater than: `a > b`\n",
        "\n",
        "Greater than or equal to: `a >= b`"
      ],
      "metadata": {
        "id": "8N-MjdsJEIk-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 5\n",
        "b = 2\n",
        "if a > b:\n",
        "  print (\"a is greater than b\")\n",
        "elif b > a:\n",
        "  print (\"b is greater than a\")\n",
        "else:\n",
        "  print (\"a,b are equal\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rXk365XuEHs-",
        "outputId": "4afcc014-fe46-44b9-b195-e7e8927cb03f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a is greater than b\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Loops in Python\n",
        "\n",
        "Loops are a programming element that repeat a portion of code a set number of times until the desired process is complete. Repetitive tasks are common in programming, and loops are essential to save time and minimize errors."
      ],
      "metadata": {
        "id": "j_mZvWcgFt1F"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##While loops\n",
        "\n",
        "With the `while` loop we can execute a set of statements as long as a condition is `True`.\n",
        "\n"
      ],
      "metadata": {
        "id": "pzQf5lgJF3kF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "counter = 1\n",
        "while counter < 5:\n",
        "  print (counter ** 2)\n",
        "  counter += 1\n",
        "\n",
        "print (counter)\n",
        "\n",
        "while counter < 9:\n",
        "  print (counter ** 3)\n",
        "  counter += 1\n",
        "  if counter == 7:\n",
        "    break\n",
        "\n",
        "print (counter)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ikzSxK8YJyEk",
        "outputId": "4a10d30c-e5b6-4251-8ea3-7a81e5562ab0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "4\n",
            "9\n",
            "16\n",
            "5\n",
            "125\n",
            "216\n",
            "7\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##For loops\n",
        "\n",
        "A `for` loop is used for iterating over a sequence (that is either a list, a tuple, a dictionary, a set, or a string)."
      ],
      "metadata": {
        "id": "HFg_nhJbKgEk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "even_numbers = [2,4,6,8,10]\n",
        "squares = []\n",
        "for number in even_numbers:\n",
        "  squares.append(number ** 2)\n",
        "\n",
        "print (squares)\n",
        "\n",
        "my_dict = {\"cat\" : 4 , \"human\" : 2 , \"bee\" : 6 , \"spider\" : 8 , \"snail\" : 0}\n",
        "for key in my_dict:\n",
        "  print (key , \": \", end = \"\")\n",
        "  print (my_dict[key])\n",
        "\n",
        "print (\"\") # only for separating results\n",
        "\n",
        "for key, value in my_dict.items():\n",
        "  print (key , \":\" , value)\n",
        "\n",
        "print (\"\") # only for separating results\n",
        "\n",
        "my_routine = (\"eat\" , \"sleep\" , \"code\")\n",
        "for i in my_routine:\n",
        "  print (i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WLRUAzKILOTc",
        "outputId": "395d3bd5-9231-469c-e2f6-0dfaf21a3ae7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[4, 16, 36, 64, 100]\n",
            "cat : 4\n",
            "human : 2\n",
            "bee : 6\n",
            "spider : 8\n",
            "snail : 0\n",
            "\n",
            "cat : 4\n",
            "human : 2\n",
            "bee : 6\n",
            "spider : 8\n",
            "snail : 0\n",
            "\n",
            "eat\n",
            "sleep\n",
            "code\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Range function\n",
        "\n",
        "The `range()` function returns a sequence of numbers, starting from 0 by default, and increments by 1 (by default), and stops before a specified number.\n",
        "\n",
        "**Syntax**: `range(start, stop, step)`\n",
        "\n",
        "`start`:\tOptional. An integer number specifying at which position to start. Default is `0`.\n",
        "\n",
        "`stop`:\tRequired. An integer number specifying at which position to stop (**not included**).\n",
        "\n",
        "`step`:\tOptional. An integer number specifying the incrementation. Default is `1`."
      ],
      "metadata": {
        "id": "h-zkfVLVeDOx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print (list(range(5)))\n",
        "print (list(range(2,7)))\n",
        "print (list(range(4,20,5)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "76NoSaqoep9h",
        "outputId": "b55cd6b0-da4a-4a00-a932-c1bba09516fb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, 2, 3, 4]\n",
            "[2, 3, 4, 5, 6]\n",
            "[4, 9, 14, 19]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A `for` loop is also used for iterating ranges."
      ],
      "metadata": {
        "id": "GYBMC9ogfZLa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(5):\n",
        "  print (i*10)\n",
        "\n",
        "print (\"\") # only for separating results\n",
        "\n",
        "for i in range(0,10,2):\n",
        "  print (i**2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VTKj6BOOfdvo",
        "outputId": "d1498e83-ac8b-4b7a-be2c-be0be8e43fa4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "10\n",
            "20\n",
            "30\n",
            "40\n",
            "\n",
            "0\n",
            "4\n",
            "16\n",
            "36\n",
            "64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Funtions in Python\n",
        "\n",
        "A function is a block of code which only runs when it is called. You can pass data, known as parameters, into a function. A function can return data as a result."
      ],
      "metadata": {
        "id": "iGo0GHCIjv2W"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def odd_even(x):\n",
        "  if x%2 == 0:\n",
        "    return \"even\"\n",
        "  else:\n",
        "    return \"odd\"\n",
        "\n",
        "print(odd_even(4))\n",
        "\n",
        "def sign(x):\n",
        "  if x > 0:\n",
        "    return \"+\"\n",
        "  elif x < 0:\n",
        "    return \"-\"\n",
        "  else:\n",
        "    return \"0\"\n",
        "\n",
        "print(sign(0))\n",
        "print(sign(4))\n",
        "print(sign(-18))\n",
        "\n",
        "def greeting(name):\n",
        "  print(\"Hello \" + name + \"!\")\n",
        "\n",
        "greeting (\"Mehrdad\")"
      ],
      "metadata": {
        "id": "Y75CgIwgj8Qc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "13d68c53-3f1b-4374-d2c7-9590a14aeec7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "even\n",
            "0\n",
            "+\n",
            "-\n",
            "Hello Mehrdad!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#User Input in Python\n",
        "\n",
        "We are able to ask the user for input by using `input()` method.\n",
        "\n",
        "**Remember**: Inputs are strings. to ask numeric inputs we use `int(input())`"
      ],
      "metadata": {
        "id": "2W6Qh0z5NmeL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "name = input()\n",
        "print (\"Hi \" + name)\n",
        "\n",
        "number = int(input())\n",
        "print (number*2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mByrVlVtN9jq",
        "outputId": "fa8a7e4d-cc0f-48ee-9dcf-27cb382f71b1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "reza\n",
            "Hi reza\n",
            "3\n",
            "6\n"
          ]
        }
      ]
    }
  ]
}