A Moda é uma medida de tendência central que indica o valor ou valores que ocorrem com maior frequência em um conjunto de dados. Ela é particularmente útil em algumas situações em que os dados são categóricos ou possuem distribuições não simétricas.



A quantidade de valores modais que uma série estatística pode apresentar é:

Amodal Quando nenhum valor se repete; não há um valor com frequência máxima.
Unimodal Quando um valor se repete; apenas um valor apresenta frequência igual à frequência máxima.
Bimodal Quando dois valores se repetem; dois valores apresentam frequência igual à frequência máxima.
Trimodal Quando três valores se repetem; três valores apresentam frequência igual à frequência máxima.
Multimodal
ou
Plurimodal		 Mais do que três valores se repetem; mais de três valores apresentam frequência igual à frequência máxima.

 Quando usar a moda?

  • Dados categóricos: É a única medida aplicável diretamente. Por exemplo, para saber qual o produto mais vendido em uma loja.
  • Distribuições assimétricas ou com frequências muito diferentes: A moda pode ser mais informativa do que a média nesses casos.
  • Análise exploratória: Identificar padrões ou valores comuns.

Dados agrupados SEM intervalos de classe

Fórmula:

Python : 

''' A partir de uma lista '''
M = list(set([x for x in lista if lista.count(x) == max([lista.count(y) for y in lista])]))

''' A partir de um dicionário '''
M = list(k for k, v in dicionario.items() if v == max(list(dicionario.values())))[0]

Julia : 

" A partir de um vetor "

M = unique([x for x in valor if count(y -> y == x, valor) == maximum(count(y -> y == z, valor) for z in valor)])

" A partir de um dicionário"

# Transformando o vetor em um dicionário
dicionario = Dict(v => count(x -> x == v, valor) for v in unique(valor))

# Encontra as chaves com o maior valor
M = [k for (k, v) in dicionario if v == maximum(values(dicionario))]

" A partir de um dicionário, criando criando dois vetores, contendo os valores e suas frequências "

# Caso o conjunto de dados tenha mais de uma moda, esse método não é recomendado, pois só exibirá um valor, o primeiro. 

valor = collect(keys(dicionario))
freq = collect(values(dicionario))

valor[argmax(freq)]

Libs:

Linguagem Biblioteca Função
Python Statistics st.mode(values)
Scipy.stats sc.mode(values, keepdims=False)
Julia Statistics
Retorna o valor mais frequente no vetor:
mode(values)

Se tiver um empate no valor mais frequente, retorna todos ambos os valores empatados:
modes(values)
StatsBase


Exemplos

Determine o valor da moda da distribuição de frequências dadas a seguir, que representa a relação das notas dos alunos da turma A da disciplina de Estatística e Probabilidade.

Notas Frequências
31
44
56
69
710
89
95
106
Total50

A tabela apresenta na segunda coluna a frequência que os dados se repetem. Obviamente, como as frequências estão descritas, percebe-se que o valor que mais se repete (10 vezes ao todo), é o número 7, portanto, a moda dos dados é o número 7.

Mas, caso seja necessário usar fórmulas para encontrar os valores, por exemplo, se esse conjunto de dados fosse muito grande, o que tornaria essa tarefa um tanto difícil, as fórmulas que poderiam ser usadas são descritas abaixo.

 Python

''' A partir de um dicionário - Sem o uso de bibliotecas '''
dicionario = {3:1, 4:4, 5:6, 6:9, 7:10, 8:9, 9:5, 10:6}

M = list(k for k, v in dicionario.items() if v == max(list(dicionario.values())))[0]

# RESULTADO -> 7

''' A partir de uma lista - Sem o uso de bibliotecas '''
lista = [3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10]

M = list(set([x for x in lista if lista.count(x) == max([lista.count(y) for y in lista])]))

Julia

" Sem o uso de bibliotecas "
valor = [3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10]

M = unique([x for x in valor if count(y -> y == x, valor) == maximum(count(y -> y == z, valor) for z in valor)])


Dados agrupados COM intervalos de classe

Moda Bruta

A Moda Bruta é a maneira mais simples de determinar a moda em uma tabela de frequência agrupada. A moda bruta é simplesmente o ponto médio da classe modal, ou seja, a classe que contém a maior frequência.

Fórmula:

$$\large M_b = \frac{L_s + l_i}{2}$$

Sendo:

  • $Mb:$ Moda bruta
  • $L_{i}:$ limite inferior da classe modal (de maior frequência)
  • $L_{s}:$ limite superior da classe modal (de maior frequência)

Python : 

