python3+PyQt5 uses database table view-Python Tutorial-php.cn

Home

Backend Development

Python Tutorial

python3+PyQt5 uses database table view

不言

Apr 24, 2018 am 11:49 AM

databaseview

This article mainly introduces the use of database table view in python3 PyQt5 in detail, which has certain reference value. Interested friends can refer to it

It is mentioned above that the form can be presented at one time Each field from the same record comes out, but for tables where users want to see multiple records, a tabular view is needed. This article implements an example of quickly turning python Qt gui into 15 chapters by rewriting it in python3 pyqt5. Users can see multiple records at a time.

#!/usr/bin/env python3
import os
import sys
from PyQt5.QtCore import (PYQT_VERSION_STR, QDate, QFile, QRegExp, QVariant, QModelIndex,Qt)
from PyQt5.QtWidgets import (QApplication,QComboBox,
        QDateTimeEdit, QDialog, QGridLayout, QHBoxLayout, QLabel,
        QLineEdit, QDateEdit,QMessageBox, QPushButton,
        QStyleOptionViewItem, QTableView,QVBoxLayout)
from PyQt5.QtGui import QPixmap,QCursor,QRegExpValidator
from PyQt5.QtSql import (QSqlDatabase, QSqlQuery, QSqlRelation,
       QSqlRelationalDelegate, QSqlRelationalTableModel,QSqlTableModel)
import qrc_resources
MAC = True
try:
 from PyQt5.QtGui import qt_mac_set_native_menubar
except ImportError:
 MAC = False

ID = 0
NAME = ASSETID = 1
CATEGORYID = DATE = DESCRIPTION = 2
ROOM = ACTIONID = 3

ACQUIRED = 1


