PyQt5 控件学习（一个一个学习之QWidget）

一：QWidget 继承的类：

查看一个控件的父类，

(一)：可以直接点入到内置文件中查看

它是继承QObject 还要一个：QPaintDevice 的！

(二)：通过保留属性base

注：如果使用mro() ，则是整个的继承链条！

还要注意：它的父类QObject 中所有的功能，它都可以使用！

二：QWidget (所有可视控件的基类)：

它其实也是个矩形！

三：QWiget的功能作用：

(一)：QWidget 控件之控件的创建：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #创建控件
 8 window = QWidget() #注： 这里括号里放的不是继承而是指定父控件
 9 
10 
11 #QWidget 类的初始化函数，如果我们不给它指定父控件的话，
12 # 那么它就自己成为了顶层窗口，顶层窗口是不会自己出现的，需要我们自己show()
13 # def __init__(self, parent=None, flags, Qt_WindowFlags=None, Qt_WindowType=None, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__
14 #     pass
15 
16 window.show()
17 
18 
19 
20 #3,进入消息循环
21 sys.exit(app.exec_())

QWidget 的初始化函数的参数parent

当一个控件没有父控件的时候，它会被包装成一个框架（有标题栏啊，等等......）

但是，我们可以通过init函数中第二个参数flags 来设置的，后面再讲（待放链接）

(二)：QWidget控件之大小位置：

关于控件的坐标系统：

API之获取：

最后一句话：空间显示完毕之后，具体的位置或尺寸才会正确：
验证代码如下：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #创建控件
 8 window = QWidget()
 9 
10 window.move(100,100)
11 window.resize(200,200)
12 
13 print(window.geometry()) #输出： PyQt5.QtCore.QRect(100, 100, 200, 200)
14 
15 
16 window.show()
17 print(window.geometry())  #输出： PyQt5.QtCore.QRect(101, 131, 200, 200)
18 
19 
20 #3,进入消息循环
21 sys.exit(app.exec_())

控件显示之后，某些数据才会正确

所以，要获取控件的尺寸，一定要在控件显示完毕之后再去获取！

API之设置：

move 是操控的x,y 也就是pos ，包含框架。

resize 操控的是用户区域，不包含框架（但是太小的话，也不行）

setGeometry() 也是用户区域，

但是此时会有问题：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #创建控件
 8 window = QWidget()
 9 
10 # window.setGeometry(0,0,150,150)  # 这样不行，需要放在展示后面
11 
12 window.show()
13 window.setGeometry(0,0,150,150) 
14 
15 
16 #3,进入消息循环
17 sys.exit(app.exec_())

setGeometry()要放在show() 后面，在前面会无效！

adjustSize() 根据内容自适应大小

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #创建控件
 8 window = QWidget()
 9 
10 window.move(200,200)
11 window.resize(500,500)
12 
13 label = QLabel(window)
14 label.setText("hello world")
15 label.move(100,100)
16 label.setStyleSheet("background-color:cyan;")  #为了更清晰看到具体的区域
17 
18 def addContent():
19     new_content = label.text() +"hello world"
20     label.setText(new_content)
21     label.resize(label.width()+100,label.height())
22 
23 
24 btn = QPushButton(window)
25 btn.setText("增加内容")
26 btn.move(200,200)
27 btn.clicked.connect(addContent)

增加内容（版本二）笨方法改变大小

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #创建控件
 8 window = QWidget()
 9 
10 window.move(200,200)
11 window.resize(500,500)
12 
13 label = QLabel(window)
14 label.setText("hello world")
15 label.move(100,100)
16 label.setStyleSheet("background-color:cyan;")  #为了更清晰看到具体的区域
17 
18 def addContent():
19     new_content = label.text() +"hello world"
20     label.setText(new_content)
21 
22 btn = QPushButton(window)
23 btn.setText("增加内容")
24 btn.move(200,200)
25 btn.clicked.connect(addContent)

增加内容（版本一）此时不行，是因为label 的大小是固定的

效果：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #创建控件
 8 window = QWidget()
 9 
10 window.move(200,200)
11 window.resize(500,500)
12 
13 label = QLabel(window)
14 label.setText("hello world")
15 label.move(100,100)
16 label.setStyleSheet("background-color:cyan;")  #为了更清晰看到具体的区域
17 
18 def addContent():
19     new_content = label.text() +"hello world"
20     label.setText(new_content)
21     # label.resize(label.width()+100,label.height())  笨方法
22     label.adjustSize()
23 
24 
25 btn = QPushButton(window)
26 btn.setText("增加内容")
27 btn.move(200,200)
28 btn.clicked.connect(addContent)
29 
30 
31 
32 window.show()
33 
34 
35 #3,进入消息循环
36 sys.exit(app.exec_())

增加内容（版本三）自适应大小

setFixedSize() 设置固定尺寸：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #创建控件
 8 window = QWidget()
 9 
10 window.move(200,200)
11 # window.resize(500,500) # 这不是固定大小，可以拖拽
12 window.setFixedSize(500,500)  # 这才是固定大小
13 
14 label = QLabel(window)
15 label.setText("hello world")
16 label.move(100,100)
17 
18 
19 window.show()
20 
21 
22 #3,进入消息循环
23 sys.exit(app.exec_())

设置固定大小

大小位置之案例：

案例一：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #创建控件
 8 window = QWidget()
 9 
10 window.resize(500,500)
11 window.move(300,300)
12 
13 
14 window.show()
15 
16 
17 #3,进入消息循环
18 sys.exit(app.exec_())

View Code

案例二：

首先我们先看下关于子控件的显示问题：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #创建控件
 8 window = QWidget()
 9 
10 w = QWidget(window)
11 w.resize(100,100)
12 w.setStyleSheet("background-color:red;")
13 
14 
15 window.show()  #显示子控件时是这样的，它必须要在顶层窗口的前面，
16                 #因为当顶层窗口显示时，它会遍历它身上的所有的子控件
17 window.resize(500,500)
18 window.move(300,300)
19 
20 #3,进入消息循环
21 sys.exit(app.exec_())

子控件的正常显示

但是如果子控件的代码放在了顶层窗口的后面，就没法显示了，因为已经遍历完了，不会再遍历它了。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #创建控件
 8 window = QWidget()
 9 
10 
11 
12 window.show()  #显示子控件时是这样的，它必须要在顶层窗口的前面，
13                 #因为当顶层窗口显示时，它会遍历它身上的所有的子控件
14 window.resize(500,500)
15 window.move(300,300)
16 
17 w = QWidget(window)
18 w.resize(100,100)
19 w.setStyleSheet("background-color:red;")
20 
21 
22 #3,进入消息循环
23 sys.exit(app.exec_())

此时，不会显示子控件

如何解决，要自己手动调用才能显示子控件：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #创建控件
 8 window = QWidget()
 9 
10 
11 
12 window.show()  #显示子控件时是这样的，它必须要在顶层窗口的前面，
13                 #因为当顶层窗口显示时，它会遍历它身上的所有的子控件
14 window.resize(500,500)
15 window.move(300,300)
16 
17 w = QWidget(window)
18 w.resize(100,100)
19 w.setStyleSheet("background-color:red;")
20 w.show() # 自己手动展示
21 
22 #3,进入消息循环
23 sys.exit(app.exec_())

手动调用show() 解决上述问题

难点是关于九宫格的布局：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #创建控件
 8 window = QWidget()
 9 
10 window.show()
11 
12 window.resize(500,500)
13 window.move(300,300)
14 
15 
16 #总控件的个数
17 widget_count = 9
18 
19 #有多少列
20 column_count = 3
21 
22 #一个控件的宽度
23 widget_width = window.width()/column_count
24 
25 #row_count 是有多少行
26 row_count  = (widget_count-1)//column_count +1
27 
28 #一个控件的高度
29 widget_height = window.height()/row_count
30 
31 for i in range(widget_count):
32     w = QWidget(window)
33     w.resize(widget_width,widget_height)
34     x,y = divmod(i,column_count)
35     w.move(widget_width*y,widget_height*x)
36     w.setStyleSheet("background-color:red;border:1px solid yellow")
37     w.show()
38 
39 #3,进入消息循环
40 sys.exit(app.exec_())

九宫格

效果：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #创建控件
 8 window = QWidget()
 9 
10 window.show()
11 
12 window.resize(500,500)
13 window.move(300,300)
14 
15 
16 #总控件的个数
17 widget_count = 50
18 
19 #有多少列
20 column_count = 4
21 
22 #一个控件的宽度
23 widget_width = window.width()/column_count
24 
25 #row_count 是有多少行
26 row_count  = (widget_count-1)//column_count +1
27 
28 #一个控件的高度
29 widget_height = window.height()/row_count
30 
31 for i in range(widget_count):
32     w = QWidget(window)
33     w.resize(widget_width,widget_height)
34     x,y = divmod(i,column_count)
35     w.move(widget_width*y,widget_height*x)
36     w.setStyleSheet("background-color:red;border:1px solid yellow")
37     w.show()
38 
39 #3,进入消息循环
40 sys.exit(app.exec_())

修改总数为50，列数为4

效果：

另：

import math
import sys
from PyQt5.QtWidgets import QWidget, QLabel, QApplication, QPushButton


class Window(QWidget):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("QT的学习")
        self.resize(500,500)
        self.num = 33
        self.col = 3
        self.set_ui()


    def set_ui(self):
        temp = 0
        width = self.width()/self.col
        height = self.height()/math.ceil(self.num / self.col)
        for rIdx in range(math.ceil(self.num / self.col)):
            for cIdx in range(self.col):
                temp += 1
                if temp >self.num:
                    break
                w = QWidget(self)
                w.resize(width, height)
                w.move(cIdx*width,rIdx*height)
                w.setStyleSheet("background-color:red;border:1px solid yellow;")





        # self.startTimer(1000)

    # def timerEvent(self, evt):
    #     self.setGeometry(100,100,self.num,self.num)
    #     self.num += 50

if __name__ == '__main__':
    app =QApplication(sys.argv)

    window = Window()
    window.show()

    sys.exit(app.exec_())

View Code

(三)：QWidget控件之最大和最小尺寸：

直接上案例（api 比较简单）

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("最小尺寸和最大尺寸的限定")
14 # window.resize(500,500)
15 window.setMinimumSize(200,200)  #当然也可单独限制高和宽
16 window.setMaximumSize(600,600)
17 
18 
19 #展示控件
20 window.show()
21 
22 #3,进入消息循环
23 sys.exit(app.exec_())

限制最大最小尺寸，即可宽高一起设置，也可单独设置

问题？

此时能否通过代码来修改尺寸呢？

答案也是不行的。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("最小尺寸和最大尺寸的限定")
14 # window.resize(500,500)
15 window.setMinimumSize(200,200)  #当然也可单独限制高和宽
16 window.setMaximumSize(500,500)
17 
18 window.resize(1000,1000)  #通过代码也是无法修改的
19 
20 #展示控件
21 window.show()
22 
23 #3,进入消息循环
24 sys.exit(app.exec_())

一旦限制之后，通过代码也是无法修改的

(四)：QWidget控件之内容边距：

内容区域：（文本区域）

内容区域默认是整个标签，可以通过获取内容区域来查看：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("内容边距的设定")
14 window.resize(500,500)
15 
16 
17 label = QLabel(window)
18 label.setText("Life is short,I learn Python!")
19 label.resize(300,300)
20 label.setStyleSheet("background-color:cyan;")
21 
22 print(label.contentsRect())
23 
24 
25 #展示控件
26 window.show()
27 
28 
29 #3,进入消息循环
30 sys.exit(app.exec_())
31 '''
32     输出：
33     PyQt5.QtCore.QRect(0, 0, 300, 300)
34 '''

查看内容区域

再次查看内容区域：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("内容边距的设定")
14 window.resize(500,500)
15 
16 
17 label = QLabel(window)
18 label.setText("Life is short,I learn Python!")
19 label.resize(300,300)
20 label.setStyleSheet("background-color:cyan;border:1px solid red")
21 
22 print(label.contentsRect())
23 
24 
25 #展示控件
26 window.show()
27 
28 
29 #3,进入消息循环
30 sys.exit(app.exec_())
31 '''
32     输出：
33     PyQt5.QtCore.QRect(1, 1, 298, 298)  #之所以是因为border 占用了内容区域
34 '''

边框占用内容区域

内容区域是可以进行控制的，可以通过设置内容边距来实现。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("内容边距的设定")
14 window.resize(500,500)
15 
16 
17 label = QLabel(window)
18 label.setText("Life is short,I learn Python!")
19 label.resize(300,300)
20 label.setStyleSheet("background-color:cyan;border:1px solid red")
21 
22 label.setContentsMargins(100,0,0,0)  # 设置内容边距，四个参数是边距顺时针，从左开始
23 print(label.contentsRect())
24 
25 
26 #展示控件
27 window.show()
28 
29 
30 #3,进入消息循环
31 sys.exit(app.exec_())
32 '''
33     输出：
34     PyQt5.QtCore.QRect(100, 0, 200, 300)
35 '''

使用setContentsMargins设置内容边距

默认文本显示是水平靠左，竖直居中的！

当然，各个边的内容边距，我们可以通过getContentsMargins() 来获得，

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("内容边距的设定")
14 window.resize(500,500)
15 
16 
17 label = QLabel(window)
18 label.setText("Life is short,I learn Python!")
19 label.resize(300,300)
20 label.setStyleSheet("background-color:cyan;border:1px solid red")
21 
22 label.setContentsMargins(100,0,100,0)
23 # print(label.contentsRect())
24 
25 print(label.getContentsMargins())  #打印各个边内容边距设置的具体值
26 
27 #展示控件
28 window.show()
29 
30 
31 #3,进入消息循环
32 sys.exit(app.exec_())
33 '''
34     输出：
35     (100, 0, 100, 0)
36 '''

