Интересные алгоритмы кластеризации, часть вторая: dbscan

Обзор основных модулей

  • QtCore — основные не графические классы: система сигналов и слотов, платформонезависимые абстракции для Unicode, потоков, разделяемой памяти, регулярных выражений и т. д.
  • QtGui — компоненты графического интерфейса (элементы управления), основанные на визуальном представлении.
  • QtNetwork — классы для сетевого программирования. Например, клиентов и серверов через UDP и TCP.
  • QtOpenGL — классы, позволяющие использовать OpenGL и 3D-графику в приложениях PyQt.
  • QtScript — классы, позволяющие использовать встроенный в Qt интерпретатор JavaScript для управления приложением.
  • QtSql — классы для интеграции с базами данных с помощью SQL.
  • QtSvg — классы для отображения векторной графики в формате SVG.
  • QtXml — классы, реализующие обработку XML.
  • uic — реализация обработки XML-файлов, созданных в Qt Designer, для генерации из них Python-кода графического интерфейса.

Installing multiple versions

On Unix and Mac systems if you intend to install multiple versions of Python
using the same installation prefix ( argument to the configure
script) you must take care that your primary python executable is not
overwritten by the installation of a different version. All files and
directories installed using contain the major and minor
version and can thus live side-by-side. also creates
which refers to . If you
intend to install multiple versions using the same prefix you must decide which
version (if any) is your «primary» version. Install that version using . Install all other versions using .

For example, if you want to install Python 2.7, 3.6, and 3.9 with 3.9 being the
primary version, you would execute in your 3.9 build directory
and in the others.

Примеры программ

Программа Hello, world!

Стандартный минималистичный пример, дающий представление о PyQt. Программа показывает пустое окно, обладающее базовыми функциями — изменение размера, сворачивание, разворачивание:

#! /usr/bin/env python2
# -*- coding: utf-8 -*-
#
import sys
from PyQt4.QtGui import * # компоненты интерфейса

# Каждое приложение должно создать объект QApplication
# sys.argv - список аргументов командной строки
application = QApplication(sys.argv)

# QWidget - базовый класс для всех объектов интерфейса
# пользователя; если использовать для виджета конструктор
# без родителя, такой виджет станет окном
widget = QWidget()

widget.resize(320, 240) # изменить размеры виджета
widget.setWindowTitle("Hello, World!") # установить заголовок
widget.show() # отобразить окно на экране

sys.exit(application.exec_()) # запуск основного цикла приложения

Результат выполнения программы в Linux с KDE

Более сложный пример

В этом примере показаны принципы создания более серьёзных программ. Используется Python 3 и Qt Designer. Применяется объектно-ориентированный подход, позволяющий разделить визуальное представление и логику программы.

Состав программы:

  • test.pyw — главный файл, запускающий программу.
  • mainform.py — файл описания главного окна.
  • mainform.ui — файл, содержащий автоматически сгенерированное при помощи Qt Designer описание главного окна. В программе Qt Designer был создан проект, основанный на QDialog и выбраны 2 элемента: кнопка с именем pushButton, текстовая метка с именем label.

Содержание файла test.pyw:

#! /usr/bin/env python3
#
import sys
from PyQt4 import QtCore, QtGui # подключает основные модули PyQt
import mainform # подключает модуль описания формы

def main():
    app = QtGui.QApplication(sys.argv)  # создаёт основной объект программы
    form = mainform.MainForm()  # создаёт объект формы
    form.show()  # даёт команду на отображение объекта формы и содержимого
    return app.exec()  # запускает приложение

if __name__ == "__main__"
    sys.exit(main())

Содержание файла mainform.py:

#! /usr/bin/env python3
#
from PyQt4 import QtCore, QtGui, uic # подключает основные модули PyQt

# прототип главной формы
class MainForm(QtGui.QDialog):

    # конструктор
    def __init__(self):
        super(MainForm, self).__init__()

        # динамически загружает визуальное представление формы
        uic.loadUi("mainform.ui", self)

        # связывает событие нажатия на кнопку с методом
        self.connect(self.pushButton, QtCore.SIGNAL("clicked()"),
            self.setLabelText)

    def setLabelText(self):
        self.label.setText("New label text")

Результат выполнения программы в Windows XP

В этом примере довольно простая функциональность, представленная методом setLabelText. Однако при необходимости реализовать более сложную обработку поступающих данных, целесообразно вынести эту обработку в отдельный модуль (файл).

Detailed Description¶

class

Constructs a null point, i.e. with coordinates (0.0, 0.0)

See also

