32_ClassDef.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0oHQECja2BSA",
        "outputId": "925029fc-97ea-4dcb-f017-3710561a6ac8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "##Python code from jpynb:\n",
            "![logo.jpg](data:image/jpeg;base64,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)\n",
            "# Programmation avancée - Lab 6 - Classes\n",
            "## Sylvain Lobry, 14/11/2022\n",
            "## Exercice 1 - Point2D\n",
            "### Exercice 1.1 - Simple point\n",
            "\n",
            "Define a class Point2D which contains two coordinates. You will define a method to have a human-readable print.\n",
            "\n",
            "*Example*\n",
            "```\n",
            ">> a = Point2D(1, 1)\n",
            ">> print(f\"a = {a}\")\n",
            "a = (1, 1)\n",
            "```\n",
            "### Exercice 1.2 - Adding a distance\n",
            "\n",
            "Re-define this class, adding a method to compute the L2 distance with another point.\n",
            "\n",
            "*Example*\n",
            "```\n",
            ">> a = Point2D(0, 0)\n",
            ">> b = Point2D(1, 1)\n",
            ">> print(\"Distance between \" + str(a) + \" and \" + str(b) + \": {:.2f}\".format(a.distanceL2(b)))\n",
            "Distance between (0, 0) and (1, 1): 1.41\n",
            "```\n",
            "### Exercice 1.3 - Counting the points\n",
            "\n",
            "Re-define this class, adding a method to count the number of points currently defined\n",
            "\n",
            "*Example*\n",
            "```\n",
            ">> print(Point2D.number_points)\n",
            "0\n",
            ">> p = Point2D(0, 0)\n",
            ">> print(Point2D.number_points)\n",
            "1\n",
            "```\n",
            "## Exercise 2 - International animals\n",
            "Write a class hierarchy of animals, implementing the classes Dog and Cat. Each class is initialized with a name and a nationality. The classes also implement the methods speak, which will return a string depending on the type of animal and its nationality (\"Meow\" for an american cat, \"Miaou\" for a french cat, \"Woof\" for an american dog, \"Waf\" for a french dog). Finally, their string representation should be the animal sound, followed by \". My name is NAME and I am a NATIONALIITY ANIMALTYPE.\"\n",
            "\n",
            "*Example*\n",
            "```\n",
            ">> animals = [Cat(\"Felix\", \"French\"), Cat(\"Garfield\", \"American\"), Dog(\"Belle\", \"French\"), Dog(\"Droopy\", \"American\")]\n",
            ">> for animal in animals:\n",
            ">>    print(animal)\n",
            "Miaou. My name is Felix and I am a French cat.\n",
            "Meow. My name is Garfield and I am a American cat.\n",
            "Waf. My name is Belle and I am a French dog.\n",
            "Woof. My name is Droopy and I am a American dog.\n",
            "```\n",
            "\n"
          ]
        }
      ],
      "source": [
        "import codecs\n",
        "import json\n",
        "\n",
        "f = codecs.open(\"/content/Lab_Python4.ipynb.txt\", 'r')\n",
        "source = f.read()\n",
        "\n",
        "y = json.loads(source)\n",
        "pySource = '##Python code from jpynb:\\n'\n",
        "for x in y['cells']:\n",
        "     for x2 in x['source']:\n",
        "         pySource = pySource + x2\n",
        "         if x2[-1] != '\\n':\n",
        "            pySource = pySource + '\\n'\n",
        "print(pySource)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Exercice 1 - Point2D\n",
        "### Exercice 1.1 - Simple point\n",
        "\n",
        "Define a class Point2D which contains two coordinates. You will define a method to have a human-readable print.\n",
        "\n",
        "*Example*\n",
        "```\n",
        ">> a = Point2D(1, 1)\n",
        ">> print(f\"a = {a}\")\n",
        "a = (1, 1)\n",
        "```"
      ],
      "metadata": {
        "id": "Kcn23whg2QBU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Point2D:\n",
        "  def __init__(self, x, y):\n",
        "    self.x = x\n",
        "    self.y = y\n",
        "\n",
        "  def __str__(self):\n",
        "    return f'({self.x}, {self.y})'\n",
        "\n",
        "point = Point2D(9, 4)\n",
        "print(point)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j0HsJQsY2RRj",
        "outputId": "f528607b-a730-4113-d988-45d7e9181198"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(9, 4)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Exercice 1.2 - Adding a distance\n",
        "\n",
        "Re-define this class, adding a method to compute the L2 distance with another point.\n",
        "\n",
        "*Example*\n",
        "```\n",
        ">> a = Point2D(0, 0)\n",
        ">> b = Point2D(1, 1)\n",
        ">> print(\"Distance between \" + str(a) + \" and \" + str(b) + \": {:.2f}\".format(a.distanceL2(b)))\n",
        "Distance between (0, 0) and (1, 1): 1.41"
      ],
      "metadata": {
        "id": "EwS-nF1L3Zeo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Point2D:\n",
        "  def __init__(self, x, y):\n",
        "    self.x = x\n",
        "    self.y = y\n",
        "\n",
        "  def __str__(self):\n",
        "    return f'({self.x}, {self.y})'\n",
        "\n",
        "  def distanceL2(self, other):\n",
        "    dx = self.x - other.x\n",
        "    dy = self.y - other.y\n",
        "    return (dx**2 + dy**2)**0.5\n",
        "\n",
        "a = Point2D(0, 0) \n",
        "b = Point2D(1, 1) \n",
        "\n",
        "print(\"Distance between \" + str(a) + \" and \" + str(b) + \": {:.2f}\".format(a.distanceL2(b))) "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Mgy260Um3bzH",
        "outputId": "8822aad3-a004-4bc4-bc4f-5693728de575"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Distance between (0, 0) and (1, 1): 1.41\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Exercice 1.3 - Counting the points\n",
        "\n",
        "Re-define this class, adding a method to count the number of points currently defined\n",
        "\n",
        "*Example*\n",
        "```\n",
        ">> print(Point2D.number_points)\n",
        "0\n",
        ">> p = Point2D(0, 0)\n",
        ">> print(Point2D.number_points)\n",
        "1\n",
        "```"
      ],
      "metadata": {
        "id": "U4xtBihWGfA0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Point2D:\n",
        "  count = 0\n",
        "\n",
        "  def __init__(self, x, y):\n",
        "    self.x = x\n",
        "    self.y = y\n",
        "    Point2D.count += 1\n",
        "\n",
        "  def __str__(self):\n",
        "    return f'({self.x}, {self.y})'\n",
        "\n",
        "  @classmethod\n",
        "  def number_points(cls):\n",
        "    return cls.count\n",
        "\n",
        "\n",
        "Point2D(0, 0)\n",
        "number_points = Point2D.number_points()\n",
        "print(number_points)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BNLFO2uBGgBW",
        "outputId": "91d62494-ee1f-420f-c997-317263472de5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Exercise 2 - International animals\n",
        "Write a class hierarchy of animals, implementing the classes Dog and Cat. Each class is initialized with a name and a nationality. The classes also implement the methods speak, which will return a string depending on the type of animal and its nationality (\"Meow\" for an american cat, \"Miaou\" for a french cat, \"Woof\" for an american dog, \"Waf\" for a french dog). Finally, their string representation should be the animal sound, followed by \". My name is NAME and I am a NATIONALIITY ANIMALTYPE.\"\n",
        "\n",
        "*Example*\n",
        "```\n",
        ">> animals = [Cat(\"Felix\", \"French\"), Cat(\"Garfield\", \"American\"), Dog(\"Belle\", \"French\"), Dog(\"Droopy\", \"American\")]\n",
        ">> for animal in animals:\n",
        ">>    print(animal)\n",
        "Miaou. My name is Felix and I am a French cat.\n",
        "Meow. My name is Garfield and I am a American cat.\n",
        "Waf. My name is Belle and I am a French dog.\n",
        "Woof. My name is Droopy and I am a American dog.\n",
        "```\n"
      ],
      "metadata": {
        "id": "4wg6qiLiJUGV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Animal:\n",
        "  def __init__(self, name, nationality):\n",
        "    self.name = name\n",
        "    self.nationality = nationality\n",
        "\n",
        "  def __str__(self):\n",
        "    return f\"{self.speak()}. My name is {self.name} and I am a {self.nationality} {self.__class__.__name__.lower()}.\"\n",
        "\n",
        "class Cat(Animal):\n",
        "  def speak(self):\n",
        "    if self.nationality == \"American\":\n",
        "      return \"Meow\"\n",
        "    elif self.nationality == \"French\":\n",
        "      return \"Miaou\"\n",
        "\n",
        "class Dog(Animal):\n",
        "  def speak(self):\n",
        "    if self.nationality == \"American\":\n",
        "      return \"Woof\"\n",
        "    elif self.nationality == \"French\":\n",
        "      return \"Waf\"\n",
        "\n",
        "animals = [Cat(\"Felix\", \"French\"), Cat(\"Garfield\", \"American\"), Dog(\"Belle\", \"French\"), Dog(\"Droopy\", \"American\")]\n",
        "for animal in animals:\n",
        "  print(animal)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-FSqUry8JU2g",
        "outputId": "f5c8fb48-e450-490e-c730-3967932bc4ca"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Miaou. My name is Felix and I am a French cat.\n",
            "Meow. My name is Garfield and I am a American cat.\n",
            "Waf. My name is Belle and I am a French dog.\n",
            "Woof. My name is Droopy and I am a American dog.\n"
          ]
        }
      ]
    }
  ]
}