29 de mayo de 2016

16.3 Python: tutorial de pseudocódigo

Tutorial de Pseudocódigo

REGLAS

Nota: de la web http://aprenderaprogramar.es
Cada línea del pseudocódigo será numerada como forma de recordarnos que estamos escribiendo instrucciones y que el orden es fundamental. Una vez tengamos soltura podrá prescindirse de los números de línea. La numeración tendrá el formato que se desee (1, 2, 3, 4, 5, ...; 1, 2, 2.1, 2.2, 2.3, 3, 4, ...; 10, 20, 30, 40, ...; 10, 20, 20.1, 20.2, ...)
La asignación de contenidos a variables se hará conforme a lo expuesto: el nombre de la variable seguido de un igual y un número para variables numéricas o un texto entrecomillado para variables de tipo alfanumérico.
LAS VARIABLES COMO BASE DE CÁLCULO
Hay un aspecto diferenciador de la forma de calcular de un humano y la de un ordenador. Los humanos podemos guardar datos en espacios de memoria temporales que no tienen asignado un nombre mientras que el ordenador sólo puede guardar datos a través de variables que necesariamente tienen un nombre. Un humano puede operar de la siguiente manera:
“7 por 2 son 14; si lo multiplico por 6 son 84 y si lo divido por 2 son 42;
le sumo 4 y son 46, que dividido entre 2 son 23”
 
Un ordenador tendrá que operar a través de variables, por ejemplo:
a)   A = 7 * 2  ; A = A * 6 ; A = A / 2 ; A = A + 4 ; A = A / 2
b)   A = 7 * 2  ; B = A * 6 ; C = B / 2 ; D = C + 4 ; E = D / 2
En el caso a) el valor actual de la variable A es 23, habiéndose perdido todos los valores intermedios que fue tomando. En el caso b) el valor final de la serie de cálculos está registrado en la variable E, mientras que las variables A, B, C, D contienen los resultados intermedios.
La cantidad de variables a emplear en un proceso de cálculo dependerá del criterio del programador, quien habrá de valorar el interés que puede tener el conservar resultados intermedios. Con los criterios de economía y eficiencia, buscaremos siempre utilizar el menor número de variables posibles.
 
INSERCIÓN DE COMENTARIOS EN EL PSEUDOCÓDIGO
Una línea o el final de una línea puede ser utilizado para introducir comentarios relativos al pseudocódigo que se está escribiendo. Los comentarios no existen a efectos de instrucción, sino únicamente como aclaración informativa para otra persona que pueda leer el pseudocódigo. A fin de ser identificados los comentarios irán encerrados entre corchetes.
Ejemplos:
5.
M = 12
[Es el número de meses de un año]
ESTO ES VÁLIDO
6.
B = M / 2
[Es el número de bimestres en un año]
 
5.
[Dividimos el peso total entre peso unitario]
ESTO ES VÁLIDO
6.
U = Pt / Pu

5.
S = Dt * Id
[Salario como días trabajados por importe del día]
ESTO ES VÁLIDO

5.
[Número de trabajadores]    Nt = 57
NO VÁLIDO: EL COMENTARIO NO PUEDE SER PRINCIPIO DE LÍNEA
6.
[Días trabajados]    Dt = 19

Para el ordenador una línea que únicamente tiene comentarios es una línea vacía, ya que no contiene instrucciones a ejecutar.
= = =
ORDENACIÓN SIMBÓLICA DEL PSEUDOCÓDIGO
En algún momento dijimos que un algoritmo se divide en pasos o líneas cuyo contenido y extensión es criterio del autor del algoritmo. Vamos a matizar esta afirmación. Si las instrucciones en un algoritmo se ejecutan de izquierda a derecha y de arriba a abajo, en principio dará igual escribir cuatro instrucciones de izquierda a derecha (en una línea) que de arriba a abajo (en cuatro líneas).
La escritura de órdenes una detrás de otra la realizaremos valiéndonos de un elemento de separación, que en nuestro caso serán los dos puntos ( : ). Así podríamos escribir: A = 3 : B = 2 : C = A * B.
Diferentes órdenes relacionadas a través de dos puntos reciben el nombre de órdenes concatenadas y se ejecutan una detrás de otra, de izquierda a derecha. Como decíamos anteriormente, sería equivalente escribir:
1.  Inicio
2.  A = 3 : B = 2 : C = A * B : D = C ^2
     3.  Fin
<- Equivale a ->
1.  Inicio
2.  A = 3
3.  B = 2
4.  C = A * B
5.  D = C ^2
6.  Fin
Parece que la concatenación de órdenes redunda en una mejor economía del algoritmo, puesto que se reduce el número de líneas a emplear. Pero ojo: ¿Por qué no escribirlo todo en una sola línea, incluso los indicadores de inicio y fin? La respuesta nos lleva a las formas de percepción y de comprensión humanas. Un libro cualquiera podría ser escrito en una sola línea. Sin embargo, se organiza en párrafos y líneas utilizando efectos visuales como son las sangrías y los márgenes que afectan más a la percepción que al contenido.
En la escritura de pseudocódigo buscaremos claridad y ordenación visual. No es recomendable escribir muchas órdenes en una sola línea. Para ello nos basaremos en sangrías y en delimitación e información de bloques o procesos. Llamaremos “bloque” a un conjunto de órdenes con interdependencia, estrecha relación o agrupadas con un fin. La sangría se hará siempre respecto a una instrucción o comentario que marcan el inicio y fin de la sangría.
Inicio sangría
--------------------------------> Instrucciones con sangría
Fin de la sangría

Ejemplos:
[Valor de los parámetros]
 A = 7
   B = 16
 C = 3
[Fin de asignación de valor a parámetros]

[Cálculo de superficies]
S1 = 3 * A
S2 = 4 * B
S3 = 2 * C
[Fin de cálculo de superficies]
 
Las sangrías se pueden anidar cuantas veces se quiera.
Ejemplo:
 No existe norma que diga cuantas sangrías se deben introducir. El exceso o defecto pueden ir en contra de la lectura del programa, y ha de ser el programador el que siguiendo una lógica tal como si estuviera escribiendo una novela, defina su estilo para conseguir la máxima claridad. La subordinación se puede originar a partir de comentarios o a partir de órdenes con principio y fin.
Supongamos que una instrucción asigna a la variable suma el resultado de sumar una serie de variables. Escribiríamos:
Suma de variables (SUMA)
A
C
D
M
Fin de suma de variables

 El inicio y fin de la instrucción funcionarían como límites subordinantes mientras que la lista de variables sería el bloque subordinado. Igualmente aceptable sería el no haber utilizado sangría. Sin embargo, es preferible usarla para mayor claridad.
En cuanto a la delimitación e información de bloques y procesos, se trata de buscar que la presentación del programa sea tal que permita buscar e identificar con rapidez las distintas partes del mismo. Para ello nos apoyamos en la introducción de comentarios delimitadores y en sangrías. Veamos con un ejemplo muy “gráfico” lo que sería el mismo pseudocódigo con cuatro formas de presentarlo.
Versión 1

1.  Inicio
2.  T = 32 : TT = 11 : CT = 40 : CTT = 65 : NC = T * CT + TT * CTT
   3.  Fin

Versión 2

1.  Inicio
2.  T = 32
3.  TT = 11
4.  CT = 40
5.  CTT = 65
6.  NC = T * CT + TT * CTT
7.  Fin

 Versión 3