Constructs a copy of the given .

See also

Constructs a point with the given coordinates ( , ).

See also

()
Return type
()
Return type
static (p1, p2)
Parameters
  • p1 –

  • p2 –

Return type
QPointF p( 3.1, 7.1);
QPointF q(-1.0, 4.1);
int lengthSquared = QPointF::dotProduct(p, q);   // lengthSquared becomes 26.01

Returns the dot product of and .

()
Return type

Returns if both the x and y coordinates are set to 0.0 (ignoring the sign); otherwise returns .

()
Return type

Returns the sum of the absolute values of and , traditionally known as the “Manhattan length” of the vector from the origin to the point.

See also

(p2)
Parameters

p2 –

Return type
(m)
Parameters

m –

Return type
(matrix)
Parameters

matrix –

Return type
(matrix)
Parameters

matrix –

Return type
(m)
Parameters

m –

Return type
(c)
Parameters

c –

Return type
(c)
Parameters

c –

Return type
(c)
Parameters

c –

Return type

Multiplies this point’s coordinates by the given , and returns a reference to this point. For example:

p = QPointF(-1.1, 4.1)
p *= 2.5  # p becomes (-2.75, 10.25)

See also

()
Return type
(p2)
Parameters

p2 –

Return type
(p)
Parameters

p –

Return type

Adds the given to this point and returns a reference to this point. For example:

p = QPointF( 3.1, 7.1)
q = QPointF(-1.0, 4.1)
p += q    # p becomes (2.1, 11.2)

See also

()
Return type
(p2)
Parameters

p2 –

Return type
(p)
Parameters

p –

Return type

Subtracts the given from this point and returns a reference to this point. For example:

p = QPointF( 3.1, 7.1)
q = QPointF(-1.0, 4.1)
p -= q    # p becomes (4.1, 3.0)

See also

(divisor)
Parameters

divisor –

Return type
(c)
Parameters

c –

Return type

Divides both x and y by the given , and returns a reference to this point. For example:

p = QPointF(-2.75, 10.25)
p /= 2.5  # p becomes (-1.1, 4.1)

See also

(p2)
Parameters

p2 –

Return type
(x)
Parameters

x –

Sets the x coordinate of this point to the given coordinate.

See also

(y)
Parameters

y –

Sets the y coordinate of this point to the given coordinate.

See also

()
Return type

Rounds the coordinates of this point to the nearest integer, and returns a object with the rounded coordinates.

See also

()
Return type
()
Return type

Returns a point with x and y coordinates exchanged:

QPointF{1.0, 2.0}.transposed() // {2.0, 1.0}

See also

()
Return type

Returns the x coordinate of this point.

See also

()
Return type

Returns the y coordinate of this point.

See also

Detailed Description¶

Subclassing QSpinBox

class (parent=None)

Constructs a spin box with 0 as minimum value and 99 as maximum value, a step value of 1. The value is initially set to 0. It is parented to .

See also

()
Return type

unicode

()
Return type

See also

()
Return type

See also

()
Return type

See also

()
Return type

unicode

See also

(base)
Parameters

base –

See also

(max)
Parameters

max –

See also

(min)
Parameters

min –

See also

(prefix)
Parameters

prefix – unicode

See also

(min, max)
Parameters
  • min –

  • max –

Convenience function to set the , and values with a single function call.

setRange(minimum, maximum)

is equivalent to:

setMinimum(minimum)
setMaximum(maximum)

See also

(val)
Parameters

val –

See also

(stepType)
Parameters

stepType –

Sets the step type for the spin box to , which is single step or adaptive decimal step.

Adaptive decimal step means that the step size will continuously be adjusted to one power of ten below the current . So when the value is 1100, the step is set to 100, so stepping up once increases it to 1200. For 1200 stepping up takes it to 1300. For negative values, stepping down from -1100 goes to -1200.

Step direction is taken into account to handle edges cases, so that stepping down from 100 takes the value to 99 instead of 90. Thus a step up followed by a step down – or vice versa – always lands on the starting value; 99 -> 100 -> 99.

Setting this will cause the spin box to disregard the value of , although it is preserved so that comes into effect if adaptive decimal step is later turned off.

See also

(suffix)
Parameters

suffix – unicode

See also

(val)
Parameters

val –

See also

()
Return type

See also

()
Return type

See also

()
Return type

unicode

See also

(arg__1)
Parameters

arg__1 – unicode

(val)
Parameters

val –

Return type

unicode

This virtual function is used by the spin box whenever it needs to display the given . The default implementation returns a string containing printed in the standard way using .toString(), but with the thousand separator removed unless is set. Reimplementations may return anything. (See the example in the detailed description.)

