Python  Exercises 1 - Solutions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "\n",
    "<a href='https://www.virasec.ir/academy'> <img src='viraacademy-Logo.png' /></a>\n",
    "___\n",
    "# Python Basic Course Exercises "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n",
    "Answer the questions or complete the tasks outlined in bold below, use the specific method described if applicable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** What is 7 to the power of 4?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "7**4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Split this string:**\n",
    "\n",
    "    s = \"Hi there Darya!\"\n",
    "    \n",
    "**into a list. **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'Hi there Darya!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Hi', 'there', 'Darya!']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Given the variables:**\n",
    "\n",
    "    planet = \"Earth\"\n",
    "    diameter = 12742\n",
    "\n",
    "** Use .format() to print the following string: **\n",
    "\n",
    "    The diameter of Earth is 12742 kilometers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "planet = \"Earth\"\n",
    "diameter = 12742"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The diameter of Earth is 12742 kilometers.\n"
     ]
    }
   ],
   "source": [
    "print(\"The diameter of {} is {} kilometers.\".format(planet,diameter))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Given this nested list, use indexing to grab the word \"hello\" **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [1,2,[3,4],[5,[100,200,['hello']],23,11],1,7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst[3][1][2][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** What is the main difference between a tuple and a list? **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tuple is immutable"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Given a Python list you should be able to display Python list in the following order\n",
    "aLsit = [100, 200, 300, 400, 500]\n",
    "[500, 400, 300, 200, 100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[500, 400, 300, 200, 100]\n"
     ]
    }
   ],
   "source": [
    "aList = [100, 200, 300, 400, 500]\n",
    "aList = aList[::-1]\n",
    "print(aList)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Concatenate two lists index-wise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [\"M\", \"na\", \"i\", \"Re\"] \n",
    "list2 = [\"y\", \"me\", \"s\", \"za\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['My', 'name', 'is', 'Reza']\n"
     ]
    }
   ],
   "source": [
    "# We need to use list comprehension and zip() function as follows\n",
    "\n",
    "list1 = [\"M\", \"na\", \"i\", \"Re\"] \n",
    "list2 = [\"y\", \"me\", \"s\", \"za\"]\n",
    "list3 = [i + j for i, j in zip(list1, list2)]\n",
    "print(list3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My\n",
      "name\n",
      "is\n",
      "Reza\n"
     ]
    }
   ],
   "source": [
    "#Use For loop\n",
    "\n",
    "for i, j in zip(list1, list2):\n",
    "    print(i+j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Reza "
     ]
    }
   ],
   "source": [
    "#Use For loop\n",
    "\n",
    "for i, j in zip(list1, list2):\n",
    "    print(i+j , end = ' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given a Python list. Turn every item of a list into its square"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "aList = [1, 2, 3, 4, 5, 6, 7]\n",
    "Answer:\n",
    "[1, 4, 9, 16, 25, 36, 49]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25, 36, 49]\n"
     ]
    }
   ],
   "source": [
    "aList = [1, 2, 3, 4, 5, 6, 7]\n",
    "aList =  [x * x for x in aList]\n",
    "print(aList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Concatenate two lists in the following order"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "list1 = [\"Hello \", \"take \"]\n",
    "list2 = [\"Dear\", \"Sir\"]\n",
    "#Expected output:\n",
    "\n",
    "['Hello Dear', 'Hello Sir', 'take Dear', 'take Sir']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello Dear', 'Hello Sir', 'take Dear', 'take Sir']\n"
     ]
    }
   ],
   "source": [
    "list1 = [\"Hello \", \"take \"]\n",
    "list2 = [\"Dear\", \"Sir\"]\n",
    "\n",
    "resList = [x+y for x in list1 for y in list2]\n",
    "print(resList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given a two Python list. Iterate both lists simultaneously such that list1 should display item in original order and list2 in reverse order"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "list1 = [10, 20, 30, 40]\n",
    "list2 = [100, 200, 300, 400]\n",
    "#Expected output:\n",
    "\n",
    "10 400\n",
    "20 300\n",
    "30 200\n",
    "40 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 400\n",
      "20 300\n",
      "30 200\n",
      "40 100\n"
     ]
    }
   ],
   "source": [
    "#We need to use the zip() function here.\n",
    "\n",
    "list1 = [10, 20, 30, 40]\n",
    "list2 = [100, 200, 300, 400]\n",
    "\n",
    "for x, y in zip(list1, list2[::-1]):\n",
    "    print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add item 7000 after 6000 in the following Python List"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "list1 = [10, 20, [300, 400, [5000, 6000], 500], 30, 40]\n",
    "#Expected output:\n",
    "\n",
    "[10, 20, [300, 400, [5000, 6000, 7000], 500], 30, 40]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, [300, 400, [5000, 6000, 7000], 500], 30, 40]\n"
     ]
    }
   ],
   "source": [
    "list1 = [10, 20, [300, 400, [5000, 6000], 500], 30, 40]\n",
    "list1[2][2].append(7000)\n",
    "print(list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given a Python list, find value 20 in the list, and if it is present, replace it with 200. Only update the first occurrence of a value"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "list1 = [5, 10, 15, 20, 25, 50, 20]\n",
    "#Expected output:\n",
    "\n",
    "list1 = [5, 10, 15, 200, 25, 50, 20]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 10, 15, 200, 25, 50, 20]\n"
     ]
    }
   ],
   "source": [
    "list1 = [5, 10, 15, 20, 25, 50, 20]\n",
    "\n",
    "index = list1.index(20)\n",
    "list1[index] = 200\n",
    "print(list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below are the two lists convert it into the dictionary"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "keys = ['Ten', 'Twenty', 'Thirty']\n",
    "values = [10, 20, 30]\n",
    "#Expected output:\n",
    "\n",
    "{'Ten': 10, 'Twenty': 20, 'Thirty': 30}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Ten': 10, 'Twenty': 20, 'Thirty': 30}\n"
     ]
    }
   ],
   "source": [
    "keys = ['Ten', 'Twenty', 'Thirty']\n",
    "values = [10, 20, 30]\n",
    "\n",
    "sampleDict = dict(zip(keys, values))\n",
    "print(sampleDict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Merge following two Python dictionaries into one"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "dict1 = {'Ten': 10, 'Twenty': 20, 'Thirty': 30}\n",
    "dict2 = {'Thirty': 30, 'Fourty': 40, 'Fifty': 50}\n",
    "#Expected output:\n",
    "\n",
    "{'Ten': 10, 'Twenty': 20, 'Thirty': 30, 'Fourty': 40, 'Fifty': 50}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Ten': 10, 'Twenty': 20, 'Thirty': 30, 'Fourty': 40, 'Fifty': 50}\n"
     ]
    }
   ],
   "source": [
    "# Python 3.5+\n",
    "\n",
    "dict1 = {'Ten': 10, 'Twenty': 20, 'Thirty': 30}\n",
    "dict2 = {'Thirty': 30, 'Fourty': 40, 'Fifty': 50}\n",
    "\n",
    "dict3 = {**dict1, **dict2}\n",
    "print(dict3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Ten': 10, 'Twenty': 20, 'Thirty': 30, 'Fourty': 40, 'Fifty': 50}\n"
     ]
    }
   ],
   "source": [
    "dict1 = {'Ten': 10, 'Twenty': 20, 'Thirty': 30}\n",
    "dict2 = {'Thirty': 30, 'Fourty': 40, 'Fifty': 50}\n",
    "\n",
    "dict3 = dict1.copy()\n",
    "dict3.update(dict2)\n",
    "print(dict3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Access the value of key ‘history’"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "sampleDict = { \n",
    "   \"class\":{ \n",
    "      \"student\":{ \n",
    "         \"name\":\"Mike\",\n",
    "         \"marks\":{ \n",
    "            \"physics\":70,\n",
    "            \"history\":80\n",
    "         }\n",
    "      }\n",
    "   }\n",
    "}"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "#Expected output:\n",
    "\n",
    "80"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "80\n"
     ]
    }
   ],
   "source": [
    "print(sampleDict['class']['student']['marks']['history'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given a Python dictionary, Change Brad’s salary to 8500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "sampleDict = {\n",
    "     'emp1': {'name': 'Jhon', 'salary': 7500},\n",
    "     'emp2': {'name': 'Emma', 'salary': 8000},\n",
    "     'emp3': {'name': 'Brad', 'salary': 6500}\n",
    "}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'emp1': {'name': 'Jhon', 'salary': 7500}, 'emp2': {'name': 'Emma', 'salary': 8000}, 'emp3': {'name': 'Brad', 'salary': 8500}}\n"
     ]
    }
   ],
   "source": [
    "sampleDict['emp3']['salary'] = 8500\n",
    "print(sampleDict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Given an input string, count occurrences of all characters within a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A': 1, 'p': 2, 'l': 1, 'e': 1}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Given:\n",
    "\n",
    "str1 = \"Apple\"\n",
    "\n",
    "#Expected Outcome:\n",
    "\n",
    "{'A': 1, 'p': 2, 'l': 1, 'e': 1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'A': 1, 'p': 2, 'l': 1, 'e': 1}\n"
     ]
    }
   ],
   "source": [
    "str1 = \"Apple\"\n",
    "countDict = dict()\n",
    "for char in str1:\n",
    "    count = str1.count(char)\n",
    "    countDict[char]=count\n",
    "print(countDict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reverse a given string"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "#Given:\n",
    "\n",
    "str1 = \"Welcome\"\n",
    "\n",
    "#Expected Output:\n",
    "\n",
    "emocleW"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original String is: Welcome\n",
      "Reversed String is: emocleW\n"
     ]
    }
   ],
   "source": [
    "str1 = \"Welcome\"\n",
    "print(\"Original String is:\", str1)\n",
    "\n",
    "str1 = str1[::-1]\n",
    "print(\"Reversed String is:\", str1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find the last position of a substring “Emma” in a given string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "str1 = \"Darya is a data scientist who knows Python. Darya works at google.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original String is: Darya is a data scientist who knows Python. Darya works at google.\n",
      "Last occurrence of Darya starts at 44\n"
     ]
    }
   ],
   "source": [
    "str1 = \"Darya is a data scientist who knows Python. Darya works at google.\"\n",
    "print(\"Original String is:\", str1)\n",
    "\n",
    "index = str1.rfind(\"Darya\")\n",
    "print(\"Last occurrence of Darya starts at\", index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Split a given string on hyphens into several substrings and display each substring"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "#Given:\n",
    "str1 = \"Darya-is-a-data-scientist\"\n",
    "\n",
    "#Expected Output:\n",
    "\n",
    "#Displaying each substring\n",
    "\n",
    "Darya\n",
    "is\n",
    "a\n",
    "data\n",
    "scientist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original String is: Darya-is-a-data-scientist\n",
      "Displaying each substring\n",
      "Darya\n",
      "is\n",
      "a\n",
      "data\n",
      "scientist\n"
     ]
    }
   ],
   "source": [
    "str1 = \"Darya-is-a-data-scientist\"\n",
    "print(\"Original String is:\", str1)\n",
    "\n",
    "# split string\n",
    "substrings = str1.split(\"-\")\n",
    "\n",
    "print(\"Displaying each substring\")\n",
    "for sub in substrings:\n",
    "    print(sub)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remove empty strings from a list of strings\n"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "#Given:\n",
    "\n",
    "str_list = [\"Darya\", \"Ali\", \"\", \"Negar\", None, \"Azadeh\", \"\"]\n",
    "\n",
    "#Expected Output:\n",
    "\n",
    "#Original list of sting\n",
    "[\"Darya\", \"Ali\", \"\", \"Negar\", None, \"Azadeh\", \"\"]\n",
    "\n",
    "#After removing empty strings\n",
    "['Darya', 'Ali', 'Negar', 'Azadeh']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original list of sting\n",
      "['Darya', 'Ali', '', 'Negar', None, 'Azadeh', '']\n",
      "After removing empty strings\n",
      "['Darya', 'Ali', 'Negar', 'Azadeh']\n"
     ]
    }
   ],
   "source": [
    "str_list = [\"Darya\", \"Ali\", \"\", \"Negar\", None, \"Azadeh\", \"\"]\n",
    "print(\"Original list of sting\")\n",
    "print(str_list)\n",
    "\n",
    "# use built-in function filter to filter empty value\n",
    "new_str_list = list(filter(None, str_list))\n",
    "\n",
    "print(\"After removing empty strings\")\n",
    "print(new_str_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remove special symbols/Punctuation from a given string"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "#Given:\n",
    "\n",
    "str1 = \"/*Ali is @developer & musician\"\n",
    "#Expected Output:\n",
    "\n",
    "“Ali is developer musician”"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original string is:  /*Ali is @developer & musician\n",
      "New string is:  Ali is developer  musician\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "\n",
    "str1 = \"/*Ali is @developer & musician\"\n",
    "print(\"Original string is: \", str1)\n",
    "\n",
    "# use translate function of a string\n",
    "# and maketrans function of str class\n",
    "new_str = str1.translate(str.maketrans('', '', string.punctuation))\n",
    "\n",
    "print(\"New string is: \", new_str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Removal all the characters other than integers (numbers) from string"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "#Given:\n",
    "\n",
    "I am 25 years and 10 months old\n",
    "\n",
    "#Expected Output:\n",
    "\n",
    "2510"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original string is I am 25 years and 10 months old\n",
      "2510\n"
     ]
    }
   ],
   "source": [
    "str1 = 'I am 25 years and 10 months old'\n",
    "print(\"Original string is\", str1)\n",
    "numbers=''\n",
    "for i in str1:\n",
    "    if i.isdigit():\n",
    "        numbers += i\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original string is I am 25 years and 10 months old\n",
      "2510\n"
     ]
    }
   ],
   "source": [
    "str1 = 'I am 25 years and 10 months old'\n",
    "print(\"Original string is\", str1)\n",
    "\n",
    "# Retain Numbers in String\n",
    "# Using list comprehension + join() + isdigit()\n",
    "res = \"\".join([item for item in str1 if item.isdigit()])\n",
    "\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A*B*C\n"
     ]
    }
   ],
   "source": [
    "a=(\"A\",\"B\",\"C\")\n",
    "b='*'.join(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "From given string replace each punctuation with #\n",
    "Given:\n",
    "\n",
    "str1 = '/*Negar is @developer & musician!!'\n",
    "Expected Output:\n",
    "\n",
    "##Negar is #developer # musician##"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original string is :  /*Negar is @developer & musician!!\n",
      "The strings after replacement :  ##Negar is #developer # musician##\n"
     ]
    }
   ],
   "source": [
    "from string import punctuation\n",
    "\n",
    "str1 = '/*Negar is @developer & musician!!'\n",
    "print(\"The original string is : \", str1)\n",
    "\n",
    "# Replace punctuations with #\n",
    "replace_char = '#'\n",
    "\n",
    "# Using string.punctuation to get the list of all punctuations\n",
    "# use string function replace() to replace each punctuation with #\n",
    "\n",
    "for char in punctuation:\n",
    "    str1 = str1.replace(char, replace_char)\n",
    "\n",
    "print(\"The strings after replacement : \", str1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print First 10 natural numbers using while loop\n",
    "Expected output:\n",
    "\n",
    "0\n",
    "1\n",
    "2\n",
    "3\n",
    "4\n",
    "5\n",
    "6\n",
    "7\n",
    "8\n",
    "9\n",
    "10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i <= 10:\n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Print the following pattern\n",
    "1 \n",
    "1 2 \n",
    "1 2 3 \n",
    "1 2 3 4 \n",
    "1 2 3 4 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Second Number Pattern \n",
      "1 \n",
      "1 2 \n",
      "1 2 3 \n",
      "1 2 3 4 \n",
      "1 2 3 4 5 \n"
     ]
    }
   ],
   "source": [
    "print(\"Second Number Pattern \")\n",
    "lastNumber = 6\n",
    "for row in range(1, lastNumber):\n",
    "    for column in range(1, row + 1):\n",
    "        print(column, end=' ')\n",
    "    print(\"\")"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Accept number from user and calculate the sum of all number between 1 and given number\n",
    "\n",
    "For example user given 10 so the output should be 55"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter number 66\n",
      "\n",
      "\n",
      "Sum is:  2211\n"
     ]
    }
   ],
   "source": [
    "sum1 = 0\n",
    "n = int(input(\"Please enter number \"))\n",
    "for i in range(1, n + 1, 1):\n",
    "    sum1 += i\n",
    "print(\"\\n\")\n",
    "print(\"Sum is: \", sum1)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Print multiplication table of given number\n",
    "For example num = 2 so the output should be\n",
    "2\n",
    "4\n",
    "6\n",
    "8\n",
    "10\n",
    "12\n",
    "14\n",
    "16\n",
    "18\n",
    "20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 2\n",
    "for i in range(1, 11, 1):\n",
    "    product = n*i\n",
    "    print(product)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Given a list iterate it and display numbers which are divisible by 5 and if you find number greater than 150 stop the loop iteration\n",
    "list1 = [12, 15, 32, 42, 55, 75, 122, 132, 150, 180, 200]\n",
    "\n",
    "Expected output:\n",
    "\n",
    "15\n",
    "55\n",
    "75\n",
    "150"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [12, 15, 32, 42, 55, 75, 122, 132, 150, 180, 200]\n",
    "for item in list1:\n",
    "    if (item > 150):\n",
    "        break\n",
    "    if(item % 5 == 0):\n",
    "        print(item)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Given a number count the total number of digits in a number\n",
    "For example, the number is 75869, so the output should be 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = 75869\n",
    "count = 0\n",
    "while num != 0:\n",
    "    num //= 10\n",
    "    count+= 1\n",
    "print(\"Total digits are: \", count)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Print the following pattern using for loop\n",
    "5 4 3 2 1 \n",
    "4 3 2 1 \n",
    "3 2 1 \n",
    "2 1 \n",
    "1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 5\n",
    "k = 5\n",
    "for i in range(0,n+1):\n",
    "    for j in range(k-i,0,-1):\n",
    "        print(j,end=' ')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Reverse the following list using for loop\n",
    "list1 = [10, 20, 30, 40, 50]\n",
    "\n",
    "Expected output:\n",
    "\n",
    "50\n",
    "40\n",
    "30\n",
    "20\n",
    "10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [10, 20, 30, 40, 50]\n",
    "start = len(list1) - 1\n",
    "stop = -1\n",
    "step = -1\n",
    "for i in range(start, stop, step) :\n",
    "    print(list1[i])"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Display -10 to -1 using for loop\n",
    "Expected output:\n",
    "\n",
    "-10\n",
    "-9\n",
    "-8\n",
    "-7\n",
    "-6\n",
    "-5\n",
    "-4\n",
    "-3\n",
    "-2\n",
    "-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for num in range(-10, 0, 1):\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Display a message “Done” after successful execution of for loop\n",
    "For example, the following loop will execute without any error.\n",
    "\n",
    "for i in range(5):\n",
    "    print(i)\n",
    "So the Expected output should be:\n",
    "\n",
    "0\n",
    "1\n",
    "2\n",
    "3\n",
    "4\n",
    "Done!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print(i)\n",
    "else:\n",
    "    print(\"Done!\")"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Display Fibonacci series up to 10 terms\n",
    "Expected output:\n",
    "\n",
    "Fibonacci sequence:\n",
    "0  1  1  2  3  5  8  13  21  34"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "terms = 10\n",
    "# first two terms\n",
    "num1, num2 = 0, 1\n",
    "count = 0\n",
    "\n",
    "print(\"Fibonacci sequence:\")\n",
    "while count < terms:\n",
    "    print(num1, end=\"  \")\n",
    "    temp = num1 + num2\n",
    "    # update values\n",
    "    num1 = num2\n",
    "    num2 = temp\n",
    "    count += 1"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Write a loop to find the factorial of any number\n",
    "The factorial (symbol: !) means to multiply all whole numbers from our chosen number down to 1.\n",
    "\n",
    "For example: calculate the factorial of 5\n",
    "\n",
    "5! = 5 × 4 × 3 × 2 × 1 = 120\n",
    "Expected output:\n",
    "\n",
    "120"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = 5\n",
    "factorial = 1\n",
    "if num < 0:\n",
    "    print(\"Factorial does not exist for negative numbers\")\n",
    "elif num == 0:\n",
    "    print(\"The factorial of 0 is 1\")\n",
    "else:\n",
    "    for i in range(1, num + 1):\n",
    "        factorial = factorial * i\n",
    "    print(\"The factorial of\", num, \"is\", factorial)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Reverse a given integer number\n",
    "Given:\n",
    "\n",
    "76542\n",
    "\n",
    "Expected output:\n",
    "\n",
    "24567"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = 76542\n",
    "reverse_number = 0\n",
    "print(\"Given Number \", num)\n",
    "while num > 0:\n",
    "    reminder = num % 10\n",
    "    reverse_number = (reverse_number * 10) + reminder\n",
    "    num = num // 10\n",
    "print(\"Revered Number \", reverse_number)"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Use a loop to display elements from a given list which are present at even positions\n",
    "Given:\n",
    "\n",
    "my_list = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]\n",
    "\n",
    "Expected output:\n",
    "\n",
    "20 40 60 80 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]\n",
    "for i in my_list[1::2]:\n",
    "    print(i, end=\" \")"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "Print the following pattern\n",
    "* \n",
    "* * \n",
    "* * * \n",
    "* * * * \n",
    "* * * * * \n",
    "* * * * \n",
    "* * * \n",
    "* * \n",
    "*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rows = 5\n",
    "for i in range(0, rows):\n",
    "    for j in range(0, i + 1):\n",
    "        print(\"*\", end=' ')\n",
    "    print(\"\\r\")\n",
    "\n",
    "for i in range(rows, 0, -1):\n",
    "    for j in range(0, i - 1):\n",
    "        print(\"*\", end=' ')\n",
    "    print(\"\\r\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Good Luck\n",
    "Please email your file for me: mr.gerami@gmail.com or whatsapp +989125792641"
   ]
  }
 ],
 "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}