Programowanie w języku

Python
Dr. Inż. Marcin Caryk
Moduły i pakiety
 Wstęp
• Programowanie modułowe odnosi się do procesu dzielenia dużego, nieporęcznego zadania
programistycznego na osobne, mniejsze, łatwiejsze do zarządzania podzadania lub moduły.
• Poszczególne moduły można następnie łączyć ze sobą jak klocki, tworząc większą aplikację.

Modularyzacja kodu w dużej aplikacji ma kilka zalet:

• Prostota: zamiast skupiać się na całym problemie, moduł zazwyczaj koncentruje się na jednej stosunkowo
małej części problemu. Dzięki temu programowanie jest łatwiejsze i mniej podatne na błędy.
• Łatwość utrzymania: moduły są zazwyczaj projektowane w taki sposób, aby wymuszały logiczne granice
pomiędzy różnymi problematycznymi domenami. Jeśli moduły są napisane w sposób minimalizujący
współzależności, zmniejsza się prawdopodobieństwo, że modyfikacje w pojedynczym module będą miały
wpływ na inne części programu.
• Re-używalność: Funkcjonalność zdefiniowana w pojedynczym module może być łatwo ponownie
wykorzystana (poprzez odpowiednio zdefiniowany interfejs) przez inne części aplikacji. Eliminuje to potrzebę
duplikowania kodu.
• Zakres: moduły zazwyczaj definiują oddzielną przestrzeń nazw, co pomaga uniknąć kolizji między
identyfikatorami w różnych obszarach programu.
 Wstęp
W rzeczywistości istnieją trzy różne sposoby definiowania modułu w
Pythonie: pakage
• Moduł można napisać w samym Pythonie.
• Moduł można napisać w języku C i ładować dynamicznie w czasie
wykonywania, podobnie jak moduł re (wyrażenie regularne).
module
• Wbudowany moduł jest wewnętrznie zawarty w interpreterze,
podobnie jak moduł itertools. class/function
We wszystkich trzech przypadkach dostęp do zawartości modułu
odbywa się w ten sam sposób: za pomocą instrukcji import.

• Moduł to rodzaj kontenera wypełnionego funkcjami – można

spakować dowolną liczbę funkcji w jeden moduł i dystrybuować go
do innych programów. Tworzenie wielu modułów może
spowodować mały bałagan - prędzej czy później będzie potrzeba
pogrupować moduły dokładnie w taki sam sposób, w jaki
poprzednio grupuje się funkcje
• Paczka - pełni podobną rolę jak folder/katalog w świecie plików
 Import modułu

module.py main_module.py

my_text = "MY TEXT TO BE IMPORT" import module

list_pi = [3, 1, 4, 1, 5, 9, 2] print(dir(module))

def add_two_numbers(x, y):
return x + y
class ModuleImport():
def __init__(self, name):
self.__name = name
print(module.my_text)
print(module.list_pi)
print(module.add_two_numbers(5,4))
cls = module.ModuleImport("New")
cls.show_name()
print(module)

def show_name(self):
print(self.__name)
 Import
import <module_name> • Instrukcja import <nazwa_modułu> umieszcza tylko
<nazwa_modułu> w tablicy symboli wywoływanych.
import <module_name>[, <module_name> ...] • Obiekty zdefiniowane w module pozostają w prywatnej tablicy
symboli modułu.
import module • Z poziomu wywołującego obiekty w module są dostępne tylko
print(dir(module)) wtedy, gdy są poprzedzone <nazwą_modułu> w notacji
print(module.my_text) kropkowej, jak pokazano poniżej.

from <module_name> import <name(s)>
from module import my_text, list_pi
print(my_text, list_pi)
• Ta forma instrukcji import pozwala na import poszczególnych
obiektów z modułu bezpośrednio do tablicy symboli
wywoływanych.
• Po wykonaniu powyższej instrukcji, w środowisku wywołującym
można odwoływać się do <nazwy> bez prefiksu
<nazwa_modułu>
• Ponieważ ta forma importu umieszcza nazwy obiektów
bezpośrednio w tabeli symboli wywoływanych, wszelkie
istniejące już obiekty o tej samej nazwie zostaną nadpisane

