Python 101.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6c7c51ae",
   "metadata": {},
   "source": [
    "# Python 101 xD\n",
    " \n",
    "Alright, if you know programming and you just want to jump into python, this crashcourse is for you!<br />\n",
    "It's just the basics of the python's syntax to boost you a little bit. :)<br />\n",
    "without wasting time, let's crack on!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34c8d2fd",
   "metadata": {},
   "source": [
    "# Hello World"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7879214c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "# First program in python!\n",
    "# Yay and blah blah blah!\n",
    "print(\"Hello World!\")\n",
    "# Done!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2939e14",
   "metadata": {},
   "source": [
    "# Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8238f003",
   "metadata": {},
   "outputs": [],
   "source": [
    "# There is no such thing as \"data type\".\n",
    "# Wait what?\n",
    "my_variable = 12 #int\n",
    "my_variable = 12.0 #float\n",
    "my_variable = True #boolean\n",
    "my_variable = \"This is a 'string' \" #string\n",
    "my_variable = 'This is also a \"string\" '\n",
    "# '' and \"\" are pretty much the same thing "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6d0dd0d",
   "metadata": {},
   "source": [
    "# Comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0eb6cc43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    This is a string\n",
      "    So\n",
      "    I can\n",
      "    Print it!\n",
      "    :)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# There are two ways to write comments.\n",
    "# Frist with '#' as you see now\n",
    "# And with ''' '''\n",
    "# Or \"\"\" \"\"\"\n",
    "'''This is a comment'''\n",
    "\n",
    "\"\"\"\n",
    "You\n",
    "can\n",
    "write\n",
    "multiline\n",
    "comments    \n",
    "\"\"\"\n",
    "# This is a string as well, look below!\n",
    "print(\"\"\"\n",
    "    This is a string\n",
    "    So\n",
    "    I can\n",
    "    Print it!\n",
    "    :)\n",
    "\"\"\")\n",
    "# With '#' you can write only one line comments"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25954628",
   "metadata": {},
   "source": [
    "# Data Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a87527c2",
   "metadata": {},
   "source": [
    "## List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "758b30ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "# In python, we have list, Tuple and Dictionary as main Data Structures\n",
    "# We only talk about lists in this part"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73701318",
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "So lists are like arrays.\n",
    "But!\n",
    "you don't need to initialize a lenght for it! :)\n",
    "For example:\n",
    "'''\n",
    "my_list = list()\n",
    "''' Yep! That's it! '''\n",
    "\n",
    "# You can also define a list this way\n",
    "my_list = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8b68141c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 12.0, 'bullshit', True]\n"
     ]
    }
   ],
   "source": [
    "# Let me show you something intersting!\n",
    "my_list = [1, 2, 12.0, 'bullshit', True]\n",
    "# See! You can put any type in a list! Interesting huh!\n",
    "\n",
    "\n",
    "\n",
    "# Let's see how we can add something in our list!\n",
    "my_list.append(13) # my_list = [1, 2, 12.0, 'bullshit', True, 13]\n",
    "# \"append\" method will add to the end of the list.\n",
    "\n",
    "\n",
    "# We can also add data to our list with \"insert\" method. First argument is index and the second one is data.\n",
    "my_list.insert(1, 12) # my_list = [1, 12, 2, 12.0, 'bullshit', True, 13]\n",
    "\n",
    "\n",
    "\n",
    "# Lists also can be used as stacks.\n",
    "# As you know \"append\" method adds to the end of the list.\n",
    "#Then we have the \"pop\" method. It will remove from the end of the list and return that item.\n",
    "poped_item = my_list.pop() # my_list = [1, 12, 2, 12.0, 'bullshit', True] , poped_item: 13\n",
    "\n",
    "\n",
    "# Lists as queues?\n",
    "# The pop method can also get an argument as an index. So we have a queue here! TADA!\n",
    "poped_item = my_list.pop(0) # my_list = [12, 2, 12.0, 'bullshit', True] , poped_item: 12\n",
    "\n",
    "\n",
    "# You can also delete an item directly from your list.\n",
    "# Simply call the \"remove\" method! Cool right? :)\n",
    "my_list.remove(12.0)\n",
    "# Our list should be like this: [2, 12.0, 'bullshit', True]\n",
    "\n",
    "# Hold on now! What happened there?\n",
    "# We wanted to delete 12.0 not 12!\n",
    "# So in Python, 12 and 12.0 are equal!\n",
    "\n",
    "# \"remove\" method starts iterating on the list and checks if the item is what we want to remove or not.\n",
    "# And if we have similar items in our list, \"remove\" method will delete the item that has the lowest index.\n",
    "# In this case, the first item in my_list is 12 and we want 12.0. These are the same to python so it just deleted 12.\n",
    "\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ce589345",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# The first index in python is 0\n",
    "print(my_list[0])\n",
    "\n",
    "# If you want to find the lenght of any object(obviously it has to be iterable) you can use \"len\" method.\n",
    "# In our case, the iterable object is the list\n",
    "print(len(my_list))\n",
    "\n",
    "# FYI: \"list\" is not the only iterable object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5a8e3fc5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Question:\n",
    "# What do you expect when you see this syntax \"my_list[-1]\" ?\n",
    "# Let's try it\n",
    "print(my_list[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f2998d0b",
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-6-4f99dcda318a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;31m# But you should be careful with that.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;31m# For example:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmy_list\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "# What happened?\n",
    "# Our list is [2, 12.0, 'bullshit', True]. Then the last object in the list is \"True\".\n",
    "# So... Yup! We have negative index in python!\n",
    "# But you should be careful with that.\n",
    "# For example:\n",
    "print(my_list[-5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e0b8113f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# You can only go up to the end of list\n",
    "my_list[-len(my_list)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "601d162a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 4, 3, 6]\n"
     ]
    }
   ],
   "source": [
    "# Imagine I have a list like this\n",
    "my_list = [1, 2, 4,4,3,6,8, 5,9]\n",
    "\n",
    "# And I want some part of it! for example from index 2 up to index 5\n",
    "# In other programming languages like C we do something like this:\n",
    "'''\n",
    "for(int i=2; i < 6; i++){\n",
    "   newList[i-2] = my_list[i]; #as you may know we creates a new list and called it newList and etc \n",
    "} \n",
    "'''\n",
    "# But it's way easier in python:\n",
    "print(my_list[2:6])\n",
    "# From index \"i\" till index \"j-1\"(in this case i=2 and j=6)\n",
    "# We call this \"slicing\"!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "24ffc10b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# There is also a third argument that defines step!\n",
    "# For example I want to go from index 1 up to index 5 with step=2: [2, 4, 6]\n",
    "my_list[1:6:2]\n",
    "# That's it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "00d2a2f5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not sorted list:  [1, 2, 4, 4, 3, 6, 8, 5, 9]\n",
      "Sorted list:  [1, 2, 3, 4, 4, 5, 6, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "# There are many built-in methods in \"list\" object. One of them is \"sort\"\n",
    "print('Not sorted list: ',my_list)\n",
    "my_list.sort()\n",
    "print('Sorted list: ', my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f0abfb15",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not reversed list:  [1, 2, 3, 4, 4, 5, 6, 8, 9]\n",
      "Reversed list:  [9, 8, 6, 5, 4, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "# What if I wanted to reverse my list?\n",
    "# Python is a language for lazy poeple(like me :D)\n",
    "print('Not reversed list: ',my_list)\n",
    "my_list.reverse()\n",
    "print('Reversed list: ', my_list)\n",
    "# EZ PZ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4abb27fc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 8, 6, 5, 4, 4, 3, 2, 1]\n"
     ]
    }
   ],
   "source": [
    "# There is another way if you don't like to use that method\n",
    "'''\n",
    "Remember the slicing part?\n",
    "We can pass a step arg to list, right?\n",
    "What if I pass -1 for step?\n",
    "'''\n",
    "my_list = [1, 2, 3, 4, 4, 5, 6, 8, 9] # This is my_list before the reverse method, right?\n",
    "# Check this out!\n",
    "print(my_list[::-1]) # [9, 8, 6, 5, 4, 4, 3, 2, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a425034",
   "metadata": {},
   "outputs": [],
   "source": [
    "# It's simply reversed!\n",
    "\n",
    "# Next, we're gonna talk about tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fa8d72d",
   "metadata": {},
   "source": [
    "## Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "be196a78",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tuples are very similar to lists\n",
    "\n",
    "# You can define a tuple like a list\n",
    "my_tuple = tuple()\n",
    "# or\n",
    "my_tuple = (1, 2, 12.0, 'bullshit', True, [], ())\n",
    "# And you can put anything in tuples and lists, because we don't have any data type in python. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "54eb4c5a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1,)\n"
     ]
    }
   ],
   "source": [
    "# What if I wanted to define a one item tuple?\n",
    "# Using the keyword\n",
    "my_tuple_with_one_item = tuple([1]) # What is that list doing in there?\n",
    "# tuple() has one optional argument and it has to be an iterable object\n",
    "# Also I can get the same result:\n",
    "my_tuple_with_one_item = (1, )\n",
    "# What is that comma?\n",
    "# it has to be there for python to understand that this is a tuple, otherwise the python interpreter recognizes\n",
    "# this is a normal number and the perentesis as the operators\n",
    "print(my_tuple_with_one_item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e6190a4f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "((), [], True, 'bullshit', 12.0, 2, 1)\n"
     ]
    }
   ],
   "source": [
    "# We can iterate on tuples like lists and any other iterable object\n",
    "print(my_tuple[0])\n",
    "print(my_tuple[::-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3357f77",
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can use everything that we talked about in list, for tuples\n",
    "\"\"\"EXCEPT ONE THING!\"\"\"\n",
    "# tuples are immutable!\n",
    "# What does it mean?\n",
    "# It means you can't change the data stored in tuples!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "a2711b30",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-17-ffab84a18bfc>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mmy_tuple\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m '''\n\u001b[0;32m      3\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;34m'tuple'\u001b[0m \u001b[0mobject\u001b[0m \u001b[0mdoes\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0msupport\u001b[0m \u001b[0mitem\u001b[0m \u001b[0massignment\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m '''\n\u001b[0;32m      5\u001b[0m \u001b[1;31m# That's what I'm talking about.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "my_tuple[0] = 2\n",
    "'''\n",
    "TypeError: 'tuple' object does not support item assignment\n",
    "'''\n",
    "# That's what I'm talking about.\n",
    "# Avoid these for safety measures."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf0af228",
   "metadata": {},
   "source": [
    "## Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "1a90f3b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now we may need a data structure to store data in a way of sets. So basically we need sets.\n",
    "# The question is how can we achive that? very simple\n",
    "my_set = {}\n",
    "\n",
    "# It's that simple as everything else in python :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "66321f1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6}\n",
      "{2, 3, 4, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "# Remember that sets are collections which they are unordered, unchangeable, and unindexed.\n",
    "# By unchangeable I mean we can add or remove but we can't change the item!\n",
    "\n",
    "my_set = {1,2,3,4,5}\n",
    "\n",
    "my_set.add(6)\n",
    "\n",
    "print(my_set)\n",
    "\n",
    "my_set.remove(1)\n",
    "\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cd2cd3d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 'some random data', 'taxi'}\n"
     ]
    }
   ],
   "source": [
    "# As you know sets can't have duplicates. It is valid also here\n",
    "my_set = {1, 1, \"taxi\", \"some random data\"}\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "40991ca1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 'some random data'}\n"
     ]
    }
   ],
   "source": [
    "# So let me tell you something, let me tell you something....\n",
    "my_set = {1, 1, True, \"some random data\"}\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ecfe87e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1}\n"
     ]
    }
   ],
   "source": [
    "# wait whaaa....\n",
    "# where did the True go???\n",
    "# So funny thing is in sets 1 and True are the same and counts as a duplicate!\n",
    "# Intresting, right?\n",
    "# So with this logic we can say that the 0 and False are counting as a duplicate as well.\n",
    "# You are right!\n",
    "my_set = {1, 0, False, 1, 0}\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "9fc6e7bf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# You may ask\n",
    "# \"Well we don't have index for sets, right?\"\n",
    "# \"Yes\"\n",
    "# \"Then we can't itterate over them?\"\n",
    "# \"You can!\"\n",
    "# \"Nani??\"\n",
    "\n",
    "# So listen! The fact that set doesn't have index, it doesn't mean that we can't itterate over it!\n",
    "# We still have item in the set. So we can have a for on it, right?\n",
    "my_set = {1, 2, 3, 4, 5}\n",
    "for i in my_set:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "daae186d",
   "metadata": {},
   "source": [
    "## Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "068a5d91",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n"
     ]
    }
   ],
   "source": [
    "# Dictionary is a non sequence datastructure with a \"key, value\" system.\n",
    "# it means that you define a key and add a value for that specific key.\n",
    "# You can define an empty dictionary with the 'dict()' method.\n",
    "my_dict = dict()\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "7e2c3dc6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key': 'value', 'key1': 'value1', 'key2': 'value2'}\n"
     ]
    }
   ],
   "source": [
    "# Or you can define it like this.\n",
    "# key, and \":\" , value.\n",
    "my_dict = {\n",
    "    'key': 'value',\n",
    "    'key1': 'value1',\n",
    "    'key2': 'value2',\n",
    "}\n",
    "# There is no data type, so your key and value can be anything you want.\n",
    "# But keys are uniqe! Just try to keep your code clean xD\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1f0d33e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value\n"
     ]
    }
   ],
   "source": [
    "# You can simply call a key and it will return the expected value.\n",
    "print(my_dict['key']) # Should be 'value'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "81ba8050",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key': 'value', 'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}\n",
      "value3\n"
     ]
    }
   ],
   "source": [
    "# If you want to add a pair of <key, value> you can do this:\n",
    "# my_dict[<key>] = <value>\n",
    "# For example\n",
    "my_dict['key3'] = 'value3'\n",
    "print( my_dict)\n",
    "print(my_dict['key3'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "6e0b20f6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('key3', 'value3')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Dictionary has a \"popitem()\" method.\n",
    "# It'll delete and return the last added \"key, value\".\n",
    "my_dict.popitem()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "88a02560",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key1': 'value1', 'key2': 'value2'}\n"
     ]
    }
   ],
   "source": [
    "# It also has an optional argument that using which you can pass a key and it'll delete the expected value and return it.\n",
    "my_dict.pop(\"key\")\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "937cea3d",
   "metadata": {},
   "source": [
    "So as of now we saw 4 data collection types:\n",
    "- List is a collection which is ordered and changeable. Allows duplicate members.\n",
    "- Tuple is a collection which is ordered and unchangeable. Allows duplicate members.\n",
    "- Set is a collection which is unordered, unchangeable*, and unindexed. No duplicate members.\n",
    "- Dictionary is a collection which is ordered** and changeable. No duplicate members.\n",
    "\n",
    "*Set items are unchangeable, but you can remove items and add new items.\n",
    "\n",
    "**As of Python version 3.7, dictionaries are ordered. In Python 3.6 and earlier, dictionaries are unordered."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31a9d825",
   "metadata": {},
   "source": [
    "## Python is a good calculator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1e958e61",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 + 2 =  3\n",
      "2 * 4.5 =  9.0\n",
      "10 - 2.5 =  7.5\n",
      "1 / 2 =  0.5\n",
      "5 // 2 =  2\n",
      "2 ** 3 =  8\n"
     ]
    }
   ],
   "source": [
    "# Python is also a very good calculator\n",
    "# Normal arithmetic operators like '+', '-', '*', '/' are similar to other programing languages\n",
    "print('1 + 2 = ', 1 + 2)\n",
    "print('2 * 4.5 = ', 2 * 4.5)\n",
    "print('10 - 2.5 = ', 10 - 2.5)\n",
    "print('1 / 2 = ', 1/2)# '/' operator returns float numbers.\n",
    "# If you don't like floats you can use '//' operator. This returns just the integer part of the number\n",
    "print('5 // 2 = ', 5//2)\n",
    "# You can also use '**' operator as power\n",
    "print('2 ** 3 = ',2**3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b967bf8",
   "metadata": {},
   "source": [
    "## Statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "bb0f6cf5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# There are a few operators like '==', '!=', '>=', '<=' using which you can compare two objects.\n",
    "print(1 == 2)\n",
    "print(1 >= 2)\n",
    "print(1 <= 2)\n",
    "print(1 != 2)\n",
    "# You can also do chain operators\n",
    "print(1 < 2 < 3 < 10 > 5)\n",
    "# If one of them is false, the whole statement is false.\n",
    "print(1 < 2 < 3 > 10 > 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c763c825",
   "metadata": {},
   "source": [
    "## if"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "563ef152",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "blah blah blah 2\n",
      "2 == 2\n",
      "2 == 2\n"
     ]
    }
   ],
   "source": [
    "# For 'if' we do this:\n",
    "if 1 == 2:\n",
    "    print('blah blah blah')\n",
    "else:    \n",
    "    print('blah blah blah 2')\n",
    "\n",
    "# There is also nested if.\n",
    "if 1 == 2:\n",
    "    print('1 == 2')\n",
    "else:\n",
    "    if 2 == 2:\n",
    "        print('2 == 2')\n",
    "    else:\n",
    "        print('blah blah blah 3')\n",
    "        \n",
    "# But this is so ugly!\n",
    "# Then let me introduce you to 'elif'.\n",
    "# 'elif' is else then if!\n",
    "if 1 == 2:\n",
    "    print('1 == 2')\n",
    "elif 2 == 2:\n",
    "    print('2 == 2')\n",
    "else:\n",
    "    print('blah blah blah 3')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9a53c70",
   "metadata": {},
   "source": [
    "## match - case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0973ffe8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# in the c/c++ we use switch case\n",
    "# The switch case statement in a C/C++ program would look something like this\n",
    "switch (variable to be evaluated):\n",
    "{\n",
    "     case value1 : //statement 1\n",
    "                   break;\n",
    " \n",
    "     case value2 : //statement 2\n",
    "                   break;\n",
    " \n",
    "     case value_n : //statement n\n",
    "                    break;\n",
    " \n",
    "     default:  //default statement\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dcfa0de6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# In Python 3.10 (2021) introduced the match-case statement\n",
    "# Which provides a first-class implementation of a \"switch\" for Python\n",
    "# The syntax looks something like this\n",
    "match variable_name:\n",
    "            case ‘pattern1’ : //statement1\n",
    "            case ‘pattern2’ : //statement2\n",
    "            …            \n",
    "            case ‘pattern n’ : //statement n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9be1f807",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's see an example\n",
    "list1 = ['a', 'b', 'c', 'd']\n",
    " \n",
    "match list1:\n",
    "    case ['e','f'] : print(\"e,f present\")\n",
    "    case ['a','b','c','d'] : print(\"a,b,c,d present\")\n",
    "# Since I'm using the Python3.8 I can't show you the output\n",
    "# But the output will be:\n",
    "# a,b,c,d present"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "099d96a0",
   "metadata": {},
   "source": [
    "## while"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "ebb6281b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I is:  0\n",
      "I is:  1\n",
      "I is:  2\n",
      "I is:  3\n",
      "I is:  4\n",
      "I is:  5\n",
      "I is:  6\n",
      "I is:  7\n",
      "I is:  8\n",
      "I is:  9\n"
     ]
    }
   ],
   "source": [
    "# The first kind of loop :)\n",
    "\"\"\"\n",
    "while condition:\n",
    "    do something!\n",
    "\"\"\"\n",
    "# That's it!\n",
    "# Example: \n",
    "i = 0\n",
    "while i < 10:\n",
    "    print('I is: ', i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "42bda932",
   "metadata": {},
   "outputs": [],
   "source": [
    "# You want to stop the while whenever you want?\n",
    "# No problem!\n",
    "i = 0\n",
    "while True:\n",
    "    i += 1\n",
    "    if i > 15:\n",
    "        break\n",
    "# 'break' will stop the while and moves on to the rest of the code"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fa433fe",
   "metadata": {},
   "source": [
    "## for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "d38edc5b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "item is:  1\n",
      "item is:  2\n",
      "item is:  3\n",
      "item is:  4\n"
     ]
    }
   ],
   "source": [
    "# 'for' In python is like 'for each' in java\n",
    "my_list = [1, 2, 3, 4]\n",
    "for item in my_list:\n",
    "    print('item is: ', item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "2fdd1efc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I is:  0\n",
      "I is:  1\n",
      "I is:  2\n",
      "I is:  3\n",
      "I is:  4\n",
      "I is:  5\n",
      "I is:  6\n",
      "I is:  7\n",
      "I is:  8\n",
      "I is:  9\n"
     ]
    }
   ],
   "source": [
    "# What if I want to use 'for' like a normal for?\n",
    "# Well, check this out!\n",
    "for i in range(0, 10):\n",
    "    print('I is: ', i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0355bb01",
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# range() is a built-in function that returns a range from the first argument up to the second argumnet\n",
    "# with the step of the third argument.\n",
    "# for example:\n",
    "for i in range(0, 10):\n",
    "    print(i)\n",
    "'''\n",
    "out:\n",
    "0\n",
    "1\n",
    "2\n",
    "3\n",
    "4\n",
    "5\n",
    "6\n",
    "7\n",
    "8\n",
    "9\n",
    "'''\n",
    "for i in range(5, 10, 2):\n",
    "    print(i)\n",
    "'''\n",
    "out:\n",
    "5\n",
    "7\n",
    "9\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "b7df917c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value 1\n",
      "value 2\n",
      "value 3\n",
      "value 4\n"
     ]
    }
   ],
   "source": [
    "# You can put any iterable object after 'in' when using 'for':\n",
    "my_dict = {\n",
    "    'item 1': 'value 1',\n",
    "    'item 2': 'value 2',\n",
    "    'item 3': 'value 3',\n",
    "    'item 4': 'value 4'\n",
    "}\n",
    "for item in my_dict:\n",
    "    print(my_dict[item])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4feec66b",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "c206e186",
   "metadata": {},
   "outputs": [],
   "source": [
    "# To define finctions:\n",
    "'''\n",
    "def <function name>():\n",
    "    whatever!\n",
    "'''\n",
    "# That's it! You're all set!\n",
    "def my_func():\n",
    "    print('Yay! My function is working!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "62f42cd5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi! my name is Ali Daghighi. and I'm 21\n"
     ]
    }
   ],
   "source": [
    "# What if I wanted to get argumants for my function?\n",
    "# Simple!\n",
    "'''\n",
    "def <function name>(arg1, arg2, arg3):\n",
    "    whatever!\n",
    "'''\n",
    "def my_func2(name, family, age):\n",
    "    print('Hi! my name is ' + name + ' ' + family + \". and I'm \" + age)\n",
    "# How am I gonna use it?\n",
    "# By calling it!\n",
    "my_func2('Ali', 'Daghighi', '21')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "0fdf653b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi! my name is Ali Daghighi. and I'm 21\n"
     ]
    }
   ],
   "source": [
    "# If you want, you can give them a default value by assigning the value to each argument while you're writing the function\n",
    "def my_func3(name='Ali', family='Daghighi', age='21'):\n",
    "    print('Hi! my name is ' + name + ' ' + family + \". and I'm \" + age)\n",
    "    \n",
    "my_func3()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "522fad86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi my name is Ali and this is some other stuff xD\n",
      "Some\n",
      "Random\n",
      "Other\n",
      "Stuff\n"
     ]
    }
   ],
   "source": [
    "# What if we don't know the number of arguments?\n",
    "# Ez Pz\n",
    "\n",
    "def my_func4(name='Ali', *other_stuff):\n",
    "    print(\"Hi my name is \" + name + \" and some other stuff xD\")\n",
    "    for var in other_stuff:\n",
    "        print(var)\n",
    "\n",
    "my_func4('Ali', 'Some', 'Random', 'Other', 'Stuff')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "aa0ee560",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# What about return?\n",
    "# You just have to return whatever you want at the end of the function\n",
    "\n",
    "def my_func5(*args):\n",
    "    resault = 0\n",
    "    for arg in args:\n",
    "        resault += arg\n",
    "    return resault\n",
    "\n",
    "print(my_func5(1 ,2, 3, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff5abaa2",
   "metadata": {},
   "source": [
    "# Scope of Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "9b496d7c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inside the function local total :  30\n",
      "Outside the function global total :  0\n"
     ]
    }
   ],
   "source": [
    "# \"So All variables in a program may not be accessible at all locations in that program.\"\n",
    "# What does it mean?\n",
    "# That means \"where have you declared a variable?\"\n",
    "# let me elaborate:\n",
    "# In python we have \"Global variables\" and \"Local variables\" \n",
    "\n",
    "total = 0; # This is a global variable.\n",
    "# Now we have this function:\n",
    "def sum( arg1, arg2 ):\n",
    "    # Add both parameters and return them.\"\n",
    "    total = arg1 + arg2; # the total is a local variable.\n",
    "    print(\"Inside the function local total : \", total)\n",
    "    return total;\n",
    "\n",
    "# Now you can call the \"sum\" function\n",
    "sum( 10, 20 );\n",
    "print(\"Outside the function global total : \", total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "16ff7c70",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before:\t Bianca Peterson\n",
      "After:\t Bianca Lucinda Peterson\n"
     ]
    }
   ],
   "source": [
    "# What if we needed access to the global variable?\n",
    "\n",
    "# Check this example:\n",
    "\n",
    "name = \"Bianca Peterson\"\n",
    "print(\"Before:\\t\", name)\n",
    "def setName():\n",
    "    global name\n",
    "    name = \"Bianca Lucinda Peterson\"\n",
    "\n",
    "setName()\n",
    "print(\"After:\\t\", name)\n",
    "\n",
    "# Using the keyword \"global\" you can access the outer scope"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d7a7581",
   "metadata": {},
   "source": [
    "# files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d93cf8a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python has a built-in \"open()\" function for opening a file.\n",
    "# This function returns a file object, also called a handle, as it is used to read or modify the file accordingly\n",
    "\n",
    "f = open(\"test.txt\")    # open file in current directory\n",
    "\n",
    "#                       \"OR\"\n",
    "\n",
    "f = open(\"C:/Python38/README.txt\")  # specifying full path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bce913cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# The default is reading in text mode\n",
    "# On the other hand, binary mode returns bytes and this is the mode to be used when dealing with -\n",
    "# non-text files like images or executable files\n",
    "\n",
    "# There are a few modes that you can use to open a file:\n",
    "\n",
    "# r : Opens a file for reading. (default)\n",
    "\n",
    "# w : Opens a file for writing. Creates a new file if it does not exist\n",
    "#     or truncates the file if it exists.\n",
    "\n",
    "# x : Opens a file for exclusive creation.\n",
    "#     But if the file already exists, the operation fails.\n",
    "\n",
    "# a : Opens a file for appending at the end of the file without truncating it.\n",
    "#     Creates a new file if it does not exist\n",
    "\n",
    "# t : Opens in text mode. (default)\n",
    "\n",
    "# b : Opens in binary mode.\n",
    "\n",
    "# + : Opens a file for updating (reading and writing)\n",
    "\n",
    "\n",
    "f = open(\"test.txt\")      # equivalent to 'r' or 'rt'\n",
    "f = open(\"test.txt\",'w')  # write in text mode\n",
    "f = open(\"img.bmp\",'r+b') # read and write in binary mode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51dae666",
   "metadata": {},
   "outputs": [],
   "source": [
    "# For closing file:\n",
    "\n",
    "f.close()\n",
    "# Tada!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8312efaf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Since we are working with files, it's time to see how error handling works in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "791a26da",
   "metadata": {},
   "source": [
    "# Exceptions Handling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ddc2a31",
   "metadata": {},
   "outputs": [],
   "source": [
    "# we are gonna use the \"try\" and \"except\" statments for handling exceptions.\n",
    "# This is a simple try and except block:\n",
    "\n",
    "try:\n",
    "   # your operations here\n",
    "   \n",
    "except ExceptionI:\n",
    "   # If there is ExceptionI, execute this block.\n",
    "\n",
    "except ExceptionII:\n",
    "   # If there is ExceptionII, execute this block.\n",
    "\n",
    "else:\n",
    "   # If there is no exception, execute this block. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "1334b8af",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error: can't find file or read data\n"
     ]
    }
   ],
   "source": [
    "# Let's try that\n",
    "try:\n",
    "    fh = open(\"testfile\", \"r\")\n",
    "    fh.write(\"This is my test file for exception handling!!\")\n",
    "except IOError:\n",
    "    print(\"Error: can\\'t find file or read data\")\n",
    "else:\n",
    "    print(\"Written content in the file successfully\")\n",
    "    fh.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "28190722",
   "metadata": {},
   "outputs": [],
   "source": [
    "# What if I want to have multiple exceptoins?\n",
    "\n",
    "try:\n",
    "   # Your operations here\n",
    "\n",
    "except(Exception1[, Exception2[,...ExceptionN]]):\n",
    "   # If there is any exception from the given exception list, \n",
    "   # then execute this block.\n",
    "   \n",
    "else:\n",
    "   # If there is no exception, execute this block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b503f53b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# There is also a try-finally Clause\n",
    "\n",
    "try:\n",
    "   # Your operations here\n",
    "   # ......................\n",
    "   # Due to any exception, this may be skipped.\n",
    "\n",
    "finally:\n",
    "   # This would always be executed.\n",
    "   # ......................\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0381796",
   "metadata": {},
   "outputs": [],
   "source": [
    "# For the argument of an Exception we can do this:\n",
    "\n",
    "try:\n",
    "   # Your operations here\n",
    "   # ......................\n",
    "\n",
    "except ExceptionType, Argument:\n",
    "   # Print value of Argument here..."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cb3c3ce",
   "metadata": {},
   "source": [
    "# class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ab31797",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python has been an object-oriented language since the beginning.\n",
    "# Creating and using classes and objects are easy\n",
    "\n",
    "######################################## BREAKING POINT ########################################\n",
    "\n",
    "# I assume that you know OOP(object-oriented programming)\n",
    "# But if you don't know..... well I can't tell you the whole OOP paradigm here but here are some pointer:\n",
    "\n",
    "\"\"\"\n",
    "Class − A user-defined prototype for an object that defines a set of attributes that characterize any object of the class.\n",
    "        The attributes are data members (class variables and instance variables) and methods, accessed via dot notation.\n",
    "\n",
    "Class variable − A variable that is shared by all instances of a class.\n",
    "                Class variables are defined within a class but outside any of the class's methods.\n",
    "                Class variables are not used as frequently as instance variables are.\n",
    "\n",
    "Data member − A class variable or instance variable that holds data associated with a class and its objects.\n",
    "\n",
    "Function overloading − The assignment of more than one behavior to a particular function.\n",
    "                       The operation performed varies by the types of objects or arguments involved.\n",
    "\n",
    "Instance variable − A variable that is defined inside a method and belongs only to the current instance of a class.\n",
    "\n",
    "Inheritance − The transfer of the characteristics of a class to other classes that are derived from it.\n",
    "\n",
    "Instance − An individual object of a certain class. An object obj that belongs to a class Circle,\n",
    "           for example, is an instance of the class Circle.\n",
    "\n",
    "Instantiation − The creation of an instance of a class.\n",
    "\n",
    "Method − A special kind of function that is defined in a class definition.\n",
    "\n",
    "Object − A unique instance of a data structure that's defined by its class.\n",
    "         An object comprises both data members (class variables and instance variables) and methods.\n",
    "\n",
    "Operator overloading − The assignment of more than one function to a particular operator\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b5025ad8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining a class is similar to a function:\n",
    "\n",
    "class ClassName:\n",
    "   # 'Optional class documentation string'\n",
    "   #  class_suite\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5309a32f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's see an example\n",
    "\n",
    "class Employee:\n",
    "    'Common base class for all employees'\n",
    "    empCount = 0\n",
    "\n",
    "    def __init__(self, name, salary):\n",
    "        self.name = name\n",
    "        self.salary = salary\n",
    "        Employee.empCount += 1\n",
    "   \n",
    "    def displayCount(self):\n",
    "        print(\"Total Employees \" + Employee.empCount)\n",
    "\n",
    "    def displayEmployee(self):\n",
    "        print(\"Name : \", self.name,  \", Salary: \", self.salary)\n",
    "        \n",
    "# But this is not similar to functions at all!\n",
    "\n",
    "# Let's go step by step.\n",
    "# We have a keyword definition for class which is \"class\", and the name of the class.\n",
    "# After that we have the \"empCount\" which is the base attribute for the Employee class.\n",
    "# Then we have \"def __init__\"\n",
    "# The __init__() Function:\n",
    "# All classes have a function called __init__() which is always executed when the class is being initiated\n",
    "# And the other two functions are the methods of the class.\n",
    "# You declare other class methods like normal functions with the exception that the first argument to each method is \"self\"\n",
    "# Python adds the self argument to the list for you, so you do not need to include it when you call the methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "76635375",
   "metadata": {},
   "outputs": [],
   "source": [
    "# To create instances of a class, you call the class using the class name\n",
    "# and pass in whatever arguments its __init__ method accepts\n",
    "\n",
    "# This creates the first object of the Employee class\n",
    "emp1 = Employee(\"Zara\", 2000)\n",
    "\n",
    "# This creates the second object of the Employee class\n",
    "emp2 = Employee(\"Manni\", 5000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2c11f658",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name :  Zara , Salary:  2000\n",
      "Name :  Manni , Salary:  5000\n",
      "Total Employees: 2\n"
     ]
    }
   ],
   "source": [
    "# You can access the object's attributes using the dot operator with an object like java\n",
    "emp1.displayEmployee()\n",
    "emp2.displayEmployee()\n",
    "print(\"Total Employees: \" + str(Employee.empCount))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "df2958ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can add, remove, or modify attributes of classes and objects at any time.\n",
    "\n",
    "emp1.age = 7  # Add an 'age' attribute.\n",
    "emp1.age = 8  # Modify 'age' attribute.\n",
    "del emp1.age  # Delete 'age' attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "7f062c27",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Instead of using the normal statements to access attributes, you can use the following functions:\n",
    "\n",
    "# The getattr(obj, name[, default]) − to access the attribute of object.\n",
    "# The hasattr(obj,name) − to check if an attribute exists or not.\n",
    "# The setattr(obj,name,value) − to set an attribute. If attribute does not exist, then it would be created.\n",
    "# The delattr(obj, name) − to delete an attribute.\n",
    "\n",
    "setattr(emp1, 'age', 8) # Set attribute 'age' at 8\n",
    "getattr(emp1, 'age')    # Returns value of 'age' attribute\n",
    "hasattr(emp1, 'age')    # Returns true if 'age' attribute exists\n",
    "delattr(emp1, 'age')    # Delete attribute 'age'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "2b280576",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Employee.__doc__: Common base class for all employees\n",
      "Employee.__name__: Employee\n",
      "Employee.__module__: __main__\n",
      "Employee.__bases__: (<class 'object'>,)\n",
      "Employee.__dict__: {'__module__': '__main__', '__doc__': 'Common base class for all employees', 'empCount': 2, '__init__': <function Employee.__init__ at 0x00000218210FF550>, 'displayCount': <function Employee.displayCount at 0x00000218210FF280>, 'displayEmployee': <function Employee.displayEmployee at 0x00000218210FF1F0>, '__dict__': <attribute '__dict__' of 'Employee' objects>, '__weakref__': <attribute '__weakref__' of 'Employee' objects>}\n"
     ]
    }
   ],
   "source": [
    "# There are a few built-in Class Attributes:\n",
    "\n",
    "# __dict__ − Dictionary containing the class's namespace\n",
    "# __doc__ − Class documentation string or none, if undefined\n",
    "# __name__ − Class name.\n",
    "# __module__ − Module name in which the class is defined. This attribute is \"__main__\" in interactive mode\n",
    "\"\"\"\n",
    "yeah I haven't talked about the modules.\n",
    "\"\"\"\n",
    "# __bases__ − A possibly empty tuple containing the base classes, in the order of their occurrence in the base class list.\n",
    "\n",
    "# Let's try these for the Employee class\n",
    "\n",
    "print(\"Employee.__doc__:\", Employee.__doc__)\n",
    "print(\"Employee.__name__:\", Employee.__name__)\n",
    "print(\"Employee.__module__:\", Employee.__module__)\n",
    "print(\"Employee.__bases__:\", Employee.__bases__)\n",
    "print(\"Employee.__dict__:\", Employee.__dict__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "baec7189",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Destroying Objects?\n",
    "# Like java, Python deletes unneeded objects (built-in types or class instances) -\n",
    "# automatically to free the memory space\n",
    "\n",
    "# Python's garbage collector runs during program execution and is triggered when an object's reference count reaches zero.\n",
    "# An object's reference count changes as the number of aliases that point to it changes"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3822f7c1",
   "metadata": {},
   "source": [
    "## Class Inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8d009ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A class in python can have many parents\n",
    "\n",
    "class SubClassName (ParentClass1[, ParentClass2, ...]):\n",
    "    'Optional class documentation string'\n",
    "    class_suite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "f131ed04",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling child constructor\n",
      "Calling child method\n",
      "Calling parent method\n",
      "Parent attribute : 200\n"
     ]
    }
   ],
   "source": [
    "# Let's see an example:\n",
    "\n",
    "class Parent:        # define parent class\n",
    "    parentAttr = 100\n",
    "    def __init__(self):\n",
    "        print(\"Calling parent constructor\")\n",
    "\n",
    "    def parentMethod(self):\n",
    "        print('Calling parent method')\n",
    "\n",
    "    def setAttr(self, attr):\n",
    "        Parent.parentAttr = attr\n",
    "\n",
    "    def getAttr(self):\n",
    "        print(\"Parent attribute :\", Parent.parentAttr)\n",
    "\n",
    "class Child(Parent): # define child class\n",
    "    def __init__(self):\n",
    "        print(\"Calling child constructor\")\n",
    "\n",
    "    def childMethod(self):\n",
    "        print('Calling child method')\n",
    "\n",
    "c = Child()          # instance of child\n",
    "c.childMethod()      # child calls its method\n",
    "c.parentMethod()     # calls parent's method\n",
    "c.setAttr(200)       # again call parent's method\n",
    "c.getAttr()          # again call parent's method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "668dec41",
   "metadata": {},
   "outputs": [],
   "source": [
    "# you can drive a class from multiple parent classes in a similar way, as follows\n",
    "\n",
    "class A:        # define class A\n",
    "    # .....\n",
    "\n",
    "class B:         # define class B\n",
    "    # .....\n",
    "\n",
    "class C(A, B):   # subclass of A and B\n",
    "    # ....."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9d3bd1f",
   "metadata": {},
   "source": [
    "## Overriding Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "173fe87f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling child method\n"
     ]
    }
   ],
   "source": [
    "# You can always override the parent methods using:\n",
    "\n",
    "class Parent:        # define parent class\n",
    "    def myMethod(self):\n",
    "        print('Calling parent method')\n",
    "\n",
    "class Child(Parent): # define child class\n",
    "    def myMethod(self):\n",
    "        print('Calling child method')\n",
    "\n",
    "c = Child()          # instance of child\n",
    "c.myMethod()         # child calls overridden method"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1868ee3b",
   "metadata": {},
   "source": [
    "## Data Hiding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "907221b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'JustCounter' object has no attribute '__secretCount'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-48-4c10b3a36e61>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     14\u001b[0m \u001b[0mcounter\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     15\u001b[0m \u001b[0mcounter\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 16\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcounter\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__secretCount\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# We gonna ge an error for this line\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'JustCounter' object has no attribute '__secretCount'"
     ]
    }
   ],
   "source": [
    "# If you want an object's attributes to not be visible outside the class definition,\n",
    "# You need to name attributes with a double underscore prefix\n",
    "# Those attributes will not be directly visible to outsiders\n",
    "# Let's see an example\n",
    "\n",
    "class JustCounter:\n",
    "    __secretCount = 0 # Our secret attr\n",
    "  \n",
    "    def count(self):\n",
    "        self.__secretCount += 1\n",
    "        print(self.__secretCount)\n",
    "\n",
    "counter = JustCounter()\n",
    "counter.count()\n",
    "counter.count()\n",
    "print(counter.__secretCount) # We're gonna get an error for this line"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8dba3a34",
   "metadata": {},
   "source": [
    "----"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18a2515a",
   "metadata": {},
   "source": [
    "### This is it for now!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16cb53fb",
   "metadata": {},
   "source": [
    "I'm gonna end the file here. <br />\n",
    "If you need someone to ask for help, you can find me in [GitHub](https://github.com/alidaghighi) <br />\n",
    "or just use google it!<br />\n",
    "<br />\n",
    "<b> Happy coding! </b>"
   ]
  }
 ],
 "metadata": {
  "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}