Como usar o Pyqt QtableWidget

Uma tabela é usada para exibir dados em um formato estruturado, de acordo com linhas e colunas. O QTableWidget A classe de PYQT pode ser usada no Python para exibir dados em forma de tabular para tarefas relacionadas à pesquisa ou análise de dados. O conteúdo da tabela pode ser gerado a partir de diferentes tipos de armazenamento, como listas ou tabelas bidimensionais, tabelas de banco de dados, arquivos JSON etc. Uma ou mais tabelas podem ser criadas usando QTableWidget No aplicativo PYQT. Este tutorial mostra como usar QTableWidget Para criar vários tipos de tabelas usando o script python.

Métodos necessários

O QTableWidget A classe inclui muitos métodos para executar tarefas relacionadas à criação de tabela. Alguns dos métodos mais usados ​​desta classe são explicados abaixo:

Nome do método	Propósito
setRowCount ()	Usado para definir o número de linhas.
setColumnCount ()	Usado para definir o número de colunas.
sethorizontalheaderlabels ()	Usado para definir os rótulos do cabeçalho da tabela.
setItem ()	Usado para definir o valor da célula da tabela.
ResazecolumnSToContents ()	Usado para redimensionar as colunas da tabela com base no conteúdo.
Resivesowstocontents ()	Usado para redimensionar as linhas da tabela com base no conteúdo.
setminimumwidth ()	Usado para definir a largura mínima da tabela.
setminimumHeight ()	Usado para definir a altura mínima da tabela.
mostrar()	Usado para exibir a tabela.

QTableWidget Uso

As seções a seguir fornecem exemplos simples para explicar como criar uma tabela no aplicativo PYQT usando dados estáticos e dados de listar.

Exemplo 1: Crie uma tabela simples usando dados estáticos

O script a seguir cria uma tabela de dados estáticos com cinco linhas e quatro colunas usando o QTableWidget aula. Dois para Loops com valores de alcance foram usados ​​no script para adicionar os dados estáticos nas células da tabela. As posições de linha e coluna de cada célula foram adicionadas como conteúdo de cada célula. O Qdesktopwidget é usado no script para exibir a janela com a tabela no centro da tela.

# Importar bibliotecas necessárias
Importar sistemas
de pyqt5.Qtwidgets importar qapplication, qmainwindow, qtablewidget, qtablewidgetItem, qdesktopwidget
de pyqt5.Qtcore importar qsize
# Defina classe para criar a tabela com dados estáticos
Classe Simpletable (QMainWindow):
def __init __ (self):
# Ligue para o construtor pai
super().__iniciar__()
# Defina o tamanho e o título da janela
auto.Setminimumsize (QSize (420, 150))
auto.setWindowTitle ("Tabela simples com dados estáticos")
# Crie a tabela com as propriedades necessárias
tabela = QtableWidget (self)
mesa.setColumnCount (4)
mesa.setRowCount (5)
mesa.setminimumwidth (500)
mesa.SetminimumHeight (500)
# Defina os cabeçalhos da tabela
mesa.Sethorizontalheaderlabels (["Header-1", "Header-2", "Header-3", "Header-4"])
# Defina os valores da tabela
para i no intervalo (5):
para j no intervalo (4):
mesa.setItem (i, j, qtablewidgetItem ("linha-" + str (i + 1) + ", col-" + str (j + 1)))
# Redimensionar as linhas e colunas com base no conteúdo
mesa.ResazecolumnSToContents ()
mesa.Resivesowstocontents ()
# Exibir a tabela
mesa.mostrar()
# Exiba a janela no centro da tela
win = self.FrameGeometria ()
POS = QDESKTOPWIDGET ().DisponívelGeometria ().Centro()
ganhar.MoveCenter (POS)
auto.mover (Win.topleft ())
auto.mostrar()
# Crie objeto de aplicativo e execute o aplicativo
app = qapplication (sys.argv)
MW = SimpleTable ()
MW.mostrar()
aplicativo.exec ()

A seguinte janela com uma tabela aparecerá o script acima é executado. De acordo com os valores do para Loops, o valor da célula da primeira linha e a primeira coluna é 'Row-1, Col-1,'e o valor celular da última linha e última coluna é'Linha-5, Col-4.'

