Separatrizes são medidas numéricas usadas na estatística descritiva para dividir um conjunto de dados ordenados de forma igualitária, com o objetivo de facilitar a leitura e interpretação da distribuição dos dados. As principais separatrizes são a mediana, os quartis, os decis e os percentis.


Mediana, Quartis, Decis e Percentis

Mediana (2º quartil): divide a série de dados estatísticos em duas partes iguais, 50% dos dados para cada um dos lados do valor da mediana.

Quartis: dividem a série de dados estatísticos em quatro partes iguais, cada uma das quais contendo 25% dos dados. 
Quartis: (100 / 4 | 1º, 2º e 3º quartis (Q1, Q2, Q3))

Decis: dividem a série de dados estatísticos em dez partes iguais, cada uma das quais contendo 10% dos dados. 
Decis: (100 / 10 | 1º a 10º decis (D1 ... D10))

Percentis: dividem a série de dados estatísticos em cem partes iguais, cada uma das quais contendo 1% dos dados. 
Percentis: (100 / 100 | 1º a 100º percentil (P1 ... P100))

Dados NÃO agrupados

Fórmula:

$$\large QDP = V_{P} + P_{D} \cdot (V_{P1} – V_{P})$$

Sendo:

  • $QDP:$ valores dos quartis, dos decis e dos percentis.
  • $V_{P}:$ valor da posição “P” do dado na série da base escolhida.
  • $V_{P1}:$ valor da posição “P + 1”, a posição seguinte à posição “P” do dado na série da base escolhida.
  • $P_{D}:$ parte decimal do cálculo resultante da aplicação das fórmulas matemáticas que determinam os pontos de “corte” dos valores das séries de dados.

Python : 
N = len(values)

#Encontrando o percentil n, a proporção n do conjunto de dados
'QUARTIS'
pn = (n * (N - 1)) / 4
'DECIS'
pn = (n * (N - 1)) / 10
'PERCENTIS'
pn = (n * (N - 1)) / 100

# Valor inteiro do percentil n (pn).
trunc = int(pn)
# Fração da distância entre as posições P e P+1 que deve ser percorrida para chegar à posição exata da separatriz.
PD = pn - trunc
# Valor na posição inferior ao valor da separatriz dentro do conjunto de dados ordenado.
VP = lista[trunc]
# Valor na posição superior ao valor da separatriz dentro do conjunto de dados ordenado.
VP1 = lista[trunc + 1]
# Cálculo da separatriz
QDP = VP + PD * (VP1 - VP)

Julia : 

" N - 1 "
N = length(values)
comp = 1

# Encontrando o percentil n, a proporção n do conjunto de dados
"QUARTIS"
pn = (n * (N - 1)) / 4
"DECIS"
pn = (n * (N - 1)) / 10
"PERCENTIS"
pn = (n * (N - 1)) / 100

# Valor inteiro do percentil n (pn).
trunc = Int.(floor.(pn))
# Fração da distância entre as posições P e P+1 que deve ser percorrida para chegar à posição exata da separatriz.
PD = round.(pn - trunc, digits=2)
# Valor na posição inferior ao valor da separatriz dentro do conjunto de dados ordenado.
VP = sort(nums)[trunc .+ comp]
# Valor na posição superior ao valor da separatriz dentro do conjunto de dados ordenado.
VP1 = sort(nums)[trunc .+ (comp + 1)]
# Cálculo da separatriz
Q = VP + PD .* (VP1 - VP)

" N + 1 "
N = length(values)
comp = 0

# Encontrando o percentil n, a proporção n do conjunto de dados
"QUARTIS"
pn = (n * (N + 1)) / 4
"DECIS"
pn = (n * (N + 1)) / 10
"PERCENTIS"
pn = (n * (N + 1)) / 100

# Valor inteiro do percentil n (pn).
trunc = Int.(floor.(pn))
# Fração da distância entre as posições P e P+1 que deve ser percorrida para chegar à posição exata da separatriz.
PD = round.(pn - trunc, digits=2)
# Valor na posição inferior ao valor da separatriz dentro do conjunto de dados ordenado.
VP = sort(nums)[trunc .+ comp]
# Valor na posição superior ao valor da separatriz dentro do conjunto de dados ordenado.
VP1 = sort(nums)[trunc .+ (comp + 1)]
# Cálculo da separatriz
Q = VP + PD .* (VP1 - VP)

Libs:

