diff --git a/.idea/Python2018.iml b/.idea/Python2018.iml new file mode 100644 index 0000000..6711606 --- /dev/null +++ b/.idea/Python2018.iml @@ -0,0 +1,11 @@ + + + + + + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..377499f --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..76bd165 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..94a25f7 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/labs01/podstawy.ipynb b/labs01/podstawy.ipynb index 175783e..1334cf4 100644 --- a/labs01/podstawy.ipynb +++ b/labs01/podstawy.ipynb @@ -28,7 +28,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" diff --git a/labs02/intro_task.py b/labs02/intro_task.py index 92164f5..89f0fa3 100644 --- a/labs02/intro_task.py +++ b/labs02/intro_task.py @@ -9,48 +9,81 @@ Zadania wprowadzające do pierwszych ćwiczeń. """ Wypisz na ekran swoje imię i nazwisko. """ - +print("Swoje imię i nazwisko") """ Oblicz i wypisz na ekran pole koła o promienie 10. Jako PI przyjmij 3.14. """ +pi = 3.14 +r = 10 +pole = pi * (r ** 2) # potega to znak ** a nie ^ + +print("Promień:", r) +print("Liczba pi:", pi) +print("Pole koła:", pole) """ Stwórz zmienną pole_kwadratu i przypisz do liczbę: pole kwadratu o boku 3. """ +bok = 3 +pole_kwadratu = bok ** 2 +print("Pole kwadratu o boku", bok, "wynosi", pole_kwadratu) """ Stwórz 3 elementową listę, która zawiera nazwy 3 Twoich ulubionych owoców. Wynik przypisz do zmiennej `owoce`. """ +owoce = ["japko", "bananas", "arbuzas"] +print(owoce) """ Dodaj do powyższej listy jako nowy element "pomidor". """ +owoce.append("pomidor") +print(owoce) """ Usuń z powyższej listy drugi element. """ - +owoce.pop(1) +print(owoce) """ Rozszerz listę o tablice ['Jabłko', "Gruszka"]. """ +owoce.append(['Jabłko', "Gruszka"]) +print(owoce) """ Wyświetl listę owoce, ale bez pierwszego i ostatniego elementu. """ +print(owoce) +print('Lista bez pierwszego i ostatniego elementu:', owoce[1:-1]) """ Wyświetl co trzeci element z listy owoce. """ +print(owoce) +print('Lista bez pierwszego i ostatniego elementu:', owoce[::3]) """ Stwórz pusty słownik i przypisz go do zmiennej magazyn. """ +magazyn = {} + """ Dodaj do słownika magazyn owoce z listy owoce, tak, aby owoce były kluczami, zaś wartościami były równe 5. """ +magazyn = {"japko" : 5, "arbuzas" : 5, "pomidor": 5, "Jabłko": 5, "Gruszka" : 5} +print("Słownik:", magazyn) +""" +cos tu jest namieszane +magazyn1 = {"japko" : 1, "arbuzas" : 1, "pomidor": 1, "Jabłko": 1, "Gruszka" : 1} +owocetupla = tuple(owoce) +for owoc in owocetupla: + magazyn1(owoc) = 5 +print("Słownik:", magazyn1) +""" diff --git a/labs02/task01.py b/labs02/task01.py index 7c08c56..6c9c8dd 100644 --- a/labs02/task01.py +++ b/labs02/task01.py @@ -6,6 +6,12 @@ Zad 2. Napisz funkcję even_elements zwracającą listę, która zawiera tylko elementy z list o parzystych indeksach. """ +""" +def sum(a,b): + return a+b +""" + + def even_elements(lista): pass diff --git a/labs02/task02.py b/labs02/task02.py index a6d6321..37aa875 100644 --- a/labs02/task02.py +++ b/labs02/task02.py @@ -5,6 +5,18 @@ Napisz funkcję days_in_year zwracającą liczbę dni w roku (365 albo 366). """ + +""" +/400 jest przestepny +/100 nieprzestepny +/4 przestepny + +if y %400==0: TAK +elif y %100==0: NIE +elif y %4==0: TAK +else: NIE +""" + def days_in_year(days): pass diff --git a/labs04/README.md b/labs04/README.md index 24d5a4b..1a06df2 100644 --- a/labs04/README.md +++ b/labs04/README.md @@ -2,32 +2,33 @@ ## Zadania -**ćwiczenie 0** +**ćwiczenie 0** NIE TRZEBA ROBIC!!!! Uruchom programy z katalogu `examples` i zobacz ich kod. Spróbuj odgadnąć, co robią konkretne linie w kodzie. -**ćwiczenie 1** +**ćwiczenie 1** NIE TRZEBA ROBIC!!!! Każdy obiekt w Pythonie na wbudowaną funkcję ``id()``, która zwraca liczbę, która jest unikatowa i stała dla obiektu. Pozwala ona w prosty sposób sprawdzić, który obiekt jest *mutable*a, który *immutable*: jeżeli po wykonaniu operacji, zwracana liczba jest stała, to oznacza, że obiekt jest *mutable*. Sprawdź zachowanie funkcji na obiektach typy: * lista, * napis (string), * liczba zmiennoprzecinkowa. -**ćwiczenie 2** +**ćwiczenie 2** NIE TRZEBA ROBIC!!!! 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)``). -**ćwiczenie 3** +**ćwiczenie 3** NIE TRZEBA ROBIC!!!! 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 obiektu typu JSON. * Wyświetl wartość kursu EUR do PLN. -**ćwiczenie 4** +**ćwiczenie 4** NIE TRZEBA ROBIC!!!! 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. -**ćwiczenie 5** +**ćwiczenie 5** TRZEBA ZROBIĆ JAKO ZADANIE DOMOWE!!! 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ą). +Cwiczenie 5 zrobić do 2.06.2018 nawet do 5 w nocy. \ No newline at end of file diff --git a/notatki/zajecia20180512.py b/notatki/zajecia20180512.py new file mode 100644 index 0000000..392553a --- /dev/null +++ b/notatki/zajecia20180512.py @@ -0,0 +1,214 @@ +# Przedmiot Jezyki skryptowe - Python +# Pierwsze zajecia +# 2018.05.12 + +print('Czesc') +print("Czesc") # nie wolno mieszac typow cudzyslowiow + +# / = dokladny wynik dzielenia +# % = dzielenie modulo - zwróci resztę z dzielenia + +print("Teks1", "Po przecinku drugi txt") +print(12 ** (3+4 % 8 / 9)) +print("Teks1", "Mozna mieszac txt i liczby", 3.1445) +print("Liczby ulamkowe zapisujemy z kropka", 45.456) + +""" +Potrojny cydzysłów - komentarz wielolinijkowy +cos tam +""" + + +""" +Zmienne nie mają typów +cese sensitive +do zmiennej mozna prypisac praktycznie wszystko +""" + +zmienna = "Zmienna" +nic = None +imie_prowadzacego = 'Tomek' +imie2_prowadzacego = "Radek" +zmienna2 = True +zm3 = False + +lucky = 7 +lucky += 8 # wynik => 7+8=15 +lucky = lucky / 3 # dzielenie zawsze zwraca liczbe zmiennoprzecinkową +print(lucky) +print("lucky") # zwróci napis lucky + +print(type(pi)) # wyswietla typ zmiennej +""" +int +float +str +bool +""" + +""" +W pythonie nie ma tablic +Są za to listy +Listy moga przechowywac elementy roznych typow +Indexowanie zaczyna się od 0 +""" + +pusta_lista = [] +oceny = [1,2,3,4,5,6,7] +innalista = [3.14, "napis", 3, ["pi"], oceny,"nie_musi_byc_spacji_pomiedzy_elementmi_listy"] # lista moze zawierac takze inna listę + +""" +W pythonie 3 +Zwraca tzw. iterator +funkcją list tworzy nową listę o wartościach z oryginalnej listy +""" + +ciag_10_elem = list(range(10)) + +# W Python nie ma list wielowymiarowych + +oceny.append(4) # dodanie elementu na końcu listy +oceny.extend([4,4,4]) # też dodaje ale mozna dodac kilka elementow na raz np. listę i wkleje jej wartosci do oryginalnej listy + +oceny.append([4,4,4]) # doda listę +oceny.extend([4,4,4]) # doda wartości listy + +oceny.pop() # usuwa ostatni element listy +oceny.pop(0) # usuwa element zerowy, czyli pierwszy na liście :) +oceny.pop(-1) # usuwa ostatni element +oceny.pop(-3) # usuwa 3 element od konca + +# INDEXOWANIE + +print('pierwszy element:', oceny[0]) # drukuje zerowy element listy +print('pierwszy element:', oceny[-1]) # ostatni element od konca +print('pierwszy element:', oceny[:5]) # zwraca wszystkie elementy, ktore mają element mniejszy od 5 (z indexem 0, 1... 4) +print('pierwszy element:', oceny[-5:]) # 5 ostatnich elementow +print('pierwszy element:', oceny[1:5]) # elementy od id 1,2,3,4 +print('pierwszy element:', oceny[::2]) # od początku do końca co 2gi element, parzyste +# [1::2] pokaz nieparzyste elementy +# [::-1] wypisze całą listę od końca +# [::-2] wypisze co 2gi element od końca + +oceny.sort() # sortuje roznaco +oceny.reverse() # odwaca liste +print("liczba piątek", oceny.count(5)) # liczy ile liczb "5" jest na liście +zm = sorted(oceny) # sortuje do nowej zmiennej zm, efekt ten sam co powyzej +nowa_lista = oceny[:] # bez nawiasu [] nie zadziała +nowa_lista = oceny + [0] +# pomnożyć listę przez listę NIE MOZNA [3,2,1] * [3] +oceny = [3,2,1] * 2 # można mnożyć listę przez liczbę +# sortuje też stringi +# oceny = ['a', 'c'] + [str'0'] ????????????? # zadziała, można to sortować + +# +# PĘTLE +# + +for i in range(5): + print('element:', i) + print('sqr:', i ** 2) +print('>>>>>') + +# "i" TO JEST NORMANA ZMIENNA, JEJ NAZWA MOŻE BYC TOTALNIE DOWOLNA +# po przejściu pętli i ma wartość ostatnie operacji na petli for + + +# NIE WOLNO MIESZAĆ TABULATORA I SPACJI - TO ZŁO I BĘDZIESZ SIĘ ZMAZYC W PIEKLE +# NAJLEPIEJ W KODZIE NIE UŻYWĆ TABULATOR TYLKO SPACJI +# NIE MUSZĄ TO BYĆ 4 SPACJE +# NIEKTORE EDYTORY ZAMIENIAJĄ AUTOMATYCZNIE TAB NA 4 SPACJE + +for i in list(range(5))[::-1] + print(i) + +pass # nie rób nic + +for zmienna in oceny: + pass + + +lista_pusta = [] + +""" +kwadraty=[] +for i in range(10): + kwadraty.append() +nie dokończyłem +""" + +# +# SŁOWNIKI +# + +słownik = {} +# lub dict() +# klucze muszą być unikatowe +s_oceny = {"Justyna" : [5,5,5], "Jan" : [4,3,2}} +s_oceny["Ala"] = [3,4,5] +print(s_oceny.keys()) +print(s_oceny.values()) + + +for osoba in s_oceny: + print(osoba,':', s_oceny[osoba]) + # iterujemy po kluczach slownika + + +for key, value in s_oceny.items(): + print(key,':', value) +# key, value to nie są słowa kluczowe, tylko zwykłe nazwy zmiennych + + +# +# IF... ELIF... ELSE +# + +if warunek: + operacja1 +elif warunek2: + operacja2 + + +if warunek: + operacja1 +else: + operacja2 + +""" +operatory porównnia +== rowne +<= +>= +!= nierówne +""" + + +if "Ala" in s_oceny: + print("Ala jest w grupie") +sprawdza w liscie kluczy w slowniku + + +# +# FUNKCJE +# PRYJMUJE ARGUMNTY, ZWRACA WARTOŚCI +# + +def is_greater_than_5 (x): + if x > 5: + return True # zwraca wartość z funkcji + else: + return False + +if 'dom' in napis: # sparawdza czy dom jest w zmiennej napis + print(True) + +slowa['bardzo','wazna'] +print(' '.join(slowa)) # zlaczenie + +print(text.split(' ')) # podzieli na slowa wg spacji + + + + + diff --git a/notatki/zajecia20180513.py b/notatki/zajecia20180513.py new file mode 100644 index 0000000..a1ee865 --- /dev/null +++ b/notatki/zajecia20180513.py @@ -0,0 +1,290 @@ +# Zajęcia 2018.05.13 +# kod z Podstawy 2.py z moimi notatkami + + +def dwojak(x): + x *= 2 + return x + + +def dwojak2(x): + x = x * 2 + return x + +l = [1, 2, 3] +#ll = l[:] ## l sie nie zmieni +ll = l # l sie zmieni, stworz inna nazwe dla tego samego obiektu; jedne obiekt ma dwie różne nazwy - tak się zachowują obiekty mutable +s = "123" +# lista, slownik, set są mutable, są zawsze przekazywane przez referencje; ale tuple tak nie działają + +# w przypadku tej funkcji dwojak i listy robimy 2 kopie i laczymy w jedna +#dwojak(l) +dwojak(ll) +dwojak(s) + +print(l) +print(s) +print(dwojak(1)) + +# no i gówno wiadomo + +# ## Mutable i Immutable +# +# ### Mutable +# * listy, +# * słowniki, +# * sety, +# * własnoręcznie zdefiniowane klasy. +# +# ### Immutable +# * liczby: inty i floaty, +# * napisy, +# * tuple. + +# ## Nieoczywistości + +# In[11]: + + +def dwojak1(x): x *= 2 + + +def dwojak2(x): + x = x * 2 + print("F:", x) + + +l = [1, 2, 3] +dwojak1(l) +print(l) + +l = [1, 2, 3] +dwojak2(l) +print(l) + +# In[17]: + + +l = [1, 2, 3] +e = l[:] +e.append(4) +print(l) +print(e) + +# In[19]: + + +e = [] +f = [e for i in range(3)] +""" +f = [i * 2 for i in range(3)] # krotszy sposobna tworzenie listy, range(3) = 0,1,2 +lub +f=[] +for i in range(3): + f.append(i * 2) +robia to samo, tylko pierwszy zapis jest krotszy +""" +f[0].append(1) # wez pierwszy element listy i dodaj 1 do listy +print(f) + +# ## To może ``tuple``? +# * stały rozmiar, +# * immutable, +# * mogą być kluczami w słownikach + +# In[25]: + +""" +tuple, krotki - lista, która nie może się zmieniać, nie możemy dodawać elementów do krotki +nawiasy okrągłe +tuple mogą być kluczem w słowniku +listę nie można przekazać jako klucz do słownika +Można zamienic listę na tuple + +t = [1, "napis", "9") +t = tuple(t) # zamienia listę na tuple +print(t) +print(len(t)) +print({t: None}) + +s_oceny = {} +s_ocny[("Jan", "Kowalski)] = 1990 + +Gdy do krotki trzeba jednak coś dodac: +tworzymy nową krotke t i konkatenujemy +t = ("Jan", "Kowalski") + (1990,) # (1990,) oznacza krotke jednoelementowa, musi byc przecinek +print(t) +print(t[-1]) # pokaz ostatni element, indexowanie jest takie samo jak w listach +print(t[:2]) +""" + +# funkcja len - liczba elementów + +t = (1, "napis", []) +t[-1].append(0) +print(t) +print(len(t)) # ilość elementów w liście +print({t: None}) + + +# ## Funkcje cz. 2 + +# In[36]: + + +def suma(*args): + return sum(args) + +""" +chcemy pzekazać funkci dowolna ilość elementów +tu *args jest listą elementów + +funkcja sum jest wbudowana w Pythona +print(sum([1,1,1,1,11]) +""" + +print(suma(1, 2, 3, 4, 5)) + +""" +def greet_me(z): + print("pozdr",z) + +greet_me("Tomek") + + + +def greet_me(z, x="Pozdr"): + print(x,z) + +greet_me("Tomek", "czesc") # czesc nadpisze Pozdr + +greet_me(x="cześć", z="Tomek") + +greet_me("cześć", "Tomek") + +Przydaje się to np. w Pandas, gdy czesc argumanetow chcemy uruchomic z wartosciami domyslnymi, a czesc chcemy zmienic + + +def greet_me(z, x="Pozdr"): + print(x,z) + return x, x*2 + +x1,x2 = greet_me(Czesc","Tomaj") # ilość argumentów musi się zgadzać +x3 = greet_me(Czesc","Tomaj") # tworzy krotkę +print(x1,x2) +print(x3) +""" + +def greet_me(z=None, **kwargs): + if kwargs is not None: + for key, value in kwargs.items(): + print("%s == %s" % (key, value)) + + +greet_me(a=1, b=(3, 4)) + +# +# ## Generatory +# +# In[38]: + +""" +ord - f. ktora zwraca liczbę dla każdego znaku + +def Range(x): + i=0 + while i>") + +plik.close() # musimy zamknac plik + +# In[47]: + + +with open("haslo.txt", 'r') as plik: # drugi sposob otwieraia pliku, popularniejszy + for linia in plik.readlines(): + print(linia) # mogą byc linie przerwy ze względu na znaki końca linii +# print(plik.read()) + +# In[48]: + + +with open("haslo2.txt", 'w') as plik: # w = tryb do zapisu, nadpisujemy go + # w+ = to o dodamy bedzie dodane na sam koniec + + for word in ('corect', 'horse', 'battery', 'staple'): + plik.write(word) + plik.write('\n') +with open("haslo2.txt", 'w+') as plik: + plik.writelines([' '.join(('corect', 'horse', 'battery', 'staple'))]) + +# # Korzystanie z modułów + +# ## Importowanie + +# In[49]: + + +import os +# import pandas as pd # ładuje pandas z alaiasem pd +print(os.name) + +from os import getenv # nie importuje calosc, tylko okreslona funkcje getenv + +print('Nazwa uzytkownika: {}'.format(getenv("USER"))) + +# In[50]: + + +from collections import * # importuje wszystko + +print(Counter("konstantynopolitańczykowianeczka")) # funkcja couner liczy elemeny, np. ila razy jakas litera pojawił się + +import numpy as np + +np.array([[1, 3, 4, 5]], dtype='float32') + +# ## Instalacja +# +# * lokalnie (per użytkownik) lub globalnie +# * pyCharm lub linia komend, np. ``pip install --user flask`` lub ``python -m pip install --user flask`` + +# ## Wczytywanie z klawiatury + +# In[51]: + + +name = input("What's your name?\n") +print("Welcome home, {}.".format(name)) + +# In[ ]: + + +liczby = eval(input("Podaj liczby")) +print(sum(liczby)) +