Você está aqui: Python ::: Matplotlib Python Library (Biblioteca Python Matplotlib) ::: Geração e Plotagem de Gráficos usando Matplotlib

Como gerar o gráfico da função tangente usando a biblioteca Matplotlib do Python

Quantidade de visualizações: 1966 vezes
A função tangente é a razão entre o seno e o cosseno, ou seja, trata-se de uma razão trigonométrica indefinida para os ângulos de 90º e 270º, pois são os valores em que o cosseno é igual a 0, o que geraria uma divisão por 0 (zero).

Diferentemente da função seno e da função cosseno, a imagem da função tangente é o conjunto dos números reais, ou seja, ela não é limitada e não possui valor de máximo nem de mínimo.

Nesta dica mostrarei como podemos usar as capacidades de geração de gráficos da biblioteca Matplotlib da linguagem Python, combinadas com as funções linspace() e tan() da biblioteca NumPy para gerar o gráfico da função tangente.

Antes de vermos o código, observe o resultado gerado na imagem a seguir:



Veja agora o código Python completo para a geração do gráfico:

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

# importamos a biblioteca NumPy
import numpy as np
#importamos a biblioteca Matplotlib
import matplotlib.pyplot as plt
  
def main():
  # definimos o título para a área de plotagem
  plt.title('Gráfico da Função Tangente')
  
  # vamos exibir o grid da área de plotagem
  plt.grid(True)
  
  # vamos gerar 1000 valores igualmente espaçados
  # começando em -2 * np.pi e indo até 2 * np.pi
  x = np.linspace(-2 * np.pi, 2 * np.pi, 1000)

  # agora plotamos o vetor x e a tangente de cada um dos
  # valores desse vetor
  plt.plot(x, np.tan(x))

  # definimos os limites no eixo y
  plt.ylim(-5, 5)
  
  # finalmente exibimos o resultado
  plt.show()
  
if __name__== "__main__":
  main()


Link para compartilhar na Internet ou com seus amigos:

Python ::: Dicas & Truques ::: Programação Orientada a Objetos

Programação orientada a objetos em Python: Classes, objetos, métodos e variáveis de instância - Atualizado

Quantidade de visualizações: 13953 vezes
A melhor forma de entender a programação orientada a objetos (OOP) é começar com uma analogia simples. Suponha que você queira dirigir um carro e fazê-lo ir mais rápido pressionado o acelerador. O que deve acontecer antes que você seja capaz de fazer isso? Bem, antes que você possa dirigir um carro, alguém tem que projetá-lo. Um carro geralmente começa com desenhos feitos pelos engenheiros responsáveis por tal tarefa, tal qual a planta de uma casa. Tais desenhos incluem o projeto de um acelerador que possibilita ao carro ir mais rápido. O pedal do acelerador "oculta" os mecanismos complexos responsáveis por fazer o carro ir mais rápido, da mesma forma que o pedal de freio "oculta" os mecanismos que fazem o carro ir mais devagar e o volante "oculta" os mecanismos que fazem com que o carro possa virar para a direita ou esquerda. Isso permite que pessoas com pequeno ou nenhum conhecimento de motores possam facilmente dirigir um carro.

Infelizmente, não é possível dirigir o projeto de um carro. Antes que possamos dirigí-lo, o carro deve ser construído a partir do projeto que o descreve. Um carro já finalizado tem um pedal de aceleração de verdade, que faz com que o carro vá mais rápido. Ainda assim, é preciso que o motorista pressione o pedal. O carro não acelerará por conta própria.

Agora vamos usar nosso exemplo do carro para introduzir alguns conceitos de programação importantes à programação orientada a objetos. A execução de uma determinada tarefa em um programa exige um método. O método descreve os mecanismos que, na verdade, executam a tarefa. O método oculta tais mecanismos do usuário, da mesma forma que o pedal de aceleração de um carro oculta do motorista os mecanismos complexos que fazem com que um carro vá mais rápido. Em Python, começamos criando uma unidade de programa chamada classe para abrigar um método, da mesma forma que o projeto de um carro abriga o design do pedal de acelerador. Em uma classe fornecemos um ou mais métodos que são projetados para executar as tarefas da classe. Por exemplo, a classe que representa uma conta bancária poderia conter muitos métodos, incluindo um método para depositar dinheiro na conta, outro para retirar dinheiro, um terceiro para verificar o saldo, e assim por diante.

