GVKun编程网logo

如何使用 Python 和 PyQt5 制作 VLC 缩放视频以填充窗口？

2

对于如何使用Python和PyQt5制作VLC缩放视频以填充窗口？感兴趣的读者，本文将会是一篇不错的选择，并为您提供关于PyQt5-如何使用QinputDialog.getItems制作取消按钮、Py

对于如何使用 Python 和 PyQt5 制作 VLC 缩放视频以填充窗口？感兴趣的读者，本文将会是一篇不错的选择，并为您提供关于PyQt5 - 如何使用 QinputDialog.getItems 制作取消按钮、PyQt5：PyQt5 信号与槽（PyQt5的事件处理机制）、Python PyQt5：如何使用PyQt5显示错误消息、python pyside2 pyqt5 消息框 按钮 汉化的有用信息。

本文目录一览：

如何使用 Python 和 PyQt5 制作 VLC 缩放视频以填充窗口？

如何使用 Python 和 PyQt5 制作 VLC 缩放视频以填充窗口？

如何解决如何使用 Python 和 PyQt5 制作 VLC 缩放视频以填充窗口？

所以我在 MacOS 上使用 VLC 的 python 绑定模块，使用 PyQt5 来渲染窗口。

当我使用 VLC GUI 时，它完全符合您在扩展窗口时所期望的功能，缩放视频以适合窗口，即使视频的分辨率低于窗口。

使用 python-vlc 模块，没有那么多。即使使用 --autoscale 选项实例化。

在全屏模式下，视频仅占窗口左下角屏幕的 1/4 左右。在非全屏模式下，只有手动调整窗口大小后，视频才会缩放到窗口，然后最终返回非缩放。

我的目标是让视频窗口保留原始视频的纵横比并拉伸以填满屏幕，必要时进行裁剪。

我缺少什么选项或神秘方法？该文档似乎不存在。或者这实际上是我缺少的 pyqt 选项？

请原谅冗长的代码摘录。 vlc 和 pyqt 实例化有很多特性，我看不到另一种方式来向您展示我在做什么。

"""
This module contains a bare-bones VLC player class to play videos.
Adapted  from an example by Saveliy Yusufov,Columbia University,sy2685@columbia.edu
"""

import os
import sys
import platform

from PyQt5 import QtWidgets,QtGui,QtCore
import vlc

