wikipediaillustrated

tutoriales

[2021] Diferencia entre NFD, NFC, NFKD y NFKC explicada con código Python {DH}

10BDFnrW J2zDIL4 GpzE6g

La diferencia entre las formas de normalización Unicode

14 de noviembre de 2019·4 minutos de lectura

1*0BDFnrW J2zDIL4 GpzE6g

Estoy trabajando en una tarea de NLP japonés recientemente, un problema es convertir caracteres especiales a una forma normalizada. Así que investigué un poco y escribí esta publicación para cualquiera que tenga la misma necesidad.

El japonés contiene diferentes formas del carácter, por ejemplo, el latín tiene dos formas, la forma de ancho completo y la forma de medio ancho.

En el ejemplo anterior, podemos ver que el formulario de ancho completo es muy feo y también es difícil de usar para el siguiente procesamiento. Entonces necesitamos convertirlo a una forma normalizada.

Usar NFKC Método.

>>> from unicodedata import normalize
>>> s = "株式会社KADOKAWA Future Publishing"
>>> normalize('NFKC', s)
株式会社KADOKAWA Future Publishing

Hayyo 4 tipos de formularios de normalización Unicode. Este artículo da una explicación muy detallada. Pero explicaré la diferencia de una manera simple y fácil de entender.

Primero, podríamos ver el siguiente resultado para la comprensión intuitiva.

アイウエオ ==(NFC)==> アイウエオ
アイウエオ ==(NFD)==> アイウエオ
アイウエオ ==(NFKC)==> アイウエオ
アイウエオ ==(NFKD)==> アイウエオ
パピプペポ ==(NFC)==> パピプペポ
パピプペポ ==(NFD)==> パピプペポ
パピプペポ ==(NFKC)==> パピプペポ
パピプペポ ==(NFKD)==> パピプペポ
パピプペポ ==(NFC)==> パピプペポ
パピプペポ ==(NFD)==> パピプペポ
パピプペポ ==(NFKC)==> パピプペポ
パピプペポ ==(NFKD)==> パピプペポ
abcABC ==(NFC)==> abcABC
abcABC ==(NFD)==> abcABC
abcABC ==(NFKC)==> abcABC
abcABC ==(NFKD)==> abcABC
123 ==(NFC)==> 123
123 ==(NFD)==> 123
123 ==(NFKC)==> 123
123 ==(NFKD)==> 123
+-.~)} ==(NFC)==> +-.~)}
+-.~)} ==(NFD)==> +-.~)}
+-.~)} ==(NFKC)==> +-.~)}
+-.~)} ==(NFKD)==> +-.~)}

Hay dos métodos de clasificación para estas 4 formas.

# 1 original form changed or not
- A(not changed): NFC & NFD
- B(changed): NFKC & NFKD
# 2 the length of original length changed or not
- A(not changed): NFC & NFKC
- B(changed): NFD & NFKD
abcABC ==(NFC)==> abcABC
abcABC ==(NFD)==> abcABC
abcABC ==(NFKC)==> abcABC
abcABC ==(NFKD)==> abcABC
# 1 original form changed or not
- A(not changed): NFC & NFD
- B(changed): NFKC & NFKD

El primer método de clasificación se basa en si se modifica o no la forma original. Más específicamente, un grupo no contiene K pero contiene el grupo B K. Qué estás haciendo K ¿Medio?

D = Decomposition 
C = Composition
K = Compatibility

K significa compatibilidad, usado para distinguir con la forma original. Ahí K cambia la forma original, por lo que la longitud también cambia.

>>> s="…"
>>> normalize('NFKC', s)
'...'
>>> len(s)
1
>>> len(normalize('NFC', s))
1
>>> len(normalize('NFKC', s))
3
>>> len(normalize('NFD', s))
1
>>> len(normalize('NFKD', s))
3
パピプペポ ==(NFC)==> パピプペポ
パピプペポ ==(NFD)==> パピプペポ
パピプペポ ==(NFKC)==> パピプペポ
パピプペポ ==(NFKD)==> パピプペポ
# 2 the length of original length changed or not
- A(not changed): NFC & NFKC
- B(changed): NFD & NFKD

Este segundo método de clasificación se basa en si se cambia o no la longitud del formulario original. Un grupo contiene C(Composición), que no cambia la duración. El grupo B contiene D(Descomposición), lo que hace que cambie la longitud.

Quizás se pregunte por qué se cambia la longitud. Vea la prueba a continuación.

>>> from unicodedata import normalize
>>> s = "パピプペポ"
>>> len(s)
5
>>> len(normalize('NFC', s))
5
>>> len(normalize('NFKC', s))
5
>>> len(normalize('NFD', s))
10
>>> len(normalize('NFKD', s))
10

Podemos ver que el método de Descomposición duplica la longitud.

Eso es porque NFD & NFKD divide cada carácter Unicode en dos caracteres Unicode. Por ejemplo, ポ(U+30DD) = ホ(U+30DB) + Dot(U+309A) . Entonces la longitud cambia de 5 a 10. NFC & NFKC componer caracteres Unicode separados para que la longitud permanezca sin cambios.

Puede usar la biblioteca Unicodata para obtener diferentes formularios.

>>> from unicodedata import normalize
>>> s = "パピプペポ"
>>> len(s)
5
>>> len(normalize('NFC', s))
5
>>> len(normalize('NFKC', s))
5
>>> len(normalize('NFD', s))
10
>>> len(normalize('NFKD', s))
10

longitud

Normalmente podemos usarlos todos. NFKC or NFKD para obtener la forma normalizada. La longitud no causará problemas solo si su tarea de PNL es sensible a la longitud. Principalmente uso el NFKC Método.

Mira mis otras publicaciones Medio Con una vista categorizada!
GitHub:
Mora
LinkedIn:
XuLiang
Blog:
Mora

  • https://unicode.org/reports/tr15/#Norm_Forms
  • https://www.wikiwand.com/en/Unicode_equivalence#/Normal_forms
  • http://nomenclator.la.coocan.jp/unicode/normalization.htm
  • [2021] Diferencia entre NFD, NFC, NFKD y NFKC explicada con código Python {DH}

Puede que también te guste...

Deja una respuesta

Tu dirección de correo electrónico no será publicada.