Note: does not call this function for and that neither nor should be included in the return value.

If you reimplement this, you may also need to reimplement and

See also

()
Return type

See also

(arg__1)
Parameters

arg__1 – unicode

Note

This function is deprecated.

def callback_unicode(value_as_unicode):
    print 'unicode value changed:', repr(value_as_unicode)

app = QApplication(sys.argv)
spinbox = QSpinBox()
spinbox.valueChangedunicode.connect(callback_unicode)
spinbox.show()
sys.exit(app.exec_())
(arg__1)
Parameters

arg__1 –

def callback_int(value_as_int):
    print 'int value changed:', repr(value_as_int)

app = QApplication(sys.argv)
spinbox = QSpinBox()
spinbox.valueChangedunicode.connect(callback_unicode)
spinbox.show()
sys.exit(app.exec_())
(text)
Parameters

text – unicode

Return type

This virtual function is used by the spin box whenever it needs to interpret entered by the user as a value.

Subclasses that need to display spin box values in a non-numeric way need to reimplement this function.

Note: handles separately; this function is only concerned with the other values.

See also

Кнопка переключателя (toogle button)

Кнопка переключателя – это QPushButton в особом режиме. Это кнопка, которая имеет два состояния: нажатое и не нажатое. Мы переключаемся между этими двумя состояниями, кликая по ней. Существуют ситуации, где эта функциональность отлично подходит.

#!/usr/bin/python3
# -*- coding: utf-8 -*-

import sys
from PyQt5.QtWidgets import (QWidget, QPushButton,
    QFrame, QApplication)
from PyQt5.QtGui import QColor


class Example(QWidget):

    def __init__(self):
        super().__init__()

        self.initUI()


    def initUI(self):

        self.col = QColor(, , )

        redb = QPushButton('Red', self)
        redb.setCheckable(True)
        redb.move(10, 10)

        redb.clickedbool.connect(self.setColor)

        greenb = QPushButton('Green', self)
        greenb.setCheckable(True)
        greenb.move(10, 60)

        greenb.clickedbool.connect(self.setColor)

        blueb = QPushButton('Blue', self)
        blueb.setCheckable(True)
        blueb.move(10, 110)

        blueb.clickedbool.connect(self.setColor)

        self.square = QFrame(self)
        self.square.setGeometry(150, 20, 100, 100)
        self.square.setStyleSheet("QWidget { background-color: %s }" %
            self.col.name())

        self.setGeometry(300, 300, 280, 170)
        self.setWindowTitle('Toggle button')
        self.show()


    def setColor(self, pressed):

        source = self.sender()

        if pressed
            val = 255
        else val = 

        if source.text() == "Red"
            self.col.setRed(val)
        elif source.text() == "Green"
            self.col.setGreen(val)
        else
            self.col.setBlue(val)

        self.square.setStyleSheet("QFrame { background-color: %s }" %
            self.col.name())


if __name__ == '__main__'

    app = QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())

В нашем примере, мы создаём три кнопки переключателя и QWidget. Мы устанавливаем чёрный цвет фона. Кнопки переключателей будут переключать красные, зелёные и синие части значений цвета. Цвет фона будет зависеть от того, на какие кнопки переключателей мы нажали.

self.col = QColor(, , )

Это начальное значение цвета (чёрный).

redb = QPushButton('Red', self)
redb.setCheckable(True)
redb.move(10, 10)

Чтобы создать кнопку переключателя, мы создаём QPushButton и делаем её проверяемой, путём вызова метода setCheckable().

redb.clickedbool.connect(self.setColor)

Мы привязываем сигнал к нашему пользовательскому методу. Мы используем сигнал clicked, который работает с логическим значением.

source = self.sender()

Мы получаем кнопку, которая была переключена.

if source.text() == "Red"
    self.col.setRed(val)

В случае кнопки red, мы обновляем красную часть цвета соответственно.

self.square.setStyleSheet("QFrame { background-color: %s }" % self.col.name())

Мы используем таблицы стилей, чтобы менять цвет фона.

Slider.py

Again some simple codes to build a dialog.

main.py

Now we need to check if the dialog(s) are popping up when I run the main file. Go ahead and paste it. I’ll just add a single line later.

Run: main.py

Running the main.py file shows these two Dialog(s). We haven’t added any functionalities on slider and progressbar, so changing the position of the slider won’t do anything. Now it’s time to add some signal-slot codes. Are you ready?

Adding Signal to Slider_Dialog class

