9. Objekty¶

9.1.1. Barevné kruhy¶

Vytvořte třídu pro reprezentaci barevného kruhu na daných souřadnicích.

class Circle:

    def __init__(self, x: float, y: float, radius: float, color: str) -> None:
        pass

def test_circle() -> None:
    circle = Circle(4, 5, 10, 'red')
    assert circle.y == 5
    assert circle.color == 'red'

9.1.2. Obdélník¶

Napište třídu Rectangle pro reprezentaci obdélníku o dané šířce a výšce a funkci pro výpočet obsahu předaného obdélníku.

class Rectangle:
    pass

def area(rectangle: Rectangle) -> float:
    pass

def test_rectangle() -> None:
    rectangle = Rectangle(4, 3)
    assert rectangle.width == 4
    assert rectangle.height == 3
    assert area(rectangle) == 12

9.1.3. Bod¶

Napište třídu pro reprezentaci bodu v rovině (parametry x a y). Potom implementujte funkci, která vypočítá vzdálenost dvou bodů.

9.1.4. Kniha¶

Napište třídu pro reprezentaci knihy (s atributy název, autor, ISBN a cena). Dále napište funkce print_info pro výpis informací o knize a draw_cover pro vykreslení obálky knihy.

Výstup může vypadat třeba nějak takto (nemusíte si ale hrát se zarovnáním do středu):

name:   Cooking for Geeks
author: Jeff Potter
isbn:   0596805888
price:  $22

+-------------------------+
|                         |
|                         |
|                         |
|    Cooking for Geeks    |
|                         |
|                         |
|                         |
|       Jeff Potter       |
|                         |
|                         |
|                         |
|                         |
+-------------------------+

9.2.1. Kruh¶

Napište třídu pro reprezentaci kruhu s daným středem a poloměrem. Implementujte metody pro výpočet obvodu, obsahu a vrácení informačního řetězce (__str__).

class Circle:

    def __init__(self, center: float, radius: float) -> None:
        pass

    def get_perimeter(self) -> float:
        pass

    def get_area(self) -> float:
        pass

    def __str__(self) -> str:
        pass

def test_circle() -> None:
    circle = Circle((-130, -130), 100)
    assert str(circle) == "Circle at (-130, -130) with radius 100"
    assert circle.get_area() == 31415.926535897932

9.2.2. Želvy¶

Prozkoumejte následující třídu pro reprezentaci kreslící želvy a vyzkoušejte si její použití.

class Turtle:
    def __init__(self) -> None:
        self.x = 0
        self.y = 0
        self.direction = 0
        self.lines = []

    def left(self, angle: float) -> None:
        self.direction -= angle

    def right(self, angle: float) -> None:
        self.direction += angle

    def forward(self, distance: float) -> None:
        nx = self.x + distance * math.cos(self.direction * math.pi / 180)
        ny = self.y + distance * math.sin(self.direction * math.pi / 180)

        self.lines.append((self.x, self.y, nx, ny))
        self.x, self.y = nx, ny

    def get_lines_svg(self) -> str:
        svg = ""
        for x1, y1, x2, y2 in self.lines:
            svg += """\t<line x1='{}' y1='{}' x2='{}' y2='{}'
                style='stroke: red; stroke-width:2' />\n""".format(x1, y1, x2, y2)
        return svg

    def save(self, filename: str) -> None:
        with open(filename, "w") as f:
            f.write('<svg width="100%" height="100%" xmlns="http://www.w3.org/2000/svg" xmlns:xlink= "http://www.w3.org/1999/xlink">\n')
            f.write(self.get_lines_svg())
            f.write("\n</svg>")

• Přidejte želvě metodu pro vykreslení mnohoúhelníka.

• Upravte želvu tak, aby začínala na náhodné pozici (třeba v intervalu 0-500).

• Upravte želvu tak, aby uměla kreslit i jinou barvou než černou (např. můžete přidat metodu set_color(self, color: str) -> None).

• Přidejte želvě metodu, která ji posune o danou vzdálenost náhodným směrem (random_step(self, distance: float) -> None).

• Napište funkci chase(steps: int = 10) -> None. Funkce vytvoří 2 želvy, jedna bude honit druhou. První (černá) bude daný počet kroků náhodně chodit (třeba o 100), druhá (červená) bude vždy chodit směrem k první (taky třeba o 100). Nakonec funkce uloží obě želvy do jednoho svg (pozn.: není možné přímo použít metodu save()), můžete využít metodu:

  def turn_towards(self, other_turtle: 'Turtle') -> None:
      self.direction = math.atan2(other_turtle.y - self.y,
                          other_turtle.x - self.x) / math.pi * 180
  

• Napište funkci multichase(steps: int = 10, turtles: int = 10) -> None, která vytvoří požadovaný počet želv a uloží je do seznamu; v každém kroku každá ze želv udělá krok (třeba 10) k nejbližší želvě (může se hodit metoda typu find_nearest(self, turtles: List['Turtle']) -> 'Turtle', která vrátí nejbližší želvu z daného seznamu).

• Zkuste změnit želvy na tanky, které po sobě budou střílet.

9.2.3. Příšera¶

Doplňte následující kostru třídy a vyzkoušejte její funkčnost. Poté přidejte příšeře další metody, např. is_defeated, která vrací True, pokud už příšera nemá žádné životy.

9.2.4. Zásobník¶

Vytvořte třídu pro reprezentaci zásobníku podporující operace přidání prvku, odebrání prvku a test na prázdnost.

class Stack:
    pass


def test_stack() -> None:
    stack = Stack()
    stack.push(5)
    stack.push(10)
    assert stack.pop() == 10
    assert not stack.is_empty()
    assert stack.pop() == 5
    assert stack.is_empty()

9.2.5. Fronta¶

Vytvořte třídu pro reprezentaci fronty podporující operace přidání prvku, odebrání prvku, test na prázdnost, seřazení prvků ve frontě a konverzi fronty na zásobník.

class Queue:
    pass

def test_queue() -> None:
    queue = Queue()
    queue.enqueue(42)
    queue.enqueue(10)
    queue.enqueue(5)
    assert not queue.is_empty()
    assert queue.dequeue() == 42

    queue.sort()

    stack = queue.to_stack()
    assert stack.pop() == 10
    assert queue.dequeue() == 5

9.2.6. Knihovna¶

Vytvořte třídu Library pro reprezentaci kolekce knih s metodami pro přidání knihy, odebrání knihy, nalezení knihy podle názvu nebo ISBN, nalezení všech knih daného autora, nalezení všech knih s cenu pod zadanou mez. Pro reprezentaci knih využijte třídu Book ze cvičení Kniha.

9.2.7. Geometrické tvary¶

Napište třídy pro několik jednoduchých geometrických útvarů (čtverec, kruh, rovnostranný trojúhelník). Každá třída bude mít metody pro výpočet obvodu, výpočet obsahu a vrácení informačního řetězce (__str__). V následující ukázce si všimněte dynamické (pozdní) vazby jmen metod (např. get_perimeter na řádku 10) na jejich definice (tj. skutečně volaná metoda se různí podle toho, na jaký objekt zrovna ukazuje proměnná shape).