#-*- coding: utf-8 -*-
## Klasa, z punktu widzenia programowania, jest to typ zmiennej.
## Natomiast w ujęciu projektowym jest to ogólna definicja pewnej grupy powiązanych ze sobą obiektów,
## które różnią się tożsamością. Klasa definiuje metody, czyli funkcjonalności, które są dostarczane przez obiekty.
## Poza tym definiuje również atrybuty, które są indywidualne (choć nie zawsze) dla konkretnych obiektów.
## Czym jest obiekt? Jest to konkretna zmienna danego typu czyli instancja danej klasy.

## Janek, Ania, Zosia to obiekty klasy Człowiek in. to poszczególne egzemplarze danej klasy czyli instancje
## Każde z nich może spać, jeść, poruszać się i to są właśnie metody zdefiniowane w klasie Człowiek.
## Oprócz tego każdy człowiek posiada imię oraz datę urodzenia, jednak są one indywidualne dla każdego obiektu,
## czyli nie są bezpośrednio powiązane z klasą, a z jej instancją (obiektem)

## Zapamiętaj: w programowaniu  obiektowym  tworzymy/wykorzystujemy: klasy i obiekty.
## Klasa  tworzy nowy typ. Obiekty to są  egzemplarze (instancje) danej klasy.
## Klasa zawiera:
## a) elementy opisujące  stan (pola klasy)
## b) zachowania (metody klasy)
##
## Wyobraź sobie dwa różne zwierzęta: Samochód i Motyla  - to są dwie różne klasy
## Samochód: jeździ, wyrzuca spaliny, psuje się - to są metody klasy Samochód
## Motyl: lata, pije nektar  - to są metody klasy Motyl
## Samochód ma: masę, rok produkcji, typ silnika, pojemność silnika - to są pola/dane klasy Samochód
## Motyl ma: rozmiar skrzydeł, wagę, kolorystykę itp. - to są pola/dane klasy Motyl
##
## Ale jeżeli będziesz mieć  konkretny Samochód lub Motyla (np. Twoje własne)  to  będą one
## konkretnymi egzemplarzami, czyli obiektem klasy Samochód lub obiektem klasy Motyl

####################################################################################
# print('##########################################################')
# print('Przykład 1: Tworzymy klasę o nazwie Komputer1 oraz metodę o nazwie powitanie')
# print('Parametr ”self” to specjalny parametr (wpisuj go zawsze jako pierwszy argument w funkcji),')
# print('który przekazuje do każdej metody obiekt klasy na jakiej ma operować.')
# print('##########################################################')


# class Komputer1:
#     def powitanie(self):
#         print('Witaj użytkowniku to ja Twój PC')
#
#
# mojKomputer = Komputer1() #Tworzymy obiekt klasy Komputer -> struktura: nazwa_obiektu = nazwa_Klasy()
# mojKomputer.powitanie()# Wywołujemy metodę -> metodę powitanie na obiekcie mojKomputer


# print('###################################################################')
# print('Zadanie 1')
# print('Utwórz klasę Imiona z metodą o nazwie zapytaj,'
#       'metoda zapytaj po wywołaniu na obiekcie klasy Imiona'
#       'powinna wyświetlić pytanie "Jak masz na imie?')

# class Imiona:
#     def zapytaj(self):
#         print ("Jak masz na imie?")
#
# Zbiorimion = Imiona()
# Zbiorimion.zapytaj ()
# print('###################################################################')



# ################################################################################
# print('Przykład 2: Utworzymy klasę o nazwie Komputer w której')
# print('zdefiniujemy pola: rodzajMatrycy, pojemnoscDysku w/w pola to zmienne proste')
# print('ustawimy też początkowe wartości w/w własności dla przykładowej instancji/konkretnego obiektu')
# class Komputer:
#     rodzajMatrycy = 'LCD' # zmienna widoczna tylko wewnątrz klasy
#     pojemnoscDysku = 100
#     def jakirodzajMatrycy(self):
#         return(self.rodzajMatrycy)  # wywołanie metody na obiekcie   self.nazwa_metody
#     def jakapojemnoscDysku(self):
#         return(self.pojemnoscDysku)
#
# mojKomputer = Komputer() #Tworzymy obiekt klasy Komputer
# w1 = mojKomputer.jakirodzajMatrycy()# przypisujemy do zmiennej w1 rezultat wywołania metody jakiRodzajMatrycy na obiekcie mojKomputer
# print(w1) ## wyświetlamy wynik
# w2 = mojKomputer.jakapojemnoscDysku()
# print(w2)

