Refresh_python1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/AhmedKaramDev/Python-machineLearning-course/blob/master/Refresh_python.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DesGhoHlMV2S"
   },
   "source": [
    "# python for Data Sci"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "-perWb5cMV2U",
    "outputId": "6d7eab2a-a5f5-48fb-9446-997e690deb86"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "0\n",
      "25\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "# python and all programming languages can do basic math (add, subtratct , multiply, division)\n",
    "print(5+5)\n",
    "print(5-5)\n",
    "print(5*5)\n",
    "print(5/5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "sFlf2FmVMV2b"
   },
   "source": [
    "in python there are additional operators power`**` and modulo `%`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "w-6xxLOhMV2c",
    "outputId": "6c0bdffa-a79d-4a2b-e148-e5740af068f0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "125\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "print(5**3) # means 5*5*5\n",
    "print(11%2) # means the reminder of the divison"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Hm7NsF1gMV2h"
   },
   "source": [
    "## Example:\n",
    "Suppose you have $100, which you can invest with a 10%\n",
    "return each year. After one year, it's 100×1.1=110 dollars,\n",
    "and after two years it's 100×1.1×1.1=121."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "napb1BVoMV2i"
   },
   "outputs": [],
   "source": [
    "#TODO: Add code to calculate how much money you end up with after 7 years."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "swz1d_-tMV2k"
   },
   "source": [
    "## variables \n",
    "* case sensitive\n",
    "* no start with numbers\n",
    "* no symbols just _  \n",
    "\n",
    "## Types \n",
    "there are commoan types in python (int, float, string, bool ,list, set, dictioninary)\n",
    "to know the type write `type(varible name)` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "u9tgiJt1MV2l"
   },
   "outputs": [],
   "source": [
    "# Create a variable savings with the value 100.\n",
    "# Check out this variable by typing print(savings) in the script.\n",
    "# Check out this variable type by typing print(type(savings)) in the script."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "rpjS6jOTMV2o"
   },
   "source": [
    "###  we saw int and float values now lets another data types \n",
    "**TODO:** Create a new string, desc, with the value \"pyhton Course\".  \n",
    "\n",
    "**TODO:** Create a new boolean, profitable, with the value True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "G9fpbVtkMV2p"
   },
   "source": [
    "String vlaues must be between tow double or single quotes Ex: \"Hello\" or 'Hi'. You can merge between strings with + operator.\n",
    "\n",
    "boolean values can be `True` or `False` first capital letter is important also can be 0 or 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "CBToLHArMV2q",
    "outputId": "85912b5a-cf04-4107-d1e0-a4cc7285964f"
   },
   "outputs": [],
   "source": [
    "savings = 100\n",
    "result = 100 * 1.10 ** 7\n",
    "\n",
    "# Fix the printout\n",
    "print(\"I started with $\" + savings + \" and now have $\" + result + \". Awesome!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "NnI0yf7yMV2u"
   },
   "source": [
    "## we can convert between some python types\n",
    "we can convert string value contains numbers to int or float but we can't convert letters to float or int\n",
    "we can convert between int and float but in convert int to float the numbers after the fraction point removed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "K7DJZc3wMV2v"
   },
   "outputs": [],
   "source": [
    "# Definition of pi_string\n",
    "pi_string = \"3.1415926\"\n",
    "\n",
    "# TODO: Convert pi_string into float: pi_float and then print the type of it\n",
    "pi_float ="
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fQepKzEqMV2y"
   },
   "source": [
    "## all these types store single values and our probelm in data scinece have many datapoint and it's hard to store each value in variable so we're using list to hold many values in one variable\n",
    "\n",
    "**List features**\n",
    "* name a collection of values \n",
    "* contain any type\n",
    "* Contain different type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 0,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "pD0FuGlSMV2z"
   },
   "outputs": [],
   "source": [
    "fam = [\"lyla\",1.65,\"Naser\",1.70,\"mom\",1.67,\"dad\",1.89]\n",
    "fam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# You can access the list by its index the index start from 0 to (length of list-1)\n",
    "# so fam[0] will print \"lyla\" and fam[7] will print 1.89\n",
    "print(fam[0])\n",
    "print(fam[7])\n",
    "#TODO: print the second element from the fam list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# also you can go backword by using minus sign for eaxmple fam[-1] will print the last element\n",
    "\n",
    "#TODO: print \"mom\" from the list using backward index\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### list slicing :  list[ start : end ]\n",
    "\n",
    "**Start inclusive ---------     end exclusive**\n",
    "\n",
    "for example if we want to get the name \"Naser\" and his tall from our `fam` varibale we will insert the index of \"Naser\" which is 2 and the index of his tall+1 which is 4 so it will be `fam[2:4]`  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TODO: print \"dad\" and his tall from fam list using list slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "areas = [\"hallway\", 11.25, \"kitchen\", 18.0, \"living room\", 20.0, \"bedroom\", 10.75, \"bathroom\", 9.50]\n",
    "\n",
    "#TODO: Use slicing to create a list, downstairs, that contains the first 6 elements of areas.\n",
    "# TODO: Do a similar thing to create a new variable, upstairs, that contains the last 4 elements of areas.\n",
    "# TODO: Print both downstairs and upstairs using print()."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you don't specify the `start` index, Python figures out that you want to start your slice at the beginning of your list. If you don't specify the `end` index, the slice will go all the way to the last element of your list\n",
    "\n",
    "**Try this in the cell below**\n",
    "\n",
    "x = [\"a\", \"b\", \"c\", \"d\"]\n",
    "\n",
    "x[:2]\n",
    "\n",
    "x[2:]\n",
    "\n",
    "x[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import packges\n",
    "In python we can import packges that profiessinal developers made them and make our code life easier in data sci there are many comman packages we use such as `numpy`, `pandas`, `matplotlib`, `scikit learn` and there are more packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## import numpy and using it \n",
    "to import package we to type import then packcage name and we can give it local name for shortcut and the comman local name for numpy is np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: import numpy package as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can convert normal list to array using `np.array()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores = [20,40,60,70,30,50]\n",
    "# TODO: convert scores list to array and assign the value to np_scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Array vs List\n",
    "the main diffrence between them \n",
    "\n",
    "**Array**: can apply math opreations on it like +,*,/,-\n",
    "\n",
    "**List** if you used + operator it means merage the values not add them\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "scores_1 = [20,40]\n",
    "score_2 = [60,80]\n",
    "#TODO: add scores_1 with scores_2 and print the output\n",
    "\n",
    "# TODO: convert scores_1 and scores_2 to array and add them then print the output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### there are similar features between the array and list like indexing and slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "players = np.array([\"ahmed\",\"Yasser\",\"Naser\",\"Fahad\",\"Ali\",\"Youssef\",\"Anas\",\"Jameel\"])\n",
    "#TODO: print Ali from the players array\n",
    "#TODO: assign the first 4 players to red_team and the last 4 players to blue_team"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Create a 1D array of numbers from 0 to 9 with arange() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#TODO: Create a 3×3 numpy array of all True’s with boolean type using full function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# you can but condition inside the index brackets to print all values that condation is true\n",
    "#TODO:  extract items that satisfy a given condition from 1D array element is even\n",
    "arr = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# TODO: Convert a 1D array to a 2D array with 2 rows using reshape function\n",
    "arr = np.arange(10)\n",
    "#hint: Setting cols to -1 automatically decides the number of cols"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## for more numpy exercises visit the [website](https://www.machinelearningplus.com/python/101-numpy-exercises-python/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Now it's the time of condition \n",
    "In python you can logic operators like bigger than `>`, less than`<`, equal`==` and not equal `!=`\n",
    "these operators returns boolean value `True` or `False` it basiclly if the condition is True do something if something else to another things"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wrong answer\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# Examples \n",
    "v1 = 5\n",
    "v2 = 10\n",
    "if v1>v2:\n",
    "    print(\"Correct Answer\")\n",
    "    print(v1>v2)\n",
    "else:\n",
    "    print(\"Wrong answer\")\n",
    "    print(v1>v2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It can be more than one if statments and it can be nested"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 is the largest number\n"
     ]
    }
   ],
   "source": [
    "a = 2\n",
    "b = 4\n",
    "c = 6\n",
    "\n",
    "if a > b:\n",
    "    if a> c: # if statment inside if statment\n",
    "        print(str(a)+\" is the largest number\")\n",
    "elif b > c: # elif used when you create multiple if statments \n",
    "    print(str(b)+\" is the largest number\")\n",
    "else:\n",
    "    print(str(c)+\" is the largest number\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It was a quick intro to the if statments and now what if you want to repeat an instruction few times should you write down the instruction five times or 1000 times it's very hard so we can use **for loop** to repeat the instructions and to read data from continers like lists or arrays "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola\n",
      "Hola\n",
      "Hola\n",
      "Hola\n",
      "Hola\n"
     ]
    }
   ],
   "source": [
    "#Example of foor loop\n",
    "for i in range(5): # it means give the variable i value in range 5 * range(5) means 0,1,2,3,4 = repeat 5 times\n",
    "    print(\"Hola\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ahmed\n",
      "Mohamed\n",
      "Omar\n",
      "Waleed\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# you can read elements from list also\n",
    "friends = [\"Ahmed\", \"Mohamed\",\"Omar\",\"Waleed\"]\n",
    "for i in friends: # means for variable i in the list friends \n",
    "    print(i) \n",
    "# you can also add iterate by range\n",
    "for i in range(len(friends)): # len to get the length of the list (how many times you want to iterate)\n",
    "    print(i)\n",
    "# It's same in some points and not same in some else"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We write code to make functions and write functions to make classes\n",
    "\n",
    "The function is like a continaer to your code have specific name and do specific task let us see some example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "def add(a,b): # def here means define function with name (add) takes tow values\n",
    "    print(a+b) #here print the value of a+b\n",
    "# see the function weill not print and value and wont work if we don't called it now let's called the function\n",
    "add(6,6)\n",
    "#TODO: add sub, multiple, divide functions and print them out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ahmed\n"
     ]
    }
   ],
   "source": [
    "fName = \"Ahmed\"\n",
    "def print_value(x):\n",
    "    print(x)\n",
    "    \n",
    "# we can pass variable with not same name of the argument value\n",
    "print_value(fName)\n",
    "# argument variable effects only inside the function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "include_colab_link": true,
   "name": "Refresh python.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}