1.  Inicio
2.  [Definición de vehículos aprenderaprogramar.com]
3.  Turismos = 32
4.  Todoterrenos = 11
5.  [Fin de definición de vehículos]
6.  [Definición de capacidad de depósitos]
7.  Capturismos = 40
8.  Captodot = 65
9.  [Fin de definición de capacidad de depósitos]
10.  [Cálculo de necesidades de combustible]
11.  Necesidadescom = Turismos * Capturismos + Todoterrenos * Captodot
12.  [Fin de cálculo de necesidades de combustible]
    13.  Fin

Versión 4

1.  Inicio
2.  [Definición de vehículos]
3.  Turismos = 32
4.  Todoterrenos = 11
5.  [Fin de definición de vehículos]
6.  [Definición de capacidad de depósitos]
7.  Capturismos = 40
8.  Captodot = 65
9.  [Fin de definición de capacidad de depósitos]
10.  [Cálculo de necesidades de combustible]
11.  Necesidadescom = Turismos * Capturismos + Todoterrenos * Captodot
12.  [Fin de cálculo de necesidades de combustible]
13.  Fin

 Comentaremos una a una las diferentes versiones del algoritmo.
La versión 1 Es la menos extensa al reunir todo el proceso en una línea. Sin embargo, es difícilmente interpretable pues no contiene información a modo de comentarios. Tampoco se aprecia delimitación de procesos.
La versión 2 Permite identificar mejor los distintos pasos, aunque sigue siendo difícilmente interpretable.
La versión 3  Es de mayor longitud pero aporta información que hace interpretable el algoritmo, quedando además delimitados los distintos procesos.
La versión 4  No varía en longitud respecto a la tercera, pero mejora la calidad de presentación a través de sangrías.
 Esquemáticamente tendremos:
Economía Mayor
|
|
|
|
|
Menor
Versión 1

Versión 2

Versión 3

Versión 4
Menor
|
|
|
|
|
Mayor
Claridad y calidad
de presentación

Buscaremos la máxima claridad y calidad de presentación, pero sin exageraciones. La identificación de procesos, variables, etc. será la justa y necesaria.
= = =
SENTENCIAS BÁSICAS PARA PROGRAMACIÓN EN PSEUDOCÓDIGO
Llamamos instrucción, orden o sentencia a cualquier expresión que el ordenador reconoce y le induce a realizar un proceso.Ya hemos visto elementos a los que podemos considerar órdenes como:

Inicio ,   equivalente a “Comienza a procesar información”
Fin ,   equivalente a “Termina de procesar información”
Variable1 = número ,   equivalente a “Asigna el número a la variable 1”
Variable1 = texto ,   equivalente a “Asigna el texto a la variable 1”
Variable1 = Variable2 ,   equivalente a “Asigna el contenido de la variable 2 a la variable 1”

Junto a éstas, las órdenes más habituales son las de captura y emisión de datos. Entenderemos por captura la recepción de un dato que proviene de:
· Una entrada de teclado manejada por el usuario.
· Un archivo.
· Una base de datos.
· Un dispositivo periférico.
· Un ordenador.
· Otros dispositivos.
Para escritura de algoritmos diferenciaremos entre:
1. Entradas de teclado, que escribiremos como Pedir VAR, siendo VAR la variable a la que se asigna la entrada de teclado.
2. Entradas desde archivo, bases de datos, etc. que escribiremos como Leer VAR, siendo VAR la variable a la que se asigna la información contenida en un archivo, base de datos, etc.
En cuanto a emisión de datos, será cualquier proceso de salida de datos desde el programa hacia:
· La pantalla.
· La impresora.
· Un archivo.
· Una base de datos.
· Otros dispositivos.
Para la escritura de algoritmos nos quedaremos de momento con Mostrar como instrucción para visualizar elementos en la pantalla del ordenador e Imprimir como indicador de que se mandan los datos a impresora.
La sintaxis que emplearemos es la siguiente: Pedir y Leer irán siempre seguidos de un nombre de variable, o de varios nombres seguidos por comas.
Ejemplo:       Pedir salario
                      Pedir Edad, Altura, Peso
Mostrar e Imprimir podrán ir seguidos de variables, números o texto separados por comas. El texto, como venimos haciendo habitualmente, irá entrecomillado.
Ejemplo:      Mostrar “No se ha encontrado una solución”
                     Mostrar “El salario a percibir es”, salario, “pesetas”
                     Imprimir “Tiene derecho a”, 100, Periodo, “de vacaciones”
Cuando se desea que la petición de un dato vaya acompañada de un mensaje lo haremos encadenando un mostrar con el mensaje, dos puntos, y la petición de variable.
Ejemplo:     Mostrar “Introduzca su peso en Kgs por favor” : Pedir Peso
                    Mostrar “Introduzca la temperatura en ºC” : Pedir TempCelsius              
Mostrar “Introduzca su fecha de nacimiento como dd/mm/aaaa” : Pedir Fechanam       
Si volvemos al caso antes visto de los vehículos y el combustible, podemos ahora escribir un algoritmo más enfocado a lo que es la interacción entre el usuario y el ordenador. Este sería el siguiente:
1.  Inicio
2.  [Petición de datos]
3.  Mostrar “Por favor, introduzca el número de turismos” : Pedir Turismos
4.  Mostrar “Por favor, introduzca el número de todoterrenos” : Pedir Todoterrenos
5.  Mostrar “Por favor, introduzca la capacidad del depósito de un turismo, en litros” : Pedir Capturismos
6.  Mostrar “Por favor, introduzca la capacidad del depósito de un todoterreno, en litros” : Pedir Captodot
7.  [Fin de petición de datos]
8.  [Cálculo y muestra de resultados]
9.  Necesidadescom = Turismos * Capturismos + Todoterrenos * Captodot
10.  Mostrar “Las necesidades totales de combustible son de”, Necesidadescom, “litros” 
11.  [Fin de cálculos y muestra de resultados]
12.  Fin
 
Nos encontramos ya ante un programa tipo de un ordenador:
Datos   ------------->   Proceso o cálculo   --------------->   Resultados

16.2 Python: diagramas de flujo y pseudocódigo

Introducción


Los símbolos de un diagrama de flujo

Antes de dibujar un diagrama de flujo, conviene saber qué significan, al menos, los símbolos más importantes o usados. Información completa en la página http://creately.com/blog/diagrams/flowchart-guide-flowchart-tutorial/

Símbolo

Uso

Ejemplo

TERMINAL: cartucho; usado al comienzo o alfinal de un programa
PROCESO: un rectángulo; ilustra una acción (lleva un verbo), una operación matemática.
DATOS Entrada/Salida I/O: paralelogramo; representa la información que el ordenador obtiene mediante un método de entrada como el teclado. También la información que se registra en un periférico de salida
DECISIÓN (condicional IF): diamante; corresponde a una pregunta que hacemos en el programa y que se contesta con SÍ o NO (o verdadero o falso). Tiene un camino de entrada y dos de salida. Si tiene más líneas de salida, es una SELECCIÓN MÚLTIPLE.
INFORME O MENSAJE: rectángulo con la base en línea curva; representa la impresión de un mensaje en el programa
SUBPROCESO o PROCESO PREDEFINIDO (SUBRUTINA): rectángulo con barras laterales; proceso importante que puede descomponerse en procesos más simples y que dan lugar a otro diagrama de flujo
TECLADO: rectángulo cortado por línea superior; entrada manual de datos por el usuario. Se puede utilizar a veces en lugar del símbolo de entrada/salida
DATOS: Información guardada en memoria interna RAM.
storedd data shape DATOS: información guardada o leída desde cualquier dispositivo de almacenamiento. Principalmente en ficheros.
DATOS: información guardada o leída desde el disco duro (instantánea). Si el símbolo se representa en vertical, representa a una base de datos.
On-page reference shapehttp://www.conceptdraw.com/How-To-Guide/picture/diagram-software-flow-chart-symbols/flow-chart-symbols-Off-pageconnector.png CONECTORES: el círculo usado para conectar partes en una misma página, el segundo en varias páginas.
delay shape ESPERA: en un programa representa un período de inactividad.
MENSAJES EN PANTALLA: mensajes de atención al usuario.

