Acrobatic_gymnastics.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "source": [
        " # This cell to remove every varialbe \n",
        "import sys   \n",
        "sys.modules[__name__].__dict__.clear()\n",
        "print(dir())"
      ],
      "metadata": {
        "id": "DbIh55yKTrML"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NksalGhO6WiK"
      },
      "source": [
        "# Modules"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "q42ySIY56U01"
      },
      "outputs": [],
      "source": [
        "from datetime import date\n",
        "import random\n",
        "import string"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Parameters"
      ],
      "metadata": {
        "id": "nCZTQRvNlEXR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "List_Unit = [\"W2\", \"W3\", \"M2\", \"M4\", \"MX\"]\n",
        "List_Category = [\"11_16\", \"12_18\", \"J\", \"S\"]"
      ],
      "metadata": {
        "id": "y0J6GgQJk6Yq"
      },
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "byYZFfwf6eQd"
      },
      "source": [
        "# Athletes\n",
        "Each athlete is characterised by a first and last name, a gender, a date of birth and a nationality"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "b-3C7z_k6766"
      },
      "outputs": [],
      "source": [
        "class Athlete:\n",
        "    def __init__(self, fi, la, gen, bir ,natio):\n",
        "        self.__first  = str(fi).title()    # Double leading underscore: interpreter replaces this name with '_Athlete__first'\n",
        "        self.__last = str(la).title()\n",
        "        self.gender = gen\n",
        "        self.__birth = bir            \n",
        "        self.__age = self.agef() \n",
        "        self.nationality = str(natio).title()\n",
        "        self.speci = self.__class__.__name__.lower()\n",
        "    \n",
        "    def agef(self):\n",
        "        today = date.today()\n",
        "        assert self.__birth < today,f'date of birth should be less than today {today}. '\n",
        "        age = today.year - self.__birth.year - ((today.month, today.day) < (self.__birth.month, self.__birth.day))\n",
        "        return age  \n",
        "    \n",
        "    def __str__(self):\n",
        "        return f'Name : {self.first}, Surname : {self.last}, \\nBirthday : {self.__birth} \\nGender : {self.gender} \\nNationality: {self.nationality}'\n",
        "    \n",
        "    #Athlete comparison based on the attribute .age \n",
        "    # Note that just a trivial-quick alternative to direct comparison like  (obj1.age < obj2.age)\n",
        "    def __lt__(self,other):   # less than\n",
        "        if isinstance(other, Athlete):\n",
        "            return self.age<other.age\n",
        "        return NotImplemented\n",
        "        \n",
        "    #Make objects hashable \n",
        "    # The hash codes are not allowed to change for an object, so, \n",
        "    # to prevent attributes from external accidental mutation, try to make them read-only. Do so: using @property.\n",
        "    # It is a kind of mask, which however can be violated.\n",
        "    @property\n",
        "    def birth(self):\n",
        "        return self.__birth\n",
        "    @property\n",
        "    def age(self):\n",
        "        return self.__age\n",
        "    @property\n",
        "    def first(self):\n",
        "        return self.__first\n",
        "    @property\n",
        "    def last(self):\n",
        "        return self.__last                \n",
        "        \n",
        "    def __eq__(self, other):\n",
        "        if isinstance(other, Athlete):\n",
        "            return self.age == other.age  \n",
        "        return NotImplemented\n",
        "\n",
        "    def __hash__(self): \n",
        "        return hash((self.age,self.first,self.last))      # better than: \"return hash(self.age)\" Reason: See test below  \"st = {k_copy,k_similar,k,k2}\"  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y4a46pSIBoHR"
      },
      "source": [
        "# Team\n",
        "\n",
        "There are five possible teams compositions:\n",
        "\n",
        "- Women's pair (W2): a team composed of two female athletes\n",
        "- Women's group (W3): a team composed of three female athletes\n",
        "- Men's pair (M2): a team composed of two male athletes\n",
        "- Men's group (M4): a team composed of four male athletes\n",
        "- Mixed pair (MX): a team composed of a male and a female athletes\n",
        "\n",
        "\n",
        "Each team competes in a single specific category:\n",
        "\n",
        "- Age-group 11-16 (11-16): all the team members must be at least 11 years old and at most 16\n",
        "- Age-group 12-18 (12-18): all the team members must be at least 12 years old and at most 18\n",
        "- Junior (J): all the team members must be at least 13 years old and at most 19\n",
        "- Senior (S): all the team members must be at least 15 years old, without an upper bound"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "01SkybXJBwIw"
      },
      "outputs": [],
      "source": [
        "class Team:\n",
        "\n",
        "   def __init__(self, CAT = None, UNI = None, *args):\n",
        "      self.li_a = []            # list of athletes in Team\n",
        "      self.number = 0           # total number of athletes\n",
        "      self.category = str(CAT)\n",
        "      self.unit = str(UNI)\n",
        "      self.id = ''.join(random.choice(string.ascii_letters) for i in range(5))  # id code\n",
        "      self.name =   self.category + \" \" + self.unit + \" \" + self.id             # Team name    \n",
        "\n",
        "      # Built a Team\n",
        "      for i in args:\n",
        "        self.li_a.append(i)\n",
        "        self.number = self.number + 1\n",
        "\n",
        "\n",
        "   def __str__(self) :\n",
        "        if self.name[:5] == \"None\":\n",
        "           return f'The data entered does not make up a valid Team'\n",
        "        else:\n",
        "           return f'Team : {self.name} \\nTot athletes: {self.number}'\n",
        "\n",
        "\n",
        "   #Building Iterator  \n",
        "   def __iter__(self):       \n",
        "         self.x = 0                       # initialization\n",
        "         return self                   \n",
        "\n",
        "   def __next__(self): \n",
        "         if self.x < len(self.li_a):\n",
        "             result = self.li_a[self.x]\n",
        "             self.x  = self.x + 1\n",
        "             return result                # return the next item in the sequence\n",
        "         else:\n",
        "             raise StopIteration          #  when it reachs the end\n",
        "   \n",
        "\n",
        "   @classmethod                           # generate multiple Team-objects within the same class\n",
        "   def _multiple(cls, CAT, UNI, l):\n",
        "        return [Team(CAT, UNI) for i in range(l)]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u3VUagno9Hao"
      },
      "source": [
        "# Rankings\n",
        "\n",
        "\n",
        "Rankings are split by category and team composition, e.g., a Junior MX team competes against only other Junior MX teams. Each team in the competition is assigned a unique identifier.\n",
        "\n",
        "\n",
        "Given the previous information, there could be up to 20 different rankings to be considered."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Rankings:   \n",
        "   \n",
        "   def __init__(self, CAT = None, UNI = None, *args):\n",
        "      self.li_t = []        # list of  Team\n",
        "      self.num_t = 0        # total number of Team in ranking\n",
        "      self.category = str(CAT)\n",
        "      self.unit = str(UNI)\n",
        "      self.name_t =   self.category + \" \" + self.unit + \" \" +  str(date.today().year) # Ranking name \n",
        "\n",
        "       # Built\n",
        "      for i in args:\n",
        "        self.li_t.append(i)\n",
        "        self.num_t = self.num_t + 1\n",
        "        i.scoring = 0       #  starting score of a certain team. Note : once team are in the ranking they have a scoring attribute\n",
        "\n",
        "   def __str__(self):\n",
        "         return f'\\\\ Rankings : {self.name_t} \\nTot Team: {self.num_t}'\n",
        "\n",
        "   def __len__(self):\n",
        "         return self.num_t\n",
        "\n",
        "   #Building Iterator  \n",
        "   def __iter__(self):       \n",
        "         self.x = 0                       # initialization\n",
        "         return self                   \n",
        "\n",
        "   def __next__(self): \n",
        "         if self.x < len(self.li_t):\n",
        "             result = self.li_t[self.x]\n",
        "             self.x  = self.x + 1\n",
        "             return result                # return the next item in the sequence\n",
        "         else:\n",
        "             raise StopIteration          #  when it reachs the end\n"
      ],
      "metadata": {
        "id": "-fNNlVEhc_CR"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Exercise  -- Approach Multiple Inheritance\n",
        "\n",
        "\n",
        "There are three types of exercises:\n",
        "\n",
        "- Balance (B): an exercise with a focus on strength, poise and flexibility\n",
        "- Dynamic (D): an exercise with a focus on throws, catches and tumbling elements\n",
        "- Combined (C): a combination of balance and dynamic elements\n",
        "\n",
        "Balance and dynamic exercises are performed in qualifiers whereas combined exercises are performed only during finals.\n",
        "\n"
      ],
      "metadata": {
        "id": "5VKACZZpNIQ0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Approach Multiple inheritance\n",
        "\n",
        "class Exercise:\n",
        "   def __init__(self, NE, *args,**kwargs):    \n",
        "     self.name_ex = NE                       # exercise name\n",
        "     super().__init__(*args, **kwargs)  \n",
        "\n",
        "\n",
        "class Balance(Exercise):\n",
        "   def __init__(self, NE, stre = 0.1, po = 0.2, fle = 0.3, *args,**kwargs):     # float 0.1 , 0.2., 0.3  I figured they are the minimum difficulty levels for the respective feature\n",
        "     self.strength = float(stre)   # level of difficulty a priori for strength :  a value between 0.00 and 3.00    \n",
        "     self.poise =  float(po)       # level of difficulty a priori for poise\n",
        "     self.flexibility =float(fle)  # level of difficulty a priori for flexibility\n",
        "     self.final = False            # whether or not it runs in the final\n",
        "     super().__init__(NE, *args,**kwargs)\n",
        "\n",
        "   def __str__(self):\n",
        "        return f'Exercise name : {self.name_ex} \\nType of exercise : {self.__class__.__name__}'\n",
        "\n",
        "\n",
        "class Dynamic(Exercise):\n",
        "   def __init__(self, NE, thro = 0.11 , cat = 0.22, tum = 0.33, *args,**kwargs):\n",
        "     self.throws = float(thro)           # level of difficulty a priori for throws :  a value between 0.00 and 3.00    \n",
        "     self.catches =  float(cat)          # level of difficulty a priori for catches\n",
        "     self.tumbling_elements =float(tum)  # level of difficulty a priori for tumbling elements\n",
        "     self.final = False            # whether or not it runs in the final\n",
        "     super().__init__(NE, *args,**kwargs)\n",
        "\n",
        "   def __str__(self):\n",
        "        return f'Exercise name : {self.name_ex} \\nType of exercise : {self.__class__.__name__}'\n",
        "     \n",
        "class Combined(Dynamic,Balance): \n",
        "      def __init__(self, NE, stre = 0 , po = 0  , fle = 0  , thro = 0 , cat = 0 , tum = 0 , *args,**kwargs ):\n",
        "         super().__init__(NE, thro , cat , tum, stre, po , fle, *args,**kwargs)\n",
        "         self.final = True\n",
        "    \n",
        "\n",
        "#Test 1  Multiple inheritance\n",
        "# class test1(Dynamic): \n",
        "#       def __init__(self, NE, thro , cat , tum  , *args, **kwargs ):\n",
        "#          super().__init__(NE, thro , cat , tum, *args,**kwargs)\n",
        "#          self.final = True\n"
      ],
      "metadata": {
        "id": "DxoOIAuwNJEc"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Competition setup\n",
        "\n",
        "The competition is organised in a qualifier round and a final round. All the teams partake in the qualifiers, but only a few are allowed to compete in the finals. For the sake of simplicity, assume that only the first top-8 teams for each category/composition are allowed to move on."
      ],
      "metadata": {
        "id": "h5cZTOK-QGqi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Match:\n",
        "   def __init__(self, t_A=None, t_B=None, s=(0,0)):\n",
        "     self.team_A = t_A\n",
        "     self.team_B = t_B\n",
        "     self.score = s\n",
        "\n",
        "   def __str__(self):\n",
        "      return(f'{self.team_A.id} {self.team_B.id} {self.score}')\n",
        "\n",
        "   def result(self):\n",
        "      self.score = (random.randint(0, 10),random.randint(0, 10))\n",
        "      if self.score[0] > self.score[1]:\n",
        "         return self.team_A\n",
        "      elif self.score[0] < self.score[1]:\n",
        "         return self.team_B\n",
        "      else:\n",
        "         return (random.choice([self.team_A,self.team_B]))  \n",
        "\n",
        "\n",
        "def Qualifiers(R):                               #Practically:   in : tthe top 8 Team in rankings ; out: one Team winner\n",
        "     final1 = Match( (Match(R.li_t[0],R.li_t[7])).result(), (Match(R.li_t[1],R.li_t[6]).result()) ).result()\n",
        "     final2 = Match( (Match(R.li_t[2],R.li_t[5])).result(), (Match(R.li_t[3],R.li_t[4]).result()) ).result()\n",
        "\n",
        "     winner = Match(final1, final2).result()    # This is the final match\n",
        "\n",
        "     return winner"
      ],
      "metadata": {
        "id": "HtICGumyQL8F"
      },
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Code testing"
      ],
      "metadata": {
        "id": "HhzPHhdPh70I"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xqm-jgm_-ejO",
        "outputId": "76d733f2-83e7-464f-ddbe-c0d2f06355d7"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "***Testing class codes Athlete, Team, Rankings\n",
            "\n",
            "Name : Aldo, Surname : Ielpo, \n",
            "Birthday : 2011-03-10 \n",
            "Gender : M \n",
            "Nationality: Ita\n",
            "{'_Athlete__first': 'Aldo', '_Athlete__last': 'Ielpo', 'gender': 'M', '_Athlete__birth': datetime.date(2011, 3, 10), '_Athlete__age': 12, 'nationality': 'Ita', 'speci': 'athlete'}\n",
            "['_Athlete__age', '_Athlete__birth', '_Athlete__first', '_Athlete__last', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'agef', 'birth', 'first', 'gender', 'last', 'nationality', 'speci']\n",
            "True\n",
            "AGE :  12\n",
            "BIRTH :  2011-03-10\n",
            "BIRTH :  2011-03-10\n",
            "**Objects comparable\n",
            "True\n",
            "True\n",
            "False\n",
            "True\n",
            "**Objects hashable\n",
            "3573423092939226284\n",
            "3573423092939226284\n",
            "-192299527290732160\n",
            "-1009371881009322356\n",
            "Set :  {<__main__.Athlete object at 0x7f78dbaa20d0>, <__main__.Athlete object at 0x7f78dbaa2100>, <__main__.Athlete object at 0x7f78dbaa2d60>}\n",
            "\n",
            "\n",
            "***Testing class codes Team\n",
            "\n",
            "Name : Aldo, Surname : Ielpo, \n",
            "Birthday : 2011-03-10 \n",
            "Gender : M \n",
            "Nationality: Ita\n",
            "Name : Jose, Surname : Morata, \n",
            "Birthday : 2010-01-05 \n",
            "Gender : M \n",
            "Nationality: Spa\n",
            "\n",
            "\n",
            "Team : M2 11_16 bJqjb \n",
            "Tot athletes: 2\n",
            "\n",
            "\n",
            "***Testing class codes Rankings\n",
            "\n",
            "Team : M2 11_16 CBQzw \n",
            "Tot athletes: 0\n",
            "\n",
            " \\ Rankings : M2 11_16 2023 \n",
            "Tot Team: 10\n",
            "10\n",
            "Team : M2 11_16 PaIEN \n",
            "Tot athletes: 0\n",
            "Current scoring :  0 \n",
            "\n",
            "Team : M2 11_16 dBIws \n",
            "Tot athletes: 0\n",
            "Current scoring :  0 \n",
            "\n",
            "Team : M2 11_16 lRxCu \n",
            "Tot athletes: 0\n",
            "Current scoring :  0 \n",
            "\n",
            "Team : M2 11_16 lRWeK \n",
            "Tot athletes: 0\n",
            "Current scoring :  0 \n",
            "\n",
            "Team : M2 11_16 JLwDH \n",
            "Tot athletes: 0\n",
            "Current scoring :  0 \n",
            "\n",
            "Team : M2 11_16 mQZks \n",
            "Tot athletes: 0\n",
            "Current scoring :  0 \n",
            "\n",
            "Team : M2 11_16 EtnTa \n",
            "Tot athletes: 0\n",
            "Current scoring :  0 \n",
            "\n",
            "Team : M2 11_16 bJqjb \n",
            "Tot athletes: 2\n",
            "Current scoring :  0 \n",
            "\n",
            "Team : M2 11_16 CBQzw \n",
            "Tot athletes: 0\n",
            "Current scoring :  0 \n",
            "\n",
            "Team : M2 11_16 vTYQq \n",
            "Tot athletes: 0\n",
            "Current scoring :  0 \n",
            "\n"
          ]
        }
      ],
      "source": [
        "\n",
        "print(\"***Testing class codes Athlete, Team, Rankings\\n\")\n",
        "k = Athlete(\"Aldo\", \"Ielpo\", \"M\", date(2011, 3, 10) ,\"ITA\")\n",
        "print(k)\n",
        "print(k.__dict__)\n",
        "print(dir(k))\n",
        "print(isinstance(k, Athlete))\n",
        "print(\"AGE : \" , k.age)       #Read Only Properties\n",
        "print(\"BIRTH : \", k.birth)    #Read Only Properties\n",
        "print(\"BIRTH : \", k._Athlete__birth)   # Can change with this\n",
        "\n",
        "\n",
        "print(\"**Objects comparable\")\n",
        "k2 = Athlete(\"Jose\", \"Morata\", \"M\", date(2010, 1, 5) ,\"SPA\")\n",
        "k_copy = Athlete(\"Aldo\", \"Ielpo\", \"M\", date(2011, 3, 10) ,\"ITA\")\n",
        "k_similar = Athlete(\"Pino\", \"Renzulli\", \"M\", date(2011, 3, 10) ,\"ITA\")\n",
        "print(k == k_copy)\n",
        "print(k == k_similar)\n",
        "print(k == k2)\n",
        "print(k < k2)\n",
        "\n",
        "print(\"**Objects hashable\")\n",
        "print(hash(k_copy))\n",
        "print(hash(k))\n",
        "print(hash(k_similar))\n",
        "print(hash(k2))\n",
        "st = {k_copy,k_similar,k,k2}\n",
        "print(\"Set : \", st)\n",
        "\n",
        "\n",
        "print(\"\\n\")\n",
        "\n",
        "print(\"***Testing class codes Team\\n\")\n",
        "u = Team(List_Unit[2],List_Category[0],k,k2)\n",
        "\n",
        "[print(i) for i in u]\n",
        "# Practical alternative to use of iterator\n",
        "# for i in u.li_a:\n",
        "#   print(i)\n",
        "\n",
        "print(\"\\n\")\n",
        "print(u)\n",
        "\n",
        "print(\"\\n\")\n",
        "print(\"***Testing class codes Rankings\\n\")\n",
        "\n",
        "l_t = []\n",
        "for i in range(7):\n",
        "  l_t.append(Team(List_Unit[2],List_Category[0]))\n",
        "l_t.append(u)\n",
        "\n",
        "kl = Team._multiple(List_Unit[2],List_Category[0],2)  \n",
        "print(kl[0])\n",
        "l_t = l_t + kl\n",
        "\n",
        "rk1 = Rankings(List_Unit[2],List_Category[0],*l_t)\n",
        "\n",
        "print(\"\\n\",rk1)\n",
        "print(len(rk1))\n",
        "for z in rk1:\n",
        "  print(z)\n",
        "  print(\"Current scoring : \", z.scoring,\"\\n\")      \n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Testing class Match\\n\")\n",
        "# rt = Match(rk1.li_t[0],rk1.li_t[7])\n",
        "# print(rt.result().id)\n",
        "# print(rt.score)\n",
        "fg = Match(rk1.li_t[0],rk1.li_t[7]).result().id\n",
        "print(fg)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HectApkBUzZl",
        "outputId": "0dab194f-271b-4c2d-b6b1-9bb7b0675351"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Testing class Match\n",
            "\n",
            "bJqjb\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Testing class Qualifiers\\n\")\n",
        "wi = Qualifiers(rk1)\n",
        "print(wi,\"\\n\")\n",
        "print(\"The Winner is :\",wi.id)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JDAOosyBXKGd",
        "outputId": "d03dbac4-539b-422f-cbc1-463b6757409c"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Testing class Qualifiers\n",
            "\n",
            "Team : M2 11_16 mQZks \n",
            "Tot athletes: 0 \n",
            "\n",
            "The Winner is : mQZks\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Testing class codes Exercise - Approach Multiple inheritance \\n\")\n",
        "\n",
        "ex1 = Dynamic(\"Pike\", 2.7)\n",
        "print(ex1)\n",
        "print(ex1.throws)\n",
        "print(ex1.catches)\n",
        "print(ex1.tumbling_elements)\n",
        "\n",
        "print(\"   \")\n",
        "\n",
        "\n",
        "ex2 = Combined(\"Butterfly\",stre=1.1, fle=1.8, tum=2.2, po=1.5)\n",
        "print(Combined.__mro__)\n",
        "print(ex2)\n",
        "print(dir(ex2))\n",
        "print(\"\")\n",
        "print(\"In final : \", ex2.final)\n",
        "print(\"Dynamic features\")\n",
        "print(ex2.throws)\n",
        "print(ex2.catches)\n",
        "print(ex2.tumbling_elements)\n",
        "print(\"Balance features\")\n",
        "print(ex2.strength)\n",
        "print(ex2.poise)\n",
        "print(ex2.flexibility)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mrFPvY98mq8n",
        "outputId": "875d396a-9ebc-4e93-a34d-a77c6a61d6fc"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Testing class codes Exercise - Approach Multiple inheritance \n",
            "\n",
            "Exercise name : Pike \n",
            "Type of exercise : Dynamic\n",
            "2.7\n",
            "0.22\n",
            "0.33\n",
            "   \n",
            "(<class '__main__.Combined'>, <class '__main__.Dynamic'>, <class '__main__.Balance'>, <class '__main__.Exercise'>, <class 'object'>)\n",
            "Exercise name : Butterfly \n",
            "Type of exercise : Combined\n",
            "['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'catches', 'final', 'flexibility', 'name_ex', 'poise', 'strength', 'throws', 'tumbling_elements']\n",
            "\n",
            "In final :  True\n",
            "Dynamic features\n",
            "0.0\n",
            "0.0\n",
            "2.2\n",
            "Balance features\n",
            "1.1\n",
            "1.5\n",
            "1.8\n"
          ]
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}