Da mesma forma que não podemos dirigir o projeto de um carro, nós não podemos "dirigir" uma classe. Da mesma forma que alguém teve que construir um carro a partir de seu projeto antes que pudessémos dirigí-lo, devemos construir um objeto de uma classe antes de conseguirmos executar as tarefas descritas nela.

Quando dirigimos um carro, o pressionamento do acelerador envia uma mensagem ao carro informando-o da tarefa a ser executada (neste caso informando-o de que queremos ir mais rápido). Da mesma forma, enviamos mensagens aos objetos de uma classe. Cada mensagem é uma chamada de método e informa ao objeto qual ou quais tarefas devem ser executadas.

Até aqui nós usamos a analogia do carro para introduzir classes, objetos e métodos. Já é hora de saber que um carro possui atributos (propriedades) tais como cor, o número de portas, a quantidade de gasolina em seu tanque, a velocidade atual, etc. Tais atributos são representados como parte do projeto do carro. Quando o estamos dirigindo, estes atributos estão sempre associados ao carro que estamos usando, e cada carro construído a partir do projeto sofrerá variações nos valores destes atributos em um determinado momento. Da mesma forma, um objeto tem atributos associados a ele quando o usamos em um programa. Estes atributos são definidos na classe a partir da qual o objeto é instanciado (criado) e são chamados de variáveis de instância da classe.

Veremos agora como definir uma classe em Python e usar um objeto desta classe em um programa. Veja o trecho de código abaixo:

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

# Definição da classe Cliente 
class Cliente:
  "Minha primeira classe Python"
  # define a propriedade nome
  _nome = None
 
  # um método que permite definir o nome do cliente
  def definir_nome(self, nome):
    self._nome = nome
 
  # um método que permite obter o nome do cliente
  def obter_nome(self):
    return self._nome
# Fim da definição da classe Cliente
 
def main():
  # Cria uma instância da classe Cliente
  cliente = Cliente()
 
  # Define o nome do cliente
  cliente.definir_nome("Osmar J. Silva")
 
  # Obtém o nome do cliente
  print(cliente.obter_nome())

if __name__== "__main__":
  main()

Em mais dicas dessa seção você aprenderá mais sobre a programação orientada a objeto em Python.


Python ::: Desafios e Lista de Exercícios Resolvidos ::: Python Básico

Exercícios Resolvidos de Python - Lendo a idade de um nadador e classificando sua categoria como infantil, juvenil, adolescente, adulto ou sênior

Quantidade de visualizações: 309 vezes
Pergunta/Tarefa:

Escreva um programa Python que solicita a idade de um nadador e classifica sua categoria de acordo com as seguintes regras:

a) De 5 a 7 anos - Infantil;
b) De 8 a 10 anos - Juvenil;
c) De 11 a 15 anos - Adolescente;
d) De 16 a 30 anos - Adulto;
e) Acima de 30 anos - Sênior.

Sua saída deverá ser parecida com:

Informe sua idade: 19
Sua categoria é Adulto
Resposta/Solução:

Veja a resolução comentada deste exercício usando Python:

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

# vamos solicitar a idade do nadador
idade = int(input("Informe sua idade: "))
     
# vamos verificar a categoria do nadador
if ((idade >= 5) and (idade <= 7)):
  print("Sua categoria é Infantil")
elif ((idade >= 8) and (idade <= 10)):  
  print("Sua categoria é Juvenil")  
elif ((idade >= 11) and (idade <= 15)):
  print("Sua categoria é Adolescente") 