def createFakeData():
 import random

 print("Dropping tables...")
 query = QSqlQuery()
 query.exec_("DROP TABLE assets")
 query.exec_("DROP TABLE logs")
 query.exec_("DROP TABLE actions")
 query.exec_("DROP TABLE categories")
 QApplication.processEvents()

 print("Creating tables...")
 query.exec_("""CREATE TABLE actions (
    id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE NOT NULL,
    name VARCHAR(20) NOT NULL,
    description VARCHAR(40) NOT NULL)""")
 query.exec_("""CREATE TABLE categories (
    id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE NOT NULL,
    name VARCHAR(20) NOT NULL,
    description VARCHAR(40) NOT NULL)""")
 query.exec_("""CREATE TABLE assets (
    id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE NOT NULL,
    name VARCHAR(40) NOT NULL,
    categoryid INTEGER NOT NULL,
    room VARCHAR(4) NOT NULL,
    FOREIGN KEY (categoryid) REFERENCES categories)""")
 query.exec_("""CREATE TABLE logs (
    id INTEGER PRIMARY KEY AUTOINCREMENT UNIQUE NOT NULL,
    assetid INTEGER NOT NULL,
    date DATE NOT NULL,
    actionid INTEGER NOT NULL,
    FOREIGN KEY (assetid) REFERENCES assets,
    FOREIGN KEY (actionid) REFERENCES actions)""")
 QApplication.processEvents()

 print("Populating tables...")
 query.exec_("INSERT INTO actions (name, description) "
    "VALUES (&#39;Acquired&#39;, &#39;When installed&#39;)")
 query.exec_("INSERT INTO actions (name, description) "
    "VALUES (&#39;Broken&#39;, &#39;When failed and unusable&#39;)")
 query.exec_("INSERT INTO actions (name, description) "
    "VALUES (&#39;Repaired&#39;, &#39;When back in service&#39;)")
 query.exec_("INSERT INTO actions (name, description) "
    "VALUES (&#39;Routine maintenance&#39;, "
    "&#39;When tested, refilled, etc.&#39;)")
 query.exec_("INSERT INTO categories (name, description) VALUES "
    "(&#39;Computer Equipment&#39;, "
    "&#39;Monitors, System Units, Peripherals, etc.&#39;)")
 query.exec_("INSERT INTO categories (name, description) VALUES "
    "(&#39;Furniture&#39;, &#39;Chairs, Tables, Desks, etc.&#39;)")
 query.exec_("INSERT INTO categories (name, description) VALUES "
    "(&#39;Electrical Equipment&#39;, &#39;Non-computer electricals&#39;)")
 today = QDate.currentDate()
 floors = list(range(1, 12)) + list(range(14, 28))
 monitors = ((&#39;17" LCD Monitor&#39;, 1),
    (&#39;20" LCD Monitor&#39;, 1),
    (&#39;21" LCD Monitor&#39;, 1),
    (&#39;21" CRT Monitor&#39;, 1),
    (&#39;24" CRT Monitor&#39;, 1))
 computers = (("Computer (32-bit/80GB/0.5GB)", 1),
     ("Computer (32-bit/100GB/1GB)", 1),
     ("Computer (32-bit/120GB/1GB)", 1),
     ("Computer (64-bit/240GB/2GB)", 1),
     ("Computer (64-bit/320GB/4GB)", 1))
 printers = (("Laser Printer (4 ppm)", 1),
    ("Laser Printer (6 ppm)", 1),
    ("Laser Printer (8 ppm)", 1),
    ("Laser Printer (16 ppm)", 1))
 chairs = (("Secretary Chair", 2),
    ("Executive Chair (Basic)", 2),
    ("Executive Chair (Ergonimic)", 2),
    ("Executive Chair (Hi-Tech)", 2))
 desks = (("Desk (Basic, 3 drawer)", 2),
    ("Desk (Standard, 3 drawer)", 2),
    ("Desk (Executive, 3 drawer)", 2),
    ("Desk (Executive, 4 drawer)", 2),
    ("Desk (Large, 4 drawer)", 2))
 furniture = (("Filing Cabinet (3 drawer)", 2),
     ("Filing Cabinet (4 drawer)", 2),
     ("Filing Cabinet (5 drawer)", 2),
     ("Bookcase (4 shelves)", 2),
     ("Bookcase (6 shelves)", 2),
     ("Table (4 seater)", 2),
     ("Table (8 seater)", 2),
     ("Table (12 seater)", 2))
 electrical = (("Fan (3 speed)", 3),
     ("Fan (5 speed)", 3),
     ("Photocopier (4 ppm)", 3),
     ("Photocopier (6 ppm)", 3),
     ("Photocopier (8 ppm)", 3),
     ("Shredder", 3))
 query.prepare("INSERT INTO assets (name, categoryid, room) "
     "VALUES (:name, :categoryid, :room)")
 logQuery = QSqlQuery()
 logQuery.prepare("INSERT INTO logs (assetid, date, actionid) "
      "VALUES (:assetid, :date, :actionid)")
 assetid = 1
 for i in range(20):
  room = "{0:02d}{1:02d}".format(
    random.choice(floors), random.randint(1, 62))
  for name, category in (random.choice(monitors),
    random.choice(computers), random.choice(chairs),
    random.choice(desks), random.choice(furniture)):
   query.bindValue(":name", name)
   query.bindValue(":categoryid", category)
   query.bindValue(":room", room)
   query.exec_()
   logQuery.bindValue(":assetid", assetid)
   when = today.addDays(-random.randint(7, 1500))
   #when=when.toString()
   logQuery.bindValue(":date", when.toString("yyyy-MM-dd"))
   logQuery.bindValue(":actionid", ACQUIRED)
   logQuery.exec_()
   if random.random() > 0.7:
    logQuery.bindValue(":assetid", assetid)
    when = when.addDays(random.randint(1, 1500))
    if when <= today:
     logQuery.bindValue(":date", when.toString("yyyy-MM-dd"))
     logQuery.bindValue(":actionid",
       random.choice((2, 4)))
     logQuery.exec_()
   assetid += 1
  if random.random() > 0.8:
   name, category = random.choice(printers)
   query.bindValue(":name", name)
   query.bindValue(":categoryid", category)
   query.bindValue(":room", room)
   query.exec_()
   logQuery.bindValue(":assetid", assetid)
   when = today.addDays(-random.randint(7, 1500))
   logQuery.bindValue(":date", when.toString("yyyy-MM-dd"))
   logQuery.bindValue(":actionid",ACQUIRED)
   logQuery.exec_()
   if random.random() > 0.6:
    logQuery.bindValue(":assetid", assetid)
    when = when.addDays(random.randint(1, 1500))
    if when <= today:
     logQuery.bindValue(":date", when.toString("yyyy-MM-dd"))
     logQuery.bindValue(":actionid",
       random.choice((2, 4)))
     logQuery.exec_()
   assetid += 1
  if random.random() > 0.6:
   name, category = random.choice(electrical)
   query.bindValue(":name", name)
   query.bindValue(":categoryid", category)
   query.bindValue(":room", room)
   query.exec_()
   logQuery.bindValue(":assetid", assetid)
   when = today.addDays(-random.randint(7, 1500))
   logQuery.bindValue(":date", when.toString("yyyy-MM-dd"))
   logQuery.bindValue(":actionid",ACQUIRED)
   logQuery.exec_()
   if random.random() > 0.5:
    logQuery.bindValue(":assetid", assetid)
    when = when.addDays(random.randint(1, 1500))
    if when <= today:
     logQuery.bindValue(":date", when.toString("yyyy-MM-dd"))
     logQuery.bindValue(":actionid",
       random.choice((2, 4)))
     logQuery.exec_()
   assetid += 1
  QApplication.processEvents()

 print("Assets:")
 query.exec_("SELECT id, name, categoryid, room FROM assets "
    "ORDER by id")
 categoryQuery = QSqlQuery()
 while query.next():
  id = query.value(0)
  name = str(query.value(1))
  categoryid = query.value(2)
  room = str(query.value(3))
  categoryQuery.exec_("SELECT name FROM categories "
    "WHERE id = {0}".format(categoryid))
  category = "{0}".format(categoryid)
  if categoryQuery.next():
   category = str(categoryQuery.value(0))
  print("{0}: {1} [{2}] {3}".format(id, name, category, room))
 QApplication.processEvents()


class ReferenceDataDlg(QDialog):

 def __init__(self, table, title, parent=None):
  super(ReferenceDataDlg, self).__init__(parent)

  self.model = QSqlTableModel(self)
  self.model.setTable(table)
  self.model.setSort(NAME, Qt.AscendingOrder)
  self.model.setHeaderData(ID, Qt.Horizontal,"ID")
  self.model.setHeaderData(NAME, Qt.Horizontal, "Name")
  self.model.setHeaderData(DESCRIPTION, Qt.Horizontal,"Description")
  self.model.select()

  self.view = QTableView()
  self.view.setModel(self.model)
  self.view.setSelectionMode(QTableView.SingleSelection)
  self.view.setSelectionBehavior(QTableView.SelectRows)
  self.view.setColumnHidden(ID, True)
  self.view.resizeColumnsToContents()
  addButton = QPushButton("&Add")
  deleteButton = QPushButton("&Delete")
  okButton = QPushButton("&OK")
  if not MAC:
   addButton.setFocusPolicy(Qt.NoFocus)
   deleteButton.setFocusPolicy(Qt.NoFocus)

  buttonLayout = QHBoxLayout()
  buttonLayout.addWidget(addButton)
  buttonLayout.addWidget(deleteButton)
  buttonLayout.addStretch()
  buttonLayout.addWidget(okButton)
  layout = QVBoxLayout()
  layout.addWidget(self.view)
  layout.addLayout(buttonLayout)
  self.setLayout(layout)

  addButton.clicked.connect(self.addRecord)
  deleteButton.clicked.connect(self.deleteRecord)
  okButton.clicked.connect(self.accept)

  self.setWindowTitle(
    "Asset Manager - Edit {0} Reference Data".format(title))

 def addRecord(self):
  row = self.model.rowCount()
  self.model.insertRow(row)
  index = self.model.index(row, NAME)
  self.view.setCurrentIndex(index)
  self.view.edit(index)


 def deleteRecord(self):
  index = self.view.currentIndex()
  if not index.isValid():
   return
  #QSqlDatabase.database().transaction()
  record = self.model.record(index.row())
  id = record.value(ID)
  table = self.model.tableName()
  query = QSqlQuery()
  if table == "actions":
   query.exec_("SELECT COUNT(*) FROM logs "
        "WHERE actionid = {0}".format(id))
  elif table == "categories":
   query.exec_("SELECT COUNT(*) FROM assets "
        "WHERE categoryid = {0}".format(id))
  count = 0
  if query.next():
   count = query.value(0)
  if count:
   QMessageBox.information(self,
     "Delete {0}".format(table),
     ("Cannot delete {0}<br>"
        "from the {1} table because it is used by "
        "{2} records").format(record.value(NAME),table,count))
   #QSqlDatabase.database().rollback()
   return
  self.model.removeRow(index.row())
  self.model.submitAll()
  self.model.select()
  #QSqlDatabase.database().commit()



class AssetDelegate(QSqlRelationalDelegate):


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


 def paint(self, painter, option, index):
  myoption = QStyleOptionViewItem(option)
  if index.column() == ROOM:
   myoption.displayAlignment |= (Qt.AlignRight|Qt.AlignVCenter)
  QSqlRelationalDelegate.paint(self, painter, myoption, index)


 def createEditor(self, parent, option, index):
  if index.column() == ROOM:
   editor = QLineEdit(parent)
   regex = QRegExp(r"(?:0[1-9]|1[0124-9]|2[0-7])"
         r"(?:0[1-9]|[1-5][0-9]|6[012])")
   validator = QRegExpValidator(regex, parent)
   editor.setValidator(validator)
   editor.setInputMask("9999")
   editor.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
   return editor
  else:
   return QSqlRelationalDelegate.createEditor(self, parent,
              option, index)

 def setEditorData(self, editor, index):
  if index.column() == ROOM:
   text = index.model().data(index, Qt.DisplayRole)
   editor.setText(text)
  else:
   QSqlRelationalDelegate.setEditorData(self, editor, index)


 def setModelData(self, editor, model, index):
  if index.column() == ROOM:
   model.setData(index, editor.text())
  else:
   QSqlRelationalDelegate.setModelData(self, editor, model,
            index)


class LogDelegate(QSqlRelationalDelegate):

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


 def paint(self, painter, option, index):
  myoption = QStyleOptionViewItem(option)
  if index.column() == DATE:
   myoption.displayAlignment |= (Qt.AlignRight|Qt.AlignVCenter)
  QSqlRelationalDelegate.paint(self, painter, myoption, index)


 def createEditor(self, parent, option, index):
  if (index.column() == ACTIONID and
   index.model().data(index, Qt.DisplayRole) ==
   ACQUIRED): # Acquired is read-only
   return
  if index.column() == DATE:
   editor = QDateEdit(parent)
   editor.setMaximumDate(QDate.currentDate())
   editor.setDisplayFormat("yyyy-MM-dd")
   if PYQT_VERSION_STR >= "4.1.0":
    editor.setCalendarPopup(True)
   editor.setAlignment(Qt.AlignRight|
        Qt.AlignVCenter)
   return editor
  else:
   return QSqlRelationalDelegate.createEditor(self, parent,
              option, index)

 def setEditorData(self, editor, index):
  if index.column() == DATE:
   date = index.model().data(index, Qt.DisplayRole)
   editor.setDate(date)
  else:
   QSqlRelationalDelegate.setEditorData(self, editor, index)


 def setModelData(self, editor, model, index):
  if index.column() == DATE:
   model.setData(index, QVariant(editor.date()))
  else:
   QSqlRelationalDelegate.setModelData(self, editor, model,
            index)


class MainForm(QDialog):

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

  self.assetModel = QSqlRelationalTableModel(self)
  self.assetModel.setTable("assets")
  self.assetModel.setRelation(CATEGORYID,
    QSqlRelation("categories", "id", "name"))
  self.assetModel.setSort(ROOM, Qt.AscendingOrder)
  self.assetModel.setHeaderData(ID, Qt.Horizontal,"ID")
  self.assetModel.setHeaderData(NAME, Qt.Horizontal,"Name")
  self.assetModel.setHeaderData(CATEGORYID, Qt.Horizontal,"Category")
  self.assetModel.setHeaderData(ROOM, Qt.Horizontal,"Room")
  self.assetModel.select()

  self.assetView = QTableView()
  self.assetView.setModel(self.assetModel)
  self.assetView.setItemDelegate(AssetDelegate(self))
  self.assetView.setSelectionMode(QTableView.SingleSelection)
  self.assetView.setSelectionBehavior(QTableView.SelectRows)
  self.assetView.setColumnHidden(ID, True)
  self.assetView.resizeColumnsToContents()
  assetLabel = QLabel("A&ssets")
  assetLabel.setBuddy(self.assetView)

  self.logModel = QSqlRelationalTableModel(self)
  self.logModel.setTable("logs")
  self.logModel.setRelation(ACTIONID,
    QSqlRelation("actions", "id", "name"))
  self.logModel.setSort(DATE, Qt.AscendingOrder)
  self.logModel.setHeaderData(DATE, Qt.Horizontal, "Date")
  self.logModel.setHeaderData(ACTIONID, Qt.Horizontal,"Action")
  self.logModel.select()

  self.logView = QTableView()
  self.logView.setModel(self.logModel)
  self.logView.setItemDelegate(LogDelegate(self))
  self.logView.setSelectionMode(QTableView.SingleSelection)
  self.logView.setSelectionBehavior(QTableView.SelectRows)
  self.logView.setColumnHidden(ID, True)
  self.logView.setColumnHidden(ASSETID, True)
  self.logView.resizeColumnsToContents()
  self.logView.horizontalHeader().setStretchLastSection(True)
  logLabel = QLabel("&Logs")
  logLabel.setBuddy(self.logView)

  addAssetButton = QPushButton("&Add Asset")
  deleteAssetButton = QPushButton("&Delete Asset")
  addActionButton = QPushButton("Add A&ction")
  deleteActionButton = QPushButton("Delete Ac&tion")
  editActionsButton = QPushButton("&Edit Actions...")
  editCategoriesButton = QPushButton("Ed&it Categories...")
  quitButton = QPushButton("&Quit")
  for button in (addAssetButton, deleteAssetButton,
    addActionButton, deleteActionButton,
    editActionsButton, editCategoriesButton, quitButton):
   if MAC:
    button.setDefault(False)
    button.setAutoDefault(False)
   else:
    button.setFocusPolicy(Qt.NoFocus)

  dataLayout = QVBoxLayout()
  dataLayout.addWidget(assetLabel)
  dataLayout.addWidget(self.assetView, 1)
  dataLayout.addWidget(logLabel)
  dataLayout.addWidget(self.logView)
  buttonLayout = QVBoxLayout()
  buttonLayout.addWidget(addAssetButton)
  buttonLayout.addWidget(deleteAssetButton)
  buttonLayout.addWidget(addActionButton)
  buttonLayout.addWidget(deleteActionButton)
  buttonLayout.addWidget(editActionsButton)
  buttonLayout.addWidget(editCategoriesButton)
  buttonLayout.addStretch()
  buttonLayout.addWidget(quitButton)
  layout = QHBoxLayout()
  layout.addLayout(dataLayout, 1)
  layout.addLayout(buttonLayout)
  self.setLayout(layout)

  #self.connect(self.assetView.selectionModel(),
    #SIGNAL(("currentRowChanged(QModelIndex,QModelIndex)")),
    #self.assetChanged)
  self.assetView.selectionModel().currentRowChanged.connect(self.assetChanged)
  addAssetButton.clicked.connect(self.addAsset)
  deleteAssetButton.clicked.connect(self.deleteAsset)
  addActionButton.clicked.connect(self.addAction)
  deleteActionButton.clicked.connect(self.deleteAction)
  editActionsButton.clicked.connect(self.editActions)
  editCategoriesButton.clicked.connect(self.editCategories)
  quitButton.clicked.connect(self.done)

  self.assetChanged(self.assetView.currentIndex())
  self.setMinimumWidth(650)
  self.setWindowTitle("Asset Manager")


 def done(self, result=1):
  query = QSqlQuery()
  query.exec_("DELETE FROM logs WHERE logs.assetid NOT IN"
     "(SELECT id FROM assets)")
  QDialog.done(self, 1)


 def assetChanged(self, index):
  if index.isValid():
   record = self.assetModel.record(index.row())
   #print(index.row())
   id = record.value("id")
   self.logModel.setFilter("assetid = {0}".format(id))
  else:
   self.logModel.setFilter("assetid = -1")
  #self.logModel.reset() # workaround for Qt <= 4.3.3/SQLite bug
  #self.logModel.beginResetModel() 
  self.logModel.select()
  self.logView.horizontalHeader().setVisible(
    self.logModel.rowCount() > 0)
  if PYQT_VERSION_STR < "4.1.0":
   self.logView.setColumnHidden(ID, True)
   self.logView.setColumnHidden(ASSETID, True)
  #self.logModel.endResetModel()



 def addAsset(self):
  row = (self.assetView.currentIndex().row()
    if self.assetView.currentIndex().isValid() else 0)

  QSqlDatabase.database().transaction()
  self.assetModel.insertRow(row)
  index = self.assetModel.index(row, NAME)
  self.assetView.setCurrentIndex(index)

  assetid = 1
  query = QSqlQuery()
  query.exec_("SELECT MAX(id) FROM assets")
  if query.next():
   assetid = query.value(0)
  query.prepare("INSERT INTO logs (assetid, date, actionid) "
      "VALUES (:assetid, :date, :actionid)")
  query.bindValue(":assetid", assetid + 1)
  query.bindValue(":date", QDate.currentDate())
  query.bindValue(":actionid", ACQUIRED)
  query.exec_()
  QSqlDatabase.database().commit()
  #self.logModel.select()
  self.assetView.edit(index)


 def deleteAsset(self):
  index = self.assetView.currentIndex()
  if not index.isValid():
   return
  QSqlDatabase.database().transaction()
  record = self.assetModel.record(index.row())
  assetid = record.value(ID)
  logrecords = 1
  query = QSqlQuery("SELECT COUNT(*) FROM logs WHERE assetid = {0}".format(assetid))
  if query.next():
   logrecords = query.value(0)
  msg = ("<font color=red>Delete</font><br><b>{0}</b>"
        "<br>from room {1}").format(record.value(NAME),record.value(ROOM))
  if logrecords > 1:
   msg += (", along with {0} log records"
     .format(logrecords))
  msg += "?"
  if (QMessageBox.question(self, "Delete Asset", msg,
    QMessageBox.Yes|QMessageBox.No) ==
    QMessageBox.No):
   QSqlDatabase.database().rollback()
   return
  #query.exec_("DELETE FROM logs WHERE assetid = {0}"
  #    .format(assetid))

  #use model API
  self.logModel.setFilter("assetid={0}".format(assetid))
  self.logModel.select()
  if self.logModel.rowCount()>0:
   self.logModel.removeRows(0,self.logModel.rowCount())
   self.logModel.submitAll()   


  self.assetModel.removeRow(index.row())
  self.assetModel.submitAll()
  QSqlDatabase.database().commit()
  self.assetModel.select()
  self.assetChanged(self.assetView.currentIndex())


 def addAction(self):
  index = self.assetView.currentIndex()
  if not index.isValid():
   return
  QSqlDatabase.database().transaction()
  record = self.assetModel.record(index.row())
  assetid = record.value(ID)

  row = self.logModel.rowCount()
  self.logModel.insertRow(row)
  self.logModel.setData(self.logModel.index(row, ASSETID),
        assetid)
  self.logModel.setData(self.logModel.index(row, DATE),
        QDate.currentDate())
  QSqlDatabase.database().commit()
  index = self.logModel.index(row, ACTIONID)
  self.logView.setCurrentIndex(index)
  self.logView.edit(index)


 def deleteAction(self):
  index = self.logView.currentIndex()
  if not index.isValid():
   return
  record = self.logModel.record(index.row())
  action = record.value(ACTIONID)
  if action == "Acquired":
   QMessageBox.information(self, "Delete Log",
     "The &#39;Acquired&#39; log record cannot be deleted.<br>"
     "You could delete the entire asset instead.")
   return
  when = str(record.value(DATE))
  if (QMessageBox.question(self, "Delete Log",
    "Delete log<br>{0} {1}?".format(when, action),
    QMessageBox.Yes|QMessageBox.No) ==
    QMessageBox.No):
   return
  self.logModel.removeRow(index.row())
  self.logModel.submitAll()
  self.logModel.select()


 def editActions(self):
  form = ReferenceDataDlg("actions", "Action", self)
  form.exec_()

 def editCategories(self):
  form = ReferenceDataDlg("categories", "Category", self)
  form.exec_()



def main():
 app = QApplication(sys.argv)

 filename = os.path.join(os.path.dirname(__file__), "assets.db")
 create = not QFile.exists(filename)
 db = QSqlDatabase.addDatabase("QSQLITE")
 db.setDatabaseName(filename)
 if not db.open():
  QMessageBox.warning(None, "Asset Manager",
   ("Database Error: {0}"
   .format(db.lastError().text())))
  sys.exit(1)

 splash = None
 if create:
  app.setOverrideCursor(QCursor(Qt.WaitCursor))
  splash = QLabel()
  pixmap = QPixmap(":/assetmanagersplash.png")
  splash.setPixmap(pixmap)
  splash.setMask(pixmap.createHeuristicMask())
  splash.setWindowFlags(Qt.SplashScreen)
  rect = app.desktop().availableGeometry()
  splash.move((rect.width() - pixmap.width()) / 2,
     (rect.height() - pixmap.height()) / 2)
  splash.show()
  app.processEvents()
  createFakeData()

 form = MainForm()
 form.show()
 if create:
  splash.close()
  app.processEvents()
  app.restoreOverrideCursor()
 app.exec_()
 del form
 del db


main()

Running results:

##Related recommendations:

python3 PyQt5 implements drag and drop function

python3 Detailed explanation of PyQt5 custom view

python3 Detailed explanation of PyQt5 generic delegate

The above is the detailed content of python3+PyQt5 uses database table view. For more information, please follow other related articles on the PHP Chinese website!

Statement

The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn

Merging Lists in Python: Choosing the Right MethodMay 14, 2025 am 12:11 AM

TomergelistsinPython,youcanusethe operator,extendmethod,listcomprehension,oritertools.chain,eachwithspecificadvantages:1)The operatorissimplebutlessefficientforlargelists;2)extendismemory-efficientbutmodifiestheoriginallist;3)listcomprehensionoffersf

How to concatenate two lists in python 3?May 14, 2025 am 12:09 AM

In Python 3, two lists can be connected through a variety of methods: 1) Use operator, which is suitable for small lists, but is inefficient for large lists; 2) Use extend method, which is suitable for large lists, with high memory efficiency, but will modify the original list; 3) Use * operator, which is suitable for merging multiple lists, without modifying the original list; 4) Use itertools.chain, which is suitable for large data sets, with high memory efficiency.