class Player(QtWidgets.QMainWindow):
    """Stripped-down PyQt5-based media player class
    """

    def __init__(self,master=None):
        QtWidgets.QMainWindow.__init__(self,master)

        self.media_files = [
            "data/Tv Static Noise HD 720p.mp4","data/070_SHARP_Titles_Flower_Titles.mp4","data/072_SHARP_Footage_Shantyboat_Flyby_Titles.mp4","data/1900 Victorian Time Machine - Parade with Brass Bands (Speed Corrected w_ Sound).mp4"
        ]
        self.current_index = 0

        # PyQy prep stuff
        #
        # set fullscreen mode (we Could do this after the object,but let''s do this early)
        #
        # in fullscreen mode,videos show up in the bottom left corner
        self.showFullScreen()
        #
        # in this window,videos are scaled only when window is manually resized
        #self.resize(680,420)
        #
        self.init_ui()

        # VLC prep stuff
        #
        # VLC Options
        vlc_options = [
            "--embedded-video","--no-audio","--autoscale","--fullscreen","--video-on-top","--no-video-title-show","--random","--verbose -1","--canvas-aspect 3:4","--no-canvas-padd"
        ]
        # Create a basic vlc instance
        self.instance = vlc.Instance(" ".join(vlc_options))
        # later used to store media object,for Now blank
        self.media = None
        # Create an empty vlc media player
        self.player = self.instance.media_player_new()
        # self.mediaplayer = vlc.MediaPlayer()
        # Set to fullscreen
        #self.player.set_fullscreen(True)
        #
        # The media player has to be ''connected'' to the qframe (otherwise the
        # video would be displayed in it''s own window). This is platform
        # specific,so we must give the ID of the qframe (or similar object) to
        # vlc. Different platforms have different functions for this
        if platform.system() == "Linux":  # for Linux using the X Server
            self.player.set_xwindow(int(self.videoframe.winId()))
        elif platform.system() == "Windows":  # for Windows
            self.player.set_hwnd(int(self.videoframe.winId()))
        elif platform.system() == "Darwin":  # for MacOS
            self.player.set_nsobject(int(self.videoframe.winId()))

        # load media
        self.open_file(self.media_files[self.current_index])

        # create a timer to refresh video
        self.timer = QtCore.QTimer(self)
        self.timer.setInterval(5000)
        self.timer.timeout.connect(self.next_video)

        self.timer.start()

    def init_ui(self):
        """Set up the user interface
        """
        if platform.system() == "Darwin":  # for MacOS
            self.videoframe = QtWidgets.QMacCocoaViewContainer(0)
        else:
            self.videoframe = QtWidgets.qframe()
        # set videoframe color
        self.palette = self.videoframe.palette()
        self.palette.setColor(QtGui.QPalette.Window,QtGui.QColor(0,0))
        self.videoframe.setPalette(self.palette)
        self.videoframe.setAutoFillBackground(True)
        self.setCentralWidget(self.videoframe)

    def open_file(self,filename):
        """Open a media file in a MediaPlayer
        """
        if not filename:
            return
        # getopenFileName returns a tuple,so use only the actual file name
        self.media = self.instance.media_new(filename)
        # Put the media in the media player
        self.player.set_media(self.media)
        # Parse the Metadata of the file
        self.media.parse()
        # Start playing the video as soon as it loads
        self.player.play()

    def next_video(self):
        self.current_index += 1
        if self.current_index >= len(self.media_files):
            self.current_index = 0
        self.open_file(self.media_files[self.current_index])
        return


def main():
    """Entry point for our simple vlc player
    """
    app = QtWidgets.QApplication(sys.argv)

    player = Player()
    player.show()

    # _ = Client("localhost",10000,data_queue)
    sys.exit(app.exec_())


if __name__ == "__main__":
    main()

理想情况下，我想制作一个从不调整大小以填充窗口/屏幕的全屏播放器。

如果您可以对 pyqt 代码进行调整以消除对 vBoxlayout 的需求，则可以获得加分。编辑：固定。谢谢@alec

这是我在播放视频时看到的：

Video emprisoned in bottom left corner

PyQt5 - 如何使用 QinputDialog.getItems 制作取消按钮

PyQt5 - 如何使用 QinputDialog.getItems 制作取消按钮

如何解决PyQt5 - 如何使用 QinputDialog.getItems 制作取消按钮

我有这个代码，在 python 中使用 PyQt5 QinputDialog，但是当我运行程序并单击取消按钮时，它会打开我的另一个窗口而不是关闭当前窗口

  1. pasanger = (''1'',''2'',''3'',''4'')
  2. self.selection,self.ok = QInputDialog.getItem(self,"Choose the passanger","Passanger",passanger,False)

有人知道如何使取消按钮起作用吗？

解决方法

看看here。您可以使用第二个返回值（在您的情况下为 self.ok）来检查用户是否点击了 Ok 或 Cancel。

假设您在 QWindow 中运行代码片段：

  1. pasanger = (''1'',''2'',''3'',''4'')
  2. self.selection,self.ok = QInputDialog.getItem(self,"Choose the passanger","Passanger",passanger,False)
  4. if not self.ok:
  5.     self.close()
  6. else:
  7.     # run your remaining code

（另外，您可能想检查一下乘客的拼写。）

PyQt5：PyQt5 信号与槽（PyQt5的事件处理机制）

PyQt5：PyQt5 信号与槽（PyQt5的事件处理机制）

一、事件

　　在事件模型，有三个参与者：事件源、事件目标、事件对象。

  • 　　事件源：状态发生改变的对象，它产生事件 Source_Obj
  • 　　事件目标：是想要被通知的对象 Target_Obj
  • 　　事件对象：封装了事件源中的状态变化 Evnet_Obj