# print('###################################################################')
# print('Zadanie 2')
# print('Utwórz klasę Pies z polami: waga = 10, rasa = "Jamnik" ')
# print('Utwórz metody: jakaWaga, jakaRasa które będą wyświetlały wartości utworzonych pól')

# class Pies:
#     waga = 10
#     rasa = "Jamnik"
#     def jakawaga(self):
#         return(self.waga)
#     def jakarasa(self):
#         return(self.rasa)
#
#
#
# mojpies = Pies()
# w1 = mojpies.jakawaga()
# print (w1)
# r1 = mojpies.jakarasa()
# print(r1)
# #####################################################################################
# print('Przykład 3: Tworzymy klasę o nazwie Telewizor w której')
# print('zdefiniujemy pole, które będzie listą: listaKanalow')
# print('zdefiniujemy metodę jakieKanaly która wyświetli dostępne kanały')
# class Telewizor:
#     listaKanalow = ['TV1','Polsat','TVN']
#     def jakieKanaly(self):
#         for i in self.listaKanalow:
#             print(i)
# print('######Wynik działania Przykład 3 ###########')
# mojTelewizor = Telewizor()
# mojTelewizor.jakieKanaly()
# print('###################################################################')


# ###########################################################################################
# print('Zadanie 3')
# print('Utwórz klasę Kwiaty z 1 polem tj. listą zawierająca wartości: Tulipan, Hiacynt, Bez, Dalia')
# print('utwórz metodę: jakiRodzaj która będzie wyświetlała wartości z w/w listy')

# class Kwiaty:
#     Rodzaj = ['Tulipan','Hiacynt','Bez', 'Dalia']
#     def jakiRodzaj(self):
#         for i in self.Rodzaj:
#             print(i)
#
#
# mojKwiat = Kwiaty()
# mojKwiat.jakiRodzaj()




# ############################################################################
# # Metoda która jest wywoływana tylko raz (automatycznie podczas
# # tworzenia przez nas obiektu) nazywana jest konstruktorem.
# # Konstruktor możemy wykorzystać np. do ustalenia wartości początkowej pól klasy,
# # Załóżmy, że tworzysz 5 różnych obiektów (egzemplarzy) dla klasy Pies
# # więc każdego obiektu możesz przypisać inną wartość wagi i rasę bo
# # są różne rasy psów i psy mają różną wagę, ale możesz ustawić jakieś wartości początkowe
# print('Przykład 4: Tworzymy klasę o nazwie TV w której')
# print('zdefiniujemy pole, które będzie listą: listaKanalow oraz pole numerKanalu o wartości 1')
# print('zdefiniujemy konstruktor który ustawi/wyświetli bieżacy kanał włączony w TV')

# class TV:
#     listaKanalow = ['TV1','Polsat','TVN']
#     numerKanalu = 1
#     def __init__(self):
#         print('Włączony kanał to: ' + self.listaKanalow[self.numerKanalu])
#
# mojTV = TV() # wywołanie

# print('################################################')
# print('Zadanie 4')
# print('Utwórz klasę Koty z 1 polem tj. listą zawierająca wartości: Pers, Egipski, Bengalski, Sfinks')
# print('utwórz konstruktor który przypisze i wyświetli dowolnie wybrany gatunek kota')
# print('################################################')

# class Koty:
#     Rasy = ['Pers','Egipski','Bengalski','Sfinks']
#     Rasa = 1
#     def __init__(self):
#         print('Wybrana Rasa to: ' + self.Rasy[self.Rasa])
#
# mojkot = Koty()