# Criando uma lista com a frequência acumulada
lista = list(dicio.values())
fa = list(map(lambda x: sum(lista[:x+1]), range(len(lista))))
# Número de frequẽncias dividido por 2 (p)
n = sum(dicio.values())
p = n / 2
# Intervalo de classe a qual pertence a mediana a partir do p
num_fa = list(s for s in fa if s == p or s > p)[0]
interval = list(dicio.keys())[fa.index(num_fa)].split(' - ')
# Limite inferior da classe mediana (li)
li = float(interval[0])
# Limite superior da classe mediana (ls)
ls = float(interval[1])
# Calculando a Moda Bruta
Mb = (ls + li) / 2

Julia : 

# Criando um vetor com as frequências acumuladas
fa = cumsum(frequencias)
# Metade das frequências
p = sum(frequencias) / 2
# Intervalo de classe a qual pertence a mediana a partir do p
num_fa = [s for s in fa if s == p || s > p][1]
interval = split(intervalos[findfirst(x -> x == num_fa, fa)], " - ")
# Limite inferior da classe mediana (li)
li = parse(Float64, interval[1])
# Limite superior da classe mediana (ls)
ls = parse(Float64, interval[2])
# Calculando a Moda Bruta
Mb = (ls + li) / 2

Método de Czuber

O Método de Czuber refina a moda utilizando o conceito de interpolação linear, levando em consideração não só a classe modal, mas também as frequências das classes adjacentes.

Fórmula:

$$\large M_c = l_i + \frac{h \cdot (f_{max} – f_{ant})}{2 \cdot f_{max} – (f_{ant}+f_{post})}$$

Sendo:

  • $M_{c}:$ Método de Czuber
  • $L_{i}:$ limite inferior da classe modal (de maior frequência)
  • $h:$ amplitude total
  • $f_{max}:$ frequência máxima
  • $f_{ant}:$ frequência imediatamente anterior à frequência máxima
  • $f_{post}:$ frequência imediatamente posterior à frequência máxima

Python : 

# Criando uma lista com a frequência acumulada
lista = list(dicio.values())
fa = list(map(lambda x: sum(lista[:x+1]), range(len(lista))))
# Número de frequẽncias dividido por 2 (p)
n = sum(dicio.values())
p = n / 2
# Intervalo de classe a qual pertence a mediana a partir do p
num_fa = list(s for s in fa if s == p or s > p)[0]
interval = list(dicio.keys())[fa.index(num_fa)].split(' - ')
# Limite inferior da classe mediana (li)
li = float(interval[0])
# Amplitude de classe (h)
h = ls - li
# Maior frequência
f_max = max(dicio.values())
# Frequência imediatamente anterior à frequência máxima (f_ant)
f_ant = list(dicio.values())[fa.index(num_fa) - 1]
# Frequência imediatamente posterior à frequência máxima (f_post)
f_post = list(dicio.values())[fa.index(num_fa) + 1]
# Calculando a Moda pelo Método de Czuber
Mc = li + ((h * (f_max - f_ant)) / (2 * f_max - (f_ant + f_post)))

Julia : 

# Criando um vetor com as frequências acumuladas
fa = cumsum(frequencias)
# Metade das frequências
p = sum(frequencias) / 2
# Intervalo de classe a qual pertence a mediana a partir do p
num_fa = [s for s in fa if s == p || s > p][1]
interval = split(intervalos[findfirst(x -> x == num_fa, fa)], " - ")
# Limite inferior da classe mediana (li)
li = parse(Float64, interval[1])
# Amplitude de classe (h)
h = ls - li
# Maior frequência
f_max = maximum(frequencias)
# Frequência imediatamente anterior à frequência máxima (f_ant)
f_ant = frequencias[findfirst(x -> x == num_fa, fa) - 1]
# Frequência imediatamente posterior à frequência máxima (f_post)
f_post = frequencias[findfirst(x -> x == num_fa, fa) + 1]
# Calculando a Moda pelo Método de Czuber
Mc = li + ((h * (f_max - f_ant)) / (2 * f_max - (f_ant + f_post)))

Método de King

O Método de King oferece outro ajuste para calcular a moda, priorizando diferenças relativas entre as frequências das classes modal e adjacentes.

Fórmula:

$$\large M_k = li +\frac{h \cdot f_{post}}{f_{ant}+f_{post}}$$

Sendo:

  • $M_{k}:$ Método de King
  • $L_{i}:$ limite inferior da classe modal (de maior frequência)
  • $h:$ amplitude total
  • $f_{ant}:$ frequência imediatamente anterior à frequência máxima
  • $f_{post}:$ frequência imediatamente posterior à frequência máxima

Python : 