from <module_name> import *
from module import *
print(list_pi)
print(add_two_numbers(5, 6))
from <module_name> import <name> as
<alt_name>
from module import my_text as t
from module import add_two_numbers as a2
print(t)
print(a2(1,2))
Import
• Możliwe jest nawet masowe importowanie wszystkiego z
modułu za jednym zamachem
• Spowoduje to umieszczenie nazw wszystkich obiektów z
<nazwa_modułu> w lokalnej tablicy symboli, z wyjątkiem tych,
które zaczynają się od znaku podkreślenia (_)
• Niekoniecznie jest to zalecane w przypadku kodu
produkcyjnego na dużą skalę. Jest to trochę niebezpieczne,
ponieważ masowo wprowadzasz nazwy do lokalnej tablicy
symboli.
• Może powodować nadpisywanie modułów co będzie
prowadziło do konfliktów
• Możliwe jest również importowanie pojedynczych obiektów, ale
wprowadzanie ich do lokalnej tablicy symboli z alternatywnymi
nazwami
• Umożliwia to umieszczanie nazw bezpośrednio w lokalnej
tablicy symboli, ale pozwala uniknąć konfliktów z wcześniej
istniejącymi nazwami
 Import
import <module_name> as <alt_name> • Można także zaimportować cały moduł pod alternatywną
nazwą
import module as m • Zawartość modułu można importować z definicji funkcji. W
print(m.my_text) takim przypadku import nie nastąpi do momentu wywołania
print(m.list_pi) funkcji
 Wbudowana zmienna __name__
• __name__ jest wbudowaną zmienną która odnosi się do nazwy obecnego modułu.
• Pozwala też definiować czy dany skrypt jest użyty jako importowany moduł przez inny skrypt albo jako samodzielny skrypt.
• Kiedy plik .py jest importowany jako moduł, Python ustawia specjalną zmienną dunder __name__ na nazwę modułu.
• Jeśli jednak plik jest uruchamiany jako samodzielny skrypt, __name__ jest ustawiane na ciąg „__main__”.

mod1.py mod2.py
import mod2 as md def check_test(test_name):
print(__name__) __main__ print("{} - {} checked".format(__name__, test_name))
print(md.__name__) mod2
def run_test(test):
test = "Small_test" mod2 - Small_test checked print("{} - Runing the {}".format(__name__, test))
print("{} - {}.....OK".format(__name__, test))
md.check_test(test) mod2 - Runing the Small_test
md.run_test(test) mod2 - Small_test.....OK
def main(test):
check_test(test)
run_test(test) __main__ - SuperTest checked
if __name__ == '__main__':
__main__ - Runing the SuperTest
main("SuperTest") __main__ - SuperTest.....OK
 Pakiety
• Pakiety umożliwiają hierarchiczną strukturę przestrzeni nazw modułu przy użyciu notacji kropkowej.
• W ten sam sposób, w jaki moduły pomagają unikać kolizji między nazwami zmiennych globalnych, pakiety pomagają unikać
kolizji między nazwami modułów.
• Tworzenie pakietu jest dość proste, ponieważ wykorzystuje wrodzoną hierarchiczną strukturę plików systemu
operacyjnego.
• Jeśli katalog pkg znajduje się w lokalizacji, w której można go znaleźć (w jednym z katalogów zawartych w sys.path), można
odwołać się do dwóch modułów z notacją kropkową (pkg.mod1, pkg.mod2) i zaimportuj je ze składnią import
import <package_name>
from <package_name> import <modules_name>[, <module_name> ...]
from <package_name> import <module_name> as <alt_name>
 Pakiety
main_pkg.py

Używanie samego import Używanie from package import function

import pkg.module_alpha oraz import as i dodanie ścieżki do sys path
print(pkg.module_alpha.alpha_show()) import sys
import pkg.calculus.module_mathematica sys.path.append('/pkg/calculus')
print(pkg.calculus.module_mathematica.sum(2, 3))
from pkg.module_betha import betha_func
Używanie from package import function from pkg.calculus.module_physics import acceleration
oraz import as betha_func()
print(acceleration(100, 20))
from pkg.module_betha import betha_func
from pkg.calculus.module_physics import acceleration import sys
from pkg.module_alpha import alpha_func as af sys.path.append('/pkg/calculus')
from pkg.calculus.module_mathematica import sum as s
betha_func() from pkg.module_alpha import alpha_func as a
acceleration(100, 20) from pkg.calculus.module_physics import velocity as v
af()
s(10,15) a()
print(pkg.module_alpha) print(v(200, 4))
print(pkg.module_alpha.__file__)
print(pkg.calculus.module_mathematica) print(__file__)
print(pkg.calculus.module_mathematica.__file__)
 Inicjalizacja pakietu