# print('Przykład 5: Nauczymy zmieniać wartości pól, tworzymy klasę o nazwie Muzyka w której')
# print('zdefiniujemy pole, które będzie listą zawierająca typy muzyki oraz pole nrTyp o wartości 0')
# print('zdefiniujemy konstruktor który ustawi/wyświetli początkowy typ muzyki')
# print('następnie zdefiniujemy metody ustawTypMuzyki, wyswietlTypMuzyki do zmiany wartości pola typ muzyki i wyświetlania wyniku ')
# class Muzyka:
#     typyMuzyki = ['ROCK','POP','JAZZ','KLASYKA','DISCO_POLO']
#     nrTyp = 0
#     def __init__(self):
#         self.typyMuzyki[self.nrTyp]
#         # print('Początkowy typ muzyki to: ' + self.typyMuzyki[self.nrTyp])
#
#     def ustawTypMuzyki(self, wpisanyNumer):
#         self.nrTyp = wpisanyNumer
#         #print(self.typyMuzyki[self.nrTyp])
#
#     def wyswietlTypMuzyki(self):
#         print('Ustawiony typ muzyki to: ' + self.typyMuzyki[self.nrTyp])

# print('#################')
# mojaMuzyka1 = Muzyka()
# mojaMuzyka1.wyswietlTypMuzyki()
# mojaMuzyka1.ustawTypMuzyki(3)
# mojaMuzyka1.wyswietlTypMuzyki()

# print('######A teraz odblokuj kod który jest jeszcze bardziej uniwersalny########################')
# mojaMuzyka2 = Muzyka()
# mojaMuzyka2.ustawTypMuzyki(int(input("Wskaz numer typu muzyki od 1-5: "))-1)
# mojaMuzyka2.wyswietlTypMuzyki()
#
#################
# print('Zadanie 5: Utwórz klasę o nazwie Egzamin w której')
# print('zdefiniujemy pole Przedmioty, które będzie listą zawierającą nazwy przedmiotów które zdajesz w tym semestrze oraz pole nrPrzedmiotu,
# wartość tego pola odpowiada nr przedmiotu który zdajesz jako pierwszy w sesji')
# print('zdefiniujemy konstruktor który ustawi/wyświetli początkowy przedmiot który będziesz zdawał w sesji')
# print('następnie zdefiniujemy 2 metody ustawPrzedmiot, wyswietlPrzedmiot do zmiany wartości w/w pola i wyświetlania wyniku ')
# print('wstaw odpowiedni komentarz dla wyświetlanej odpowiedzi, przetestuj swój program')

# class Egzamin:
#     Przedmioty = ['Matematyka Dyskretna','Analiza Matematyczna','Python','Ask']
#     nrPrzedmiotu = 0
#     def __init__(self):
#         self.Przedmioty[self.nrPrzedmiotu]
#         print('Pierwszy przedmiot w sesji to: ' + self.Przedmioty[self.nrPrzedmiotu])
#
#     def ustawPrzedmiot(self, wpisanyNumer):
#         self.nrTyp = wpisanyNumer
#         print(self.Przedmioty[self.nrPrzedmiotu])
#
#     def wyswietlPrzedmiot(self):
#         print('Wynik to: ' + self.Przedmioty[self.nrPrzedmiotu])
#
# mojeprzedmioty1 = Egzamin()
# mojeprzedmioty1.ustawPrzedmiot(3)
# mojeprzedmioty1.wyswietlPrzedmiot()
#
# mojeprzedmioty2 = Egzamin()
# mojeprzedmioty2.ustawPrzedmiot(int(input("Wskaz ocene od od 2-5: "))-1)
# mojeprzedmioty2.wyswietlPrzedmiot()

######################################################################
# print(' Przykład 6. Utwórz klasę Prostokat, ktora bedzie miała możliwość obliczenia pola powierzchni '
#       'prostokąta o bokach dowolnie zdefiniowanych przez użytkownika, początkowe wartości boków ustaw na 2 i 5')