查看内容边距的设置

(五)：QWidget控件之事件消息：

API之显示和关闭事件：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("QWidget 之事件的api 之显示关闭的学习")
 8         self.resize(400,400)
 9         self.set_ui()
10 
11 
12     def set_ui(self):
13         pass
14 
15     def showEvent(self, QShowEvent):   #具体传过来的事件是什么后面说
16         print("窗口被展示出来")
17 
18     def closeEvent(self, QCloseEvent):  #点×调用它
19         print("窗口被关闭了")
20 
21 if __name__ == '__main__':
22     app =QApplication(sys.argv)
23 
24     window = Window()
25     window.show()
26 
27     sys.exit(app.exec_())

显示窗口，和关闭窗口事件

API之移动事件：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("QWidget 之事件的api 之显示关闭的学习")
 8         self.resize(400,400)
 9         self.set_ui()
10 
11 
12     def set_ui(self):
13         pass
14 
15     def moveEvent(self, QMoveEvent):
16         print("窗口被移动了")
17 
18 if __name__ == '__main__':
19     app =QApplication(sys.argv)
20 
21     window = Window()
22     window.show()
23 
24     sys.exit(app.exec_())

移动窗口事件

API之调整大小事件：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("QWidget 之事件的api 之显示关闭的学习")
 8         self.resize(400,400)
 9         self.set_ui()
10 
11 
12     def set_ui(self):
13         pass
14 
15     def resizeEvent(self, QResizeEvent):
16         print("窗口改变了尺寸大小")
17 
18 if __name__ == '__main__':
19     app =QApplication(sys.argv)
20 
21     window = Window()
22     window.show()
23 
24     sys.exit(app.exec_())

改变窗口尺寸大小事件

这里要注意的是，窗口移动仅仅指的是窗口的左上角坐标改变，

而调整大小是整个形状大小改变，二者是不同的。

API之鼠标事件：

鼠标事件之进入和离开事件：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("QWidget 之事件的api 之显示关闭的学习")
 8         self.resize(400,400)
 9         self.set_ui()
10 
11 
12     def set_ui(self):
13         pass
14 
15     def enterEvent(self, QEvent):
16         print("鼠标进入")
17 
18     def leaveEvent(self, QEvent):
19         print("鼠标离开")
20 
21 if __name__ == '__main__':
22     app =QApplication(sys.argv)
23 
24     window = Window()
25     window.show()
26 
27     sys.exit(app.exec_())

鼠标进入和离开窗口

它就可以用做当鼠标在不同位置的时候，给我们呈现不同的样式的应用场景！

例如，鼠标进入给显示黄色，离开显示绿色。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("QWidget 之事件的api 之显示关闭的学习")
 8         self.resize(400,400)
 9         self.set_ui()
10 
11 
12     def set_ui(self):
13         pass
14 
15     def enterEvent(self, QEvent):
16         print("鼠标进入")
17         self.setStyleSheet("background-color:yellow;")
18 
19     def leaveEvent(self, QEvent):
20         print("鼠标离开")
21         self.setStyleSheet("background-color:green;")
22 
23 if __name__ == '__main__':
24     app =QApplication(sys.argv)
25 
26     window = Window()
27     window.show()
28 
29     sys.exit(app.exec_())

进入黄色，离开绿色

鼠标事件之左键按下和释放（按下/释放==单击）事件：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("QWidget 之事件的api 之显示关闭的学习")
 8         self.resize(400,400)
 9         self.set_ui()
10 
11 
12     def set_ui(self):
13         pass
14 
15     def mousePressEvent(self, QMouseEvent):
16         print("鼠标被按下了")
17 
18     def mouseReleaseEvent(self, QMouseEvent):
19         print("鼠标被释放了")
20 
21 if __name__ == '__main__':
22     app =QApplication(sys.argv)
23 
24     window = Window()
25     window.show()
26 
27     sys.exit(app.exec_())

鼠标按下/释放

鼠标事件之左键双击事件：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("QWidget 之事件的api 之显示关闭的学习")
 8         self.resize(400,400)
 9         self.set_ui()
10 
11 
12     def set_ui(self):
13         pass
14 
15     def mouseDoubleClickEvent(self, QMouseEvent):
16         print("鼠标被双击了")
17 
18         
19 if __name__ == '__main__':
20     app =QApplication(sys.argv)
21 
22     window = Window()
23     window.show()
24 
25     sys.exit(app.exec_())

双击

鼠标事件之移动事件：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("QWidget 之事件的api 之显示关闭的学习")
 8         self.resize(400,400)
 9         self.set_ui()
10 
11 
12     def set_ui(self):
13         pass
14 
15     def mouseMoveEvent(self, QMouseEvent):
16         print("鼠标移动了")
17 
18 if __name__ == '__main__':
19     app =QApplication(sys.argv)
20 
21     window = Window()
22     window.show()
23 
24     sys.exit(app.exec_())

按下后移动

设置追踪后，没有按下也可以出发移动事件：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("QWidget 之事件的api 之显示关闭的学习")
 8         self.resize(400,400)
 9         self.set_ui()
10         self.setMouseTracking(True)   #设置鼠标追踪
11 
12 
13     def set_ui(self):
14         pass
15 
16     def mouseMoveEvent(self, QMouseEvent):
17         print("鼠标移动了")
18 
19 if __name__ == '__main__':
20     app =QApplication(sys.argv)
21 
22     window = Window()
23 
24     window.show()
25 
26     sys.exit(app.exec_())

在初始化时，设置鼠标追踪

API之键盘事件：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("QWidget 之事件的api 之显示关闭的学习")
 8         self.resize(400,400)
 9         self.set_ui()
10         self.setMouseTracking(True)   #设置鼠标追踪
11 
12 
13     def set_ui(self):
14         pass
15 
16     def keyPressEvent(self, QKeyEvent):
17         print("键盘上某个键被按下了")
18 
19     def keyReleaseEvent(self, QKeyEvent):
20         print("键盘上某个键被释放了")
21 
22 
23 
24 
25 if __name__ == '__main__':
26     app =QApplication(sys.argv)
27 
28     window = Window()
29 
30     window.show()
31 
32     sys.exit(app.exec_())

按键的按压和释放

具体哪个按键，我们可以对事件进行判断，这里先不说。

API之焦点事件：

某个控件，获得了焦点，比如，用户输入，输入到的是获得焦点的输入框，而不是另外一个输入框。

API之拖拽事件：

将文件直接拖拽到当前的窗口中，例如，直接将.py 文件拓展到cmd 命令行中。

API之绘制事件：

我们之所以可以看到控件，就是因为绘制事件。所以，如果，我们想自定义个控件的形状，就可以在这里完成。

API之改变事件：

API之右键菜单事件：

API之输入法事件：

事件之应用场景：

补充：事件的转发（传递）：

此时，假设窗口中有两个按钮，二者是父子关系，

假设，现在鼠标点击触发了事件，但是儿子中没有实现相应的方法，这时这个事件不会被立即丢弃，而是去看它的父亲中有没有实现相应的方法，如果实现就发给父亲，这就是事件的转发。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def mousePressEvent(self, QMouseEvent):
 6         print("顶层窗口-按下")
 7 class MidWindow(QWidget):
 8     def mousePressEvent(self, QMouseEvent):
 9         print("中间窗口-按下")
10 
11 class Label(QLabel):
12     def mousePressEvent(self, QMouseEvent):
13         print("标签控件被按下")
14 
15 #1,创建app
16 app  = QApplication(sys.argv)
17 
18 
19 #2，控件的操作：
20 #创建控件
21 window = Window()
22 mid_window =  (window)
23 mid_window.resize(300,300)
24 mid_window.setStyleSheet("background-color:red;")  #此时，它不起作用，因为它这个样式默认被取消掉了
25 
26 label = Label(mid_window)
27 label.setText("我是标签")
28 label.setStyleSheet("background-color:yellow")
29 
30 
31 #设置控件
32 window.setWindowTitle("事件转发")
33 window.resize(500,500)
34 
35 
36 
37 #展示控件
38 window.show()
39 
40 #3,进入消息循环
41 sys.exit(app.exec_())

View Code

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def mousePressEvent(self, QMouseEvent):
 6         print("顶层窗口-按下")
 7 class MidWindow(QWidget):
 8     def mousePressEvent(self, QMouseEvent):
 9         print("中间窗口-按下")
10 
11 class Label(QLabel):
12     def mousePressEvent(self, QMouseEvent):
13         print("标签控件被按下")
14 
15 #1,创建app
16 app  = QApplication(sys.argv)
17 
18 
19 #2，控件的操作：
20 #创建控件
21 window = Window()
22 
23 mid_window = MidWindow(window)
24 mid_window.resize(300,300)
25 mid_window.setAttribute(Qt.WA_StyledBackground,True)  #这样能是下方的qss生效
26 mid_window.setStyleSheet("background-color:red;")
27 
28 label = Label(mid_window)
29 label.setText("我是标签")
30 label.setStyleSheet("background-color:yellow")
31 label.move(100,100)
32 
33 #设置控件
34 window.setWindowTitle("事件转发")
35 window.resize(500,500)
36 
37 
38 
39 #展示控件
40 window.show()
41 
42 #3,进入消息循环
43 sys.exit(app.exec_())

使中间的窗口的qss 生效

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def mousePressEvent(self, QMouseEvent):
 6         print("顶层窗口-按下")
 7 class MidWindow(QWidget):
 8     def mousePressEvent(self, QMouseEvent):
 9         print("中间窗口-按下")
10 
11 class Label(QLabel):
12     pass 
13 
14 #1,创建app
15 app  = QApplication(sys.argv)
16 
17 
18 #2，控件的操作：
19 #创建控件
20 window = Window()
21 
22 mid_window = MidWindow(window)
23 mid_window.resize(300,300)
24 mid_window.setAttribute(Qt.WA_StyledBackground,True)  #这样能是下方的qss生效
25 mid_window.setStyleSheet("background-color:red;")
26 
27 label = Label(mid_window)
28 label.setText("我是标签")
29 label.setStyleSheet("background-color:yellow")
30 label.move(100,100)
31 
32 #设置控件
33 window.setWindowTitle("事件转发")
34 window.resize(500,500)
35 
36 
37 
38 #展示控件
39 window.show()
40 
41 #3,进入消息循环
42 sys.exit(app.exec_())

此时，去掉Label 中的方法

这个时候是会将事件转发给它的父控件的，注意是父控件，不是父对象。

如果将中间控件的方法也给它去掉之后，那么会继续转发到上层父控件！

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def mousePressEvent(self, QMouseEvent):
 6         print("顶层窗口-按下")
 7 class MidWindow(QWidget):
 8     def mousePressEvent(self, QMouseEvent):
 9         print("中间窗口-按下")
10 
11 
12 class Label(QLabel):
13     def mousePressEvent(self, QMouseEvent):
14         print("标签窗口-按下")
15 
16 #1,创建app
17 app  = QApplication(sys.argv)
18 
19 
20 #2，控件的操作：
21 #创建控件
22 window = Window()
23 
24 mid_window = MidWindow(window)
25 mid_window.resize(300,300)
26 mid_window.setAttribute(Qt.WA_StyledBackground,True)  #这样能是下方的qss生效
27 mid_window.setStyleSheet("background-color:red;")
28 
29 label = QLabel(mid_window)  #  注意，这行是QLabel 
30 label.setText("我是标签")
31 label.setStyleSheet("background-color:yellow")
32 label.move(100,100)
33 
34 btn = QPushButton(mid_window)
35 btn.setText("我是按钮")
36 btn.setStyleSheet("background-color:yellow;")
37 btn.move(50,50)
38 
39 
40 
41 #设置控件
42 window.setWindowTitle("事件转发")
43 window.resize(500,500)
44 
45 
46 
47 #展示控件
48 window.show()
49 
50 #3,进入消息循环
51 sys.exit(app.exec_())

View Code

上面这段代码要说明的是：

当我们点击按钮时候，它是不会触发中间窗口的，但是点击标签时它是会触发中间窗口。

这说明了按钮的QPushButton () 内部是有方法来处理相应的点击的，但是标签QLabel是没有相应的方法来处理的。

这也正说明了QPushButton 就是用来被点击的，而QLabel 的天生的才能只是用来展示内容的。

而且就算是有方法存在也不行，必须对事件对象作出处理，否则还是会往上传。如下代码：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def mousePressEvent(self, QMouseEvent):
 6         print("顶层窗口-按下")
 7 class MidWindow(QWidget):
 8     def mousePressEvent(self, QMouseEvent):
 9         print("中间窗口-按下")
10 
11 
12 class Label(QLabel):
13     def mousePressEvent(self, QMouseEvent):
14         # print("标签窗口-按下")
15         pass # 此时虽然有这个方法，但是并为对QMouseEvent 对象作出处理
16 
17 #1,创建app
18 app  = QApplication(sys.argv)
19 
20 
21 #2，控件的操作：
22 #创建控件
23 window = Window()
24 
25 mid_window = MidWindow(window)
26 mid_window.resize(300,300)
27 mid_window.setAttribute(Qt.WA_StyledBackground,True)  #这样能是下方的qss生效
28 mid_window.setStyleSheet("background-color:red;")
29 
30 label = Label(mid_window) 
31 label.setText("我是标签")
32 label.setStyleSheet("background-color:yellow")
33 label.move(100,100)
34 
35 btn = QPushButton(mid_window)
36 btn.setText("我是按钮")
37 btn.setStyleSheet("background-color:yellow;")
38 btn.move(50,50)
39 
40 
41 
42 #设置控件
43 window.setWindowTitle("事件转发")
44 window.resize(500,500)
45 
46 
47 
48 #展示控件
49 window.show()
50 
51 #3,进入消息循环
52 sys.exit(app.exec_())

