19_comprehension_single_if.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comprehension & Single-if-line-statement\n",
    "    \n",
    "   1. [Single line if statement](#Single_line_if_statement)\n",
    "   2. [List comprehension](#List_comprehension)\n",
    "   3. [Dictionary comprehensiont](#Dictionary_comprehension)\n",
    "   4. [Set comprehensiont](#Set_comprehension)\n",
    "   5. [tuple comprehension?](#Don't_we_have_a_tuple_comprehension?)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"Single_line_if_statement\" ></a>\n",
    "## Single line if statement\n",
    "    The process of assigining variables or filtering can be done with single line if statement!\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# recommended\n",
    "# structure \n",
    "# variable_name = if-output if-condition else else-out\n",
    "val_1 = 10\n",
    "val_2 = 20 if val_1 == 1 else 10\n",
    "print(val_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# not recommended!\n",
    "val_1 = 10\n",
    "if val_1 == 1:\n",
    "    val_2 = 20\n",
    "else:\n",
    "    val_2 = 10\n",
    "print(val_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# if elif else\n",
    "# not recommended! Code comprehension is lost\n",
    "x = 1 \n",
    "y = 2 \n",
    "output = '=' if x == y else '<' if x < y else '>'\n",
    "output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# not recommended: more than one condition\n",
    "val = 12\n",
    "val_2 = 'val is bigger than 10 ' if val > 10 else 'val is 10' if val == 10 else 'val is lower than 10'\n",
    "print(val_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"Why_do_we_use_comprehension?\" ></a>\n",
    "## List Comprehension\n",
    "    1. Comprehensions are a concise and an expressive way to write a data transformation and filtering\n",
    "    2. They are quick to write, easy to parse, and surprisingly fast.\n",
    "    3. List comprehension offers a shorter syntax when you want to create a new list based on the values of an existing list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"loop_in_list_comprehension\" ></a>\n",
    "### loop in  list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# data transformation\n",
    "squares = []\n",
    "for i in range(10):\n",
    "    squares.append(i**2)\n",
    "squares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The numbers one to nine are raised to the power of two and put into a list:\n",
    "# variable_name = [output for-loop]\n",
    "squares = [i**2 for i in range(10)]\n",
    "\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Test speed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "348 ms ± 14.6 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "v = []\n",
    "for i in range(1000000):\n",
    "    v.append(i**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "309 ms ± 5.66 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "v = [i**2 for i in range(1000000)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 9, 36, 81]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# filtering\n",
    "# The numbers one to nine are raised to the power of tree and put into a list:\n",
    "# this works for only single line ifs with no else statements\n",
    "# variable_name = [output for-loop condition]\n",
    "squares_3 = [i**2 for i in range(10) if i % 3 == 0]\n",
    "squares_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 9, 36, 81]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares_3 = []\n",
    "for i in range(10):\n",
    "    if i % 3 == 0:\n",
    "        squares_3.append(i**2)\n",
    "squares_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['pooya',\n",
       " 'pooya',\n",
       " 1728,\n",
       " 'pooya',\n",
       " 'pooya',\n",
       " 3375,\n",
       " 'pooya',\n",
       " 'pooya',\n",
       " 5832,\n",
       " 'pooya',\n",
       " 'pooya',\n",
       " 9261,\n",
       " 'pooya',\n",
       " 'pooya',\n",
       " 13824,\n",
       " 'pooya',\n",
       " 'pooya',\n",
       " 19683,\n",
       " 'pooya',\n",
       " 'pooya']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# transformation -> condition (if-else statement)\n",
    "# use if and else statenemts and for in list comprehension:\n",
    "squares_3 = [i**3 if i % 3 == 0 else \"pooya\" for i in range(10, 30)]\n",
    "squares_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[(1, 1), (2, 1), (3, 1), (4, 1), (5, 1), (6, 1), (7, 1)],\n",
       " [(1, 2), (2, 2), (3, 2), (4, 2), (5, 2), (6, 2), (7, 2)],\n",
       " [(1, 3), (2, 3), (3, 3), (4, 3), (5, 3), (6, 3), (7, 3)]]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# nested list comprehension\n",
    "# recommend\n",
    "nes_list = [[(k2, k1) for k2 in range(1, 8)] for k1 in range(1, 4)]\n",
    "nes_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 1),\n",
       " (1, 2),\n",
       " (1, 3),\n",
       " (2, 1),\n",
       " (2, 2),\n",
       " (2, 3),\n",
       " (3, 1),\n",
       " (3, 2),\n",
       " (3, 3),\n",
       " (4, 1),\n",
       " (4, 2),\n",
       " (4, 3),\n",
       " (5, 1),\n",
       " (5, 2),\n",
       " (5, 3),\n",
       " (6, 1),\n",
       " (6, 2),\n",
       " (6, 3),\n",
       " (7, 1),\n",
       " (7, 2),\n",
       " (7, 3)]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# not recommend, unless you are an expert!\n",
    "# Note: the most inner for is representative of the fist for\n",
    "nes_list = [(k1, k2) for k1 in range(1, 8) for k2 in range(1, 4)]\n",
    "nes_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# recommended!\n",
    "nes_list = []\n",
    "for k1 in range(1, 8):\n",
    "    for k2 in range(1, 4):\n",
    "        nes_list.append((k1, k2))\n",
    "nes_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"Dictionary_comprehension\" ></a>\n",
    "## 2. Dictionary Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 0,\n",
       " 3: 9,\n",
       " 6: 36,\n",
       " 9: 81,\n",
       " 12: 144,\n",
       " 15: 225,\n",
       " 18: 324,\n",
       " 21: 441,\n",
       " 24: 576,\n",
       " 27: 729}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares_dict = {i: i**2 for i in range(30) if i % 3 == 0}\n",
    "squares_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# zip\n",
    "keys = ['a', 'b', 'c', 'd', 'e']\n",
    "values = [1, 2, 3, 4, 5]  \n",
    "   \n",
    "{k:v for (k, v) in zip(keys, values)} "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e'}"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# enumerate\n",
    "values = ['a', 'b', 'c', 'd', 'e']\n",
    "{en:v for en, v in enumerate(values)} "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'P': 'ppp', 'O': 'ooo', 'Y': 'yyy', 'A': 'aaa'}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# any kind of transformation is possible\n",
    "dict_ = {x.upper(): x*3 for x in 'pooya'}\n",
    "dict_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'fereshteh': 'young', 'reza': 'old', 'pooya': 'young', 'ali': 'old', 'zahra': 'young'}\n"
     ]
    }
   ],
   "source": [
    "age_dict = {'fereshteh': 20, 'reza': 65, 'pooya': 28, 'ali': 57, 'zahra': 33}\n",
    "\n",
    "age_dict = {k: 'old' if v > 40 else 'young' for (k, v) in age_dict.items()}\n",
    "print(age_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"nested_dictionary\" ></a>\n",
    "### Nested dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: {1: 1, 2: 2, 3: 3, 4: 4, 5: 5},\n",
       " 2: {1: 2, 2: 4, 3: 6, 4: 8, 5: 10},\n",
       " 3: {1: 3, 2: 6, 3: 9, 4: 12, 5: 15},\n",
       " 4: {1: 4, 2: 8, 3: 12, 4: 16, 5: 20}}"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# recommended\n",
    "nes_dict = {k1: {k2: k1 * k2 for k2 in range(1, 6)} for k1 in range(1, 5)}\n",
    "nes_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 1: create a new dictionary like capitals which the keys and values are replaced(using comprehensions)\n",
    "\n",
    "capitals = {'Iran': 'Tehran','France': 'Paris','Italy': 'Rome'}\n",
    "output = {\"Tehran\": \"Iran\", ...}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "capitals = {'Iran': 'Tehran','France': 'Paris','Italy': 'Rome'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Tehran': 'Iran', 'Paris': 'France', 'Rome': 'Italy'}"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# answer\n",
    "reverse_capitals = {value : key for key, value in capitals.items()}\n",
    "reverse_capitals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"Set_comprehension\" ></a>\n",
    "## 3. Set Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 4}\n",
      "[2, 4, 2, 2, 4]\n"
     ]
    }
   ],
   "source": [
    "# Comparison list Comprehension and set Comprehension\n",
    "set_ = {i for i in [1, 2, 4, 3, 3, 2, 2, 4] if i % 2==0}\n",
    "list_ = [i for i in [1, 2, 4, 3, 3, 2, 2, 4] if i % 2==0]\n",
    "print(set_)\n",
    "print(list_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id = \"Don't_we_have_a_tuple_comprehension?\" ></a>\n",
    "## How about tuple comprehensions?\n",
    "    Python does not support tuple comprehension!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x000001F994A7D2A0>"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple_ = (i for i in \"fereshteh\")\n",
    "tuple_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('f', 'e', 'r', 'e', 's', 'h', 't', 'e', 'h')"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# create a list comprehension and convert it to tuple!\n",
    "tuple_ = tuple([i for i in \"fereshteh\"])\n",
    "tuple_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*_:-)_*"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}