# # ####wariant 1
# class Prostokat:
#     def __init__(self):
#         self.bokA = 2
#         self.bokB = 5
#         #return(print('Poczatkowe wartosci bokow to a = ' + str(self.bokA) + ' oraz b = ',str(self.bokB)))
#     def podajBokA(self,podanybokA):
#         self.bokA = podanybokA
#     def podajBokB(self, podanybokB):
#         self.bokB = podanybokB
#     def pole(self):
#         S = self.bokA * self.bokB
#         return(print('Pole wynosi: '+ str(S)))
#
# mojProstokat = Prostokat()
# mojProstokat.pole()  # bez ustawiania wartości boku A i B, program korzysta z wartości początkowych
# mojProstokat.podajBokA(10)  # ustawianie wartości boku A, początkowa wartość 2 zamieniana jest na 10
# mojProstokat.podajBokB(20)  # ustawianie wartości boku B, początkowa wartość 5 zamieniana jest na 20
# mojProstokat.pole()

# ####wariant 2
# class Prostokat():
#     def __init__(self):
#         self.bokA = 2
#         self.bokB = 5
#     def podajBoki(self,bokA,bokB):
#         self.bokA = bokA
#         self.bokB = bokB
#     def pole(self):
#         S = self.bokA * self.bokB
#         return(print('Pole wynosi: '+ str(S)))
#
# mojProstokat = Prostokat()
# mojProstokat.pole()
# mojProstokat.podajBoki(3,5)
# mojProstokat.pole()
#
# # ####wariant 3
# class Prostokat():
#     def __init__(self,bokA,bokB):
#         self.bokA = bokA
#         self.bokB = bokB
#     def pole(self):
#         S = self.bokA * self.bokB
#         return(print('Pole wynosi: '+ str(S)))
#
# mojProstokat = Prostokat(2,5)
# mojProstokat.pole()
######################################################################
# print(' Zadanie 6. Utwórz klasę Koło, ktora bedzie miała możliwość obliczenia pola powierzchni i obwodu koła'
#       'o promieniu dowolnie zdefiniowanym przez użytkownika, początkową wartość promienia ustaw na 1')

# # ####wariant 3
# class Koło():
#     def __init__(self,promien,pi):
#         self.promien = promien
#         self.pi = pi
#     def pole(self):
#         S = self.promien * self.pi
#         return(print('Pole wynosi: '+ str(S)))
#
# mojeKolo = Koło(1,3)
# mojeKolo.pole()

# class Kolo:
#     def __init__(self):
#         self.r = 1
#         self.pi = 3.14
#         self.d = 2
#         return(print('Poczatkowe wartosci bokow to r = ' + str(self.r) + ' oraz pi = ',str(self.pi)))
#     def podajd(self,podaned):
#         self.d = podaned
#     def podajr(self,podaner):
#         self.r = podaner
#     def podajpi(self, podanepi):
#         self.pi = podanepi
#     def pole(self):
#         S = self.r * self.pi
#         return(print('Pole wynosi: '+ str(S)))
#     def Obwod(self):
#         O = self.d * self.pi
#         return(print('Obwod wynosi: '+ str(O)))
#
# mojeKolo = Kolo()
# mojeKolo.podajr(10)  # ustawianie wartości boku A, początkowa wartość 2 zamieniana jest na 10
# mojeKolo.podajpi(20)  # ustawianie wartości boku B, początkowa wartość 5 zamieniana jest na 20
# mojeKolo.pole()
#
# mojeKolo = Kolo()
# mojeKolo.podajd(10)  # ustawianie wartości boku A, początkowa wartość 2 zamieniana jest na 10
# mojeKolo.podajpi(20)  # ustawianie wartości boku B, początkowa wartość 5 zamieniana jest na 20
# mojeKolo.Obwod()