　　PyQt5有一个独一无二的信号和槽机制来处理事件。信号和槽用于对象之间的通信。当指定事件发生，一个事件信号会被发射。槽可以被任何Python脚本调用。当和槽连接的信号被发射时，槽会被调用。调用示意图如图1所示：

图1

 二、信号和槽（或槽函数）

　　在Qt中，每一个QObject对象和PyQt中所有继承自QWidget的控件（这些都是QObject的子对象）都支持信号与槽机制。当信号发射时，连接的槽函数将会自动执行。在PyQt 5中信号与槽通过object.signal.connect()方法连接。

　　PyQt的窗口控件类中有很多内置信号，开发者也可以添加自定义信号。信号与槽具有如下特点。

  • 一个信号可以连接多个槽。
  • 一个信号可以连接另一个信号。
  • 信号参数可以是任何Python类型。
  • 一个槽可以监听多个信号。
  • 信号与槽的连接方式可以是同步连接，也可以是异步连接。
  • 信号与槽的连接可能会跨线程。
  • 信号可能会断开。

　　在GUI编程中，当改变一个控件的状态时（如单击了按钮），通常需要通知另一个控件，也就是实现了对象之间的通信。在早期的GUI编程中使用的是回调机制，在Qt中则使用一种新机制——信号与槽。在编写一个类时，要先定义该类的信号与槽，在类中信号与槽进行连接，实现对象之间的数据传输。信号与槽机制示意图如图1所示。

图2

　　当事件或者状态发生改变时，就会发出信号。同时，信号会触发所有与这个事件（信号）相关的函数（槽）。信号与槽可以是多对多的关系。一个信号可以连接多个槽，一个槽也可以监听多个信号。

　　关于PyQt API中信号与槽的更详细解释，可以参考官方网站： http://pyqt.sourceforge.net/Docs/PyQt5/signals_slots.html？highlight=pyqtsignal#PyQt5.QtCore.pyqtSignal。

三、高级自定义信号与槽

　　所谓高级自定义信号与槽，指的是我们可以以自己喜欢的方式定义信号与槽函数，并传递参数。自定义信号的一般流程如下：

　　（1）定义信号。

　　（2）定义槽函数。

　　（3）连接信号与槽函数。

　　（4）发射信号。

（1）定义信号

　　通过类成员变量定义信号对象。使用 pyqtSignal()方法

import sys
import PyQt5.QtWidgets as PQW
import PyQt5.QtCore as PQC

class MyWidget(PQW.QWidget):
    # 无参数的信号
    Signal_NoParameters = PQC.pyqtSignal()
    # 带一个参数(整数)的信号
    Signal_OneParameter = PQC.pyqtSignal(int)
    # 带一个参数(整数或者字符串)的重载版本的信号
    Signal_OneParameter_Overload = PQC.pyqtSignal([int],[str])
    # 带两个参数(整数,字符串)的信号
    Signal_TwoParameters = PQC.pyqtSignal(int,str)
    # 带两个参数([整数,整数]或者[整数,字符串])的重载版本的信号
    Signal_TwoParameters_Overload = PQC.pyqtSignal([int,int],[int,str])

（2）定义槽函数

　　定义一个槽函数，它有多个不同的输入参数。槽函数就是普通类中的函数或方法。

class MyWidget(PQW.QWidget):  #接上例程序，同一个类MyWidget。
    def setValue_NoParameters(self):   
        ''''''无参数的槽函数''''''  
        pass  
    def setValue_OneParameter(self,nIndex):   
        ''''''带一个参数(整数)的槽函数''''''  
        pass
    def setValue_OneParameter_String(self,szIndex):   
        ''''''带一个参数(字符串)的槽函数''''''  
        pass 
    def setValue_TwoParameters(self,x,y):   
        ''''''带两个参数(整数,整数)的槽函数''''''  
        pass  
    def setValue_TwoParameters_String(self,x,szY):   
        ''''''带两个参数(整数,字符串)槽函数''''''  
        pass

 