Estructuras repetitivas o complejas

MIENTRAS: dada una expresión al principio de la iteración esta es evaluada; si la condición es verdadera realizará el ciclo, si es falsa la repetición cesará. DO - WHILE
PARA (FOR): Esta estructura de control repetitiva se usa generalmente cuando se conoce de antemano el numero de iteraciones. Incluye el símbolo de PREPARACIÓN (ITERACIÓN)
FOR
HASTA: funciona igual que la estructura Mientras, con la diferencia que al menos una vez hará el grupo de instrucciones y luego evaluará una condición. Si la condición evaluada es falsa continua dentro del ciclo y si es verdadera termina la iteración. WHILE - UNTIL
SELECCIÓN MÚLTIPLE: dada una expresión permite escoger una opción de muchas. SWITCH

Recomendaciones para el diseño de Diagramas de Flujo

  • Se deben usar solamente líneas de flujo horizontales y/o verticales.
  • Se debe evitar el cruce de líneas utilizando los conectores.
  • Se deben usar conectores sólo cuando sea necesario.
  • No deben quedar líneas de flujo sin conectar.
  • Se deben trazar los símbolos de manera que se puedan leer de arriba hacia abajo y de izquierda a derecha.
  • Todo texto escrito dentro de un símbolo deberá ser escrito claramente, evitando el uso de muchas palabras.

16.1 Pyhton: algoritmos. Tipos de variables.

Introducción a los algoritmos

¿QUÉ ES ALGORITMO?

La palabra algoritmo se deriva de la traducción al latín de la palabra árabe alkhowarizmi, nombre de un matemático y astrónomo árabe que escribió un tratado sobre manipulación de números y ecuaciones en el siglo IX.

Un algoritmo es una serie de pasos organizados que describe el proceso que se debe seguir, para dar solución a un problema específico.

¿TIPOS DE ALGORITMOS…?

Existen dos tipos y son llamados así por su naturaleza:
  •     Cualitativos: Son aquellos en los que se describen los pasos utilizando palabras.
  •     Cuantitativos: Son aquellos en los que se utilizan cálculos numéricos para definir los pasos del proceso.
DESCRIPCIÓN DE ALGORITMOS
Solemos describir los algoritmos de dos formas: con un lenguaje gráfico, de grafos, llamado diagrama de flujo o con un lenguaje "natural", pseudocódigo, que describe la operación casi tal como un "humano" lo haría.
METODOLOGÍA DE DESARROLLO DE ALGORITMOS
Hay que tener en cuenta que un ordenador es una máquina con gran potencia de cálculo y almacenamiento de datos, pero a la que, a priori no se le ha enseñado a hacer nada. Es como un niño pequeño que, además, no tiene capacidad de aprender (¡por ahora!) así que, si no le decimos cómo, no sabe qué hacer con sus grandes habilidades. Por eso es que necesitamos darle una serie de instrucciones para que haga lo que queremos que haga (programa), normalmente para resolver un problema con una serie de datos de partida. Esa serie de instrucciones estarán codificadas en un lenguaje de programación específico, y, se escribirán en base a un guión de cómo se resuelve el problema que nos ocupa. Ese guión es el algoritmo.
  • DEFINICIÓN DEL PROBLEMA: El problema se enuncia, de la forma más clara y precisa posible. Las imprecisiones pueden conllevar grandes desastres.
  • ANÁLISIS DEL PROBLEMA: tenemos que tener claro los datos que ses suministran al ordenador (entrada),  los resultados o datos que queremos obtener (salida) y los métodos o fórmulas que tenemos que desarrollar para conseguirlo.
  • DISEÑO DEL ALGORITMO: Las características de un buen algoritmo son:
    • Debe tener un punto particular de inicio.
    • Debe ser definido, no debe permitir dobles interpretaciones.
    • Debe ser general, es decir, soportar la mayoría de las variantes que se puedan presentar en la definición del problema.
    • Debe ser finito en tamaño y tiempo de ejecución.
    • Prueba de escritorio o Depuración: comprobar si responde adecuadamente como se esperaba.

    Tipos de variables a usar en un algoritmo y expresiones

    Ya hemos visto que las variables pueden ser numéricas, de varios tipos, lógicas (valer 0 ó 1) o alfanuméricas (cadenas de texto), según el tipo de valor que almacenen. Atendiendo a su uso dentro de un programa pueden, además, ser:
  • Variables de Trabajo: Variables que reciben el resultado de una operación matemática completa y que se usan normalmente dentro de un programa.
    Ejemplo:
    Suma = a + b /c
  • Contadores: Se utilizan para llevar el control del numero de ocasiones en que se realiza una operación o se cumple una condición; muy habitualmente, pero no siempre, se incrementan de uno en uno.
  • Acumuladores: Forma que toma una variable y que sirve para llevar la "suma acumulativa" de una serie de valores que se van leyendo o calculando progresivamente.
Las variables, combinadas con los operadores que expresan diversas operaciones matemáticas, lógicas o de comparación (relacionales), forman expresiones. Para cada valor de las variables, las expresiones devolverán un valor determinado. Ejemplo, a + (b + 3) / c.



04.6 Python: ¿Qué es un algoritmo?


04.5 Anexo Python: paradigmas y enfoque top-down

Paradigma

Thomas Kuhn, Structure of Scientific Revolutions (1962): "A paradigm is a constellation of concepts, values, perceptions and practices shared by a community which forms a particular vision of reality that is the basis of the way a community organises itself". Un paradigma es una amalgama de conceptos, valores, percepciones y prácticas compartidas por una comunidad que construye una visión particular de la realidad que es la base de la forma en la que la comunidad se organiza a sí misma.
En pocas palabras, es una forma de pensar, una forma de hacer las cosas: una forma de enfocar la realidad, un modelo de la realidad. A veces los paradigmas son conscientes, muchas veces no. Los paradigmas, pueden ser negativos o positivos, aceptarse o no aceptarse.
Ejemplo: ¿las cosas más caras son de mayor calidad? http://www.yorokobu.es/vino-caro/

Paradigmas en la programación

A la hora de programar también hay paradigmas: hay maneras de enfocar cómo diseñar un programa. Entre ellas:
  • Paradigma imperativo: el ordenador acepta órdenes en secuencia, y va cambiando el valor o estado de ciertas variables hasta conseguir la resolución de un problema (algoritmo). Hay una estructura y existe también una modularidad, es decir, ciertas partes del programa pueden reutilizarse varias veces en él u otros programas.
    • Paradigma de programación orientado a objetos (POO): es una variante del paradigma imperativo en el que, además, se declaran objetos que tienen propiedades y métodos propios.
    • Paradigma dinámico: un problema complejo se resuelve dividiéndolo en problemas más pequeños y resolviendo estos últimos, de manera recursiva. Los algoritmos dinámicos intentan optimizarse evitando resolver subproblemas varias veces (memoización).
  • Paradigma declarativo: en él el usuario describe el problema, sus condiciones e indica qué solución quiere encontrar, pero no da las instrucciones precisas de cómo encontrar la solución. Dentro del paradigma declarativo encontramos programación funcional (basada en funciones), lógica (basada en hechos, restricciones y planteamiento de hipótesis) y programación con restricciones.
  • Multiparadigma: usar más de un paradigma de programación en un lenguaje. De hecho, Python es un lenguaje imperativo, que soporta la POO y que puede utilizar, por ejemplo, el lenguaje específico, de tipo declarativo SQL.

