task02 **dodatkowe (labs06) done

.idea/vcs.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+    <mapping directory="" vcs="Git" />
   </component>
 </project>

labs01/podstawy.ipynb

@@ -30,6 +30,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -43,6 +44,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -76,6 +78,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -110,6 +113,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -130,6 +134,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -146,6 +151,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -177,6 +183,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "slide"
     }
@@ -207,6 +214,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -221,6 +229,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -235,6 +244,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -260,6 +270,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -291,6 +302,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -320,6 +332,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -348,6 +361,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -362,6 +376,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -387,6 +402,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -415,6 +431,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -433,6 +450,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -458,6 +476,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -472,6 +491,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -509,6 +529,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -526,6 +547,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -553,6 +575,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -570,6 +593,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -595,13 +619,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {
     "slideshow": {
      "slide_type": "fragment"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Wiadomość\n"
+     ]
+    }
+   ],
    "source": [
     "napis = \"Wiadomość\"\n",
     "print(napis)"
@@ -609,13 +641,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {
     "slideshow": {
      "slide_type": "slide"
     }
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "W 87\n",
+      "i 105\n",
+      "a 97\n",
+      "d 100\n",
+      "o 111\n",
+      "m 109\n",
+      "o 111\n",
+      "ś 347\n",
+      "ć 263\n"
+     ]
+    }
+   ],
    "source": [
     "for znak in napis:\n",
     "    print(znak, ord(znak))"
@@ -625,6 +673,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "slide"
     }
@@ -641,6 +690,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "slide"
     }
@@ -655,6 +705,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }
@@ -669,6 +720,7 @@
    "cell_type": "code",
    "execution_count": null,
    "metadata": {
+    "collapsed": true,
     "slideshow": {
      "slide_type": "fragment"
     }

labs02/task01.py

@@ -7,8 +7,7 @@ która zawiera tylko elementy z list o parzystych indeksach.
 """
 
 def even_elements(lista):
-    pass
+    return(lista[::2])
-
 
 def tests(f):
     inputs = [[[1, 2, 3, 4, 5, 6]], [[]], [[41]]]

labs02/task02.py

@@ -6,7 +6,10 @@
 """
 
 def days_in_year(days):
-    pass
+    if ((days%4 == 0) and (days%100 != 0)) or (days%400 == 0):
+        return (366)
+    else:
+        return (365)
 
 def tests(f):
     inputs = [[2015], [2012], [1900], [2400], [1977]]

labs02/task03.py

@@ -13,7 +13,10 @@ jak 'set', która przechowuje elementy bez powtórzeń.)
 
 
 def oov(text, vocab):
-    pass
+    text = text.split(" ")
+
+    return(set(text) - set(vocab))
+
 
 
 

labs02/task04.py

@@ -7,7 +7,11 @@ Jeśli podany argument jest mniejszy od 1 powinna być zwracana wartość 0.
 """
 
 def sum_from_one_to_n(n):
-    pass
+    if n >= 1:
+        return(sum(range(1,n+1)))
+    if n < 1:
+        return (0)
+
 
 
 def tests(f):

labs02/task05.py

@@ -8,9 +8,11 @@ dwoma punktami przestrzeni trójwymiarowej. Punkty są dane jako
 trzyelementowe listy liczb zmiennoprzecinkowych.
 np. odległość pomiędzy punktami (0, 0, 0) i (3, 4, 0) jest równa 5.
 """
+import math
 
 def euclidean_distance(x, y):
-    pass
+    return(math.sqrt((x[0] - y[0])**2) + math.sqrt((x[1]-y[1])**2))
+
 
 def tests(f):
     inputs = [[(2.3, 4.3, -7.5), (2.3, 8.5, -7.5)]]

labs02/task06.py

@@ -10,7 +10,10 @@ ma być zwracany napis "It's not a Big 'No!'".
 """
 
 def big_no(n):
-    pass
+    if n >=5:
+        return('N' + ('O' * n)+'!')
+    if n <5:
+        return ("It's not a Big 'No!'")
 
 def tests(f):
     inputs = [[5], [6], [2]]

labs02/task07.py

@@ -6,7 +6,11 @@ Napisz funkcję char_sum, która dla zadanego łańcucha zwraca
 sumę kodów ASCII znaków.
 """
 def char_sum(text):
-    pass
+    suma = 0
+    for element in text:
+        suma += ord(element)
+    return(suma)
+
 
 def tests(f):
     inputs = [["this is a string"], ["this is another string"]]

