PyQt - wstęp do tworzenia programów okienkowych

Stronę tą wyświetlono już: 11933 razy

Jak zapewne zauważyliście w Pythonie istnieje możliwość tworzenia programów okienkowych, które np. coś rysują. Przykładem są tutaj omawiane już wcześniej moduł turtle czy biblioteka matplotlib. Tym razem opiszę pokrótce możliwość tworzenia interfejsów graficznych w bibliotece PyQt.

Najpierw jednak instalacja PyQt:

pip install pyqt4

Qt designer - graficzne tworzenie interfejsu graficznego programu

Pod systemem Linux można zainstalować sobie taki dodatek o nazwie Qt designer. Oprogramowanie to pozwala na tworzenie interfejsu programu w trybie graficznym. Po uruchomieniu tego programu pojawić się naszym oczom powinno okno z poniższej ilustracji.

Qt designer - widok początkowy — Rys. 1
**Qt designer** - widok początkowy (po uruchomieniu)

Jak widać na załączonym rysunku, na powitanie program wyświetla okno Nowy formularz, ja wybieram to co jest zaznaczone na początku, czyli Widget i ciesząc się niezmiernie klikam przycisk Utwórz. Wynikiem tego działania będzie pojawienie się standardowego projektu pustego okna. Do projektu należy dodać kilka standardowych kontrolek tak jak pokazane zostało to na poniższej ilustracji.

Widok Qt Designer-a z utworzonym interfejsem graficznym przyszłego programu — Rys. 2
Widok **Qt Designer-a** z utworzonym interfejsem graficznym przyszłego programu

W projekcie użyto następujących kontrolek:

QPushButton - kontrolka przycisku, której właściwość objectName powinna zostać zmieniona na Calculate;
QLineEdit - kontrolka tekstu, której właściwość objectName powinna zostać zmieniona na writeText
QPlainTextEdit - kontrolka tekstu wieloliniowego, której właściwość objectName powinna zostać zmieniona na wynik

Nie będę wchodził w szczegóły omawiania interfejsu programu, po prawej jest okno z kontrolkami, po lewej jest okno z właściwościami, które pojawiają się po zaznaczeniu danej kontrolki w projekcie.

Po utworzeniu tego jakże zaawansowanego technicznie oprogramowania należy niezwłocznie zapisać projekt np. do pliku o nazwie projekt.ui, co też i z najdzikszą wręcz rozkoszą ja uczyniłem.

Konwersja pliku .ui do kodu Pythonowego

Nadeszła wiekopomna chwila, by zamienić plik projekt.ui w plik projekt.py, co też z i uczyniłem wpisując w systemowej konsoli następujące polecenie:

pyuic4 projekt.ui > projekt.py

Wynikiem działania powyższego kodu będzie powstanie pliku projekt.py, w którym to znajdzie się kod naszego okna z kontrolkami.

Kod programu

Utworzę sobie program o nazwie Kalkulator, który będzie działał trochę tak jak kalkulator naukowy. Poniżej zamieszczam kod programu:

Listing 1

#!/usr/bin/env python3
# coding: utf-8
import sys
from PyQt4 import QtCore, QtGui
from projekt import Ui_Form
from math import * # importuję wszystkie funkcje z biblioteki math
def silnia(n):
"""
Funkcja oblicza silnię wykorzystując do tego celu pętlę iteracyjną
"""
if n == 0:
return 1
elif n < 0:
return None
wynik = 1
for i in range(2, n + 1): # generator od 2 do n
wynik *= i
return wynik
class MyForm(QtGui.QMainWindow):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.ui = Ui_Form()
self.ui.setupUi(self)
self.setWindowTitle("Kalkulator 1.0")
self.setWindowOpacity(0.8)
QtCore.QObject.connect(self.ui.Calculate,QtCore.SIGNAL("clicked()"), self.calculate_value)
QtCore.QObject.connect(self.ui.writeText,QtCore.SIGNAL("returnPressed()"), self.calculate_value)
def calc_text(self, errortext, calcText):
if calcText == "":
self.ui.wynik.setPlainText(self.ui.writeText.text() + " = " + errortext)
else:
self.ui.wynik.setPlainText(self.ui.writeText.text() + " = " + errortext + "n" + calcText)
def calculate_value(self):
calcText = self.ui.wynik.toPlainText() # pobieranie tekstu zawartego w kontrolce wynik
try:
exp = eval(self.ui.writeText.text())
self.calc_text(str(exp), calcText)
except ZeroDivisionError as e:
self.calc_text('Dzielisz przez zero ({0})'.format(e), calcText)
except NameError as e:
self.calc_text('Nieznana zmienna ({0})'.format(e), calcText)
except TypeError as e:
self.calc_text('Błąd typu danych lub deklaracji zmiennej ({0})'.format(e), calcText)
except:
self.calc_text('Błąd składni',calcText)
self.ui.writeText.setText("") # ustawianie tekstu w kontrolce writeText
self.ui.writeText.setFocus(True) # przypisanie fokusa kontrolce writeText
if __name__ == "__main__":
app = QtGui.QApplication(sys.argv)
myapp = MyForm()
myapp.show()
sys.exit(app.exec_())

W powyższym kodzie z wygenerowanego pliku projekt.py zaimportowana została klasa Ui_Form, która opisuje elementy okna i ich właściwości. Utworzona została również klasa odpowiedzialna za obsługę okna, która nazywa się MyForm, nie trudno zauważyć, że klasa ta dziedziczy po klasie QtGui.QMainWindow. Konstruktor klasy MyForm przyjmuje jeden opcjonalny argument, którym jest okno rodzica (domyślna wartość None). Pole klasy MyForm o nazwie ui przyjmuje jako wartość klasę Ui_Form następnie następuje uruchomienie metody setupUi, która przyjmuje jako argument wskaźnik do klasy MyForm.

Kolejne dwie metody wywołane w konstruktorze ustawiają tytuł okna i jego przezroczystość, natomiast ostatnie dwie tworzą połączenie pomiędzy kontrolkami formy a metodą calculate_value. W metodzie calculate_value zawarte zostały instrukcje związane z obliczeniami.

W bloku instrukcji warunkowej na końcu kodu utworzony został obiekt QtGui.QApplication, odpowiedzialny za wywołanie programu i przechwycenie argumentów z jakimi ten został uruchomiony, a następnie stworzony został obiekt typu MyForm. Metoda show powoduje wyświetlenie interfejsu graficznego programu. Zakończenie (zamknięcie okna) powoduje wywołanie funkcji z biblioteki sys.

Poniżej zamieszczam screen programu Kalkulator.