Enfoque top-down

En el enfoque top-down formulamos un problema de su generalidad a sus partes. Vamos dividiendo el problema principal en subproblemas, cada vez con mayor nivel de detalle hasta completar el problema en sus totalidad.
Un enfoque top-down puro no resuelve el problema hasta no tener completado todos los niveles de subproblemas necesarios.
Se contrapone al enfoque bottom-up, en el que resolvemos pequeños problemas para después unirlos o usarlos y poder resolver problemas de mayor complejidad.
Actualmente se suele preferir usar un enfoque top-down, aunque con uso de código para resolver problemas parciales, lo que le da cierto aire de bottom-up. También se suele resolver el problema parcialmente usando la técnica de top-down, y completarlo usando técnicas de bottom-up o top-down.

enfoque top down

24 de mayo de 2016

Root Guadalinex

  1. Arrancar con un linux
  2. Montar el disco duro donde está Guadalinex.
  3. Buscar la carpeta GRUB. 
  4. Modificar el grub.cnf y marcar con un asterisco donde esté el passwd. También en menu.lst
  5. Cuando esté arrancando grub, pulsar ESC.
  6. Aparece el listado del GRUB. Marcar "e" sobre recovery mode.
  7. Cambiar la contraseña a otra que te sepas. Pulsa "b" (boot)
  8. En la lista arrancas el modo recovery. Pon la contraseña que escribistes antes.
  9. Accedes como root...

23 de mayo de 2016

60. PR17 Conversor de bases de datos

PR17: Convirtiendo bases de datos: de MySQL a XML y JSON

Usa la base de datos en MySQL del ejemplo para hacer lo siguiente:
  1. Lee los registros de los nombres y de la fecha de creación de la calle.
  2. Traspasa estos datos a dos ficheros: uno XML y otro JSON con estos datos.
  3. Guarda los ficheros.
  1. Programa realizado. 

59. JSON y Python. MySQL y Python.

¿Qué es JSON?


JSON (JavaScript Object Notation) es un formato para el intercambios de datos, básicamente JSON describe los datos con una sintaxis dedicada que se usa para identificar y gestionar los datos. JSON nació como una alternativa a XML, el fácil uso en javascript ha generado un gran numero de seguidores de esta alternativa. Una de las mayores ventajas que tiene el uso de JSON es que puede ser leído por cualquier lenguaje de programación. Por lo tanto, puede ser usado para el intercambio de información entre distintas tecnologías.
  • En JSON se utiliza la sintaxis nombre/valor, separados por dos puntos "Manzanas": 20
  • Los tipos de valores a usar son string, numérico (int, float) , boolean, array [], objeto {} y null.
  • Un objeto JSON se identifica entre llaves: { "NombreFruta":"Manzana" , "Cantidad":20 }
  • Se pueden usar arrays, entre corchetes []
{
"Frutas": [
{ "NombreFruta":"Manzana" , "cantidad":10 }, 
{ "NombreFruta":"Pera" , "cantidad":20 }, 
{ "NombreFruta":"Naranja" , "cantidad":30 }
]
}
  • Por poner un ejemplo, tenemos un JSON formado por un array de dos elementos, los cuales a su vez son objetos, que a su vez son arrays de tres elementos
{"Fruteria":
 [
  {"Fruta":
   [
    {"Nombre":"Manzana","Cantidad":10},
    {"Nombre":"Pera","Cantidad":20},
    {"Nombre":"Naranja","Cantidad":30}
   ]
  },
  {"Verdura":
   [
    {"Nombre":"Lechuga","Cantidad":80},
    {"Nombre":"Tomate","Cantidad":15},
    {"Nombre":"Pepino","Cantidad":50}
   ]
  }
 ]
}
  • Para, por ejemplo, acceder a la cantidad de manzanas que tenemos, tengo que acceder al elemento 0 de "Frutería", y dentro de él al elemento 0 de "Fruta" y recuperar el valor de la etiqueta "Cantidad".
  • Con algo así:  json['Fruteria'][0]['Fruta'][0]['Cantidad']

Trabajando con JSON

Formateando un diccionario como JSON
# coding: utf-8

import json

data = {"Fruteria": [  {"Fruta":   [    {"Nombre":"Manzana","Cantidad":10},    {"Nombre":"Pera","Cantidad":20},    {"Nombre":"Naranja","Cantidad":30}   ]  },  {"Verdura":   [    {"Nombre":"Lechuga","Cantidad":80},    {"Nombre":"Tomate","Cantidad":15},    {"Nombre":"Pepino","Cantidad":50}   ]  } ]}

#Nos imprime en pantalla data como un tipo de dato nativo.
print 'DATA:', str(data)

#Nos devuelve el String con el JSON
data_string = json.dumps(data) # --> Analiza el dato como JSON 
print 'JSON:', data_string
El resultado está codificado como UTF-8. Para decodificarlo como UNICODE, añadir:
decoded = json.loads(data_string)
print 'DECODIFICADO:', decoded
El elemento original data, el codificado como JSON y el vuelto a decodificar no son iguales. Añade el código siguiente y cambia, data por data_string y por decoded. Analiza y piensa en lo que has obtenido.
tab = "-" * 3
for clave, elemento in data.items():
    # --> elemento es un diccionario, luego la clave es Fruteria, y elemento es el resto
    print tab,clave
    # print elemento # -> Imprimiría una lista de DOS elementos
    tab += tab
    for i in elemento: # -> recuerda, elemento es una lista. Tiene dos elementos diccionarios
        for clave, j in i.items(): 
            print tab, clave # --> Saca las claves, "Fruta" y "verdura
            # print j # -> Imprimiría dos listas
            for k in j:
                # --> print k, cada "k" es un diccionario
                for clave, l in k.items():
                    print tab,tab,clave, ": ", l
De hecho, al escribir nosotros la variable data, hemos creado un objeto JSON, compuesto por diccionarios y listas anidados. Al usar la orden json.dumps(), el objeto data_string es codificado como una simple cadena de texto, y tratada como tal. Al volver a decodificarla , la vuelve a convertir a objeto.
¿Qué importancia tiene? Pues que al guardar un objeto JSON en un fichero lo tenemos que hacer como texto... Y al revés, al recuperarlo lo tengo que extraer como texto y convertirlo a objeto.
Guardar objeto JSON
# coding: utf-8

import json

data = {"Frutería": [  {"Fruta":   [    {"Nombre":"Sandía","Cantidad":10},    {"Nombre":"Pera","Cantidad":20},    {"Nombre":"Naranja","Cantidad":30}   ]  },  {"Verdura":   [    {"Nombre":"Lechuga","Cantidad":80},    {"Nombre":"Tomate","Cantidad":15},    {"Nombre":"Pepino","Cantidad":50}   ]  } ]}

data_string = json.dumps(data, ensure_ascii=False) # --> Ensure ascci False ASEGURA guardar en UTF-8 

archivo = open("fruteria.txt","w")
archivo.write(data_string.encode("utf-8")) # --> Ensure ascci False ASEGURA guardar en UTF-8 JUNTO CON codificar en UTF-8
archivo.close()
Recuperar objeto JSON
# coding: utf-8

import json

archivo = open("fruteria.txt","r")
data_string = archivo.read()
archivo.close()

# --> Obtenido como cadena de texto
print data_string