labs02/task08.py

@@ -7,7 +7,11 @@ przez 3 lub 5 mniejszych niż n.
 """
 
 def sum_div35(n):
-    pass
+    suma = 0
+    for i in range(n):
+        if (i%3 == 0 or i%5 == 0):
+            suma += i
+    return (suma)
 
 def tests(f):
     inputs = [[10], [100], [3845]]

labs02/task09.py

@@ -9,7 +9,17 @@ Np. leet('leet') powinno zwrócić '1337'.
 
 
 def leet_speak(text):
-    pass
+    if 'l' in text:
+        text = text.replace('l', '1')
+    if 'e' in text:
+        text = text.replace('e', '3')
+    if 'o' in text:
+        text = text.replace('o', '0')
+    if 't' in text:
+        text = text.replace('t', '7')
+    return (text)
+
+
 
 
 def tests(f):

labs02/task10.py

@@ -7,9 +7,19 @@ Napisz funkcję pokemon_speak, która zamienia w podanym napisie co drugą liter
 na wielką. Np. pokemon_speak('pokemon') powinno zwrócić 'PoKeMoN'.
 """
 
-
 def pokemon_speak(text):
-    pass
+    txtstr= ''
+    if text.isupper():
+        return(text)
+    else:
+        for i in range (len(text)):
+            if (i % 2 == 0):
+                txtstr +=text[i].upper()
+            else:
+                txtstr += text[i]
+        return(txtstr)
+
+
 
 
 def tests(f):

labs02/task11.py