Exemplo 2: Crie a tabela com ponta de ferramenta usando dados de dicionário e lista

O script a seguir cria uma tabela com o conteúdo de um dicionário Python e uma lista usando o QTableWidget aula. O script também adiciona um texto de ponta de ferramenta para o cabeçalho da tabela. Um dicionário python nomeado Marcas também é declarado no script. Os códigos do curso são usados ​​como os principais valores do dicionário. Uma lista de Python é declarada para definir os IDs dos alunos. Os valores -chave do dicionário são adicionados ao cabeçalho da tabela, os valores da lista são adicionados à primeira coluna da tabela e os valores do dicionário são adicionados às outras colunas da tabela.

# Importar módulos necessários
Importar sistemas
de pyqt5.Qtwidgets importar qapplication, qtablewidget, qtablewidgetItem, qdesktopwidget
# Declare uma variável de dicionário com marcas
Marks = 'CSE-401': [78, 93, 67, 88, 78],
'CSE-404': [90, 59, 82, 73, 89],
'CSE-406': [81, 80, 74, 83, 67],
'CSE-407': [81, 80, 98, 83, 72]
Classe TableFromlist (QtableWidget):
def __init __ (self, dados, *args):
# Ligue para o construtor pai
QTableWidget.__init __ (eu, *args)
# Declare uma lista dos IDs dos alunos
auto.Id_list = ['0189945', '0154590', '0196734', '0185611', '0178956']
# Defina as configurações necessárias para a tabela
auto.dados = dados
auto.ResazecolumnSToContents ()
auto.Resivesowstocontents ()
auto.setColumnWidth (0, 100)
para i no intervalo (4):
auto.setColumnWidth (i, 80)
auto.setminimumwidth (400)
auto.setWindowtitle ("folha de marcas")
# Declare a variável para definir o conteúdo do cabeçalho
Cabeçalhos = []
cabeçalhos.acrescentar(")
# para o loop ler as chaves do dicionário
para n, chave em enumerar (classificada (self.dados.chaves())):
cabeçalhos.Anexar (chave)
# para o loop ler os valores do dicionário
para M, item em enumerar (eu.dados [chave]):
Id = qtablewidgetItem (self.Id_list [m])
auto.setItem (m, 0, id)
newval = QtableWidgetItem (str (item))
auto.setItem (m, n+1, newval)
# Defina o rótulo do cabeçalho da tabela
auto.SethorizontalHeaderLabels (cabeçalhos)
# Defina as dicas de ferramentas para os cabeçalhos
auto.HorizontalHeaderitem (1).SetolOoltip ("Multimídia")
auto.HorizontalHeaderitem (2).SettOoltip ("Inteligente Artificial")
auto.HorizontalHeaderitem (3).SettOoltip ("Banco de Dados Avançado")
auto.HorizontalHeaderitem (4).SettOoltip ("UNIX Programming")
# Leia o valor da célula específico
auto.clicado.Conecte -se (self.on_click)
# Exiba a janela no centro da tela
win = self.FrameGeometria ()
POS = QDESKTOPWIDGET ().DisponívelGeometria ().Centro()
ganhar.MoveCenter (POS)
auto.mover (Win.topleft ())
auto.mostrar()
def on_click (self):
para itemval em si mesmo.itens selecionados():
# Leia o valor do cabeçalho com base na célula selecionada
sujeito = self.HorizontalHeaderitem (ItemVal.coluna()).texto()
# Imprima as informações detalhadas da marca
print ("\ n", eu.Id_list [itemVal.linha ()], "Got", Itemval.text (), "in", sujeito)
# Crie objeto de aplicativo e execute o aplicativo
app = qapplication (sys.argv)
tabela = tabelafromlist (Marks, 5, 5)
mesa.mostrar()
aplicativo.exec ()

A seguinte janela com a tabela aparecerá depois que o script acima for executado.

Conclusão

Este tutorial mostrou como criar tabelas com dados fixos, dados de dicionário e dados de listar usando dois exemplos. As tabelas também podem ser criadas com dados dinâmicos usando tabelas de banco de dados ou outras fontes de dados.