Lekcja 1. Wprowadzenie 23.09.2024

Python - przystępny, czytelny, bogaty w gotowce, szybko się w nim tworzy
nie jest szybki w liczeniu, ale szybki się w nim pisze

Do czego można używać Pythona?

Python jest dobry do:

• do rozwoju
• analiza preferencji danych, analiza danych
• inżynieria danych
• procesy decyzyjne (budowanie algorytmów)
• "klej" do łączenia aplikacji
• automatyzacja (DevOps, skrypty)
• uczenie maszynowe/AI (aby lepiej ocenić grupy docelowy/dobrać marketing)
• back-end aplikacji internetowych
• web scraping - sczytywanie danych ze stron internetowych

Python jest ok do:

• aplikacje na komputery stacjonarne (excel niekoniecznie)
• programowanie mini kontrolerów (które sterują maszynami) - mini Python jako podwersja pythona stworzona specjalnie do tego
• niektórych aplikacji mobilnych

Nie sprawdzi się do:

• aplikacji mobilnych i systemowych
• gier
• front-endu

Podział strony internetowej - front-end (to co widzi użytkownik) / back-end (to co widzi twórca)
Python podaje front-endowi dane, które mają go zbudować

Ansible - aplikacja do zarządzania … napisana w Pythonie

Cel języka - komunikacja, wyrażanie emocji, opisanie stanu/właściwości danego obiektu,
Cel język programowania - poinstruowanie komputera jak coś wykonać, opisanie obiektu (ten przedmioty w sklepie jest niedostępny), ustawienie jego cechy

Język naturalny - cel - jęz. programowania

• czasownik - opisanie czynności - funkcja/metoda
• rzeczownik - nazwanie rzeczy - obiekt/zmienna
• przymiotnik - określenie cechy - wartość atrybutu

Język programowania jest wyczulony na gramatykę/kolejność/poprawność - bo nie umieją się domyślić, wyciągnąć z kontekstu
Trzeba układać w odpowiedniej kolejności

Python jest wyczulony na wcięcia w tekście - linijki tekstu umieszczone na tym samym poziomie wcięcia rozpatruje jako bloki, kute trzeba traktować wspólnie

Podstawowa struktura zdania:

funkcja ( ciało funkcji ) = print(mojazmienna)

Lekcja 2 25/09/2024

ZMIENNE - "etykietka" naklejana na wartość/zbiór wartości, która umożliwia nam szybkie jej odnalezienie
Jedna wartość może mieć dwie etykietki
Zawartość zmiennej można zmieniać
WSZYSTKIE ZMIENNE (W NAZWIASIE, W CUDZYSŁOWIE) MOGĄ ZAWIERAĆ POLSKIE ZNAKI, SPACJE, WSZYSTKO

liczby = zmienna niemodyfikowalna
zbiór liczb = modyfikowalna

Jeśli zmienna jest niemodyfikowalna to gdy przeklejamy etykietę oryginalny obiekt pozostaje bez zmian. jeśli ma na sobie inne etykiety to pozostaje w pamięci komputera, jeśli nie - automatycznie się usuwa
jest zmienna jest modyfikowalna i nie zrobimy jej kopii - jej zawartość się zmieni

DEKLAROWANIE ZMIENNYCH: nazwa = zawartość moj_zwierzak = "pies"

nazwa nie powinna zawierać polskich znaków i znaków specjalnych np. spacja. nie może składać się wyłącznie z cyfr lub zaczynać od nich
nazwy zmiennych piszemy małą literą, jeśli składają się z 2+ słów, oddzielamy je podłogą _

FUNKCJA INPUT nazwa_zmiennej = input("opcjonalna instrukcja dla użytkownika") - umożliwia użytkownikowi dodanie zmiennej
W Inpucie, jeśli użytkownik wprowadzi liczbę - będzie ona automatycznie odczytana jako tekst. jeśli chcemy aby była widoczna jako liczba, musimy to ustawić:

              wprowadz_liczba=input("wprowadz liczbe calkowita: ")
              liczba_konwersja = int(wprowadz_liczba)