（3）连接信号与槽函数

　　通过connect方法连接信号与槽函数或者可调用对象。

app = QApplication(sys.argv)   
widget = MyWidget()   
# 连接无参数的信号
widget.Signal_NoParameters.connect(self.setValue_NoParameters )                                          

# 连接带一个整数参数的信号
widget.Signal_OneParameter.connect(self.setValue_OneParameter)                                         

# 连接带一个整数参数，经过重载的信号
widget.Signal_OneParameter_Overload[int].
    connect(self.setValue_OneParameter)                              

# 连接带一个整数参数，经过重载的信号
widget.Signal_OneParameter_Overload[str].
    connect(self.setValue_OneParameter_String )                     

# 连接一个信号，它有两个整数参数
widget.Signal_TwoParameters.connect(self.setValue_TwoParameters )                                        

# 连接带两个参数(整数,整数)的重载版本的信号
widget.Signal_TwoParameters_Overload[int,int].
    connect(self.setValue_TwoParameters )                      

# 连接带两个参数(整数,字符串)的重载版本的信号
widget.Signal_TwoParameters_Overload[int,str].
    connect(self.setValue_TwoParameters_String )              
widget.show()

 

（4）发射信号

　　通过emit()方法发射信号。

class MyWidget(QWidget):  

    def mousePressEvent(self, event):  
        # 发射无参数的信号
        self.Signal_NoParameters.emit() 
        # 发射带一个参数(整数)的信号
        self.Signal_OneParameter.emit(1) 
        # 发射带一个参数(整数)的重载版本的信号
        self.Signal_OneParameter_Overload.emit(1)
        # 发射带一个参数(字符串)的重载版本的信号
        self.Signal_OneParameter_Overload.emit("abc")
        # 发射带两个参数(整数,字符串)的信号
        self.Signal_TwoParameters.emit(1,"abc")
        # 发射带两个参数(整数,整数)的重载版本的信号
        self.Signal_TwoParameters_Overload.emit(1,2)
        # 发射带两个参数(整数,字符串)的重载版本的信号
        self.Signal_TwoParameters_Overload.emit (1,"abc")

 

（5）实例

 1 from PyQt5.QtCore import QObject , pyqtSignal
 2 
 3 class CustSignal(QObject):
 4 
 5     #声明无参数的信号
 6     signal1 = pyqtSignal()
 7 
 8     #声明带一个int类型参数的信号
 9     signal2 = pyqtSignal(int)
10 
11     #声明带int和str类型参数的信号
12     signal3 = pyqtSignal(int,str)
13 
14     #声明带一个列表类型参数的信号
15     signal4 = pyqtSignal(list)
16 
17     #声明带一个字典类型参数的信号
18     signal5 = pyqtSignal(dict)
19 
20     #声明一个多重载版本的信号，包括带int和str类型参数的信号和带str类型参数的信号
21     signal6 = pyqtSignal([int,str], [str])
22 
23     def __init__(self,parent=None):
24         super(CustSignal,self).__init__(parent)
25 
26         #将信号连接到指定槽函数
27         self.signal1.connect(self.signalCall1)
28         self.signal2.connect(self.signalCall2)
29         self.signal3.connect(self.signalCall3)
30         self.signal4.connect(self.signalCall4)
31         self.signal5.connect(self.signalCall5)
32         self.signal6[int,str].connect(self.signalCall6)
33         self.signal6[str].connect(self.signalCall6OverLoad)
34 
35         #发射信号
36         self.signal1.emit()
37         self.signal2.emit(1)
38         self.signal3.emit(1,"text")
39         self.signal4.emit([1,2,3,4])
40         self.signal5.emit({"name":"wangwu","age":"25"})
41         self.signal6[int,str].emit(1,"text")
42         self.signal6[str].emit("text")
43 
44     def signalCall1(self):
45         print("signal1 emit")
46 
47     def signalCall2(self,val):
48         print("signal2 emit,value:",val)
49 
50     def signalCall3(self,val,text):
51         print("signal3 emit,value:",val,text)
52 
53     def signalCall4(self,val):
54         print("signal4 emit,value:",val)
55 
56     def signalCall5(self,val):
57         print("signal5 emit,value:",val)
58 
59     def signalCall6(self,val,text):
60         print("signal6 emit,value:",val,text)
61 
62     def signalCall6OverLoad(self,val):
63         print("signal6 overload emit,value:",val)
64 
65 if __name__ == ''__main__'':
66     custSignal = CustSignal()
View Code

 

