OOP_HW_1.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Sinrez/pyCoursera/blob/master/OOP_HW_1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zRfv6UQLp1cb"
      },
      "source": [
        "# Задание 1.1\n",
        "\n",
        "1. Написать класс BoomBam, у которого есть метод Boom. При его вызове, как ни странно, печатается слово BOOM\n",
        "2. Доработать этот класс так, чтобы вызов метода чередовал слова BOOM и BAM.\n",
        "\n",
        "Плюс пример использования всего функционала класса с комментариями\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Yh3zdfAsp1cd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8d43f182-5b43-413a-c5f6-9b7caeba9e7f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "BOOM\n"
          ]
        }
      ],
      "source": [
        "class BoomBam:\n",
        "\n",
        "  def boom(self):\n",
        "    print('BOOM')\n",
        "  def bam(self):\n",
        "    print('BAM')\n",
        "  \n",
        "bbam = BoomBam()\n",
        "bbam.boom()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-b2k8xOtp1ce",
        "outputId": "1f1e31ca-031b-4a49-b43e-47b6bd1004c4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "BOOM\n",
            "BAM\n",
            "BOOM\n",
            "BAM\n",
            "BOOM\n",
            "BAM\n",
            "BOOM\n",
            "BAM\n",
            "BOOM\n",
            "BAM\n"
          ]
        }
      ],
      "source": [
        "class BoomBam:\n",
        "\n",
        "  def __init__(self):\n",
        "    self.sound = 'BOOM'\n",
        "  \n",
        "  def boom(self):\n",
        "      print(self.sound)\n",
        "      if self.sound == 'BOOM':\n",
        "        self.sound = 'BAM'\n",
        "      else:\n",
        "        self.sound = 'BOOM'\n",
        "\n",
        "bbam = BoomBam()\n",
        "for _ in range(10):\n",
        "  bbam.boom()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "my_XmcSFp1ce"
      },
      "source": [
        "# Задание 1.2\n",
        "\n",
        "\n",
        "Создайте класс RoundCircle. Методы:\n",
        "* add(x, y) -- добавление точки с координатами (x, y)\n",
        "* remove(x, y) -- удаление точки с координатами (x, y)\n",
        "* circle() -- печать координат центра и радиуса минимальной окружности, содержащей все эти точки\n",
        "* plot() -- создание изображения (графика), на котором нарисованы все точки и окружность\n",
        "\n",
        "Плюс пример использования всего функционала класса с комментариями"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "from random import randint\n",
        "from itertools import combinations"
      ],
      "metadata": {
        "id": "snVT7orJPrxa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class RoundCircle:\n",
        "    def __init__(self):\n",
        "        self.dots = []\n",
        "        self.all_circles = []\n",
        "\n",
        "    def add(self, x, y):\n",
        "        if (x,y) not in self.dots:\n",
        "            self.dots.append((x,y))\n",
        "\n",
        "    def random_dots(self, n = 10, range_x = (-10, 10), range_y = (-10, 10)):\n",
        "        for _ in range(n):\n",
        "            self.add(\n",
        "                randint(range_x[0], range_x[1]),\n",
        "                randint(range_y[0], range_y[1])\n",
        "            )\n",
        "\n",
        "    def remove(self, x, y):\n",
        "        try:\n",
        "            self.dots.remove((x,y))\n",
        "        except ValueError:\n",
        "            pass\n",
        "\n",
        "    def run(self):\n",
        "        try:\n",
        "            type(self.true_circles)\n",
        "        except AttributeError:\n",
        "            self.get_lines()\n",
        "            self.get_triangles()\n",
        "            self.dots_in_circle()\n",
        "\n",
        "# получаем все возможные отрезки между точками (dot1, dot2): = длинна отрезка\n",
        "# плюс данные о окружностях с центром на этих отрезках [x-окружности],[у-окружности],[радиус окружности]\n",
        "    def get_lines(self):\n",
        "        self.all_lines = dict()\n",
        "        for indx1, dot1 in enumerate(self.dots):\n",
        "            for indx2, dot2 in enumerate(self.dots[indx1 + 1:]):\n",
        "                xo = (dot1[0] + dot2[0])/2\n",
        "                yo = (dot1[1] + dot2[1])/2\n",
        "                d = np.sqrt(((dot2[0]-dot1[0])**2) + ((dot2[1]-dot1[1])**2))/2\n",
        "                self.all_lines[(indx1, indx2+indx1+1)] = d\n",
        "                self.all_circles.append((xo,yo,d))\n",
        "\n",
        "# получаем все возможные треугольники и окружности в которые они вписаны [x-окружности],[у-окружности],[радиус окружности]\n",
        "    def get_triangles(self):\n",
        "        self.all_triangles = [i for i in combinations(range(0, len(self.dots)), 3)]\n",
        "        for i in self.all_triangles:\n",
        "            a, b, c = combinations(i, 2)\n",
        "            a, b, c = self.all_lines[a], self.all_lines[b], self.all_lines[c]\n",
        "            ax,ay,bx,by,cx,cy = self.dots[i[0]][0],self.dots[i[0]][1],\\\n",
        "                                self.dots[i[1]][0],self.dots[i[1]][1],\\\n",
        "                                self.dots[i[2]][0],self.dots[i[2]][1]\n",
        "            p = (a+b+c)/2\n",
        "            if ((ax-cx)*(by-cy)-(bx-cx)*(ay-cy))*0.5 == 0:\n",
        "                continue\n",
        "            r = ((a*b*c)/(4*np.sqrt(abs(p*(p-a)*(p-b)*(p-c)))))*2\n",
        "            xo = ((ay*(bx**2+by**2-cx**2-cy**2)+by*(cx**2 +cy**2-ax**2-ay**2)+cy*(ax**2+ay**2-bx**2-by**2))/\n",
        "                  (ax*(by-cy)+bx*(cy-ay)+cx*(ay-by)))*(-0.5)\n",
        "            yo = ((ax*(bx**2+by**2-cx**2-cy**2)+bx*(cx**2 +cy**2-ax**2-ay**2)+cx*(ax**2+ay**2-bx**2-by**2))/\n",
        "                  (ax*(by-cy)+bx*(cy-ay)+cx*(ay-by)))*0.5\n",
        "            self.all_circles.append((xo,yo, r))\n",
        "\n",
        "    def dots_in_circle(self):\n",
        "        self.true_circles = []\n",
        "        for circle in self.all_circles:\n",
        "            for dot in self.dots:\n",
        "                if round((dot[0] - circle[0])**2 + (dot[1] - circle[1])**2,9) > round(circle[2]**2, 9):\n",
        "                    break\n",
        "            else:\n",
        "                self.true_circles.append((circle[0], circle[1], circle[2]))\n",
        "\n",
        "    def circle(self):\n",
        "        self.run()\n",
        "        tmp = [i[2] for i in self.true_circles]\n",
        "        self.circle = self.true_circles[tmp.index(min(tmp))]\n",
        "        print(f'Координаты центра окружности: ({self.circle[0]}, {self.circle[1]}), радиус: {self.circle[2]}')\n",
        "\n",
        "    def plot(self):\n",
        "        x,y,r = self.circle\n",
        "        circle = plt.Circle((x, y), r, color = 'blue')\n",
        "        fig = plt.figure(figsize=(10,10))\n",
        "        ax = plt.gca()\n",
        "        ax.cla()\n",
        "        ax.spines['left'].set_position(('data',0))\n",
        "        ax.spines['bottom'].set_position(('data',0))\n",
        "        ax.spines['top'].set_visible(True)\n",
        "        ax.spines['right'].set_visible(True)\n",
        "        ax.set_xlim((x-r*1.1, x+r*1.1))\n",
        "        ax.set_ylim((y-r*1.1, y+r*1.1))\n",
        "        ax.plot([i[0] for i in self.dots],([j[1] for j in self.dots]), 'o', color='green')\n",
        "        ax.plot(x, y, 'o', color='red')\n",
        "        plt.annotate(f'({round(x, 2)}, {round(y, 2)})', (x, y), xytext=(x + r*0.03, y - r* 0.04), c = 'red')\n",
        "        ax.add_artist(circle)\n",
        "        plt.show()"
      ],
      "metadata": {
        "id": "Na9wrUaJ1nMF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rB-u2E7Vp1ce"
      },
      "outputs": [],
      "source": [
        "a = RoundCircle()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# добавим тестовые точки\n",
        "a.add(3,7)\n",
        "a.add(-1,4)"
      ],
      "metadata": {
        "id": "7F5rCbAf2tzh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# посмотрим сущеструющие точки\n",
        "print(a.dots)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Lm4ZXEm824R-",
        "outputId": "30e1f91c-ab09-49cc-b6dc-82d6821b25b4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(3, 7), (-1, 4)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a.add(3,7)\n",
        "a.add(9,3)\n",
        "print(a.dots)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8bCRu-My2-mQ",
        "outputId": "9e110733-94d6-4390-bd9d-7440b9004fd5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(3, 7), (-1, 4), (9, 3)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# удалим одну точку\n",
        "a.remove(3,7)\n",
        "print(a.dots)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "75-JnyvM3C7E",
        "outputId": "b16e8b15-5421-46bb-f1e1-a883f3a79579"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(-1, 4), (9, 3)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# включение случайных точек\n",
        "a.random_dots( n = 20, range_x = (-20, 20), range_y = (-20, 20))\n",
        "print(a.dots)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zLjE4eId3MeY",
        "outputId": "33306d6e-d742-4ccc-d68c-00965a18d2a9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(-1, 4), (9, 3), (2, -2), (-11, -7), (-12, 12), (7, -6), (-1, -5), (8, -18), (2, -1), (12, 8), (-16, -20), (-18, -8), (7, 13), (0, -18), (15, 4), (-16, 13), (-6, 12), (-6, -6), (10, -16), (17, 6), (10, 14)]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# мин окружность описывающая все точки\n",
        "a.circle()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "92HhU11k3Q7x",
        "outputId": "c4a858ec-ef89-4372-97c1-33a9bc9e9959"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Координаты центра окружности: (-2.257575757575758, -3.5), радиус: 21.47333751559756\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a.plot()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 577
        },
        "id": "lRwjZ_eA3bFL",
        "outputId": "1f4f858e-d999-4ee3-f789-47e4ab091531"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "b = RoundCircle()\n",
        "b.random_dots( n = 5, range_x = (2, 11), range_y = (0, 3))"
      ],
      "metadata": {
        "id": "Prwac9583le4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "b.get_lines()"
      ],
      "metadata": {
        "id": "9-QWRFZP3mOS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# словарь all_lines в котором содержаться длинны отрезков\n",
        "# (dot1, dot2): = длинна отрезка\n",
        "b.all_lines"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lLOhlhhi3pQD",
        "outputId": "da0d4f88-49bf-47cb-d9e2-86da34b6aab1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{(0, 1): 4.272001872658765,\n",
              " (0, 2): 2.5495097567963922,\n",
              " (0, 3): 1.5811388300841898,\n",
              " (0, 4): 1.0,\n",
              " (1, 2): 1.8027756377319946,\n",
              " (1, 3): 3.5,\n",
              " (1, 4): 4.031128874149275,\n",
              " (2, 3): 2.23606797749979,\n",
              " (2, 4): 2.5495097567963922,\n",
              " (3, 4): 0.7071067811865476}"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# список all_circle в котором содержатся все возможные окружности\n",
        "# [x-окружности],[у-окружности],[радиус окружности]\n",
        "# после исполнения метода get_lines в этот атрибут добавляются все окружности построенные по двум точкам\n",
        "b.all_circles"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OYEN_CCb4Isj",
        "outputId": "2e85766f-d5de-4bbf-a457-c0cc4aaefcdb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[(6.0, 1.5, 4.272001872658765),\n",
              " (7.5, 2.5, 2.5495097567963922),\n",
              " (9.5, 1.5, 1.5811388300841898),\n",
              " (10.0, 2.0, 1.0),\n",
              " (3.5, 1.0, 1.8027756377319946),\n",
              " (5.5, 0.0, 3.5),\n",
              " (6.0, 0.5, 4.031128874149275),\n",
              " (7.0, 1.0, 2.23606797749979),\n",
              " (7.5, 1.5, 2.5495097567963922),\n",
              " (9.5, 0.5, 0.7071067811865476),\n",
              " (6.0, 1.5, 4.272001872658765),\n",
              " (7.5, 2.5, 2.5495097567963922),\n",
              " (9.5, 1.5, 1.5811388300841898),\n",
              " (10.0, 2.0, 1.0),\n",
              " (3.5, 1.0, 1.8027756377319946),\n",
              " (5.5, 0.0, 3.5),\n",
              " (6.0, 0.5, 4.031128874149275),\n",
              " (7.0, 1.0, 2.23606797749979),\n",
              " (7.5, 1.5, 2.5495097567963922),\n",
              " (9.5, 0.5, 0.7071067811865476)]"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# метод get_triangles(), получаем все возможные комбинации по три точки\n",
        "# после чего находятся окружности описывающие эти треугольники\n",
        "# (три точки лежащие на одной прямой отсеиваются)\n",
        "b.get_triangles()"
      ],
      "metadata": {
        "id": "IH6hJi1R4RHk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "b.all_triangles"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZULs5FsJ4XwA",
        "outputId": "13f060ac-ad78-42bb-80e7-7f394ac542c9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[(0, 1, 2),\n",
              " (0, 1, 3),\n",
              " (0, 1, 4),\n",
              " (0, 2, 3),\n",
              " (0, 2, 4),\n",
              " (0, 3, 4),\n",
              " (1, 2, 3),\n",
              " (1, 2, 4),\n",
              " (1, 3, 4),\n",
              " (2, 3, 4)]"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# следующий шаг метод dots_in_circle, который проверяет каждую окружность,\n",
        "# на принодлежность к ней всех заданных точек\n",
        "# результат заносится в список атрибута true_circles\n",
        "b.dots_in_circle()\n",
        "b.true_circles"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CpKJGTqf4bii",
        "outputId": "e450be64-f17b-4e47-b5e9-edd5ca3631c4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[(6.0, 1.5, 4.272001872658765),\n",
              " (6.0, 1.5, 4.272001872658765),\n",
              " (9.642857142857142, -8.214285714285714, 11.219971261194999),\n",
              " (5.8125, 2.0, 4.305247524823626),\n",
              " (5.5, 4.5, 5.700877125495679)]"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "b.circle()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wbpoCTJK4gnz",
        "outputId": "9223bfc9-35f2-4271-b058-3f6f617fd905"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Координаты центра окружности: (6.0, 1.5), радиус: 4.272001872658765\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "b.plot()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 575
        },
        "id": "8ZnYxIbd4kmO",
        "outputId": "4caa9c78-e953-4d3b-c017-65f658b8b1ce"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 720x720 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QSDrtwRep1ce"
      },
      "source": [
        "# Задание 2.1\n",
        "\n",
        "Создать базовый класс - Геометрическая фигура, определить в нём поля и следующие методы: инициализация, печать, посчитать площадь и периметр. Создать 3 класса - наследника (квадрат, круг, конус), переопределить методы, при необходимости - добавить. \n",
        "\n",
        "Плюс пример использования всего функционала класса с комментариями\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "eiqP1gwUp1cf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4885baa8-e757-45a3-a232-e8a2553b22d4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Это фигура: Квадрат, например\n",
            "Площадь равна 9\n",
            "Периметр равен 12\n",
            "-----\n",
            "Это фигура: Кружок\n",
            "Площадь равна 153.93804002589985\n",
            "Периметр равен 43.982297150257104\n",
            "-----\n",
            "Это фигура: Это конус!\n",
            "Площадь равна 123.76\n",
            "Периметр равен 25.13\n",
            "-----\n"
          ]
        }
      ],
      "source": [
        "from math import pi,sqrt\n",
        "\n",
        "class Figure:\n",
        "  #инициализация\n",
        "  def __init__(self, name):\n",
        "    self.name = name\n",
        "  \n",
        "  #печать\n",
        "  def __str__(self):\n",
        "        return f'Это фигура: {self.name}'\n",
        "\n",
        "  #посчитать полощадь - нет универсальной формулы для всех фигур\n",
        "  #также тут нет как в Java абстарактных методов, поэтому попробуем \"эмулировать\" их так\n",
        "  #а непосредственные вычисления будут в наследниках ps асб методы есть - но что-то через \"огороды\" https://habr.com/ru/post/72757/\n",
        "\n",
        "  def area(self):\n",
        "    pass\n",
        "  \n",
        "  def per(self):\n",
        "    pass\n",
        "  \n",
        "class Square(Figure):\n",
        "    def __init__(self, length):\n",
        "        super().__init__(\"Квадрат, например\")\n",
        "        self.length = length\n",
        "\n",
        "    def area(self):\n",
        "        return f'Площадь равна {self.length**2}'\n",
        "\n",
        "    def per(self):\n",
        "        return f'Периметр равен {4*self.length}'\n",
        "\n",
        "class Circle(Figure):\n",
        "    def __init__(self, radius):\n",
        "        super().__init__(\"Кружок\")\n",
        "        self.radius = radius\n",
        "\n",
        "    def area(self):\n",
        "        return f'Площадь равна {pi*self.radius**2}'\n",
        "\n",
        "    def per(self):\n",
        "        return f'Периметр равен {2*pi*self.radius}'\n",
        "\n",
        "class Conus(Figure):\n",
        "    def __init__(self, length, radius):\n",
        "        super().__init__(\"Это конус!\")\n",
        "        self.length = length\n",
        "        self.radius = radius\n",
        "\n",
        "    def area(self):\n",
        "      #через через радиус и высоту\n",
        "        return f'Площадь равна {\"{0:.2f}\".format(pi*self.radius*sqrt(self.radius**2 + self.length**2))}'\n",
        "    \n",
        "    #Как считать периметр? И применим ли он к конусу? можно считать периметр основания - окружности\n",
        "    def per(self):\n",
        "        return f'Периметр равен {\"{0:.2f}\".format(2*pi*self.radius)}'\n",
        "\n",
        "def fabric(cl):\n",
        "  #метод паттерна 'фабрика'\n",
        "  print(cl.__str__())\n",
        "  print(cl.area())\n",
        "  print(cl.per())\n",
        "  print('-' * 5)\n",
        "\n",
        "if __name__ == '__main__':\n",
        "  s = Square(3)\n",
        "  fabric(s)\n",
        "\n",
        "  c = Circle(7)\n",
        "  fabric(c)\n",
        "\n",
        "  co = Conus(9,4)\n",
        "  fabric(co)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UOxfjYX9p1cf"
      },
      "source": [
        "# Задание 2.2\n",
        "\n",
        "Создать собственный класс - строку. Отнаследовать от него классы: палиндром (при инициалицации создаёт из строки палиндром, если она не является палидромом), транслит(переводит строку в транслитерационную запись). Длина всех строк не должна превышать 20 символов. Перегружать можно только метод `__init__`\n",
        "\n",
        "Плюс пример использования всего функционала класса с комментариями"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pip install transliterate"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "THMD--GSw4T9",
        "outputId": "aa20b323-69ae-41ac-9d87-6f749de90858"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting transliterate\n",
            "  Downloading transliterate-1.10.2-py2.py3-none-any.whl (45 kB)\n",
            "\u001b[K     |████████████████████████████████| 45 kB 1.9 MB/s \n",
            "\u001b[?25hRequirement already satisfied: six>=1.1.0 in /usr/local/lib/python3.7/dist-packages (from transliterate) (1.15.0)\n",
            "Installing collected packages: transliterate\n",
            "Successfully installed transliterate-1.10.2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "I7OWQEYmp1cf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "539694ef-6a2b-490f-fb6e-94ae17f751af"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "тестСтрока\n",
            "Вот палиндром: акортСтсет\n",
            "Вот транслит: testStroka\n"
          ]
        }
      ],
      "source": [
        "from transliterate import translit\n",
        "\n",
        "class MyString:\n",
        "  #Основной конструктор класса \"Строка\"\n",
        "    def __init__(self, string):\n",
        "        self.string = str(string)[0: 20]\n",
        "    \n",
        "    def __str__(self):\n",
        "        return self.string\n",
        "\n",
        "class Palindrome(MyString):\n",
        "  def __init__(self, string):\n",
        "    super().__init__(string)\n",
        "\n",
        "  def __str__(self):\n",
        "        return f'Вот палиндром: {self.string[::-1]}'\n",
        "\n",
        "class Translit(MyString):\n",
        "  def __init__(self, string):\n",
        "    super().__init__(string)\n",
        "\n",
        "  def __str__(self):\n",
        "    return f'Вот транслит: {translit(self.string,\"ru\", reversed=True)}'\n",
        "  # translit\n",
        "\n",
        "if __name__ == '__main__':\n",
        "  s1 = MyString('тестСтрока')\n",
        "  print(s1)\n",
        "  p1 = Palindrome(s1)\n",
        "  print(p1)\n",
        "  t1 = Translit(s1)\n",
        "  print(t1)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "auQK2ZD6p1cg"
      },
      "source": [
        "# Задание 3.1\n",
        "\n",
        "Создайте класс «Целочисленная матрица» для работы с матрицами произвольного размера. В классе должны быть реализованы следующие операции:\n",
        "\n",
        "•\tприбавление к одной матрице другой, вычитание матриц, умножение матрицы на матрицу и умножение матрицы на число.(реализовать с помощью перегрузки операций); \n",
        "\n",
        "•\tзаполнение матрицы случайными числами из заданного диапазона;\n",
        "\n",
        "•\tвывод матрицы на печать;\n",
        "\n",
        "•\tнахождение транспонированной матрицы\n",
        "\n",
        "•\tопределение ортогональности матрицы\n",
        "\n",
        "•\tсравнение на равенство (операция ==)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "vRmNYb0-p1cg"
      },
      "outputs": [],
      "source": [
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zNoFo5S2p1cg"
      },
      "outputs": [],
      "source": [
        "class Matrix:\n",
        "    def __init__(self, size = None, mtx = None):\n",
        "        self.size_mtx = size if mtx is None else mtx.shape\n",
        "        self.mtx = mtx\n",
        "\n",
        "    def __repr__(self):\n",
        "        return f'{self.mtx}'\n",
        "\n",
        "    def __add__(self, other):\n",
        "        return Matrix(mtx= self.mtx + other.mtx)\n",
        "\n",
        "    def __sub__(self, other):\n",
        "        return Matrix(mtx= self.mtx - other.mtx)\n",
        "\n",
        "    def __mul__(self, other):\n",
        "        if isinstance(other,(int,float)):\n",
        "            return Matrix(mtx=self.mtx * other)\n",
        "        else:\n",
        "            if self.size_mtx[0] == other.size_mtx[1] and self.size_mtx[1] == other.size_mtx[0]:\n",
        "                return Matrix(mtx=self.mtx @ other.mtx)\n",
        "            else:\n",
        "                print(f'Некорректные размерности перемножаемых матриц {self.size_mtx}, {other.size_mtx})')\n",
        "\n",
        "    def __eq__(self, other):\n",
        "        if self.mtx.ravel().shape == other.mtx.ravel().shape:\n",
        "            if np.all(self.mtx == other.mtx):\n",
        "                return True\n",
        "            else:\n",
        "                return False\n",
        "        else:\n",
        "            return False\n",
        "\n",
        "    def print(self):\n",
        "        for i in self.mtx:\n",
        "            for j in i:\n",
        "                if isinstance(j, float):\n",
        "                    print(f'{j:f}'.ljust(len(str(np.max(self.mtx)))+2), end='')\n",
        "                else:\n",
        "                    print(f'{j}'.ljust(len(str(np.max(self.mtx)))+1), end='')\n",
        "            print()\n",
        "\n",
        "    def orth(self):\n",
        "        if self.size_mtx[0] == self.size_mtx[1]:\n",
        "            if np.all(self.mtx @ self.mtx.T == np.eye(self.size_mtx[0], dtype='int')):\n",
        "                return True\n",
        "            else:\n",
        "                return False\n",
        "        else:\n",
        "            print(f'Некорректная размерность! {self.size_mtx}')\n",
        "\n",
        "\n",
        "\n",
        "    def rnd_int(self, start, end):\n",
        "        self.mtx = np.random.randint(start, end, self.size_mtx, dtype=np.int)\n",
        "\n",
        "    def trans(self):\n",
        "        return Matrix(mtx= self.mtx.T)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = Matrix((4,6))\n",
        "y = Matrix((4,6))\n",
        "\n",
        "x.rnd_int(2,8)\n",
        "y.rnd_int(500,10000)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j46FhcK55AkU",
        "outputId": "7fe71fc1-e8b1-4988-eca6-105cd9598f28"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:54: DeprecationWarning: `np.int` is a deprecated alias for the builtin `int`. To silence this warning, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.\n",
            "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x == y"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uREmP8D75E_n",
        "outputId": "7d2130ef-534a-4b08-d514-c952c4c897c7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "z = x + y"
      ],
      "metadata": {
        "id": "yxQhIcqk5IVf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6QA5ASlB5Lhv",
        "outputId": "a3a5b005-7793-488d-ee11-fe7fb5c0cd16"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[3 6 4 7 4 5]\n",
              " [5 6 7 3 7 6]\n",
              " [2 6 6 2 4 4]\n",
              " [3 3 6 4 5 2]]"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bwLDDcxy5Nrl",
        "outputId": "1451d183-082a-48b9-9cdc-34a8621e9f2d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[1853 1032 3966 9140 2324 6517]\n",
              " [4160 3748 9458 8357 9252 2965]\n",
              " [7367 2874 6454 1933 8564 2690]\n",
              " [3428 8225 4689 8446 8509 4219]]"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "z"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iw3Ayhqc5Q9d",
        "outputId": "79fc964b-1bc9-4883-de09-0cbad0524836"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[1856 1038 3970 9147 2328 6522]\n",
              " [4165 3754 9465 8360 9259 2971]\n",
              " [7369 2880 6460 1935 8568 2694]\n",
              " [3431 8228 4695 8450 8514 4221]]"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "z.print()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MiAt8ObP5Smw",
        "outputId": "de0e23fc-c949-4fab-96be-32e1d3b616c6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1856 1038 3970 9147 2328 6522 \n",
            "4165 3754 9465 8360 9259 2971 \n",
            "7369 2880 6460 1935 8568 2694 \n",
            "3431 8228 4695 8450 8514 4221 \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y == z - x"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FKkn_WOq5WNl",
        "outputId": "862d6663-7984-4b68-e208-e2d0aa9a6887"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = x * 64\n",
        "a.print()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tqRaW3Pd5bbm",
        "outputId": "497215cc-8206-4717-864a-e11aec1076af"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "192 384 256 448 256 320 \n",
            "320 384 448 192 448 384 \n",
            "128 384 384 128 256 256 \n",
            "192 192 384 256 320 128 \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "b = (y - a) * 0.1\n",
        "b.print()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gR8kIXx05isc",
        "outputId": "410e9132-5fa4-4f2f-d21d-355d5f1ba30f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "166.10000064.800000371.000000869.200000206.800000619.700000\n",
            "384.000000336.400000901.000000816.500000880.400000258.100000\n",
            "723.900000249.000000607.000000180.500000830.800000243.400000\n",
            "323.600000803.300000430.500000819.000000818.900000409.100000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a.trans()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Vj49fHlN5naE",
        "outputId": "58a30849-96a4-4efd-b0bb-0d0a91653c4b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[[192 320 128 192]\n",
              " [384 384 384 192]\n",
              " [256 448 384 384]\n",
              " [448 192 128 256]\n",
              " [256 448 256 320]\n",
              " [320 384 256 128]]"
            ]
          },
          "metadata": {},
          "execution_count": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "c = b * a.trans()\n",
        "c.print()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-oumY6cx5qe_",
        "outputId": "e5c38eaf-5afc-4eb4-8532-73a907e90fe1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "792396.800000741740.800000511449.600000554809.600000\n",
            "1107328.0000001306003.200000920281.6000001008089.600000\n",
            "761433.6000001099520.000000719462.400000763104.000000\n",
            "1188268.8000001286092.800000934400.000000905753.600000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "c.orth()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RB0VlEUl5wpb",
        "outputId": "b760c64e-be87-4541-9561-e60348eea570"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "d = Matrix(mtx=np.array([[0,0,1],[1,0,0],[0,1,0]]))\n",
        "d.print()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9UFhzWRl5z4t",
        "outputId": "a183ab1c-203a-4ffb-fba0-50e56d710f77"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 0 1 \n",
            "1 0 0 \n",
            "0 1 0 \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "d.orth()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rzRWdXBk54D3",
        "outputId": "1194fed4-c6f5-44ce-ce8e-32754a768f00"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    }
  ],
  "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.4"
    },
    "colab": {
      "name": "OOP-HW-1.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}