diff --git a/.github/workflows/publish-docs-pipeline.yaml b/.github/workflows/publish-docs-pipeline.yaml new file mode 100644 index 0000000..028b5a8 --- /dev/null +++ b/.github/workflows/publish-docs-pipeline.yaml @@ -0,0 +1,30 @@ +name: Publish docs + +on: + push: + branches: + - zaj01 + +permissions: + contents: write + +jobs: + deploy-docs: + runs-on: ubuntu-latest + + steps: + - name: Checkout repository + uses: actions/checkout@v3 + + - name: Setup Python + uses: actions/setup-python@v5 + with: + python-version: '3.x' + + - name: Install dependencies + run: | + pip install mkdocs mkdocs-material pymdown-extensions + + - name: Deploy to Github Pages + run: | + mkdocs gh-deploy --force diff --git a/.gitignore b/.gitignore index b7faf40..15201ac 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,6 @@ # Byte-compiled / optimized / DLL files __pycache__/ -*.py[codz] +*.py[cod] *$py.class # C extensions @@ -46,7 +46,7 @@ htmlcov/ nosetests.xml coverage.xml *.cover -*.py.cover +*.py,cover .hypothesis/ .pytest_cache/ cover/ @@ -106,24 +106,17 @@ ipython_config.py # commonly ignored for libraries. # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control #poetry.lock -#poetry.toml # pdm # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. -# pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python. -# https://pdm-project.org/en/latest/usage/project/#working-with-version-control #pdm.lock -#pdm.toml +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/latest/usage/project/#working-with-version-control +.pdm.toml .pdm-python .pdm-build/ -# pixi -# Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control. -#pixi.lock -# Pixi creates a virtual environment in the .pixi directory, just like venv module creates one -# in the .venv directory. It is recommended not to include this directory in version control. -.pixi - # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm __pypackages__/ @@ -136,7 +129,6 @@ celerybeat.pid # Environments .env -.envrc .venv env/ venv/ @@ -175,33 +167,5 @@ cython_debug/ # option (not recommended) you can uncomment the following to ignore the entire idea folder. #.idea/ -# Abstra -# Abstra is an AI-powered process automation framework. -# Ignore directories containing user credentials, local state, and settings. -# Learn more at https://abstra.io/docs -.abstra/ - -# Visual Studio Code -# Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore -# that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore -# and can be added to the global gitignore or merged into this file. However, if you prefer, -# you could uncomment the following to ignore the entire vscode folder -# .vscode/ - -# Ruff stuff: -.ruff_cache/ - # PyPI configuration file .pypirc - -# Cursor -# Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to -# exclude from AI features like autocomplete and code analysis. Recommended for sensitive data -# refer to https://docs.cursor.com/context/ignore-files -.cursorignore -.cursorindexingignore - -# Marimo -marimo/_static/ -marimo/_lsp/ -__marimo__/ diff --git a/docs/assets/images/.gitkeep b/docs/assets/images/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000..2594f86 --- /dev/null +++ b/docs/index.md @@ -0,0 +1,38 @@ +Witam Państwa na zajęciach z przedmiotu Programowanie w języku Python (I) dla kierunku **Inżynieria i analiza danych - rok 2, semestr 3**. + +## 🎯 Cel kursu + +Po ukończeniu kursu uczestnicy będą potrafili: + +- Wykorzystywać podstawowe typy danych i struktury, +- Tworzyć funkcje i klasy, +- Pracować z modułami i pakietami, +- Korzystać z podstawowych bibliotek, +- Debugować i testować kod, +- Pisać czytelny i dobrze udokumentowany kod. + +## 📌 Informacje o przedmocie + +- **Prowadzący**: Jakub Staszel +- **Forma zajęć**: ćwiczenia laboratoryjne +- **Liczba godzin**: 1h 30 min x 30 +- **Miejsce**: Sala 312, A0 + +## 📝 Forma zaliczenia + +Aby zaliczyć kurs, uczestnicy muszą: + +1. Oddać wszystkie wykonane ćwiczenia, +2. Zaliczyć kolokwium na koniec semestru. + +**Nieobecności**: możliwe 2 nieobecności nieusprawiedliwione, później wymagane usprawiedliwienie. + +## 🛠️ Wymagania + +- Znajomość podstaw programowania, +- Konto na **GitHub**, +- Umiejętność pracy z **terminalem** i **docker**. + +## 📢 Kontakt +W razie pytań, proszę o kontakt na Teams lub poprzez email - jstaszel@agh.edu.pl. + diff --git a/docs/zaj0/srod-lok.md b/docs/zaj0/srod-lok.md new file mode 100644 index 0000000..5fa7294 --- /dev/null +++ b/docs/zaj0/srod-lok.md @@ -0,0 +1,196 @@ +# 📌 **Środowisko lokalne do pracy z Pythonem w kontenerze** + +Na tych zajęciach skonfigurujemy środowisko do pracy z Pythonem w kontenerze **Docker**. Dzięki temu każdy będzie miał **spójne, odizolowane środowisko**, w którym można instalować pakiety, uruchamiać skrypty i pracować z Pythonem **interaktywnie z poziomu IDE**. + +--- + +## 🏁 1. Połączenie z repozytorium w GitHub + +### 1.1 Instalacja git + +Jeśli nie masz jeszcze gita, możesz go zainstalować: + +- **Linux (Ubuntu/Debian):** + ```sh + sudo apt update + sudo apt install git + ``` + +- **Windows:** Pobierz instalator ze strony [git-scm.com](https://git-scm.com/) i zainstaluj. + +- **macOS:** + ```sh + brew install git + ``` + +Po instalacji sprawdź wersję w terminalu: +```sh +git --version +``` + +### 1.2 Klonowanie repozytorium zdalnego + +!!! danger "Link do Twojego repozytorium zdalnego dostaniesz od prowadzącego zajęcia!" + +Stwórz lokalną kopię repozytorium, użyj komendy: +```sh +git clone https://github.com/uzytkownik/nazwa-repozytorium.git +``` +Lub jeśli używasz SSH: +```sh +git clone git@github.com:uzytkownik/nazwa-repozytorium.git +``` + +### 1.3 Konfiguracja użytkownika + +1. Wejdź w terminalu do folderu ze sklonowanym projektem. +2. Skonfiguruj swoje dane: + +```sh +git config user.name "Twoje Imię i Nazwisko" +git config user.email "twoj@email.com" +``` + +## 🛠 2. Instalacja Dockera + +???- info "Jak działa Docker?" + + Docker to platforma do uruchamiania aplikacji w kontenerach, czyli lekkich, odizolowanych środowiskach, które zawierają wszystko, co jest potrzebne do działania aplikacji (kod, zależności, konfigurację). Dzięki temu aplikacje działają identycznie niezależnie od systemu operacyjnego. + + - Każdy kontener działa jak mini-wirtualna maszyna, ale jest lżejszy i bardziej wydajny. + + - Docker używa obrazów – predefiniowanych pakietów, które można wielokrotnie uruchamiać jako kontenery. + + - Izolacja pozwala uniknąć konfliktów zależności i różnic między środowiskami. + +???- info "Po co nam Docker?" + + Docker jest przydatny, ponieważ: + + - Eliminuje problem „u mnie działa” – środowisko w kontenerze jest identyczne na każdym komputerze. + + - Łatwo można współdzielić środowiska – wystarczy przekazać pliki Dockerfile i devcontainer.json. + + - Szybkie wdrażanie – nowe środowisko można uruchomić w kilka sekund. + + - Ułatwia pracę zespołową – każdy programista ma tę samą konfigurację. + + - Można uruchamiać aplikacje w chmurze i na serwerach bez zmian w kodzie. + + Docker to idealne narzędzie dla programistów, którzy chcą pracować w powtarzalnym i stabilnym środowisku! 🚀 + +### 📥 2.1. Instalacja na Windows/macOS/Linux +1. Pobierz i zainstaluj **Docker Desktop**: [Pobierz Docker](https://www.docker.com/get-started) +2. Sprawdź instalację: + ```sh + docker --version + ``` +3. Upewnij się, że Docker jest **uruchomiony**. + +--- + +## 🔧 3. Konfiguracja IDE (VS Code) z Dockerem i Miniforge + +- **Otwórz katalog projektu** w VS Code. +- Zapoznaj się z widocznymi tam plikami: + +???- info "Plik `Dockerfile`" + + Ten plik definiuje obraz Dockera z preinstalowanym Pythonem i condą. + + ```dockerfile + FROM condaforge/miniforge3:latest + + WORKDIR /app + + CMD ["/bin/bash", "-l"] + ``` + +???- info "Plik `./.devcontainer/devcontainer.json`" + + Ten plik konfiguruje VS Code do pracy w kontenerze Dockera z odpowiednimi rozszerzeniami. + + ```json + { + "name": "Python Dev Container", + "build": { + "dockerfile": "../Dockerfile" + }, + "workspaceFolder": "/app", + "mounts": [ + "source=${localWorkspaceFolder},target=/app,type=bind,consistency=cached" + ], + "customizations": { + "vscode": { + "settings": { + "terminal.integrated.defaultProfile.linux": "bash" + }, + "extensions": [ + "ms-python.python", + "ms-vscode-remote.remote-containers", + "ms-vscode-remote.dev-containers" + ] + } + } + } + ``` + +- Ręcznie zbuduj obraz w terminalu: +```sh +docker build -t python-env . +``` + +- Uruchom kontener w trybie interaktywnym i podłącz lokalny katalog: +```sh +docker run -it -v .:/app python-env /bin/bash -l +``` +Dzięki temu wszystkie zmiany w projekcie będą widoczne w kontenerze. + +--- + +Teraz chcemy sobie ułatwić życie, połączyć się do kontenera bezpośrednio z VS Code: + +- **Zainstaluj rozszerzenie** ➝ `Remote - Containers` lub `Dev Container`. +- Kliknij `Ctrl+Shift+P` i wybierz **`Remote-Containers: Reopen in Container`**. +- VS Code uruchomi kontener i otworzy projekt w odizolowanym środowisku. +- Otwórz terminal w VS Code (`Ctrl+~`) i sprawdź aktywne środowisko Conda: + ```sh + conda info --envs + ``` + Powinieneś zobaczyć, że aktywowane jest środowisko `base`. + +--- + +## 📦 5. Instalacja pakietów wewnątrz kontenera + +!!! danger "Tego kroku nie robimy, jest czysto informacyjny." + +Gdy kontener jest uruchomiony, można instalować pakiety za pomocą **mamby**: + +```sh +micromamba install -y -n base -c conda-forge matplotlib geopandas +``` +Pakiety można też instalować przez **pip**: +```sh +pip install requests +``` + +--- + +## 📝 Zadania + +Utwórz plik `main.py`: + +```python +import this +``` + +Uruchom go w kontenerze: + +```sh +python main.py +``` + +Zrób zrzut ekranu (screenshot) pokazujący wynik działania tego skryptu w terminalu kontenera i wyślij go na czat 📸 + +--- diff --git a/docs/zaj01/git.md b/docs/zaj01/git.md new file mode 100644 index 0000000..6b26e0a --- /dev/null +++ b/docs/zaj01/git.md @@ -0,0 +1,306 @@ +W tym module poznasz podstawowe informacje o systemie kontroli wersji git. Omówimy commity, synchronizację z repozytorium zdalnym, pracę z gałęziami oraz współpracę przez pull requesty. + +## Czym jest git? + +Git to rozproszony system kontroli wersji, który umożliwia śledzenie zmian w plikach, współpracę między programistami i zarządzanie kodem źródłowym w sposób efektywny i bezpieczny. Jest szeroko stosowany w projektach open-source oraz w firmach na całym świecie. + +### Kluczowe cechy gita +- **Rozproszony system** – każdy użytkownik ma pełną kopię repozytorium, +- **Wersjonowanie** – śledzenie zmian i możliwość powrotu do wcześniejszych wersji kodu, +- **Gałęzie (branches)** – możliwość pracy nad różnymi wersjami kodu równocześnie, +- **Integracja z platformami zdalnymi** – np. GitHub, GitLab, Bitbucket. + +--- + +## Połączenie z repozytorium zdalnym + +Tą funkcjonalość mamy już opanowaną - zrobiliśmy to w poprzednich krokach. + +## Co to są commity i jak działają? + +???+ info "Commit - zapisywanie zmian" + + **Commit** to jak "zapisanie gry" w programowaniu. To moment, w którym zapisujesz aktualny stan swoich plików w repozytorium git. Każdy commit ma unikalny identyfikator (hash) i zawiera informacje o tym, co zostało zmienione, kiedy i przez kogo. + + **Dlaczego commity są ważne?** + + - Pozwalają śledzić historię zmian w kodzie. + - Umożliwiają powrót do wcześniejszych wersji. + - Ułatwiają współpracę w zespole. + - Pomagają zrozumieć, co i dlaczego zostało zmienione. + + **Podstawowy workflow z commitami**: + ```sh + # 1. Sprawdź status plików + git status + + # 2. Dodaj pliki do staging area (przygotowanie do commita) + git add nazwa-pliku.py + # lub dodaj wszystkie zmienione pliki: + git add . + + # 3. Stwórz commit z opisem zmian + git commit -m "Add function to calculate average" + ``` + + **Dobre praktyki przy commitach**: + + - Pisz jasne i zwięzłe opisy commitów. + - Commituj często, ale tylko logicznie spójne zmiany. + - Używaj czasu teraźniejszego w opisach (np. "Add function" zamiast "Added function"). + + **Przykłady dobrych opisów commitów**: + ``` + "Fix calculation bug in average function" + "Add input validation for user data" + "Remove unused imports" + "Update function documentation" + ``` + +## Synchronizacja z repozytorium zdalnym + +???+ info "Push, Pull i Fetch" + + Gdy pracujesz (chociażby na tych zajęciach), musisz synchronizować zmiany z repozytorium zdalnym (np. na GitHubie). To dopiero tam inni zainteresowani będą mieć wgląd w kod i zmiany. + + **Push - wysyłanie zmian na serwer**: + ```sh + git push origin nazwa-galezi + ``` + Wysyła twoje lokalne commity do repozytorium zdalnego. `origin` to domyślna nazwa repozytorium zdalnego, a `nazwa-galezi` to gałąź, którą chcesz wysłać. + + **Pull - pobieranie i scalanie zmian**: + ```sh + git pull origin nazwa-galezi + ``` + Pobiera zmiany z repozytorium zdalnego i automatycznie scala je z twoją lokalną gałęzią. To skrót dla `git fetch` + `git merge`. + + **Fetch - tylko pobieranie informacji**: + ```sh + git fetch origin + ``` + Pobiera informacje o zmianach z repozytorium zdalnego, ale nie scala ich automatycznie. Pozwala sprawdzić, co się zmieniło, zanim zdecydujesz się na scalenie. + + **Kiedy używać którego polecenia?** + + - `git push` - gdy skończyłeś pracę nad funkcją i chcesz udostępnić zmiany innym. + - `git pull` - gdy chcesz pobrać najnowsze zmiany od innych programistów. + - `git fetch` - gdy chcesz tylko sprawdzić, czy są nowe zmiany, bez ich scalania. + + **Typowy workflow**: + ```sh + # Przed rozpoczęciem pracy - pobierz najnowsze zmiany + git pull origin main + + # Po skończeniu pracy - wyślij swoje zmiany + git push origin moja-galez + ``` + +## 📝 Zadania + +1. Przenieś swoje zmiany po wykonanym poprzednim zadaniu do staging area. +2. Zacommituj je. +3. Wypchnij swoje zmiany do repozytorium zdalnego. + +--- + +## Gałęzie + +???+ info "Branches" + + Gałęzie pozwalają na jednoczesne rozwijanie różnych funkcji projektu bez wpływania na główną wersję kodu. To bardzo użyteczne, gdy kilka osób pracuje nad różnymi aspektami projektu lub gdy testujesz nowe funkcjonalności przed ich wdrożeniem do głównej wersji kodu. + + **Tworzenie nowej gałęzi**: + ```sh + git branch nazwa-galezi + ``` + Tworzy nową gałąź, ale pozostajesz na obecnej. + + **Przełączanie się na nową gałąź**: + ```sh + git checkout nazwa-galezi + ``` + Lub używając nowoczesnej wersji polecenia: + ```sh + git switch nazwa-galezi + ``` + + **Tworzenie i przejście na nową gałąź jednocześnie**: + ```sh + git checkout -b nazwa-galezi + ``` + Dzięki temu unikasz konieczności tworzenia gałęzi i przełączania się na nią osobno. + + **Merging (scalanie gałęzi)**: + + Przykład: synchronizacja swojej gałęzi z najnowszymi zmianami z `main`: + ```sh + # 1. Przełącz się na swoją gałąź + git checkout feature/kalkulator + + # 2. Pobierz najnowsze zmiany z main + git pull origin main + + # 3. Scal zmiany z main do swojej gałęzi + git merge main + + # 4. Wyślij zaktualizowaną gałąź + git push origin feature/kalkulator + ``` + + **Kiedy to robić?** + + - Gdy ktoś inny dodał zmiany do main, a ty chcesz mieć najnowszą wersję. + - Gdy chcesz uniknąć konfliktów przy końcowym mergowaniu. + - Gdy chcesz przetestować swoją funkcję z najnowszymi zmianami. + + **Alternatywnie - rebase (bardziej eleganckie)**: + ```sh + git checkout feature/kalkulator + git pull origin main + git rebase main + git push origin feature/kalkulator + ``` + +## Współpraca przez repozytorium zdalne + +???+ info "Pull Requests" + + Pull Requesty to sposób na proponowanie zmian w kodzie i ich review przed mergowaniem do głównej gałęzi. + + **Workflow**: + + 1. Wyślij gałąź na serwer: `git push origin feature/kalkulator`. + 2. Na GitHubie kliknij "Compare & pull request". + 3. Wypełnij tytuł i opis zmian. + 4. Poproś o review od innych programistów. + 5. Po zaakceptowaniu - merge do głównej gałęzi. + + **Dlaczego PR?** + + - Code review przed mergowaniem. + - Dokumentacja zmian i dyskusji. + - Lepsza jakość kodu. + - Współpraca w zespole. + +--- + +Teraz masz podstawową wiedzę na temat gita. Możemy zaczynać pracę nad Pythonem! + +!!! tip "Nowoczesne IDE mają moduły do obsługi kontroli wersji, więc możemy używać interfejsu graficznego zamiast poleceń w terminalu." + +--- + +## Przydatne w codziennej pracy + +???- tip "Revert i Reset - wycofywanie zmian" + + Błędy zdarzają się każdemu. Dlatego git oferuje kilka metod na ich cofnięcie. + + **Cofnięcie ostatniego commita**: + ```sh + git revert HEAD + ``` + Tworzy nowy commit cofający zmiany z poprzedniego. Jest to bezpieczna metoda, ponieważ nie usuwa historii. + + Jeśli chcesz całkowicie usunąć commit: + ```sh + git reset --hard HEAD~1 + ``` + Ta opcja może być ryzykowna, bo usunie lokalne zmiany bez możliwości ich przywrócenia. + + **Usunięcie zmian w plikach przed commitem**: + ```sh + git checkout -- nazwa-pliku + ``` + Przywraca wersję pliku do ostatniego stanu w repozytorium. Przydatne, jeśli zmieniłeś plik przez pomyłkę. + +???- tip "Stash – przechowanie tymczasowych zmian" + + Czasami pracujemy nad jakąś zmianą, ale musimy pilnie przełączyć się na inną gałąź. W takich przypadkach możemy użyć `stash`. + + **Schowanie zmian**: + ```sh + git stash + ``` + To powoduje zapisanie bieżących zmian na stosie i przywrócenie plików do stanu z ostatniego commita. + + **Przywrócenie ostatniego stasha**: + ```sh + git stash pop + ``` + Dzięki temu odzyskujesz zapisane zmiany. + +???- tip "Sprawdzanie historii commitów" + + Historia commitów pomaga w śledzeniu zmian w kodzie, co jest szczególnie przydatne w zespołach. + + **Podstawowa historia commitów**: + ```sh + git log + ``` + + **Skrócona i czytelniejsza wersja**: + ```sh + git log --oneline --graph --all + ``` + Pozwala szybko zobaczyć strukturę commitów i ich relacje. + +???- tip "Usuwanie plików z repozytorium i `.gitignore`" + + Nie zawsze chcemy, aby dany plik był częścią repozytorium. + + **Usunięcie pliku z repozytorium i lokalnego systemu plików**: + ```sh + git rm nazwa-pliku + ``` + + **Usunięcie pliku tylko z repozytorium, ale zachowanie go lokalnie**: + ```sh + git rm --cached nazwa-pliku + ``` + To przydatne, jeśli przypadkowo dodaliśmy do repozytorium plik, który nie powinien się tam znaleźć (np. plik konfiguracyjny). + + **`.gitignore`** + Plik `.gitignore` pozwala ignorować określone pliki i katalogi, aby nie były one dodawane do repozytorium. + + **Przykład `.gitignore`**: + ``` + # Ignorowanie plików tymczasowych edytora + *.swp + *.swo + + # Ignorowanie katalogu build + /build/ + + # Ignorowanie plików konfiguracyjnych + config.yaml + .env + ``` + Plik `.gitignore` powinien być umieszczony w głównym katalogu repozytorium. + +???- tip "git LFS (Large File Storage)" + + Jeśli pracujesz z dużymi plikami, git może nie być optymalny do ich przechowywania. Git LFS (Large File Storage) to rozszerzenie gita, które pozwala przechowywać duże pliki osobno od kodu źródłowego. + + **Instalacja git LFS**: + ```sh + # Na systemach Linux/macOS + curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | sudo bash + sudo apt install git-lfs + + # Na Windows + choco install git-lfs + ``` + + **Używanie git LFS**: + ```sh + git lfs install + ``` + Następnie dodaj typ plików, które mają być przechowywane w LFS: + ```sh + git lfs track "*.psd" + ``` + To oznacza, że pliki `.psd` będą przechowywane w git LFS zamiast w standardowym repozytorium gita. + + Dzięki temu repozytorium pozostaje lekkie, a duże pliki są przechowywane w zoptymalizowany sposób. \ No newline at end of file diff --git a/docs/zaj01/moduly_przestrzenie.md b/docs/zaj01/moduly_przestrzenie.md new file mode 100644 index 0000000..d237dad --- /dev/null +++ b/docs/zaj01/moduly_przestrzenie.md @@ -0,0 +1,89 @@ +## Wprowadzenie +W Pythonie moduły i przestrzenie nazw odgrywają kluczową rolę w organizacji kodu. Moduły pozwalają na podzielenie kodu na mniejsze, łatwiejsze w zarządzaniu części, a przestrzenie nazw pomagają uniknąć konfliktów pomiędzy nazwami zmiennych, funkcji czy klas. + +--- + +## Moduły w Pythonie + +### Czym jest moduł? +Moduł w Pythonie to plik `.py`, który zawiera zmienne, funkcje i klasy. Dzięki nim można podzielić kod na niezależne sekcje, co ułatwia jego ponowne użycie oraz utrzymanie. + +#### Tworzenie i używanie modułu +Załóżmy, że chcemy stworzyć moduł do operacji matematycznych. Tworzymy plik `matematyka.py`: +```python +def dodaj(a, b): + return a + b + +def odejmij(a, b): + return a - b +``` +Teraz możemy zaimportować go w innym skrypcie: +```python +import matematyka + +wynik = matematyka.dodaj(5, 3) +print(f'Wynik dodawania: {wynik}') +``` + +Możemy też importować tylko wybrane funkcje: +```python +from matematyka import odejmij + +wynik = odejmij(10, 4) +print(f'Wynik odejmowania: {wynik}') +``` + +--- + +## Przestrzenie nazw + +Przestrzeń nazw to mechanizm pozwalający unikać konfliktów między zmiennymi i funkcjami. Python organizuje przestrzenie nazw w hierarchiczny sposób: + +1. **Lokalna** – zmienne wewnątrz funkcji, +2. **Globalna** – zmienne zadeklarowane w module, +3. **Wbudowana** – standardowe funkcje Pythona jak `print()`. + +#### Przykład użycia przestrzeni nazw +```python +x = 10 # Zmienna globalna + +def funkcja(): + x = 5 # Zmienna lokalna + print(f'Wartość x wewnątrz funkcji: {x}') + +funkcja() +print(f'Wartość x na poziomie globalnym: {x}') +``` + +## Podsumowanie +1. **Moduły** pomagają organizować kod i unikać powielania funkcji. +2. **Przestrzenie nazw** zapobiegają konfliktom nazw i organizują zmienne w hierarchii. + +Dzięki tym mechanizmom Python zapewnia elastyczność w organizacji kodu i jego efektywne zarządzanie! + +## 📝 Zadania + + 1. Z pakietu `os` zaimportuj funkcję `getcwd` + ```python + from os import getcwd + ``` + 2. Wywołaj funkcję i przypisz wynik do zmiennej `current_path` + 3. Wypisz wartość zmiennej `current_path` + 4. Stwórz plik `czas.py` + 5. W pliku `czas.py` dodaj zmienną `aktualny_czas`: + ```python + from datetime import datetime + aktualny_czas = datetime.now() + ``` + 6. Zaimportuj moduł `czas` w `skrypt1.py` + 7. Wypisz wartość zmiennej `aktualny_czas` + 8. Zaimportuj pakiet `time` i dodaj opóźnienie: + ```python + import time + time.sleep(20) + ``` + 9. Ponownie wypisz wartość zmiennej `aktualny_czas` + 10. Przeładuj moduł `czas` (`importlib.reload()`) + 11. Po raz trzeci wypisz wartość zmiennej `aktualny_czas` + +Zwróć uwagę na to, kiedy zmieniła się wartość zmiennej. Zastanów się, kiedy inicjowana jest zmienna `aktualny_czas`. \ No newline at end of file diff --git a/docs/zaj01/niespodziewane.md b/docs/zaj01/niespodziewane.md new file mode 100644 index 0000000..3e0bd25 --- /dev/null +++ b/docs/zaj01/niespodziewane.md @@ -0,0 +1,44 @@ +### Przypisanie tworzy referencję, a nie kopię + +W Pythonie przypisanie listy do innej zmiennej nie tworzy nowej kopii, lecz odniesienie do tej samej struktury danych. +```python +L = [1,2,3,4] +M = [1,2,3,L,4] +print(f"Wartość zmiennej M przed zmianą L: {M}") +L[1] = "woooow" +print(f"Wartość zmiennej M po zmianie L: {M}") +``` + +???- "Dlaczego tak się dzieje?" + - `M` zawiera referencję do `L`, a nie jej kopię. + - Gdy zmienimy element w `L`, zmiana jest widoczna również w `M`, ponieważ odwołuje się do tej samej instancji obiektu. + +### Powtórzenie dodaje jeden poziom zagłębienia +```python +L = [4,5,6] +X = L * 4 +Y = [L] * 4 +print(f"X: {X}, Y: {Y}") +L[1] = "wow" +print(f"X: {X}, Y: {Y}") +``` + +???- "Dlaczego tak się dzieje?" + - `X = L * 4` tworzy nową listę powielając zawartość `L` jako wartości skalarne + - `Y = [L] * 4` powiela odniesienie do listy `L`, nie tworząc nowych instancji + - Po zmianie elementu w `L`, efekt jest widoczny w `Y`, ale nie w `X`, ponieważ `X` zawiera wartości skopiowane + +### Głębsza analiza kopiowania list +```python +L = [4,5,6] +Y = [list(L)] * 4 +L[1] = "wow" +print(f"Y: {Y}") +Y[0][1] = "wow" +print(f"Y: {Y}") +``` + +???- "Dlaczego tak się dzieje?" + - `[list(L)] * 4` tworzy listę zawierającą cztery referencje do **tej samej kopii `list(L)`** + - Modyfikacja `L` **nie wpłynie** na `Y`, ponieważ `list(L)` tworzy nową instancję + - Jednak zmiana `Y[0][1]` spowoduje zmianę we wszystkich elementach `Y`, ponieważ wszystkie odwołują się do tej samej listy \ No newline at end of file diff --git a/docs/zaj01/typy_wbudowane.md b/docs/zaj01/typy_wbudowane.md new file mode 100644 index 0000000..6949659 --- /dev/null +++ b/docs/zaj01/typy_wbudowane.md @@ -0,0 +1,236 @@ +## Wprowadzenie +W Pythonie istnieje kilka podstawowych typów wbudowanych, które pozwalają na przechowywanie i manipulowanie różnymi rodzajami danych. Do najważniejszych należą: + +- **Liczby (int, float, complex)** – typy liczbowe, +- **Łańcuchy znaków (str)** – sekwencje znaków, +- **Listy (list)** – uporządkowane kolekcje elementów, +- **Krotki (tuple)** – niemutowalne kolekcje elementów, +- **Słowniki (dict)** – struktury danych przechowujące pary klucz-wartość, +- **Zbiory (set)** – nieuporządkowane kolekcje unikalnych elementów. + +--- + +## Liczby +### Typy liczbowe w Pythonie +Python obsługuje kilka typów liczbowych: +```python +# Liczba całkowita +x = 10 # int + +# Liczba zmiennoprzecinkowa +y = 3.14 # float + +# Liczba zespolona +z = 1 + 2j # complex +``` + +???- warning "Dokładność liczb zmiennoprzecinkowych" + **Dokładność liczb zmiennoprzecinkowych** + + Warto pamiętać, że liczby zmiennoprzecinkowe (`float`) są reprezentowane w standardzie IEEE 754, co może prowadzić do błędów zaokrągleń: + ```python + print(0.1 + 0.2) # Wynik może być 0.30000000000000004 zamiast 0.3 + ``` + Aby uniknąć problemów precyzji, można używać modułu `decimal`: + ```python + from decimal import Decimal + + x = Decimal('0.1') + y = Decimal('0.2') + print(x + y) # Wynik: 0.3 (dokładnie) + ``` + + **32-bit vs. 64-bit** + + Python samodzielnie zarządza precyzją liczb całkowitych, ale liczby zmiennoprzecinkowe (`float`) zależą od architektury systemu: + + - **Systemy 32-bitowe** przechowują `float` jako pojedynczą precyzję (32 bity), co może prowadzić do większych błędów zaokrągleń. + - **Systemy 64-bitowe** używają podwójnej precyzji (64 bity), co zapewnia większą dokładność, ale nadal podlega ograniczeniom standardu IEEE 754. + + Jeśli kluczowa jest precyzja obliczeń, warto rozważyć użycie `decimal.Decimal` lub `fractions.Fraction`. + +### Operacje matematyczne +Python obsługuje podstawowe operacje matematyczne: +```python +a = 10 +b = 3.5 + +suma = a + b +roznica = a - b +iloczyn = a * b +iloraz = a / b +potega = a ** 2 +modulo = a % 3 +``` + +--- + +## Łańcuchy znaków +Łańcuchy znaków w Pythonie są niezmienne i można się do nich odwoływać jak do sekwencji: +```python +tekst = "Witaj, świecie!" +print(tekst[0]) # Pierwszy znak +print(tekst[-1]) # Ostatni znak +print(tekst[0:5]) # Fragment łańcucha +``` + +Możemy również manipulować łańcuchami: +```python +print(tekst.upper()) # Wielkie litery +print(tekst.lower()) # Małe litery +print(tekst.replace("Witaj", "Hello")) # Zamiana fragmentu +``` + +--- + +## Listy +Listy są dynamicznymi kolekcjami elementów różnych typów: +```python +lista = [1, 2, 3, "Python", 3.14] +print(lista[2]) # Dostęp do elementu + +lista.append("Nowy element") # Dodanie elementu +lista.remove(3) # Usunięcie elementu +print(lista) +``` + +### Operacje na listach +#### Wycinki (slicing) +Listy obsługują operacje wycinania (slicing): +```python +lista = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] +print(lista[2:5]) # Elementy od indeksu 2 do 4 +print(lista[:4]) # Pierwsze 4 elementy +print(lista[5:]) # Wszystkie elementy od indeksu 5 +print(lista[-3:]) # Ostatnie 3 elementy +print(lista[::2]) # Co drugi element +``` + +#### Odwracanie listy +```python +print(lista[::-1]) # Odwrócenie kolejności elementów +``` + +#### Sprawdzanie obecności elementu +```python +if "Python" in lista: + print("Element istnieje w liście!") +``` + +Można także używać list składanych: +```python +liczby = [x for x in range(10) if x % 2 == 0] +print(liczby) # Lista parzystych liczb +``` + +--- + +## Słowniki +Słowniki przechowują dane w postaci par klucz-wartość: +```python +osoba = { + "imie": "Jan", + "nazwisko": "Kowalski", + "wiek": 30 +} +print(osoba["imie"]) # Dostęp do wartości + +osoba["miasto"] = "Warszawa" # Dodanie nowej pary +print(osoba) +``` + +--- + +## Krotki +Krotki działają podobnie do list, ale są niemutowalne: +```python +krotka = (1, 2, "Python", 3.14) +print(krotka[1]) +``` +Próba modyfikacji krotki spowoduje błąd: +```python +# krotka[1] = 5 # Błąd: nie można modyfikować elementów krotki +``` + +--- + +## Zbiory +Zbiory przechowują unikalne wartości i pozwalają na operacje matematyczne: +```python +zbior1 = {1, 2, 3, 4} +zbior2 = {3, 4, 5, 6} + +print(zbior1 & zbior2) # Część wspólna +print(zbior1 | zbior2) # Suma zbiorów +``` + +--- + +## 📝 Zadania +1. Stwórz nowy plik o nazwie `skrypt2.py`, wszystkie kolejne instrukcje wprowadzaj po kolei w tym pliku + +!!! tip "Pamiętaj, że dobrą praktyką jest importowanie modułów i pakietów na samym początku pliku" + +!!! tip "Na różnych etapach tych zadań wykorzystaj funkcję `type()`, która pozwala zauważyć, jak działa **dynamiczne typowanie** w Pythonie" + +**Działania matematyczne** + +1. Stwórz zmienną `wartosc` i przypisz jej liczbę 100 +2. Do zmiennej `dodawanie` przypisz wartość dodania do zmiennej `wartosc` liczby `123.15` +3. Stwórz zmienną `potega` i przypisz do niej zmienną `dodawanie` podniesioną do potęgi `12345` + + ???- warning "Pojawia Ci się błąd?" + Jest to spodziewane, zamień potęgę na `12`. + +4. Do zmiennej `tekst` przypisz rzutowanie wartości zmiennej `potega` na typ `string` (funkcja `str()`) +5. Do zmiennej `wartosc_pi` przypisz wartość liczby pi +6. Do zmiennej `losowa` przypisz losową wartość z listy [1,2,3,4,5] + +**Łańcuchy znaków** + +1. Nadpisz zmienną `tekst` następującym wyrażeniem: `tekst = f"Wartosc: {tekst}"` +2. Wyświetl długość tekstu w zmiennej `tekst` i później wykorzystując wycinki wyświetl część zmiennej `tekst` o wartości „art” +3. Wypisz wartość funkcji `dir(tekst)` +4. Zmień cały łańcuch znaków w zmiennej `tekst` na wielkie litery, wypisz +5. Spróbuj zamienić znak na pozycji 2 w łańcuchu w zmiennej `tekst` na znak p + + ???- warning "Pojawia Ci się błąd?" + Jest to spodziewane, zapoznaj się z błędem i usuń lub zakomentują tą linię kodu. + +**Listy** + +Działania na listach: + +1. Stwórz zmienną o nazwie `lista`, przypisz do niej rzutowanie na listę (funkcja `list()`) zmiennej `tekst`. +2. Wykorzystując wycinki zrób tak, żeby lista zawierała jedynie litery słowa `WARTOSC` i później dwukropek. +3. Do listy dodaj kolejny wyraz, niech będzie to kolejna lista `[1,2,3,4,5]`. +4. Z listy usuń wyraz, który jest dwukropkiem. +5. Wypisz zmienną lista. + +Listy składane (list comprehension): + +1. Stwórz zmienną jak tutaj: `lista2 = [1,2,3,"banan",100]`. +2. Jako zmienna `lista3`, wykorzystaj składnię listy składanej, przeiteruj po każdym wyrazie z listy, do nowej listy zapisz wartość podniesioną do potęgi 2, jeśli wartość jest równa "banan" to ją pomiń. +3. Stwórz `lista4`, wykorzystaj funkcję `range()`, ma ona zawierać co drugą liczbę od 2 do 16. +4. Wypisz zmienne `lista2`, `lista3` i `lista4`. + +**Słowniki** + +1. Stwórz pusty słownik o nazwie `ja` +2. Niech będzie to reprezentacja Twojej osoby, dodaj do niego klucze `imie`, `nazwisko`, `wiek`, `moje_hobby` (reprezentowane przez listę z 2 zagnieżdżonymi słownikami o 2 kluczach: `nazwa` i `dlaczego`) +3. Wypisz wartość klucza `moje_hobby` +4. Wypisz jedynie nazwę pierwszego hobby +5. Wypisz wszystkie klucze naszego słownika +6. Sprawdź czy nasz słownik posiada klucz `adres`, wypisz zmienną typu `boolean` + +**Krotki** + +1. Do zmiennej `krotka1` przypisz wartość `(1,2,"3",4,2,5)` +2. Wypisz długość zmiennej i pierwszy wyraz +3. Sprawdź, ile razy występuje wartość 2 i wypisz +4. Spróbuj zmienić pierwszy wyraz na wartość 2 + +**Zbiory** + +1. Stwórz dwa zbiory o nazwach `X` i `Y`, nadaj im wartości odpowiednio: `set("kalarepa")` oraz `set("lepy")` +2. Wyświetl część wspólną obu zbiorów - można na nich wykonywać podobne operacje jak na zbiorach matematycznych \ No newline at end of file diff --git a/mkdocs.yml b/mkdocs.yml new file mode 100644 index 0000000..94eb39f --- /dev/null +++ b/mkdocs.yml @@ -0,0 +1,51 @@ +site_name: Programowanie w języku Python (I) +docs_dir: docs +repo_url: https://github.com/eo-agh/python1-materials +repo_name: python1-materials + +copyright: Copyright 2024 Jakub Staszel KGiIS AGH + +theme: + name: material + features: + - navigation.sections + - content.code.copy + palette: + - media: "(prefers-color-scheme)" + toggle: + icon: material/link + name: Switch to light mode + - media: "(prefers-color-scheme: light)" + scheme: default + primary: indigo + accent: indigo + toggle: + icon: material/toggle-switch + name: Switch to dark mode + - media: "(prefers-color-scheme: dark)" + scheme: slate + primary: black + accent: indigo + toggle: + icon: material/toggle-switch-off + name: Switch to system preference + font: + text: Roboto + code: Roboto Mono + +markdown_extensions: + - admonition + - codehilite + - pymdownx.highlight: + use_pygments: true + - pymdownx.superfences + - pymdownx.details + +watch: + - docs + +nav: + - Strona główna: index.md + - Podstawy programowania: + - 👽 Środowisko lokalne: zaj0/srod-lok.md + - 🌞 Git - kontrola wersji: zaj01/git.md