运行结果如下：

signal1 emit
signal2 emit,value: 1
signal3 emit,value: 1 text
signal4 emit,value: [1, 2, 3, 4]
signal5 emit,value: {''name'': ''wangwu'', ''age'': ''25''}
signal6 emit,value: 1 text
signal6 overload emit,value: text

 四、使用自定义参数

　　在PyQt编程过程中，经常会遇到给槽函数传递自定义参数的情况，比如有一个信号与槽函数的连接是：

button1.clicked.connect(show_page)

　　我们知道对于clicked信号来说，它是没有参数的；对于show_page函数来说，希望它可以接收参数。希望show_page函数像如下这样：

def show_page(self, name):
    print(name,"  点击啦")

 　　于是就产生一个问题——信号发出的参数个数为0，槽函数接收的参数个数为1，由于0<1，这样运行起来一定会报错（原因是信号发出的参数个数一定要大于槽函数接收的参数个数）。解决这个问题就是：自定义参数的传递。

　　有两种解决方法，其中一种解决方法是使用lambda表达式。其完整代码如下：

from PyQt5.QtWidgets import QMainWindow, QPushButton , QWidget , QMessageBox, QApplication, QHBoxLayout
import sys

class WinForm(QMainWindow):
    def __init__(self, parent=None):
        super(WinForm, self).__init__(parent)
        button1 = QPushButton(''Button 1'')
        button2 = QPushButton(''Button 2'')

        button1.clicked.connect(lambda: self.onButtonClick(1))
        button2.clicked.connect(lambda: self.onButtonClick(2))

        layout = QHBoxLayout()
        layout.addWidget(button1)
        layout.addWidget(button2)

        main_frame = QWidget()
        main_frame.setLayout(layout)
        self.setCentralWidget(main_frame)

    def onButtonClick(self, n):
        print(''Button {0} 被按下了''.format(n))
        QMessageBox.information(self, "信息提示框", ''Button {0} clicked''.format(n))

if __name__ == "__main__":
    app = QApplication(sys.argv)
    form = WinForm()
    form.setGeometry(300,300,600,400)
    form.show()
    sys.exit(app.exec_())

 运行效果如下：

图3

　　这里重点解释onButtonClick()函数是怎样处理从两个按钮传来的信号的。使用lambda表达式传递按钮数字给槽函数，当然也可以传递其他任何东西，甚至是按钮控件本身（假设槽函数打算把传递信号的按钮修改为不可用的话）。

　　另一种解决方法是使用functools中的partial函数。实例代码如下：

from PyQt5.QtWidgets import QMainWindow, QPushButton , QWidget , QMessageBox, QApplication, QHBoxLayout
import sys
from functools import partial

class WinForm(QMainWindow):
    def __init__(self, parent=None):
        super(WinForm, self).__init__(parent)
        button1 = QPushButton(''Button 1'')
        button2 = QPushButton(''Button 2'')

        # button1.clicked.connect(lambda: self.onButtonClick(1))
        # button2.clicked.connect(lambda: self.onButtonClick(2))
        button1.clicked.connect(partial(self.onButtonClick, 1))
        button2.clicked.connect(partial(self.onButtonClick, 2))

        layout = QHBoxLayout()
        layout.addWidget(button1)
        layout.addWidget(button2)

        main_frame = QWidget()
        main_frame.setLayout(layout)
        self.setCentralWidget(main_frame)

    def onButtonClick(self, n):
        print(''Button {0} 被按下了''.format(n))
        QMessageBox.information(self, "信息提示框", ''Button {0} clicked''.format(n))