# Criando uma lista com a frequência acumulada
lista = list(dicio.values())
fa = list(map(lambda x: sum(lista[:x+1]), range(len(lista))))
# Número de frequẽncias dividido por 2 (p)
n = sum(dicio.values())
p = n / 2
# Intervalo de classe a qual pertence a mediana a partir do p
num_fa = list(s for s in fa if s == p or s > p)[0]
interval = list(dicio.keys())[fa.index(num_fa)].split(' - ')
# Limite inferior da classe mediana (li)
li = float(interval[0])
# Limite superior da classe mediana (ls)
h = ls - li
# Frequência imediatamente anterior à frequência máxima (f_ant)
f_ant = list(dicio.values())[fa.index(num_fa) - 1]
# Frequência imediatamente posterior à frequência máxima (f_post)
f_post = list(dicio.values())[fa.index(num_fa) + 1]
# Calculando a Moda pelo Método de King
Mk = li + ((h * f_post) / (f_ant + f_post))

Julia : 

# Criando um vetor com as frequências acumuladas
fa = cumsum(frequencias)
# Metade das frequências
p = sum(frequencias) / 2
# Intervalo de classe a qual pertence a mediana a partir do p
num_fa = [s for s in fa if s == p || s > p][1]
interval = split(intervalos[findfirst(x -> x == num_fa, fa)], " - ")
# Limite inferior da classe mediana (li)
li = parse(Float64, interval[1])
# Limite superior da classe mediana (ls)
h = ls - li
# Frequência imediatamente anterior à frequência máxima (f_ant)
f_ant = frequencias[findfirst(x -> x == num_fa, fa) - 1]
# Frequência imediatamente posterior à frequência máxima (f_post)
f_post = frequencias[findfirst(x -> x == num_fa, fa) + 1]
# Calculando a Moda pelo Método de King
Mk = li + ((h * f_post) / (f_ant + f_post))

Exemplos

Determine a idade modal das 70 pessoas adultas que se pesaram no mesmo dia, na balança de uma farmácia. Calcule a moda bruta, a moda pelo método de Czuber e a moda pelo método de King, com base nos dados a seguir.

Notas Frequências
59.0 – 61.53
61.5 – 64.05
64.0 – 66.55
66.5 – 69.07
69.0 – 71.59
71.5 – 74.011
74.0 – 76.58
76.5 – 79.07
79.0 – 81.55
81.5 – 84.06
84.0 – 86.54

Python

dicio ={'59.0 - 61.5':3,'61.5 - 64.0':5,'64.0 - 66.5':5,'66.5 - 69.0':7,
       '69.0 - 71.5':9,'71.5 - 74.0':11,'74.0 - 76.5':8,'76.5 - 79.0':7,
       '79.0 - 81.5':5,'81.5 - 84.0':6,'84.0 - 86.5':4}

lista = list(dicio.values())
fa = list(map(lambda x: sum(lista[:x+1]), range(len(lista))))
n = sum(dicio.values())
p = n / 2
num_fa = list(s for s in fa if s == p or s > p)[0]
interval = list(dicio.keys())[fa.index(num_fa)].split(' - ')
li = float(interval[0])
ls = float(interval[1])
h = ls - li
f_max = max(dicio.values())
f_ant = list(dicio.values())[fa.index(num_fa) - 1]
f_post = list(dicio.values())[fa.index(num_fa) + 1]

''' Moda bruta '''
mb = (ls + li) / 2

''' Método de Czuber '''
mc = li + ((h * (f_max - f_ant)) / (2 * f_max - (f_ant + f_post)))

''' Método de King '''
mk = li + ((h * f_post) / (f_ant + f_post))

RES = 'RESULTADOS'
print(RES.center(36, '*'))
print(f'Moda bruta : {mb}')
print(f'Método de Czuber : {mc}')
print(f'Método de King : {mk}')

# *************RESULTADOS*************
# Moda bruta : 72.75
# Método de Czuber : 72.5
# Método de King : 72.67647058823529

Julia

intervalos = ["59.0 - 61.5","61.5 - 64.0","64.0 - 66.5","66.5 - 69.0","69.0 - 71.5","71.5 - 74.0","74.0 - 76.5","76.5 - 79.0","79.0 - 81.5","81.5 - 84.0","84.0 - 86.5"]
frequencias = [3, 5, 5, 7, 9, 11, 8, 7, 5, 6, 4]

fa = cumsum(frequencias)
p = sum(frequencias) / 2
num_fa = [s for s in fa if s == p || s > p][1]
interval = split(intervalos[findfirst(x -> x == num_fa, fa)], " - ")
li = parse(Float64, interval[1])
ls = parse(Float64, interval[2])
h = ls - li
f_max = maximum(frequencias)
f_ant = frequencias[findfirst(x -> x == num_fa, fa) - 1]
f_post = frequencias[findfirst(x -> x == num_fa, fa) + 1]

Mb = (ls + li) / 2
Mc = li + ((h * (f_max - f_ant)) / (2 * f_max - (f_ant + f_post)))
Mk = li + ((h * f_post) / (f_ant + f_post))