Let’s add a signal to the Slider_Dialog class. We are passing an integer value from Slider to the ProgressBar. To add a signal just add the following line after class declaration (before constructor).

If we needed to send a QString signal to pass we would have been done something like this.

changedValue = pyqtSignal('QString')

One more thing left with Slider.py

We created a signal but didn’t define any function with which other objects from other classes will listen to. Let’s add that,

We need to define when this function will start working. Since value will be passed/emitted whenever user changes the position of the slider.

We need to make some kind of connection between the QSlider component of Slider class and the signal function. We are going to make that connection when the object of the class is created.

Within the init_ui function, simply add the following line

# Setting a connection between slider position change and on_changed_value function we created earlierself.slider.valueChanged.connect(self.on_changed_value)

Now we’re done with the Slider.py. Let’s move on to the next section.

Creating a pyqtSlot on Progress.py

Adding a slot is pretty straightforward. You’ll just have to add a decorator and mention the parameter.

I’m going to define the function as get_slider_value. Add this function as any other ordinary functions of this class.

@pyqtSlot(int)def get_slider_value(self, val):    self.progressBar.setValue(val)

This slot grabs the integer val and sets it to the progressBar value. Simple as that.

But remember, we haven’t made any connection between ProgressBar_Dialog and Slider_Dialog. To keep things easy, I’m going to make a function which takes care of that problem

def make_connection(self, slider_object):    slider_object.changedValue.connect(self.get_slider_value)

If I call this function after creating an object of Slider_Dialog class. This function will make a signal-slot connection between the Slider_Dialog and ProgressBar_Dialog.

I am getting the changedValue pyqtSignal using the dot notation, then connecting with the get_slider_value function of the Slider_Dialog class.

Adding a final code to main.py

Don’t forget to call the make_connection function after you’ve created an object of Slider_Dialog class.

from SliderDialog.Slider import Slider_Dialogfrom ProgressDialog.Progress import ProgressBar_Dialogimport sysfrom PyQt5.QtWidgets import QApplicationif __name__ == '__main__':    app = QApplication(sys.argv)    sd = Slider_Dialog()    pb = ProgressBar_Dialog()# Making the connectionpb.make_connection(sd)    sys.exit(app.exec_())

That’s it!

Run the code, and see if it’s working properly. Here are the complete codes.

I hope it will solve the problem of passing data between objects of different classes. Stay tuned for next episodes. Thanks for reading!

QFileDialog

QFileDialog – это диалог, который позволяет пользователям выбирать файлы или папки. Файлы могут быть выбраны и для открытия, и для сохранения.

#!/usr/bin/python3
# -*- coding: utf-8 -*-

import sys
from PyQt5.QtWidgets import (QMainWindow, QTextEdit,
    QAction, QFileDialog, QApplication)
from PyQt5.QtGui import QIcon


class Example(QMainWindow):

    def __init__(self):
        super().__init__()

        self.initUI()


    def initUI(self):

        self.textEdit = QTextEdit()
        self.setCentralWidget(self.textEdit)
        self.statusBar()

        openFile = QAction(QIcon('open.png'), 'Open', self)
        openFile.setShortcut('Ctrl+O')
        openFile.setStatusTip('Open new File')
        openFile.triggered.connect(self.showDialog)

        menubar = self.menuBar()
        fileMenu = menubar.addMenu('&File')
        fileMenu.addAction(openFile)

        self.setGeometry(300, 300, 350, 300)
        self.setWindowTitle('File dialog')
        self.show()


    def showDialog(self):

        fname = QFileDialog.getOpenFileName(self, 'Open file', '/home')[

        f = open(fname, 'r')

        with f
            data = f.read()
            self.textEdit.setText(data)


if __name__ == '__main__'

    app = QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())

Пример показывает строку меню, виджет редактирования текста и строку состояния. Пункт меню показывает QtGui.QFileDialog, который используется для выбора файла. Содержимое файла загружается в виджет редактирования текста.