Linguagem Biblioteca Função
Python Statistics
st.quantiles(dados, n=[quartil, decil, percentil], method=['inclusive', 'exclusive'])

    n:
      quartil = 4 | decil = 10 | percentil = 100
    method:
      ‘inclusive’ = N – 1 | ‘Exclusive’ = N + 1
Numpy (Quartil)
np.quantile(dados, p, method=['linear', 'weibull' ])
    p:
      • 0.25 | 0.5 | 0.75
    method:
      • linear = N – 1 | weibull = N + 1
Numpy (Decil e Percentil)
np.quantile(dados, p, method=['linear', 'weibull'])
    p:
      • Se for decil, multiplicar o valor que se quer encontrar por 10.
      • Se for percentil, somente colocar o valor que se quer encontrar.
    method:
      • linear = N – 1 | weibull = N + 1
Julia Statistics
quantile(dados, p)

    p:
      • 0.25 | 0.5 | 0.75
      • Se for decil, usar um múltiplo percentual de 10, por exemplo, 40 -> 0.40.
      • Se for percentil, usar o número percentual inteiro, por exemplo, 63 -> 0.63.
StatsBase
    Quartis:
quantile(dados)

    Decis e Percentis:
quantile( dados, [n * 0.01] )
    Decis e Percentis:
percentile(dados, [n])

nquantile(dados, n)

    n: 4 | 10 | 100
      • Para qualquer n usado, a contagem do elemento deve iniciar a partir do segundo número, por exemplo, se o percentil procurado for o 32, deve-se colocar 33, como mostrado abaixo.

nquantile(dados, 100)[33]

Exemplos

A partir da série: 10, 13, 11, 18, 7, 12, 15, 5, 21, 11, 9, 25, 13, 7, 25 e 22, determine os valores dos:

  • a) Três quartis.
  • b) Quarto e sétimo decis.
  • c) Trigésimo segundo e septuagésimo sexto percentis.
Base N – 1
05
17
27
39
410
511
611
712
813
913
1015
1118
1221
1322
1425
1525
Base N + 1
15
27
37
49
510
611
711
812
913
1013
1115
1218
1321
1422
1525
1625

Python

''' Sem o uso de bibliotecas '''
lista = [10, 13, 11, 18, 7, 12, 15, 5, 21, 11, 9, 25, 13, 7, 25, 22]

# listas com os resultados
listaq = []
listad = []
listap = []

# ordenando os elementos
lista = sorted(lista)

# encontrando o N
N = len(lista)

# a) calculando os quartis
for n in range(1, 4):
    kq = (n * (N - 1)) / 4
    trunc = int(kq)
    PD = kq - trunc
    VP = lista[trunc]
    VP1 = lista[trunc + 1]

    Q = VP + PD * (VP1 - VP)
    listaq.append(Q)

# b) calculando os decis
for n in [4, 7]:
    kq = (n * (N - 1)) / 10
    trunc = int(kq)
    PD = kq - trunc
    VP = lista[trunc]
    VP1 = lista[trunc + 1]

    D = VP + PD * (VP1 - VP)
    listad.append(D)

# c) calculando os percentis
for n in [32, 76]:
    kq = (n * (N - 1)) / 100
    trunc = int(kq)
    PD = kq - trunc
    VP = lista[trunc]
    VP1 = lista[trunc + 1]

    P = VP + PD * (VP1 - VP)
    listap.append(float(f'{P:.1f}'))

RES = 'RESULTADOS'
print(RES.center(22, '*'))
print('a)', str(listaq)[1:-1])
print('b)', str(listad)[1:-1])
print('c)', str(listap)[1:-1])

''' Sem o uso de bibliotecas '''
lista = [10, 13, 11, 18, 7, 12, 15, 5, 21, 11, 9, 25, 13, 7, 25, 22]

# listas com os resultados
listaq = []
listad = []
listap = []

# ordenando os elementos
lista = sorted(lista)

# encontrando o N
N = len(lista)

# a) calculando os quartis
for n in range(1, 4):
    kq = (n * (N + 1)) / 4
    trunc = int(kq)
    PD = kq - trunc
    VP = lista[trunc - 1]
    VP1 = lista[trunc]

    Q = VP + PD * (VP1 - VP)
    listaq.append(Q)

# b) calculando os decis
for n in [4, 7]:
    kq = (n * (N + 1)) / 10
    trunc = int(kq)
    PD = kq - trunc
    VP = lista[trunc - 1]
    VP1 = lista[trunc]

    D = VP + PD * (VP1 - VP)
    listad.append(float(f'{D:.1f}'))

