Programiranje 1 (22/23)

Košarica

1. V razredu Kosarica bomo hranili seznam artiklov. Napišite razred Kosarica in njegov konstruktor __init__(self), ki ustvari prazno košarico (interna predstavitev košarice je lahko npr. seznam).

>>> kosarica = Kosarica()

2. Razredu Kosarica dodajte metodo dodaj(self, artikel, kolicina), ki v košarico doda kolicina artiklov artikel, kar z drugimi besedami pomeni, da jih dodamo v seznam.

>>> kosarica.dodaj(jabolko, 42)
>>> kosarica.dodaj(hruska, 6)
>>> kosarica.dodaj(kokakola, 7)
>>> kosarica.dodaj(sesalnik, 1)

class Kosarica:
    def __init__(self):
        self.kosarica = []

    def dodaj(self, artikel, kolicina):
        self.kosarica.append((artikel, kolicina))
    

3. Napišite metodo izpisiImena(self), ki izpiše imena vseh nakupljenih artiklov.

4. Razredu Kosarica dodajte metodo racun(self), ki izpiše nekaj takega:

>>> kosarica.racun()
jabolko                 1.30 EUR *  42 =   54.68 EUR 
hruska                  1.84 EUR *   6 =   11.07 EUR 
kokakola                1.39 EUR *   7 =    6.94 EUR 
Gorenje                48.89 EUR *   1 =   48.89 EUR 
----------------------------------------------------
SKUPAJ                                    121.58 EUR
Od tega DDV                                13.84 EUR

 class Kosarica:
    def __init__(self):
        self.kosarica = []

    def dodaj(self, artikel, kolicina):
        self.kosarica.append((artikel, kolicina))

    def racun(self):
        cena, ddv = 0, 0
        for artikel, kolicina in self.kosarica:
            print('%-20s %7.2f EUR * %3d = %7.2f EUR ' % (artikel.ime, artikel.skupna_cena(1), kolicina, artikel.skupna_cena(kolicina)))
            cena += artikel.skupna_cena(kolicina)
            ddv += artikel.vrednost_DDV(kolicina)
        print('-' * 52)
        print('%-40s %7.2f EUR' % ('SKUPAJ', cena))
        print('%-40s %7.2f EUR' % ('Od tega DDV', ddv))

Od tu naprej bomo spet uporabljali razred Turtle, ki ste ga definirali na predavanjih. Naloge rešujte tako, da ustvarite nove razrede. Razreda Turtle ne smete spreminjati, razen če je to eksplicitno dovoljeno.

Želva z imenom

Napiši razred ZelvaZImenom, ki je izpeljan iz razreda Turtle. ZelvaZImenom se obnaša kot vsaka druga želva, le da ima, poleg vseh svojih atributov, še atribut ime, ki ga nastavimo v konstruktorju in metodo pozdrav.

i = ZelvaZImenom('Jožica') # Ustvari želvo z imenom Jožica
i.forward(100)
i.pozdrav() # izpiše 'Jaz sem želva Jožica'

import turtle

class ZelvaZImenom(turtle.Turtle):
    def __init__(self, ime):
        super().__init__()
        self.ime = ime

    def pozdrav(self):
        print('Jaz sem želva', self.ime)

Čveka

Želva čveka je zelo glasna želva -- preden se premakne ali obrne, nas o tem obvesti. Želva čveka ima tudi ime in metodo pozdrav.

c = Cveka('Jožica') # Ustvari želvo čveko z imenom Jožica
c.forward(20) # izpiše 'Jožica gre 20 korakov naprej'
c.turn(60) # izpiše 'Jožica se obraca za 60 stopinj'
c.forward(20) # izpiše 'Jožica gre 20 korakov naprej'
c.pozdrav() # izpiše 'Jaz sem želva Jožica'

class Cveka(ZelvaZImenom):
    def forward(self, l):
        super().forward(l)
        print(self.ime, 'gre naprej', l)

    def turn(self, angle):
        super().turn(angle)
        print(self.ime, 'se obraca', angle)

Rdečevratka

Želva rdečevratka nima imena. Ima pa vse ostale lastnosti navadne želve. Poleg tega:

• ima rdeč vrat.

  

  Krogu, ki je že narisan lahko spremenite barvo tako, da na vrhu programa napišete

  from PyQt4.QtCore import *
  from PyQt4.QtGui import *
  

  Krog pa pobarvate z ukazom

  self.head.setPen(QPen(QBrush(risar.rdeca), 3))
  

• se premika dvakrat počasneje kot navadna želva.

  # Zelva Rdecevratka je pocasna zelva
  r = Rdecevratka()
  r.forward(40)
  r.turn(90)
  r.forward(50)
  
  
  t = turtle.Turtle()
  t.forward(40)
  t.turn(90)
  t.forward(50)
  

  

• se ne zna dobro skriti -- skrije se tako, da glavo povleče v oklep.

  r = Rdecevratka()
  r.hide()
  

  

from PyQt4.QtCore import *
from PyQt4.QtGui import *

import turtle
import risar

class Rdecevratka(turtle.Turtle):
    def __init__(self):
        super().__init__()
        self.head.setPen(QPen(QBrush(risar.rdeca), 3))

    def forward(self, l):
        super().forward(l // 2)

    def hide(self):
        self.head.hide()

Pijanka

Želva pijanka je vesela želva -- pred vsakim premikom se želva pijanka zmede in naključno spremeni svoj kot. Velikost naključne spremembe je seveda sorazmerna s številom popitih kozarcev. Po prvem kozarcu je velikost spremembe od -5 do 5 stopinj, po drugem kozarcu od -10 do 10 stopinj, itd. Po petih popitih kozarcih želva pijanka obleži, zato se ne premika več.

# Zelva pijanka po stirih popitih kozarcih
p = Pijanka()
p.drink()
p.drink()
p.drink()
p.drink()
for i in range(20):
    p.forward(10)

# Zelo pijana zelva pijanka se ne premika
p = Pijanka()
p.drink()
p.drink()
p.drink()
p.drink()
p.drink()
p.turn(45)
p.forward(100)

import turtle
import random

class Pijanka(turtle.Turtle):
    def __init__(self):
        super().__init__()
        self.drinks = 0

    def drink(self):
        self.drinks += 1

    def forward(self, l):
        if self.drinks < 5:
            self.angle += random.randint(-self.drinks * 5, self.drinks * 5)
            super().forward(l)

    def turn(self, angle):
        if self.drinks < 5:
            super().turn(angle)

Pravokotnica

Želva pravokotnica je posebna želva -- premika se lahko le v vodoravni in navpični smeri. Če ji ukažemo drugače, bo premik opravila v dveh korakih: najprej v vodoravni, nato pa v navpični smeri.

p = Pravokotnica()
p.turn(30)
p.forward(20)
p.forward(20)
p.forward(20)
p.forward(20)
p.turn(100)
p.forward(100)

import turtle
import math

class Pravokotnica(turtle.Turtle):
    def forward(self, l):
        angle = math.radians(90 - self.angle)
        nx, ny = l*math.cos(angle), l*math.sin(angle)

        angle_old = self.angle
        self.angle = 0
        super().forward(ny)
        self.angle = 90
        super().forward(nx)
        self.angle = angle_old
        self.update()

Množenje

Želve se lahko množijo -- ko se dve želvi zmnožita, ustvarita novo želvo na koordinatah (0, 0). Želvi se lahko množita le če sta dovolj blizu (manj kot 10 pikslov narazen). Pri tej nalogi lahko izjemoma spremenite razred Turtle tako, da mu dodate ustrezno metodo.

oce = turtle.Turtle()
mati = turtle.Turtle()
sin = oce * mati

oce.forward(20)
oce.turn(30)
oce.forward(20)

mati.forward(20)
mati.turn(-30)
mati.forward(20)

oce = turtle.Turtle()
oce.forward(100)
mati = turtle.Turtle()
sin = oce * mati # Zelvi nista dovolj blizu. Program naj vrze napako.

# Razredu Turtle dodajte metodo __mul__
    def __mul__(self, other):
        if (self.x - other.x)**2 + (self.y - other.y)**2 > 10**2:
            raise ConnectionRefusedError()
        return Turtle()