ALBO
wprowadz_liczba=int(input("wprowadz liczbe calkowita: ")
print(wprowadz_liczba)

ALGORYTMY - sposoby rozwiązania problemu (przepis na pizze to algorytm zrobienia pizzy)

TYPY - grupujemy podobne do siebie rzeczy w kategorie. Są od siebie inne, ale mają cechy wspólne (wśród ssaków znajdziemy delfiny i myszy)

• teksty (string) - zawsze w cudzysłowiu, podwójny lub pojedynczy jeśli w środku też chcemy użyć cudzysłowie tekst = "mój tekst" tekst2 = '"lubię szpinak"'
• liczby całkowite (integer / skrót: int) - zmiana tekstu na liczbę opisana wyżej
• liczby z ułamkiem dzisiętnym/liczby zmiennoprzecinkowe (float) - zawsze kropka, nie przecinek
• wartości logiczne True/False (bool) - True false zawsze z dużej litery, inaczej Python nie wie o co chodzi

Na TYPACH można wykonywać dodawanie+, odejmowanie-, mnożenie*, dzielenie/, modulo% czyli reszta z dzielenia
dodawanie i mnożenie można robić na znakach i liczbach ("Hej"*3 = HejHejHej), resztę tylko na liczbach

WPROWADZANIE TESKTU WIELOWIERSZOWEGO: (w przykładzie pierwszym jeśli dodamy spację przed/po \n to dodadzą się do tekstu)
tekst = "pierwsza linijka.\nDruga linijka.\nTrzecia linijka."

ALBO

tekst="""Pierwsza linijka
Druga linijka
Trzecia linijka"""

pojemniki - lista, krotka, słownik, set. można tworzyć własne typy i struktury danych

f -> Fstring -> w nawiasach klamrowych. Pozwala wrzucić w tekst wartość liczbową zamiast dodawać wszystko ręcznie

		zamiast: (print(str(km)+ " km to " +str(mile) + " w milach"))

      	  	otrzymujemy:         print(f"{km} km to {mile} w milach")
                               ...{mile:0.2f}... -> pokaże wynik z dwoma liczbami po przecinku

Przykład:
km = float(input("wprowadź odległość w km: "))
PRZELICZNIK = 0.621371
mile = km*PRZELICZNIK
print(f"{km} km to {mile:0.2f} w milach")

	wynik: 10.0 km to 6.21 w milach

Wartości prawda/fałsz zapisane jako True/False (musi być z dużej litery)
Prawda == 1
Fałsz == 0

Operatory:
dodawanie +
odejmowanie -
mnożenie *
dzielenie /
modulo % (reszta z dzielenia)
dodawanie i mnożenie można dokonywać na wszystkich typach (w przypadku tesktu go mnoży), resztę tylko na liczbach (integer, float, bool)

print("Hej"*3) -> HejHejHej

W przypadku ciągu znaków (string) możemy wykonać operację mnożenia przez liczbę - powtórzy nam to
dany tekst wskazaną ilość razy. Nie można jednak mnożyć ciągu znaków przez ciąg znaków.
Wartości logiczne True / False są równoważne 1 i 0 - stąd też da się wykonać operacje dzielenia, czy modulo

Funkcja SUM może zebrać tylko dwa argumenty sum(1+2), większa liczba argumentów musi mieć dwa nawiasy sum((1, 2, 3))

Zajęcia 3 27.09.2024 - instrukcje warunkowe, bloki kodu, porównania i jak na ich podstawie podejmować decyzje w programie

.lower i .upper zmieniają nam cały tekst na małe lub duże litery - Python każda liczbę widzi jako wartość liczbową więc Przemek i przemek to dla niego różne wartości.

zmienna1 = Przemek
zmienna2 = przemek
zmienna1.lower() = przemek
zmienna1.lower() == zmienna2.lower() -> prawda, ponieważ teraz obie wartości są napisane w ten sam sposób (z małej litery)
zmienna1.upper() = PRZEMEK

INSTRUKCJE WARUNKOWE - zaczyna się od skonstruowania pytania warunkowego, na które można odpowiedzieć tak/nie lub prawda/fałsz
== x == y równe? - podchwytliwe! muszą być == bo = oznacza przypisanie
!= x != y nierówne?

= x >= y większe lub równe?
< x < y mniejsze?
<= x <= y mniejsze lub równe?

AND - jeśli choć jeden z parametrów będzie fałszem, to "and" także zwróci nam fałsz
OR - jeśli choć jeden z parametrów będzie prawdą, to "or" także zwróci nam prawdę
NOT - odwróci wartość logiczną, czyli prawdę zamieni na fałsz
najpierw rozstrzygany jest operator not, potem and, na końcu or

FUNKCJA "IF" - wyposażamy program w możliwość podejmowania decyzji. Po każdym warunku (if, elif, else) musi być dwukropek:

if:
print(
(wcięcie TABem!!! lub 4 spacje)(może być wiele linijek, ale musi być TAB żeby się zaczytało)
elif: - skrót od else if,czyli kolejny/inny warunek
print(
else: - w przeciwnym wypadku (jeśli żaden warunek powyżej nie został spełniony, zrób to co poniżej)
print(

zwierzak = "kot"
if zwierzak == "pies":
print("0, miłośnik psów")
print("Kostka dla ciebie")
elif zwierzak == "kot":
print("0, miłośnik kotów)
print("Miau!")
elif zwierzak == "rybka"
print("Lubisz wodę?")
else:
print("A co to za zwierzak?")

x =5
y =5
if x> y:
print("X jest większy od Y")
elif x < y:
print("X jest mniejszy od Y")
else:
print("X i Y są równe")

W powyższym przykładzie jeśli zostanie spełniony warunek (nieważne który w kolejności będzie), Python zamyka sekwencję warunkową i przechodzi do kolejnego wiersza
Jeżeli zamiast "elif" wszędzie wpiszemy "if" - Python będzie sprawdzał wszystkie warunki po kolei

truthie i falsie - prawie prawda i prawie fałsz.

Blok kodu w Pythonie możemy rozpoznać po wcięciach

Lekcja 4 - 30.09.2024 - struktury danych

lista [ang.list] - są modyfikowalne, przemieszczamy się po elementach. raczej unika się sięgania po elementy w środku listy. Nawiasy kwadratowe

krotka (ang.tuple) - niemodyfikowalne, często sięga się po elementy w środku (stała długość). Nawiasy okrągłe

listy i krotki - obie mogą posiadać duplikaty, każdy element ma indeks - przypisane numerowane miejsce (liczone od 0)
mojalista = [1, 2, 3, 4]
mojakrotka = (1, 2, 3, 4)

for element in mojalista
print(element) -> wypisuje po kolei 1 2 3 4. Dla krotki tak samo tylko odpowiednie nawiasy

moje_ksiazki = ["Blade Runner", "Hobbit", "Unicorn Project"]
print(moje_ksiazki[0]) -> blade Runner

moje_ksiazki = ["Blade Runner", "Hobbit", "Unicorn Project", "Krzyzacy"]
print(moje_ksiazki[1:]) - wyświetli od Hobbita do samego końca
print(moje_ksiazki[1:3]) - wyświetli tylko Hobbita i Unicorn Project

-1 odnosi nas do ostatniego elementu krotki/listy

tekst = "Lorem ipsum"
print(tekst[2]) -> litera r

tekst - string - jest niemodyfikowalny - specyficzny rodzaj krotki

kombinowane struktury: krotki w liście
moja_lista = [(1, 2), (4, 5), (3, 4), (5, 6)]

METODY - specjalne funkcje przypisane do danego obiektu. wywołuje się je po wpisaniu ich nazwy po kropce, za nazwą obiektu
nazwa-zmiennej.nazwa-metody(atrybuty) - moja_lista.append(nowy_element)

Wybrane metody dla list i krotek:
krotka lista
.count() .count() zlicza ilość wystąpień przekazanego parametru
.index() .index() podaje pierwszy indeks pod którym przekazywana jest wartość
.append() dodaje argumenty do listy
.pop() usuwa elementy o podanym indeksie z listy, lub ostatni element (zastępstwo "del" -> del menu "soki" usunie klucz soki i jego wartości)
.sort() sortuje elementy
.copy() zwraca kopię obiektu

mierzenie obiektów - funkcja "len"
len(obiekt)

moje_ksiazki = ["Blade Runner", "Hobbit", "Unicorn Project", "Krzyzacy"]

print(len(moje_ksiazki) -> 4

moja_lista = ["a", "b", "c", "d", "e"]
moja_lista += [1, "white"] -> ["a", "b", "c", "d", "e", 1, "white"]

słowniki - modyfikowalna, bardziej zaawansowana struktura. pozwalają na szybkie odnalezienie jakiejś zawartości z pomocą wartości klucza przypisanego dno niej. nawiasy klamrowe {}
moj_slownik={klucz,wartość}
moj_slownik = {"klucz1", "wartość1", "klucz2", "wartość2"}
klucz musi być unikalną wartością, na której da się wykonać tzw funkcję skrótu. struktury niemodyfikowalne (teksty, liczby, krotki) moga być kluczem
przykład: klucz to "zebra" a wartość to opis wyglądu zebry
słownik może być wartością dla innego słownika

moj_slownik
"klucz1": "wartość1",
"klucz2": "wartość2",
"klucz3": "wartość3",
"klucz4": "wartość4",
"klucz5": [1, 2, 3]

print(moj_slownik["klucz3"]) -> pokaże wartość3
print(moj_slownik["klucz4"] [1]) -> pokaże litere "a" z wartości4
print(moj_slownik["klucz5"][-1]) -> pokaże cyfre 3

dict- tworzy nowe pary/elementy

ZBIORY (ang. set) - wygladają jak listy, ale nie mają duplikowatów wartości i indeksów. Jeśli chcesz dwa razy dodać słowo "kot", to drugi wpis zostanie usunięty. Nawiasy klamrowe. Przydatne, jesli chcemy pozbyć się duplikatów (zmieniamy listę na zbiór -> zbior = set(mojalista). może zmieniać kolejność
moj_zbior = {unikat1, unikat2, unikat3}

refactor - przebudowanie kodu - poprawki do kwestionariusza

moje_zdanie = "Ala ma kota - powiedział Stefan"
lista_slow = moje_zdanie.split()
print(lista_slow) efekt: ['Ala', 'ma', 'kota']
print(len(lista_slow)) efekt: 3

papier, nozyce, kamieć - tylko z tekstem i listami, radom.choice

Lekcja 5 02.10.2024

odpowiedzi = random.shuffle(odpowiedzi) -> zmienia kolejność odpowiedzi w pytaniu

PyPI (pypi.org) - program pythona, z którego można pobrać (zaimportować) bibliotekę -> pip install
github.com

DRY = Don't repeat yourself - żeby nie powtarzać się w pisaniu kodu

PĘTLE - sposoby definiowania powtarzalnej czynności, np. "wykonaj coś x razy", "wykonuj coś tak długo aż warunek zostanie spełniony"

Pętla "FOR" - wykona się określoną liczbę razy: "wykonaj coś tyle razy ile jest elementów w..." - ułatwia nam poruszanie się po sekwencji: elementach listy/krotki, znaków w ciągu znaków
wykonuje je tyle razy ile mamy elementów w sekwencji
preferowany rodzaj pętli w pythonie
wcięcia kodu takie jak w IF, oznacza blok kodu który zostanie wykonany w pętli (cos co chcemy wykonać wiele razy)

moja_lista = [1, 2, 3, 4]
for element in moja_lista: (element może być tak naprawdę dowolnym słowem, nawet lddksnc - dlatego kulturalnie przyjęło się używanie _ : for _ in moja_lista:)
print("Hello") -> Hello Hello Hello Hello

moja_lista = [1, 2, 3, 4]
for element in moja_lista:
print("Hello")
print("World")
efekt:
Hello
World
Hello
World
Hello
World
Hello
World

moja_lista = [1, 2, 3, 4]
for liczba in moja_lista:
print(liczba)
print("Hello")
print("World")

			1
			Hello
			World
			2
			Hello
			World
			3
			Hello
			World
			4
			Hello
			World

moj_slownik = {"a":1, "b":2, "c":3}
for klucz in moj_slownik:
print(klucz) -> a b c

moja_lista = ["ala", 1, "kot", 2.38, (1, "chomik")]
for element in moja_lista:
print(element) -> ala
1
kot
2.38
(1, 'chomik')

for litera in "Robisz.to":
print(litera) -> r o b i s z . t o

FUNCKA RANGE - generuje sekwencję o wybranej przez nas długości i wybranym zakresie i kroku. drukuje od 0

for i in range(10):
print(i) -> 0 1 2 3 4 5 6 7 8 9

for _ in range(10):
print("Hej") -> Hej Hej Hej Hej Hej Hej Hej Hej Hej Hej

aby wylosować losowy element : random.choice(moja.lista)

słowo "as" podmienia

moja_lista = [2, 3, 4]
a = 1
for i in moja_lista:
a*= i (mnożenie)
print(a) -> 2 6 24 (wynik mnożenia -> "a" nadpisuje się i podstawia się pod każdą pozycje z listy, czyli 12=2 i "a" teraz =2; 23=6 i "a" teraz=6, 6*4=24)

moja_lista = [2, 3, 4]
for i in moja_lista:
a=1
a*= i
print(a) -> 2 3 4

MODUŁ TURTLE - służy do proceduralnego rysowania kształtów po ekranie (poprzez kod). wykorzystywane w przemyśle (maszyny cnc)
ułatwia zrozumienie pętli i jej konstruowanie (pip install turtle) (import turtle)

import turtle

zolwik = turtle.Turtle()
zolwik.speed(5)
zolwik.shape("turtle")

.forward() - pójdzie do przodu - w nawiasie podajemy o ile jednostek ma się ruszyć
.left() - w lewo - w nawiasie podajemy liczbę stopni (np.. kąt prosty 90)
.right() - w prawo
.penup - "podnosi" długopis żeby między obiektami nie były linii
.pendown - "opuszcza" długopis
.circle() - narysuje kółko o podanej średnicy

for _ in range(4):
zolwik.forward(100)
zolwik.right(90) -> narysuje kwadrat

for _ in range(4):
zolwik.circle(100)
zolwik.penup()
zolwik.forward(150)
zolwik.pendown() -> znak audi

ilosc_bokow = 6
for _ in range(6):
zolwik.forward(100)
zolwik.right(360/6) -> narysuje sześciokąt

zolwik.circle(100)
zolwik.penup()
zolwik.forward(150)
zolwik.pendown()

for _ in range(4):
zolwik.forward(100)
zolwik.right(90) -> narysuje koło a potem kwadrat, które nie będą się spotykały

for _ in range(5):
zolwik.circle(60)
zolwik.right(70)
zolwik.pendown() -> zrobi rozetę

for _ in range(4):
for bok in range(2):
zolwik.forward(60)
zolwik.right(90)
zolwik.forward(60)
zolwik.left(90) -> zrobi plusik/krzyżyk

ilosc_slupkow = 4
for i in range(ilosc_slupkow):
for _ in range(2):
zolwik.forward(80)
zolwik.left(90)
zolwik.forward(80*(i+1)) (żeby nie mnożyć przez 0, robimy i+1)
zolwik.left(90)
zolwik.forward(80) -> robi schodki

rozmiar = 80
ilosc_kwadratow = 6
for _ in range(4):
for x in range(ilosc_kwadratow):
for y in range(4):
zolwik.forward(rozmiar)
zolwik.left(90)
rozmiar += 20
zolwik.left(90)
rozmiar = 80 -> robi kwadraty w kwadratach w odbiciu lustrzanym

ilosc_bokow = 6

skret = 360 / ilosc_bokow - 0.5

dlugosc_boku = 20

for _ in range(20):

zolwik.forward(dlugosc_boku)

dlugosc_boku +=5

zolwik.left(skret) -> niekończąca sie rozeta

for i in range(6, 600, 2):

zolwik.forward(i)

zolwik.left(59.5) -> niekończąca sie rozeta

zolwik.hideturtle() -> znika żółwik

Lekcja 6. 04.10.2024 PĘTLA WHILE, WARUNKI, BREAK

aby przerwać działanie programu, trzeba kliknąć w terminal i wcisnąć ctrl + c

PĘTLA WHILE - "wykonuj tak długo aż…" - jak tylko warunek zostanie spełniona pętla się zatrzymuje. lub nie zatrzymuje jeśli nie ma jako takiego warunku lub jest nieskończona liczba odpowiedzi

faslse w oogle
true nieskomcze

BREAK - przerywa trwanie kodu który ma nieskończoną ilość odpowiedzi

x = 0
while True:
x = x +1
print(x)
if x == 99:
break -> mogłoby lecieć w nieskończoność, ale przez break ostatnim numerem będzie 99

i = 100

while True:

print(i)

if i == 0:

break

i -=1

KWADRAT zółwikiem za pomocą while:

i =0
while i < 4:
zolwik.forward(80)
zolwik.right(90)
i +=1

SZEŚCIOKĄT zółwikiem za pomocą while:

i = 0
while i < 6:
zolwik.forward(100)
zolwik.right(360/6)
i+=1

               ciąg Fibonacciego

		0, 1
		0, 1, 1
		0, 1, 1, 2
		0, 1, 1, 2, 3
		0, 1, 1, 2, 3, 5

program, który stworzy ciąg Fibonacciego: używamy krotki bo będziemy dodawać do niej elementy

fibo = [0, 1]
pulap = 50
suma_ostatnich = fibo[-1]+fibo[-2]

while suma_ostatnich < 50:
fibo.append(suma_ostatnich)
suma_ostatnich = fibo[-1]+fibo[-2]

print(fibo)

	ciąg Fibonacciego w żółwiu - kwadraty od małego do dużego obok siebie

fibo = [0, 1]
pulap = 50
suma_ostatnich = fibo[-1]+fibo[-2]

dl_boku = 15

for element in fibo[1:]:
zolwik.fillcolor(random.choice(kolory))
zolwik.begin_fill()
for _ in range(4):
zolwik.forward(dl_bokuelement)
zolwik.left(90)
zolwik.end_fill()
zolwik.forward(dl_bokuelement)
zolwik.left(90)
zolwik.forward(dl_boku*element)

zajęcia 7 07.10.2024

RANDOM WALK

katy = [0, 90, 180, 270]
while True:
zolwik.color(random.choice(kolory))
zolwik.left(random.choice(katy))
zolwik.forward(30)

PĘTLA WHILE WYMAGA WARUNKU I JEST NIESKOŃCZONA. PĘTLA FOR WYMAGA RZECZY PO KTÓREJ MA SIĘ PRZEMIESZCZAĆ, NIE JEST NIESKOŃCZONA.

HASH - funkcja szyfrująca. proces nieodwracalny