Você está aqui: Python ::: Matplotlib Python Library (Biblioteca Python Matplotlib) ::: Área de Plotagem do Matplotlib

Matplotlib Python - Como definir os rótulos para os eixo-x e eixo-y da área de plotagem do Matplotlib

Quantidade de visualizações: 3261 vezes
Uma das exigências que todo gráfico no Matplotlib exige é o rótulo que facilita o entendimento dos valores nos eixos x e y da plotagem. Sem os rótulos ficaremos dependentes de explicações em documentações ou algo assim.

Os rótulos para os eixos x e y podem ser definidos por meio das funções xlabel() e ylabel() do objeto pyplot da biblioteca Matplotlib. Comece observando a imagem a seguir:



Note que o eixo-x representa a temperatura e o eixo-y representa o tempo. É importante observar que podemos definir também a cor e o tamanho da fonte dos rótulos, mas isso mostramos em outra dica dessa seção.

E agora veja o código Python completo para este exemplo:

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

import matplotlib.pyplot as plt

def main():
  # eixo-x inicial e final
  x1 = -15
  x2 = 15

  # eixo-y inicial e final
  y1 = -15
  y2 = 15 
  
  # construímos os eixos
  plt.axis([x1, x2, y1, y2])

  # "ligamos" a área de plotagem
  plt.axis('on')

  # vamos exibir o grid da área de plotagem
  plt.grid(True)

  # define o rótulo para o eixo-x
  plt.xlabel('Tempo (Segundos)')

  # define o rótulo par ao eixo-y
  plt.ylabel('Temperatura (Celsius)')

  # finalmente exibimos o resultado
  plt.show()

if __name__== "__main__":
  main()


Link para compartilhar na Internet ou com seus amigos:

Python ::: Python para Engenharia ::: Geometria Analítica e Álgebra Linear

Como calcular o determinante de uma matriz 3x3 usando a Método de Sarrus em Python - Python para Álgebra Linear

Quantidade de visualizações: 5140 vezes
Os estudos da Geometria Analítica e Álgebra Linear envolvem, em boa parte de seus cálculos, a magnitude de vetores, ou seja, o módulo, tamanho, comprimento ou intensidade dos vetores. E isso não é diferente em relação às matrizes.

Quando uma matriz é envolvida nos cálculos, com muita frequência precisamos obter o seu determinante, que nada mais é que um número real associado à todas as matrizes quadradas.

Nesta dica mostrarei como obter o determinante de uma matriz quadrada de ordem 3, ou seja, três linhas e três colunas, usando o Método de Sarrus (somente matrizes 3x3). Note que é possível obter o mesmo resultado com o Teorema de Laplace, que não está restrito às matrizes quadradas de ordem 3. Veja também que não considerei as propriedades do determinante, o que, em alguns casos, simplifica muito os cálculos.

Então, vamos supor a seguinte matriz 3x3:



O primeiro passo é copiarmos a primeira e a segunda colunas para o lado direito da matriz. Assim:



Agora dividimos a matriz em dois conjuntos: três linhas diagonais descendentes e três linhas diagonais ascendentes:



Agora é só efetuar cálculos. Multiplicamos e somamos os elementos de cada conjunto, subtraindo o segundo conjunto do primeiro. Veja:

(1 x 5 x 9 + 2 x 6 x 7 + 3 x 4 x 8) - (7 x 5 x 3 + 8 x 6 x 1 + 9 x 4 x 2) = 0

Como podemos ver, o determinante dessa matriz é 0.

E agora veja o código Python no qual declaramos e instanciamos uma matriz 3x3, em seguida, calculamos o seu determinante:

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

# importamos a bibliteca NumPy
import numpy as np

# função principal do programa
def main():
  # vamos criar uma matriz 3x3
  m = np.array([(1, 2, 3), (2, 5, 2), (1, 3, 1)])
  
  # calcula o determinante usando a Regra de Sarrus
  det = ((m[0][0] * m[1][1] * m[2][2]) + (m[0][1]  
    * m[1][2] * m[2][0]) + (m[0][2] * m[1][0] * m[2][1])) - ((m[2][0] 
    * m[1][1] * m[0][2]) + (m[2][1]  * m[1][2] * m[0][0]) + (m[2][2] 
    * m[1][0] * m[0][1]))
    
  # mostramos o resultado
  print("O determinante da matriz é: %f" % det)
  
if __name__== "__main__":
  main()

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

O determinante da matriz é: 2.0

É possível também obter o determinante de uma matriz (não restrita à dimensão 3x3) usando o método linalg.det() da biblioteca NumPy do Python. Veja o código a seguir:

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

# importamos a bibliteca NumPy
import numpy as np

# função principal do programa
def main():
  # vamos criar uma matriz 3x3
  m = np.array([(1, 2, 3), (2, 5, 2), (1, 3, 1)])
  
  # calcula o determinante usando apenas NumPy
  det = np.linalg.det(m)
    
  # mostramos o resultado
  print("O determinante da matriz é: %f" % det)
  
if __name__== "__main__":
  main()

Veja que usei a mesma matriz e, usando apenas o método linalg.det() nós obtemos o mesmo resultado.


Python ::: Dicas & Truques ::: Lista (List)

Como adicionar itens ao final de uma lista de inteiros em Python usando a função append()

Quantidade de visualizações: 8478 vezes
O método append() é usado quando queremos adicionar um novo elemento no final de uma list Python. Esta função aceita qualquer tipo de elemento, ou seja, uma string, um number, um object, etc.

Veja um exemplo de seu uso no trecho de código a seguir:

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

"""
  Este exemplo mostra como adicionar itens ao
  fim de uma lista de inteiros.
"""
def main():
  # cria uma lista vazia
  valores = []

  # início do laço for
  for i in range(1, 6):
    valor = int(input("Informe um inteiro: "))

    # insere o valor no final da lista
    valores.append(valor)

  # exibe os valores da lista
  print("Valores na lista:", valores, "\n")
    
if __name__== "__main__":
  main()

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

Informe um inteiro: 7
Informe um inteiro: 2
Informe um inteiro: 9
Informe um inteiro: 3
Informe um inteiro: 6
Valores na lista: [7, 2, 9, 3, 6]


Python ::: PyQt GUI Toolkit ::: QPushButton

Como criar um botão em Python PyQt usando a classe QPushButton

Quantidade de visualizações: 1125 vezes
Os botões QPushButton são os controles mais básicos e comuns em aplicações GUI PyQt. Eles são criados a partir da classe QPushButton. Veja a sua posição na hierarquia de classes dos PyQt:

QObject, QPaintDevice
  QWidget
    QAbstractButton
      QPushButton
        QCommandLinkButton


Veja um trecho de código no qual criamos um botão QPushButton e o colocamos em uma janela QWidget:

----------------------------------------------------------------------
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 *

# método que mostrará a janela principal
def mostrar_janela_principal():
  # cria uma instância da classe QApplication
  app = QApplication(sys.argv)
  
  # criamos a janela principal
  janela = QWidget()
  
  # definimos o título da janela
  janela.setWindowTitle("Cadastro de Clientes")
  
  # definimos as coordenadas e as dimensões da janela
  janela.setGeometry(100, 100, 500, 300)

  # vamos criar um botão QPushButton
  botao = QPushButton("Cadastrar", janela)
  
  # definimos a localização do botão 
  botao.move(10, 10)

  # tornamos a janela visível 
  janela.show()

  # e executamos a aplicação
  sys.exit(app.exec())

if __name__== "__main__":
  mostrar_janela_principal()

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




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á 61 usuários muito felizes estudando em nosso site.