Python concatenate list stringsMay 14, 2025 am 12:08 AM

Using the join() method is the most efficient way to connect strings from lists in Python. 1) Use the join() method to be efficient and easy to read. 2) The cycle uses operators inefficiently for large lists. 3) The combination of list comprehension and join() is suitable for scenarios that require conversion. 4) The reduce() method is suitable for other types of reductions, but is inefficient for string concatenation. The complete sentence ends.

Python execution, what is that?May 14, 2025 am 12:06 AM

PythonexecutionistheprocessoftransformingPythoncodeintoexecutableinstructions.1)Theinterpreterreadsthecode,convertingitintobytecode,whichthePythonVirtualMachine(PVM)executes.2)TheGlobalInterpreterLock(GIL)managesthreadexecution,potentiallylimitingmul

Python: what are the key featuresMay 14, 2025 am 12:02 AM

Key features of Python include: 1. The syntax is concise and easy to understand, suitable for beginners; 2. Dynamic type system, improving development speed; 3. Rich standard library, supporting multiple tasks; 4. Strong community and ecosystem, providing extensive support; 5. Interpretation, suitable for scripting and rapid prototyping; 6. Multi-paradigm support, suitable for various programming styles.

Python: compiler or Interpreter?May 13, 2025 am 12:10 AM