• Jeśli w katalogu pakietu znajduje się plik o nazwie __init__.py, jest on wywoływany podczas importowania
pakietu lub modułu z pakietu.
• Można to wykorzystać do wykonania kodu inicjującego pakiet, na przykład inicjalizacji danych na poziomie
pakietu.
• Moduł w pakiecie może uzyskać dostęp do zmiennej globalnej, importując ją po kolei

main_pkg1.py
import pkg1

print(pkg1.some_list)

__init__.py
print(f'Invoking __init__.py for {__name__}')
some_list = ["mod1", "mod2"]
 Inicjalizacja pakietu
mod1.py mod3.py
def func_example1(): def func_example3():
print("This is function func_example1") print("This is function func_example3")

class ClsExample1(): class ClsExample3():

def __init__(self): def __init__(self):
print("This is class example 1") print("This is class example 3")

def run(self): def run(self):

print("Run method of class example 1") print("Run method of class example 3")

mod2.py mod4.py
def func_example2(): def func_example4():
print("This is function func_example2") print("This is function func_example4")

class ClsExample2(): class ClsExample4():

def __init__(self): def __init__(self):
print("This is class example 2") print("This is class example 4")

def run(self): def run(self):

print("Run method of class example 2") print("Run method of class example 4")
 Inicjalizacja pakietu
• Duża część dokumentacji Pythona stwierdza, że podczas tworzenia pakietu w katalogu pakietu musi
znajdować się plik __init__.py.
• Wcześniej było tak, że sama obecność __init__.py oznaczała dla Pythona, że pakiet był definiowany.
• Plik może zawierać kod inicjujący lub nawet być pusty, ale musiał być obecny.
• Począwszy od Pythona 3.3, wprowadzono Implicit Namespace Packages (PEP 420).
• Pozwalają one na utworzenie pakietu bez pliku __init__.py.
• Oczywiście może nadal być obecny, jeśli konieczna jest inicjalizacja pakietu. Ale nie jest to już wymagane.

main_pkg1.py
__init__.py from pkg1.mod1 import *
print(dir())
__all__ = ['mod1', 'mod2']
from pkg1 import *
print(dir())

• Python postępuje zgodnie z następującą konwencją: jeśli plik __init__.py w katalogu pakietu zawiera listę o
nazwie __all__, przyjmuje się, że jest to lista modułów, które powinny zostać zaimportowane w przypadku
napotkania instrukcji z <nazwa_pakietu> import *.
 Inicjalizacja pakietu i subpakietu
subpackage/__init__.py
from .mod3 import func_example3, ClsExample3
from .mod4 import func_example4, ClsExample4

__all__ = ['func_example3', 'func_example4', 'ClsExample3', 'ClsExample4']

__init__.py
from .subpackage import *
main_pkg1.py
from .mod1 import func_example1, ClsExample1
from pkg1 import * from .mod2 import func_example2, ClsExample2
print(dir())
func_example1() __all__ = ['func_example1',
func_example2() 'func_example2',
func_example3() 'func_example3',
func_example4() 'func_example4',
c1 = ClsExample1() 'ClsExample1',
c2 = ClsExample2() 'ClsExample2',
c3 = ClsExample3() 'ClsExample3',
c4 = ClsExample4() 'ClsExample4']
Wbudowane pakiety pythona
Wbudowane moduły python
. https://docs.python.org/3/py-modindex.html
.
.
 Moduł os
• Moduł OS w Pythonie zapewnia funkcje interakcji z systemem operacyjnym.
• System operacyjny należy do standardowych modułów narzędziowych Pythona.
• Moduł ten zapewnia przenośny sposób korzystania z funkcjonalności zależnych od systemu operacyjnego.
• Moduły os i os.path zawierają wiele funkcji umożliwiających interakcję z systemem plików.
• Oprócz operacji na plikach i katalogach moduł os umożliwia uzyskać informacje o systemie operacyjnym,
zarządzać procesami, operować na strumieniach we/wy przy użyciu deskryptorów plików.
• Uzyskujemy to poprzez import os
 Moduł os