if __name__ == "__main__":
    app = QApplication(sys.argv)
    form = WinForm()
    form.setGeometry(300,300,600,400)
    form.show()
    sys.exit(app.exec_())

 　　运行效果和上图一样。采用哪种方法好一点呢？这属于风格问题，笔者比较喜欢使用lambda表达式，因为其条理清晰，而且灵活。

五、装饰器信号与槽

　　所谓装饰器信号与槽，就是通过装饰器的方法来定义信号和槽函数。具体的使用方法如下：

@PyQt5.QtCore.pyqtSlot(参数)
def on_发送者对象名称_发射信号名称(self, 参数):
        pass

　　这种方法有效的前提是下面的函数已经被执行：

QtCore.QMetaObject.connectSlotsByName(QObject)

 

 　　在上面代码中，“发送者对象名称”就是使用setObjectName函数设置的名称，因此自定义槽函数的命名规则也可以看成：on + 使用setObjectName设置的名称 + 信号名称。接下来看具体的使用方法，完整代码如下：

from PyQt5 import QtCore
from PyQt5.QtWidgets import QApplication  ,QWidget ,QHBoxLayout , QPushButton
import sys

class CustWidget(QWidget):

    def __init__(self, parent=None):
        super(CustWidget, self).__init__(parent)

        self.okButton = QPushButton("OK", self)
        #使用setObjectName设置对象名称
        self.okButton.setObjectName("okButton")
        layout = QHBoxLayout()
        layout.addWidget(self.okButton)
        self.setLayout(layout)
        QtCore.QMetaObject.connectSlotsByName(self)

    @QtCore.pyqtSlot()
    def on_okButton_clicked(self):
        print( "单击了OK按钮")

if __name__ == "__main__":
    app =  QApplication(sys.argv)
    win = CustWidget()
    win.setWindowTitle(''装饰器信号和槽'')
    win.setGeometry(300,300,600,400)
    win.show()
    app.exec_()

 　　运行脚本，显示效果如图所示。单击“OK”按钮，控制台打印出预期的调试信息。

图4

 　　有的读者可能注意到，我们一直没有解释下面这行代码的含义：QtCore.QMetaObject.connectSlotsByName(QObject)，事实上，它是在PyQt 5中根据信号名称自动连接到槽函数的核心代码。通过前面章节中的例子可以知道，使用pyuic5命令生成的代码中会带有这么一行代码，接下来对其进行解释。

　　这行代码用来将QObject中的子孙对象的某些信号按照其objectName连接到相应的槽函数。这句话读起来有些拗口，这里举个例子进行简单说明。以上面例子中的代码为例：

　　假设代码QtCore.QMetaObject.connectSlotsByName(self)已经执行，则下面的代码：

@QtCore.pyqtSlot()    
def on_okButton_clicked(self):
    print( "单击了OK按钮")

 

　　会被自动识别为下面的代码（注意，函数中去掉了on，因为on会受到connectSlotsByName的影响，加上on运行时会出现问题）：

def __init__(self, parent=None):

    self.okButton.clicked.connect(self.okButton_clicked)

    def okButton_clicked(self):
        print("单击了OK按钮")

 实例如下：

 1 from PyQt5 import QtCore 
 2 from PyQt5.QtWidgets import QApplication ,QWidget ,QHBoxLayout , QPushButton
 3 import sys
 4 
 5 class CustWidget( QWidget ):
 6 
 7     def __init__(self, parent=None):
 8         super(CustWidget, self).__init__(parent)
 9 
10         self.okButton = QPushButton("OK", self)
11         #使用setObjectName设置对象名称
12         self.okButton.setObjectName("okButton")
13         layout =  QHBoxLayout()
14         layout.addWidget(self.okButton)
15         self.setLayout(layout)
16         QtCore.QMetaObject.connectSlotsByName(self)
17         self.okButton.clicked.connect(self.okButton_clicked)
18 
19     def okButton_clicked(self):
20         print( "单击了OK按钮")
21 
22 if __name__ == "__main__":
23     app =  QApplication(sys.argv)
24     win = CustWidget()
25     win.show()
26     sys.exit(app.exec_())
View Code

