done

# Conflicts:
#	labs02/test_task.py

README.md

@@ -1,3 +0,0 @@
-Link do arkusza z obecnością:
-
-https://docs.google.com/spreadsheets/d/1TxJSYM-voKJ7siCgtkCS77pSF0l7I-OtzfCrQdq9RtE/edit?usp=sharing

labs02/task01.py

@@ -7,7 +7,8 @@ która zawiera tylko elementy z list o parzystych indeksach.
 """
 
 def even_elements(lista):
-    pass
+    return lista[::2]
+    # moje rozwiązanie
 
 
 def tests(f):

labs02/task02.py

@@ -5,8 +5,18 @@
  Napisz funkcję days_in_year zwracającą liczbę dni w roku (365 albo 366).
 """
 
-def days_in_year(days):
+# moje rozwiązanie
-    pass
+
+def days_in_year(year):
+    if year%4==0 and year%100!=0:
+        return 366
+    elif year%400==0:
+        return 366
+    else:
+        return 365
+
+
+    #pass
 
 def tests(f):
     inputs = [[2015], [2012], [1900], [2400], [1977]]

labs02/task03.py

@@ -11,9 +11,17 @@ litery. (OOV = out of vocabulary) (W pythonie istnieje struktura danych tak
 jak 'set', która przechowuje elementy bez powtórzeń.)
 """
 
+# moje rozwiązanie
 
 def oov(text, vocab):
-    pass
+    _text=text.split(' ')
+#    _vocab=vocab.split(' ')
+    wynik=[]
+    for i in _text:
+        if i not in vocab:
+            wynik.append(i)
+    return wynik
+#pass
 
 
 

labs02/task04.py

@@ -7,7 +7,17 @@ Jeśli podany argument jest mniejszy od 1 powinna być zwracana wartość 0.
 """
 
 def sum_from_one_to_n(n):
-    pass
+    xN=range(1,n+1)
+    xSum = 0
+    if n<1:
+        xSum=0
+    else:
+        for i in xN:
+            xSum += i
+
+    return xSum
+
+#pass
 
 
 def tests(f):

labs02/task05.py

@@ -10,7 +10,11 @@ np. odległość pomiędzy punktami (0, 0, 0) i (3, 4, 0) jest równa 5.
 """
 
 def euclidean_distance(x, y):
-    pass
+    if len(x) != len(y):
+        return 0
+    else:
+        return ((x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2) ** (1 / 2)
+
 
 def tests(f):
     inputs = [[(2.3, 4.3, -7.5), (2.3, 8.5, -7.5)]]

labs02/task06.py

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

labs02/task07.py

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

labs02/task08.py

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

labs02/task09.py

@@ -9,7 +9,16 @@ Np. leet('leet') powinno zwrócić '1337'.
 
 
 def leet_speak(text):
-    pass
+    tekst = ""
+    slownik = {"e": "3", "l": "1", "o": "0", "t": "7"}
+    for i in text:
+        if i in slownik:
+            tekst += slownik[i]
+        else:
+            tekst += i
+    return tekst
+##aa
+
 
 
 def tests(f):

labs02/task10.py

@@ -7,10 +7,16 @@ Napisz funkcję pokemon_speak, która zamienia w podanym napisie co drugą liter
 na wielką. Np. pokemon_speak('pokemon') powinno zwrócić 'PoKeMoN'.
 """
 
+## NIE WIEM CZEMU ŹLE??
 
 def pokemon_speak(text):
-    pass
+    a = ''
-
+    for i in range(len(text)):
+        if i % 2 == 0:
+            a += text[i].upper()
+        else:
+            a += text[i]
+    return a
 
 def tests(f):
     inputs = [['pokemon'], ['do not want'], ['POKEMON']]

labs02/task11.py

