本文详细介绍了QT中的常见控件，包括QLabel、QLineEdit、QTextEdit以及各种按键组件如QPushButton、QToolButton、QRadioButton和QCheckBox。讲解了它们的特性和常用方法，如设置文本、输入限制、信号与槽的使用，还涉及了对话框和布局管理。
2主窗口类型
有三种窗口
QMainWindow
QWiget
QDialog
QMainWindow:可以包含菜单栏，工具栏和标题栏，是
最常见的窗口显示形式。
QDialog：是对话窗口的基类。没有菜单栏，工具栏，状态栏
QWiget：不确定窗口的用途，就用QWidget。
## QT中常用的控价
### 1、Qlabel控件
setAlignment() 设置文本的对齐方式
setIndent() 设置文本的缩进
text() 获取文本
setBuddy() 设置伙伴关系
setText() 设置文本内容
selectedText() 返回所选择的字符
setWordWrap() 设置是否运行换行
#### QLabel常用的信号
1.当鼠标划过Qlabel控件时触发：linkHovered
2.当鼠标单击Qlabel控件时触发：linkActivated
| 方法 | 解释 |
| ------------- | ------------------------------- |
| clear() | 清空剪贴板内容 |
| mimeData() | 获取剪贴板上的MIME类型数据 |
| setMimeData() | 将MIME类型数据放到剪贴板中 |
| pixmap() | 获取剪贴板上的QPixmap类型的数据 |
| setPixmap() | 将QPixmap类型数据放到剪贴板中 |
| image() | 获取剪贴板上QImage类型的数据 |
| setImage() | 将QImage类型数据放到剪贴板中 |
| text() | 获取剪贴板上的文本 |
| setText() | 将文本放到剪贴板中 |
#### QLabel与伙伴控件
### 2、Edit控件
#### QLineEdit
基本功能：输入单行的文本
##### EchoMode(回显模式)
4种回显模式
1、Normal
2、NoEcho
3、Password
4、PasswordEchoOnEdit
##### 方法：
+ setPlaceholderText():在line没有输入的时候给出提示信息
##### QLineEdit控件的输入(校验器)
如限制只能输入整数，浮点数或者满足一定条件的字符串
##### 用掩码限制QLineEdit控件的输入
```pyth
用掩码限制QLineEdit控件的输入
A ASCII字母字符是必须输入的(A-Z、a-z)
a ASCII字母字符是允许输入的,但不是必需的(A-Z、a-z)
N ASCII字母字符是必须输入的(A-Z、a-z、0-9)
n ASII字母字符是允许输入的,但不是必需的(A-Z、a-z、0-9)
X 任何字符都是必须输入的
x 任何字符都是允许输入的,但不是必需的
9 ASCII数字字符是必须输入的(0-9)
0 ASCII数字字符是允许输入的,但不是必需的(0-9)
D ASCII数字字符是必须输入的(1-9)
d ASCII数字字符是允许输入的,但不是必需的(1-9)
# ASCI数字字符或加减符号是允许输入的,但不是必需的
H 十六进制格式字符是必须输入的(A-F、a-f、0-9)
h 十六进制格式字符是允许输入的,但不是必需的(A-F、a-f、0-9)
B 二进制格式字符是必须输入的(0,1)
b 二进制格式字符是允许输入的,但不是必需的(0,1)
> 所有的字母字符都大写
< 所有的字母字符都小写
! 关闭大小写转换
\ 使用"\"转义上面列出的字符
```
##### QLineEdit综合案例
#### QTextEdit控件
QLineEdit控件只支持单行输入，QTextEdit支持多行输入
##### 常用的方法：
1.setPlainText() #设置文本
2.setHtml() #设置html格式
3.toPlainText() #获取文本
4.toHtml
5.setFont() 设置文本框显示的字体，参数是Font类型
```python
#设置字体的多选框和设置字体的Line的
import sys
from PyQt5.QtWidgets import QApplication, QWidget, QComboBox, QFontComboBox, QLineEdit, QMessageBox, QVBoxLayout
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.combobox_2 = QFontComboBox(self) # 2
self.lineedit = QLineEdit(self) # 3
self.v_layout = QVBoxLayout()
self.layout_init()
self.combobox_init()
def layout_init(self):
self.v_layout.addWidget(self.combobox_2)
self.v_layout.addWidget(self.lineedit)
self.setLayout(self.v_layout)
def combobox_init(self):
self.combobox_2.currentFontChanged.connect(lambda: self.on_combobox_func(self.combobox_2))
def on_combobox_func(self, combobox): # 8
self.lineedit.setFont(combobox.currentFont())
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
##### 事件：
+ textChanged 当文本框的文本内容发生变化时自动触发信号
#### QTextBrowser控件
QTextEdit和QTextBrowser控件类似，但是一般QTextEdit是用来编辑文本的，而QTextBroser是用来显示文本的
### 4、按键控件
1.QPushButton
事件:
+ toggled 标记
配合isChecked()函数使用，如果按键是已经标记则打印True，否则打印False。
+ clicked 点击
+ pressed 按下
+ released 松开
方法：
+ setCheckable(True) 设置一个按键为一个可以标记的按键，该按键就会有两种状态，标记和非标记的状态
+ setIcon() 为按键设置一个图片，传入的参数是QIcon的格式
+ isChecked() 查看按键的状态，如果是标记状态则是True，否标记状态False
```python
import sys
from PyQt5.QtGui import QIcon
from PyQt5.QtWidgets import QApplication, QWidget, QPushButton
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.test_button = QPushButton('Test', self)
self.test_button.setCheckable(True) #设置按键为一个可标记的按键
self.test_button.setIcon(QIcon('images/save_as.ico')) #为按键设置图片
self.test_button.toggled.connect(self.button_state_func) #为按键绑定事件
def button_state_func(self):
print(self.test_button.isChecked()) # 4
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
2.QToolButton
注意：QToolButton实例化的时候不能直接传入文本字符串，因为该控件没有相应的初始化函数，也就是说这样是错误的：self.test_button = QToolButton("test",self),如果要设置文本的话，的通过setText()的方法。但是如果同时使用setText()和setIcon()方法的话，只会显示图标。
```python
import sys
from PyQt5.QtGui import QIcon
from PyQt5.QtWidgets import QApplication, QWidget, QToolButton
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.test_button = QToolButton(self) # 1
self.test_button.setCheckable(True)
self.test_button.setIcon(QIcon('images/save_as.ico'))
self.test_button.toggled.connect(self.button_state_func)
self.test_button.isCheckable()
def button_state_func(self):
print(self.test_button.isChecked())
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
3.QRadioButton
一个布局中只能又一个单选框被选中
方法toggled相当于选中和取消选中。现在QPushButton的toggle的方法类似，按下不会弹起
+ setChecked(True) 单选框设置为选中。
+ setChecke() 获取是否选中的状态
+ setCheckState() 传入参数Qt.Checked为选中状态，Qt.Unchecked为无选中的状态，Qt.PartiallyChecked为半选中的状态。
+ text() 获取文本
+ stateChanged 在复选框的状态发生改变的时候触发
```python
import sys
from PyQt5.QtGui import QPixmap
from PyQt5.QtWidgets import QApplication, QWidget, QRadioButton, QLabel, QHBoxLayout, QVBoxLayout
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.off_button = QRadioButton('off', self) # 1
self.on_button = QRadioButton('on', self) # 2
self.pic_label = QLabel(self) # 3
self.button_h_layout = QHBoxLayout()
self.pic_h_layout = QHBoxLayout()
self.all_v_layout = QVBoxLayout()
self.layout_init()
self.radiobutton_init()
self.label_init()
def layout_init(self):
self.pic_h_layout.addStretch(1) #在未加入标签之前先加入一个占位符
self.pic_h_layout.addWidget(self.pic_label)
self.pic_h_layout.addStretch(1) #在加入标签之后加入一个占位符，作用是拉伸窗口的时候，label会自动适用窗口的大小
self.button_h_layout.addWidget(self.off_button)
self.button_h_layout.addWidget(self.on_button)
self.all_v_layout.addLayout(self.pic_h_layout)
self.all_v_layout.addLayout(self.button_h_layout)
self.setLayout(self.all_v_layout)
def radiobutton_init(self):
self.off_button.setChecked(True) #设置为选中的状态
self.off_button.toggled.connect(self.on_off_bulb_func) # 6
# self.on_button.toggled.connect(self.on_off_bulb_func)
def label_init(self):
self.pic_label.setPixmap(QPixmap('images/off.png')) # 7
def on_off_bulb_func(self): # 8
if self.off_button.isChecked():
self.pic_label.setPixmap(QPixmap('images/off.png'))
else:
self.pic_label.setPixmap(QPixmap('images/on.png'))
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
4.QCheckBox
三种状态：
1、没选中0
2、半选中1
3、选中2
复选框一共有三种状态：全选中、半选中和无选中。若一个父选项的子选项全部为选中状态，则该父选项为全选中；若子选项全部为无选中状态，则该父选项为无选中状态；若子选项既有全选中和无选中状态，则该父选项为半选中状态。
事件：
stateChanged 是状态变化时触发信号
方法：
checkState() 查看选中的状态：0、1、2
setchecked(True) 设置选择状态，只有选中和未选中
setcheckState() 设置选择的状态，Qt.Checked为选中的状态，Qt.Unchecked未选中状态和
Qt.PartiallyChecked为半选中的状态。
```py
import sys
from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import QApplication, QWidget, QCheckBox, QVBoxLayout
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.checkbox1 = QCheckBox('Checkbox 1', self)
self.checkbox2 = QCheckBox('Checkbox 2', self)
self.checkbox3 = QCheckBox('Checkbox 3', self)
self.v_layout = QVBoxLayout()
self.checkbox_init()
self.layout_init()
def layout_init(self):
self.v_layout.addWidget(self.checkbox1)
self.v_layout.addWidget(self.checkbox2)
self.v_layout.addWidget(self.checkbox3)
self.setLayout(self.v_layout)
def checkbox_init(self):
# self.checkbox1.setChecked(True) # 1
self.checkbox1.setCheckState(Qt.Checked) # 2
self.checkbox1.stateChanged.connect(lambda: self.on_state_change_func(self.checkbox1)) # 3
# self.checkbox2.setChecked(False)
self.checkbox2.setCheckState(Qt.Unchecked)
self.checkbox2.stateChanged.connect(lambda: self.on_state_change_func(self.checkbox2))
# self.checkbox3.setTristate(True) # 4
self.checkbox3.setCheckState(Qt.PartiallyChecked) # 5
self.checkbox3.stateChanged.connect(lambda: self.on_state_change_func(self.checkbox3))
def on_state_change_func(self, checkbox): # 6
print('{} was clicked, and its current state is {}'.format(checkbox.text(), checkbox.checkState()))
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
父类都是QAbstractButton
### 5、下拉列表控件QComboBox
```python
from PyQt5.QtWidgets import QCombobox
choice = "a"
choice_list = ["a","b","c"]
self.combobox_1 = QCombobox(self)
self.combobox_1.addItem(choice) #选择下拉框中的一项
self.combobox_1.addItems(choice_list) #选择下拉框的下拉列表
```
+ currentIndexChanged 当下拉框的选项发生变化时，会触发这个方法。
+ currentTextChanged 当下拉框的文本发生变化时，会触发这个方法。
+ currentIndex() 获取下拉框当前的序号
+ currentText() 获取当前的文本值
```python
import sys
from PyQt5.QtWidgets import QApplication, QWidget, QComboBox, QFontComboBox, QLineEdit, QMessageBox, QVBoxLayout
class Demo(QWidget):
choice = 'a'
choice_list = ['b', 'c', 'd', 'e']
def __init__(self):
super(Demo, self).__init__()
self.combobox_1 = QComboBox(self) # 1
self.combobox_2 = QFontComboBox(self) # 2
self.lineedit = QLineEdit(self) # 3
self.v_layout = QVBoxLayout()
self.layout_init()
self.combobox_init()
def layout_init(self):
self.v_layout.addWidget(self.combobox_1)
self.v_layout.addWidget(self.combobox_2)
self.v_layout.addWidget(self.lineedit)
self.setLayout(self.v_layout)
def combobox_init(self):
self.combobox_1.addItem(self.choice) # 4
self.combobox_1.addItems(self.choice_list) # 5
self.combobox_1.currentIndexChanged.connect(lambda: self.on_combobox_func(self.combobox_1)) # 6
# self.combobox_1.currentTextChanged.connect(lambda: self.on_combobox_func(self.combobox_1)) # 7
self.combobox_2.currentFontChanged.connect(lambda: self.on_combobox_func(self.combobox_2))
# self.combobox_2.currentFontChanged.connect(lambda: self.on_combobox_func(self.combobox_2))
def on_combobox_func(self, combobox): # 8
if combobox == self.combobox_1:
QMessageBox.information(self, 'ComboBox 1',
'{}: {}'.format(combobox.currentIndex(), combobox.currentText()))
else:
self.lineedit.setFont(combobox.currentFont())
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
### 6、滑块控件
#### QSlider
```python
#水平滑条
from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import QSlider
self.slider_1 = QSlider(Qt.Horizontal,self)
self.slider_1.setRanger(0,100)
#垂直滑块
self.slider_2 = QSlider(Qt.Vertical,self)
self.slider_2.setMinmum(0)
self.slider_2.setMaxmum(100)
```
valueChanged 滑块的值发生变化的时候触发此方法
```python
import sys
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QFont
from PyQt5.QtWidgets import QApplication, QWidget, QSlider, QLabel, QVBoxLayout, QHBoxLayout
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.slider_1 = QSlider(Qt.Horizontal) # 水平滑块
self.slider_1.setRange(0, 100) #设置滑块滑动的范围
self.slider_1.valueChanged.connect(lambda: self.on_change_func(self.slider_1)) # 3
self.slider_2 = QSlider(Qt.Vertical) #竖直的滑块
self.slider_2.setMinimum(0) # 4
self.slider_2.setMaximum(100) # 5
self.slider_2.valueChanged.connect(lambda: self.on_change_func(self.slider_2))
self.label = QLabel('0', self) # 6
self.label.setFont(QFont('Arial Black', 20))
self.h_layout = QHBoxLayout()
self.v_layout = QVBoxLayout()
self.h_layout.addWidget(self.slider_2)
self.h_layout.addStretch(1)
self.h_layout.addWidget(self.label)
self.h_layout.addStretch(1)
self.v_layout.addWidget(self.slider_1)
self.v_layout.addLayout(self.h_layout)
self.setLayout(self.v_layout)
def on_change_func(self, slider): # 7
if slider == self.slider_1:
self.slider_2.setValue(self.slider_1.value())
self.label.setText(str(self.slider_1.value()))
else:
self.slider_1.setValue(self.slider_2.value())
self.label.setText(str(self.slider_2.value()))
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
#### QDial
```python
#球形滑块
from PyQt5.QtWidgets import QDial
self.dial = QDial(self)
self.dial.setFixedSize(100,100) #设置QDail的大小
self.dial.setRange(0,100) #滑动的范围
self.dial.setNotchesVisible(True) #显示刻度，根据我们设置的数值自动调整
```
+ valueChanged 当改变Qdial的值时自动触发这个信号
```python
import sys
from PyQt5.QtGui import QFont
from PyQt5.QtWidgets import QApplication, QWidget, QDial, QLabel, QHBoxLayout
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.setWindowTitle('QDial') # 1
self.dial = QDial(self)
self.dial.setFixedSize(100, 100) # 2
self.dial.setRange(0, 100) # 3
self.dial.setNotchesVisible(True) # 4
self.dial.valueChanged.connect(self.on_change_func) # 5
self.label = QLabel('0', self)
self.label.setFont(QFont('Arial Black', 20))
self.h_layout = QHBoxLayout()
self.h_layout.addWidget(self.dial)
self.h_layout.addWidget(self.label)
self.setLayout(self.h_layout)
def on_change_func(self):
self.label.setText(str(self.dial.value()))
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
### 7、计数器控件 QSpinBox
```python
from PyQt5.Qtwidgets import QSpinBox
self.spinbox = QSpinbox(self)
self.spinbox.setRange(-99,99)
self.spinbox.setSigleStep(1)
self.spinbox.setValue(66)
```
+ valueChanged 当里面的值发生变化时触发此信号
+ setValue() 设置计数器的值。
+ value() 获取计数器的值
QSpinBox为整型的数字计数器，而QDoubleSpinBox为浮点型的数字计数器
```python
import sys
from PyQt5.QtWidgets import QApplication, QWidget, QSpinBox, QDoubleSpinBox, QHBoxLayout
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.spinbox = QSpinBox(self)
self.spinbox.setRange(-99, 99) # 1
self.spinbox.setSingleStep(1) # 2
self.spinbox.setValue(66) # 3
self.spinbox.valueChanged.connect(self.value_change_func) # 4
self.double_spinbox = QDoubleSpinBox(self) # 5
self.double_spinbox.setRange(-99.99, 99.99)
self.double_spinbox.setSingleStep(0.01)
self.double_spinbox.setValue(66.66)
self.h_layout = QHBoxLayout()
self.h_layout.addWidget(self.spinbox)
self.h_layout.addWidget(self.double_spinbox)
self.setLayout(self.h_layout)
def value_change_func(self):
decimal_part = self.double_spinbox.value() - int(self.double_spinbox.value()) # 6
self.double_spinbox.setValue(self.spinbox.value() + decimal_part) # 7
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
### 8 定时器和进度条
QTimer
```python
self.timer = QTimer(self)
self.timer.start(100) #开始启动，没过100ms触发timeout信号
self.tiomer.stop() #停止
```
+ isActive() 为True时表示计时器已启动，False为计时器没有启动
+ timeout 超时信号器，当有超时信号来时自动触发
```python
import sys
from PyQt5.QtCore import QTimer, Qt
from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QLabel, QVBoxLayout
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.label = QLabel('0', self) # 1
self.label.setAlignment(Qt.AlignCenter)
self.step = 0 # 2
self.timer = QTimer(self) # 3
self.timer.timeout.connect(self.update_func) #到达计时时长之后自动触发
self.ss_button = QPushButton('Start', self) # 4
self.ss_button.clicked.connect(self.start_stop_func)
self.v_layout = QVBoxLayout()
self.v_layout.addWidget(self.label)
self.v_layout.addWidget(self.ss_button)
self.setLayout(self.v_layout)
def start_stop_func(self):
if not self.timer.isActive():
self.ss_button.setText('Stop')
self.timer.start(1000) #开始计时，并设置计时的时长，每次到达后，自动重新计时
else:
self.ss_button.setText('Start')
self.timer.stop()
def update_func(self):
self.step += 1
self.label.setText(str(self.step))
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
QProgressBar
```python
from PyQt5.QtWidgets importy QProcessBar
self.progressbar = QProgressBar(self)
self.progressbar.setMinimum(0)
self.progressbar.setMaximum(100)
```
+ setQrientation(Qt.Vertical) 设置进度条是垂直显示的，进度条默认是水平的
+ reset() 重置进度条
```python
import sys
from PyQt5.QtCore import Qt, QTimer
from PyQt5.QtWidgets import QApplication, QWidget, QProgressBar, QPushButton, QHBoxLayout, QVBoxLayout
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.progressbar = QProgressBar(self) # 1
# self.progressbar.setOrientation(Qt.Vertical)
self.progressbar.setMinimum(0) # 2
self.progressbar.setMaximum(100)
# self.progressbar.setRange(0, 100)
self.step = 0 # 3
self.timer = QTimer(self) # 4
self.timer.timeout.connect(self.update_func)
self.ss_button = QPushButton('Start', self) # 5
self.ss_button.clicked.connect(self.start_stop_func)
self.reset_button = QPushButton('Reset', self) # 6
self.reset_button.clicked.connect(self.reset_func)
self.h_layout = QHBoxLayout()
self.v_layout = QVBoxLayout()
self.h_layout.addWidget(self.ss_button)
self.h_layout.addWidget(self.reset_button)
self.v_layout.addWidget(self.progressbar)
self.v_layout.addLayout(self.h_layout)
self.setLayout(self.v_layout)
def start_stop_func(self):
if self.ss_button.text() == 'Start':
self.ss_button.setText('Stop')
self.timer.start(100)
else:
self.ss_button.setText('Start')
self.timer.stop()
def update_func(self):
self.step += 1
self.progressbar.setValue(self.step)
if self.step >= 100:
self.ss_button.setText('Start')
self.timer.stop()
self.step = 0
def reset_func(self):
self.progressbar.reset()
self.ss_button.setText('Start')
self.timer.stop()
self.step = 0
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
### 9 液晶数字显示屏QLCDNumber
```python
from PyQt5.QtWidgets import QLCDNumber
self.lcd_1 = QLCDNumber(self)
self.lcd_1.setDigitCount(10) #显示多少数字
self.lcd_1.display(1234567890)
```
+ setSegmentStyle()可以设置显示屏数字样式
| 常量 | 值 | 描述 |
| ------------------ | ---- | ---------------------------------------- |
| QLCDNumber.Outline | 0 | 让内容浮显，其颜色同显示屏背景颜色相同 |
| QLCDNumber.Filled | 1 | 让内容浮显，颜色同窗口标题颜色相同 |
| QLCDNumber.Flat | 2 | 让内容扁平化显示，颜色同窗口标题颜色相同 |
+ setSmallDecimalPoint(bool)方法key9i设置小数点的显示方式：为True小数点就在两个数字之间显示出来，而不会单独占一个位置，如果为False，那么就会单独占位(默认为False)
+ setMode()方法来更改数字显示方式
| 参数 | 值 | 描述 |
| -------------- | ---- | -------- |
| QLCDNumber.Hex | 0 | 十六进制 |
| QLCDNumber.Dec | 1 | 十进制 |
| QLCDNumber.Oct | 2 | 八进制 |
| QLCDNumber.Bin | 3 | 二进制 |
### 10 日期相关的控件
QCalendarWidget 日历控件
```python
from PyQt5.QtWidgets import QCalendarWidget
self.calendar = QCalendarWidget(self)
self.calendar.setMinimumDate(QDate(1956,2,14))
self.calendar.setMaximumDate(QDate(6666,6,6))
self.calendat.setGridVisible(True) #是否显示网格
self.calendat.setSelectedDate(QDate(2020,8,9))
self.calendar.setFirstDayOfWeek(Qt.Monday) #设置一周的第一天是星期几
```
+ setFirstDayOfWeek() 设置一个星期的第一天，默认是星期天
| Qt.Monday | 星期一 |
| ------------ | ------ |
| Qt.Tuesday | 星期二 |
| Qt.Wednesday | 星期三 |
| Qt.Thursday | 星期四 |
| Qt.Friday | 星期五 |
| Qt.Saturday | 星期六 |
| Qt.Sunday | 星期天 |
+ selectedDate().toString('ddd') 方法获取星期的缩写
#### QDateTimeEdit
```python
from PyQt5.QtWidgets import QDateTimeEdit,QDateEdit,QTimeEdit
from PyQt5.QtCore import QDate,QTime,QDateTime
self.datetime_1 = QDateTimeEdit(self) #初始时间2000年1月1号
self.datetime_2 = QDateTimeEdit(QDateTime.currentDateTime(),self) #系统的当前时间
self.datetime_2.setDisplayFormat("yyyy-MM-dd HH:mm:ss") #显示的格式 'yyyy/MM/dd'，'HH:mm:ss'
print(self.datetime_2.date()) #日期
print(self.datetime_2.time())#时间
print(self.datetime_2.dateTime()) #日期+时间
self.datetime_2.setCalendarPopup(True) #改变日期的时候调用日历
```
+ dateChanged 当时间改变的时候触发此信号
```python
import sys
from PyQt5.QtCore import QDate, QTime, QDateTime
from PyQt5.QtWidgets import QApplication, QWidget, QDateTimeEdit, QDateEdit, QTimeEdit, QVBoxLayout
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.datetime_1 = QDateTimeEdit(self) # 1
self.datetime_1.dateChanged.connect(lambda: print('Date Changed!'))
self.datetime_2 = QDateTimeEdit(QDateTime.currentDateTime(), self) # 2
self.datetime_2.setDisplayFormat('yyyy-MM-dd HH:mm:ss')
self.datetime_2.timeChanged.connect(lambda: print('Time Changed!'))
print(self.datetime_2.date())
print(self.datetime_2.time())
print(self.datetime_2.dateTime())
self.datetime_3 = QDateTimeEdit(QDateTime.currentDateTime(), self) # 3
self.datetime_3.dateTimeChanged.connect(lambda: print('DateTime Changed!'))
self.datetime_3.setCalendarPopup(True)
self.datetime_4 = QDateTimeEdit(QDate.currentDate(), self) # 4
self.datetime_5 = QDateTimeEdit(QTime.currentTime(), self)
self.date = QDateEdit(QDate.currentDate(), self) # 5
self.date.setDisplayFormat('yyyy/MM/dd')
print(self.date.date())
self.time = QTimeEdit(QTime.currentTime(), self) # 6
self.time.setDisplayFormat('HH:mm:ss')
print(self.time.time())
self.v_layout = QVBoxLayout()
self.v_layout.addWidget(self.datetime_1)
self.v_layout.addWidget(self.datetime_2)
self.v_layout.addWidget(self.datetime_3)
self.v_layout.addWidget(self.datetime_4)
self.v_layout.addWidget(self.datetime_5)
self.v_layout.addWidget(self.date)
self.v_layout.addWidget(self.time)
self.setLayout(self.v_layout)
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
### 11、各种对话框
QDialog是所有对话框的基类
下面四种为常见的对话框
QMessageBox 消息对话框
QColorDialog 颜色对话框
QFontDialog 字体对话框
QInPutDialog 输入对话框
QFileDialog 文件对话框
#### 消息对话框QmessageBox
总共分为以下几种
1、关于对话框
```python
QMessageBox.about(self, 'Title', "content")
```
2、错误对话框
```python
QMessageBox.critical(self, 'Title', "content")
```
3、警告对话框
```python
QMessageBox.warning(self, 'Title', "content")
```
4、提问对话
```python
QMessageBox.question(self, 'Title', 'Content')
```
5、消息对话框
```python
from PyQt5.QtWidgets import QMessageBox
QMessageBox.information(self, 'Title', "content", QMessageBox.Yes | QMessageBox.No
| QMessageBox.Cancel)
```
```python
import sys
from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QMessageBox
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.button = QPushButton('information', self)
self.button.clicked.connect(self.show_messagebox)
def show_messagebox(self):
#第一个参数填self表示这个消息对话框是属于Demo窗口的
QMessageBox.information(self, 'Title', 'Content',
QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel)
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
常见的按钮类型有以下几种：
+ QMessageBox.OK
+ QMessageBox.Yes
+ QMessageBox.No
+ QMessageBox.Close
+ QMessageBox.Cancel
+ QMessageBox.Open
+ QMessageBox.Save
有2点差异
1、显示的对话框图标可能不同
2、显示的按钮是不一样的
```python
#与消息框进行交互
import sys
from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QMessageBox
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.button = QPushButton('Click Me!', self)
self.button.clicked.connect(self.show_messagebox)
def show_messagebox(self):
choice = QMessageBox.question(self, 'Change Text?', 'Would you like to change the button text?',
QMessageBox.Yes | QMessageBox.No)
#选择不同的按钮，有不同选择
if choice == QMessageBox.Yes:
self.button.setText('Changed!')
elif choice == QMessageBox.No:
pass
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
```python
#调用父类QDialog来使用消息框
import sys
from PyQt5.QtWidgets import QApplication, QWidget, QDialog, QLineEdit, QPushButton
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.resize(300, 100)
self.dialog = SigninPage()
self.btn = QPushButton("调用Dialog", self)
self.btn.clicked.connect(self.my_dialog)
def my_dialog(self):
self.dialog.exec_() #使用exec_()方法可以在主程序中加载一个dialog出来
class SigninPage(QDialog):
def __init__(self):
super(SigninPage, self).__init__()
self.resize(200, 100)
self.line = QLineEdit("我是一个新的dialog", self)
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
#### 颜色对话框和字体对话框
```python
import sys
from PyQt5.QtWidgets import QApplication, QWidget, QTextEdit, QColorDialog, QFontDialog, QPushButton,QHBoxLayout, QVBoxLayout
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.text_edit = QTextEdit(self)
self.color_btn = QPushButton('Color', self)
self.font_btn = QPushButton('Font', self)
self.color_btn.clicked.connect(lambda: self.open_dialog_func(self.color_btn))
self.font_btn.clicked.connect(lambda: self.open_dialog_func(self.font_btn))
self.h_layout = QHBoxLayout()
self.h_layout.addWidget(self.color_btn)
self.h_layout.addWidget(self.font_btn)
self.v_layout = QVBoxLayout()
self.v_layout.addWidget(self.text_edit)
self.v_layout.addLayout(self.h_layout)
self.setLayout(self.v_layout)
def open_dialog_func(self, btn):
if btn == self.color_btn:
color = QColorDialog.getColor() #获取颜色框
if color.isValid():
self.text_edit.setTextColor(color) #设置颜色
else:
font, ok = QFontDialog.getFont() #获取字体的框
if ok:
self.text_edit.setFont(font) #设置字体
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
#### 输入对话框
输入对话框一共有五种输入的方法：
| 方法 | 用法 |
| ------------------ | ---------------------- |
| getItem() | 从下拉框中获取选项输入 |
| getInt() | 获取整型值输入 |
| getDouble() | 获取浮点型值输入 |
| getText() | 获取字符输入 |
| getMultiLineText() | 获取多行字符串输入 |
```python
import sys
from PyQt5.QtWidgets import QApplication, QWidget, QInputDialog, QLineEdit, QTextEdit, QPushButton,QGridLayout
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.name_btn = QPushButton('Name', self)
self.gender_btn = QPushButton('Gender', self)
self.age_btn = QPushButton('Age', self)
self.score_btn = QPushButton('Score', self)
self.info_btn = QPushButton('Info', self)
self.name_btn.clicked.connect(lambda: self.open_dialog_func(self.name_btn))
self.gender_btn.clicked.connect(lambda: self.open_dialog_func(self.gender_btn))
self.age_btn.clicked.connect(lambda: self.open_dialog_func(self.age_btn))
self.score_btn.clicked.connect(lambda: self.open_dialog_func(self.score_btn))
self.info_btn.clicked.connect(lambda: self.open_dialog_func(self.info_btn))
self.name_line = QLineEdit(self)
self.gender_line = QLineEdit(self)
self.age_line = QLineEdit(self)
self.score_line = QLineEdit(self)
self.info_textedit = QTextEdit(self)
self.g_layout = QGridLayout()
self.g_layout.addWidget(self.name_btn, 0, 0, 1, 1)
self.g_layout.addWidget(self.name_line, 0, 1, 1, 1)
self.g_layout.addWidget(self.gender_btn, 1, 0, 1, 1)
self.g_layout.addWidget(self.gender_line,1, 1, 1, 1)
self.g_layout.addWidget(self.age_btn, 2, 0, 1, 1)
self.g_layout.addWidget(self.age_line, 2, 1, 1, 1)
self.g_layout.addWidget(self.score_btn, 3, 0, 1, 1)
self.g_layout.addWidget(self.score_line, 3, 1, 1, 1)
self.g_layout.addWidget(self.info_btn, 4, 0, 1, 1)
self.g_layout.addWidget(self.info_textedit, 4, 1, 1, 1)
self.setLayout(self.g_layout)
def open_dialog_func(self, btn):
if btn == self.name_btn: #QInputDialog为输入对话框
name, ok = QInputDialog.getText(self, 'Name Input', 'Please enter the name:')
if ok:
self.name_line.setText(name)
elif btn == self.gender_btn:
gender_list = ['Female', 'Male']
gender, ok = QInputDialog.getItem(self, 'Gender Input', 'Please choose the gender:', gender_list, 0, False)
if ok:
self.gender_line.setText(gender)
elif btn == self.age_btn:
age, ok = QInputDialog.getInt(self, 'Age Input', 'Please select the age:')
if ok:
self.age_line.setText(str(age))
elif btn == self.score_btn:
score, ok = QInputDialog.getDouble(self, 'Score Input', 'Please select the score:')
if ok:
self.score_line.setText(str(score))
else:
info, ok = QInputDialog.getMultiLineText(self, 'Info Input', 'Please enter the info:')
if ok:
self.info_textedit.setText(info)
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
#### 文件对话框
```python
import sys
from PyQt5.QtWidgets import QApplication, QWidget, QTextEdit, QPushButton, QMessageBox, QVBoxLayout,QHBoxLayout, QFileDialog
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.is_saved = True
self.is_saved_first = True
self.path = ''
self.textedit = QTextEdit(self)
self.textedit.textChanged.connect(self.on_textchanged_func) #文本内容改变时自动触发
self.button = QPushButton('Save', self)
self.button.clicked.connect(self.on_clicked_func)
self.button_2 = QPushButton('Open', self)
self.button_2.clicked.connect(self.open_file_func)
self.h_layout = QHBoxLayout()
self.h_layout.addWidget(self.button)
self.h_layout.addWidget(self.button_2)
self.v_layout = QVBoxLayout()
self.v_layout.addWidget(self.textedit)
self.v_layout.addLayout(self.h_layout)
self.setLayout(self.v_layout)
def on_textchanged_func(self):
if self.textedit.toPlainText():
self.is_saved = False
else:
self.is_saved = True
def on_clicked_func(self):
if self.is_saved_first:
self.save_as_func(self.textedit.toPlainText())
else:
self.save_func(self.textedit.toPlainText())
def save_func(self, text):
with open(self.path, 'w') as f:
f.write(text)
self.is_saved = True
def save_as_func(self, text):
#保存文件的对话框
self.path, _ = QFileDialog.getSaveFileName(self, 'Save File', './', 'Files (*.txt *.log)')
if self.path:
with open(self.path, 'w') as f:
f.write(text)
self.is_saved = True
self.is_saved_first = False
def open_file_func(self):
#打开文本对话框
file, _ = QFileDialog.getOpenFileName(self, 'Open File', './', 'Files (*.txt *.log)')
if file:
with open(file, 'r') as f:
self.textedit.clear()
self.textedit.setText(f.read())
self.is_saved = True
#关闭程序事件
def closeEvent(self, QCloseEvent):
if not self.is_saved:
choice = QMessageBox.question(self, '', 'Do you want to save the text?',
QMessageBox.Yes | QMessageBox.No | QMessageBox.Cancel)
if choice == QMessageBox.Yes:
self.on_clicked_func()
QCloseEvent.accept()
elif choice == QMessageBox.No:
QCloseEvent.accept()
else:
QCloseEvent.ignore()
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
### 12、绘图API：绘制文本 QPainter
drawText()
1.文本
2、各种图形(直线、点、椭圆、弧、扇形、多变形等)
3、图形
painter = QPainter()
painter.begin()
painter.drawText()
painter.end()
必须在pantEvent事件中绘制各种元素
#### 用像素绘制正弦曲线QPainter
drawPoint(x,y)
#### 绘制不同的直线QPainter
drawLine()
#### 绘制不同的图像
rect = QRect(0,10,100,100)
aln:1一个alen等于1/16度
drawArc(rect ,0, 45*16)
#### 绘制带铉的弧
drawpie(10,240,100,100,12,130*16)
椭圆
drawEllipse(120,120,150,100)
### 13 组合框QGroupBox和工具箱QToolBox
#### QGroupBox
容器，可以把相同功能的控件放在一起，使得界面更加清晰
```python
import sys
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QPixmap
from PyQt5.QtWidgets import QApplication, QWidget, QGroupBox, QRadioButton, QLabel, QHBoxLayout, QVBoxLayout
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.groupbox_1 = QGroupBox('On and Off', self) # 1
self.groupbox_2 = QGroupBox('Change Color', self)
self.red = QRadioButton('Red', self) # 2
self.blue = QRadioButton('Blue', self)
self.green = QRadioButton('Green', self)
self.yellow = QRadioButton('Yellow', self)
self.color_list = [self.red, self.blue, self.green, self.yellow]
self.on = QRadioButton('On', self) # 3
self.off = QRadioButton('Off', self)
self.pic_label = QLabel(self) # 4
self.h1_layout = QHBoxLayout()
self.h2_layout = QHBoxLayout()
self.h3_layout = QHBoxLayout()
self.all_v_layout = QVBoxLayout()
self.layout_init()
self.radiobutton_init()
self.label_init()
def layout_init(self):
self.h1_layout.addWidget(self.on)
self.h1_layout.addWidget(self.off)
self.groupbox_1.setLayout(self.h1_layout)
self.h2_layout.addWidget(self.red)
self.h2_layout.addWidget(self.blue)
self.h2_layout.addWidget(self.green)
self.h2_layout.addWidget(self.yellow)
self.groupbox_2.setLayout(self.h2_layout)
self.h3_layout.addWidget(self.groupbox_1)
self.h3_layout.addWidget(self.groupbox_2)
self.all_v_layout.addWidget(self.pic_label)
self.all_v_layout.addLayout(self.h3_layout)
self.setLayout(self.all_v_layout)
def radiobutton_init(self):
self.yellow.setChecked(True) # 5
for btn in self.color_list:
btn.clicked.connect(self.change_color_func)
self.off.setChecked(True) # 6
self.off.toggled.connect(self.on_and_off_func)
def label_init(self): # 7
self.pic_label.setPixmap(QPixmap('images/Off.png'))
self.pic_label.setAlignment(Qt.AlignCenter)
def change_color_func(self):
if self.on.isChecked():
path = 'images/{}_light.png'.format([btn.text() for btn in self.color_list if btn.isChecked()][0])
self.pic_label.setPixmap(QPixmap(path))
def on_and_off_func(self):
if self.on.isChecked():
path = 'images/{}_light.png'.format([btn.text() for btn in self.color_list if btn.isChecked()][0])
self.pic_label.setPixmap(QPixmap(path))
else:
self.pic_label.setPixmap(QPixmap('images/Off_light.png'))
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
QToolBox
工具箱，这个工具箱有很多的抽屉，每次只能打开一个，抽屉里面放了很多格式各样的东西
```python
import sys
from PyQt5.QtGui import QIcon
from PyQt5.QtWidgets import QApplication, QToolBox, QGroupBox, QToolButton, QVBoxLayout
class Demo(QToolBox): # 1
def __init__(self):
super(Demo, self).__init__()
self.groupbox_1 = QGroupBox(self) # 2
self.groupbox_2 = QGroupBox(self)
self.groupbox_3 = QGroupBox(self)
self.toolbtn_f1 = QToolButton(self) # 3
self.toolbtn_f2 = QToolButton(self)
self.toolbtn_f3 = QToolButton(self)
self.toolbtn_m1 = QToolButton(self)
self.toolbtn_m2 = QToolButton(self)
self.toolbtn_m3 = QToolButton(self)
self.v1_layout = QVBoxLayout()
self.v2_layout = QVBoxLayout()
self.v3_layout = QVBoxLayout()
self.addItem(self.groupbox_1, 'Couple One') # 一个Item相当于一个抽屉
self.addItem(self.groupbox_2, 'Couple Two')
self.addItem(self.groupbox_3, 'Couple Three')
self.currentChanged.connect(self.print_index_func) # 5
self.layout_init()
self.groupbox_init()
self.toolbtn_init()
def layout_init(self):
self.v1_layout.addWidget(self.toolbtn_f1)
self.v1_layout.addWidget(self.toolbtn_m1)
self.v2_layout.addWidget(self.toolbtn_f2)
self.v2_layout.addWidget(self.toolbtn_m2)
self.v3_layout.addWidget(self.toolbtn_f3)
self.v3_layout.addWidget(self.toolbtn_m3)
def groupbox_init(self): # 6
self.groupbox_1.setFlat(True)
self.groupbox_2.setFlat(True)
self.groupbox_3.setFlat(True)
self.groupbox_1.setLayout(self.v1_layout)
self.groupbox_2.setLayout(self.v2_layout)
self.groupbox_3.setLayout(self.v3_layout)
def toolbtn_init(self): # 7
self.toolbtn_f1.setIcon(QIcon('images/cartoon1.ico'))
self.toolbtn_f2.setIcon(QIcon('images/cartoon2.ico'))
self.toolbtn_f3.setIcon(QIcon('images/cartoon3.ico'))
self.toolbtn_m1.setIcon(QIcon('images/cartoon4.ico'))
self.toolbtn_m2.setIcon(QIcon('images/close.ico'))
self.toolbtn_m3.setIcon(QIcon('images/cut.ico'))
def print_index_func(self):
couple_dict = {
0: 'Couple One',
1: 'Couple Two',
2: 'Couple Three'
}
sentence = 'You are looking at {}.'.format(couple_dict.get(self.currentIndex()))
print(sentence)
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
### 14 窗口坐标
窗口分为三块：标题栏，边框，和客户区
+ x()——得到窗口左上角在显示屏屏幕上的x坐标；
+ y()——得到窗口左上角在显示屏屏幕上的y坐标；
+ pos()——得到窗口左上角在显示屏屏幕上的x和y坐标，类型为QPoint()；
+ geometry().x()——得到客户区左上角在显示屏屏幕上的x坐标；
+ geometry().y()——得到客户区左上角在显示屏屏幕上的y坐标；
+ geometry()——得到客户区左上角在显示屏屏幕上的x和y坐标，以及客户区的宽度和长度，类型为QRect()；
+ width()——得到客户区的宽度；
+ height()——得到客户区的长度；
+ geometry().width()——得到客户区的宽度；
+ geometry().height()——得到客户区的长度；
+ frameGeometry().width()——得到窗口的宽度；
+ frameGeometry().height()——得到窗口的长度；
```python
import sys
from PyQt5.QtWidgets import QApplication, QWidget
if __name__ == '__main__':
app = QApplication(sys.argv)
widget = QWidget()
widget.resize(200, 200) # 1
widget.move(100, 100) # 2
# widget.setGeometry(100, 100, 200, 200) # 3
widget.show()
print('-----------------x(), y(), pos()-----------------')
print(widget.x())
print(widget.y())
print(widget.pos())
print('-----------------width(), height()-----------------')
print(widget.width())
print(widget.height())
print('-----------------geometry().x(), geometry.y(), geometry()-----------------')
print(widget.geometry().x())
print(widget.geometry().y())
print(widget.geometry())
print('-----------------geometry.width(), geometry().height()-----------------')
print(widget.geometry().width())
print(widget.geometry().height())
print('-----------------frameGeometry().x(), frameGeometry().y(), frameGeometry(), '
'frameGeometry().width(), frameGeometry().height()-----------------')
print(widget.frameGeometry().x())
print(widget.frameGeometry().y())
print(widget.frameGeometry())
print(widget.frameGeometry().width())
print(widget.frameGeometry().height())
sys.exit(app.exec_())
```
### 15 事件处理
#### 窗口关闭事件
```python
def closeEvent(self, QCloseEvent) 是QWidget的窗口关闭函数，通过重写这个函数，可以定制化关闭的功能
QCloseEvent.accept() #接受窗口关闭的操作
QCloseEvent.ignore() #不接受窗口关闭的操作
```
#### 鼠标事件
```python
def mouseMoveEvent(self, QMouseEvent):
def mousePressEvent(self, QMouseEvent):
def mouseReleaseEvent(self, QMouseEvent):
def mouseDoubleClickEvent(self, QMouseEvent):
这四个函数都是QWidget的函数，作用分别是：鼠标移动触发、鼠标按下的时候触发、鼠标释放的时候触发
和鼠标双击的时候触发。通过重构这四个函数，可以对鼠标事件进行定制化的功能。
```
+ Qt.LeftButton 、Qt.MidButton、Qt.RightButton:分别表示点击的是左键、之间键、右键。
+ QMouseEvent.x()、QMouseEvent.y()表示获取鼠标离程序的坐标
+ QMouseEvent.globalX()、QMouseEvent.globalY()表示鼠标离桌面的坐标
+ self.setMouseTracking(True) 表示让窗口始终追踪鼠标。
#### 键盘事件
```python
def keyPressEvent(self,QkeyEvent)
def keyReleaseEvent(self,QkeyEvent)
这个两个函数式QWidget的函数，分别表示键盘任意键的按下和释放。
```
+ QkeyEvent 表示接受的按键的值
### 16 拖放与剪贴板
拖放和剪贴板的功能原理基础都是QMimeData类
| 判断函数 | 获取函数 | 设置函数 | MIME类型 |
| ---------- | ----------- | -------------- | ------------------- |
| hasText() | text() | setText() | text/plain |
| hasHtml() | html() | setHtml() | text/html |
| hasUrls() | urls() | setUrls() | text/uri-list |
| hasImage() | imageData() | setImageData() | image/* |
| hasColor() | colorData() | setColorData() | application/x-color |
#### 拖放
拖放分为拖动和放下两个动作，它们涉及到以下的事件：
+ DragEnterEvent: 所拖动目标进入接收该事件的窗口或控件时触发；
+ DragMoveEvent: 所拖动目标进入窗口或控件后，继续被拖动时触发；
+ DragLeaveEvent: 所拖动目标离开窗口或控件时触发；
+ DropEvent: 所拖动目标被放下时触发。
#### 剪贴板
```python
from PyQt5.QtWidgets import QApplication
self.clipboard = QApplication.clipboard() #实例化一个剪贴板
self.clipboard.setText("xxxxxx") #将内容放在剪切板中
self.clipboard.text() #取出剪贴板中的内容
```
+ dataChanged 当剪贴板中的内容发生变化时候，将触发这个信号。
剪贴板的常用方法
### 17 列表控件、树形控件、表格控件
QListWidget列表控件应当与QListWidgetItem一起使用，后者作为项被添加入列表控件中
QTreeWidget树形控件应当与QTreeWidgetItem一起使用，后者作为项被添加入列表控件中
QTableWidget表格控件应当与QTableWidgetItem一起使用，后者作为项被添加入列表控件中
#### 列表控价
```python
from PyQt5.QtWidgets import QListWidget,QListWidgetItem
self.listwidget_1 = QListWidget(self) #实例化一个列表控件
#添加列表控件的几种方式：
1.
self.item = QListWidgetItem(text)
self.listwidget_1.addItem(self.item)
2
self.item_6 = QListWidgetItem('Item 6', self.listwidget_1)
3
self.listwidget_1.addItem('Item 7')
4
str_list = ['Item 9', 'Item 10']
self.listwidget_1.addItems(str_list)
5
self.item_8 = QListWidgetItem('Item 8')
self.listwidget_1.insertItem(8, self.item_8)
```
+ currentItem() 获取当前点击的项
#### 树形控件
```python
from PyQt5.QtWidgets import QTreeWidget, QTreeWidgetItem
self.tree = QTreeWidget(self) #实例化一个树形控件
self.tree.setColumnCount(2) #设置显示的列数，默认是一列的
self.tree.setHeaderLabels(['Install Components', 'Test']) #设置显示的标题
#设置第一级项
self.preview = QTreeWidgetItem(self.tree)
self.preview.setText(0, 'Preview')
#设置第二级项
self.qt5112 = QTreeWidgetItem()
self.qt5112.setText(0, 'Qt 5.11.2 snapshot')
self.qt5112.setCheckState(0, Qt.Unchecked)
self.preview.addChild(self.qt5112)
#设置第三级项
choice_list = ['macOS', 'Android x86', 'Android ARMv7', 'Sources', 'iOS']
for i, c in enumerate(choice_list):
item = QTreeWidgetItem(self.qt5112)
item.setText(0, c)
item.setCheckState(0, Qt.Unchecked)
```
+ itemClicked 表示点击item时自动触发
#### 表格控件
```python
from PyQt5.QtWidgets import QTableWidget, QTableWidgetItem
class Demo(QTableWidget):
self.setRowCount(6) #设定表格的行数
self.setColumnCount(6) #设定表格的列数
self.setColumnWidth(0, 30) #设定列的大小
self.setRowHeight(0, 30) #设定行的大小
self.setHorizontalHeaderLabels(['h1', 'h2', 'h3', 'h4', ' h5', 'h6']) #设置列名
self.setVerticalHeaderLabels(['t1', 't2', 't3', 't4', 't5', 't6']) #设置行的名
self.item_1 = QTableWidgetItem('Hi') #设置表格里面的内容
self.setItem(0, 0, self.item_1)
self.setSpan(2, 2, 2, 2) #设置居中的格式，表示2行2列中有2列2行集中
```
### 18 滚动区域QScrollArea和滚动条QScollBar
```python
import sys
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QPixmap
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QPushButton, QScrollArea, QScrollBar,QHBoxLayout, QVBoxLayout
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.label = QLabel(self)
self.label.setPixmap(QPixmap('image.jpg'))
self.label.setScaledContents(True) #设置图片会随着label便签的变化而变化大小
self.scroll_area = QScrollArea(self) #初始化一个滚动区域
self.scroll_area.setWidget(self.label)
#将滚动区域的水平滚动条关闭
self.scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.scrollbar = QScrollBar(Qt.Horizontal, self) #实例化一个水平的滚动条
#水平滚动条的大小和滚动区域水平滚动条的大小相同
self.scrollbar.setMaximum(self.scroll_area.horizontalScrollBar().maximum())
self.bigger_btn = QPushButton('Zoom in', self)
self.smaller_btn = QPushButton('Zoom out', self)
self.bigger_btn.clicked.connect(self.bigger_func)
self.smaller_btn.clicked.connect(self.smaller_func)
self.scrollbar.valueChanged.connect(self.sync_func)
self.h_layout = QHBoxLayout()
self.h_layout.addWidget(self.bigger_btn)
self.h_layout.addWidget(self.smaller_btn)
self.v_layout = QVBoxLayout()
self.v_layout.addWidget(self.scroll_area)
self.v_layout.addWidget(self.scrollbar)
self.v_layout.addLayout(self.h_layout)
self.setLayout(self.v_layout)
def bigger_func(self):
self.label.resize(self.label.width()*1.2, self.label.height()*1.2)
self.scrollbar.setMaximum(self.scroll_area.horizontalScrollBar().maximum())
def smaller_func(self):
self.label.resize(self.label.width() * 0.8, self.label.height() * 0.8)
self.scrollbar.setMaximum(self.scroll_area.horizontalScrollBar().maximum())
def sync_func(self):
#设置滚动区域水平滚动条的大小等于滚动条的大小
self.scroll_area.horizontalScrollBar().setValue(self.scrollbar.value())
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
### 层叠样式表
```python
import sys
from PyQt5.QtWidgets import QWidget, QApplication, QListWidget, QStackedWidget,\
QHBoxLayout, QFormLayout, QRadioButton, QLabel, QLineEdit, QCheckBox
class StackUi1(QWidget):
def __init__(self):
super().__init__()
layout = QFormLayout()
layout.addRow('姓名', QLineEdit())
layout.addRow('地址', QLineEdit())
self.setLayout(layout)
class StackUi2(QWidget):
def __init__(self):
super().__init__()
layout = QFormLayout()
sex = QHBoxLayout()
sex.addWidget(QRadioButton('男'))
sex.addWidget(QRadioButton('女'))
layout.addRow(QLabel('性别'), sex)
layout.addRow('生日', QLineEdit())
self.setLayout(layout)
class StackUi3(QWidget):
def __init__(self):
super().__init__()
layout = QHBoxLayout()
# 添加控件到布局中
layout.addWidget(QLabel('科目'))
layout.addWidget(QCheckBox('物理'))
layout.addWidget(QCheckBox('高数'))
self.setLayout(layout)
class Demo(QWidget):
def __init__(self):
super().__init__()
#设置窗口的初始位置和大小
self.setGeometry(300, 300, 30, 30)
self.setWindowTitle("层叠样式")
# 创建三个小控件
self.stack1 = StackUi1()
self.stack2 = StackUi2()
self.stack3 = StackUi3()
#创建列表窗口
self.left_list = QListWidget()
# 创建层叠样式表
self.stack = QStackedWidget()
self.init_stack()
self.init_layout()
self.left_list.currentRowChanged.connect(self.display)
def init_layout(self):
# 水平布局，添加部件到布局中
h_layout = QHBoxLayout()
h_layout.addWidget(self.left_list)
h_layout.addWidget(self.stack)
self.setLayout(h_layout)
def init_stack(self):
# 创建列表窗口，添加条目
self.left_list.insertItem(0, "联系方式")
self.left_list.insertItem(1, "个人信息")
self.left_list.insertItem(2, "教育程度")
self.stack.addWidget(self.stack1)
self.stack.addWidget(self.stack2)
self.stack.addWidget(self.stack3)
def display(self, i):
# 设置当前可见的选项卡的索引
self.stack.setCurrentIndex(i)
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
### 主窗口QMainWindow
主窗口类为我们提供了菜单栏(Menu Bar)、工具栏(Tool Bar)、控件停靠区域(Docke Widgets)和状态栏(Status Bar)。
### 19 Qt中的多线程
```PYTHON
import sys
from PyQt5.QtCore import Qt, QThread, pyqtSignal
from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QLabel, QVBoxLayout
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.button = QPushButton('Count', self)
self.button.clicked.connect(self.count_func)
self.label = QLabel('0', self)
self.label.setAlignment(Qt.AlignCenter)
self.my_thread = MyThread()
self.my_thread.my_signal.connect(self.set_label_func) # 3
self.v_layout = QVBoxLayout()
self.v_layout.addWidget(self.label)
self.v_layout.addWidget(self.button)
self.setLayout(self.v_layout)
def count_func(self):
self.my_thread.start()
def set_label_func(self, num): # 4
self.label.setText(num)
class MyThread(QThread):
my_signal = pyqtSignal(str) # 1
def __init__(self):
super(MyThread, self).__init__()
self.count = 0
def run(self):
while True:
print(self.count)
self.count += 1
self.my_signal.emit(str(self.count)) # 2
self.sleep(1)
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
### 20、QT中的信号与槽
+ 一个信号连接一个槽
+ 多个信号连接一个槽
+ 一个信号连接另一个信号
+ 自定义信号
```python
#自定义信号
import sys
from PyQt5.QtCore import pyqtSignal # 1
from PyQt5.QtWidgets import QApplication, QWidget, QLabel
class Demo(QWidget):
my_signal = pyqtSignal() #定义信号 # 2
def __init__(self):
super(Demo, self).__init__()
self.label = QLabel('Hello World', self)
self.my_signal.connect(self.change_text) # 3
def change_text(self): #槽接受自定义信号
if self.label.text() == 'Hello World':
self.label.setText('Hello PyQt5')
else:
self.label.setText('Hello World')
def mousePressEvent(self, QMouseEvent): # 4
self.my_signal.emit() #触发信号
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
```pyt
#携带参数的自定义信号
import sys
from PyQt5.QtCore import pyqtSignal
from PyQt5.QtWidgets import QApplication, QWidget
class Demo(QWidget):
my_signal = pyqtSignal(int) #携带的值，需要说明类型
def __init__(self):
super(Demo, self).__init__()
self.my_signal.connect(self.signal_slot)
def signal_slot(self, x): 形参x接收
print('信号发射成功')
print(x)
def mouseDoubleClickEvent(self, event):
pos_x = event.pos().x()
self.my_signal.emit(pos_x)#触发信号时携带参数
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
```python
#把一个窗口的信息传递给另一个窗口时，可以把第一窗口期的实例化对象传给第二个窗口，但是这样的话，两个窗口的耦合性太强了。可以在第一个窗口建立一个槽函数，第二个窗口建立信号。
import sys
from PyQt5.QtCore import pyqtSignal
from PyQt5.QtWidgets import QApplication, QWidget, QTextBrowser, QLineEdit, QPushButton, QHBoxLayout
class Window1(QTextBrowser): # 1
def __init__(self):
super(Window1, self).__init__()
def show_msg_slot(self, msg):
self.append(msg)
class Window2(QWidget): # 2
win2_signal = pyqtSignal(str)
def __init__(self):
super(Window2, self).__init__()
self.line = QLineEdit()
self.send_btn = QPushButton('发送')
self.send_btn.clicked.connect(self.send_to_win1_slot)
h_layout = QHBoxLayout()
h_layout.addWidget(self.line)
h_layout.addWidget(self.send_btn)
self.setLayout(h_layout)
def send_to_win1_slot(self):
msg = self.line.text()
self.win2_signal.emit(msg)
if __name__ == '__main__': # 3
app = QApplication(sys.argv)
win1 = Window1()
win1.show()
win2 = Window2()
win2.show()
win2.win2_signal.connect(win1.show_msg_slot) #信号与槽在此绑定，可以减少两个类之间的耦合性
sys.exit(app.exec_())
```
```python
#线程之间的通信
import sys
import random
from PyQt5.QtCore import pyqtSignal, QThread
from PyQt5.QtWidgets import QApplication, QWidget, QTextBrowser, QPushButton, QVBoxLayout
class ChildThread(QThread):
child_signal = pyqtSignal(str) # 1
def __init__(self):
super(ChildThread, self).__init__()
def run(self): # 2
result = str(random.randint(1, 10000))
for _ in range(100000000):
pass
self.child_signal.emit(result)
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
self.browser = QTextBrowser() # 3
self.btn = QPushButton('开始爬取')
self.btn.clicked.connect(self.start_thread_slot)
v_layout = QVBoxLayout()
v_layout.addWidget(self.browser)
v_layout.addWidget(self.btn)
self.setLayout(v_layout)
self.child_thread = ChildThread() # 4
self.child_thread.child_signal.connect(self.child_thread_done_slot)
def start_thread_slot(self):
self.browser.clear()
self.browser.append('爬虫开启')
self.btn.setText('正在爬取')
self.btn.setEnabled(False)
self.child_thread.start()
def child_thread_done_slot(self, msg):
self.browser.append(msg)
self.browser.append('爬取结束')
self.btn.setText('开始爬取')
self.btn.setEnabled(True)
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
### 21、布局管理
+ 垂直布局QVBoxLaout
```python
#通用情况
v_layout = QVBoxLaout()
v_latout.addWiget(xxxx1)
v_latout.addWiget(xxxx2)
self.setLayout(v_latout)
```
+ 水平布局QHBoxLayout
+ 混合使用QVBoxLaout和QHBoxLayout
+ 表单布局QFormLayout
```python
f_layout = QFormLayout()
v_layout = QVBoxLayout()
f_layout.addRow(xxx1, xxx2) #前面的为label，后面的为line
v_layout.addLayout(self.f_layout) #将表单布局加入其他的布局中
```
+ 网格布局QGridLaout
```python
grid_layout = QGridLayout()
grid_layout.addWidget(xxxx1, 0, 0, 1, 1) #第一行第一列，标签的大小为占一行一列
```
### 学会使用文档
1 安装QtAssistant软件，并下载文档查看
2 在线文档
如果不用QtAssistant软件的话，我们也可以通过以下链接来进行文档查询：
http://pyqt.sourceforge.net/Docs/PyQt5/class_reference.html
[文档地址1：https://doc.qt.io/qtforpython/modules.html](https://doc.qt.io/qtforpython/modules.html)
[文档地址2：https://www.riverbankcomputing.com/static/Docs/PyQt5/sip-classes.html](https://www.rrbankcomputing.com/static/Docs/PyQt5/sip-classes.html)
## PyQt5图形界面编程
### QWidget
```python
#属性
setWindowTitle('学点编程吧出品') #设置标题
resize(250, 150) #调整控件的大小
move(300, 300) #移动到控件的位置，如果是最外层的控件则是屏幕的位置
from PyQt5.QtGui import QIcon
setWindowIcon(QIcon('xdbcb8.ico'))
setMouseTracking(True) #开启鼠标跟踪的功能，鼠标没有按下也会接受鼠标的移动事件
update() #刷新控件。
```
```python
#方法
show() #显示控件
def keyPressEvent(self, e): #QWdiget自带的事件处理程序，当按下键盘时自动触发，e触发的事件，e.key()键盘输入的值
def mouseMoveEvent(self, event): #QWiget控件自带事件处理程序，当鼠标移动的时候触发，需要开启鼠标跟踪的功能， event.x event.y 表示鼠标当前位置的坐标。
def mousePressEvent(self, e): #QWidget控件自带事件处理程序，当单击鼠标的时候自动触发
def eventFilter(self, object, event) #事件过滤器。
```
### QDialog
```python
QWidget 是QDialog的父类
done(1)#退出控件
```
### PushButton
```python
QPushButton('按键名称', self) #控件实例
setToolTip('点击这里猜数字') #鼠标悬停在按键上面的时候出现提示，支持富文本
clicked #点击事件，单击松开为一个完整的点击事件
```
### QLineEdit
```Python
QLineEdit('内容', self) #控件实例
text() #控件的内容
setFocus() #让焦点置于文本框中，使文本处于选中的状态
selectAll() #表示选文本框时，对里面的内容进行全选
clear() #对内容进行清除
from PyQt5.QtCore import Qt
setContextMenuPolicy(Qt.NoContextMenu) #禁止在文本框内右键弹出菜单
setPlaceholderText() #文本框为空的时候出现提示
setEchoMode(QLineEdit.Password) #设置显示方式为密码，输入的值将不可见
from PyQt5.QtCore import QRegExp
from PyQt5.QtGui import QRegExpValidator
regx = QRegExp("^[a-zA-Z][0-9A-Za-z]{14}$") #在QLinEdit中加入正则显示器
validator = QRegExpValidator(regx, ledit) #构造一个验证器，该父对象接受与正则表达式匹配的所有字符串
setValidator(validator)
```
#显示模式
| 方式 | 描述 |
| ---------------------------- | ------------------------------------------------ |
| QLineEdit.Normal | 显示输入的字符。这是默认值 |
| QLineEdit.NoEcho | 不要显示任何东西，这可能适用于密码长度保密的密码 |
| QLineEdit.Password | 显示密码字符 |
| QLineEdit.PasswordEchoOnEdit | 在编辑时显示字符，其他时候显示密码 |
### QMeeageBox
```python
QMessageBox.about(self, '内容') #控件实例
QMessageBox.question(self, "标题", "内容"， QMessageBox.Yes | QMessageBox.No, QMessageBox.No) #
QMessageBox.critical(self, "内容", )
QMessageBox.warning(self, "内容", )
QMessageBox.information(self, "内容", )
msgBox = QMessageBox(QMessageBox.NoIcon, '关于','不要意淫了，早点洗洗睡吧!') #基于属性的方式设置消息框的图片
msgBox.setIconPixmap(QPixmap("images/screen2.jpg"))
```
```python
import sys
from PyQt5.QtWidgets import QMessageBox, QApplication, QWidget, QPushButton
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
btn = QPushButton("按键", self)
btn.clicked.connect(self.closeEvent)
def closeEvent(self, event):
reply = QMessageBox.question(self, '确认', '确认退出吗', QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if reply == QMessageBox.Yes:
event.accept()
else:
pass
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
消息对话框的调用可以分为两种1、静态函数的调用；2、基于属性的调用，上面的例子是静态函数的调用，下面的例子是基于属性的调用
```python
import sys
from PyQt5.QtWidgets import QMessageBox, QApplication, QWidget, QPushButton
from PyQt5.QtWidgets import QCheckBox, QLabel
class Demo(QWidget):
def __init__(self):
super(Demo, self).__init__()
btn = QPushButton("按键", self)
self.la = QLabel('这里将会显示我们选择的按钮信息', self)
self.la.move(20,20)
btn.clicked.connect(self.closeEvent)
def closeEvent(self, event):
cb = QCheckBox('所有文档都按此操作')
msgBox = QMessageBox()
msgBox.setWindowTitle('警告')
msgBox.setIcon(QMessageBox.Warning)
msgBox.setText('这是一个警告消息对话框')
msgBox.setInformativeText('出现更改愿意保存吗?')
Save = msgBox.addButton('按键1', QMessageBox.AcceptRole)
msgBox.addButton('按键2', QMessageBox.RejectRole)
msgBox.addButton('按键3', QMessageBox.DestructiveRole)
msgBox.setDefaultButton(Save)
msgBox.setCheckBox(cb)
cb.stateChanged.connect(self.check)
reply = msgBox.exec_()
if reply == QMessageBox.AcceptRole:
self.la.setText('你选择了保存！')
elif reply == QMessageBox.RejectRole:
self.la.setText('你选择了取消！')
else:
self.la.setText('你选择了不保存！')
def check(self):
if self.sender().isChecked():
self.la.setText('你打勾了哦')
else:
self.la.setText('怎么又不打了啊')
if __name__ == '__main__':
app = QApplication(sys.argv)
demo = Demo()
demo.show()
sys.exit(app.exec_())
```
按键的类型
### QLabel
```python
QLabel('内容',self)
setText("新的内容")
```
### QCheckBox
```python
Qt.Checked #2
Qt.PartiallyChecked #半选1
Qt.UnChecked #0
isChecked() #查询状态全选为True，半选为True，未选中为False
checkState() #查询状态，全选为2，半选为1,未选为0
setChecked(True) #设置状态，True为全选，False为未选中 ，0为未选，1为半选不需要使能半选功能，2为全选
setTristate() #使能按键的半选功能，
```
### QDial
```python
valueChanged #值发生改变的信号
```
### QSlider
```python
```
### QPaintert
```python
drawLine(0, 0, self.pos.x(), self.pos.y())# 起点的坐标x,起点的坐标y,终点坐标x,终点坐标y
```
### 信号与槽
```python
#coding=utf-8
import sys
from PyQt5.QtWidgets import (QApplication, QWidget, QMessageBox)
from PyQt5.QtCore import (pyqtSignal, QObject)
class Signal(QObject):
showmouse = pyqtSignal()
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setGeometry(200, 200, 300, 300)
self.setWindowTitle('学点编程吧')
self.s = Signal()
self.s.showmouse.connect(self.about)
self.show()
def about(self):
QMessageBox.about(self,'鼠标','你点鼠标了吧！')
def mousePressEvent(self, e):
self.s.showmouse.emit()
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_())
```
### 布局
```python
#QHBoxLayout,QVBoxLayout
addWidget(bt) #布局中增加控件
widget.setLayout(vbox)#控件中设置布局
addStretch(1) #控件中增加一个拉绳因子，里面的参数表示QSpacerItem的个数
#QGridLayout
addWidget(控件,0,0,3,0) #哪行，哪列，占多少行，占多少列
#QFormLayout
addRow(控件1，控件2)
```
### 颜色对话框
```python
col = QColorDialog.getColor() #打开颜色对话框，如果选择的颜色有效，则设置TextEdit问选择的当前颜色
if col.isValid():
self.tx.setTextColor(col)
```
### 字体对话框
```python
font, ok = QFontDialog.getFont() #打开颜色对话框，如果ok存在表示存在字体
tx.setCurrentFont(font) #TextEdit 设置选择的字体
```
### 文件对话框
```python
fname = QFileDialog.getOpenFileName(self, '打开文件','./') #打开单个文件
fname = QFileDialog.getOpenFileName(self, '打开文件','./',("Images (*.png *.xpm *.jpg)")) #对打开的文件进行过滤
```
### QProgressDiaglog
```python
QProgressDialog(self)
setWindowTitle("请稍等") #设置标题
setLabelText("正在操作...") #设置内容
setCancelButtonText("取消") #添加按键
setWindowModality(Qt.WindowModal) #设置模式
setMinimumDuration(5) #设置最小显示时间，自动计算花费时间，如果小于设置时间不显示进度条
setRange(0,num) #进度条的范围
setValue(i) #设置进度条的值
progress.wasCanceled(): #为True表示关闭进度条
```
#进度条的模式
| 属性 | 描述 |
| ------------------- | ---------------------------------- |
| Qt.NonModal | 窗口不是模态的，不会阻止到其他输入 |
| Qt.WindowModal | 单个模态窗口 |
| Qt.ApplicationModal | 所有窗口模态 |
```python
from PyQt5.QtWidgets import (QApplication, QWidget, QPushButton, QLabel, QLineEdit, QMessageBox, QProgressDialog)
from PyQt5.QtCore import Qt
import sys
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.resize(300,150)
self.setWindowTitle("微信公众号：学点编程吧--进度对话框")
self.lb = QLabel("文件数量",self)
self.lb.move(20,40)
self.bt1 = QPushButton('开始',self)
self.bt1.move(20,80)
self.edit = QLineEdit('100000',self)
self.edit.move(100,40)
self.show()
self.bt1.clicked.connect(self.showDialog)
def showDialog(self):
num = int(self.edit.text())
progress = QProgressDialog(self)
progress.setWindowTitle("请稍等")
progress.setLabelText("正在操作...")
progress.setCancelButtonText("取消")
progress.setMinimumDuration(5)
progress.setWindowModality(Qt.WindowModal)
progress.setRange(0,num)
for i in range(num):
progress.setValue(i)
if progress.wasCanceled():
QMessageBox.warning(self,"提示","操作失败")
break
else:
progress.setValue(num)
QMessageBox.information(self,"提示","操作成功")
if __name__ == '__main__':
app = QApplication(sys.argv)
ex = Example()
sys.exit(app.exec_()
```
### 杂
```python
from PyQt5.QtCore import QCoreApplication
QCoreApplication.instance().quit # QcoreApplication包含主事件循环，它处理和调度所有事件，instance()表示当前的实例。
```
一键复制
编辑
Web IDE
原始数据
按行查看
历史
524
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