运行上述代码，结果和图4一样。

六、信号与槽的断开和连接

　　有时候基于某些原因，想要临时或永久断开某个信号与槽的连接。这就是本节案例想要达到的目的。其完整代码如下：

from PyQt5.QtCore import QObject , pyqtSignal

class SignalClass(QObject):

     # 声明无参数的信号
    signal1 = pyqtSignal()

    # 声明带一个int类型参数的信号
    signal2 = pyqtSignal(int)

    def __init__(self,parent=None):
        super(SignalClass,self).__init__(parent)

        # 将信号signal1连接到sin1Call和sin2Call这两个槽函数
        self.signal1.connect(self.sin1Call)
        self.signal1.connect(self.sin2Call)

        # 将信号signal2连接到信号signal1
        self.signal2.connect(self.signal1)

        # 发射信号
        self.signal1.emit()
        self.signal2.emit(1)

        # 断开signal1、signal2信号与各槽函数的连接
        self.signal1.disconnect(self.sin1Call)
        self.signal1.disconnect(self.sin2Call)
        self.signal2.disconnect(self.signal1)

        # 将信号signal1和signal2连接到同一个槽函数sin1Call
        self.signal1.connect(self.sin1Call)
        self.signal2.connect(self.sin1Call)

        # 再次发射信号
        self.signal1.emit()
        self.signal2.emit(1)

    def sin1Call(self):
        print("signal-1 emit")

    def sin2Call(self):
        print("signal-2 emit")

if __name__ == ''__main__'':
    signal = SignalClass()

  运行结果如下：

signal-1 emit
signal-2 emit
signal-1 emit
signal-2 emit
signal-1 emit
signal-1 emit

七、多线程中信号与槽的使用

1、简单多线程中信号与槽的使用 　　

　　最简单的多线程使用方法是利用QThread函数，如下代码展示了QThread函数和信号与槽简单的结合方法。其完整代码如下： 

# 多线程中信号与槽的使用
from PyQt5.QtWidgets import  QApplication ,QWidget
from PyQt5.QtCore import QThread ,  pyqtSignal
import sys

class Main(QWidget):
    def __init__(self, parent = None):
        super(Main,self).__init__(parent)

        # 创建一个线程实例并设置名称、变量、信号与槽
        self.thread = MyThread()        
        self.thread.setIdentity("thread1")
        self.thread.sinOut.connect(self.outText)
        self.thread.setVal(6)

    def outText(self,text):
        print(text)

class MyThread(QThread):
    sinOut = pyqtSignal(str)

    def __init__(self,parent=None):
        super(MyThread,self).__init__(parent)
        self.identity = None

    def setIdentity(self,text):
        self.identity = text

    def setVal(self,val):
        self.times = int(val)
        # 执行线程的run方法
        self.start()

    def run(self):
        while self.times > 0 and self.identity:
            # 发射信号
            self.sinOut.emit(self.identity+"==>"+str(self.times))
            self.times -= 1

if __name__ == ''__main__'':
    app = QApplication(sys.argv)
    main = Main()
    main.show()
    sys.exit(app.exec_())

 

运行结果：

thread1==>6
thread1==>5
thread1==>4
thread1==>3
thread1==>2
thread1==>1

 

2、多线程处理显示和逻辑运算分开

　　有时在开发程序时经常会执行一些耗时的操作，这样就会导致界面卡顿，这也是多线程的应用范围之一——为了解决这个问题，我们可以创建多线程，使用主线程更新界面，使用子线程实时处理数据，最后将结果显示到界面上。

　　下例中，定义了一个后台线程类BackendThread来模拟后台耗时操作，在这个线程类中定义了信号update_date。使用BackendThread线程类在后台处理数据，每秒发射一次自定义信号update_date。