View code

此时如果点击标签，还是会触发中间窗口的。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def mousePressEvent(self, QMouseEvent):
 6         print("顶层窗口-按下")
 7 class MidWindow(QWidget):
 8     def mousePressEvent(self, QMouseEvent):
 9         print("中间窗口-按下")
10 
11 
12 class Label(QLabel):
13     # def mousePressEvent(self, QMouseEvent):
14     #     print("标签窗口-按下")
15     def mousePressEvent(self, event):
16         print("标签窗口-按下")
17         event.accept()  # 这代表的是告诉操作系统，
18                         # 我们已经收到了这个事件对象，不需要再次向上转发了
19 #1,创建app
20 app  = QApplication(sys.argv)
21 
22 
23 #2，控件的操作：
24 #创建控件
25 window = Window()
26 
27 mid_window = MidWindow(window)
28 mid_window.resize(300,300)
29 mid_window.setAttribute(Qt.WA_StyledBackground,True)  #这样能是下方的qss生效
30 mid_window.setStyleSheet("background-color:red;")
31 
32 label = Label(mid_window)
33 label.setText("我是标签")
34 label.setStyleSheet("background-color:yellow")
35 label.move(100,100)
36 
37 btn = QPushButton(mid_window)
38 btn.setText("我是按钮")
39 btn.setStyleSheet("background-color:yellow;")
40 btn.move(50,50)
41 
42 
43 
44 #设置控件
45 window.setWindowTitle("事件转发")
46 window.resize(500,500)
47 
48 
49 
50 #展示控件
51 window.show()
52 
53 #3,进入消息循环
54 sys.exit(app.exec_())

事件对象的方法accept() 告诉操作系统不让向上转发事件了

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def mousePressEvent(self, QMouseEvent):
 6         print("顶层窗口-按下")
 7 class MidWindow(QWidget):
 8     def mousePressEvent(self, QMouseEvent):
 9         print("中间窗口-按下")
10 
11 
12 class Label(QLabel):
13     # def mousePressEvent(self, QMouseEvent):
14     #     print("标签窗口-按下")
15     def mousePressEvent(self, event):
16         print("标签窗口-按下")
17         print(event.isAccepted())   # 它用来查看事件对象是否被接受了
18 #1,创建app
19 app  = QApplication(sys.argv)
20 
21 
22 #2，控件的操作：
23 #创建控件
24 window = Window()
25 
26 mid_window = MidWindow(window)
27 mid_window.resize(300,300)
28 mid_window.setAttribute(Qt.WA_StyledBackground,True)  #这样能是下方的qss生效
29 mid_window.setStyleSheet("background-color:red;")
30 
31 label = Label(mid_window)
32 label.setText("我是标签")
33 label.setStyleSheet("background-color:yellow")
34 label.move(100,100)
35 
36 btn = QPushButton(mid_window)
37 btn.setText("我是按钮")
38 btn.setStyleSheet("background-color:yellow;")
39 btn.move(50,50)
40 
41 
42 
43 #设置控件
44 window.setWindowTitle("事件转发")
45 window.resize(500,500)
46 
47 
48 
49 #展示控件
50 window.show()
51 
52 #3,进入消息循环
53 sys.exit(app.exec_())

event.isAccepted() 查看事件对象是否被接收

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def mousePressEvent(self, QMouseEvent):
 6         print("顶层窗口-按下")
 7 class MidWindow(QWidget):
 8     def mousePressEvent(self, QMouseEvent):
 9         print("中间窗口-按下")
10 
11 
12 class Label(QLabel):
13     # def mousePressEvent(self, QMouseEvent):
14     #     print("标签窗口-按下")
15     def mousePressEvent(self, event):
16         print("标签窗口-按下")
17         event.ignore()
18         print(event.isAccepted())
19 
20 #1,创建app
21 app  = QApplication(sys.argv)
22 
23 
24 #2，控件的操作：
25 #创建控件
26 window = Window()
27 
28 mid_window = MidWindow(window)
29 mid_window.resize(300,300)
30 mid_window.setAttribute(Qt.WA_StyledBackground,True)  #这样能是下方的qss生效
31 mid_window.setStyleSheet("background-color:red;")
32 
33 label = Label(mid_window)
34 label.setText("我是标签")
35 label.setStyleSheet("background-color:yellow")
36 label.move(100,100)
37 
38 btn = QPushButton(mid_window)
39 btn.setText("我是按钮")
40 btn.setStyleSheet("background-color:yellow;")
41 btn.move(50,50)
42 
43 
44 
45 #设置控件
46 window.setWindowTitle("事件转发")
47 window.resize(500,500)
48 
49 
50 
51 #展示控件
52 window.show()
53 
54 #3,进入消息循环
55 sys.exit(app.exec_())
56 '''
57 输出：
58     标签窗口-按下  (虚假的，它不代表事件对象被处理了，后面将它忽略了)
59     False
60     中间窗口-按下
61 '''

event.ignore() 将事件对象忽略，它将会向上继续转发事件

其实，我们是可以利用event.ignore() 来实现，整个父控件都去处理它这个信号的，相当于加了个标识！。

事件消息之案例：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 
 5 class MyLabel(QLabel):
 6     def enterEvent(self, *args, **kwargs):
 7         self.setText("欢迎光临")
 8         print("鼠标进入")
 9     def leaveEvent(self, *args, **kwargs):
10         self.setText("谢谢惠顾")
11         print("鼠标离开")
12 
13 
14 #1,创建app
15 app  = QApplication(sys.argv)
16 
17 
18 #2，控件的操作：
19 #创建控件
20 window = QWidget()
21 
22 
23 #设置控件
24 window.setWindowTitle("事件的案例1")
25 window.resize(500,500)
26 
27 label = MyLabel(window)
28 label.setStyleSheet("background-color:cyan")
29 label.move(200,200)
30 label.resize(100,100)
31 
32 
33 
34 #展示控件
35 window.show()
36 
37 #3,进入消息循环
38 sys.exit(app.exec_())

案例一

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 
 5 class MyLabel(QLabel):
 6     def enterEvent(self, *args, **kwargs):
 7         self.setText("欢迎光临")
 8         print("鼠标进入")
 9     def leaveEvent(self, *args, **kwargs):
10         self.setText("谢谢惠顾")
11         print("鼠标离开")
12 
13     # def keyPressEvent(self, QKeyEvent):
14     #
15     def keyPressEvent(self, event):
16         # event.key() == Qt.Key_Tab   #所有的普通都可以这样对比
17         #键分为  普通键和修饰键  ctrl alt fn 等键
18         if event.key() == Qt.Key_Tab:
19             print("点击了Tab键")
20 
21 
22 #1,创建app
23 app  = QApplication(sys.argv)
24 
25 
26 #2，控件的操作：
27 #创建控件
28 window = QWidget()
29 
30 
31 #设置控件
32 window.setWindowTitle("事件的案例1")
33 window.resize(500,500)
34 
35 label = MyLabel(window)
36 label.setStyleSheet("background-color:cyan")
37 label.move(200,200)
38 label.resize(100,100)
39 
40 
41 
42 #展示控件
43 window.show()
44 
45 #3,进入消息循环
46 sys.exit(app.exec_())

监听Tab

这时不行，因为用户按下按键，但是控件有多个，所以我们要设置将焦点给标签，这样才能捕获到按键。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 
 5 class MyLabel(QLabel):
 6     def enterEvent(self, *args, **kwargs):
 7         self.setText("欢迎光临")
 8         print("鼠标进入")
 9     def leaveEvent(self, *args, **kwargs):
10         self.setText("谢谢惠顾")
11         print("鼠标离开")
12 
13     # def keyPressEvent(self, QKeyEvent):
14     #
15     def keyPressEvent(self, event):
16         # event.key() == Qt.Key_Tab   #所有的普通都可以这样对比
17         #键分为  普通键和修饰键  ctrl alt fn 等键
18         if event.key() == Qt.Key_Tab:
19             print("点击了Tab键")
20 
21 
22 #1,创建app
23 app  = QApplication(sys.argv)
24 
25 
26 #2，控件的操作：
27 #创建控件
28 window = QWidget()
29 
30 
31 #设置控件
32 window.setWindowTitle("事件的案例1")
33 window.resize(500,500)
34 
35 label = MyLabel(window)
36 label.setStyleSheet("background-color:cyan")
37 label.move(200,200)
38 label.resize(100,100)
39 label.grabKeyboard()          # 让label 捕获键盘
40 
41 
42 #展示控件
43 window.show()
44 
45 #3,进入消息循环
46 sys.exit(app.exec_())

用grabKeyboard()来让label来获取焦点

下面看组合键，它就涉及到了修饰键了。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 
 5 class MyLabel(QLabel):
 6     def enterEvent(self, *args, **kwargs):
 7         self.setText("欢迎光临")
 8         print("鼠标进入")
 9     def leaveEvent(self, *args, **kwargs):
10         self.setText("谢谢惠顾")
11         print("鼠标离开")
12 
13     # def keyPressEvent(self, QKeyEvent):
14     #
15     def keyPressEvent(self, event):
16         # event.key() == Qt.Key_Tab   #所有的普通都可以这样对比
17         #键分为  普通键和修饰键  ctrl alt fn 等键
18         # if event.key() == Qt.Key_Tab:
19         #     print("点击了Tab键")
20         if event.modifiers() == Qt.ControlModifier and event.key() == Qt.Key_S:  #modifiers() 是获取修饰键的
21             print("用户点击了 Ctrl + S ")
22 
23 
24 #1,创建app
25 app  = QApplication(sys.argv)
26 
27 
28 #2，控件的操作：
29 #创建控件
30 window = QWidget()
31 
32 
33 #设置控件
34 window.setWindowTitle("事件的案例1")
35 window.resize(500,500)
36 
37 label = MyLabel(window)
38 label.setStyleSheet("background-color:cyan")
39 label.move(200,200)
40 label.resize(100,100)
41 label.grabKeyboard()          # 让label 捕获键盘
42 
43 
44 #展示控件
45 window.show()
46 
47 #3,进入消息循环
48 sys.exit(app.exec_())

Ctrl + s 组合键

如果有多个修饰键：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 
 5 class MyLabel(QLabel):
 6     def enterEvent(self, *args, **kwargs):
 7         self.setText("欢迎光临")
 8         print("鼠标进入")
 9     def leaveEvent(self, *args, **kwargs):
10         self.setText("谢谢惠顾")
11         print("鼠标离开")
12 
13     # def keyPressEvent(self, QKeyEvent):
14     #
15     def keyPressEvent(self, event):
16         # event.key() == Qt.Key_Tab   #所有的普通都可以这样对比
17         #键分为  普通键和修饰键  ctrl alt fn 等键
18         # if event.key() == Qt.Key_Tab:
19         #     print("点击了Tab键")
20         if event.modifiers() == Qt.ControlModifier | Qt.ShiftModifier  and event.key() == Qt.Key_A:  #modifiers() 是获取修饰键的
21             print("用户点击了 Ctrl + Shift+ A ")
22 
23 
24 #1,创建app
25 app  = QApplication(sys.argv)
26 
27 
28 #2，控件的操作：
29 #创建控件
30 window = QWidget()
31 
32 
33 #设置控件
34 window.setWindowTitle("事件的案例1")
35 window.resize(500,500)
36 
37 label = MyLabel(window)
38 label.setStyleSheet("background-color:cyan")
39 label.move(200,200)
40 label.resize(100,100)
41 label.grabKeyboard()          # 让label 捕获键盘
42 
43 
44 #展示控件
45 window.show()
46 
47 #3,进入消息循环
48 sys.exit(app.exec_())

Ctrl + Shift +A

多个修饰键要用按位或 | 来写。

简单了解按位或：

案例三：

一般情况下，用户区是不支持拖拽的，只有标题栏那个地方可以拖拽。

它解决如下需求：

其实这里涉及到三个事件，鼠标按下，鼠标移动，鼠标松开，

这里涉及的计算问题如下：

具体计算向量的时候应该以全局的坐标为准，因为桌面不会变。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("窗口移动的学习")
 8         self.resize(400,400)
 9         self.set_ui()
10 
11 
12     def set_ui(self):
13         pass
14 
15     def mousePressEvent(self, event):
16         # print("鼠标按下")
17         QMouseEvent
18         #确定两个点，鼠标第一次按下的点，和控件窗口的原始点
19         self.mouse_x = event.globalX()
20         self.mouse_y = event.globalY()
21         self.contrl_window_x = self.x()  # 控件窗口的全局坐标
22         self.contrl_window_y = self.y()
23 
24 
25 
26     def mouseMoveEvent(self, event):
27         # print("鼠标移动")
28         #计算移动向量
29         move_x  = event.globalX() - self.mouse_x
30         move_y  = event.globalY() - self.mouse_y
31         print(move_x,move_y)
32         #我们将这个移动向量作用到控件窗口的原始点就行了
33         self.move(self.contrl_window_x+move_x,self.contrl_window_y+move_y)
34 
35 
36     def mouseReleaseEvent(self, QMouseEvent):
37         print("鼠标松开")
38 
39 
40 if __name__ == '__main__':
41     app =QApplication(sys.argv)
42 
43     window = Window()
44     window.show()
45 
46     sys.exit(app.exec_())