fname = QFileDialog.getOpenFileName(self, 'Open file', '/home')[

Мы показываем QFileDialog. Первая строка в методе getOpenFileName() – это заголовок. Вторая строка указывает на показываемую директорию. По умолчанию, файловый фильтр установлен в положение «Все файлы (*)».

f = open(fname, 'r')

with f
    data = f.read()
    self.textEdit.setText(data)

Выбранный файл читается и содержимое файла записывается в виджет редактирования текста.

В этой части руководства PyQt5, мы работали с диалогами.

Пишем код

Теперь у нас есть файл  с нужной частью дизайна нашего приложения и мы начинать работу над созданием его логики.

Создайте файл  в папке, где находится .

Используем дизайн

Для Python GUI приложения понадобятся следующие модули:

Также нам нужен код дизайна, который мы создали ранее, поэтому его мы тоже импортируем:

Так как файл с дизайном будет полностью перезаписываться каждый раз при изменении дизайна, мы не будем изменять его. Вместо этого мы создадим новый класс , который объединим с кодом дизайна для использования всех его функций:

В этом классе мы будем взаимодействовать с элементами интерфейса, добавлять соединения и всё остальное, что нам потребуется. Но для начала нам нужно инициализировать класс при запуске кода. С этим мы разберёмся в функции :

И чтобы выполнить эту функцию, мы воспользуемся привычной конструкцией:

В итоге  выглядит таким образом:

Если запустить этот код: , то наше приложение запустится!

Но нажатие на кнопку ничего не даёт, поэтому нам придётся с этим разобраться.

Добавляем функциональность в наше Python GUI приложение

Примечание Весь дальнейший код пишется внутри класса .

Начнём с кнопки Выберите папку. Привязать к функции событие вроде нажатия на кнопку можно следующим образом:

Добавьте эту строку в метод  класса , чтобы выполнить привязку при запуске приложения. А теперь взглянем на неё поближе:

  • : здесь — имя объекта, который мы определили в Qt Designer.  говорит само за себя и означает принадлежность к текущему классу;
  •  — событие, которое мы хотим привязать. У разных элементов разные события, например, у виджетов списка есть  и т.д.;
  • — метод, который привязывает событие к вызову переданной функции;
  • — просто функция (метод), которую мы описали в классе .

Для открытия диалога выбора папки мы можем использовать встроенный метод :

Если пользователь выберет директорию, переменной  присвоится абсолютный путь к выбранной директории, в противном случае она будет равна . Чтобы не выполнять код дальше, если пользователь закроет диалог, мы используем команду .

Для отображения содержимого директории нам нужно импортировать :

И получить список содержимого следующим образом:

Для добавления элементов в мы используем метод , а для удаления всех элементов у нас есть .

В итоге функция  должна выглядеть так:

Теперь, если запустить приложение, нажать на кнопку и выбрать директорию, мы увидим:

Так выглядит весь код нашего Python GUI приложения:

Это были основы использования Qt Designer и PyQt для разработки Python GUI приложения. Теперь вы можете спокойно изменять дизайн приложения и использовать команду без страха потерять написанный код.

Переопределение обработчика события

События в PyQt5 часто обрабатываются путём переопределения обработчиков.

#!/usr/bin/python3
# -*- coding: utf-8 -*-

import sys
from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import QWidget, QApplication


class Example(QWidget):

    def __init__(self):
        super().__init__()

        self.initUI()


    def initUI(self):

        self.setGeometry(300, 300, 250, 150)
        self.setWindowTitle('Event handler')
        self.show()


    def keyPressEvent(self, e):

        if e.key() == Qt.Key_Escape
            self.close()


if __name__ == '__main__'

    app = QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())

В этом примере, мы переопределяем обработчик события keyPressEvent().

def keyPressEvent(self, e):

    if e.key() == Qt.Key_Escape
        self.close()

Начинаем работу Python + Qt5 + QML урок №1 +8

  • 11.04.17 08:14


FUNNYDMAN

#326268

Хабрахабр


Tutorial

5300

Python, Qt

Всем привет. Сегодня познакомимся с QML. Узнаем что это такое и с чем его едят. Создадим небольшое приложение с использованием данной технологии.

Небольшое отступление:

QML(Qt Meta Language) — декларативный язык программирования, основанный на JavaScript, предназначенный для дизайна приложений. Является частью Qt Quick, среды разработки пользовательского интерфейса, которая поставляется вместе с Qt.

В качестве примера декларативных языков можно привести SQL и HTML. Подробнее о QML можете почитать здесь: документация.

Начнем, пожалуй, с самого простого: создания окна. Создаем два файла base.qml и test.py следующего содержания:

base.qml

test.py

Код файла test.py должен быть вам полностью понятен, но если все же он вызывает у вас трудности, рекомендую пройти курс по PyQt5 здесь: https://pythonworld.ru/gui/pyqt5-firstprograms.html

Собственно это и есть простейший пример работы с qml, на выходе мы получим окно, размером 250X250 залитое зеленым цветом:

В QML, основным видимым элементом является элемент Rectangle. Элемент Rectangle имеет свойства для управления внешним видом и местоположением элемента, которые мы можем ему задавать, например, такие:

Другие свойства мы рассмотрим чуть позже.

Немного усложним задачу: создадим окно в котором будет прямоугольник с надписью: «Hello World»:

Теперь мы получим такой результат:

Здесь мы центрируем по вертикали и горизонтали наш объект относительно родителя anchors.verticalCenter: parent.verticalCenter,anchors.horizontalCenter: parent.horizontalCenter. Parent позволяет обратится к родителю, в нашем случае родителем объекта Text является Rectangle с id:rec_green.

Вообщем теперь вы должны понять, что интерфейс на QML строится на иерархии объектов. В нашем случае это выглядит так:

Сделали прямоугольник с надписью. Хм… Пока это мало напоминает полезный интерфейс, давайте добавим кнопку по клике на которую в консоль будет выводится надпись: «Hey Programmer».
Немного изменим код, теперь он будет выглядеть так:

В итоге получаем:

Здесь мы добавляем объект MouseArea, позволяющий работать с мышью.
anchors.fill: parent — говорим, что вся область родителя будет задействована.
onClicked — событие нажатия на кнопку. В нашем случае, вызывается функция, выводящая в консоль: ‘Hey Programmer’.

На этом, пожалуй, сегодня и закончим. В следующих статьях разберем qml более подробно.

Пока вы, возможно, не видите преимуществ использования qml, но когда мы познакомимся с этим замечательным инструментом подробнее, вы поймете какой он удобный и функциональный.

Author : Matthieu Kieffer

Description

This little project shows how to execute external python programs/scripts from inside a C++/Qt widget application.
Elements from the source code (and more specifically the method MainWindow::launchPythonProgram()) could be reimplemented in another Qt application to enable running external python programs in an easy/fast way, for example reading/writing into files or launch a complex algorithm with many dependencies (e.g. object-oriented python code with many includes) that is not practical to code in C++.

Motivations

I have initially written this program for two reasons:

  • To be able to run some machine learning scripts that rely on the scikit-learn python library, directly within a C++/Qt window application and do further treatment with the output data using C++ code.
  • To learn how to wrap a programming language into a C++ application.

After some tests I figured out that staying with pure python code and using the pyQt library for the window application would be a better choice than wrapping, but I was still interested into finishing this C++/Qt project, for self-learning satisfaction but also to provide a functional program to people who could be interested in such a C++/python embedding functionality into their own programs.

Details about the implementation

To make the application run properly, a working version of python2.7 must be installed onto your computer, with PATH and PYTHONPATH environment variables set correctly.
If running python script that include libraries such as numpy and scikit-learn, I recommand installing Anaconda instead.

…more details coming soon…

Limitations

  • The program is not able to read python files line by line with dynamic output/error printing, and is not able to interact with the user through the console. Instead, the program simply runs the whole python program and then prints the output/error after the end of the program execution.
    In consequence, it is only possible to run python programs (single file or with multiple file inclusions) that does not interact with the user at run time.
    Interaction with the user would be more complex to implement and requires to enter deeply in the Python/C API documentation.
  • For an unknown reason, the program doesn’t work with python module «panda» (apparently this is a common issue with the Python/C API)
  • The current version of the program doesn’t seem to work with matplotlib. This may be due to the 32bits version of MINGW.
    Qt creator is shipped with MINGW 32Bit, not 64Bit, but python module matplotlib apparently requires 64bits to work in that specific configuration (I’ve already encountered a similar problem when using python2.7 from an Anaconda 32bits distribution in a Visual Studio project, and matplotlib was suddenly working when changing to the 64bits Anaconda distribution)
    —> Possible solution to the problem: install Qt Creator with MINGW-w64 (need then to be configured by hand)

__main__.py

from PyQt5.QtWidgets import QApplication, QMainWindow, QWidget, QCheckBox, QGridLayout, QLabel, QSpacerItem, \
    QSizePolicy
from PyQt5.QtCore import QSize, QCoreApplication, QSettings


ORGANIZATION_NAME = 'Example App'
ORGANIZATION_DOMAIN = 'example.com'
APPLICATION_NAME = 'QSettings program'
SETTINGS_TRAY = 'settings/tray'


