La legibilidad es la facilidad con la que un lector puede comprender un texto escrito. En lenguaje natural, la legibilidad del texto depende de su contenido (la complejidad de su vocabulario y sintaxis). Se enfoca en las palabras que elegimos y cómo las ponemos en oraciones y párrafos para que los lectores las comprendan.
Nuestro principal objetivo al escribir es transmitir información que tanto el escritor como el lector piensan que vale la pena. Si no logramos transmitir esa información, nuestros esfuerzos serán en vano. Para atraer al lector, es fundamental presentarles información que con gusto seguirán leyendo y que podrán comprender con claridad. Por lo tanto, se requiere que el contenido sea lo suficientemente fácil de leer y comprender que sea lo más legible posible. Hay varias escalas de dificultad disponibles con sus propias fórmulas para determinar la dificultad.
Este artículo ilustra varias fórmulas de legibilidad tradicionales disponibles para la evaluación del puntaje de legibilidad. En el procesamiento del lenguaje natural, a veces se requiere analizar palabras y oraciones para determinar la dificultad del texto. Los puntajes de legibilidad son generalmente niveles de grado en escalas particulares, que califican el texto en cuanto a cuál es la dificultad de ese texto en particular. Ayuda al escritor a mejorar el texto para que sea comprensible para una audiencia más amplia, lo que hace que el contenido sea atractivo.
Varios métodos/fórmulas disponibles para la determinación de la puntuación de legibilidad:
- La fórmula de Dale-Chall
- La fórmula de la niebla de Gunning
- Gráfico de legibilidad de freír
- Fórmula SMOG de McLaughlin
- La fórmula PRONÓSTICO
- Legibilidad y lectores de periódicos
- Puntuaciones de Flesch
Lea sobre más fórmulas de legibilidad disponibles aquí .
La implementación de las fórmulas de legibilidad se muestra a continuación.
La fórmula de Dale Chall:
Para aplicar la fórmula:
Seleccione varias muestras de 100 palabras a lo largo del texto.
Calcule la longitud promedio de las oraciones en palabras (divida el número de palabras entre el número de oraciones).
Calcule el porcentaje de palabras que NO están en la lista de palabras Dale-Chall de 3000 palabras fáciles.
Calcular esta ecuación
Raw score = 0.1579*(PDW) + 0.0496*(ASL) + 3.6365 Here, PDW = Percentage of difficult words not on the Dale–Chall word list. ASL = Average sentence length
La fórmula de Gunning fog
Grade level= 0.4 * ( (average sentence length) + (percentage of Hard Words) ) Here, Hard Words = words with more than two syllables.
fórmula de smog
SMOG grading = 3 + √(polysyllable count). Here, polysyllable count = number of words of more than two syllables in a sample of 30 sentences.
Fórmula de carne
Reading Ease score = 206.835 - (1.015 × ASL) - (84.6 × ASW) Here, ASL = average sentence length (number of words divided by number of sentences) ASW = average word length in syllables (number of syllables divided by number of words)
Ventajas de las fórmulas de legibilidad:
1. Las fórmulas de legibilidad miden el nivel de grado que deben tener los lectores para leer un texto determinado. Por lo tanto, proporciona al escritor del texto información muy necesaria para llegar a su público objetivo.
2. Sepa de antemano si el público objetivo puede entender su contenido.
3. Fácil de usar.
4. Un texto legible atrae a más audiencia.
Desventajas de las fórmulas de legibilidad:
1. Debido a las muchas fórmulas de legibilidad, existe una posibilidad cada vez mayor de obtener amplias variaciones en los resultados de un mismo texto.
2. Aplica Matemáticas a la Literatura lo cual no siempre es una buena idea.
3. No puede medir la complejidad de una palabra o frase para determinar dónde debe corregirla.
Python
import spacy
from textstat.textstat import textstatistics,legacy_round
# Splits the text into sentences, using
# Spacy's sentence segmentation which can
# be found at https://spacy.io/usage/spacy-101
def break_sentences(text):
nlp = spacy.load('en_core_web_sm')
doc = nlp(text)
return list(doc.sents)
# Returns Number of Words in the text
def word_count(text):
sentences = break_sentences(text)
words = 0
for sentence in sentences:
words += len([token for token in sentence])
return words
# Returns the number of sentences in the text
def sentence_count(text):
sentences = break_sentences(text)
return len(sentences)
# Returns average sentence length
def avg_sentence_length(text):
words = word_count(text)
sentences = sentence_count(text)
average_sentence_length = float(words / sentences)
return average_sentence_length
# Textstat is a python package, to calculate statistics from
# text to determine readability,
# complexity and grade level of a particular corpus.
# Package can be found at https://pypi.python.org/pypi/textstat
def syllables_count(word):
return textstatistics().syllable_count(word)
# Returns the average number of syllables per
# word in the text
def avg_syllables_per_word(text):
syllable = syllables_count(text)
words = word_count(text)
ASPW = float(syllable) / float(words)
return legacy_round(ASPW, 1)
# Return total Difficult Words in a text
def difficult_words(text):
nlp = spacy.load('en_core_web_sm')
doc = nlp(text)
# Find all words in the text
words = []
sentences = break_sentences(text)
for sentence in sentences:
words += [str(token) for token in sentence]
# difficult words are those with syllables >= 2
# easy_word_set is provide by Textstat as
# a list of common words
diff_words_set = set()
for word in words:
syllable_count = syllables_count(word)
if word not in nlp.Defaults.stop_words and syllable_count >= 2:
diff_words_set.add(word)
return len(diff_words_set)
# A word is polysyllablic if it has more than 3 syllables
# this functions returns the number of all such words
# present in the text
def poly_syllable_count(text):
count = 0
words = []
sentences = break_sentences(text)
for sentence in sentences:
words += [token for token in sentence]
for word in words:
syllable_count = syllables_count(word)
if syllable_count >= 3:
count += 1
return count
def flesch_reading_ease(text):
"""
Implements Flesch Formula:
Reading Ease score = 206.835 - (1.015 × ASL) - (84.6 × ASW)
Here,
ASL = average sentence length (number of words
divided by number of sentences)
ASW = average word length in syllables (number of syllables
divided by number of words)
"""
FRE = 206.835 - float(1.015 * avg_sentence_length(text)) -\
float(84.6 * avg_syllables_per_word(text))
return legacy_round(FRE, 2)
def gunning_fog(text):
per_diff_words = (difficult_words(text) / word_count(text) * 100) + 5
grade = 0.4 * (avg_sentence_length(text) + per_diff_words)
return grade
def smog_index(text):
"""
Implements SMOG Formula / Grading
SMOG grading = 3 + ?polysyllable count.
Here,
polysyllable count = number of words of more
than two syllables in a sample of 30 sentences.
"""
if sentence_count(text) >= 3:
poly_syllab = poly_syllable_count(text)
SMOG = (1.043 * (30*(poly_syllab / sentence_count(text)))**0.5) \
+ 3.1291
return legacy_round(SMOG, 1)
else:
return 0
def dale_chall_readability_score(text):
"""
Implements Dale Challe Formula:
Raw score = 0.1579*(PDW) + 0.0496*(ASL) + 3.6365
Here,
PDW = Percentage of difficult words.
ASL = Average sentence length
"""
words = word_count(text)
# Number of words not termed as difficult words
count = word_count - difficult_words(text)
if words > 0:
# Percentage of words not on difficult word list
per = float(count) / float(words) * 100
# diff_words stores percentage of difficult words
diff_words = 100 - per
raw_score = (0.1579 * diff_words) + \
(0.0496 * avg_sentence_length(text))
# If Percentage of Difficult Words is greater than 5 %, then;
# Adjusted Score = Raw Score + 3.6365,
# otherwise Adjusted Score = Raw Score
if diff_words > 5:
raw_score += 3.6365
return legacy_round(score, 2)