View Code

此时一定要避免鼠标跟踪，如果有鼠标跟踪的话，会立马崩溃。这时因为设置鼠标跟踪的话，会立马执行mouseMoveEvent() 方法，但是它的逻辑里需要先执行的是鼠标按下的操作，所以会崩。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("窗口移动的学习")
 8         self.resize(400,400)
 9         self.set_ui()
10 
11         self.move_flag = False
12 
13 
14     def set_ui(self):
15         pass
16 
17     def mousePressEvent(self, event):
18         self.move_flag  = True
19         # print("鼠标按下")
20         QMouseEvent
21         #确定两个点，鼠标第一次按下的点，和控件窗口的原始点
22         self.mouse_x = event.globalX()
23         self.mouse_y = event.globalY()
24         self.contrl_window_x = self.x()  # 控件窗口的全局坐标
25         self.contrl_window_y = self.y()
26 
27     def mouseMoveEvent(self, event):
28         if self.move_flag:
29             # print("鼠标移动")
30             #计算移动向量
31             move_x  = event.globalX() - self.mouse_x
32             move_y  = event.globalY() - self.mouse_y
33             print(move_x,move_y)
34             #我们将这个移动向量作用到控件窗口的原始点就行了
35             self.move(self.contrl_window_x+move_x,self.contrl_window_y+move_y)
36 
37     def mouseReleaseEvent(self, QMouseEvent):
38         print("鼠标松开")
39         self.move_flag = False
40 
41 
42 if __name__ == '__main__':
43     app =QApplication(sys.argv)
44 
45     window = Window()
46     window.setMouseTracking(True)
47     window.show()
48 
49     sys.exit(app.exec_())

通过move_flag 来解决鼠标追踪的问题

这时有鼠标跟踪也没关系了，点击鼠标，给移动标记为True ,松开鼠标，移动标记为False .

此时，还有点小问题，就是如果这时候，我们通过鼠标的右键也是可以移动窗口的。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("窗口移动的学习")
 8         self.resize(400,400)
 9         self.set_ui()
10 
11         self.move_flag = False
12 
13 
14     def set_ui(self):
15         pass
16 
17     def mousePressEvent(self, event):
18         if event.button() == Qt.LeftButton:
19             self.move_flag  = True
20             # print("鼠标按下")
21             QMouseEvent
22             #确定两个点，鼠标第一次按下的点，和控件窗口的原始点
23             self.mouse_x = event.globalX()
24             self.mouse_y = event.globalY()
25             self.contrl_window_x = self.x()  # 控件窗口的全局坐标
26             self.contrl_window_y = self.y()
27 
28     def mouseMoveEvent(self, event):
29         if self.move_flag:
30             # print("鼠标移动")
31             #计算移动向量
32             move_x  = event.globalX() - self.mouse_x
33             move_y  = event.globalY() - self.mouse_y
34             print(move_x,move_y)
35             #我们将这个移动向量作用到控件窗口的原始点就行了
36             self.move(self.contrl_window_x+move_x,self.contrl_window_y+move_y)
37 
38     def mouseReleaseEvent(self, QMouseEvent):
39         print("鼠标松开")
40         self.move_flag = False
41 
42 
43 if __name__ == '__main__':
44     app =QApplication(sys.argv)
45 
46     window = Window()
47     window.setMouseTracking(True)
48     window.show()
49 
50     sys.exit(app.exec_())

通过 event.button() 来设置只能鼠标左键按下才能移动

(六)：QWidget控件之鼠标相关：

API 之设置鼠标形状：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("鼠标操作")
14 window.resize(500,500)
15 
16 window.setCursor(Qt.BusyCursor)   #转圈圈的样式
17 
18 
19 
20 #展示控件
21 window.show()
22 
23 #3,进入消息循环
24 sys.exit(app.exec_())

Qt.BusyCursor 繁忙的样式

其他的效果都可以尝试。

也可以自定义图标。

下面看如何自定义：

先看，鼠标变化它是对应到具体的控件的，它只有进入到相应的控件才会变化。

所以，我们在上面先创建个对象。

那么QCursor 对象如何创建，我们点进去，它需要一个QPixMap对象，

所以我们再构造一个QPixMap对象。它的构造方法是将图片的路径传入即可。

图片如下图：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("鼠标操作")
14 window.resize(500,500)
15 
16 # window.setCursor(Qt.BusyCursor)   #转圈圈的样式
17 
18 pixmap = QPixmap("d:/icon.png")
19 cursor = QCursor(pixmap)
20 window.setCursor(cursor)
21 
22 #展示控件
23 window.show()
24 
25 #3,进入消息循环
26 sys.exit(app.exec_())

这时鼠标进入之后就变成相应的图片了

而且图片的大小本身都是可以调节的，可以通过pixmap 中的scaled() 进行缩放。

但是要注意，scaled() 是将缩放后的图片通过返回值的形式给出的，

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("鼠标操作")
14 window.resize(500,500)
15 
16 # window.setCursor(Qt.BusyCursor)   #转圈圈的样式
17 
18 pixmap = QPixmap("d:/icon.png")
19 new_pixmap = pixmap.scaled(50,50)  #改变图片的尺寸  #注意它是以返回值的形式给出
20 
21 cursor = QCursor(new_pixmap)
22 window.setCursor(cursor)
23 
24 #展示控件
25 window.show()
26 
27 #3,进入消息循环
28 sys.exit(app.exec_())

缩放大小

关于鼠标的热点位置：

可以修改为0,0，这就是图片的左上角成为热点。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("鼠标操作")
14 window.resize(500,500)
15 
16 # window.setCursor(Qt.BusyCursor)   #转圈圈的样式
17 
18 pixmap = QPixmap("d:/icon.png")
19 new_pixmap = pixmap.scaled(50,50)  #改变图片的尺寸  #注意它是以返回值的形式给出
20 
21 cursor = QCursor(new_pixmap,0,0)  # 将热点修改为0,0
22 window.setCursor(cursor)
23 
24 #展示控件
25 window.show()
26 
27 #3,进入消息循环
28 sys.exit(app.exec_())

修改热点位置为左上角

API 之设置重置形状：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("鼠标操作")
14 window.resize(500,500)
15 
16 # window.setCursor(Qt.BusyCursor)   #转圈圈的样式
17 
18 pixmap = QPixmap("d:/icon.png")
19 new_pixmap = pixmap.scaled(50,50)  #改变图片的尺寸  #注意它是以返回值的形式给出
20 
21 cursor = QCursor(new_pixmap,0,0)  # 将热点修改为0,0
22 window.setCursor(cursor)
23 
24 
25 window.unsetCursor()  # 重置鼠标形状，使上面的设置失效
26 
27 #展示控件
28 window.show()
29 
30 #3,进入消息循环
31 sys.exit(app.exec_())

重置鼠标形状

API 之获取鼠标对象：

获取鼠标对象，之后我们就可以获取它的图片，它的位置，等等。。。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("鼠标操作")
14 window.resize(500,500)
15 
16 current_cursor = window.cursor()  #获取鼠标对象
17 
18 print(current_cursor.pos())  #获取鼠标的位置   PyQt5.QtCore.QPoint(748, 260)
19                                     # 它是相对于整个电脑屏幕的
20 
21 #为了验证这一点，我们通过下的验证
22 current_cursor.setPos(0,0)  # 这时鼠标的位置在 屏幕的左上角
23 
24 
25 
26 #展示控件
27 window.show()
28 
29 #3,进入消息循环
30 sys.exit(app.exec_())

获取鼠标对象

它里面的pos() 方法获取的位置是相对于整个屏幕的左上角而言的！

API 之鼠标跟踪：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class MyWindow(QWidget):
 5     def mouseMoveEvent(self, event):
 6         print("鼠标移动了")
 7 
 8 
 9 #1,创建app
10 app  = QApplication(sys.argv)
11 
12 #2，控件的操作：
13 #创建控件
14 window = MyWindow()
15 
16 window.setMouseTracking(True)  #设置跟踪
17 print(window.hasMouseTracking())  #查看鼠标是否处于跟踪状态
18 
19 
20 
21 #设置控件
22 window.setWindowTitle("鼠标操作")
23 window.resize(500,500)
24 
25 
26 #展示控件
27 window.show()
28 
29 #3,进入消息循环
30 sys.exit(app.exec_())

设置鼠标跟踪

#设置鼠标跟踪，这样鼠标一进去就会调用它的方法mouseMoveEvent() 了

下面看下传来的参数event中的东西：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class MyWindow(QWidget):
 5 
 6     # def mouseMoveEvent(self, QMouseEvent):
 7     #     pass
 8     def mouseMoveEvent(self, event):
 9         # print("鼠标移动了",event.globalPos())  # globalPos() 是整个屏幕为准
10         print("鼠标移动了",event.localPos())  # globalPos() 是控件本身为准
11 
12 
13 #1,创建app
14 app  = QApplication(sys.argv)
15 
16 #2，控件的操作：
17 #创建控件
18 window = MyWindow()
19 
20 window.setMouseTracking(True)  #设置跟踪
21 print(window.hasMouseTracking())  #查看鼠标是否处于跟踪状态
22 
23 
24 
25 #设置控件
26 window.setWindowTitle("鼠标操作")
27 window.resize(500,500)
28 
29 
30 #展示控件
31 window.show()
32 
33 #3,进入消息循环
34 sys.exit(app.exec_())

View Code

鼠标相关的案例：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 
 5 class Window(QWidget):
 6     def mouseMoveEvent(self, event):
 7         print("鼠标移动",event.localPos())
 8         label = self.findChild(QLabel)
 9         # label.move(300,300)
10         # label.move(event.localPos())  # 这样直接放是不行的
11         # print(event.localPos())  #PyQt5.QtCore.QPointF
12         # QPointF   里面有x() y()
13         label.move(event.localPos().x(),event.localPos().y())
14 
15 
16 #1,创建app
17 app  = QApplication(sys.argv)
18 
19 
20 #2，控件的操作：
21 #创建控件
22 window = Window()
23 
24 
25 #设置控件
26 window.setWindowTitle("鼠标相关的案例")
27 window.resize(500,500)
28 window.setMouseTracking(True)  #设置鼠标跟踪，这样鼠标一进去就会调用它的方法
29                                 #mouseMoveEvent() 了
30 
31 
32 #自定义鼠标
33 pixmap = QPixmap("d:/icon.png").scaled(50,50)
34 cursor = QCursor(pixmap)
35 window.setCursor(cursor)
36 
37 label  = QLabel(window)
38 label.setText("Life is short,I learn Python!")
39 label.move(100,100)
40 label.setStyleSheet("background-color:cyan;")
41 
42 
43 
44 #展示控件
45 window.show()
46 
47 #3,进入消息循环
48 sys.exit(app.exec_())

案例（版本一未封装）

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 
 5 class Window(QWidget):
 6     def __init__(self):
 7         super().__init__()
 8         #设置控件
 9         self.setWindowTitle("鼠标相关的案例")
10         self.resize(500,500)
11         self.setMouseTracking(True)
12         self.setMyCursor()
13         self.setLabel()
14 
15 
16     def setMyCursor(self):
17         pixmap = QPixmap("d:/icon.png").scaled(50,50)
18         cursor = QCursor(pixmap)
19         self.setCursor(cursor)
20     def setLabel(self):
21         self.label  = QLabel(self)
22         self.label.setText("Life is short,I learn Python!")
23         self.label.move(100,100)
24         self.label.setStyleSheet("background-color:cyan;")
25 
26 
27     def mouseMoveEvent(self, event):
28         print("鼠标移动",event.localPos())
29         self.label.move(event.localPos().x(),event.localPos().y())
30 
31 
32 #1,创建app
33 app  = QApplication(sys.argv)
34 
35 
36 window = Window()
37 
38 
39 #展示控件
40 window.show()
41 
42 #3,进入消息循环
43 sys.exit(app.exec_())

案例（版本二采用封装）

(七)：QWidget控件之父子关系：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("父子关系的学习")
14 window.resize(500,500)
15 
16 label1 = QLabel(window)
17         # label1.setParent(window)  也可以设置父亲
18 label1.setText("标签1")
19 
20 label2 = QLabel(window)
21 label2.setText("标签2")
22 label2.move(100,100)
23 
24 label3 = QLabel(window)
25 label3.setText("标签3")
26 label3.move(200,200)
27 
28 print(window.childAt(101,105))  # 窗口 window 查看101,105 处是否有控件   输出：<PyQt5.QtWidgets.QLabel object at 0x0000021076265A68>
29 
30 print(window.childAt(300,300))  # 窗口 window 查看300,300 处是否有控件   输出：None
31 
32 
33 #展示控件
34 window.show()
35 
36 #3,进入消息循环
37 sys.exit(app.exec_())

利用ChildrenAt() 来查看一个位置是否有子控件

利用parentWidget() 查看父控件

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("父子关系的学习")
14 window.resize(500,500)
15 
16 label1 = QLabel(window)
17         # label1.setParent(window)  也可以设置父亲
18 label1.setText("标签1")
19 
20 label2 = QLabel(window)
21 label2.setText("标签2")
22 label2.move(100,100)
23 
24 label3 = QLabel(window)
25 label3.setText("标签3")
26 label3.move(200,200)
27 
28 print(window.childrenRect())  # 查看所有子控件的矩形区域  输出：PyQt5.QtCore.QRect(0, 0, 300, 230)
29 
30 #展示控件
31 window.show()
32 
33 #3,进入消息循环
34 sys.exit(app.exec_())

