Przez Natalia Borowska-Żuchowska w python — 20 wrz 2025

# Python 9 (def, GUI, flet)

Def

W Pythonie słowo kluczowe def służy do definiowania funkcji — czyli bloków kodu, które można wywoływać wielokrotnie, przekazując im dane wejściowe (argumenty), a opcjonalnie zwracając wynik (za pomocą return).

# Zad. 1 Napisz funkcję do której użytkownik będzie przekazywał tekst z imieniem.
# Funkcja ma zwrócić tekst witający użytkownika 
# (czyli sklejający słowo witaj z przekazanym imieniem)

def powitanie(imie:str) ->str:
    print(f"Witaj {imie}!")
          
powitanie("Natalia")  #Witaj Natalia!

# Zad. 2 Pole koła
def pole_kola(r: int|float) -> int|float:
    pole_kola = 3.14159 * r**2
    return pole_kola
print(pole_kola(4))

# Zad. 3 Obwód koła
def obwod_kola(r: int|float)->int|float:
    obwod_kola=3.14159 * 2 * r
    return obwod_kola
print(obwod_kola(4))

# Zad. 4 Napisz funkcję do której użytkownik będzie przekazywał liczbę całkowitą.
# Policz silnię tej liczby.
liczba = int(input("Podaj liczbę całkowitą: "))
def silnia(liczba:int) -> int:
    wynik = 1
    for i in range(1, liczba+1):#pamiętamy, że w range ostatni element zakresu nie jest włączany -> stąd +1 
        wynik *= i
    return wynik

print(f"Silnia z {liczba} to {silnia(liczba)}")

# Zad.5 Napisz funkcję do której użytkownik będzie przekazywał tekst.
# Zwróć ten tekst odwrócony.

tekst = input("Wprowadź słowo: ")

def odwrocone_znaki(tekst:str) -> str:
    return tekst[::-1]

print(odwrocone_znaki(tekst))

# Zad. 6
# Napisz funkcję do której użytkownik będzie przekazywał listę słów.
# Sprawdź czy któreś ze słów na liście jest palindromem. Zwróc listę wartości True / False

slowa = input("Wprowadź wybrane słowa. Jako separatora użyj spacji: ")
lista_slow = list(slowa.strip().split())
print(lista_slow)

def palindrom_check(lista_slow):
    for slowo in lista_slow:
        if slowo[::-1] == slowo:
            print(f" {slowo} to palindrom")
        else:
            print(f" {slowo} nie jest palindromem")

palindrom_check(lista_slow)

Alternatywnie żeby zwracało listę True/False:
def palindromy(lista_slow):
    return [slowo == slowo[::-1] for slowo in lista_slow]

print(palindromy(lista_slow))

Zmienne globalne, a prywatne

Zmienne globalne:

są zdefiniowane poza funkcjami (czyli na najwyższym poziomie pliku/skryptu),
są widoczne i dostępne w całym pliku, także wewnątrz funkcji (tylko do odczytu, jeśli ich nie nadpisujemy),
można je modyfikować wewnątrz funkcji, ale trzeba użyć słowa kluczowego global - TO NIE JEST DOBRA PRAKTYKA

Zmienne lokalne (prywatne w praktyce):

są tworzone wewnątrz funkcji,
istnieją tylko w czasie działania tej funkcji,
nie są widoczne na zewnątrz — nie można się do nich odwołać spoza funkcji.

wynik = 9

def kwadrat(x:int) -> int:
    wynik = x * x
    return wynik

kwadrat(4)
print(wynik)   # 9, bo to zmienna globalna



wynik = 9

def kwadrat(x:int) -> int:
    wynik = x * x
    return wynik

wynik = kwadrat(4)
print(wynik)   # 16

GUI versus CLI

CLI (Command Line Interface) - to tekstowy interfejs użytkownika, w którym wpisujesz komendy w konsoli (terminalu), a program zwraca tekst jako odpowiedź. To przeciwieństwo GUI - nie ma okien ani przycisków, tylko tekstowe polecenia i wyniki.

