Você está aqui: Python ::: PyQt GUI Toolkit ::: QMainWindow

Como centralizar uma janela QMainWindow do PyQt

Quantidade de visualizações: 119 vezes
Nesta dica mostrarei como podemos centralizar a janela principal de nossa aplicação PyQt. Note que esta janela principal, na maioria das vezes, é representada por uma instância da classe QMainWindow.

Veja o código completo para o exemplo, já atualizado para o PyQt6:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

# vamos importar os módulos necessários
import sys
from PyQt6.QtCore import *
from PyQt6.QtGui import *
from PyQt6.QtWidgets import *
 
# vamos criar uma classe que herda de QMainWindow
class JanelaPrincipal(QMainWindow):
  # construtor da classe
  def __init__(self):
    super().__init__()
 
    # definimos o título da janela 
    self.setWindowTitle("Cadastro de Produtos")
     
    # vamos definir as dimensões da janela
    self.resize(600, 420)

    # vamos obter a geometria do frame da nossa janela
    geometria_frame = self.frameGeometry()

    # acessamos a geometria da monitor e obtemos seu centro
    ponto_central = self.screen().availableGeometry().center()

    # movemos o retângulo obtido anteriormente para o centro da tela
    geometria_frame.moveCenter(ponto_central)
    
    # e finalmente movemos nossa janela para este ponto
    self.move(geometria_frame.topLeft())

if __name__== "__main__":
  # cria a aplicação
  app = QApplication(sys.argv)
 
  # cria a janela principal e a coloca visível
  janela_principal = JanelaPrincipal()
  janela_principal.show()
 
  # executa a aplicação
  app.exec()


Link para compartilhar na Internet ou com seus amigos:

Python ::: Dicas & Truques ::: Strings e Caracteres

Como testar se uma string contém apenas letras em Python usando a função isalpha()

Quantidade de visualizações: 14778 vezes
Este exemplo mostra como podemos a função isalpha() do Python para verificar se uma string contém apenas letras, ou seja, nada de números, espaços nem pontuação. Se algum número, espaço, um caractere especial ou pontuação estiver contido, a função retorna False.

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

def main():
  # uma palavra contendo apenas letras
  palavra = "Arquivo"

  # a palavra contém apenas letras?
  if palavra.isalpha():
    print("A string contém apenas letras")
  else:
    print("A string não contém somente letras")

if __name__== "__main__":
  main()

Ao executar este código Python nós teremos o seguinte resultado:

A string contém apenas letras.


Python ::: Python para Engenharia ::: Engenharia Civil - Cálculo Estrutural

Como calcular o peso que um pilar aguenta usando Python - Python para Engenharia Civil

Quantidade de visualizações: 192 vezes


O sonho de todo estudante de Engenharia Civil é poder responder, com segurança, a uma das perguntas mais recorrentes no nosso dia-a-dia: Quanto de peso um pilar aguenta?

Para responder, basta nos lembrarmos de que o concreto é muito resistente à compressão, e, no caso dos pilares, a armadura é usada, em sua maior parte, para combater a flambagem, que é quando o pilar tende a fletir para os lados, parecendo-se com um arco ou com uma barriga de chope.

Então, uma vez que o pilar recebe sua carga em seu eixo (carga axial) e o concreto é muito resistente à compressão, só precisamos nos concentrar na resistência característica do concreto à compressão e na área da seção transversal do pilar.

Sempre que falamos de resistência do concreto, nós estamos falando de FCK C15, C20, C25, C30, etc, que são os termos usados para designar sua resistência. Assim, um concreto C25 é o mesmo que 25 MPa, ou seja, esse concreto resiste a 250Kg/cm2.

Os concretos usinados, em geral, vêm com resistência de 25 MPa para cima, enquanto aquele concreto que fazemos na obra, na betoneira, usando a combinação de 3x1, chega no máximo a 15 MPa. Além disso, é importante nos lembrarmos de que a norma NBR 6118/2014 exige que o concreto seja igual ou superior a 25 MPa.

Há também o fator de segurança de 40%, também exigido pela norma NBR 6118/2014. Dessa forma, se o concreto for de 25 MPa, aplicado o fator de segurança, só podemos contar com 15 MPa mais ou menos, o que daria 150Kg/cm2.

Vamos ver código agora? Veja o código Python completo que pede os lados b (base) e h (altura) do pilar e o FCK do concreto usado e retorna o peso que o pilar suporta (já aplicado o fator de segurança):

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

# Algoritmo Python que calcula o peso suportado por um pilar
# dados os seus lados e o FCK do concreto

# função principal do programa
def main():
  # vamos ler o lado b do pilar
  base = float(input("Informe a base (b) do pilar em cm: "))
  # vamos ler a altura h do pilar
  altura = float(input("Informe a altura (h) do pilar em cm: "))

  # vamos calcular a área da seção transversal do pilar
  area = base * altura

  # agora vamos ler o FCK do concreto em MPa
  fck = float(input("Informe o FCK do concreto em MPa: "))

  # vamos calcular o peso suportado pelo pilar
  peso_suportado = area * (fck * 10)
  # vamos aplicar o fator de segurança de 40%
  peso_suportado = peso_suportado / 1.4

  # e mostramos o resultado
  print("A área da seção transversal é: {0} cm2".format(area))
  print("Esse pilar suporta {0} kg".format(peso_suportado))

if __name__== "__main__":
  main()

Ao executar este código Python nós teremos o seguinte resultado:

Informe a base (b) do pilar em cm: 14
Informe a altura (h) do pilar em cm: 26
Informe o FCK do concreto em MPa: 20
A área da seção transversal é: 364.0 cm2
Esse pilar suporta 52000.0 kg

Lembre-se de que a área mínima da seção de um pilar, de acordo com a NBR 6118/2014 é de 360 cm2.


Python ::: Fundamentos da Linguagem ::: Passos Iniciais

Como usar os argumentos padrões das funções em Python

Quantidade de visualizações: 7235 vezes
Geralmente quando efetuamos chamadas às funções, nosso código fica responsável por fornecer os valores para os argumentos da função. Em Python é possível termos argumentos padrões, e tais argumentos já podem ter um valor pré-definido. Desta forma, a passagem dos parâmetros se torna opcional. Veja um exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

# função com argumento padrão
def erro(msg = "Houve um erro."):
  print msg

# chamada à função fornecendo o argumento
erro("Erro desconhecido.")

# chamada à função sem fornecer o argumento
erro()

Veja mais um exemplo:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

# função com argumentos padrões
def volume(comprimento = 1, largura = 1, altura = 1):
  return (comprimento * largura * altura)

# chamada à função fornecendo um argumento
print volume(3)

# chamada à função fornecendo dois argumentos
print volume(4, 5)

# chamada à função fornecendo três argumentos
print volume(4, 5, 7)

# chamada à função fornecendo nenhum argumento
print volume()

É importante observar que os argumentos padrões devem estar sempre à direita dos demais argumentos. Falhar em cumprir esta exigência pode causar um erro do tipo:

SyntaxError: non-default argument follows default argument


Desafios, Exercícios e Algoritmos Resolvidos de Python

Veja mais Dicas e truques de Python

Dicas e truques de outras linguagens

Códigos Fonte

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e FornecedoresSoftware de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais
Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesControle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: C
6º lugar: Delphi
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



© 2025 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 26 usuários muito felizes estudando em nosso site.