class MainWindow(QMainWindow):
    """
        Объявление чекбокса.
        Инициализироваться будет в конструкторе.
    """
    check_box = None

    # Переопределяем конструктор класса
    def __init__(self):
        # Обязательно нужно вызвать метод супер класса
        QMainWindow.__init__(self)

        self.setMinimumSize(QSize(480, 240))  # Устанавливаем размеры
        self.setWindowTitle("Settings Application")  # Устанавливаем заголовок окна
        central_widget = QWidget(self)  # Создаём центральный виджет
        self.setCentralWidget(central_widget)  # Устанавливаем центральный виджет

        grid_layout = QGridLayout()  # Создаём QGridLayout
        central_widget.setLayout(grid_layout)  # Устанавливаем данное размещение в центральный виджет
        grid_layout.addWidget(QLabel("Application, which can minimize to Tray", self), 0, 0)

        # Добавляем чекбокс, состояние которого будет сохраняться в настройках
        self.check_box = QCheckBox('Settings CheckBox for minimizing to tray')
        grid_layout.addWidget(self.check_box, 1, 0)
        grid_layout.addItem(QSpacerItem(0, 0, QSizePolicy.Expanding, QSizePolicy.Expanding), 2, 0)

        # Обращаемся к настройкам программы
        settings = QSettings()
        # Забираем состояние чекбокса, с указанием типа данных:
        # type=bool является заменой метода toBool() в PyQt5
        check_state = settings.value(SETTINGS_TRAY, False, type=bool)
        # Устанавливаем состояние
        self.check_box.setChecked(check_state)
        # подключаем слот к сигналу клика по чекбоксу, чтобы созранять его состояние в настройках
        self.check_box.clicked.connect(self.save_check_box_settings)

    # Слот для сохранения настроек чекбокса
    def save_check_box_settings(self):
        settings = QSettings()
        settings.setValue(SETTINGS_TRAY, self.check_box.isChecked())
        settings.sync()


if __name__ == "__main__":
    import sys

    # Для того, чтобы каждый раз при вызове QSettings не вводить данные вашего приложения
    # по которым будут находиться настройки, можно
    # установить их глобально для всего приложения
    QCoreApplication.setApplicationName(ORGANIZATION_NAME)
    QCoreApplication.setOrganizationDomain(ORGANIZATION_DOMAIN)
    QCoreApplication.setApplicationName(APPLICATION_NAME)

    app = QApplication(sys.argv)
    mw = MainWindow()
    mw.show()
    sys.exit(app.exec())

Примечания

  1. ↑  (англ.). Сайт Nokia. Дата обращения 10 мая 2010.
  2. ↑  (англ.). Сайт PyQt. Дата обращения 10 мая 2010.
  3.  (англ.). Сайт PyQt. Дата обращения 10 мая 2010.
  4.  (англ.). Сайт Eric IDE. Дата обращения 10 мая 2010.
  5.  (англ.). Python Wiki. Дата обращения 10 мая 2010.
  6.  (англ.). Python Wiki. Дата обращения 10 мая 2010.
  7.  (англ.). Nokia. Дата обращения 10 мая 2010.
  8.  (англ.). Сайт PyQt. Дата обращения 14 августа 2010.
  9. ↑  (англ.). KDE.news. Дата обращения 13 августа 2010.
  10.  (англ.). Сайт PyQt. Дата обращения 10 мая 2010.
  11.  (англ.). Сайт PySide. Дата обращения 10 мая 2010.
  12.  (англ.). Сайт PyQt. Дата обращения 10 мая 2010.
  13.  (англ.). Сайт PyQt. Дата обращения 10 мая 2010.
  14.  (англ.). Сайт PyQt. Дата обращения 2 июля 2013.

Начинаем работу

Основным объектом NumPy является однородный многомерный массив (в numpy называется numpy.ndarray). Это многомерный массив элементов (обычно чисел), одного типа.

Наиболее важные атрибуты объектов ndarray:

ndarray.ndim — число измерений (чаще их называют «оси») массива.

ndarray.shape — размеры массива, его форма. Это кортеж натуральных чисел, показывающий длину массива по каждой оси. Для матрицы из n строк и m столбов, shape будет (n,m). Число элементов кортежа shape равно ndim.

ndarray.size — количество элементов массива. Очевидно, равно произведению всех элементов атрибута shape.

ndarray.dtype — объект, описывающий тип элементов массива. Можно определить dtype, используя стандартные типы данных Python. NumPy здесь предоставляет целый букет возможностей, как встроенных, например: bool_, character, int8, int16, int32, int64, float8, float16, float32, float64, complex64, object_, так и возможность определить собственные типы данных, в том числе и составные.

ndarray.itemsize — размер каждого элемента массива в байтах.

Copyright and License Information

Copyright (c) 2001-2020 Python Software Foundation. All rights reserved.

Copyright (c) 2000 BeOpen.com. All rights reserved.