利用childrenRect() 来获取所有子控件的矩形区域

父子关系的案例：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Label(QLabel):
 5     def mousePressEvent(self, QMouseEvent):
 6         self.setStyleSheet("background-color:red;")
 7 
 8 
 9 #1,创建app
10 app  = QApplication(sys.argv)
11 
12 
13 #2，控件的操作：
14 #创建控件
15 window = QWidget()
16 
17 
18 #设置控件
19 window.setWindowTitle("父子关系案例")
20 window.resize(500,500)
21 
22 for i in range(10):
23     label = Label(window)
24     label.setText("标签"+str(i))
25     label.move(30*i ,30*i)
26 
27 
28 #展示控件
29 window.show()
30 
31 #3,进入消息循环
32 sys.exit(app.exec_())

通过自定义Label()类来实现

下面是不通过自定义类照样实现这个功能：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def mousePressEvent(self, event):
 6         local_x = event.x()
 7         local_y = event.y()
 8         sub_widget = self.childAt(local_x,local_y)
 9         if sub_widget:  # 排除sub_widget 是None
10             sub_widget.setStyleSheet("background-color:red;")
11 
12 #1,创建app
13 app  = QApplication(sys.argv)
14 
15 
16 #2，控件的操作：
17 #创建控件
18 window = Window()
19 
20 
21 #设置控件
22 window.setWindowTitle("父子关系案例")
23 window.resize(500,500)
24 
25 for i in range(10):
26     label = QLabel(window)
27     label.setText("标签"+str(i))
28     label.move(30*i ,30*i)
29 
30 
31 #展示控件
32 window.show()
33 
34 #3,进入消息循环
35 sys.exit(app.exec_())

不通过自定义标签类照样解决问题

(八)：QWidget控件之层级控制：

它主要的作用就是调整z轴顺序：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)  
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("层级控制")
14 window.resize(500,500)
15 
16 
17 label1 = QLabel(window)
18 label1.setText("标签1")
19 label1.resize(200,200)
20 label1.setStyleSheet("background-color:red;")
21 
22 label2 = QLabel(window)
23 label2.setText("标签2")
24 label2.resize(200,200)
25 label2.setStyleSheet("background-color:green;")
26 label2.move(100,100)
27 
28 #展示控件
29 window.show()
30 
31 #3,进入消息循环
32 sys.exit(app.exec_())

View Code

效果是：

现在如果想让早出现的红色在上面：

一共有三种方法：

1，将红色的升上去

2，将绿色的降下去

3，将绿色放在红色下面

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)  
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("层级控制")
14 window.resize(500,500)
15 
16 
17 label1 = QLabel(window)
18 label1.setText("标签1")
19 label1.resize(200,200)
20 label1.setStyleSheet("background-color:red;")
21 
22 label2 = QLabel(window)
23 label2.setText("标签2")
24 label2.resize(200,200)
25 label2.setStyleSheet("background-color:green;")
26 label2.move(100,100)
27 
28 label1.raise_()  # 让label1 升到最高
29 
30 #展示控件
31 window.show()
32 
33 #3,进入消息循环
34 sys.exit(app.exec_())

将label1 升到最高

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)  
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("层级控制")
14 window.resize(500,500)
15 
16 
17 label1 = QLabel(window)
18 label1.setText("标签1")
19 label1.resize(200,200)
20 label1.setStyleSheet("background-color:red;")
21 
22 label2 = QLabel(window)
23 label2.setText("标签2")
24 label2.resize(200,200)
25 label2.setStyleSheet("background-color:green;")
26 label2.move(100,100)
27 
28 label2.lower()   # 将label2 降到最下层
29 
30 
31 #展示控件
32 window.show()
33 
34 #3,进入消息循环
35 sys.exit(app.exec_())

将label2 降下去

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)  
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("层级控制")
14 window.resize(500,500)
15 
16 
17 label1 = QLabel(window)
18 label1.setText("标签1")
19 label1.resize(200,200)
20 label1.setStyleSheet("background-color:red;")
21 
22 label2 = QLabel(window)
23 label2.setText("标签2")
24 label2.resize(200,200)
25 label2.setStyleSheet("background-color:green;")
26 label2.move(100,100)
27 
28 label2.stackUnder(label1)   # 将label2 放在label1 的下面
29 
30 #展示控件
31 window.show()
32 
33 #3,进入消息循环
34 sys.exit(app.exec_())

将label2 放在label1 的下面

现在需求是点击谁，让谁跑到上面：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class MyLabel(QLabel):
 5     def mousePressEvent(self, QMouseEvent):
 6         self.raise_()
 7 
 8 
 9 #1,创建app
10 app  = QApplication(sys.argv)  
11 
12 
13 #2，控件的操作：
14 #创建控件
15 window = QWidget()
16 
17 
18 #设置控件
19 window.setWindowTitle("层级控制")
20 window.resize(500,500)
21 
22 
23 label1 = MyLabel(window)
24 label1.setText("标签1")
25 label1.resize(200,200)
26 label1.setStyleSheet("background-color:red;")
27 
28 label2 = MyLabel(window)
29 label2.setText("标签2")
30 label2.resize(200,200)
31 label2.setStyleSheet("background-color:green;")
32 label2.move(100,100)
33 
34 label2.stackUnder(label1)   # 将label2 放在label1 的下面
35 
36 #展示控件
37 window.show()
38 
39 #3,进入消息循环
40 sys.exit(app.exec_())

点谁，谁出现在最上层

(九)：QWidget控件之顶层窗口相关：

如果一个控件没有父控件，那么它就是顶层窗口。

API之图标：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)  
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("顶层窗口相关操作")
14 window.resize(500,500)
15 
16 icon = QIcon("d:/icon.png")
17 window.setWindowIcon(icon)  #设置图标
18 
19 print(window.windowIcon())  #获取图标
20 
21 
22 
23 #展示控件
24 window.show()
25 
26 #3,进入消息循环
27 sys.exit(app.exec_())

设置图标以及获取图标

API之标题：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)  
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("顶层窗口相关操作")
14 window.resize(500,500)
15 
16 window.setWindowTitle(" ")  #设置标题
17 print(window.windowTitle())  #获取标题
18  
19 
20 
21 #展示控件
22 window.show()
23 
24 #3,进入消息循环
25 sys.exit(app.exec_())

View Code

API之不透明度：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)  
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("顶层窗口相关操作")
14 window.resize(500,500)
15 
16 window.setWindowOpacity(0.5)  # 设置为半透明
17 print(window.windowOpacity())  # 获取不透明度
18 
19 
20 #展示控件
21 window.show()
22 
23 #3,进入消息循环
24 sys.exit(app.exec_())

View Code

API之窗口状态：

无状态是正常的状态。是默认的状态，

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)  
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("顶层窗口相关操作")
14 window.resize(500,500)
15 
16 print(window.windowState() == Qt.WindowNoState)  # True  说明默认是无状态
17 
18 window.setWindowState(Qt.WindowMinimized)  #最小化
19 window.setWindowState(Qt.WindowMaximized)  #最大化  有标题栏
20 window.setWindowState(Qt.WindowFullScreen)  #最小化  标题栏都没了 #这时要通过任务管理器结束进程
21 
22 
23 
24 #展示控件
25 window.show()
26 
27 #3,进入消息循环
28 sys.exit(app.exec_())

顶层窗口的状态---无状态，最小化，最大化，和全屏

活动窗口：是当有多个窗口时，让活跃的窗口处在最顶层。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)  
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("顶层窗口相关操作")
14 window.resize(500,500)
15 
16 print(window.windowState() == Qt.WindowNoState)  # True  说明默认是无状态
17 
18 window.setWindowState(Qt.WindowMinimized)  #最小化
19 window.setWindowState(Qt.WindowMaximized)  #最大化  有标题栏
20 # window.setWindowState(Qt.WindowFullScreen)  #最小化  标题栏都没了 #这时要通过任务管理器结束进程
21 
22 window2 = QWidget()
23 
24 window2.show()
25 
26 
27 #展示控件
28 window.show()
29 window2.setWindowState(Qt.WindowActive)
30 
31 #3,进入消息循环
32 sys.exit(app.exec_())

View Code

API之最大化和最小化：

我们可以通过窗口状态来设置最大和最小，但是一般常用的是用这些：

showFull showMax showMin

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)  
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("顶层窗口相关操作")
14 window.resize(500,500)
15 
16 
17 #展示控件
18 # window.show()
19 window.showMaximized()  #展示最大，这时上面的window.show() 也可以不用要
20 # window.showFullScreen()
21 # window.showMinimized()
22 
23 
24 #3,进入消息循环
25 sys.exit(app.exec_())

View Code

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 
 5 class Window(QWidget):
 6     def mousePressEvent(self, QMouseEvent):
 7         if self.isMaximized():
 8             self.showNormal()
 9         else:
10             self.showMaximized()
11 
12 #1,创建app
13 app  = QApplication(sys.argv)  
14 
15 
16 #2，控件的操作：
17 #创建控件
18 window = Window()
19 
20 
21 #设置控件
22 window.setWindowTitle("顶层窗口相关操作")
23 window.resize(500,500)
24 
25 
26 #展示控件
27 window.show()
28 
29 
30 
31 #3,进入消息循环
32 sys.exit(app.exec_())

通过判定窗口的状态实现点击窗口切换最大和正常

API之窗口标志：

可以通过它设置窗口的外观。

这里如果是我们只要求有一个最大化的按钮，这又该如何去搞呢？

这主要是通过顶层窗口外观标志来设置：

顶层窗口的案例：

第一个需求是：去掉标题栏

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget(flags=Qt.FramelessWindowHint)
10         # def __init__(self, parent=None, flags, Qt_WindowFlags=None, Qt_WindowType=None, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__
11                 # pass
12         # 在创建窗口的时候就可以对外观标志进行设置了，
13 
14 
15 #设置控件
16 window.setWindowTitle("顶层窗口操作案例")
17 window.resize(500,500)
18 
19 
20 
21 
22 
23 #展示控件
24 window.show()
25 
26 #3,进入消息循环
27 sys.exit(app.exec_())

初始化窗口的时候就设置flags

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 window.setWindowFlags(Qt.FramelessWindowHint)  #通过方法设置flags 
11 
12 
13 #设置控件
14 window.setWindowTitle("顶层窗口操作案例")
15 window.resize(500,500)
16 
17 
18 
19 
20 
21 #展示控件
22 window.show()
23 
24 #3,进入消息循环
25 sys.exit(app.exec_())

通过setWindowFlags设置flags

第二个需求：让窗口变为半透明，

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget(flags=Qt.FramelessWindowHint)
10 window.setWindowOpacity(0.5)
11 
12 
13 
14 #设置控件
15 window.setWindowTitle("顶层窗口操作案例")
16 window.resize(500,500)
17 
18 
19 #展示控件
20 window.show()
21 
22 #3,进入消息循环
23 sys.exit(app.exec_())

View Code

第三个需求：自定制标题栏，

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget(flags=Qt.FramelessWindowHint)
10 window.setWindowOpacity(0.9)
11 
12 
13 
14 #设置控件
15 window.setWindowTitle("顶层窗口操作案例")
16 window.resize(500,500)
17 
18 
19 
20 #添加三个子控件 - 窗口的右上角
21 close_btn = QPushButton(window)
22 close_btn.setText("关闭")  #暂时以文本呈现
23 close_btn.resize(40,25)
24 close_btn_width = close_btn.width()
25 window_width  = window.width()
26 close_btn_x = window_width - close_btn_width
27 close_btn_y = 0
28 close_btn.move(close_btn_x,close_btn_y)
29 
30 max_btn = QPushButton(window)
31 max_btn.setText("最大")
32 max_btn.resize(40,25)
33 max_btn_x = close_btn_x -max_btn.width()
34 max_btn_y = 0
35 max_btn.move(max_btn_x,max_btn_y)
36 
37 mini_btn = QPushButton(window)
38 mini_btn.setText("最小")
39 mini_btn.resize(40,25)
40 mini_btn_x = max_btn_x -mini_btn.width()
41 mini_btn_y = 0
42 mini_btn.move(mini_btn_x,mini_btn_y)
43 
44 
45 
46 #展示控件
47 window.show()
48 
49 #3,进入消息循环
50 sys.exit(app.exec_())

View Code

继续第三个操作，实现三个按钮的功能：

监听按钮有两个思路，一个是按信号和槽，一个是监听事件，修改它的方法。

信号会更好一点，它是事件的高级封装，一般能用信号和槽的都用信号和槽。

按钮按下会发出信号pressed。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget(flags=Qt.FramelessWindowHint)
10 window.setWindowOpacity(0.9)
11 
12 
13 
14 #设置控件
15 window.setWindowTitle("顶层窗口操作案例")
16 window.resize(500,500)
17 
18 
19 
20 #添加三个子控件 - 窗口的右上角
21 close_btn = QPushButton(window)
22 close_btn.setText("关闭")  #暂时以文本呈现
23 close_btn.resize(40,25)
24 close_btn_width = close_btn.width()
25 window_width  = window.width()
26 close_btn_x = window_width - close_btn_width
27 close_btn_y = 0
28 close_btn.move(close_btn_x,close_btn_y)
29 
30 max_btn = QPushButton(window)
31 max_btn.setText("最大")
32 max_btn.resize(40,25)
33 max_btn_x = close_btn_x -max_btn.width()
34 max_btn_y = 0
35 max_btn.move(max_btn_x,max_btn_y)
36 
37 mini_btn = QPushButton(window)
38 mini_btn.setText("最小")
39 mini_btn.resize(40,25)
40 mini_btn_x = max_btn_x -mini_btn.width()
41 mini_btn_y = 0
42 mini_btn.move(mini_btn_x,mini_btn_y)
43 
44 def close_window_slot():
45     window.close()
46 
47 def max_normal_window_slot():   # 最大化或者正常
48     if window.isMaximized():
49         window.showNormal()
50         max_btn.setText("最大")
51     else:
52         window.showMaximized()
53         max_btn.setText("恢复")
54 
55 def mini_window_slot():
56     window.showMinimized()
57 
58 close_btn.pressed.connect(close_window_slot)
59 max_btn.pressed.connect(max_normal_window_slot)
60 mini_btn.pressed.connect(mini_window_slot)
61 
62 
63 
64 
65 #展示控件
66 window.show()
67 
68 #3,进入消息循环
69 sys.exit(app.exec_())

