bytes - ¿Hay una constante de Python para los espacios en blanco de Unicode?

unicode python 3

Question

El módulo de string contiene un atributo de whitespace en whitespace , que es una cadena que consta de todos los caracteres ASCII que se consideran espacios en blanco. ¿Existe una constante correspondiente que incluya espacios Unicode también, como el espacio de no interrupción (U + 00A0) ? Podemos ver en la pregunta " strip () y strip (string.whitespace) que dan resultados diferentes " que al menos strip es consciente de los caracteres de espacio en blanco adicionales de Unicode.

Esta pregunta se identificó como un duplicado de In Python, ¿cómo se enumeran todos los caracteres que coinciden con las expresiones regulares extendidas POSIX [:space:] ? , pero las respuestas a esa pregunta identifican formas de buscar caracteres de espacios en blanco para generar su propia lista. Este es un proceso que consume tiempo. Mi pregunta fue específicamente sobre una constante .

Answer 1

¿Hay una constante de Python para los espacios en blanco de Unicode?

Respuesta corta: No. Personalmente he grepped para estos caracteres (específicamente, los puntos del código numérico) en la base del código de Python, y tal constante no está allí.

Las secciones a continuación explican por qué no es necesario y cómo se implementa sin que esta información esté disponible como una constante. Pero tener una constante así también sería una muy mala idea.

Si el Consorcio de Unicode agregó otro carácter / punto de código que es semánticamente en blanco, los mantenedores de Python tendrían una mala elección entre continuar soportando el código semánticamente incorrecto o cambiar la constante y posiblemente romper el código preexistente que podría (de manera imprudente) hacer suposiciones Sobre la constante no cambia.

¿Cómo podría agregar estos puntos de código de carácter? Hay 1.111.998 caracteres posibles en Unicode. Pero solo 120.672 están ocupadas a partir de la versión 8 . Cada nueva versión de Unicode puede agregar caracteres adicionales. Uno de estos nuevos caracteres podría ser una forma de espacio en blanco.

La información se almacena en una función C generada dinámicamente.

El código que determina qué es un espacio en blanco en Unicode es el siguiente code generado dinámicamente.

# Generate code for _PyUnicode_IsWhitespace()
print("/* Returns 1 for Unicode characters having the bidirectional", file=fp)
print(" * type ''WS'', ''B'' or ''S'' or the category ''Zs'', 0 otherwise.", file=fp)
print(" */", file=fp)
print(''int _PyUnicode_IsWhitespace(const Py_UCS4 ch)'', file=fp)
print(''{'', file=fp)
print(''    switch (ch) {'', file=fp)
for codepoint in sorted(spaces):
    print(''    case 0x%04X:'' % (codepoint,), file=fp)
print(''        return 1;'', file=fp)
print(''    }'', file=fp)
print(''    return 0;'', file=fp)
print(''}'', file=fp)
print(file=fp)

Esta es una declaración de cambio, que es un bloque de código constante, pero esta información no está disponible como una "constante" de módulo como la que tiene el módulo de cadena. En cambio, está enterrado en la función compilada desde C y no se puede acceder directamente desde Python.

Esto es probable porque a medida que se agregan más puntos de código a Unicode, no podríamos cambiar las constantes por razones de compatibilidad con versiones anteriores.

El código generado

Aquí está el código generado actualmente en la punta :

int _PyUnicode_IsWhitespace(const Py_UCS4 ch)
{
    switch (ch) {
    case 0x0009:
    case 0x000A:
    case 0x000B:
    case 0x000C:
    case 0x000D:
    case 0x001C:
    case 0x001D:
    case 0x001E:
    case 0x001F:
    case 0x0020:
    case 0x0085:
    case 0x00A0:
    case 0x1680:
    case 0x2000:
    case 0x2001:
    case 0x2002:
    case 0x2003:
    case 0x2004:
    case 0x2005:
    case 0x2006:
    case 0x2007:
    case 0x2008:
    case 0x2009:
    case 0x200A:
    case 0x2028:
    case 0x2029:
    case 0x202F:
    case 0x205F:
    case 0x3000:
        return 1;
    }
    return 0;
}

Haciendo tu propia constante:

El siguiente código (de mi respuesta here ), en Python 3, genera una constante de todos los espacios en blanco:

import re
import sys

s = ''''.join(chr(c) for c in range(sys.maxunicode+1))
ws = ''''.join(re.findall(r''/s'', s))

Como optimización, puede almacenar esto en una base de código, en lugar de generarla automáticamente en cada nuevo proceso, pero le advierto que no cambiará nunca.

>>> ws
''/t/n/x0b/x0c/r/x1c/x1d/x1e/x1f /x85/xa0/u1680/u2000/u2001/u2002/u2003/u2004/u2005/u2006/u2007/u2008/u2009/u200a/u2028/u2029/u202f/u205f/u3000''

(Otras respuestas a la pregunta vinculada muestran cómo obtener eso para Python 2.)

Recuerde que en un momento dado, algunas personas probablemente pensaron que 256 codificaciones de caracteres era todo lo que siempre necesitaríamos.

>>> import string
>>> string.whitespace
'' /t/n/r/x0b/x0c''

Si está insistiendo en mantener una constante en su base de código, solo genere la constante para su versión de Python, y almacénela como un literal:

unicode_whitespace = u''/t/n/x0b/x0c/r/x1c/x1d/x1e/x1f /x85/xa0/u1680/u2000/u2001/u2002/u2003/u2004/u2005/u2006/u2007/u2008/u2009/u200a/u2028/u2029/u202f/u205f/u3000''

El prefijo u hace unicode en Python 2 (2.7 también reconoce la cadena completa que aparece arriba como espacios en blanco también), y en Python 3 se ignora ya que los literales de cadena son unicode de forma predeterminada.