Copyright (c) 1995-2001 Corporation for National Research Initiatives. All
rights reserved.

Copyright (c) 1991-1995 Stichting Mathematisch Centrum. All rights reserved.

See the file «LICENSE» for information on the history of this software, terms &
conditions for usage, and a DISCLAIMER OF ALL WARRANTIES.

This Python distribution contains no GNU General Public License (GPL) code,
so it may be used in proprietary projects. There are interfaces to some GNU
code but these are entirely optional.

All trademarks referenced herein are property of their respective holders.

Отправитель события

Иногда удобно знать, какой именно виджет является отправителем сигнала. Для этого PyQt5 имеет метод sender().

#!/usr/bin/python3
# -*- coding: utf-8 -*-

import sys
from PyQt5.QtWidgets import QMainWindow, QPushButton, QApplication


class Example(QMainWindow):

    def __init__(self):
        super().__init__()

        self.initUI()


    def initUI(self):

        btn1 = QPushButton("Button 1", self)
        btn1.move(30, 50)

        btn2 = QPushButton("Button 2", self)
        btn2.move(150, 50)

        btn1.clicked.connect(self.buttonClicked)
        btn2.clicked.connect(self.buttonClicked)

        self.statusBar()

        self.setGeometry(300, 300, 290, 150)
        self.setWindowTitle('Event sender')
        self.show()


    def buttonClicked(self):

        sender = self.sender()
        self.statusBar().showMessage(sender.text() + ' was pressed')


if __name__ == '__main__'

    app = QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())

В нашем примере у нас есть две кнопки. В методе buttonClicked() мы определяем, какую из кнопок мы нажали с помощью метода sender().

btn1.clicked.connect(self.buttonClicked)
btn2.clicked.connect(self.buttonClicked)

Обе кнопки подключаются к одному слоту.

def buttonClicked(self):

    sender = self.sender()
    self.statusBar().showMessage(sender.text() + ' was pressed')

Мы определяем источник сигнала с помощью метода sender(). В строке состояния приложения, мы показываем метку нажатой кнопки.

История

Riverbank Computing Limited с 1998 года разрабатывает и поддерживает PyQt, привязки, которые позволяют использовать Qt для работы с языком программирования Python.

  • Разработка началась с создания SIP и выпуска PyQt 0.1 с поддержкой Qt 1.41 в ноябре 1998;
  • в версии 2.0, которая вышла в 2000, реализована поддержка Qt 2.2 на Linux и Windows;
  • поддержка Qt 3 реализована в 2001;
  • поддержка Mac OS X реализована в 2002;
  • выпуск PyQt4 начался с PyQt 4.0 с поддержкой Qt 4 в июне 2006;
  • в версии 4.5, которая вышла 5 июня 2009, реализована поддержка Python 3;
  • в версии 4.7, которая вышла 14 января 2010, реализована поддержка Qt 4.6;
  • в версии 5.0, которая вышла 17 июня 2013, реализована поддержка Qt 5.0.

QColorDialog

QColorDialog — виджет диалога для выбора цветовых значений.

#!/usr/bin/python3
# -*- coding: utf-8 -*-

import sys
from PyQt5.QtWidgets import (QWidget, QPushButton, QFrame,
    QColorDialog, QApplication)
from PyQt5.QtGui import QColor


class Example(QWidget):

    def __init__(self):
        super().__init__()

        self.initUI()


    def initUI(self):

        col = QColor(, , )

        self.btn = QPushButton('Dialog', self)
        self.btn.move(20, 20)

        self.btn.clicked.connect(self.showDialog)

        self.frm = QFrame(self)
        self.frm.setStyleSheet("QWidget { background-color: %s }"
            % col.name())
        self.frm.setGeometry(130, 22, 100, 100)

        self.setGeometry(300, 300, 250, 180)
        self.setWindowTitle('Color dialog')
        self.show()


    def showDialog(self):

        col = QColorDialog.getColor()

        if col.isValid():
            self.frm.setStyleSheet("QWidget { background-color: %s }"
                % col.name())


if __name__ == '__main__'

    app = QApplication(sys.argv)
    ex = Example()
    sys.exit(app.exec_())

Пример приложения показывает кнопку и QFrame. Фон виджета устанавливается чёрным. Используя QColorDialog, мы можем менять фон.

col = QColor(, , )

Это первоначальный цвет фона QtGui.QFrame.

col = QColorDialog.getColor()

Это строка высветит QColorDialog.

if col.isValid():
    self.frm.setStyleSheet("QWidget { background-color: %s }"
        % col.name())
Ссылка на основную публикацию