实现三个按钮的功能

下面在继续做之前，先做个重构，重构指的就是重新改变代码的结构，一般都是指封装起来，这样更方便修改维护和继续开发，

如下重构：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 
 5 class Window(QWidget):
 6     def __init__(self,*args,**kwargs):
 7         super().__init__(*args,**kwargs)
 8         self.setWindowOpacity(0.9)
 9         self.setWindowTitle("顶层窗口操作案例")
10         self.resize(500,500)
11         self.setup_ui()
12 
13 
14     def setup_ui(self):
15         self.btn_width = 40
16         self.btn_height = 25
17         self.top_margin = 0
18         self.add_close_max_mini_contrl()
19 
20     def add_close_max_mini_contrl(self):
21         #添加三个子控件 - 窗口的右上角
22         self.close_btn = QPushButton(self)
23         self.close_btn.setText("关闭")  #暂时以文本呈现
24         self.close_btn.resize(self.btn_width,self.btn_height)
25         close_btn_width = self.close_btn.width()
26         window_width  = self.width()
27         close_btn_x = window_width - close_btn_width
28         close_btn_y = self.top_margin
29         self.close_btn.move(close_btn_x,close_btn_y)
30 
31         self.max_btn = QPushButton(self)
32         self.max_btn.setText("最大")
33         self.max_btn.resize(self.btn_width,self.btn_height)
34         max_btn_x = close_btn_x -self.max_btn.width()
35         max_btn_y = self.top_margin
36         self.max_btn.move(max_btn_x,max_btn_y)
37 
38         self.mini_btn = QPushButton(self)
39         self.mini_btn.setText("最小")
40         self.mini_btn.resize(self.btn_width,self.btn_height)
41         mini_btn_x = max_btn_x -self.mini_btn.width()
42         mini_btn_y = self.top_margin
43         self.mini_btn.move(mini_btn_x,mini_btn_y)
44 #1,创建app
45 app  = QApplication(sys.argv)
46 
47 #2，控件的操作：
48 
49 window = Window(flags=Qt.FramelessWindowHint)
50 
51 def close_window_slot():
52     window.close()
53 def max_normal_window_slot():   # 最大化或者正常
54     if window.isMaximized():
55         window.showNormal()
56         window.max_btn.setText("最大")
57     else:
58         window.showMaximized()
59         window.max_btn.setText("恢复")
60 def mini_window_slot():
61     window.showMinimized()
62     
63 window.close_btn.pressed.connect(close_window_slot)
64 window.max_btn.pressed.connect(max_normal_window_slot)
65 window.mini_btn.pressed.connect(mini_window_slot)
66 
67 
68 #展示控件
69 window.show()
70 
71 #3,进入消息循环
72 sys.exit(app.exec_())

重构之后的代码

下面继续开发，但是要先解决bug ,因为这时按钮不会随着窗口的变大而改变位置。

要解决它。

分两步：监听窗口大小的变化，然后重新计算下按钮的位置。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 
 5 class Window(QWidget):
 6     def __init__(self,*args,**kwargs):
 7         super().__init__(*args,**kwargs)
 8         self.setWindowOpacity(0.9)
 9         self.setWindowTitle("顶层窗口操作案例")
10         self.resize(500,500)
11         self.setup_ui()
12 
13 
14     def setup_ui(self):
15         self.btn_width = 40
16         self.btn_height = 25
17         self.top_margin = 0
18         self.add_close_max_mini_contrl()
19 
20     def add_close_max_mini_contrl(self):
21         #添加三个子控件 - 窗口的右上角
22         self.close_btn = QPushButton(self)
23         self.close_btn.setText("关闭")  #暂时以文本呈现
24         self.close_btn.resize(self.btn_width,self.btn_height)
25 
26         self.max_btn = QPushButton(self)
27         self.max_btn.setText("最大")
28         self.max_btn.resize(self.btn_width,self.btn_height)
29 
30         self.mini_btn = QPushButton(self)
31         self.mini_btn.setText("最小")
32         self.mini_btn.resize(self.btn_width,self.btn_height)
33 
34     def resizeEvent(self, QResizeEvent):
35         print("窗口大小发生变化")
36         close_btn_width = self.close_btn.width()
37         window_width  = self.width()
38         close_btn_x = window_width - close_btn_width
39         close_btn_y = self.top_margin
40         self.close_btn.move(close_btn_x,close_btn_y)
41 
42         max_btn_x = close_btn_x -self.max_btn.width()
43         max_btn_y = self.top_margin
44         self.max_btn.move(max_btn_x,max_btn_y)
45 
46         mini_btn_x = max_btn_x -self.mini_btn.width()
47         mini_btn_y = self.top_margin
48         self.mini_btn.move(mini_btn_x,mini_btn_y)
49 
50 #1,创建app
51 app  = QApplication(sys.argv)
52 
53 #2，控件的操作：
54 
55 window = Window(flags=Qt.FramelessWindowHint)
56 
57 def close_window_slot():
58     window.close()
59 def max_normal_window_slot():   # 最大化或者正常
60     if window.isMaximized():
61         window.showNormal()
62         window.max_btn.setText("最大")
63     else:
64         window.showMaximized()
65         window.max_btn.setText("恢复")
66 def mini_window_slot():
67     window.showMinimized()
68 
69 window.close_btn.pressed.connect(close_window_slot)
70 window.max_btn.pressed.connect(max_normal_window_slot)
71 window.mini_btn.pressed.connect(mini_window_slot)
72 
73 
74 #展示控件
75 window.show()
76 
77 #3,进入消息循环
78 sys.exit(app.exec_())

View Code

第四个需求：支持拖拽用户去移动：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 
 5 class Window(QWidget):
 6     def __init__(self,*args,**kwargs):
 7         super().__init__(*args,**kwargs)
 8         self.setWindowOpacity(0.5)
 9         self.setWindowTitle("顶层窗口操作案例")
10         self.resize(500,500)
11         self.setup_ui()
12         self.move_flags = False   # 主要是为了防止，鼠标追踪导致出现问题
13         # self.setMouseTracking(True)
14     def setup_ui(self):
15         self.btn_width = 40
16         self.btn_height = 25
17         self.top_margin = 0
18         self.add_close_max_mini_contrl()
19     def add_close_max_mini_contrl(self):
20         #添加三个子控件 - 窗口的右上角
21         self.close_btn = QPushButton(self)
22         self.close_btn.setText("关闭")  #暂时以文本呈现
23         self.close_btn.resize(self.btn_width,self.btn_height)
24 
25         self.max_btn = QPushButton(self)
26         self.max_btn.setText("最大")
27         self.max_btn.resize(self.btn_width,self.btn_height)
28 
29         self.mini_btn = QPushButton(self)
30         self.mini_btn.setText("最小")
31         self.mini_btn.resize(self.btn_width,self.btn_height)
32     def resizeEvent(self, QResizeEvent):
33         print("窗口大小发生变化")
34         close_btn_width = self.close_btn.width()
35         window_width  = self.width()
36         close_btn_x = window_width - close_btn_width
37         close_btn_y = self.top_margin
38         self.close_btn.move(close_btn_x,close_btn_y)
39 
40         max_btn_x = close_btn_x -self.max_btn.width()
41         max_btn_y = self.top_margin
42         self.max_btn.move(max_btn_x,max_btn_y)
43 
44         mini_btn_x = max_btn_x -self.mini_btn.width()
45         mini_btn_y = self.top_margin
46         self.mini_btn.move(mini_btn_x,mini_btn_y)
47     def mousePressEvent(self, event):
48         if  event.button() == Qt.LeftButton:
49             self.move_flags = True
50             self.mouse_x = event.globalX()
51             self.mouse_y = event.globalY()
52 
53             self.window_x = self.x()
54             self.window_y = self.y()
55     def mouseMoveEvent(self, event):
56         if self.move_flags:
57             self.move_x = event.globalX() -self.mouse_x
58             self.move_y = event.globalY() -self.mouse_y
59             self.move(self.window_x + self.move_x,self.window_y +self.move_y)
60     def mouseReleaseEvent(self, event):
61         self.move_flags = False
62 
63 #1,创建app
64 app  = QApplication(sys.argv)
65 
66 #2，控件的操作：
67 
68 window = Window(flags=Qt.FramelessWindowHint)
69 
70 def close_window_slot():
71     window.close()
72 def max_normal_window_slot():   # 最大化或者正常
73     if window.isMaximized():
74         window.showNormal()
75         window.max_btn.setText("最大")
76     else:
77         window.showMaximized()
78         window.max_btn.setText("恢复")
79 def mini_window_slot():
80     window.showMinimized()
81 
82 window.close_btn.pressed.connect(close_window_slot)
83 window.max_btn.pressed.connect(max_normal_window_slot)
84 window.mini_btn.pressed.connect(mini_window_slot)
85 
86 
87 #展示控件
88 window.show()
89 
90 #3,进入消息循环
91 sys.exit(app.exec_())

终极版

至于里面的图标，可以自己替代！

(十)：QWidget控件之交互状态：

API之是否可用：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("交互状态")
14 window.resize(500,500)
15 
16 
17 btn = QPushButton(window)
18 btn.setText("按钮")
19 btn.pressed.connect(lambda :print("点击按钮"))
20 btn.setEnabled(False)  #将它设置为不可用
21 print(btn.isEnabled())  # 查看它是否可用
22 
23 
24 #展示控件
25 window.show()
26 
27 #3,进入消息循环
28 sys.exit(app.exec_())

View Code

API之是否显示/隐藏：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def paintEvent(self, event):  #窗口绘制事件
 6         print("窗口被绘制了")
 7         return super().paintEvent(event)
 8 
 9 #1,创建app
10 app  = QApplication(sys.argv)
11 
12 #2，控件的操作：
13 #创建控件
14 window = Window()
15 
16 #设置控件
17 window.setWindowTitle("交互状态")
18 window.resize(500,500)
19 
20 #展示控件
21 window.show()  # 如果此时没有window.show()就不会触发paintEvent() 了
22 
23 #3,进入消息循环
24 sys.exit(app.exec_())

window.show() 触发paintEvent()

其实show() 并不是最底层的函数，它只是调用了下面的函数，setVisible(bool)

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def paintEvent(self, event):  #窗口绘制事件
 6         print("窗口被绘制了")
 7         return super().paintEvent(event)
 8 
 9 #1,创建app
10 app  = QApplication(sys.argv)
11 
12 #2，控件的操作：
13 #创建控件
14 window = Window()
15 
16 #设置控件
17 window.setWindowTitle("交互状态")
18 window.resize(500,500)
19 
20 #展示控件
21 # window.show()
22 window.setVisible(True)  # 其实是window.show()调的它  
23 
24 #3,进入消息循环
25 sys.exit(app.exec_())

底层的setVisible()

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def paintEvent(self, event):  #窗口绘制事件
 6         print("窗口被绘制了")
 7         return super().paintEvent(event)
 8 
 9 #1,创建app
10 app  = QApplication(sys.argv)
11 
12 #2，控件的操作：
13 #创建控件
14 window = Window()
15 
16 #设置控件
17 window.setWindowTitle("交互状态")
18 window.resize(500,500)
19 
20 #展示控件
21 # window.show()
22 # window.setVisible(True)
23 window.setHidden(False)  #它也可以绘制window
24 
25 
26 #3,进入消息循环
27 sys.exit(app.exec_())

用setHidden() 来绘制窗口

而且，绘制的时候肯定是先绘制顶层窗口，然后再绘制里面的子控件。下面来验证这一点：

肯定要监听子控件的绘制事件了，所以就要重写它的类的绘制方法了。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def paintEvent(self, event):  #窗口绘制事件
 6         print("窗口被绘制了")
 7         return super().paintEvent(event)
 8 
 9 class Btn(QPushButton):
10     def paintEvent(self, event):
11         print("里面控件被绘制了")
12         return super().paintEvent(event)
13 
14 
15 #1,创建app
16 app  = QApplication(sys.argv)
17 
18 #2，控件的操作：
19 #创建控件
20 window = Window()
21 
22 #设置控件
23 window.setWindowTitle("交互状态")
24 window.resize(500,500)
25 
26 btn = Btn(window)
27 btn.setText("按钮")
28 
29 #展示控件
30 # window.show()
31 # window.setVisible(True)
32 window.setHidden(False)  #它也可以绘制window
33 
34 #3,进入消息循环
35 sys.exit(app.exec_())
36 
37 '''
38     输出： 
39         窗口被绘制了
40         里面控件被绘制了
41 '''

View Code

现在的要求是点击按钮之后，将其隐藏：

这里指的隐藏是当重新绘制时，不绘制按钮而已。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def paintEvent(self, event):  #窗口绘制事件
 6         print("窗口被绘制了")
 7         return super().paintEvent(event)
 8 
 9 class Btn(QPushButton):