data = json.loads(data_string)
tab = "-" * 3
for clave, elemento in data.items():
    # --> elemento es un diccionario, luego la clave es Fruteria, y elemento es el resto
    print tab,clave
    # print elemento # -> Imprimiría una lista de DOS elementos
    tab += tab
    for i in elemento: # -> recuerda, elemento es una lista. Tiene dos elementos diccionarios
        for clave, j in i.items(): 
            print tab, clave # --> Saca las claves, "Fruta" y "verdura
            # print j # -> Imprimiría dos listas
            for k in j:
                # --> print k, cada "k" es un diccionario
                for clave, l in k.items():
                    print tab,tab,clave, ": ", l
= = =
Cómo presentar los datos de un objeto JSON pasado a cadena de texto
# coding: utf-8

import json

data = {"Frutería": [  {"Fruta":   [    {"Nombre":"Sandía","Cantidad":10},    {"Nombre":"Pera","Cantidad":20},    {"Nombre":"Naranja","Cantidad":30}   ]  },  {"Verdura":   [    {"Nombre":"Lechuga","Cantidad":80},    {"Nombre":"Tomate","Cantidad":15},    {"Nombre":"Pepino","Cantidad":50}   ]  } ]}

desordenado = json.dumps(data)
ordenado = json.dumps(data, sort_keys=True) # --> Ordena por índices: Cantidad primero, nombre después, pero no por valores.
ordenado2 = json.dumps(data, sort_keys=True, indent=1) # --> Los presenta de una forma más legible. 
compacto = json.dumps(data, separators=(',',':')) #-> quita los espacios. Ahorra bytes en los ficheros.

print 'JSON:', desordenado,"\n"
print 'SORT:', ordenado,"\n" 
print 'SORT2:', ordenado2,"\n"
print 'COMPACTO:', compacto,"\n"

print 'UNSORTED MATCH:', desordenado == ordenado
print 'SORTED MATCH  :', ordenado == ordenado2
= = =

¿Qué es MySQL?

MySQL es un gestor de bases de datos relacionales muy usado por páginas web en todo el mundo para gestionar sus datos, desde la misma Wikipedia, hasta Facebook y Youtube.
Su uso suele ser online, y se encuentra asociado al desarrollo de lenguajes de progrmación en el lado del servidor como PHP. MySQL funciona bajo varias plataformas, aunque nosotros la solemos utilizar en Linux. Por ejemplo, el servidor donde está alojado nuestra plataforma Moodle utiliza P.H.P. 5.5.9, MySQL 5.5.47 y Apache 2.4.7 como servidor de páginas web.
Su potencia y rapidez, sobre todo en la lectura de datos, lo convierte en un gestor rápido adecuado para Internet. También su uso es fácil, no demasiado complejo de aprender. Se reduce al estudio de secuencias SQL.
= = =
Instalando MySQL (y el servidor Apache y PHP en LINUX)
Manejo de MySQL

= = = 

MySQL y Python

Callejero de madrid

Utilidad. Determinar la codificación de un fichero y cambiarla.

Python es capaz de manejar datos en MySQL. Para ello, antes de empezar, instala (si no lo tienes) la librería estándar de python para manejar bases de datos mysql.
sudo apt-get install python-mysqldb
Acceso a una base de datos MySQL en mi propio equipo (localhost)
Escribe el siguiente código. Para ello tendrás que instalar antes la base de datos callejero_madrid e importar los datos de la tabla callejero: descarga el fichero callejero_madrid.sql, crear en Phpmyadmin una base de datos llamada callejero_madrid y dentro de ella, usando la utilidad IMPORTAR, recuperar los datos.
# coding: utf-8
import MySQLdb

# datos IMPRESCINDIBLES de conexión 
DB_HOST = 'localhost'            # -> servidor
DB_USER = 'root'                 # -> usuario administrador o con permisos GRANT
DB_PASS = 'mipassword'           # -> contraseña de usuario
DB_NAME = 'callejero_madrid'     # -> Nombre de la base de datos

# Función que conecta y ejecuta una consulta 
def run_query(query=''): 
    datos = [DB_HOST, DB_USER, DB_PASS, DB_NAME] 
 
    conn = MySQLdb.connect(*datos,charset='utf8') # Conectar a la base de datos, con el juego de caracteres UTF-8
    cursor = conn.cursor()         # Crear un cursor 
    cursor.execute(query)          # Ejecutar una consulta 
 
    if query.upper().startswith('SELECT'): 
        data = cursor.fetchall()   # Traer los resultados de un select 
    else: 
        conn.commit()              # Hacer efectiva la escritura de datos 
        data = None 
 
    cursor.close()                 # Cerrar el cursor 
    conn.close()                   # Cerrar la conexión 
 
    return data

# programa principal
datos = run_query("SELECT Literal from callejero LIMIT 100") # -> Nombre de una tabla de la base de datos.
# print datos
for i in datos:
    print i[0]
Pero usando SQL no sólo se pueden leer datos...
También se pueden insertar... En el programa principal modifica por
# programa principal
insertar = "INSERT INTO `callejero_madrid`.`callejero` (`Codigo de via`, `Clase de la via`, `Particula de la via`, `Nombre de la via`, `Estado de la via`, `Tipo de denominacion de la via`, `Distritos atravesados (sólo vias historicas)`, `Literal`, `Fecha del alta de la denominacion de via`, `Fecha del baja de la denominación de via`) VALUES ('127 ', 'CALLE', '', 'Inventada por mí', 'Vigente', 'Pleno', '', 'Calle Inventada por mí', '2015-11-11', '')"
run_query(insertar)
O se puede seleccionar un registro por un determinado criterio de búsqueda...
# programa principal
buscar = "SELECT * FROM `callejero` WHERE `Nombre de la via` LIKE '%Marañón%' "
datos = run_query(buscar)
for i in datos:
    print i[4]
El resto del tutorial entraría en el apasionante pero difícil tema de hacer páginas web con Python. Yo recomendaría previamente el estudio de tecnologías como HTML, CSS, PHP, Javascript y JQuery.

58. Análisis de documentos XML en Python

Acceso al XML de ejemplo: catalogo.xml
  1. Tutorial DOM y XML (inglés).
  2. Para saber más.
  3. Datos abiertos Gobierno de España

Analizar contenido XML con DOM

Al escribir un programa en Python, usaremos el estándar DOM del W3C. Cargaremos el documento como un objeto, usando el módulo xml.dom y recuperando el objeto "minidom", que provee un acceso rápido al documento.
NOTA: tanto el fichero en Python como el fichero de ejemplo cd_catalogo.xml (descárgalo) deben estar en la misma carpeta.
#!/usr/bin/python
# coding: utf-8

from xml.dom.minidom import parse
import xml.dom.minidom

# Abre el documento XML usando el analizador (parser) minidom
DOMTree = xml.dom.minidom.parse("cd_catalogo.xml") #-> Modelo del Documento en forma de árbol
collection = DOMTree.documentElement # -> Objeto raíz
print "El nombre de la coleccion es: %s \n" % collection.localName

# Obtiene una lista de los objetos con la etiqueta CD
cds = collection.getElementsByTagName("CD")

# Muestra en pantalla cada detalle de cada CD
for cd in cds:    
   print "*****CD*****" 
   titulo = cd.getElementsByTagName('TITULO')[0]
   print "Título: %s" % titulo.childNodes[0].data.encode("utf-8")
   artista = cd.getElementsByTagName('ARTISTA')[0]
   print "artista: %s" % artista.childNodes[0].data.encode("utf-8")
   pais = cd.getElementsByTagName('PAIS')[0]
   print "País: %s" % pais.childNodes[0].data.encode("utf-8")
   comp = cd.getElementsByTagName('PAIS')[0]
   print "Compañía: %s" % comp.childNodes[0].data.encode("utf-8")
   precio = cd.getElementsByTagName('PRECIO')[0]
   print "Precio: %s €" % precio.childNodes[0].data.encode("utf-8")
   anno = cd.getElementsByTagName('ANNO')[0]
   print "Año: %s" % anno.childNodes[0].data.encode("utf-8")
   print "=" * 20 + "\n"
Todos los métodos del xml.dom pueden encontrarse en: https://docs.python.org/2.7/library/xml.dom.html
= = =

Abrir fichero XML y presentarlo en pantalla

Apertura del fichero XML y presentación en pantalla
#!/usr/bin/python
# coding: utf-8

from xml.dom.minidom import parse
import xml.dom.minidom

# Abre el documento XML usando el analizador (parser) minidom
modelo = xml.dom.minidom.parse("cd_catalogo.xml") #-> Modelo # #  del Documento en forma de árbol. Apertura por nombre
# O bien
# fichero = open("cd_catalogo.xml")
# modelo = parse(fichero) # Otra forma de abrir el fichero.

coleccion = modelo.documentElement # -> Objeto raíz
print "El nombre de la coleccion es: %s \n" % coleccion.localName

print coleccion.toxml()
# print coleccion.toprettyxml() # --> formas de presentar los daros como un bloque
 
= = = 
 

Crear un fichero XML y guardarlo

Crear un fichero XML
# coding: utf-8

from xml.dom import minidom

Ordenador1 = ['Pentium M', '512MB']
Ordenador2 = ['Pentium Core 2', '1024MB']
Ordenador3 = ['Pentium Core Duo', '1024MB']
listaOrdenadores = [Ordenador1, Ordenador2, Ordenador3]

# Abro un modelo DOM en modo implementar
DOMimpl = minidom.getDOMImplementation()

#Crear el documento econ la etiqueta principal estacionesTrabajo
xmldoc = DOMimpl.createDocument(None,"estacionesTrabajo", None)
doc_root = xmldoc.documentElement

# Recorro la lista de ordenadores
for ordenador in listaOrdenadores:
    
    #Crear Nodo... (*)
    nodo = xmldoc.createElement("Ordenador")

    # Crear un subnodo, llamado procesador
    elemento = xmldoc.createElement('Procesador')
    # Le añado un nodo de texto, y le asigno la posición 0 de la lista
    elemento.appendChild(xmldoc.createTextNode(ordenador[0]))
    # Añado el subnodo al nodo anterior
    nodo.appendChild(elemento)
    
    # Idéntico.
    elemento = xmldoc.createElement('Memoria')
    elemento.appendChild(xmldoc.createTextNode(ordenador[1]))
    nodo.appendChild(elemento)

    # (*)... que se añade como hijo al doc_root
    doc_root.appendChild(nodo)

# Recorrer para presentar en pantalla la lista de los nodos
listaNodos = doc_root.childNodes
for nodo in listaNodos:
    print nodo.toprettyxml()

# Guardar la información en un fichero de texto
fichero = open("ordenadores.xml", 'w')
# fichero.write(xmldoc.toxml())
# fichero.write(xmldoc.toprettyxml()) --> diferentes formas de guardar un fichero xml
fichero.write(xmldoc.toprettyxml(encoding="utf-8"))
fichero.close()
 
= = = 
 

Análisis de los elementos de la primera etiqueta en cd_catalogo.xml

# coding: utf-8

from xml.dom import minidom                                      

xmldoc = minidom.parse('cd_catalogo.xml')   
print xmldoc                                                               
grammarNode = xmldoc.firstChild
print grammarNode # CATALOGO

refNode = grammarNode.childNodes[1]     
print refNode #--> Nivel 1, etiqueta CD.
print refNode.childNodes  # --> Todo lo que hay bajo la etiqueta CD                         

pNode = refNode.childNodes[3]
print pNode #--> El elemento que está tercero. "ARTISTA"
print pNode.toxml()  # -> Impresión de dicho nodo.

print pNode.firstChild      #-> Texto que hay dentro de "ARTISTA", pero como objeto                         
print pNode.firstChild.data #-> Texto extraído del objeto anterior.
 
= = = 
 

Extraer texto y modificarlo

Extraigo texto del fichero de ejemplo cd_catalogo.xml y lo modifico. En particular a la primera entrada "Empire Burlesque", se le hace la modificación "Imperio Burlesco". En el ejemplo, los datos se escriben en un nuevo fichero cd_catalog2.xml
#!/usr/bin/python
# coding: utf-8

from xml.dom.minidom import parse
import xml.dom.minidom

# Abre el documento XML usando el analizador (parser) minidom
modelo = xml.dom.minidom.parse("cd_catalogo.xml") #-> Modelo # #  del Documento en forma de árbol. Apertura por nombre
# O bien
# fichero = open("cd_catalogo.xml")
# modelo = parse(fichero) # Otra forma de abrir el fichero.
# después al final habrá que cerrar el fichero. fichero.close()

coleccion = modelo.documentElement # -> Objeto raíz
print "El nombre de la coleccion es: %s \n" % coleccion.localName

cds = coleccion.getElementsByTagName("CD")

for cd in cds:    
    
    titulo = cd.getElementsByTagName("TITULO")
    # titulo es una lista de Nodos, aunque sólo sea uno. Lo siguiente print titulo.toxml() no funcionará
    # print titulo[0].toxml() Esto si funcionará
    # print titulo[0].childNodes # --> Esto es un objeto
    print titulo[0].childNodes[0].data #--> Accede a un dato de texto
    # print titulo[0].childNodes[0].data.encode("utf-8") #-> no está de más codificar en utf-8
    if titulo[0].childNodes[0].data.encode("utf-8") == "Empire Burlesque":
        print "detectado"
        titulo[0].childNodes[0].data = u'Imperio Burlesco' # --> Tiene que ser en formato UNICODE u''
        print titulo[0].childNodes[0].data #--> Accede a un dato de texto
    print "=" * 20    

fichero = open("cd_catalogo2.xml","w")
# fichero = open("cd_catalogo.xml","w") # --> Para sobrescribir en el mismo fichero.
fichero.write(coleccion.toxml(encoding='utf-8')) #--> Forzar la codificación a UTF-8
fichero.close()
# print coleccion.toprettyxml() # --> formas de presentar los daros como un bloque '''
 
= = =
 

Generar fichero XML con DOM

Generar fichero XML con DOM
# coding: utf-8

from xml.dom import minidom, Node

doc = minidom.Document() #--> Crear un documento xml

doc.appendChild(doc.createComment("Creando documento de ejemplo XML")) #-> Escribir comentario

book = doc.createElement('libro') # --> Crear elemento dentro del documento
doc.appendChild(book) #-> Añadirlo a la raíz del documento

title = doc.createElement('Título') # --> Crear elemento título
title.appendChild(doc.createTextNode('D. Quijote de La Mancha')) # --> Agrgar nodo de texto
book.appendChild(title) # --> Añadir dentro del elemento book

author = doc.createElement('Autor') # --> Crear elemento Autor
book.appendChild(author) # --> Añadir al elemento libro

name = doc.createElement('Nombre y Apellidos')  # --> Crear elemento Nombre y Apellidos
author.appendChild(name) # --> Añadir dentro de Autor

firstname = doc.createElement('Nombre') # --> Crear elemento Nombre
name.appendChild(firstname)
firstname.appendChild(doc.createTextNode('Miguel'))
name.appendChild(doc.createTextNode('Texto añadido aquí'))
lastname = doc.createElement('Apellidos') # --> Crear elemento  Apellidos
name.appendChild(lastname)
lastname.appendChild(doc.createTextNode('De Cervantes Saavedra'))

chapter = doc.createElement('Capítulo')
book.appendChild(chapter)
chapter.setAttribute('number', '1')
title = doc.createElement('title')
chapter.appendChild(title)
title.appendChild(doc.createTextNode('Capítulo Primero'))

print doc.toprettyxml(indent =' ')

= =  =

Presentar documento XML en forma de árbol

Presentar documento XML en forma de árbol
# coding: utf-8

from xml.dom import minidom, Node

def scanNode(node, level = 0):
    msg = node.__class__.__name__
    texto=""
    if node.nodeType == Node.ELEMENT_NODE:
        msg += ", tag: " + node.tagName
    elif node.nodeType == Node.TEXT_NODE:
        texto = ": "+node.data
    print " " * level * 4, msg, texto
    if node.hasChildNodes:
        for child in node.childNodes:
            scanNode(child, level + 1)
            
doc = minidom.parse('cd_catalogo.xml') 
scanNode(doc)
 
= = =  
 

 
 

57. Ficheros XML con Python.

Introducción a XML

Para saber más: http://www.w3schools.com/xml/default.asp

¿Qué es XML?

XML es una herramienta de software (y hardware) para guardar y transportar datos. Hoy en día, por su difusión en muchos sistemas, es importante conocerla para cualquier desarrollador de software. Es recomendable saber algo de HTML y Javascript antes de aprender a usar XML.
XML significa Lenguaje de Marcado Extensible (EXtensible Markup Language). Es un lenguaje de marcado como HTML. Recomienda su uso el W3C y se diseñó tanto para que las máquinas como las personas pudieran entender fácilmente la información que contienen.
Imagina que Antonio quiera enviar una nota a Maricarmen. La nota podría ser así:
Para: Maricarmen
De: Antonio
Asunto: Recordatorio
Cuerpo: ¡Oye! ¡Te recuerdo que tienes dentista el Jueves a las seis y media!
Esta información, formateada de la siguiente forma, sigue un estándar XML, que no es más que darle un formato, empaquetarla y etiquetarla. Un fichero XML no son instrucciones, no hace nada, simplemente es información.
<nota>
   <para>Maricarmen</para>
   <de>Antonio</de>
   <asunto>Recordatorio</asunto>
   <cuerpo>¡Oye! ¡Te recuerdo que tienes dentista el Jueves a las seis y media!</cuerpo>
 </nota>

Diferencias con HTML

Uno de los primeros lenguajes de marcado desarrollados, básico todavía hoy en día para el diseño de páginas web, es el HTML (Lenguaje de marcado de hipertexto). ¿Qué diferencias hay entre este lenguaje y XML?
  1. HTML trabaja con etiquetas predefinidas (<a>,<b>,<h1>,<table>,etc.) y XML no tiene etiquetado predefinido. En XML hay que definir las etiquetas y su estructura.
  2. HTML se centra en el desarrollo de páginas web, sobre todo en el contenido y su apariencia.
  3. XML se centra en el almacenamiento y transporte de datos.

XML es extensible

Un mismo documento XML puede extenderse en información por la adición de nuevas etiquetas. por ejemplo, en la nota anterior podría añadirse la etiqueta <día></día> y <hora></hora>. Programas antiguos que se desarrollaron para la versión antigua podrían seguir leyendo la información nueva simplemente ignorando las nuevas etiquetas.

XML simplifica las cosas

XML simplifica el almacenamiento de datos, su transporte, el cambio de plataformas (Windows, Linux, Macs) y la disponibilidad de los datos. Supone usar una forma común de comunicar datos entre los programas, evitando la conversión entre formatos. Facilita mucho que nuevos sistemas operativos (o nuevas versiones), nuevos programas o nuevas aplicaciones web puedan manejar los datos almacenados previamente, y no sólo ordenadores, sino incluso lo entienden las personas directamente o máquinas de lectura para ciegos, dispositivos móviles, etc.
 

XML tiene forma de árbol

Todos los documentos XML tienen una estructura de árbol. Empiezan con una etiqueta que es el "tronco" , a la que se le añaden subetiquetas, formándose "ramas", que acabn en las últimas etiquetas que serían como las "hojas".
En el siguiente ejemplo puedo definir los libros que hay en una biblioteca:
DOM node tree
  • os datos se empiezan a estructurar con una etiqueta principal, o elemento raíz (root). En nuestro ejemplo bookstore.
  • Dentro del bookstore, defino una etiqueta derivada (hija o child), llamada book. La etiqueta de la que proviene otra, se denominada etiqueta padre (parent), así que bookstore, además de ser la etiqueta raíz, es la etiqueta padre de book.
  • En este ejemplo, además, la etiqueta book tiene 4 hijos (child) que son las etiquetas title, author, year, price. Como las cuatro son hijos del mismo padre, se dice que son siblings (la palabra siblings en inglés significa hermanos o hermanas).
  • Cada etiqueta puede tener modificadores o atributos. Por ejemplo, un libro book puede pertenecer a la categoría cocina y otro a la categoría aventura. Por tanto, category es un atributo de book. Y, puede, o no, contener texto, información.
  • Además, suelen empezar con una línea donde se especifica la versión de xml usada y la codificación de los caracteres.
<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
   <book category="cooking">
     <title lang="en">Everyday Italian</title>
     <author>Giada De Laurentiis</author>
     <year>2005</year>
     <price>30.00</price>
   </book>
   <book category="children">
     <title lang="en">Harry Potter</title>
     <author>J K. Rowling</author>
     <year>2005</year>
     <price>29.99</price>
   </book>
   <book category="web">
     <title lang="en">Learning XML</title>
     <author>Erik T. Ray</author>
     <year>2003</year>
     <price>39.95</price>
   </book>
 </bookstore>
 

Reglas sintácticas de XML

Las reglas que se usan en XML son sencillas, pero hay que recordarlas y seguirlas a rajatabla.
  1. Todos los documentos XML tienen que tener una etiqueta root que será el padre del resto de los elementos.
  2. El prólogo (<?xml version="1.0" encoding="UTF-8"?>) es opcional, pero si se inserta, se escribe al principio del todo. Aunque la codificación puede cambiar, es habitual guardar los documentos XML en UTF-8 y especificar dicha codificación en el prólogo. Además, UTF-8 es la codificación usada por defecto en HTML5, CSS, JavaScript, PHP, and SQL (lenguajes usados en la web).
  3. En HTML, aunque no se recomienda, las etiquetas sin cerrar pueden funcionar <p>Esto es un párrafo... Pero en XML hay que cerrar una etiqueta abierta. La única excepción es la etiqueta prólogo (que, en el fondo, no pertenece a la estructura de datos del documento).
  4. XML es "case sensitive", es decir, que las minúsculas y mayúsculas importan. Así las etiquetas <Coche> y <coche> son distintas. Entonces...
    • <Coche>Audi A8</coche> está mal.
    • <Coche>Peugeot 308</Coche> está bien.
  5. Todos los elementos tienen que estar bien anidados. Primero hay que cerrar los hijos, y después los padres.
    • <receta><ingrediente>Manzanas</ingrediente></receta> estaría bien.
    • <receta><ingrediente>Manzanas</receta></ingrediente> estaría mal.
  6. Los atributos deben estar entrecomillados
    • <book category=cocina> estaría mal
    • <book category="cocina"> estaría bien.
  7. Caracteres especiales. Por ejemplo, si quisiera escribir como un dato: el partido entre el Betis y el Sevilla quedó <0-0> tendría un problema. Los caracteres "<" y ">" están reservados en XML para abrir y cerrar etiquetas, así que la información <0-0> produciría un error. Tengo dos opciones: o evitar esos caracteres, o usar su codificación de entidad (entity references). En XML se usan 5, que son:  &lt; < , &gt; >, &amp;  &, &apos; ' ,&quot;  " , referidas al "menor que", "mayor que", "símbolo Y", "apóstrofe" y "comillas dobles".
    • En el ejemplo, debería escribir : el partido entre el Betis y el Sevilla quedó  &lt; 0-0 &gt;
  8. Comentarios, como en HTML, <!-- Este es un comentario -->
  9. Los espacios en blanco entre palabras se conservan (en HTML no):  Hola          caracola
  10. El código de final de línea es LF (salto de línea), exactamente igual que en los sistemas Linux.
  11. Se dice que el fichero XML está bien formateado "Well-formed" y no presenta errores cuando cumple todas estas reglas.