elif ((idade >= 16) and (idade <= 30)):
  print("Sua categoria é Adulto")  
elif (idade > 30):
  print("Sua categoria é Sênior")  
else:
  print("Não pertence a nenhuma categoria.")



Python ::: Desafios e Lista de Exercícios Resolvidos ::: Engenharia Civil - Cálculo Estrutural

Exercícios Resolvidos de Python - Como calcular as reações de apoio, momento de flexão máxima e forças cortantes em uma viga bi-apoiada com carga distribuída retangular usando Python

Quantidade de visualizações: 983 vezes
Pergunta/Tarefa:

Veja a seguinte figura:



Nesta imagem temos uma viga bi apoiada com uma carga q distribuída de forma retangular a uma distância l. Para fins didáticos, vamos considerar que a carga q será em kN/m e a distância l será em metros. O apoio A é de segundo gênero e o apoio B é de primeiro gênero.

Escreva um programa Python que solicita ao usuário que informe o valor da carga q e a distância l entre os apoios A e B. Em seguida mostre os valores das reações nos apoios A e B, o momento de flexão máxima da viga e o momento de flexão para uma determinada distância (que o usuário informará) a partir do apoio A.

Mostre também as forças cortantes nos apoios A e B. Lembre-se de que, para uma carga distribuída de forma retangular, o diagrama de momento fletor é uma parábola, enquanto o diagrama de cortante é uma reta (com o valor zero para a força cortante no meio da viga).

Sua saída deve ser parecida com:

Valor da carga em kN/m: 10
Distância em metros: 13

A reação no apoio A é: 65.000000 kN
A reação no apoio B é: 65.000000 kN
O momento fletor máximo é: 211.250000 kN

Informe uma distância a partir do apoio A: 4
O momento fletor na distância informada é: 180.000000 kN

A força cortante no apoio A é: 65.000000 kN
A força cortante no apoio B é: -65.000000 kN
Resposta/Solução:

Veja a resolução comentada deste exercício usando Python:

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

# Algoritmo que calcula reação de apoio, momento fletor
# e força cortante em uma viga bi-apoiada em Python

# vamos importar o módulo Math
import math

# função principal do programa
def main():
  # vamos pedir para o usuário informar o valor da carga
  carga = float(input("Valor da carga em kN/m: "))
  
  # vamos pedir para o usuário informar a distância entre os apoios
  distancia = float(input("Distancia em metros: "))
  
  # vamos calcular a reação no apoio A
  reacao_a = (1.0 / 2.0) * carga * distancia
  
  # vamos calcular a reação no apoio B
  reacao_b = reacao_a
  
  # vamos calcular o momento fletor máximo
  flexao_maxima = (1.0 / 8.0) * carga * math.pow(distancia, 2.0)
  
  # e mostramos o resultado
  print("\nA reação no apoio A é: {0} kN".format(reacao_a))
  print("A reação no apoio B é: {0} kN".format(reacao_b))
  print("O momento fletor máximo é: {0} kN".format(flexao_maxima))
  
  # vamos pedir para o usuário informar uma distância a
  # partir do apoio A
  distancia_temp = float(input("\nInforme uma distância a partir do apoio A: "))
  # vamos mostrar o momento fletor na distância informada
  if distancia_temp > distancia:
    print("\nDistância inválida.")
  else:
    flexao_distancia = (1.0 / 2.0) * carga * distancia_temp * \
      (distancia - distancia_temp)
    print("O momento fletor na distância informada é: {0} kN".format(
      flexao_distancia))  
   
  # vamos mostrar a força cortante no apoio A
  cortante_a = (1.0 / 2.0) * carga * distancia
  print("\nA força cortante no apoio A é: {0} kN".format(cortante_a))
  
  # vamos mostrar a força cortante no apoio B
  cortante_b = cortante_a * -1
  print("A força cortante no apoio B é: {0} kN".format(cortante_b))
  
if __name__== "__main__":
  main()



Mais Desafios de Programação e 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á 70 usuários muito felizes estudando em nosso site.