10     def paintEvent(self, event):
11         print("里面控件被绘制了")
12         return super().paintEvent(event)
13 
14 
15 #1,创建app
16 app  = QApplication(sys.argv)
17 
18 #2，控件的操作：
19 #创建控件
20 window = Window()
21 
22 #设置控件
23 window.setWindowTitle("交互状态")
24 window.resize(500,500)
25 
26 btn = Btn(window)
27 btn.setText("按钮")
28 btn.pressed.connect(lambda :btn.setVisible(False))  #点击之后，就会把它给隐藏了，
29                                                     # 后面的绘制就不会显示它了，但是这个对象还是存在的
30 
31 #展示控件
32 # window.show()
33 # window.setVisible(True)
34 window.setHidden(False)  #它也可以绘制window
35 
36 #3,进入消息循环
37 sys.exit(app.exec_())

点击触发，给按钮设置隐藏标记，重新绘制时便不会绘制它了

注意事项：

有时候给setVisable 传True 也不一定能绘制成功，因为绘制都是按照先父控件，后子控件来的，所以，如果直接绘制子控件，这肯定是不行的。

如下证明：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("交换状态")
14 window.resize(500,500)
15 
16 btn = QPushButton(window)
17 btn.setText("按钮")
18 
19 btn.setVisible(True)  #就算给子控件设置了 TRUE ，因为它的父控件没有被绘制，所以 它也没被绘制
20 
21 
22 #展示控件
23 # window.show()
24 
25 #3,进入消息循环
26 sys.exit(app.exec_())

View Code

isVisable 和 isHidden 的区别：

isVisible 和 isHidden的区别：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 #2，控件的操作：
 7 #创建控件
 8 window = QWidget()
 9 
10 #设置控件
11 window.setWindowTitle("交互状态")
12 window.resize(500,500)
13 
14 btn = QPushButton(window)
15 btn.move(100,100)
16 btn.setText("按钮")
17 
18 window.show()        #此时：   输出：  False / True 
19 
20 print(btn.isHidden())  #是否被设置隐藏
21 print(btn.isVisible()) #到此是否可见
22 
23 
24 #展示控件
25 
26 #3,进入消息循环
27 sys.exit(app.exec_())

View Code

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 #2，控件的操作：
 7 #创建控件
 8 window = QWidget()
 9 
10 #设置控件
11 window.setWindowTitle("交互状态")
12 window.resize(500,500)
13 
14 btn = QPushButton(window)
15 btn.move(100,100)
16 btn.setText("按钮")
17 
18 
19 
20 print(btn.isHidden())  #是否被设置隐藏
21 print(btn.isVisible()) #到此是否可见
22 
23 window.show()        #此时：   输出：  False / False
24 
25 #展示控件
26 
27 #3,进入消息循环
28 sys.exit(app.exec_())

View Code

它强调的是如果父控件显示（不管是否真的显示父控件），它是否跟着显示。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 #2，控件的操作：
 7 #创建控件
 8 window = QWidget()
 9 
10 #设置控件
11 window.setWindowTitle("交互状态")
12 window.resize(500,500)
13 
14 btn = QPushButton(window)
15 btn.move(100,100)
16 btn.setText("按钮")
17 
18 # window.show()
19 
20 #它这句话的意思是 如果 父控件显示的时候，子控件是否被显示
21 print(btn.isVisibleTo(window))    #就算是父控件不显示也不影响它 ，它只是如果父控件显示，它就显示
22 
23 
24 #展示控件
25 
26 #3,进入消息循环
27 sys.exit(app.exec_())

View Code

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 #2，控件的操作：
 7 #创建控件
 8 window = QWidget()
 9 
10 #设置控件
11 window.setWindowTitle("交互状态")
12 window.resize(500,500)
13 
14 btn = QPushButton(window)
15 btn.move(100,100)
16 btn.setText("按钮")
17 
18 # window.show()
19 
20 btn.setVisible(False)  # 如果加上它的话，下面的打印就要是False  了
21 
22 #它这句话的意思是 如果 父控件显示的时候，子控件是否被显示
23 print(btn.isVisibleTo(window))    #就算是父控件不显示也不影响它 ，它只是如果父控件显示，它就显示
24 
25 
26 #展示控件
27 
28 #3,进入消息循环
29 sys.exit(app.exec_())

View Code

API之是否编辑：

被编辑的时候显示文件名字带* 。

【*】设置标题的时候，* 会被隐藏，直到设置setWindowModified(True) ，它会被显示。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 #2，控件的操作：
 7 #创建控件
 8 window = QWidget()
 9 
10 #设置控件
11 window.setWindowTitle("交互状态[*]")
12 window.resize(500,500)
13 
14 
15 window.show()
16 
17 #3,进入消息循环
18 sys.exit(app.exec_())

看不到 *

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 #2，控件的操作：
 7 #创建控件
 8 window = QWidget()
 9 
10 #设置控件
11 window.setWindowTitle("交互状态[*]")
12 window.resize(500,500)
13 window.setWindowModified(True)  # 此时*  就会被显示了，但是[] 不会被显示的
14 
15 
16 window.show()
17 
18 #3,进入消息循环
19 sys.exit(app.exec_())

显示 *

而且[* ] 可以放在字符串的任意位置，都是可以的。

而且，中括号内部只能放* ，其他符号都是不行的。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 #2，控件的操作：
 7 #创建控件
 8 window = QWidget()
 9 
10 #设置控件
11 window.setWindowTitle("交互状态[$]")
12 window.resize(500,500)
13 window.setWindowModified(True)  # 此时*  就会被显示了，但是[] 不会被显示的
14 
15 
16 window.show()
17 
18 #3,进入消息循环
19 sys.exit(app.exec_())

其他字符不行

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 #2，控件的操作：
 7 #创建控件
 8 window = QWidget()
 9 
10 #设置控件
11 window.setWindowTitle("交互状态[*]")
12 window.resize(500,500)
13 window.setWindowModified(True)
14 print(window.isWindowModified())  # 查看是否被被编辑的状态
15 
16 window.show()
17 
18 #3,进入消息循环
19 sys.exit(app.exec_())

查看当前窗口是否被处于被编辑的状态

API之是否活跃窗口：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 #2，控件的操作：
 7 #创建控件
 8 window = QWidget()
 9 
10 #设置控件
11 window.setWindowTitle("交互状态")
12 window.resize(500,500)
13 
14 window2 = QWidget()
15 window2.show()
16 
17 window.show()
18 
19 print(window2.isActiveWindow())  # False
20 print(window.isActiveWindow())   # True
21 
22 
23 #3,进入消息循环
24 sys.exit(app.exec_())

View Code

是否，某一个窗口在最上面，它就是处于活跃状态呢？

不一定，如下代码（它只是显示在最上面）

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 #2，控件的操作：
 7 #创建控件
 8 window = QWidget()
 9 
10 #设置控件
11 window.setWindowTitle("交互状态")
12 window.resize(500,500)
13 
14 window2 = QWidget()
15 window2.show()
16 
17 window.show()
18 
19 window2.raise_()  #将window2 提到最外层  ，但是它仍然不是出于活跃的状态
20 
21 print(window2.isActiveWindow())  # False
22 print(window.isActiveWindow())   # True
23 
24 
25 #3,进入消息循环
26 sys.exit(app.exec_())

View Code

API之关闭：

它其实是调用之前的setVisable() 方法。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 #2，控件的操作：
 7 #创建控件
 8 window = QWidget()
 9 
10 #设置控件
11 window.setWindowTitle("交互状态")
12 window.resize(500,500)
13 
14 btn = QPushButton(window)
15 btn.setText("按钮")
16 
17 #隐藏这个按钮的四种方法
18 # btn.setVisible(False)
19 # btn.setHidden(True)
20 # btn.hide()
21 btn.close()
22 
23 window.show()
24 
25 #3,进入消息循环
26 sys.exit(app.exec_())

四种隐藏方法

一般情况下，它们四个都只是隐藏，而不释放控件。

需要注意的是，close() 是可以通过设置，隐藏的时候将它释放的

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 #2，控件的操作：
 7 #创建控件
 8 window = QWidget()
 9 
10 #设置控件
11 window.setWindowTitle("交互状态")
12 window.resize(500,500)
13 
14 btn = QPushButton(window)
15 btn.setText("按钮")
16 btn.destroyed.connect(lambda :print("按钮被释放了"))
17 
18 #隐藏这个按钮的四种方法
19 # btn.setVisible(False)
20 # btn.setHidden(True)
21 # btn.hide()
22 btn.setAttribute(Qt.WA_DeleteOnClose,True)  # 这再调用close()就会释放按钮了
23 btn.close()
24 
25 window.show()
26 
27 #3,进入消息循环
28 sys.exit(app.exec_())

这时就释放了

这里只需要记住，它只是结合close() 来用的，对于其他的三个隐藏方法，一般不可用。

交互状态的案例：

首先：创建文本框和按钮和标签：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("交互状态的的案例")
 8         self.resize(400,400)
 9         self.set_ui()
10 
11 
12     def set_ui(self):
13         #添加三个子控件
14         label = QLabel(self)
15         label.setText("标签")
16         label.move(50,50)
17 
18         lineEdit = QLineEdit(self)
19         lineEdit.setText("文本框")
20         lineEdit.move(50,100)
21 
22         btn  = QPushButton(self)
23         btn.setText("登录")
24         btn.move(50,150)
25 
26 
27 
28 if __name__ == '__main__':
29     app =QApplication(sys.argv)
30 
31     window = Window()
32 
33     window.show()
34 
35     sys.exit(app.exec_())

View Code

继续：标签被隐藏，文本框和按钮被显示，按钮显示不可用。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("交互状态的的案例")
 8         self.resize(400,400)
 9         self.set_ui()
10 
11 
12     def set_ui(self):
13         #添加三个子控件
14         label = QLabel(self)
15         label.setText("标签")
16         label.move(50,50)
17         label.hide()  #异常标签
18 
19         lineEdit = QLineEdit(self)
20         lineEdit.setText("文本框")
21         lineEdit.move(50,100)
22 
23         btn  = QPushButton(self)
24         btn.setText("登录")
25         btn.move(50,150)
26         btn.setEnabled(False)  #设置它不可用
27 
28 
29 if __name__ == '__main__':
30     app =QApplication(sys.argv)
31 
32     window = Window()
33 
34     window.show()
35 
36     sys.exit(app.exec_())

View Code

继续：

这里使用textChanged信号。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("交互状态的的案例")
 8         self.resize(400,400)
 9         self.set_ui()
10 
11 
12     def set_ui(self):
13         #添加三个子控件
14         label = QLabel(self)
15         label.setText("标签")
16         label.move(50,50)
17         label.hide()  #异常标签
18 
19         lineEdit = QLineEdit(self)
20         # lineEdit.setText("文本框")
21         lineEdit.move(50,100)
22 
23         btn  = QPushButton(self)
24         btn.setText("登录")
25         btn.move(50,150)
26         btn.setEnabled(False)  #设置它不可用
27 
28         def textChanged_slot(arg):
29             print("文本框内容改变了",arg)
30 
31         lineEdit.textChanged.connect(textChanged_slot)
32                 #而且此时，会给我们传递出一个参数,这个参数
33                     # 就是每次改变之后文本框内剩余的内容，我们可以用槽函数来接收
34 if __name__ == '__main__':
35     app =QApplication(sys.argv)
36 
37     window = Window()
38 
39     window.show()
40     sys.exit(app.exec_())

监听文本框的变化，并获取里面的内容

通过它就能实现有内容登录窗口可用，没内容则不可用。如下：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("交互状态的的案例")
 8         self.resize(400,400)
 9         self.set_ui()
10 
11 
12     def set_ui(self):
13         #添加三个子控件
14         label = QLabel(self)
15         label.setText("标签")
16         label.move(50,50)
17         label.hide()  #异常标签
18 
19         lineEdit = QLineEdit(self)
20         # lineEdit.setText("文本框")
21         lineEdit.move(50,100)
22 
23         btn  = QPushButton(self)
24         btn.setText("登录")
25         btn.move(50,150)
26         btn.setEnabled(False)  #设置它不可用
27 
28         def textChanged_slot(arg):
29             print("文本框内容改变了",arg)
30             if len(arg):
31                 btn.setEnabled(True)
32             else:
33                 btn.setEnabled(False)
34                 
35         lineEdit.textChanged.connect(textChanged_slot)
36                 #而且此时，会给我们传递出一个参数,这个参数
37                     # 就是每次改变之后文本框内剩余的内容，我们可以用槽函数来接收
38 if __name__ == '__main__':
39     app =QApplication(sys.argv)
40 
41     window = Window()
42 
43     window.show()
44     sys.exit(app.exec_())

View Code

这里的判断可以被优化：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("交互状态的的案例")
 8         self.resize(400,400)
 9         self.set_ui()
10 
11 
12     def set_ui(self):
13         #添加三个子控件
14         label = QLabel(self)
15         label.setText("标签")
16         label.move(50,50)
17         label.hide()  #异常标签
18 
19         lineEdit = QLineEdit(self)
20         # lineEdit.setText("文本框")
21         lineEdit.move(50,100)
22 
23         btn  = QPushButton(self)
24         btn.setText("登录")
25         btn.move(50,150)
26         btn.setEnabled(False)  #设置它不可用
27 
28         def textChanged_slot(arg):
29             print("文本框内容改变了",arg)
30             # if len(arg):
31             #     btn.setEnabled(True)
32             # else:
33             #     btn.setEnabled(False)
34             btn.setEnabled(len(arg))
35 
36         lineEdit.textChanged.connect(textChanged_slot)
37                 #而且此时，会给我们传递出一个参数,这个参数
38                     # 就是每次改变之后文本框内剩余的内容，我们可以用槽函数来接收
39 if __name__ == '__main__':
40     app =QApplication(sys.argv)
41 
42     window = Window()
43 
44     window.show()
45     sys.exit(app.exec_())

