01ex_Fundamentals.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, 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",
      "[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",
    "ans = [(x,y) for x in range(0, 3) for y in range(0, 4)]\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",
    "ans = [x*x for x in range(0, 5) if x%2 == 0]\n",
    "print(ans)\n"
   ]
  },
  {
   "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": 2,
   "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",
      "[1, 2, 3, 0, 1, 2, 3, 4]\n",
      "[1, 2, 3]\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!\n",
    "\n",
    "\n",
    "def g(l):\n",
    "    b = [x for x in range(5)]\n",
    "    return l + b\n",
    "\n",
    "a = [1,2,3]\n",
    "an = g(a)\n",
    "print (an)\n",
    "print (a)"
   ]
  },
  {
   "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": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Higher Order Function\n",
    "#def hello(func):\n",
    "#    def wrapper():\n",
    "#        print(\"Hello!\")\n",
    "#        a = input(\"A number: \")\n",
    "#        a = float(a)\n",
    "#        func(a)\n",
    "#        print(\"Square: \", func(a))\n",
    "#    return wrapper\n",
    "\n",
    "#def square(x):\n",
    "#    return x*x\n",
    "\n",
    "#square = hello(square)     \n",
    "#square()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello!\n",
      "A number: 4\n",
      "Square:  16.0\n"
     ]
    }
   ],
   "source": [
    "#Same but using decorators\n",
    "def hello(func):\n",
    "    def wrapper():\n",
    "        print(\"Hello!\")\n",
    "        a = input(\"A number: \")\n",
    "        a = float(a)\n",
    "        func(a)\n",
    "        print(\"Square: \", func(a))\n",
    "    return wrapper\n",
    "\n",
    "@hello\n",
    "def square(x):\n",
    "    return x*x\n",
    "square()"
   ]
  },
  {
   "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": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]\n",
      "[1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880]\n"
     ]
    }
   ],
   "source": [
    "#Factorial function using recursion\n",
    "def faca(n):\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return n*faca(n-1)\n",
    "\n",
    "print([faca(i) for i in range(10)])\n",
    "\n",
    "#Factorial function not using recursion\n",
    "def facb(n):\n",
    "    if n == 0 or n == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        a, b = 1, 1\n",
    "        for i in range(1, n+1):\n",
    "            a, b = a*b, b+1\n",
    "        return a\n",
    "    \n",
    "print([facb(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": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Al 1 3.141592653589793\n",
      "Al 1 3.141592653589793\n",
      "Al 1 8.377580409572781\n",
      "Al 2 6.283185307179586\n",
      "Al 2 12.566370614359172\n",
      "Al 2 67.02064327658225\n",
      "Al 3 9.42477796076938\n",
      "Al 3 28.274333882308138\n",
      "Al 3 226.1946710584651\n",
      "Fe 1 18.84955592153876\n",
      "Fe 1 12.566370614359172\n",
      "Fe 1 20.94395102393195\n",
      "Fe 2 37.69911184307752\n",
      "Fe 2 50.26548245743669\n",
      "Fe 2 167.5516081914556\n",
      "Fe 3 56.548667764616276\n",
      "Fe 3 113.09733552923255\n",
      "Fe 3 565.4866776461628\n",
      "Pb 1 94.24777960769379\n",
      "Pb 1 62.83185307179586\n",
      "Pb 1 125.66370614359171\n",
      "Pb 2 188.49555921538757\n",
      "Pb 2 251.32741228718345\n",
      "Pb 2 1005.3096491487337\n",
      "Pb 3 282.7433388230814\n",
      "Pb 3 565.4866776461628\n",
      "Pb 3 3392.9200658769764\n"
     ]
    }
   ],
   "source": [
    "import math as m\n",
    "densities = {\"Al\":[0.5,1,2],\"Fe\":[3,4,5],\"Pb\": [15,20,30]}\n",
    "radii = [1,2,3]\n",
    "\n",
    "nvol = list(map(lambda x: [2*m.pi*x, m.pi*x*x, (4/3)*m.pi*x*x*x], iter(radii)))\n",
    "#print(nvol)\n",
    "\n",
    "for i in densities:\n",
    "    element = i\n",
    "    for j in range(len(nvol)):\n",
    "        if j == 0:\n",
    "            radius = 1\n",
    "        elif j == 1:\n",
    "            radius = 2\n",
    "        elif j == 2:\n",
    "            radius = 3\n",
    "        for d, nV in zip(densities[i], nvol[j]):\n",
    "            print (element, radius, d*nV)\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": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I have 3 dogs.\n",
      "Tom is 6 years old\n",
      "Fletcher is 7 years old\n",
      "Larry is 9 years old\n",
      "They are all mammals\n",
      "My dogs are hungry\n",
      "Tom is eating\n",
      "Fletcher is eating\n",
      "Larry is eating\n",
      "My dogs are not hungry\n"
     ]
    }
   ],
   "source": [
    "# Parent class\n",
    "class Dog:\n",
    "\n",
    "    # Class attribute\n",
    "    species = 'mammal'\n",
    "    number = 0\n",
    "\n",
    "    # Initializer / Instance attributes\n",
    "    def __init__(self, name, age, is_hungry):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.is_hungry = True\n",
    "        Dog.number += 1\n",
    "    \n",
    "    # instance method\n",
    "    def eat(self):\n",
    "        self.is_hungry = False\n",
    "        return \"{} is eating\".format(self.name)\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",
    "    # instance method: verify if all dogs are hungry or not\n",
    "    def __eq__(self, other):\n",
    "        if isinstance(other, Dog):\n",
    "            if self.is_hungry == other.is_hungry == False:\n",
    "                return False\n",
    "            else:\n",
    "                return True\n",
    "\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",
    "    \n",
    "Tom = Dog(\"Tom\", 6, 1)\n",
    "Fletcher = RussellTerrier(\"Fletcher\", 7, 2)\n",
    "Larry = Bulldog(\"Larry\", 9, 3)\n",
    "    \n",
    "print(\"I have\", Dog.number, \"dogs.\")\n",
    "print(Tom.description())\n",
    "print(Fletcher.description())\n",
    "print(Larry.description())\n",
    "\n",
    "if Tom.species == \"mammal\" and Fletcher.species == \"mammal\" and Larry.species == \"mammal\":\n",
    "    print(\"They are all mammals\")\n",
    "    \n",
    "def hunger(var):   \n",
    "    if  var == True:\n",
    "        print(\"My dogs are hungry\")\n",
    "    elif var == False:\n",
    "        print(\"My dogs are not hungry\")\n",
    "\n",
    "when_true = Tom == Fletcher == Larry\n",
    "#print(when_true)\n",
    "hunger(when_true)\n",
    "\n",
    "print(Tom.eat())\n",
    "print(Fletcher.eat())\n",
    "print(Larry.eat())\n",
    "\n",
    "when_truee = Tom == Fletcher == Larry\n",
    "#print(when_truee)\n",
    "hunger(when_truee)"
   ]
  }
 ],
 "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
}