rodzaj systemuname tworzenie katalogów mkdir
import os import os
print(os.name) os.mkdir("..\\MyDir1")
os.mkdir("./MyDir2")
os.mkdir("C:\\MyDir3")
rozmiar pliku path.getsize
parent_dir = "C/MyDir3"
import os path = os.path.join(parent_dir, "MyDir4")
os.mkdir(path)
print(f"Sieze of current file {__file__} is:
{os.path.getsize(__file__)} in bytes") usuwanie katalogów rmdir
bazowa ścieżka i nazwa pliku import os
path.basename, path.dirname os.rmdir("..\\MyDir1")
os.rmdir("./MyDir2")
import os parent_dir = "C:/MyDir3"
path = os.path.join(parent_dir, "MyDir4")
print(os.path.basename(__file__)) os.rmdir(path)
print(os.path.dirname(__file__)) os.rmdir("C:\\MyDir3")
sprawdzanie czy katalog
istnieje path.exists
import os
directory_path = './pkg1'
if os.path.exists(directory_path):
print("Directory exists")
else:
print("Directory does not exist")
tworzenie i usuwanie
folderów rekurencyjnie
makedirs, removedirs
import os
path = "C:/DIR/Python/New"
print(os.path.exists(path))
os.makedirs(path)
print(os.path.exists(path))
os.removedirs(path)
print(os.path.exists(path))
 Moduł os
aktualna katalogu getcwd jest katalogiem albo jest ścieżką os.path.isdir, os.path.isfile
import os import os
cwd = os.getcwd()
print("Current working directory:", cwd) print(f"Check if {os.path.basename(__file__)} is a file: {os.path.isfile(os.path.basename(__file__))}")
print(f"Check if {os.path.dirname(__file__)} is a file: {os.path.isfile(os.path.dirname(__file__))}")
zmiana katalogu chdir print(f"Check if {os.path.basename(__file__)} is a file: {os.path.isdir(os.path.basename(__file__))}")
print(f"Check if {os.path.dirname(__file__)} is a file: {os.path.isdir(os.path.dirname(__file__))}")
import os
def current_path():
print("Current working directory before")
print(os.getcwd()) przejście po folderach os.walk
print()
current_path() import os
os.chdir('../Classes')
current_path() for root, dirs, files in os.walk("."):
print(30 * "*")
listowanie katalogów listdir for name in files:
print(f"Files in {root}")
import os print(os.path.join(root, name))
print(os.listdir()) for name in dirs:
print(os.listdir("./")) print(f"Directories in {root}")
print(os.listdir("C:\\")) print(os.path.join(root, name))
 Zadanie 6.1
Zadanie:
• Napisz funkcję która będzie wyświetlała pliki i foldery w postaci drzewa
• Jako parametr wejściowy będzie używała ścieżki wejściowej
• Funkcja będzie wyświetlałą wszystkie pliki pod danym folderem
• Wykorzystać do tego należy np. os.walk albo listdir i isdir
 Moduł datetime
Moduł datetime jest najczęściej używany do:
• rejestrowanie zdarzeń — dzięki znajomości daty i godziny można określić, kiedy dokładnie w aplikacji
wystąpi błąd krytyczny. Podczas tworzenia logów można określić format daty i godziny;
• śledzenie zmian w bazie danych — czasami konieczne jest przechowywanie informacji o tym, kiedy rekord
został utworzony lub zmodyfikowany. Moduł datetime będzie w tym przypadku idealny;
• sprawdzanie poprawności danych — Znając aktualną datę i godzinę, jesteśmy w stanie zweryfikować
różnego rodzaju dane, np. czy kupon rabatowy wprowadzony przez użytkownika w naszej aplikacji jest
jeszcze ważny;
• przechowywanie ważnych informacji — Data i godzina pewnych działań musi zostać zachowana i musimy
sobie z tym poradzić.
 Moduł datetime
• Metoda Today zwraca obiekt daty reprezentujący
bieżącą datę lokalną.
• Należy pamiętać, że obiekt daty ma trzy atrybuty: rok,
miesiąc i dzień.
from datetime import date
today = date.today()
print("Today:", today)
print("Year:", today.year)
print("Month:", today.month)
print("Day:", today.day)
• Klasa date daje nam możliwość utworzenia
obiektu daty na podstawie znacznika czasu.
• Znacznik czasu to tak naprawdę różnica między
konkretną datą (łącznie z godziną) a godziną
00:00:00 (UTC) 1 stycznia 1970 r., wyrażoną w
sekundach.
• Aby utworzyć obiekt daty na podstawie znacznika
czasu, musimy przekazać uniksowy znacznik czasu
do metody fromtimestamp.
from datetime import date
import time
timestamp = time.time()
print("Timestamp:", timestamp)
d = date.fromtimestamp(timestamp)
print("Date:", d)
 Moduł datetime
• Moduł datetime udostępnia kilka metod tworzenia obiektu daty. Jedną z nich jest metoda fromisoformat,
która przyjmuje datę w formacie RRRR-MM-DD zgodnym z normą ISO 8601.
• Norma ISO 8601 określa sposób przedstawiania daty i godziny. Jest często używany, dlatego warto poświęcić
chwilę na zapoznanie się z nim.

from datetime import date

d = date.fromisoformat('2019-11-04')
print(d)

• Czasami może być konieczne zastąpienie roku, miesiąca lub dnia inną wartością. Nie można tego zrobić w
przypadku atrybutów roku, miesiąca i dnia, ponieważ są one tylko do odczytu.
• W takim przypadku możesz użyć metody o nazwie replace.
from datetime import date

d = date(1991, 2, 5)
print(d)

d = d.replace(year=1992, month=1, day=16)

print(d)
 Moduł datetime
• Inną pomocną funkcją przy pracy z datami jest metoda zwana dniem from datetime import date
powszednim.
• Zwraca dzień tygodnia jako liczbę całkowitą, gdzie 0 to poniedziałek, a 6 d = date(2023, 11, 21)
print(d.weekday())
to niedziela.
from datetime import time

• Moduł datetime posiada t = time(14, 53, 20, 1)

również klasę pozwalającą na
prezentację czasu print("Time:", t)
print("Hour:", t.hour)
print("Minute:", t.minute)
print("Second:", t.second)
import time
print("Microsecond:", t.microsecond)
class Student:
def take_nap(self, seconds):
• Przydatną funkcją jest też funkcja sleep – która
print("I'm very tired. I have to take a nap. See you later.")
odczekuje czas określony w sekundach time.sleep(seconds)
print("I slept well! I feel great!")

student = Student()
student.take_nap(5)
 Moduł datetime
import time
• Moduł time udostępnia funkcję o nazwie ctime, która konwertuje czas w
timestamp = 1572879180
sekundach od 1 stycznia 1970 r. (epoka Uniksa) na ciąg znaków. print(time.ctime(timestamp))
• Część funkcji dostępnych w module time wymaga znajomości klasy struct_time. import time
• Klasa struct_time umożliwia także dostęp do wartości za pomocą indeksów.
Indeks 0 zwraca wartość w tm_year, natomiast 8 zwraca wartość w tm_isdst timestamp = 1572879180
• Wyjątkami są tm_zone i tm_gmoff, do których nie można uzyskać dostępu za print(time.gmtime(timestamp))
print(time.localtime(timestamp))
pomocą indeksów.
• Moduł time posiada funkcje oczekujące obiektu struct_time lub krotki
przechowującej wartości zgodnie z indeksami przedstawionymi
podczas omawiania klasy struct_time.
• Pierwsza z funkcji, zwana asctime, konwertuje obiekt struct_time lub
timestamp = 1572879180
krotkę na ciąg znaków. Zauważ, że do pobrania obiektu struct_time st = time.gmtime(timestamp)
używana jest znana funkcja gmtime. Jeśli nie podasz argumentu
funkcji asctime, zostanie użyty czas zwrócony przez funkcję localtime print(time.asctime(st))
• Druga funkcja o nazwie mktime konwertuje obiekt struct_time lub print(time.mktime((2019, 11, 4, 14, 53, 0, 0, 308, 0)))
krotkę wyrażającą czas lokalny na liczbę sekund od epoki Uniksa. W
naszym przykładzie przekazaliśmy do niego krotkę
 Moduł datetime
• W module datetime data i godzina mogą być reprezentowane from datetime import datetime
jako oddzielne obiekty lub jako jeden. dt = datetime(2019, 11, 4, 14, 53)
• Klasa łącząca datę i godzinę nazywa się datetime.
print("Datetime:", dt)
print("Date:", dt.date())
print("Time:", dt.time())
• Klasa datetime ma kilka metod zwracających bieżącą datę i
godzinę. Metody te to:
• today() — zwraca bieżącą lokalną datę i godzinę z atrybutem
tzinfo ustawionym na None;
• now() — zwraca bieżącą lokalną datę i godzinę taką samą jak
from datetime import datetime
metoda Today, chyba że przekażemy jej opcjonalny
argument tz. Argument tej metody musi być obiektem print("today:", datetime.today())
podklasy tzinfo; print("now:", datetime.now())

from datetime import datetime
dt = datetime(2020, 10, 4, 14, 55)
print("Timestamp:", dt.timestamp())
from datetime import date
d = date(2020, 1, 4)
print(d.strftime('%Y/%m/%d'))
from datetime import time
from datetime import datetime
t = time(14, 53)
print(t.strftime("%H:%M:%S"))
dt = datetime(2020, 11, 4, 14, 53)
print(dt.strftime("%y/%B/%d %H:%M:%S"))
Moduł datetime
• Wyliczanie znacznik czasu na podstawie podanej daty i godziny jest to
możliwe dzięki metodzie timestamp udostępnianej przez klasę datetime.
• Metoda strftime przyjmuje tylko jeden argument w postaci ciągu znaków
określający format, który może składać się z dyrektyw.
• Dyrektywa to ciąg składający się ze znaku % (procent) oraz małej lub
dużej litery, np. dyrektywa %Y oznacza rok, a wiek jest liczbą dziesiętną.
%Y – zwraca rok ze stuleciem w postaci liczby dziesiętnej.
%m – zwraca miesiąc jako liczbę dziesiętną uzupełnioną zerami.
%d – zwraca dzień jako liczbę dziesiętną uzupełnioną zerami.
• Formatowanie działa również na datę.
• Pierwszy z zastosowanych formatów dotyczy wyłącznie czasu.
%H zwraca godzinę jako liczbę dziesiętną uzupełnioną zerami,
%M zwraca minutę jako liczbę dziesiętną uzupełnioną zerami,
%S zwraca sekundę jako liczbę dziesiętną uzupełnioną zerami.
 Moduł datetime
• Funkcja strftime jest dostępna również w module time.
• Różni się nieco od metod strftime w klasach udostępnianych przez import time
moduł datetime tym, że oprócz argumentu format może przyjmować
timestamp = 1572879180
także (opcjonUmiejętność tworzenia formatu może być pomocna st = time.gmtime(timestamp)
podczas korzystania z metody zwanej strptime w klasie datetime. W
przeciwieństwie do metody strftime tworzy obiekt datetime z ciągu print(time.strftime("%Y/%m/%d %H:%M:%S", st))
print(time.strftime("%Y/%m/%d %H:%M:%S"))
znaków reprezentującego datę i godzinę.Metoda strptime wymaga
określenia formatu, w jakim zapisano datę i godzinę.alnie) obiekt
krotki lub struct_time.
• Jeśli nie przekażesz obiektu krotki lub obiektu struct_time,
formatowanie zostanie wykonane przy użyciu bieżącego czasu
lokalnego from datetime import datetime
print(datetime.strptime("2022/11/04 14:53:00",
• Umiejętność tworzenia formatu może być pomocna podczas "%Y/%m/%d %H:%M:%S"))
korzystania z metody zwanej strptime w klasie datetime.
• W przeciwieństwie do metody strftime tworzy obiekt datetime z
ciągu znaków reprezentującego datę i godzinę.
• Metoda strptime wymaga określenia formatu, w jakim zapisano datę
i godzinę.
 Moduł datetime
from datetime import date
• W module datetime istnieje klasa o nazwie timedelta, która pozwala from datetime import datetime
przeprowadzać obliczenia dotyczące daty i godziny. d1 = date(2023, 11, 4)
• Aby utworzyć obiekt timedelta, należy odjąć obiekty typu date lub d2 = date(2022, 11, 4)
datetime.
print(d1 - d2)
from datetime import timedelta
from datetime import date dt1 = datetime(2023, 11, 4, 0, 0, 0)
from datetime import datetime dt2 = datetime(2020, 11, 4, 14, 53, 0)

delta = timedelta(weeks=2, days=2, hours=2) print(dt1 - dt2)

print(delta)
from datetime import timedelta
delta2 = delta * 2
print(delta2) delta = timedelta(weeks=2, days=2, hours=3)
print(delta)
d = date(2023, 10, 4) + delta2
print(d)

dt = datetime(2023, 10, 4, 14, 53) + delta2

print(dt)
 Zadanie 6.2
Zadanie:
• Napisz program w pythonie używający datetime i time do wyświetlenia:
- dzisiejszej daty (dodając również wyświetlanie daty w następujących formatach
2020/11/04 14:53:00
20/November/04 14:53:00 PM
- ilości dni do końca roku
- ilości dni od początku roku
- Informacji jaki to dzień tygodnia, jaki to miesiąc i rok
- który tydzień roku
 Moduł kalendarz
• Oprócz modułów datetime i time, standardowa biblioteka Pythona udostępnia moduł o nazwie kalendarz,
który jak sama nazwa wskazuje, oferuje funkcje związane z kalendarzem
• Jednym z nich jest oczywiście wyświetlanie kalendarza. Ważne jest, aby dni tygodnia były wyświetlane od
poniedziałku do niedzieli, a każdy dzień tygodnia miał swoją reprezentację w postaci liczby całkowitej
• Poniższa tabela przedstawia reprezentację dni tygodnia w module kalendarza.
• W przypadku miesięcy wartości całkowite są indeksowane od 1, tj. styczeń jest reprezentowany przez 1, a
grudzień przez 12.
Day of the week Integer value Constant
Monday 0 calendar.MONDAY
Tuesday 1 calendar.TUESDAY
Wednesday 2 calendar.WEDNESDAY
Thursday 3 calendar.THURSDAY
Friday 4 calendar.FRIDAY
Saturday 5 calendar.SATURDAY
Sunday 6 calendar.SUNDAY
 Moduł kalendarz
• Wyświetlanie kalendarza dla całego roku
import calendar
print(calendar.calendar(2023))
w – szerokość kolumny daty (domyślnie 2)
l – liczba linii tygodniowo (domyślnie 1)
c – ilość odstępów pomiędzy kolumnami miesiąca
(domyślnie 6)
m – liczba kolumn (domyślnie 3)
import calendar
print(calendar.calendar(2023, w=3, l=2, c=10, m = 4))
• Wyświetlanie kalendarza dla miesiąca
import calendar
print(calendar.month(2023, 11))
w – szerokość kolumny daty (domyślnie 2)
l – liczba linii tygodniowo (domyślnie 1)
• Rozpoczęcie miesiąca od określonego dnia
import calendar
calendar.setfirstweekday(calendar.SUNDAY)
calendar.prmonth(2023, 12)
• Pokazanie który to dzień tygodnia
import calendar
print(calendar.weekday(2023, 12, 24))
• Wyświetlenie nagłówka tygodnia (ilość znaków)
import calendar
print(calendar.weekheader(2))
• Sprawdzenie czy rok jest przestępny i ile lat jest
przestępnych w określonym zakresie
import calendar
print(calendar.isleap(2024))
print(calendar.leapdays(2012, 2024))
 Moduł kalendarz
• Iteracja po numerze dni tygodnia • Wyświetlanie listy tupli dzień (miesiąca, dień tygodnia)

import calendar import calendar

c = calendar.Calendar(calendar.SUNDAY) c = calendar.Calendar()

for weekday in c.iterweekdays(): for data in c.monthdays2calendar(2023, 12):

print(weekday, end=" ") print(data)

• Iteracja po datach miesiąca

import calendar

c = calendar.Calendar()

for date in c.itermonthdates(2023, 11):

print(date, end=" ")
 Moduł Random
• Moduł Python Random to wbudowany moduł Pythona, który służy do generowania liczb losowych w
Pythonie.
• Są to liczby pseudolosowe, co oznacza, że nie są one naprawdę losowe.
• Moduł ten może służyć do wykonywania losowych działań, takich jak generowanie liczb losowych,
drukowanie losowej wartości dla listy lub ciągu znaków

• losowanie wartości z tablicy choice • losowanie wartości całkowitej z zakresu randint

import random import random

lst_umbers = [1, 2, 3, 4, 5, 6] r1 = random.randint(5, 15)

print(random.choice(lst_umbers)) print(f"Random number between 5 and 15 = {r1}")
lst_names = ["Adam", "Zosia", "Tomek", "Artur"] r2 = random.randint(-10, -2)
print(random.choice(lst_names)) print(f"Random number between -10 and -2 = {r2}")
 Moduł Random
• losowanie wartości z zakresu 0.0 – 1.0 random

import random
• losowanie wartości z określonego zakresu o określonym skoku
v = random.random() randrange
print(f"Random value between 0.0 and 1.0 = {v}") import random

• mieszanie wartości w liście shuffle print(f"Random value form range 1 - 10 (step 1) = {random.randrange(1, 10)}")
print(f"Random value form range 1 - 10 (step 2) = {random.randrange(1, 10, 2)}")
import random print(f"Random value form range 0 - 101 (step 10) = {random.randrange(0, 101, 10)}")

sample_list = [1, 2, 3, 4, 5]

print(f"Original list : {sample_list}")

random.shuffle(sample_list)
print(f"After the first shuffle : {sample_list}")

random.shuffle(sample_list)
print(f"After the second shuffle : {sample_list}")
 Moduł Random przykłady
• Generowanie hasła

import random
import string
number_of_characters = 8
characters = string.ascii_letters + string.digits + string.punctuation
• Losowanie słownika ze studentami
password = ''.join(random.choice(characters) for i in range(number_of_characters))
print("Random password is:", password)
import random

student_dict = {'Adam': 80, 'Basia': 75, 'Daniel': 95, 'Ewa': 66}

print("Dictionary Before Shuffling")
print(student_dict)
keys = list(student_dict.keys())
random.shuffle(keys)

ShuffledStudentDict = dict()
for key in keys:
ShuffledStudentDict.update({key: student_dict[key]})

print("\nDictionary after Shuffling")

print(ShuffledStudentDict)
 Zadanie 6.3
Zadanie:
• Napisz grę w kości z komputerem gdzie każdy gracz rzuca pięcioma k6.
• Gra jest kościanym pokerem.
• Do tego celu wykorzystaj bibliotekę random.

Zasady:
Nic – pięć nie tworzących żadnego układu oczek.
Para – dwie kości o tej samej liczbie oczek.
Dwie Pary – dwie pary kości, o tej samej liczbie oczek.

Wygrana
Trójka – trzy kości o tej samej liczbie oczek.
Mały Strit – kości pokazujące wartości od 1 do 5, po kolei.
Duży Strit – kości pokazujące wartości od 2 do 6, po kolei.
Full – jedna para i trójka.
Kareta – cztery kości o tej samej liczbie oczek.
Poker – pięć kości o tej samej liczbie oczek.
 Moduł math
Stałe math
math.e Zwraca liczbę Eulera (2,7182...)
math.inf Zwraca zmiennoprzecinkową dodatnią nieskończoność
math.nan Zwraca zmiennoprzecinkową wartość NaN (nie liczbę).
math.pi Zwraca PI (3.1415...)math.tau Zwraca tau (6.2831...)

Funkcje math
math.ceil() Zaokrągla liczbę w górę do najbliższej liczby całkowitej
math.cos() Zwraca cosinus liczby
math.floor() Zaokrągla liczbę w dół do najbliższej liczby całkowitej
math.exp() Zwraca E podniesione do potęgi x
math.log() Zwraca logarytm naturalny liczby lub logarytm liczby o podstawie
math.pow() Zwraca wartość x do potęgi y
math.sin() Zwraca sinus liczby
math.fabs() Zwraca wartość bezwzględną liczby
math.sqrt() Zwraca pierwiastek kwadratowy z liczby
math.radians() Konwertuje wartość w stopniach na radiany
math.degrees() Konwertuje kąt z radianów na stopnie