Dividir cadena unicode en trozos de 300 bytes sin destruir los caracteres

Question

Quiero dividir u"an arbitrary unicode string" en trozos de, por ejemplo, 300 bytes sin destruir ningún carácter. Las cadenas se escribirán en un socket que espera utf8 usando unicode_string.encode("utf8"). No quiero destruir ningún personaje. ¿Cómo haría esto?

Answer 1

UTF-8 está diseñado para esto.

def split_utf8(s, n): 
    """Split UTF-8 s into chunks of maximum length n.""" 
    while len(s) > n: 
     k = n 
     while (ord(s[k]) & 0xc0) == 0x80: 
      k -= 1 
     yield s[:k] 
     s = s[k:] 
    yield s 

No probado. Pero encuentras un lugar para dividir, luego retrocedes hasta llegar al comienzo de un personaje.

Sin embargo, si un usuario alguna vez desea ver un fragmento individual, es posible que desee dividir los límites del clúster de grafemas en su lugar. Esto es significativamente más complicado, pero no difícil de resolver. Por ejemplo, en "é", podría no desea dividir el "e" y el "´". O puede que no te importe, siempre y cuando se unan nuevamente al final.

Answer 2

Si puede asegurarse de que la representación del utf-8 de sus caracteres es de solo 2 bytes de longitud, debería separar la cadena unicode en segmentos de 150 caracteres (esto debería ser cierto para la mayoría de las codificaciones europeas). Pero utf-8 es una codificación de ancho variable. Por lo tanto, podría dividir la cadena Unicode en caracteres únicos, convertir cada char a utf-8 y llenar el búfer hasta que alcance el tamaño máximo de fragmento ... esto podría ser ineficiente y un problema si el alto rendimiento es una necesidad ...

Answer 3

UTF-8 tiene una propiedad especial de que todos los caracteres de continuación son 0x80 – 0xBF (comienza con los bits 10). Así que solo asegúrate de no dividir justo antes de uno.

Algo a lo largo de las líneas de:

def split_utf8(s, n): 
    if len(s) <= n: 
     return s, None 
    while ord(s[n]) >= 0x80 and ord(s[n]) < 0xc0: 
     n -= 1 
    return s[0:n], s[n:] 

debe hacer el truco.

Answer 4

Uso codificación Unicode que por diseño tienen una longitud fija de cada personaje, por ejemplo utf-32:

>>> u_32 = u'Юникод'.encode('utf-32') 
>>> u_32 
'\xff\xfe\x00\x00.\x04\x00\x00=\x04\x00\x008\x04\x00\x00:\x04\x00\x00>\x04\x00\x 
004\x04\x00\x00' 
>>> len(u_32) 
28 
>>> len(u_32)%4 
0 
>>> 

Después de la codificación puede enviar trozo de cualquier tamaño (tamaño debe ser múltiplo de 4 bytes) sin destruir caracteres

Answer 5

Probado.

def split_utf8(s , n): 
    assert n >= 4 
    start = 0 
    lens = len(s) 
    while start < lens: 
     if lens - start <= n: 
      yield s[start:] 
      return # StopIteration 
     end = start + n 
     while '\x80' <= s[end] <= '\xBF': 
      end -= 1 
     assert end > start 
     yield s[start:end] 
     start = end