# c) calculando os percentis
for n in [32, 76]:
    kq = (n * (N + 1)) / 100
    trunc = int(kq)
    PD = kq - trunc
    VP = lista[trunc - 1]
    VP1 = lista[trunc]

    P = VP + PD * (VP1 - VP)
    listap.append(float(f'{P:.2f}'))   

RES = 'RESULTADOS'
print(RES.center(22, '*'))
print('a)', str(listaq)[1:-1])
print('b)', str(listad)[1:-1])
print('c)', str(listap)[1:-1])

''' Utilizando Statistics: Base N - 1 '''

import statistics as st

lista = [10, 13, 11, 18, 7, 12, 15, 5, 21, 11, 9, 25, 13, 7, 25, 22]

Q = st.quantiles(lista, n=4, method= 'inclusive') # Quartis

D = st.quantiles(lista, n=10, method= 'inclusive') # Decis

P = st.quantiles(lista, n=100, method= 'inclusive') # Percentis

print('Base N - 1')
print(f'Q: {Q[0]}, {Q[1]}, {Q[2]}')
print(f'D: {D[3]}, {D[6]}')
print(f'P: {P[31]}, {P[75]}')

''' Utilizando Statistics: Base N + 1 '''

import statistics as st

lista = [10, 13, 11, 18, 7, 12, 15, 5, 21, 11, 9, 25, 13, 7, 25, 22]

Q = st.quantiles(lista, n=4, method= 'exclusive') # Quartis
# RESULTADO: 9.25, 12.5, 20.25

D = st.quantiles(lista, n=10, method= 'exclusive') # Decis
# RESULTADO: 11.0 / 17.7

P = st.quantiles(lista, n=100, method= 'exclusive') # Percentis
# RESULTADO: 10.44 / 20.76

print('Base N + 1')
print(f'Q: {Q[0]}, {Q[1]}, {Q[2]}')
print(f'D: {D[3]}, {D[6]}')
print(f'P: {P[31]}, {P[75]}')

''' Utilizando Numpy: Base N - 1 '''

import numpy as np

lista = [10, 13, 11, 18, 7, 12, 15, 5, 21, 11, 9, 25, 13, 7, 25, 22]

# Quartis
Q1 = np.quantile(lista, 0.25, method='linear')
Q2 = np.quantile(lista, 0.5, method='linear')
Q3 = np.quantile(lista, 0.75, method='linear')

# Decis
D4 = np.percentile(lista, 40, method='linear')
D7 = np.percentile(lista, 70, method='linear')

# Percentis
P32 = np.percentile(lista, 32, method='linear')
P76 = np.percentile(lista, 76, method='linear')

print('Base N - 1')
print(f'Quartis: {Q1}, {Q2}, {Q3}')
print(f'Decis: {D4}, {D7}')
print(f'Percentis: {P32}, {P76:.1f}')

''' Utilizando Numpy: Base N + 1 '''

import numpy as np

lista = [10, 13, 11, 18, 7, 12, 15, 5, 21, 11, 9, 25, 13, 7, 25, 22]

# Quartis
Q1 = np.quantile(lista, 0.25, method='weibull')
Q2 = np.quantile(lista, 0.5, method='weibull')
Q3 = np.quantile(lista, 0.75, method='weibull')
# RESULTADO: Q1 = 9.25 | Q2 = 12.5 | Q3 = 20.25

# Decis
D4 = np.percentile(lista, 40, method='weibull')
D7 = np.percentile(lista, 70, method='weibull')
# RESULTADO: D4 = 11.0 | D7 = 17.7

# Percentis
P32 = np.percentile(lista, 32, method='weibull')
P76 = np.percentile(lista, 76, method='weibull')
# RESULTADO: D4 = 10.44 | D7 = 20.76

print('Base N + 1')
print(f'Quartis: {Q1}, {Q2}, {Q3}')
print(f'Decis: {D4}, {D7:.1f}')
print(f'Percentis: {P32:.2f}, {P76:.2f}')

Julia

"Base N - 1 e Base N + 1"
function separatrizes(bessel, base, N, sep, nums)
    # Usando um operador ternário
    comp = bessel == -1 ? 1 : (bessel = 1; 0)

    kq = map(x -> (x * (N + bessel) / base), sep)
    trunc = Int.(floor.(kq))
    PD = round.(kq - trunc, digits=2)
    VP = sort(nums)[trunc .+ comp]
    VP1 = sort(nums)[trunc .+ (comp + 1)]

    Q = VP + PD .* (VP1 - VP)
    return Q