#-*- coding: utf-8 -*-
# import numpy as np
#######################################################################
# print('Przykład 7 Utwórz klasę Ankieta, która będzie posiadała 5 pól: nazwisko, wiek, studia, lubi1, lubi2')
# print('oraz 5 metod: pytanieDane, pytanieWiek, pytanieStudia, pytanieLubi, wyswietlAnkiete')
# print('Zbierz informacje od conajmniej 2 użytkownikow, zadajac im pytania: o dane osobowe, wiek, kierunek studiow')
# print('o to co lubią robić w wolnym czasie, a następnie wyniki zapisz do listy/słownika ')
#
# class Ankieta(object):
#     nazwisko=[]
#     wiek = []
#     studia = []
#     lubi1 = []
#     lubi2 = []
#     def __init__(self):
#         return(print('Nazwisko: - ', 'Wiek: -', 'Studia: -', 'Lubi: -'))
#     def pytanieDane(self,noweNazwisko):
#         self.nazwisko = noweNazwisko
#         return(self.nazwisko)
#     def pytanieDane(self, wiek1):
#         self.wiek = wiek1
#         return(self.wiek)
#     def pytanieStudia(self, studia1):
#         self.studia = studia1
#         return (self.studia)
#     def pytanieLubi(self, lubi11,lubi22):
#         self.lubi1 = lubi11
#         self.lubi2 = lubi22
#         return([self.lubi1, self.lubi2])
#     def wyswietl(self):
#         mojSlownik = {'Imie_Nazwisko': self.nazwisko, 'Wiek': self.wiek, 'Studia_kierunek': self.studia,'Lubi': [self.lubi1, self.lubi2]}
#         print(mojSlownik)
#
# mojaAnkieta = Ankieta()
# mojaAnkieta.wyswietl()
# #mojaAnkieta.nazwisko = 'Kowalska'
# mojaAnkieta.nazwisko = input('Podaj nazwisko: ')
# mojaAnkieta.wiek = 18
# mojaAnkieta.studia = 'Informatyka'
# mojaAnkieta.lubi1 = 'Spacery z psem'
# mojaAnkieta.wyswietl()
# mojaAnkieta.lubi2 = 'Muzyka'
# mojaAnkieta.wyswietl()

# print('Zadanie 1 Twoim zadaniem będzie zebranie informacji w formie ankiety od conajmniej 3 osób planujących')
# print('swoje wakacje, zadaj odpowiednie pytania, zbierz interesujące Cię informacje')
# print('Utwórz klasę Wakacje, conajmniej 6 pól np.: wiek, płeć, kraj, miasto, transport, liczbaOsob')
# print('conajmniej 4 metod: pytanieWiek, ..., pytanieliczbaOsob, wyswietlAnkiete')
# print('Zbierz informacje od conajmniej 2 użytkownikow, zadajac im pytania: o dane osobowe, wiek, kierunek studiow')
# print('o to co lubią robić w wolnym czasie, a następnie wyniki zapisz do listy/słownika

class Wakacje(object):
    plec = []
    wiek = []
    kraj = []
    miasto = []
    transport = []
    liczbaOsob = []

    def __init__(self):
        return(print('imie: - ', 'Wiek: -', 'Studia: -', 'Lubi: -'))
    def pytanie(self,noweNazwisko):
        self.plec = noweNazwisko
        return(self.plec)
    def pytanieDane(self, wiek1):
        self.wiek = wiek1
        return(self.wiek)
    def pytanieStudia(self, studia1):
        self.studia = studia1
        return (self.studia)
    def pytanieLubi(self, lubi11,lubi22):
        self.lubi1 = lubi11
        self.lubi2 = lubi22
        return([self.lubi1, self.lubi2])
    def wyswietl(self):
        mojSlownik = {'Imie_Nazwisko': self.nazwisko, 'Wiek': self.wiek, 'Studia_kierunek': self.studia,'Lubi': [self.lubi1, self.lubi2]}
        print(mojSlownik)

# mojaAnkieta = Ankieta()
# mojaAnkieta.wyswietl()
# #mojaAnkieta.nazwisko = 'Kowalska'
# mojaAnkieta.nazwisko = input('Podaj nazwisko: ')
# mojaAnkieta.wiek = 18
# mojaAnkieta.studia = 'Informatyka'
# mojaAnkieta.lubi1 = 'Spacery z psem'
# mojaAnkieta.wyswietl()
# mojaAnkieta.lubi2 = 'Muzyka'
# mojaAnkieta.wyswietl()