@@ -9,7 +9,12 @@ Oba napisy będą składać się wyłacznie z małych liter.
 """
 
 def common_chars(string1, string2):
-    pass
+    cc =[]
+    for i in sorted(string1):
+        if (i in sorted(string2)) and i!=" " and i not in cc:
+            cc.append(i)
+    return cc
+
 
 
 def tests(f):

labs03/z1.py

@@ -0,0 +1,20 @@
+def f(typ):
+    return id(typ)
+
+def tests():
+    lista=[1,2,3]
+    napis='1234'
+    float=1.42
+    id_table_back = [f(lista),f(napis),f(float)]
+    typ = ['lista','napis','liczba zmiennoprzecinkowa']
+    lista.append(5)
+    napis='1234'+'5'
+    float*=2
+    id_table_now = [f(lista), f(napis), f(float)]
+
+    for i in range(len(id_table_back)):
+        if id_table_back[i]==id_table_now[i]:
+            print(typ[i],'jest mutable')
+        else:
+            print(typ[i],'jest immutable')
+tests()

labs03/z2.py

@@ -0,0 +1,12 @@
+def Fibo(n):
+    for i in range(n):
+        if n==0:
+            return 1
+        elif n==1:
+            return 1
+        else:
+            a=Fibo(n-1)
+            a+=Fibo(n-1)
+            return a
+
+print(Fibo(4))

labs03/z3.py

@@ -0,0 +1,12 @@
+import requests
+import json
+
+def script():
+    page='https://api.fixer.io/latest'
+    r=requests.get(page)
+    r.status_code
+    r.encoding
+    r.text
+    data_json=r.json()
+    print(data_json['rates'],data_json['rates'].values())
+script()

labs04/README.md

@@ -4,13 +4,13 @@ Napisz funckję ``is_numeric``, która sprawdzi, czy każdy element z przekazane
 **ć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. 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``.
+ * Klasy pochodna:  ``Recruiter``, która ma dodatkową metodę ``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.
 
 **ć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ę add, która doda 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.

labs04/task01.py

@@ -1,3 +1,12 @@
 #!/usr/bin/env python2
 # -*- coding: utf-8 -*-
 
+lista = [1,1.0,2,3,4.5]
+def is_numeric(n):
+    for i in n:
+        if isinstance(i,int):
+            print("True")
+        if isinstance(i,float):
+            print("False")
+
+print(is_numeric(lista))

labs04/task02.py

@@ -1,3 +1,62 @@
 #!/usr/bin/env python2
 # -*- coding: utf-8 -*-
+class Employee:
+    id_pracownika=1
+    lista_id=[]
+    def __init__(self,imie,nazwisko):
+        self.imie = imie
+        self.nazwisko = nazwisko
+        self.id_pracownika = Employee.id_pracownika
+        Employee.id_pracownika += 1
+        self.lista_id.append(self.id_pracownika)
+
+    def get_id(self):
+        return (self.id_pracownika)
+
+class Recruiter(Employee):
+    def __init__(self, imie, nazwisko):
+
+        Employee.__init__(self,imie,nazwisko)
+        self.recruited = []
+
+    def recruit(self,id_pracownika):
+
+        if id != self.id_pracownika:
+            if id_pracownika in Employee.lista_id:
+                self.recruited.append(id_pracownika)
+            else:
+                print("Nie ma takiego pracownika")
+        else:
+            print("Rekruter nie moze rekrutowac samego siebie")
+
+class Programmer(Recruiter):
+    def __init__(self,imie,nazwisko,rekruter):
+        Recruiter.__init__(self,imie,nazwisko)
+
+    def recruited_by(self):
+        print(f'Osoba {self.imie} {self.nazwisko} zostala zrekrutowana przez rekrutera o ID {Recruiter.id_pracownika}')
+
+
+print('********')
+pracownik1 = Employee('Jan', 'Kowalski')
+print(pracownik1.imie)
+print(pracownik1.nazwisko)
+print(pracownik1.get_id())
+
+print('********')
+
+pracownik2 = Employee('Anna', 'Nowak')
+print(pracownik2.imie)
+print(pracownik2.nazwisko)
+print(pracownik2.get_id())
+
+print('********')
+
+pracownik3 = Programmer('Janusz','Gajos', 1)
+print(pracownik3.imie)
+print(pracownik3.nazwisko)
+print(pracownik3.id_pracownika)
+print(pracownik3.get_id())
+pracownik3.recruited_by()
+
 

labs04/task03.py

@@ -1,3 +1,59 @@
 #!/usr/bin/env python2
 # -*- coding: utf-8 -*-
 
+
+class DimensionError(Exception):
+    """Klasa odpowiadajaca za wyjatek współrzędnych <>3"""
+    def __init__(self, text):
+        self.text = text
+    def __str__(self):
+        return self.text
+
+class Point:
+    """Klasa reprezentująca punkt w 3D"""
+    def __is_numeric(self,n):
+        for i in n:
+            if not (isinstance(i, int) or isinstance(i,float)):
+                return False
+        return True and len(n) > 0
+
+    def __init__(self, xyz):
+        """Konstruktor klasy Point, argument xyz - lista puntkwo w 3D. Warunkiem sa 3 wspolrzedne"""
+        if not self.__is_numeric(xyz):
+            raise DimensionError("Nieprawidlowe wspolrzedne!")
+        if len(xyz) != 3:
+            raise DimensionError("Nieprawidlowa liczba wspolrzednych (<> 3)")
+        self.x = xyz[0]
+        self.y = xyz[1]
+        self.z = xyz[2]
+
+    def to_string(self):
+        """Wypisuje wektor współrzędnych punktu w 3D jako string"""
+        return '[' + ','.join([str(self.x), str(self.y), str(self.z)]) + ']'
+
+    def add(oPoint1, oPoint2):
+        """Metoda statyczna klasy Point. Zwraca sumę współrzędnych danych 2 punktów w 3D
+
+        arg1 - obiekt klasy Punkt
+        arg2 - obiekt klasy Punkt
+        """
+        l1 = [oPoint1.x, oPoint1.y, oPoint1.z]
+        l2 = [oPoint2.x, oPoint2.y, oPoint2.z]
+        nl = [c1+c2 for c1, c2 in zip(l1, l2)]
+        return Point(nl)
+
+    def __len__(self):
+        """Zwraca liczbe wspolrzednych"""
+        return 3
+
+    def __str__(self):
+        """Funkcja string dla klasy Point, wypisuje wspolrzedne punktu jako string"""
+        return self.to_string()
+
+if __name__ == "__main__":
+    pkt1 = Point([4, 8, 12])
+    print('pkt1 =', pkt1)
+    pkt2 = Point([-1, 0, 3])
+    print('pkt2 =', pkt2)
+    pkt3 = Point.add(pkt1, pkt2)
+    print('pkt3 = pkt1 (+) pkt2 = ', pkt3)

labs05/Lab05.ipynb

@@ -33,12 +33,13 @@
    ]
   },
   {
-   "cell_type": "markdown",
+   "cell_type": "heading",
    "metadata": {
     "slideshow": {
      "slide_type": "slide"
     }
    },
+   "level": 2,
    "source": [
     "# Co na dziś?\n",
     " * Dzielenie kodu na pliki\n",
@@ -125,7 +126,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {
     "slideshow": {
      "slide_type": "fragment"

labs05/task00.py

@@ -1,11 +1,15 @@
 #!/usr/bin/env python2
 # -*- coding: utf-8 -*-
 
+"""
+Napisz funkcję ``suma``, która przyjmnie jeden argument: listę liczb i zwróci ich sumę.
+"""
+
 def suma(liczby):
-    pass
+    return sum(liczby)
 
 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 @@
+from task00 import suma
+import sys
+
+def main():
+    arguments=sys.argv[1:]
+    float_arguments=[]
+    for arg in arguments:
+        float_arguments.append(float(arg))
+
+    print(suma(float_arguments))
+
+
+if __name__ == '__main__':
+    main()

labs05/task02.py

@@ -0,0 +1,18 @@
+from task00 import suma
+import sys
+
+def main():
+    arg_list = sys.argv[1:]
+    float_arg_list = []
+    for arg in arg_list:
+        try:
+            float_arg=float(arg)
+            float_arg_list.append(float_arg)
+        except:
+            float_arg_list.append(0)
+
+    print(suma(float_arg_list))
+
+
+if __name__ == '__main__':
+    main()

labs05/task03.py

@@ -0,0 +1,15 @@
+import task00, argparse
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("numbers", nargs="+")
+    args = parser.parse_args()
+    def a_to_f(a):
+        try:
+            return float(a)
+        except:
+            return 0
+    print('%f' % (task00.suma(map(a_to_f, args.numbers))))
+
+if __name__ == '__main__':
+    main()

labs05/task04.py

@@ -1,12 +1,5 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-"""
-Implementacja narzedzia ``wc`` z linuksa (word counter).
-Zwraca liczbę słów, znaków i linii.
-"""
-
 import sys
+import argparse
 
 
 def count_lines(text):
@@ -19,7 +12,7 @@ def count_words(text):
                 for line in text.split('\n')])
 
 def count_chars(text):
-    """ return number of words. """
+    """ return number of characters. """
     return len(text)
 
 def wc(text):
@@ -32,8 +25,30 @@ def wc(text):
 
 def main():
     """ main """
-    print(wc(sys.stdin.read()))
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-l', help="number of lines", action="store_true")
+    parser.add_argument('-w', help="number of words", action="store_true")
+    parser.add_argument('-c', help="number of chars", action="store_true")
+    parser.add_argument('-filename', type=argparse.FileType('r'), default='-', help='filename to read from')
+    args = parser.parse_args()
+
+    if args.filename:
+        lines, words, chars = wc(args.filename.read())
+    elif not sys.stdin.isatty():
+        lines, words, chars = wc(args.stdin.read())
+    else:
+        pass
+
+    if(args.l):
+        print(lines)
+    elif(args.w):
+        print(words)
+    elif(args.c):
+            print(chars)
+    else:
+        print(lines, words, chars)
 
 
 if __name__ == "__main__":
     main()
+

labs06/Pandas.ipynb

@@ -28,7 +28,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {
     "collapsed": true,
     "slideshow": {
@@ -149,7 +149,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {
     "slideshow": {
      "slide_type": "slide"

labs06/task02.py

@@ -1,14 +1,22 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+import pandas as pd
+import statistics
+
 def wczytaj_dane():
-    pass
+    raw_data = pd.read_csv('mieszkania.csv',sep=',')
+    data = pd.DataFrame(raw_data)
+    return data
 
 def most_common_room_number(dane):
-    pass
+    rooms=dane['Rooms']
+    return(int(statistics.mode(rooms)))
 
 def cheapest_flats(dane, n):
-    pass
+    cheapest=pd.DataFrame(dane['Expected'])
+    cheapest.sort=cheapest.sort_values(by=['Expected'])
+    return cheapest.sort[:n]
 
 def find_borough(desc):
     dzielnice = ['Stare Miasto',
@@ -19,23 +27,46 @@ def find_borough(desc):
                  'Winogrady',
                  'Miłostowo',
                  'Dębiec']
-    pass
+    for dzielnica in dzielnice:
+        if desc.find(dzielnica)!=-1:
+            return dzielnica
+    return 'Inne'
 
 
 def add_borough(dane):
-    pass
+    borough_list=[]
+    for data in dane['Location']:
+        borough_list.append(find_borough(data))
+    borough_series = pd.Series(borough_list,name='Borough')
+    dane['Borough']=borough_series
+    return dane
+
 
 def write_plot(dane, filename):
-    pass
+    data = add_borough(dane)
+    plot_data = data.groupby(dane['Borough']).size()
+    plt = plot_data.plot.bar()
+    fig = plt.get_figure()
+    fig.savefig('{}.png'.format(filename))
+    return 0
+
+
 
 def mean_price(dane, room_number):
-    pass
+    data=dane.loc[dane['Rooms'] == room_number]
+    return round(statistics.mean(data['Expected']),2)
 
 def find_13(dane):
-    pass
+    data = add_borough(dane)
+    boroughs = data.loc[data['Floor'] == 13]
+    return set(boroughs['Borough'])
+
 
 def find_best_flats(dane):
-    pass
+    data = add_borough(dane)
+    best_flats = data.loc[(data['Borough'] == 'Winogrady') & (data['Floor'] == 1) & (data['Rooms'] == 3)]
+    return best_flats
+
 
 def main():
     dane = wczytaj_dane()
@@ -45,10 +76,13 @@ 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)))
 
+
+
 if __name__ == "__main__":
     main()