GUI (Graphical User Interface) to graficzny interfejs użytkownika – sposób interakcji z programem za pomocą okien, przycisków, pól tekstowych, ikon, list itp., zamiast wpisywania komend w konsoli. Program z GUI jest zwykle zdarzeniowy: reaguje na akcje użytkownika (kliknięcia, wpisywanie tekstu, skróty klawiszowe).

GUI w Pythonie – popularne biblioteki

Tkinter (wbudowany w Pythona) - prosty start, ALE wygląd elementów jest jak aplikacja sprzed lat:) Nie wszystkie nowoczesne funkcje i struktury są obsługiwane przez Tkinter.
Qt (biblioteki PyQt / PySide) - rozbudowane, profesjonalne aplikacje, ale skomplikowany framework, niezbyt na start.
GTK (biblioteka PyGObject) - zawężone możliwości modyfikacjiwyglądu, ale przyjazny do pracy.
Kivy - aplikacje wieloplatformowe, także mobilne.
DearPyGui - często wykorzystywany w applikacjach naukowych, świetnie wykorzystuje możliwości karty graficznej.
Flet to framework pozwalający pisać aplikacje interfejsowe w Pythonie (i kilku innych językach), które działają podobnie jak w Flutterze. To taki flutter, ale nie pisany w Dart, tylko w Pythonie.

flet.dev.docs

Instalacja flet

# W terminalu:

pip3 install flet[all]

import flet


def main(page: flet.Page):
    # Sekcja ogólnych ustawień okna aplikacji    

    page.title = "Tytul"  # np. tytulu okna

    # Sekcja deklaracji komponentów
    # - czyli opisujemy np. jakie pola tekstowe,
    # przyciski etc mają się znaleźć w oknie i jak 
    # mają one wyglądać.

    tekst = flet.Text("Jakiś tekst.") # np.tekst
    przycisk = flet.FilledButton("wciśnij mnie") # np. przycisk

    # Sekcja umieszczania komponentów w oknie
    # - czyli decydujemy jaki będzie ich układ,
    # w jakiej kolejności się będą wyświetlać,
    # gdzie zostaną umieszone
    page.add(
        tekst,
        przycisk,
    )


flet.app(main) # to wywołuje funkcję main

Trzy sekcje:

Sekcja ogólnych ustawień okna app.
Sekcja deklaracji komponentów.
Sekcja umieszczania zadeklarowanych komponentów w oknie.

# BLOK 1
# Napisz aplikację w Flet-ie wyświetlającą komunikat "Witaj!"
# Dodaj do niej pole tekstowe do którego można wpisać imię. Odpowiednio je zatytułuj.
# Dodaj guzik. Po jego naciśnięciu komunikat "Witaj!" ma się zmienić tak, żeby było uwzględniał wpisane imię.

import flet as ft

def main(page:ft.Page):
    def powitanie(_e):
        if pole.value:
            imie=pole.value
            tekst.value = f"Witaj {imie}"
            page.update()
    page.title = "Moj pierwszy flet"
    page.horizontal_alignment = ft.CrossAxisAlignment.CENTER
    page.vertical_alignment = ft.MainAxisAlignment.START

    tekst = ft.Text("Witaj")
    pole = ft.TextField(label="Wprowadź swoje imię: ")
    przycisk =ft.FilledButton("Click here", on_click=powitanie)

    page.add(tekst,
             pole,
             przycisk,
         )
ft.app(main)

# BLOK 2
# Stwórz aplikację z polem tekstowym do wprowadzania danych

import flet as ft

def main(page:ft.Page):
    def dodaj(_e):
        if pole_wprowadzenia.value:
            lista.controls.append(ft.Text(pole_wprowadzenia.value))
            pole_wprowadzenia.value = ""
            page.update()

    page.title = "Lista zakupów"

    pole_wprowadzenia = ft.TextField(label="Wprowadź nowy element do listy: ", on_submit=dodaj)
    przycisk = ft.FilledButton("Zatwierdź", on_click=dodaj)
    lista = ft.ListView(expand=True)

    page.add(pole_wprowadzenia,
             przycisk,
             lista
             )
    
ft.app(main)

Aby uruchomić aplikację z terminalu: