Curso

2022
Fundación Educativa Santisima Trinidad
Curso Python

ÍNDICE

1. Unicode ............................................................................................................... 3

2. UTF-8 .................................................................................................................... 5

3. Cadenas de bytes ............................................................................................... 6

3.1 Codificación y decodificación de cadenas ............................................... 7

4. Análisis y diferenciación ................................................................................... 7

5. XML Y JSON ........................................................................................................ 8

6. Archivos JSON con Python ............................................................................ 11

6.1 Escribir archivos ..................................................................................... 11

6.2 Obtener código json como cadena de texto .......................................... 12

6.3 Leer archivos .......................................................................................... 12

7. Convertir una cadena de texto con JSON en un diccionario………………...13

8. Opciones ........................................................................................................... 14

8.1 Codificación unicode .............................................................................. 14

8.2 Ordenación ............................................................................................. 14

8.3 Conclusiones .......................................................................................... 15

9. Ejercitación ....................................................................................................... 16

9.1 Semana 1 ............................................................................................... 16

9.2 Semana 2 ............................................................................................... 16

9.3 Semana 3 ............................................................................................... 16

9.4 Semana 4 ............................................................................................... 16

2
Fundación Educativa Santisima Trinidad
Curso Python

UNICODE

Unicode es el estándar de codificación de caracteres universal utilizado para la

representación de texto para procesamiento del equipo. Cada carácter Unicode se
asigna a un punto de código, que es un número entero entre 0 y 1114111.

Los programas de hoy necesitan poder manejar una amplia variedad de caracteres. Las
aplicaciones son a menudo internacionalizadas para mostrar mensajes y resultados en una
variedad de idiomas seleccionables por el usuario. Es posible que el mismo programa
necesite generar un mensaje de error en inglés, francés, japonés, hebreo o ruso. El
contenido web se puede escribir en cualquiera de estos idiomas y también puede incluir
una variedad de símbolos emoji. El tipo cadena de Python utiliza el estándar Unicode
para representar caracteres, lo que permite a los programas de Python trabajar con todos
estos caracteres posibles diferentes.

Unicode (https://www.unicode.org/) es una especificación que apunta a listar cada carácter

usado por lenguajes humanos y darle a cada carácter su propio código único. La
especificación Unicode es continuamente revisada y actualizada para añadir nuevos
lenguajes y símbolos.

Un carácter es el componente más pequeño posible de un texto. “A”, “B”, “C”, etc., son
todos diferentes caracteres. También lo son “È” e “Í”. Los caracteres varían dependiendo
del lenguaje o del contexto en el que estás hablando. Por ejemplo, Existe un carácter para
el «Número Uno Romano», “I”, que es distinto de la letra “I” mayúscula. Estos usualmente
lucen igual, pero son dos caracteres diferentes que tienen distintos significados.

El estándar Unicode contiene muchas tablas que enumeran caracteres y sus puntos de código
correspondientes:

3
Fundación Educativa Santisima Trinidad
Curso Python

Para resumir lo anterior: Una cadena Unicode es una secuencia de código de posiciones
que son números desde 0 hasta 0x10FFFF (1114111 decimal). Esta secuencia de código
de posiciones necesita ser representada en memoria como un conjunto de unidades de
código, y las unidades de código son mapeadas a bytes de 8 bits. Las reglas para traducir
una cadena Unicode a una secuencia de bytes son llamadas Codificación de carácter, o
sólo una codificación.

La primera codificación en que podrías pensar es usar enteros de 32 bits como unidad de
código, y luego usar la representación de la CPU de enteros de 32 bits. En esta
representación, la cadena «Python» podría verse así:

Esta representación es sencilla pero utilizarla presenta una serie de problemas.

1. No es portable; diferentes procesadores ordenan los bytes de manera diferente.

2. Es un desperdicio de espacio. En la mayoría de los textos, la mayoría de los códigos
de posición son menos de 127, o menos de 255, por lo que una gran cantidad de
espacio está ocupado por bytes 0x00. La cadena anterior toma 24 bytes en
comparación con los 6 bytes necesarios para una representación ASCII. El aumento
en el uso de RAM no importa demasiado (las computadoras de escritorio
tienen gigabytes de RAM, y las cadenas no suelen ser tan grandes), pero expandir
nuestro uso del disco y el ancho de banda de la red en un factor de 4 es intolerable.
3. No es compatible con funciones existentes en C como strlen(), para eso se
necesitaría una nueva familia de funciones de cadenas.

Por lo tanto esta codificación no es muy utilizada, y la gente prefiere elegir codificaciones
que son mas eficientes y convenientes, como UTF-8.

4
Fundación Educativa Santisima Trinidad
Curso Python

UTF-8

UTF-8 es una de las codificaciones más utilizadas, y Python generalmente la usa de forma
predeterminada. UTF significa «Unicode Transformation Format», y el «8» significa que se
utilizan valores de 8 bits en la codificación. (También hay codificaciones UTF-16 y UTF-32,
pero son menos frecuentes que UTF-8.) UTF-8 usa las siguientes reglas:

1. Si el código de posición es < 128, es representado por el valor de byte

correspondiente.
2. Si el código de posición es >= 128, se transforma en una secuencia de dos, tres, o
cuatro bytes, donde cada byte de la secuencia está entre 128 y 255.

UTF-8 tiene varias propiedades convenientes:

1. Puede manejar cualquier punto de código Unicode.

2. Una cadena Unicode se convierte en una secuencia de bytes que contiene cero
bytes incrustados solo donde representan el carácter nulo (U+0000). Esto significa
que las cadenas UTF-8 pueden ser procesadas por funciones C como strcpy() y
enviadas a través de protocolos que no pueden manejar cero bytes para nada más
que marcadores de fin de cadena de caracteres.
3. Una cadena de texto ASCII es también texto UTF-8.
4. UTF-8 es bastante compacto; La mayoría de los caracteres comúnmente usados
pueden ser representados con uno o dos bytes.
5. Si los bytes están corruptos o perdidos, es posible determinar el comienzo del
próximo código de posición y re-sincronizar. También es poco probable que datos
aleatorios de 8 bit se vean como UTF-8 válido.
6. UTF-8 es una codificación orientada a bytes. La codificación especifica que cada
carácter está representado por una secuencia específica de uno o más bytes. Esto
evita los problemas de ordenamiento de bytes que pueden ocurrir con codificaciones
orientadas a números enteros y palabras, como UTF-16 y UTF-32, donde la
secuencia de bytes varía según el hardware en el que se codificó la cadena.

5
Fundación Educativa Santisima Trinidad
Curso Python

CADENAS DE BYTES

Las cadenas de bytes en Python 3 se denominan oficialmente bytes , una secuencia

inmutable de enteros en el rango 0 <= x <256.
Python 3 transfiere datos como cadenas de bytes: bytes de tipo de datos . De manera
similar, si abre un archivo en modo binario, estará trabajando con cadenas de bytes.
Las cadenas de bytes admiten la mayoría de los métodos proporcionados con cadenas
Unicode (tipo de datos str). Si su código utiliza métodos de cadena, subíndices y
segmentos, es muy probable que continúe trabajando con cadenas de bytes.
Sin embargo, los métodos que toman parámetros de cadena fallarán si pasa una cadena
literal (constante) porque su código pasará una cadena literal Unicode a un método de
cadena de bytes.
Para definir una cadena de bytes, use un prefijo b para los literales de cadena. Por ejemplo:

Tenga en cuenta que las dos representaciones de cadenas son incompatibles, por lo que
la siguiente expresión siempre es Falsa :

No hay soporte para un método de formato en cadenas de bytes: el formato de cadena

solo es compatible con cadenas Unicode. Si imprime una cadena de bytes usando una
cadena de formato, siempre verá la forma de representación de la cadena de bytes.
Por ejemplo:

saldrá como:

6
Fundación Educativa Santisima Trinidad
Curso Python

CODIFICACIÓN Y DECODIFICACIÓN DE CADENAS

Para convertir cadenas de bytes a Unicode, use . decode () método que acepta un
parámetro de codificación. La codificación predeterminada es UTF-8 para todas las
plataformas. Podemos corregir el ejemplo anterior a:

Para convertir Unicode en una cadena de bytes, use . encode (), nuevamente con un
parámetro de codificación opcional (predeterminado UTF-8).

ANÁLISIS Y DIFERENCIACIÓN
La clase de cadena Python 3 ( str ) almacena cadenas Unicode y una nueva clase de
cadena de bytes ( bytes ) admite cadenas de un solo byte. Los dos son tipos diferentes,
por lo que las expresiones de cadena deben usar una forma u otra. Los literales de cadena
son Unicode a menos que tengan el prefijo b minúscula.
La conversión a Unicode requiere el conocimiento de la codificación del conjunto de
caracteres subyacente, siendo UTF-8 el más utilizado, especialmente en las páginas
web. Para convertir cadenas de bytes a Unicode, use .decode() y use .encode() para
convertir Unicode en una cadena de bytes. Ambos métodos permiten que la codificación
del conjunto de caracteres se especifique como un parámetro opcional si se requiere algo
distinto a UTF-8.
f-string permite que las expresiones se evalúen dentro de las llaves de una cadena de
formato, lo que proporciona un enfoque alternativo al uso de str.format()

7
Fundación Educativa Santisima Trinidad
Curso Python

XML Y JSON
La diferencia fundamental es que el xml es un lenguaje de marcado (Lenguaje de Marcado
Extensible), mientras que el json es una forma de representar objetos (Notación de
Objetos Javascript)

Un lenguaje de marcado es una forma de añadir información adicional a un texto sencillo

de flujo libre, por ejemplo:

Con xml (usando un cierto vocabulario de elementos) puedes poner:

Esto es lo que hace que los lenguajes de marcado sean tan útiles para representar
documentos.

Una notación de objeto como json no es tan flexible. Pero esto suele ser algo bueno.
Cuando representas objetos, simplemente no necesitas la flexibilidad extra. Para
representar el ejemplo anterior en JSON, tendrías que resolver algunos problemas
manualmente que xml resuelve para ti.

8
Fundación Educativa Santisima Trinidad
Curso Python

No es tan bueno como el xml, y la razón es que estamos tratando de hacer un marcado con
una notación de objeto. Así que tenemos que inventar una forma de esparcir fragmentos de
texto plano alrededor de nuestros objetos, usando matrices de "contenido" que pueden
contener una mezcla de cadenas y objetos anidados.

Por otro lado, si tienes una típica jerarquía de objetos y quieres representarlos en un flujo,
json es más adecuado para esta tarea que el html.

Aquí está el xml lógicamente equivalente:

JSON se parece más a las estructuras de datos que declaramos en los lenguajes de
programación. También tiene menos repetición redundante de nombres.

Pero lo más importante de todo es que tiene una forma definida de distinguir entre un
"registro" (artículos no ordenados, identificados por nombres) y una "lista" (artículos
ordenados, identificados por su posición). Una notación de objeto es prácticamente inútil
sin tal distinción. Y el xml no tiene tal distinción! En el ejemplo de XML <Person> es un
registro y <Relatives> es una lista, pero no se identifican como tales por la sintaxis.

En cambio, el XML tiene "elementos" frente a "atributos". Parece el mismo tipo de

distinción, pero no lo es, porque los atributos sólo pueden tener valores de cadena. No

9
Fundación Educativa Santisima Trinidad
Curso Python

pueden ser objetos anidados. Así que no podría haber aplicado esta idea a <Person>
porque no debería tener que convertirme <Relatives> en una sola cadena.

Mediante el uso de un esquema externo, o de atributos extra definidos por el usuario, se

puede formalizar una distinción entre listas y registros en XML. La ventaja de JSON es que
la sintaxis de bajo nivel tiene esa distinción incorporada, por lo que es muy sucinta y
universal. Esto significa que JSON es más "autodescriptivo" por defecto, lo cual es un
objetivo importante de ambos formatos.

Así que JSON debería ser la primera opción para la notación de objetos, donde el punto
dulce de XML es el marcado de documentos.

Desafortunadamente para el XML, ya tenemos el html como el lenguaje de marcado de

texto enriquecido número uno del mundo. Se intentó reformular el HTML en términos de
XML, pero no hay mucha ventaja en esto.

Sin embargo, el formato xml es más avanzado que el mostrado en el ejemplo. Por ejemplo,
se pueden añadir atributos a cada elemento y se pueden utilizar namespaces para dividir
los elementos. También existen estándares para definir el formato de un archivo XML, el
lenguaje XPATH para consultar datos XML, y XSLT para transformar XML en datos de
presentación.

El formato XML existe desde hace tiempo, así que hay mucho software desarrollado
para él. El formato json es bastante nuevo, así que hay mucho menos soporte para él.

Mientras que XML se desarrolló como un formato de datos independiente, JSON se

desarrolló específicamente para su uso con javascript y AJAX, por lo que el formato es
exactamente el mismo que un objeto literal Javascript (es decir, es un subconjunto del
código Javascript, ya que, por ejemplo, no puede contener expresiones para determinar
valores).

10
Fundación Educativa Santisima Trinidad
Curso Python

ARCHIVOS JSON CON PYTHON (Escritura y lectura)

Escribir archivos

La forma más sencilla de generar un archivo JSON desde Python es exportar los datos
contenidos en un objeto diccionario. Al igual que los objetos JSON, los objeto
diccionarios pueden contener cualquier tipo de datos: valores numéricos, cadena de
textos, vectores o cualquier otro tipo de objeto. El código necesario para traducir el
diccionario a formato JSON se encuentra disponible en el paquete json.

A continuación, se muestra un ejemplo.

1. Inicialmente se importa el paquete json.

2. Posteriormente se crear un objeto diccionarios al que se agregan los datos de tres
clientes entre los que se encuentra el nombre los apellidos, la edad y la cantidad
gastada por cada uno.
3. En el ejemplo se pude apreciar la utilización de diferentes tipos de datos como
cadena de texto, valores reales y vectores(listas o arrays). Otra cosa que se
puede apreciar es que una misma propiedad puede tener diferentes datos en cada
registro. Lo que no se puede conseguir en otros formatos como CSV.
4. Finalmente se abre un archivo y se vuelca en el mismo los datos del diccionario
utilizando json.dump.

11
Fundación Educativa Santisima Trinidad
Curso Python

Este comportamiento por defecto es el más adecuado ya que reduce el tamaño de los
archivos generados y por lo tanto reduce el ancho de banda necesario. En caso de que sea
necesario obtener archivos JSON formateados para que puedan ser fácilmente leídos por
personas se puede utilizar la opción indent la indentación de los valores.

Obtener el código JSON como una cadena de texto

En el caso de que se desee obtener el contenido del archivo JSON en una variable se
puede utilizar el método json.dumps. Este devuelve una cadena de texto con el contenido
en lugar de guardarlo en un archivo. Esto puede dar un poco más de control si es necesario
realizar algunas operaciones sobre la cadena, como firmarla o encriptarla.

Leer archivos

La lectura de archivos JSON es similar al proceso de escritura. Se ha de abrir un archivo y

procesar este utilizando el método json.load. El cual devolverá objeto de tipo diccionario
sobre el que se puede iterar. A modo de ejemplo se puede importar el archivo generado
anteriormente y sacar los resultados por pantalla utilizando el siguiente código.

12
Fundación Educativa Santisima Trinidad
Curso Python

CONVERTIR UNA CADENA DE TEXTO CON JSON EN UN

DICCIONARIO

Se puede convertir una cadena de texto que contiene un objeto JSON en un diccionario
de Python. Para esto se ha de utilizar el método json.loads. Este método es de gran utilidad
cuando como resultado de un servicio web se obtiene una cadena de texto con un objeto
JSON, el cual se puede transforma fácilmente en un diccionario.

13
Fundación Educativa Santisima Trinidad
Curso Python

OPCIONES
El comportamiento de la librería json se puede personalizar utilizando diferentes opciones.
Entre algunas de las opciones que se pueden configurar se encuentra la codificación y la
ordenación.

Codificación Unicode

Una de las opciones más importantes puede ser la codificación de texto empleada en el
archivo. defecto el paquete json genera los archivos en código ASCII.

Cuando existen caracteres no ASCII estos serán escapados, aunque puede ser más
interesante utilizar en estos casos codificación Unicode. Para conseguir este cambio
solamente se ha de configurar la opción ensure_ascii a False. La diferencia se puede
apreciar en el siguiente ejemplo.

Ordenación

Los objetos JSON son una colección desordenada de conjuntos de para clave valor. El
orden de los datos se encuentra definido por la posición en la que estos aparecen en el
archivo. En el caos de que sea necesario ordenarlos por la calve se puede configurar la
opción sort_keys a True. El resultado de utilizar esta opción se pude ver en el siguiente
ejemplo.

14
Fundación Educativa Santisima Trinidad
Curso Python

Conclusiones

Se han presentado algunos de los métodos disponibles en el paquete json para trabajar
con archivos JSON con Python. Un formato que cada día se hace más popular en las
aplicaciones web, por lo que tener a mano estas herramientas es cada día más importante.

El paquete json ofrece las funcionalidades básicas para trabajar con archivos en formato
JSON, aunque suficientes en la mayoría de los casos. En los casos en los que este paquete
no es suficiente se puede utilizar la alternativa simplejson que es menos estricta en la
sintaxis JSON.

15
Fundación Educativa Santisima Trinidad
Curso Python

EJERCITACIÓN

Semana 1: Cadena de bytes a Unicode

Crear una variable que contenga el texto que ustedes quieran en formato byte , en lo posible
extenso, y convertirlo a Unicode.

Semana 2: Unicode a cadena de bytes

Crear un archivo.txt que dentro contenga un texto Unicode, abrirlo con Python, recorrerlo y
transformarlo en un cadena de bytes.

Semana 3: JSON
Convertir una lista de cadenas a formato JSON.
Pista: a la hora de crear una lista los contenidos dentro de la misma se muestran con una
comilla simple ‘ ‘ pero cuando esta convertida a json la lista se muestra con comillas dobles
““

Semana 4: JSON
Leer un fichero con el nombre de como mínimo 10 países, recorrerlo y ver cuales son los
nombres más cortos y guardarlo en otro fichero.
Pistas: Utilizar funciones, for ,if, listas, apertura de ficheros, json, len. Para saber cual es el
nombre de los paises más cortos utilizar la función min()

16