end

nums = [10, 13, 11, 18, 7, 12, 15, 5, 21, 11, 9, 25, 13, 7, 25, 22]
N = length(nums)
bessel = [-1, -1, -1, 1, 1, 1]
base = [4, 10, 100, 4, 10, 100]
sep = [1:3, [4, 7], [32, 76], 1:3, [4, 7], [32, 76]]

questions = ["Quartis:", "Decis:", "Percentis:", "Quartis:", "Decis:", "Percentis:"]

for s in 1:length(questions)
    results = separatrizes(bessel[s], base[s], N, sep[s], nums)

    if s == 1
        println("Base N -1")
        println("$(questions[s]): $(results[1]), $(results[2]), $(results[3])")
    elseif s == 4
        println("nBase N + 1")
        println("$(questions[s]): $(results[1]), $(results[2]), $(results[3])")
    else
        println("$(questions[s]): $(results[1]), $(results[2])")
    end
end

# RESPOSTA

# Base N -1
# Quartis: 9.75, 12.5, 18.75
# Decis: 11.0, 16.5
# Percentis: 10.8, 19.2

# Base N + 1
# Quartis: 9.25, 12.5, 20.25
# Decis: 11.0, 17.7
# Percentis: 10.44, 20.76

" Utilizando StatsBase: Base N - 1 "

using StatsBase

valor = [10, 13, 11, 18, 7, 12, 15, 5, 21, 11, 9, 25, 13, 7, 25, 22]

Q1 = nquantile(valor, 4)[2]
Q2 = nquantile(valor, 4)[3]
Q3 = nquantile(valor, 4)[4]

D4 = nquantile(valor, 10)[5]
D7 = nquantile(valor, 10)[8]

P32 = nquantile(valor, 100)[33]
P76 = nquantile(valor, 100)[77]

Dados agrupados SEM intervalos de classe

Python

# Convertendo os elementos do dicionário e suas frequências em uma lista.
lista = list(k for k, v in notas_freq.items() for _ in range(v))

'QUARTIS'
kq = (n * (len(valor) - 1)) / 4
'DECIS'
kq = (n * (len(valor) - 1)) / 10
'PERCENTIS'
kq = (n * (len(valor) - 1)) / 100

trunc = int(kq)
PD = kq - trunc
VP = lista[trunc]
VP1 = lista[trunc + 1]

# Calculando a separatriz
QDP = VP + PD * (VP1 - VP)

Julia

# Convertendo os elementos do dicionário e suas frequências em um vetor.
valor = [k for (k,v) in notas_freq for _ in 1:v]

"QUARTIS"
kq = (n * (length(valor) - 1)) / 4
"DECIS"
kq = (n * (length(valor) - 1)) / 10
"PERCENTIS"
kq = (n * (length(valor) - 1)) / 100

trunc = floor(Int, kq)
PD = kq - trunc
VP = valor[trunc]
VP1 = valor[trunc+1]

# Calculando a separatriz
QDP = VP + PD * (VP1 - VP)

 

Exemplos

Notas345678910
Frequências146910956

A partir da tabela acima, que apresenta as notas dos alunos da turma A da disciplina de Estatística e Probabilidade e suas respectivas frequências, determine os valores dos:

a) Três quartis.
b) Terceiro e do oitavo decis.
c) Décimo quinto e nonagésimo terceiro percentis.


Python

" Sem o uso de bibliotecas "
# 1º passo: Cria-se um dicionário contendo os elementos e suas frequências
notas_freq = {3:1, 4:4, 5:6, 6:9, 7:10, 8:9, 9:5, 10:6}

# 2º passo: Utiliza-se um laço for e uma estrutura condicional if para encontrar o maior valor da frequência e relacioná-lo ao elemento procurado e salva em uma lista.
lista = list(k for k, v in notas_freq.items() for _ in range(v))

# 3º passo: O uso das funções
print("Quartis:")
for n in [1, 2, 3]:
    kq = (n * (len(lista) - 1)) / 4 
    trunc = int(kq)
    PD = kq - trunc
    VP = lista[trunc]
    print(f"n{PD}n")
    VP1 = lista[trunc + 1]
    Q = VP + PD * (VP1 - VP)
    print(f"{n}: {Q}")