@@ -9,7 +9,20 @@ Oba napisy będą składać się wyłacznie z małych liter.
 """
 
 def common_chars(string1, string2):
+    lista1 = list(string1)
+    lista2 =list(string2)
+    unique_val = set()
+    for i in lista1:
+        for x in lista2:
+            if i == x:
+                if i.isspace():
                     pass
+                else:
+                    unique_val.add(i)
+    lista = list(unique_val)
+    lista.sort()
+    return(lista)
+
 
 
 def tests(f):

labs03/task2.py

@@ -0,0 +1,21 @@
+"""**ćwiczenie 2**
+Napisz generator, który będzie zwracać ``n`` kolejnych liczb ciągu Fibonacciego (``F(0)=1, F(1)=1, FN=F(N-1) + F(N-2)``)."""
+
+def Fibonacci(n):
+
+        x = 0
+        print(x)
+        y = 1
+        print(y)
+        z = 0
+        z = x + y
+        print (z)
+
+        for i in range(2, n):
+            x = y
+            y = z
+            z = x + y
+            print(z)
+
+
+Fibonacci(19)

labs03/task3.py

@@ -0,0 +1,19 @@
+""""**ćwiczenie 3**
+Strona ``https://api.fixer.io/latest`` udostępnia kursy różnych walut w stosunku do euro. Napisz skrypt, który:
+ * pobierze zawartość JSONa. Wykorzystaj bibliotekę ``requests`` (http://docs.python-requests.org/en/master/).
+ * korzystając z biblioteki ``json`` przekształć go do obiketu typu JSON.
+ * Wyświetl wartość kursu EUR do PLN."""
+
+import requests
+
+url = 'https://api.fixer.io/latest'
+
+response = requests.get(url)
+
+content = response.json()
+
+rates = content['rates']
+
+for key , value in rates.items():
+    if key == 'PLN':
+        print (value)

labs03/task4.py

@@ -0,0 +1,121 @@
+"""**ćwiczenie 4**
+Zainstaluj bibliotekę ``weather-api`` (https://pypi.python.org/pypi/weather-api). Korzystając z niej:
+ * Wypisz informacje o aktualnej pogodzie.
+ * Napisz funkcję, która zamieni stopnie ``F`` na ``C``.
+ * Korzystając z prognozy, znajdź dzień, w którym będzie najzimniej.Wypisz nazwę tygodnia (w języku polskim) i temperaturę w C."""
+
+from weather import Weather
+
+weather = Weather()
+
+miasto ='Gdynia'
+location = weather.lookup_by_location(miasto)
+
+condition = location.condition()
+
+data = condition.date()
+dzien_slownie = data[0:3]
+dzien = data[5:7]
+miesiac = data[8:11]
+rok = data[12:16]
+
+def day_to_dzien_conv(n):
+    if n == 'Mon':
+        n = n.replace('Mon','Poniedzialek')
+        return n
+    if n == 'Tue':
+        n = n.replace('Tue', 'Wtorek')
+        return n
+    if n == 'Wed':
+        n = n.replace('Wed', 'Sroda')
+        return n
+    if n== "Thu":
+        n = n.replace('Thu','Czwartek')
+        return n
+    if n == 'Fri':
+        n = n.replace('Fri', 'Piątek')
+        return n
+    if n == 'Sat':
+        n = n.replace('Sat', 'Sobota')
+        return n
+    if n == 'Sun':
+        n = n.replace('Sun', 'Niedziela')
+        return n
+
+dzien_slownie = day_to_dzien_conv(dzien_slownie)
+
+
+def month_to_miesiac_conv(z):
+    if z == 'Jan':
+        z = z.replace('Jan','Styczen')
+        return z
+    if z == 'Feb':
+        z = z.replace('Feb', 'Luty')
+        return z
+    if z == 'Mar':
+        z = z.replace('Mar', 'Marzec')
+        return z
+    if z== "Apr":
+        z = z.replace('Apr','Kwiecien')
+        return z
+    if z == 'May':
+        z = z.replace('May', 'Maj')
+        return z
+    if z == 'Jun':
+        z = z.replace('Jun', 'Czerwiec')
+        return z
+    if z == 'Jul':
+        z = z.replace('Jul', 'Lipiec')
+        return z
+    if z == 'Aug':
+        z = z.replace('Aug', 'Sierpien')
+        return z
+    if z == 'Sep':
+        z = z.replace('Sep', 'Wrzesien')
+        return z
+    if z == 'Oct':
+        z = z.replace('Oct', 'Pazdziernik')
+        return z
+    if z == 'Nov':
+        z = z.replace('Nov', 'Listopad')
+        return z
+    if z == 'Dec':
+        z = z.replace('Dec', 'Grudzien')
+        return z
+
+miesiac = month_to_miesiac_conv(miesiac)
+
+print(f"Aktualna pogoda w mieście: {miasto}")
+print(f'Data: {dzien_slownie}, {dzien}-{miesiac}-{rok}')
+print(f'Warunki (ang.): {condition.text()}')
+
+fahrenhait = condition.temp()
+
+def temp_conversion(fahrenhait):
+    celsius = round(((int(fahrenhait) - 32) * 5/9),1)
+    return (f'Temperatura: {celsius} C')
+
+print(temp_conversion(fahrenhait))
+
+temp_min  = []
+date_temp_min = []
+
+forecasts = location.forecast()
+for forecast in forecasts:
+    temp_min.append(forecast.low())
+    date_temp_min.append(forecast.date())
+
+minimum = min(temp_min)
+indeks = temp_min.index(minimum)
+data_miminum = date_temp_min.pop(indeks)
+
+
+dzien_przew = data_miminum[0:2]
+miesiac_przew = data_miminum[3:6]
+rok_przew = data_miminum[7:11]
+
+miesiac_przew = month_to_miesiac_conv(miesiac_przew)
+
+print(f'Przewidywalna minimalna {temp_conversion(minimum)} nastąpi dnia {dzien_przew}-{miesiac_przew}-{rok_przew}')
+
+

labs03/task5.py

@@ -0,0 +1,39 @@
+"""**ćwiczenie 5**
+Katalog scores zawiera 64 pliki tekstowe, które posiadają informacje o wysokości miary ``BLEU``
+ na różnych etapach trenowania modelu. Nazwa każdego pliku na postać  ``model.iterXXXXXXX.npz.bleu``,
+  gdzie ``XXXXXXX``, to liczba iteracji.Zawartość każdego pliku jest podobna i ma następującą formę:
+   *BLEU = YY.YY, 44.4/18.5/9.3/5.0 (BP=1.000, ratio=1.072, hyp_len=45976, ref_len=42903)*,
+   gdzie ``YY.YY`` to wartość miary ``BLEU``. Znajdź plik, który zawiera najwyższą wartość miary ``BLEU``.
+ * Wykorzystaj bibliotekę ``glob`` (https://docs.python.org/2/library/glob.html)
+ * Wyświetl tylko pełną nazwe pliku (wraz z ścieżką).
+"""
+
+import glob
+import os
+
+path = '\scores'
+path = os.getcwd()+ path
+
+file_list = glob.glob(path+'\*npz.bleu')
+
+list_all = []
+#key_list = []
+value_list =[]
+
+for file in file_list:
+    with open(file, 'r') as f:
+        linijki = f.readlines()
+        for line in linijki:
+            list_all.append(line)
+
+for i in list_all:
+    i = i.split(',')
+    #a = i[0][0:4]
+    b = i[0][7:]
+    b = float(b)
+    #key_list.append(a)
+    value_list.append(b)
+
+max_bleau = (max(value_list))
+index_max_bleu = value_list.index(max_bleau)
+print(file_list[index_max_bleu])

labs04/task01.py

@@ -1,3 +1,16 @@
 #!/usr/bin/env python2
 # -*- coding: utf-8 -*-
+#**ćwiczenie 1**
+#Napisz funckję ``is_numeric``, która sprawdzi, czy każdy element z przekazanej listy jest typu int lub float. Wykorzystaj funcję ``isinstance()`` (https://docs.python.org/2/library/functions.html#isinstance).
 
+
+def is_numeric(x):
+
+    for i in x:
+        if (isinstance(i, (int, float)) == True):
+            return True
+        else:
+            return False
+
+
+print(is_numeric([5.62,7,8]))

labs04/task02.py

@@ -1,3 +1,91 @@
 #!/usr/bin/env python2
 # -*- coding: utf-8 -*-
 
+#**ćwiczenie 2**
+#Napisz prostą hierarchię klas:
+# * Klasa bazowa ``Employee``, która będzie zawierać informacje o imieniu i nazwisku pracownika. Ponadto każdy pracownik otrzyma numer ``id``, który będzie unikatowy - atrybut statyczny - counter.
+#Wykorzystaj do tego atrybut statyczny. Napisz metodę ``get_id``, która zwraca identyfikator pracownika.
+# * Klasy pochodna:  ``Recruiter``, która ma dodatkową mtodę ``recruit``, która jako parament przyjmuje obiekt ``Employee`` i zapisuje jego ``id`` w liście ``self.recruited``.
+# * Klasa pochodna ``Programmer``. Klasa ``Programmer`` ma przyjąć w konstruktorze podstawowe informacje (imię i nazwisko) oraz obiekt rekturera. Ponadto stwórz  atrybut ``recruiter``, który będzie przechowywać ``id`` rekrutera.
+
+
+class Employee(object):
+    id = 0
+    lista_id = []
+
+    def __init__(self, name, surname):
+        self.name = name
+        self.surname = surname
+        self.id = Employee.id
+        Employee.id += 1
+        self.lista_id.append(self.id)
+
+    def get_id(self):
+        return(self.id)
+
+
+class Recruiter(Employee):
+    def __init__(self, name, surname):
+
+        Employee.__init__(self, name, surname)
+
+        self.recruited = []
+
+    def recruit(self, id):
+
+        if id != self.id:
+            if id in Employee.lista_id:
+                self.recruited.append(id)
+            else:
+                print('Nie ma takiego pracownika!')
+        else:
+            print('Rekruter nie może zrekrutować samego siebie!')
+
+    def __str__(self):
+        return (f'Rekruter {self.name} {self.surname} zrekrutowal pracownikow o nastepujacych id: {self.recruited}')
+
+
+class Programmer(Recruiter):
+    def __init__(self, name, surname, recruiter):
+        Recruiter.__init__(self, name, surname)
+
+        Recruiter.id = recruiter
+
+    def recruited_by_who(self):
+        print (f'Programista {self.name} {self.surname} zostal zrekrutowany przez rekrutera o nastepujacym id: {Recruiter.id}')
+
+
+
+print('-------------------------')
+pracownik1 = Employee('Stefan', 'Stefanski')
+print(pracownik1.name)
+print(pracownik1.surname)
+print(pracownik1.get_id())
+print(pracownik1.id)
+pracownik2 = Employee('Karol', 'Karolinski')
+print(pracownik2.name)
+print(pracownik2.surname)
+print(pracownik2.get_id())
+print(pracownik2.id)
+pracownik3 =Recruiter('Kasia', 'Kasinska')
+print(pracownik3.name)
+print(pracownik3.surname)
+print(pracownik3.id)
+pracownik3.recruit(5)
+pracownik3.recruit(0)
+pracownik3.recruit(1)
+
+print(pracownik3)
+
+pracownik4 = Programmer('Bozena','Bozeniasta', 2)
+print(pracownik4.name)
+print(pracownik4.surname)
+print(pracownik4.id)
+print(pracownik4.get_id())
+pracownik4.recruited_by_who()
+
+print('-------------------------')
+print(Employee.id)
+
+print(Employee.lista_id)
+print('-------------------------')

labs04/task03.py

@@ -1,3 +1,111 @@
 #!/usr/bin/env python2
 # -*- coding: utf-8 -*-
 
+""""**ćwiczenie 3 (zadanie domowe) **
+Stwórz klasę ``Point``, która będzie reprezentować punkt w przestrzeni wielowymiarowej:
+ * Konstruktor ma przyjąc tylko 1 parametr: listę współrzednych. Wykorzystaj funkcję z pierwszego zadania, żeby sprawdzić, czy lista zawiera wyłącznie liczby.
+ * Napisz metodę add, która dida dwa punkty po współrzędnych i zwróci obiekt typu ``Punkt``. Zaimplementuj własny wyjątek ``DimensionError``, który zostaje wyrzucony, jeżeli dodawany punkt ma inny wymiar.
+ * Napisz metodę ``to\_string``, która zwróci łancuch znakowy, który w czytelny sposób przedstawi punkt.
+ * Napisz metodę __len__, która zwróci liczbę współrzędnych punktu. Zobacz, czy możesz teraz wywołać funkcję len na obiekcie typy punkt.
+ * Napisz metodę __str__, która bedzie działać dokładnie tak samo jak metoda ``to_string``. Wyświetl obiekt typy Point korzystając z funkcji print."""
+
+
+class DimensionError(Exception):
+    """Klasa wyjątku, który zostaje wyrzucony, jeżeli dodawany punkt ma inny wymiar niż 3."""
+    pass
+
+
+def is_numeric(x):
+    """funkcja sprawdzajca czy każdy element z przekazanej listy zawiera tylko liczby"""
+    for i in x:
+        if (isinstance(i, (int, float)) == True):
+            return True
+        else:
+            return False
+
+
+
+class Point(object):
+    """Klasa reprezentujaca punkt"""
+    lista_pktow = []
+
+    def __init__(self, coordinates=list):
+        """Inicjalizator punktu przyjmuje jako parametr 3-elementowa liste koordynatow"""
+        if isinstance(coordinates, list):
+            if len(coordinates) == 3:
+                if not is_numeric(coordinates):
+                    #jesli koordynaty nie zawieraja wartosci liczbowych zostaje wyrzucony wyjatek
+                    raise Exception('Lista zawiera wartosci nieliczbowe')
+
+                else:
+                    #atrybuty klasy Punkt: coordinates (lista wspolrzednych [x,y,z]); x ; y; z
+                    self.coordinates = coordinates
+                    self.x = coordinates[0]
+                    self.y = coordinates[1]
+                    self.z = coordinates[2]
+                self.lista_pktow.append(self.coordinates)
+            else:
+                # jesli punkt ma inny wymiar zostaje wyrzucony wyjatek
+                raise DimensionError('Wspolrzedne musza miec 3 wymiary!')
+
+        else:
+            print('parametrem musi byc lista!')
+
+    def add(punkt1, punkt2):
+        """metoda add dodaje wspolrzedne obiektow typu punkt i dodaje nowy obiekt punkt"""
+        punkt3 = []
+        if not isinstance(punkt1, Point):
+            if not isinstance(punkt2, Point):
+                #jesli parametry metody add nie sa obiektami typu punkt zostaje wyrzucony komunikat
+                print('zly typ parametru! - parametrem musi byc obiekt typu Punkt')
+            else:
+                print('zly typ parametru! - parametrem musi byc obiekt typu Punkt')
+        else:
+            if punkt1.coordinates and punkt2.coordinates in Point.lista_pktow:
+                #jesli parametry metody add sa obiektami typu punkt - wspolrzedne x,y,z sa sumowane i zostaje zwracany nowy obiekt typu punkt
+
+                punkt3.append(punkt1.x+punkt2.x)
+                punkt3.append(punkt1.y+punkt2.y)
+                punkt3.append(punkt1.z+punkt2.z)
+                return Point(punkt3)
+
+            else:
+                print('Nie ma takich punktow!')
+
+    def __len__(self):
+        """metoda len zwraca liczbe wspolrzednych - zawsze bedzie 3 bo tak zostalo zdefiniowane w inicjalizatorze"""
+        return len(self.coordinates)
+
+    def to_string(self):
+        """metoda to_strng przedstawia wspolrzedne w czytelnej postaci"""
+        return (f'Koordynaty punktu: [{self.x}, {self.y}, {self.z}]')
+
+    def __str__(self):
+        """Wyświetla obiekt typy Point korzystając z funkcji print"""
+        return self.to_string()
+
+
+
+print('-------')
+punkta = Point([1,5,6])
+print(punkta.coordinates)
+print(Point.lista_pktow)
+punktb =Point([1,-3,-2])
+print(punktb.coordinates)
+print(Point.lista_pktow)
+
+print(punkta.__len__())
+print(punkta.z)
+print('-------')
+punkt3 = Point.add(punkta,punktb)
+print(punkt3.coordinates)
+print(punkt3.z)
+print(Point.add(punkta,punktb))
+print('-------')
+
+print(Point.lista_pktow)
+
+print(punkta.to_string())
+print(punktb)
+print(punkta)
+

labs05/task00.py

@@ -1,11 +1,28 @@
-#!/usr/bin/env python2
+"""** zad. 0 **
+Napisz funkcję ``suma``, która przyjmnie jeden argument: listę liczb i zwróci ich sumę.
+
+zad.2 Uodpornoj program z zad. 1 w następujący sposób: do programu mogą zostać przekazane argumenty,
+które nie mają wartości liczbowej (przyjmijmy, że ich wartość to 0).
+Skorzystaj z mechanizmu wyjątków: złap wyjątek, jeżeli argumenty nie da się skonwertować 
+na liczbę zmiennoprzecinkową."""
+
+
 # -*- coding: utf-8 -*-
 
 def suma(liczby):
-    pass
+    wynik = 0
+    for i in range(len(liczby)):
+        try:
+            wynik += float(liczby[i])
+        except:
+            wynik += 0
+    return wynik
 
 def main():
-    print(summa([1, 2, 3, 4]))
+    print(suma([1, 2, 3, 4]))
 
 if __name__ == "__main__":
     main()
+
+
+

labs05/task01.py

@@ -0,0 +1,14 @@
+""""** zad. 1 **
+Zaimportuj z zadania 0 fukcje ``suma``. Korzystając z tej fukcji i tablicy ``sys.argv``
+oblicz i wyświetl sumę argumentów, jakie zostały przekazane do programu.
+Załóź, że argumentami do programu będą tylko liczby zmiennoprzecinkowe."""
+
+
+import task00
+import sys
+
+def main():
+    print(task00.suma(sys.argv[1:]))
+
+if __name__ == "__main__":
+    main()

labs05/task02.py

@@ -0,0 +1,16 @@
+
+"""* zad. 2 **
+Uodpornoj program z zad. 1 w następujący sposób: do programu mogą zostać przekazane argumenty,
+które nie mają wartości liczbowej (przyjmijmy, że ich wartość to 0).
+Skorzystaj z mechanizmu wyjątków: złap wyjątek, jeżeli argumenty nie da się skonwertować na
+liczbę zmiennoprzecinkową."""
+
+import task00
+import sys
+
+def main():
+    print(task00.suma(sys.argv[1:]))
+    #print(task00.suma(['blabla',35.42,24.5]))
+
+if __name__ == "__main__":
+    main()

labs05/task03.py

@@ -0,0 +1,23 @@
+"""** zad. 3 **
+Przekształć rozwiązanie zadania drugiego w taki sposob, żeby korzystało z biblioteki ``argparse``
+zamiast z z listy ``sys.argv``."""
+
+import task00
+import argparse
+import sys
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("float", help="liczby zmiennoprzecinkowe", nargs = '+')
+    args = parser.parse_args()
+
+    liczby = args.float
+
+    print(task00.suma(liczby))
+
+    # print(task00.suma(sys.argv[1:]))
+
+if __name__ == "__main__":
+    main()
+

labs05/task04.py

@@ -7,6 +7,7 @@ Zwraca liczbę słów, znaków i linii.
 """
 
 import sys
+import argparse
 
 
 def count_lines(text):
@@ -32,7 +33,32 @@ def wc(text):
 
 def main():
     """ main """
-    print(wc(sys.stdin.read()))
+    #print(wc(sys.stdin.read()))
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--l", help="liczba linii", action = 'store_true')
+    parser.add_argument("--w", help="liczba slow", action = 'store_true')
+    parser.add_argument("--c", help="liczba znakow", action = 'store_true')
+    parser.add_argument("file", help="sciezka do pliku", type = argparse.FileType('r'), nargs = '?')
+    args = parser.parse_args()
+
+
+    if args.file is None:
+        fh_lines = sys.stdin.read()
+    else:
+        fh_lines = args.file.read()
+
+    if args.l:
+        output = count_lines(fh_lines)
+    elif args.w:
+        output = count_words(fh_lines)
+    elif args.c:
+        output = count_chars(fh_lines)
+    elif not (args.l and args.w and args.c):
+        output = wc(fh_lines)
+
+    print(output)
+
 
 
 if __name__ == "__main__":

labs06/model.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+"""*(dodatkowe)*: Korzystając z pakietu *sklearn* zbuduj model regresji liniowej,
+która będzie wyznaczać cenę mieszkania na podstawie wielkości mieszkania i liczby pokoi."""
+
+#import bibliotek
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import sklearn
+from sklearn import linear_model
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import mean_squared_error
+import math
+
+#wczytanie danych
+dane = pd.read_csv('mieszkania.csv', sep = ',', encoding = 'utf-8')
+dane = pd.DataFrame(dane)
+
+#analiza korelacji
+print(dane.corr())
+#korelacja niewielka dodatnia pomiedzy SqrMeters, a Expected = 0.109640
+#korelacja niewielka dodatnia pomiedzy Rooms, a Expected = 0.081177
+#niska korelaje pokazuje wykres rozrzutu
+dane.plot.scatter(x='SqrMeters', y='Expected')
+plt.show()
+
+#data preparation
+#X -independent variables
+#Y -dependent variable
+
+X = dane[['SqrMeters', 'Rooms' ]]
+X= pd.DataFrame(X)
+
+Y = dane['Expected']
+
+#splitting data into a training and test set:
+X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.20, random_state=1)
+
+#train LinearRegression model using the training set of data
+lm = linear_model.LinearRegression()
+lm.fit(X_train, Y_train)
+
+# coefficients of the model
+for idx, col_name in enumerate(X_train.columns):
+    print("The coefficient for {} is {}".format(col_name, lm.coef_[idx]))
+
+# intercept of the model
+intercept = lm.intercept_
+print("The intercept for our model is {}".format(intercept))
+
+#linear model : 123969.05-34261.86*X1+5299.47*X2
+
+#R^2 proportion of variability in Y that is explained by X in model =  accuracy of regression models
+#It seems that 0.78% of the variability in Y can be explained using X
+print(lm.score(X_test, Y_test))
+
+#predykcja
+#comparing the prediction for the test data set (data not used for training) with the ground truth for the data test set
+y_predict = lm.predict(X_test)
+
+lm_mse = mean_squared_error(y_predict, Y_test)
+
+#It seems that we are an average of 1148825.67 away from the ground truth when making predictions on our test set.
+print(lm_mse)
+print(math.sqrt(lm_mse))
+
+print('--------')
+#print(X_test['SqrMeters'])
+#linear model plot - how our model plots against our test data.
+plt.scatter(X_test['SqrMeters'], Y_test,  color='black')
+plt.plot(X_test['SqrMeters'], y_predict, color='blue', linewidth=2)
+
+plt.scatter(X_test['SqrMeters'], Y_test,  color='black')
+plt.plot(X_test['SqrMeters'], y_predict, color='blue', linewidth=2)
+
+plt.xticks(())
+plt.yticks(())
+
+plt.show()
+
+#prediction using made up data
+# SqrMeters:45
+# Rooms: 3
+print(lm.predict([[45, 3]]))
+# Expected price:  259659.47

labs06/task02.py

@@ -1,16 +1,45 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import scipy.stats as stats
+import sklearn
+from sklearn import linear_model
+
+
 def wczytaj_dane():
-    pass
+    """Napisz funkcje, która wczyta zestaw danych z pliku *mieszkania.csv* i zwróci obiekt typu *DataFrame*.
+    Jeżeli wszystko zostało zrobione poprawnie,powinno się wyśtwietlić 5 pierwszych wierszy."""
+
+    flat_data = pd.read_csv('mieszkania.csv', sep = ',', encoding = 'utf-8')
+    flat_data = pd.DataFrame(flat_data)
+
+    return flat_data
 
 def most_common_room_number(dane):
-    pass
+    """Uzupełnij funkcję ``most_common_room_number``, która zwróci jaka jest najpopularniejsza liczba pokoi w ogłoszeniach.
+ Funkcji powinna zwrócić liczbę całkowitą."""
+
+    pokoje = dane['Rooms']
+    return(pokoje.value_counts(sort=True).index[0])
 
 def cheapest_flats(dane, n):
-    pass
+    """Uzupełnij kod w funkcji ``cheapest_flats(dane, n)``, która wzróci *n* najtańszych ofert mieszkań.
+ Wzrócony obiekt typu ``DataFrame``"""
+
+    posortowane = dane.sort_values(by='Expected')
+    ceny = posortowane['Expected']
+    return(ceny.head(n).to_frame())
+
 
 def find_borough(desc):
+    """Napisz funkcje ``find_borough(desc)``, która przyjmuje 1 argument typu *string*
+ i zwróci jedną z dzielnic zdefiniowaną w liście ``dzielnice``.
+ Funkcja ma zwrócić pierwszą (wzgledem kolejności) nazwę dzielnicy, która jest zawarta w ``desc``.
+ Jeżeli żadna nazwa nie została odnaleziona, zwróć *Inne*."""
+
     dzielnice = ['Stare Miasto',
                  'Wilda',
                  'Jeżyce',
@@ -19,23 +48,69 @@ def find_borough(desc):
                  'Winogrady',
                  'Miłostowo',
                  'Dębiec']
-    pass
+    for i in dzielnice:
+        if i in desc:
+            return(i)
+
+    return 'Inne'
 
 
 def add_borough(dane):
-    pass
+    """Dodaj kolumnę ``Borough``, która będzie zawierać informacje o dzielnicach i powstanie z kolumny ``Localization``.
+ Wykorzystaj do tego funkcję ``find_borough``"""
+
+    lokacja= dane['Location']
+    dzielnice = []
+    for rekord in dane['Location']:
+        new_col = find_borough(rekord)
+        dzielnice.append(new_col)
+
+    dane['Borough'] = dzielnice
+
 
 def write_plot(dane, filename):
-    pass
+    """Uzupełnił funkcje ``write_plot``, która zapisze do pliku ``filename`` wykres słupkowy przedstawiający liczbę ogłoszeń
+ mieszkań z podziałem na dzielnice."""
+
+    add_borough(dane)
+    hist_data = dane['Borough'].value_counts()
+    #plt.figure()
+
+    wyplot = hist_data.plot(kind='bar',alpha=0.5, title="Liczba ogłoszeń mieszkań z podziałem na dzielnice", fontsize=5, figsize=(7, 5))
+    wyplot.set_xlabel("Dzielnice")
+    wyplot.set_ylabel("Liczba ogłoszeń")
+
+    #plt.show()
+
+    fig = wyplot.get_figure()
+    fig.savefig(filename)
+
 
 def mean_price(dane, room_number):
-    pass
+    """Napisz funkcje ``mean_price``, która zwróci średnią cenę mieszkania ``room_numer``-pokojowego."""
+
+    pokoj = dane.loc[dane['Rooms'] == room_number]
+    return(pokoj['Expected'].agg('mean'))
+
 
 def find_13(dane):
-    pass
+    """Uzupełnij funkcje ``find_13``, która zwróci listę dzielnic, które zawierają ofertę mieszkanie na 13 piętrze."""
+
+    add_borough(dane)
+    lista13pietra = []
+    finded = dane['Borough'].loc[dane['Floor'] == 13]
+    for j in finded:
+        lista13pietra.append(j)
+    return lista13pietra
 
 def find_best_flats(dane):
-    pass
+    """Napisz funkcje ``find_best_flats``, która zwróci wszystkie ogłoszenia mieszkań, które znajdują się na Winogradach,
+  mają 3 pokoje i są położone na 1 piętrze."""
+
+    add_borough(dane)
+    finded_best = dane.loc[(dane['Floor'] == 1) & (dane['Rooms'] == 3) & (dane['Borough'] == 'Winogrady')]
+    return finded_best
+
 
 def main():
     dane = wczytaj_dane()
@@ -45,10 +120,26 @@ def main():
           .format(most_common_room_number(dane)))
 
     print("{} to najłądniejsza dzielnica w Poznaniu."
-          .format(find_borough("Grunwald i Jeżyce"))))
+          .format(find_borough("Grunwald i Jeżyce")))
 
     print("Średnia cena mieszkania 3-pokojowego, to: {}"
           .format(mean_price(dane, 3)))
 
+    find_borough("Grunwald i Jeżyce")
+
+    print(cheapest_flats(dane, 5))
+
+    print(add_borough(dane))
+
+    write_plot(dane, 'liczbaogloszen.png')
+
+    print(mean_price(dane, 7))
+
+    print(find_13(dane))
+
+    print(find_best_flats(dane))
+
+
+
 if __name__ == "__main__":
     main()