Tipos de elementos XML, Atributos y Namespaces

XML Elementos

  • Un elemento es todo aquello contenido entre dos etiquetas <precio>32€</precio>
  • Un elemento puede contener: textos, atributos, u otro elementos; o una mezcla de todo ello.
  • Pueden existir elementos vacíos (que no contengan nada) como: <elemento></elemento>. También pueden escribirse como <elemento />
  • Los elementos son sensibles a las mayúsculas y minúsculas, deben empezar por una letra o un subrayado bajo (_), una etiqueta no puede empezar con las letras "Xml" ó "xml", y no deben contener espacios. Evita, para no tener mala interpretaciones con algún software, los caracteres ".","-",":" y las letras con acento o la ñ.
  • Recuerda, que los elementos son extensibles. Pueden añadirse más elementos hijos.
= = =

XML Atributos

  • Son informaciones relativas a un elemento, como por ejemplo <persona genero="femenino">. También es posible usar las comillas simples <persona genero='femenino'>
  • Ejemplo si tengo un atributo cuyo valor contiene los caracteres comillas dobles en su interior: <gangster name='George "Shotgun" Ziegler'> De separador se usa la comilla simple; o si es necesario, al revés: <gangster name="George 'Shotgun' Ziegler", y en todo caso se puede usar las referencias a entidades &lt;  &gt;  &amp; &apos;  &quot;
  • Ejemplo de poner la misma información de tres formas (las tres son equivalentes):
<note date="2008-01-10">
  <to>Tove</to>
  <from>Jani</from>
</note>
<note>
  <date>2008-01-10</date>
  <to>Tove</to>
  <from>Jani</from>
</note>
<note>
  <date>
    <year>2008</year>
    <month>01</month>
    <day>10</day>
  </date>
  <to>Tove</to>
  <from>Jani</from>
</note>
  • No conviene abusar de los atributos. No poner demasiados, ya que no son expandibles, mo pueden contener datos múltiples y no tienen estructura de árbol. Es mejor incluir más etiquetas. Por tanto, evitar cosas como:
<note day="10" month="01" year="2008"
 to="Tove" from="Jani" heading="Reminder"
 body="Don't forget me this weekend!">
 </note>
  • Es buena idea usar "metadatos" (datos de los datos). Por ejemplo, una identificación (o id), para localizar rápidamente los datos. En este caso sí deberían ser atributos.
<messages>
  <note id="501">
    <to>Tove</to>
    <from>Jani</from>
    <heading>Reminder</heading>
    <body>Don't forget me this weekend!</body>
  </note>
  <note id="502">
    <to>Jani</to>
    <from>Tove</from>
    <heading>Re: Reminder</heading>
    <body>I will not</body>
  </note>
</messages>
= = =

XML Namespaces

  • A veces, usando XML puedo entrar en conflictos. Por ejemplo, el primer trozo de información se refiere a una tabla de datos HTML (filas y columnas) y el segundo a una mesa (table en inglés).
<table>
  <tr>
    <td>Apples</td>
    <td>Bananas</td>
  </tr>
</table>
<table>
  <name>African Coffee Table</name>
  <width>80</width>
  <length>120</length>
</table>
  • Si uso en el mismo fichero XML ambas informaciones, puedo entrar en un conflicto, ya que el elemento <table> tiene hijos distintos. Para evitar el conflicto, puedo usar un prefijo. Por ejemplo, uso el prefijo h y f en el ejemplo siguiente; así puedo usar la información sobre mesas y tablas HTML.
<h:table>
  <h:tr>
    <h:td>Apples</h:td>
    <h:td>Bananas</h:td>
  </h:tr>
</h:table>

<f:table>
  <f:name>African Coffee Table</f:name>
  <f:width>80</f:width>
  <f:length>120</f:length>
</f:table> 
  • Ahora viene lo importante: cuando uso prefijos en XML debo usar Namespaces (espacios con nombre). Se definen mediante un URI (Uniform Resource Identifier - Identificador uniforme de recurso) con el atributo xmlns, usando la nomenclatura xmlns:prefix="URI". Mejor verlo con un ejemplo (la segunda forma también es válida):
<root>

<h:table xmlns:h="http://www.w3.org/TR/html4/">
  <h:tr>
    <h:td>Apples</h:td>
    <h:td>Bananas</h:td>
  </h:tr>
</h:table>

<f:table xmlns:f="http://www.w3schools.com/furniture">
  <f:name>African Coffee Table</f:name>
  <f:width>80</f:width>
  <f:length>120</f:length>
</f:table>

</root> 
<root 
xmlns:h="http://www.w3.org/TR/html4/"
 xmlns:f="http://www.w3schools.com/furniture">

 <h:table>
   <h:tr>
     <h:td>Apples</h:td>
     <h:td>Bananas</h:td>
   </h:tr>
 </h:table>

 <f:table>
   <f:name>African Coffee Table</f:name>
   <f:width>80</f:width>
   <f:length>120</f:length>
 </f:table>

 </root>
  • Cuando asigno atributos xmlns, adjudico nombres restringidos a los prefijos. El propósito del URI del Namespace no es servir para buscar información; simplemente para asegurarnos de que el namespace es único. Pero a veces se aprovecha el URI para apuntar a una web que muestra información adicional.
= = =

Namespaces por defecto (Default Namespaces)

  • También se puede usar un xmlns por defecto, y no usar prefijos.
<table xmlns="http://www.w3.org/TR/html4/">
  <tr>
    <td>Apples</td>
    <td>Bananas</td>
  </tr>
</table>

<table xmlns="http://www.w3schools.com/furniture">
  <name>African Coffee Table</name>
  <width>80</width>
  <length>120</length>
</table> 
 

Otros aspectos de los ficheros XML

  • Los navegadores suelen mostrar la información de los ficheros XLM en forma de árbol, con signos de menos (-) o (más) para expandir los nodos.
XML
  • XML puede formatearse con ficheros CSS (hojas de estilo en cascada, aunque en la web suelen leerse desde Javascript).
  • Los ficheros XML erróneos darán lugar a salidas parcialmente incorrectas o a mensajes de error.
  • Se usa el lenguaje de transformación XSLT para transformar un fichero XML en uno HTML para mostrar los datos en la WEB. (http://www.w3schools.com/xsl/default.asp)
  • Y se suele usar con el lenguaje XPath para encontrar información en un fichero XML (http://www.w3schools.com/xsl/xpath_intro.asp)
  • Hay otras aplicaciones como XLink, XPointer, para el uso de hipertexto. Se usa XML DTD o XML Schema para validar los datos, confrontarlos con una plantilla de datos y asegurarse de que se ajustan a ellas.
  • Los ficheros XML se pueden generar con PHP o ASP (¡o con Pyhton) directamente desde una aplicación o un servidor.
  • XML DOM (http://www.w3schools.com/xml/dom_intro.asp) es una forma estandarizada de añadir, borrar, obtener o cambiar elementos de un objeto XML. En él se define los objetos, métodos y propiedades de todos los elementos XML. Es una interfaz independiente de la plataforma y del lenguaje de programación.