稍微优化

继续：

当输入的内容为Zcb 的时候，已经隐藏的标签显示登录成功。

这分两步：

1，获取文本框的内容。

2，判定是否是Zcb

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def __init__(self):
 6         super().__init__()
 7         self.setWindowTitle("交互状态的的案例")
 8         self.resize(400,400)
 9         self.set_ui()
10 
11 
12     def set_ui(self):
13         #添加三个子控件
14         label = QLabel(self)
15         label.setText("标签")
16         label.move(50,50)
17         label.hide()  #隐藏标签
18 
19 
20         lineEdit = QLineEdit(self)
21         # lineEdit.setText("文本框")
22         lineEdit.move(50,100)
23 
24         btn  = QPushButton(self)
25         btn.setText("登录")
26         btn.move(50,150)
27         btn.setEnabled(False)  #设置它不可用
28 
29         def textChanged_slot(arg):
30             print("文本框内容改变了",arg)
31             # if len(arg):
32             #     btn.setEnabled(True)
33             # else:
34             #     btn.setEnabled(False)
35             btn.setEnabled(len(arg))
36 
37         lineEdit.textChanged.connect(textChanged_slot)
38 
39         def check_slot():
40             #1,获取文本框的内容
41             content = lineEdit.text()
42             #2,判断
43             label.show()
44             if content == "Zcb":
45                 label.setText("登录成功！")
46             else:
47                 label.setText("登录失败！")
48 
49             label.adjustSize()  # 注：它一定要放在设置文本的后面。
50             
51         btn.pressed.connect(check_slot)  #用信号clicked 也可以
52 
53 if __name__ == '__main__':
54     app =QApplication(sys.argv)
55 
56     window = Window()
57 
58     window.show()
59     sys.exit(app.exec_())

最终版

(十一)：QWidget控件之信息提示：

API之状态提示：

它一般是在窗口的下方的一个横条。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("信息提示")
14 window.resize(500,500)
15 
16 #当鼠标停留在窗口控件之后，在状态栏展示提示信息，但是前提是要有状态栏
17 window.setStatusTip("这时窗口")
18 
19 
20 
21 #展示控件
22 window.show()
23 
24 #3,进入消息循环
25 sys.exit(app.exec_())

此时没有提示文本，因为没有状态栏

我们这里换个控件类别，换成个组合控件。换QWidget 为 QMainWindow .

所有组合控件，就是有很多常用的部分，例如，菜单栏，编辑区域，有状态栏。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 
 9 window = QMainWindow()  #组合控件  
10 
11 
12 #设置控件
13 window.setWindowTitle("信息提示")
14 window.resize(500,500)
15 
16 #当鼠标停留在窗口控件之后，在状态栏展示提示信息，但是前提是要有状态栏
17 window.setStatusTip("这是窗口")
18 
19 
20 
21 #展示控件
22 window.show()
23 
24 #3,进入消息循环
25 sys.exit(app.exec_())

这时并没有任何现象，因为QMainWindow 是采用懒加载的方式

所谓的懒加载指的是，当用的时候才会加载上去。

这时就可以看到当鼠标放上去的时候的提示信息了。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 
 9 window = QMainWindow()  #组合控件
10 window.statusBar()
11 
12 #设置控件
13 window.setWindowTitle("信息提示")
14 window.resize(500,500)
15 
16 #当鼠标停留在窗口控件之后，在状态栏展示提示信息，但是前提是要有状态栏
17 window.setStatusTip("这是窗口")
18 
19 
20 #展示控件
21 window.show()
22 
23 #3,进入消息循环
24 sys.exit(app.exec_())

View Code

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 
 9 window = QMainWindow()  #组合控件
10 window.statusBar()
11 
12 #设置控件
13 window.setWindowTitle("信息提示")
14 window.resize(500,500)
15 
16 #当鼠标停留在窗口控件之后，在状态栏展示提示信息，但是前提是要有状态栏
17 window.setStatusTip("这是窗口")
18 
19 print(window.statusTip()) #获取提示信息
20 
21 #展示控件
22 window.show()
23 
24 #3,进入消息循环
25 sys.exit(app.exec_())

获取提示信息

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 
 9 window = QMainWindow()  #组合控件
10 window.statusBar()
11 
12 #设置控件
13 window.setWindowTitle("信息提示")
14 window.resize(500,500)
15 
16 #当鼠标停留在窗口控件之后，在状态栏展示提示信息，但是前提是要有状态栏
17 window.setStatusTip("这是窗口")
18 
19 label = QLabel(window)
20 label.setText("hello world")
21 label.setStatusTip("这是标签")
22 
23 
24 #展示控件
25 window.show()
26 
27 #3,进入消息循环
28 sys.exit(app.exec_())

给标签添加状态提示

API之工具提示：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 
 9 window = QMainWindow()  #组合控件
10 window.statusBar()
11 
12 #设置控件
13 window.setWindowTitle("信息提示")
14 window.resize(500,500)
15 
16 
17 label = QLabel(window)
18 label.setText("hello world")
19 label.setToolTip("这是个标签")  #将鼠标停在上面的时候，在旁边会有提示
20 print(label.toolTip())   #获取工具提示
21  
22 #展示控件
23 window.show()
24 
25 #3,进入消息循环
26 sys.exit(app.exec_())

工具提示

注意：工具提示的展示时间是有限的，具体时长我们可以控制。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 
 9 window = QMainWindow()  #组合控件
10 window.statusBar()
11 
12 #设置控件
13 window.setWindowTitle("信息提示")
14 window.resize(500,500)
15 
16 
17 label = QLabel(window)
18 label.setText("hello world")
19 label.setToolTip("这是个标签")  #将鼠标停在上面的时候，在旁边会有提示
20 print(label.toolTip())   #获取工具提示
21 
22 label.setToolTipDuration(2000)  # 显示2s
23 
24 
25 #展示控件
26 window.show()
27 
28 #3,进入消息循环
29 sys.exit(app.exec_())

控制显示时长

API之这是啥提示：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 
 9 window = QMainWindow()  #组合控件
10 window.statusBar()
11 window.setWindowFlags(Qt.WindowContextHelpButtonHint)  #换个带问号的窗口样式
12 
13 
14 #设置控件
15 window.setWindowTitle("信息提示")
16 window.resize(500,500)
17 
18 
19 label = QLabel(window)
20 label.setText("hello world")
21 
22 label.setToolTipDuration(2000)  # 显示2s
23 label.setWhatsThis("这是啥，这是帮助信息")  #它的使用方法是：先点？ ，然后再带这个标签
24 print(label.whatsThis())
25 
26 #展示控件
27 window.show()
28 
29 #3,进入消息循环
30 sys.exit(app.exec_())

点？号，之后再点控件

(十二)：QWidget控件之焦点控制：

单个控件的角度：

API 之 setFocus():

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("焦点控制")
14 window.resize(500,500)
15 
16 lineEdit1 = QLineEdit(window)
17 lineEdit1.move(50,50)
18 
19 lineEdit2 = QLineEdit(window)
20 lineEdit2.move(100,100)
21 lineEdit2.setFocus()  #先让第二个获取焦点
22 
23 
24 lineEdit3 = QLineEdit(window)
25 lineEdit3.move(150,150)
26 
27 #展示控件
28 window.show()
29 
30 #3,进入消息循环
31 sys.exit(app.exec_())

用setFocus() 获取焦点。

API 之 setFocusPolicy(Policy) :

设置策略，（获取焦点的策略）

API之clearFocus() :

清除焦点，此时tab 和点击都不行了，只能通过setFocus()代码来实现。

父控件的角度：

如何获取当前窗口中，所有子控件中获取焦点的那个控件：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 #1,创建app
 4 app  = QApplication(sys.argv)
 5 
 6 
 7 #2，控件的操作：
 8 #创建控件
 9 window = QWidget()
10 
11 
12 #设置控件
13 window.setWindowTitle("焦点控制")
14 window.resize(500,500)
15 
16 lineEdit1 = QLineEdit(window)
17 lineEdit1.move(50,50)
18 
19 lineEdit2 = QLineEdit(window)
20 lineEdit2.move(100,100)
21 
22 lineEdit3 = QLineEdit(window)
23 lineEdit3.move(150,150)
24 
25 # print(window.focusWidget())  # 获取当前窗口的获取焦点的子控件，此时不行 为None 
26 
27 
28 #展示控件
29 window.show()
30 
31 print(window.focusWidget())  # 获取当前窗口的获取焦点的子控件，此时也不行  None 
32 
33 #这说明因为获取焦点是后面的事情，
34 
35 #3,进入消息循环
36 sys.exit(app.exec_())

View Code

这时是不行的，它说明焦点是后面获取的。

下面验证上述观点：

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def mousePressEvent(self, event):
 6         print(self.focusWidget())  #点击时获取它的子控件中获取焦点的那个
 7 
 8 #1,创建app
 9 app  = QApplication(sys.argv)
10 
11 
12 #2，控件的操作：
13 #创建控件
14 window = Window()
15 
16 
17 #设置控件
18 window.setWindowTitle("焦点控制")
19 window.resize(500,500)
20 
21 lineEdit1 = QLineEdit(window)
22 lineEdit1.move(50,50)
23 
24 lineEdit2 = QLineEdit(window)
25 lineEdit2.move(100,100)
26 
27 lineEdit3 = QLineEdit(window)
28 lineEdit3.move(150,150)
29 
30 
31 #展示控件
32 window.show()
33 
34 
35 
36 #3,进入消息循环
37 sys.exit(app.exec_())

这时就不打印出None 了

同时它也说明，焦点是在show() 的后面加上去的。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def mousePressEvent(self, event):
 6         # self.focusNextChild()  #在子控件中切换焦点
 7         # self.focusPreviousChild()  #反序
 8         self.focusNextPrevChild(True)  #True 是前面的Next false 是后面的Prev
 9 
10 #1,创建app
11 app  = QApplication(sys.argv)
12 
13 
14 #2，控件的操作：
15 #创建控件
16 window = Window()
17 
18 
19 #设置控件
20 window.setWindowTitle("焦点控制")
21 window.resize(500,500)
22 
23 lineEdit1 = QLineEdit(window)
24 lineEdit1.move(50,50)
25 
26 lineEdit2 = QLineEdit(window)
27 lineEdit2.move(100,100)
28 
29 lineEdit3 = QLineEdit(window)
30 lineEdit3.move(150,150)
31 
32 
33 #展示控件
34 window.show()
35 
36 
37 
38 #3,进入消息循环
39 sys.exit(app.exec_())

在子控件中切换焦点

它是个静态方法，用类对象去调用。

 1 from PyQt5.Qt import * #刚开始学习可以这样一下导入
 2 import sys
 3 
 4 class Window(QWidget):
 5     def mousePressEvent(self, event):
 6         # self.focusNextChild()  #在子控件中切换焦点
 7         # self.focusPreviousChild()  #反序
 8         self.focusNextPrevChild(True)  #True 是前面的Next false 是后面的Prev
 9 
10 #1,创建app
11 app  = QApplication(sys.argv)
12 
13 
14 #2，控件的操作：
15 #创建控件
16 window = Window()
17 
18 
19 #设置控件
20 window.setWindowTitle("焦点控制")
21 window.resize(500,500)
22 
23 lineEdit1 = QLineEdit(window)
24 lineEdit1.move(50,50)
25 
26 lineEdit2 = QLineEdit(window)
27 lineEdit2.move(100,100)
28 
29 lineEdit3 = QLineEdit(window)
30 lineEdit3.move(150,150)
31 
32 
33 Window.setTabOrder(lineEdit1,lineEdit3)
34 Window.setTabOrder(lineEdit3,lineEdit2)
35 #tab 切换  1  3  2 
36 
37 
38 #展示控件
39 window.show()
40 
41 
42 
43 #3,进入消息循环
44 sys.exit(app.exec_())

Tab 切换顺序是1 3 2

(十二)：QWidget控件之其他：

后面说。

四：QWidget 信号：

总结：

QWidget结束，见下一个QAbstractButton：https://www.cnblogs.com/zach0812/p/11360978.html

posted @ 2019-08-15 22:19 Zcb0812 阅读(5666) 评论(2) 编辑收藏举报

刷新页面返回顶部

PyQt5 控件学习（一个一个学习之QWidget）

一：QWidget 继承的类：

(一)：可以直接点入到内置文件中查看

(二)：通过保留属性__base__

二：QWidget (所有可视控件的基类)：

三：QWiget的功能作用：

(一)：QWidget 控件之控件的创建：

(二)：QWidget控件之大小位置：

(三)：QWidget控件之最大和最小尺寸：

(四)：QWidget控件之内容边距：

(五)：QWidget控件之事件消息：

补充：事件的转发（传递）：

(六)：QWidget控件之鼠标相关：

(七)：QWidget控件之父子关系：

(八)：QWidget控件之层级控制：

(九)：QWidget控件之顶层窗口相关：

(十)：QWidget控件之交互状态：

(十一)：QWidget控件之信息提示：

(十二)：QWidget控件之焦点控制：

(十二)：QWidget控件之其他：

四：QWidget 信号：

总结：

公告

(二)：通过保留属性base