print("nDecis:")
for n in [3, 8]:
    kq = (n * (len(lista) - 1)) / 10

    trunc = int(kq)
    PD = kq - trunc
    VP = lista[trunc]
    VP1 = lista[trunc + 1]
    D = VP + PD * (VP1 - VP)
    print(f"{n}: {D}")

print("nPercentis:")
for n in [15, 93]:
    kq = (n * (len(lista) - 1)) / 100
    trunc = int(kq)
    PD = kq - trunc
    VP = lista[trunc]
    VP1 = lista[trunc + 1]
    P = VP + PD * (VP1 - VP)
    print(f"{n}: {P}")


''' Utilizando Statistics '''
import statistics as st
# 1º passo: Cria-se um dicionário contendo os elementos e suas frequências
notas_freq = {3:1, 4:4, 5:6, 6:9, 7:10, 8:9, 9:5, 10:6}

# 2º passo: Utiliza-se um laço for e uma estrutura condicional if para encontrar o maior valor da frequência e relacioná-lo ao elemento procurado e salva em uma lista.
lista = list(k for k, v in notas_freq.items() for _ in range(v))

quartis = st.quantiles(lista, n=4, method='inclusive')
print(f"Quartis: {quartis}n")

decis = st.quantiles(lista, n=10, method='inclusive')
print(f"Decis: {decis[3]}, {decis[8]}n")

percentis = st.quantiles(lista, n=100, method='inclusive')
print(f"Percentis: {percentis[15]}, {percentis[93]}")

Dados agrupados COM intervalos de classe

Fórmula:

$$\large QDP = l_{i} + \frac{h \cdot(p_{n} – m)}{f_{m}}$$

Sendo:

  • $QDP$: valores dos quartis, dos decis e dos percentis
  • $l_{i}$: limite inferior da classe do quartil, do decil ou do percentil que se está calculando
  • $h$: amplitude da classe
  • $p_{n}$: (n * N) / 4 ou (n * N / 10) ou (n * N / 100) n é a separatriz procurada e N o total de repetições
  • $m$: frequência acumulada imediatamente anterior à classe que se está verificando os dados
  • $f_{m}$: frequência simples (ou absoluta) da classe que se está verificando os dados.

Python : 

# Encontrando a frequência acumulada
fa = list(map(lambda x: sum(list(dicio.values())[: x + 1]), range(len(dicio.values()))))

# Encontrando o percentil n, a proporção n do conjunto de dados)
'QUARTIS'
pn = (n * sum(list(dicio.values()))) / 4
'DECIS'
pn = (n * sum(list(dicio.values()))) / 10
'PERCENTIS'
pn = (n * sum(list(dicio.values()))) / 100

# Encontrando o intervalo de classe que está a separatriz procurada
num = list(filter(lambda x: x >= pn, fa))[0]
interval = list(dicio.keys())[fa.index(list(filter(lambda x: x == num, fa))[0])]
# limite inferior da classe do quartil ou do percentil
li = float(interval.split(' - ')[0])
# amplitude da classe
h = float(interval.split(' - ')[1]) - float(interval.split(' - ')[0])
# frequência acumulada anterior à classe que se está verificando os dados
m = list(filter(lambda x: x < pn, fa))[-1]
# frequência simples da classe que se está verificando os dados
fm = dicio.get(interval)
# Fórmula para encontrar os quartis, decis ou percentis
QDP = li + ((h * (pn - m)) / fm)

Julia : 

# Criando um vetor com as frequências acumuladas
fa = cumsum(frequencias)

# Encontrando o percentil n, a proporção n do conjunto de dados)
"QUARTIS"
pn = (1 * sum(frequencias)) / 4
"DECIS"
pn = (1 * sum(frequencias)) / 10
"PERCENTIS"
pn = (1 * sum(frequencias)) / 100

# Encontrando o intervalo de classe que está a separatriz procurada
num = filter(x -> x >= pn, fa)[1]
interval = intervalos[findfirst(x -> x == num, fa)]
# limite inferior da classe do quartil ou do percentil
li = parse(Float64, split(interval, " - ")[1])
# amplitude da classe
h = parse(Float64, split(interval, " - ")[2]) - parse(Float64, split(interval, " - ")[1])
# frequência acumulada anterior à classe que se está verificando os dados
m = filter(x -> x < pn, fa)[end]
# frequência simples da classe que se está verificando os dados
fm = frequencias[findfirst(x -> x == interval, intervalos)]
# Fórmula para encontrar os quartis, decis ou percentis
QDP = li + ((h * (pn - m)) / fm)

