01ex_solved.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1\\. Write the following as a list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3)]\n",
      "[0, 4, 16]\n"
     ]
    }
   ],
   "source": [
    "# 1\n",
    "ans = []\n",
    "for i in range(3):\n",
    "    for j in range(4):\n",
    "        ans.append((i, j))\n",
    "print (ans)\n",
    "\n",
    "# 2\n",
    "ans = map(lambda x: x*x, filter(lambda x: x%2 == 0, range(5)))\n",
    "print (list(ans))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3)]\n",
      "[0, 4, 16]\n"
     ]
    }
   ],
   "source": [
    "#1\n",
    "ans = [(x,y) for x in range(3) for y in range(4)]\n",
    "print(ans)\n",
    "#2\n",
    "ans = [x*x for x in range(5) if x%2==0]\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2\\. Convert the following function into a pure function with no global variables or side effects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 0, 1, 2, 3, 4]\n",
      "[1, 2, 3, 0, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "def f(alist):\n",
    "    for i in range(x):\n",
    "         alist.append(i)\n",
    "    return alist\n",
    "\n",
    "alist = [1,2,3]\n",
    "ans = f(alist)\n",
    "print (ans)\n",
    "print (alist) # alist has been changed!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 0, 1, 2, 3, 4]\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "def f(alist,x):\n",
    "    ans = []\n",
    "    ans += alist\n",
    "    for i in range(x):\n",
    "        ans.append(i)\n",
    "    return ans\n",
    "\n",
    "alist = [1,2,3]\n",
    "x = 5\n",
    "ans = f(alist,x)\n",
    "print(ans)\n",
    "print(alist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3\\. Write a `decorator` hello that makes every wrapped function print “Hello!”, i.e. something like:\n",
    "\n",
    "```python\n",
    "@hello\n",
    "def square(x):\n",
    "    return x*x\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "def hello(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        print('Hello!')\n",
    "        print(func(*args, **kwargs))\n",
    "    return wrapper\n",
    "\n",
    "@hello\n",
    "def square(x):\n",
    "    return x*x\n",
    "\n",
    "square(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4\\. Write the factorial function so that it a) does and b) does not use recursion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]\n"
     ]
    }
   ],
   "source": [
    "#with recursion\n",
    "\n",
    "def fact_rec(x):\n",
    "    if x == 0 or x == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return x*fact_rec(x-1)\n",
    "    \n",
    "print([fact_rec(i) for i in range(10)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]\n"
     ]
    }
   ],
   "source": [
    "#without recursion\n",
    "\n",
    "def fact_nrec(x):\n",
    "    a = 1\n",
    "    for l in range(1, x+1):\n",
    "        a *= l\n",
    "    return a\n",
    "    \n",
    "print([fact_nrec(i) for i in range(10)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5\\. Use HOFs (zip in particular) to compute the weight of a circle, a disk and a sphere, assuming different radii and different densities:\n",
    "\n",
    "```python\n",
    "densities = {\"Al\":[0.5,1,2],\"Fe\":[3,4,5],\"Pb\": [15,20,30]}\n",
    "radii = [1,2,3]\n",
    "```\n",
    "\n",
    "where the entries of the dictionary's values are the linear, superficial and volumetric densities of the materials respectively.\n",
    "\n",
    "In particular define a list of three lambda functions using a comprehension that computes the circumference, the area and the volume for a given radius.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[18.84955592153876, 12.566370614359172, 20.943951023931955]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import pi\n",
    "densities = {\"Al\":[0.5,1,2],\"Fe\":[3,4,5],\"Pb\": [15,20,30]}\n",
    "radii = [1,2,3]\n",
    "\n",
    "weight = [lambda x, ld: ld*x*2*pi, lambda x, ad: ad*pi*x*x, lambda x, vd: vd*4/3*pi*x*x*x]\n",
    "\n",
    "[func(radii[0], d) for func, d in zip(weight, densities['Fe'])]\n",
    "            \n",
    "        \n",
    "\n",
    "\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6\\. Edit the class defintion to add an instance attribute of is_hungry = True to the Dog class. Then add a method called eat() which changes the value of is_hungry to False when called. Figure out the best way to feed each dog and then output “My dogs are hungry.” if all are hungry or “My dogs are not hungry.” if all are not hungry. The final output should look like this:\n",
    "\n",
    "`I have 3 dogs. \n",
    "Tom is 6. \n",
    "Fletcher is 7. \n",
    "Larry is 9. \n",
    "And they're all mammals, of course. \n",
    "My dogs are not hungry.\n",
    "`\n",
    "\n",
    "```python\n",
    "# Parent class\n",
    "class Dog:\n",
    "\n",
    "    # Class attribute\n",
    "    species = 'mammal'\n",
    "\n",
    "    # Initializer / Instance attributes\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    # instance method\n",
    "    def description(self):\n",
    "        return \"{} is {} years old\".format(self.name, self.age)\n",
    "\n",
    "    # instance method\n",
    "    def speak(self, sound):\n",
    "        return \"{} says {}\".format(self.name, sound)\n",
    "\n",
    "# Child class (inherits from Dog class)\n",
    "class RussellTerrier(Dog):\n",
    "    def run(self, speed):\n",
    "        return \"{} runs {}\".format(self.name, speed)\n",
    "\n",
    "# Child class (inherits from Dog class)\n",
    "class Bulldog(Dog):\n",
    "    def run(self, speed):\n",
    "        return \"{} runs {}\".format(self.name, speed)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parent class\n",
    "class Dog:\n",
    "\n",
    "    # Class attribute\n",
    "    species = 'mammal'\n",
    "\n",
    "    # Initializer / Instance attributes\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.is_hungry = True\n",
    "\n",
    "    # instance method\n",
    "    def description(self):\n",
    "        return \"{} is {} years old\".format(self.name, self.age)\n",
    "\n",
    "    # instance method\n",
    "    def speak(self, sound):\n",
    "        return \"{} says {}\".format(self.name, sound)\n",
    "    \n",
    "    def eat(self):\n",
    "        self.is_hungry = False\n",
    "    \n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I have 3 dogs.\n",
      "Tom is 6.\n",
      "Fletcher is 7.\n",
      "Larry is 9.\n",
      "And they are all mammals, of course.\n",
      "My dogs are not hungry.\n"
     ]
    }
   ],
   "source": [
    "dogs = [Dog('Tom', 6), Dog('Fletcher', 7), Dog('Larry', 9)]\n",
    "\n",
    "print('I have', len(dogs), 'dogs.')\n",
    "for i in dogs:\n",
    "    print(i.name, 'is', str(i.age) + '.')\n",
    "    i.eat()\n",
    "\n",
    "if i.species == 'mammal':\n",
    "    print('And they are all mammals, of course.')\n",
    "    \n",
    "hunger = False\n",
    "for i in dogs:\n",
    "    if i.is_hungry == True:\n",
    "        hunger = True\n",
    "\n",
    "if hunger == True:\n",
    "    print('My dogs are hungry.')\n",
    "else:\n",
    "    print('My dogs are not hungry.')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}