Python is an interpreted language, but it also includes the compilation process. 1) Python code is first compiled into bytecode. 2) Bytecode is interpreted and executed by Python virtual machine. 3) This hybrid mechanism makes Python both flexible and efficient, but not as fast as a fully compiled language.

Python For Loop vs While Loop: When to Use Which?May 13, 2025 am 12:07 AM

Useaforloopwheniteratingoverasequenceorforaspecificnumberoftimes;useawhileloopwhencontinuinguntilaconditionismet.Forloopsareidealforknownsequences,whilewhileloopssuitsituationswithundeterminediterations.

Python loops: The most common errorsMay 13, 2025 am 12:07 AM

Pythonloopscanleadtoerrorslikeinfiniteloops,modifyinglistsduringiteration,off-by-oneerrors,zero-indexingissues,andnestedloopinefficiencies.Toavoidthese:1)Use'i

See all articles

Hot AI Tools

Undresser.AI Undress

AI-powered app for creating realistic nude photos

AI Clothes Remover

Online AI tool for removing clothes from photos.

Undress AI Tool

Undress images for free

Clothoff.io

AI clothes remover

Video Face Swap

Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Article

How to fix KB5055612 fails to install in Windows 10?

4 weeks agoByDDD

Roblox: Grow A Garden - Complete Mutation Guide

3 weeks agoByDDD

Roblox: Bubble Gum Simulator Infinity - How To Get And Use Royal Keys

3 weeks agoBy尊渡假赌尊渡假赌尊渡假赌

Mandragora: Whispers Of The Witch Tree - How To Unlock The Grappling Hook

3 weeks agoBy尊渡假赌尊渡假赌尊渡假赌

Nordhold: Fusion System, Explained

3 weeks agoBy尊渡假赌尊渡假赌尊渡假赌

Hot Tools

mPDF

mPDF is a PHP library that can generate PDF files from UTF-8 encoded HTML. The original author, Ian Back, wrote mPDF to output PDF files "on the fly" from his website and handle different languages. It is slower than original scripts like HTML2FPDF and produces larger files when using Unicode fonts, but supports CSS styles etc. and has a lot of enhancements. Supports almost all languages, including RTL (Arabic and Hebrew) and CJK (Chinese, Japanese and Korean). Supports nested block-level elements (such as P, DIV),