Exemplos

Dada a distribuição de frequências das 70 pessoas adultas que se pesaram, no mesmo dia, na balança de uma farmácia.

NotasFrequê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

Determine:

  • a) Os três quartis.
  • b) O quarto e o sétimo decil.
  • c) O trigésimo quinto e o sexagésimo percentil.

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}

fa = list(map(lambda x: sum(list(dicio.values())[: x + 1]), range(len(dicio.values()))))

''' QUARTIS '''

# para encontrar os valores utiliza-se a fórmula das separatrizes com um laço 'for'
for n in [1, 2, 3]:
    pn = (n * sum(list(dicio.values()))) / 4
    num = list(filter(lambda x: x >= pn, fa))[0]
    interval = list(dicio.keys())[fa.index(list(filter(lambda x: x == num, fa))[0])]
    li = float(interval.split(' - ')[0])
    h = float(interval.split(' - ')[1]) - float(interval.split(' - ')[0])
    m = list(filter(lambda x: x < pn, fa))[-1]
    fm = dicio.get(interval)
    Q = li + ((h * (pn - m))/fm)
    print(f'{n}º quartil: {Q}')

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}

fa = list(map(lambda x: sum(list(dicio.values())[: x + 1]), range(len(dicio.values()))))

''' DECIS '''

for n in [4, 7]:
    pn = (n * sum(list(dicio.values()))) / 10
    num = list(filter(lambda x: x >= pn, fa))[0]
    interval = list(dicio.keys())[fa.index(list(filter(lambda x: x == num, fa))[0])]
    li = float(interval.split(' - ')[0])
    h = float(interval.split(' - ')[1]) - float(interval.split(' - ')[0])
    m = list(filter(lambda x: x < pn, fa))[-1]
    fm = dicio.get(interval)
    D = li + ((h * (pn - m))/fm)
    print(f'{n}º decil: {D}')

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}

fa = list(map(lambda x: sum(list(dicio.values())[: x + 1]), range(len(dicio.values()))))

''' PERCENTIS '''

for n in [35, 60]:
    pn = (n * sum(list(dicio.values()))) / 100
    num = list(filter(lambda x: x >= pn, fa))[0]
    interval = list(dicio.keys())[fa.index(list(filter(lambda x: x == num, fa))[0])]
    li = float(interval.split(' - ')[0])
    h = float(interval.split(' - ')[1]) - float(interval.split(' - ')[0])
    m = list(filter(lambda x: x < pn, fa))[-1]
    fm = dicio.get(interval)
    P = li + ((h * (pn - m))/fm)
    print(f'{n}º percentil: {P}')

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)

for n in [1,2,3]
    pn = (n * sum(frequencias)) / 4    
    num = filter(x -> x >= pn, fa)[1]
    interval = intervalos[findfirst(x -> x == num, fa)]
    li = parse(Float64, split(interval, " - ")[1])
    h = parse(Float64, split(interval, " - ")[2]) - parse(Float64, split(interval, " - ")[1])
    m = filter(x -> x < pn, fa)[end]    
    fm = frequencias[findfirst(x -> x == interval, intervalos)]    
    Q = li + ((h * (pn - m)) / fm)
    println(Q)
end

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)

for n in [4,7]
    pn = (n * sum(frequencias)) / 10    
    num = filter(x -> x >= pn, fa)[1]
    interval = intervalos[findfirst(x -> x == num, fa)]
    li = parse(Float64, split(interval, " - ")[1])
    h = parse(Float64, split(interval, " - ")[2]) - parse(Float64, split(interval, " - ")[1])
    m = filter(x -> x < pn, fa)[end]    
    fm = frequencias[findfirst(x -> x == interval, intervalos)]    
    D = li + ((h * (pn - m)) / fm)
    println(D)
end

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)

for n in [35,60]
    pn = (n * sum(frequencias)) / 100    
    num = filter(x -> x >= pn, fa)[1]
    interval = intervalos[findfirst(x -> x == num, fa)]
    li = parse(Float64, split(interval, " - ")[1])
    h = parse(Float64, split(interval, " - ")[2]) - parse(Float64, split(interval, " - ")[1])
    m = filter(x -> x < pn, fa)[end]    
    fm = frequencias[findfirst(x -> x == interval, intervalos)]    
    P = li + ((h * (pn - m)) / fm)
    println(P)
end