Polígonos em Código

Sobre a Matemática

Polígono é a região do plano limitado por um poligonal fechada, ou ainda, a figura formada pela união dos n segmentos consecutivos.

Um polígono tem vértices, ângulos, lados, diagonais e ângulos externos.

Existem dois tipos de polígonos, os côncavos e os convexos, mas para classificação e estudo, serão demonstrados aqui os polígonos convexos.

Um polígono é convexo quando estiver todo contido num mesmo semiplano, determinado pela reta suporte de qualquer um dos seus lados.

Região poligonal é a união do polígono com o seu interior.

Ângulo externo de um polígono é aquele formado por um dos lados e o prolongamento de um dos lados adjacentes.

Quando à nomenclatura, os polígonos se classificam: pelo número de ângulos e de lados.

Para os demais, dizemos polígonos de n lados.

Quanto à classificação dizemos que um polígono é:

a) equilátero: aquele que tem lados congruentes (losango, quadrado, etc.);

b) equiângulo: aquele que tem ângulos congruentes (retângulo, quadrado, etc.);

c) regular: aquele que é ao mesmo tempo equilátero e equiângulo (quadrado).

Sobre o Código

Na linguagem de programação Python,

import – é o comando usado para trazer bibliotecas externas para o código.

numpy – é a biblioteca numérica usada para cálculos matemáticos e vetoriais.

as np – cria um apelido para a biblioteca (np), facilitando o uso.

matplotlib – é a biblioteca para criação de gráficos.

.pyplot – é o módulo do matplotlib que contém funções de plotagem.

as plt – é o apelido para pyplot, usado para simplificar comandos.

{} – define um dicionário (estrutura de pares chave:valor).

class – é a palavra-chave para criar uma classe (modelo de objeto).

def – define uma função ou método dentro da classe.

__init__ – é o método construtor: executa automaticamente ao criar um objeto.

self – é a referência ao próprio objeto dentro da classe.

np.linspace() – gera valores igualmente espaçados entre dois limites.

np.pi – é a constante π (3.14159…).

endpoint= – é o parâmetro que define se o último valor deve ser incluído.

np.cos() – calcula o cosseno de um ângulo.

.sin() – calcula o seno de um ângulo.

for – inicia um laço de repetição.

in – indica o conjunto a ser percorrido no loop.

return – envia um valor de volta para quem chamou a função.

range() – gera uma sequência de números inteiros.

len() – retorna o tamanho de uma lista ou sequência.

np.array() – converte listas em arrays NumPy (mais rápidos e matemáticos).

.append() – adiciona um elemento ao final de uma lista.

np.sign – retorna o sinal de um número: -1, 0 ou +1.

!= – é o operador “diferente de”.

all() – retorna True se todos os elementos de um iterável forem True.

zip() – junta listas em pares (ou tuplas) correspondentes.

plt.figure() – cria uma nova figura para o gráfico.

figsize= – define o tamanho da figura (largura, altura).

plt.plot() – desenha linhas e pontos no gráfico.

plt.title() – define o título do gráfico.

f-string – é a forma moderna de formatar strings usando f”texto {variável}”.

plt.axis() – controla os eixos do gráfico (ex.: “equal”).

plt.grid() – ativa a grade no gráfico.

plt.show() – exibe o gráfico na tela.

__name__ – é a variável interna que indica como o arquivo está sendo executado.

__main__ – é o valor de __name__ quando o arquivo é executado diretamente.

if – é a estrutura condicional (“se”).

else – é a parte alternativa da condição (“senão”).

.plotar() – é a chamada do método plotar() do objeto criado.

# – é usado para criar comentários ao código, que são notas para se entender melhor o que o código faz.

Vamos ao código…

import numpy as np
import matplotlib.pyplot as plt

# ---------------------------------------------------------
# Dicionário de nomes dos polígonos
# ---------------------------------------------------------
nomes_poligonos = {
    3: ("triângulo", "trilátero"),
    4: ("quadrângulo", "quadrilátero"),
    5: ("pentágono", "pentalátero"),
    6: ("hexágono", "hexalátero"),
    7: ("heptágono", "heptalátero"),
    8: ("octógono", "octalátero"),
    9: ("eneágono", "enelátero"),
    10: ("decágono", "decalátero"),
    11: ("undecágono", "undecalátero"),
    12: ("dodecágono", "dodecalátero"),
    15: ("pentadecágono", "pentadecalátero"),
    20: ("icoságono", "icosalátero")
}

# ---------------------------------------------------------
# Classe Polígono
# ---------------------------------------------------------
class Poligono:
    def __init__(self, n_lados, raio=1):
        self.n = n_lados
        self.raio = raio
        self.vertices = self._gerar_vertices()

    def _gerar_vertices(self):
        angulos = np.linspace(0, 2*np.pi, self.n, endpoint=False)
        return [(self.raio * np.cos(a), self.raio * np.sin(a)) for a in angulos]

    def angulo_externo(self):
        return 360 / self.n

    def eh_convexo(self):
        """Verifica convexidade usando produto vetorial."""
        sinais = []
        v = self.vertices

        for i in range(len(v)):
            p1 = np.array(v[i])
            p2 = np.array(v[(i + 1) % self.n])
            p3 = np.array(v[(i + 2) % self.n])

            a = p2 - p1
            b = p3 - p2

            cross = a[0] * b[1] - a[1] * b[0]
            sinais.append(np.sign(cross))

        sinais = [s for s in sinais if s != 0]

        return all(s == sinais[0] for s in sinais)

    def nome(self):
        return nomes_poligonos.get(self.n, (f"{self.n}-gono", f"{self.n}-látero"))

    def plotar(self):
        x, y = zip(*(self.vertices + [self.vertices[0]]))

        plt.figure(figsize=(6, 6))
        plt.plot(x, y, marker='o')
        plt.title(f"Polígono de {self.n} lados — {self.nome()[0]}")
        plt.axis("equal")
        plt.grid(True)
        plt.show()

# ---------------------------------------------------------
# Exemplo de uso
# ---------------------------------------------------------
if __name__ == "__main__":
    n = 7  # escolha o número de lados
    p = Poligono(n)

    print("Nome:", p.nome()[0])
    print("Nome alternativo:", p.nome()[1])
    print("Ângulo externo:", p.angulo_externo(), "graus")
    print("É convexo:", "Sim" if p.eh_convexo() else "Não")

    p.plotar()

Saída do código (valor de retorno)…

Nome: heptágono
Nome alternativo: heptalátero
Ângulo externo: 51.42857142857143 graus
É convexo: Sim

Fonte:

• Editora Didática Paulista. Ensino Didático 2000: Ensino Fundamental e Ensino Médio. Sorocaba: Editora Didática Paulista, [s.d.].
• Códigos e comentários gerados por Microsoft Copilot com revisão nossa.
• https://docs.python.org/pt-br/3/ [Documentação Oficial do Python]