　　在初始化窗口界面时，定义后台线程类BackendThread，并把线程类的信号update_date连接到槽函数handleDisplay()。这样后台线程每发射一次信号，就可以把最新的时间值实时显示在前台窗口的QLineEdit文本对话框中，完整示例代码如下：

from PyQt5.QtCore import QThread ,  pyqtSignal,  QDateTime
from PyQt5.QtWidgets import QApplication,  QDialog,  QLineEdit
import time
import sys

class BackendThread(QThread):    # 该类模拟后台
    # 通过类成员对象定义信号
    update_date = pyqtSignal(str)

    # 处理业务逻辑
    def run(self):
        while True:
            data = QDateTime.currentDateTime()
            currTime = data.toString("yyyy-MM-dd hh:mm:ss")
            self.update_date.emit(str(currTime))   #通过sleep(1),每秒发射一个信号
            time.sleep(1)

# class Window(QDialog):  #界面类，用于显示
class Window(PQW.QWidget):
    def __init__(self):
        # QDialog.__init__(self)
        super().__init__()
        self.setWindowTitle(''PyQt 5界面实时更新例子'')
        self.resize(400, 100)
        self.input = QLineEdit(self)
        self.input.resize(400, 30)
        self.initUI()

    def initUI(self):
        # 创建线程
        self.backend = BackendThread()
        # 连接信号
        self.backend.update_date.connect(self.handleDisplay)
        # 开始线程
        self.backend.start()

    # 将当前时间输出到文本框
    def handleDisplay(self, data):
        self.input.setText(data)

if __name__ == ''__main__'':
    app = QApplication(sys.argv)
    win = Window()
    win.show()
    sys.exit(app.exec_())

 运行结果：

 

 

图5

参考博文：https://blog.csdn.net/broadview2006/article/details/78475842

Python PyQt5：如何使用PyQt5显示错误消息

Python PyQt5：如何使用PyQt5显示错误消息

在普通的Python（3.x）中，我们总是使用tkinter模块中的showerror（）来显示错误消息，但是在PyQt5中我应该怎么做以显示完全相同的消息类型？

答案1

小编典典

Qt包含特定
于错误消息的对话框类QErrorMessage，您应使用该类来确保对话框符合系统标准。要显示对话框，只需创建一个对话框对象，然后调用.showMessage()。例如：

error_dialog = QtWidgets.QErrorMessage()error_dialog.showMessage(''Oh no!'')

这是一个最小的工作示例脚本：

import PyQt5from PyQt5 import QtWidgetsapp = QtWidgets.QApplication([])error_dialog = QtWidgets.QErrorMessage()error_dialog.showMessage(''Oh no!'')app.exec_()

python pyside2 pyqt5 消息框 按钮 汉化

python pyside2 pyqt5 消息框 按钮 汉化

from PySide2.QtWidgets import QApplication, QMainWindow, QPlainTextEdit, QPushButton, QMessageBox


def showmsg(text=''没填写内容'', title=''消息''):
    messageBox = QMessageBox()
    messageBox.setWindowTitle(title)
    messageBox.setText(text)  
    messageBox.setStandardButtons(QMessageBox.Ok)
    button_ok = messageBox.button(QMessageBox.Ok)
    button_ok.setText(''确定'')   
    
    messageBox.exec()

 

关于如何使用 Python 和 PyQt5 制作 VLC 缩放视频以填充窗口？的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于PyQt5 - 如何使用 QinputDialog.getItems 制作取消按钮、PyQt5：PyQt5 信号与槽（PyQt5的事件处理机制）、Python PyQt5：如何使用PyQt5显示错误消息、python pyside2 pyqt5 消息框 按钮 汉化的相关知识，请在本站寻找。

本文标签：

上一篇Python - 将文本文件拆分为具有字符长度限制的多个文件（python将文本文件读出的内容进行分割）

下一篇需要帮助使用 Python 从 API 中提取 JSON 数据并将其加载到 SQL 表

相关文章