• La abstracción y la composición son dos conceptos relacionados:

  • Componer consiste en combinar elementos entre sí para formar otros más complejos.

  • Abstraer consiste en coger un elemento (normalmente complejo), darle un nombre y ocultar sus detalles internos (es decir, los elementos que lo componen) dentro de una caja negra.

• Lo interesante es que la combinación y la abstracción son dos mecanismos recursivos:

  • Podemos crear elementos complejos a partir de otros elementos complejos.

  • Podemos crear abstracciones a partir de otras abstracciones.

• Además, por supuesto, podemos crear abstracciones a partir de composiciones y composiciones a partir de abstracciones.

• Por ahora, esos conceptos (composición y abstracción) sólo los hemos aplicado a las instrucciones del programa:

  • La composición de instrucciones da lugar a las expresiones compuestas y a las sentencias compuestas (también llamadas estructuras de control: secuencia, selección e iteración).

  • La abstracción de instrucciones da lugar a las abstracciones funcionales.

• Pero también se pueden aplicar a los datos:

  • La composición de datos da lugar a los datos compuestos (también llamados datos estructurados) y, en consecuencia, a los tipos de datos compuestos (también llamados tipos de datos estructurados).

  • La abstracción de datos da lugar a los datos abstractos y, en consecuencia, a los tipos abstractos de datos.

• En esta unidad hablaremos de la composición de datos y dejaremos la abstracción de datos para una unidad posterior.

• Según su mutabilidad:

  • Inmutables: el dato estructurado no puede cambiar nunca su estado interno a lo largo de su vida.

  • Mutables: el dato estructurado puede cambiar su estado interno a lo largo de su vida sin cambiar su identidad.

• El contenido de un dato estructurado forma parte del estado interno de ese dato estructurado, por lo que cambiar el contenido de un dato estructurado supone cambiar también su estado interno.

• Por ejemplo, si en la lista [7, 8, 9] sustituimos su segundo elemento (el 8) por un 5 para obtener la lista [7, 5, 9], estamos cambiando el contenido de la lista y, por consiguiente, su estado interno.

  Su identidad no ha cambiado, pero su estado interno sí.

\text{Tipos} \begin{cases} \text{Escalares} \\ \\ \text{Estructurados} \begin{cases} \text{Secuencias} \begin{cases} \text{Inmutables} \begin{cases} \text{Cadenas (\texttt{str})} \\ \text{Tuplas (\texttt{tuple})} \\ \text{Rangos (\texttt{range})} \end{cases} \\ \\ \text{Mutables} \begin{cases} \text{Listas (\texttt{list})} \end{cases} \end{cases} \\ \\ \text{No secuencias} \begin{cases} \text{Inmutables} \begin{cases} \text{Conjuntos (\texttt{frozenset})} \end{cases} \\ \\ \text{Mutables} \begin{cases} \text{Conjuntos (\texttt{set})} \\ \text{Diccionarios (\texttt{dict})} \end {cases} \end{cases} \end{cases} \end{cases}

• Ejemplos:

  >>> hash('hola')
  6290906884732116299
  >>> hash('hola')
  6290906884732116299
  >>> hash(5)
  5
  >>> hash((1, 2, 3))
  529344067295497451
  >>> hash([1, 2, 3])
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: unhashable type: 'list'

• El concepto de hashable es importante en Python ya que existen tipos de datos estructurados que sólo pueden contener elementos hashables.

• Por ejemplo, los elementos de un conjunto y las claves de un diccionario deben ser hashables.

• La mayoría de los datos inmutables predefinidos en Python son hashables.

• Las colecciones inmutables (como las tuplas o los frozensets) sólo son hashables si sus elementos también lo son.

• Las coleccion mutables (como las listas o los diccionarios) NO son hashables.

• El hash de un dato depende del estado interno del dato, ya que se calcula a partir de dicho estado interno usando un algoritmo que no nos debe preocupar por ahora.

  Como el estado interno de una colección viene determinado principalmente por los elementos que contiene, el hash de una colección dependerá también del contenido de la colección.

  Y por esta razón, las colecciones mutables no son hashables: si una colección es mutable, su contenido puede cambiar y, por tanto, su hash también cambiaría, pero esto está prohibido.

• El hash de un dato es un número que representa al dato y a todo su contenido.

• En cierto modo, ese número resume el estado del dato en un simple número entero.

• El hash de un dato se utiliza internamente para acceder al dato dentro de una colección de forma directa y eficiente.

• Para ello, el intérprete utiliza ciertas técnicas que permiten localizar directamente a un dato dentro de una colección, de forma casi inmediata y sin importar el tamaño de la colección (pero recordemos que para ello es necesario que el hash del dato nunca cambie).

• De no usar estas técnicas, el intérprete tendría que buscar el dato secuencialmente dentro de la colección, recorriéndola desde el principio hasta el final, lo que sería mucho más lento y consumiría un tiempo que sería mayor cuanto más grande fuese la colección.

• Muy en resumen, las técnicas se basan en dividir el espacio de memoria que ocupa la colección en una serie de contenedores llamados buckets.

• Cada bucket va numerado por un posible valor de hash, de forma que el bucket número n contendrá todos los elementos cuyo hash valga n.

• Por tanto, el algoritmo que usa el intérprete para encontrar un elemento hashable dentro de una colección es:

  1. Calcular el hash del elemento a localizar.

  2. Irse directamente al bucket numerado con ese valor de hash (esta es una operación inmediata, con coste O(1)).

  3. Localizar dentro del bucket el elemento que se está buscando usando el ==, lo cual consumirá un tiempo que, en general, no será mucho, ya que los elementos están repartidos entre todos los buckets y, por tanto, normalmente no habrá muchos elementos en cada bucket.

• Al final, se consigue encontrar al elemento (si está) de forma muy rápida, con un coste que es casi constante, independientemente de la cantidad de elementos que haya en la colección.

No se debe confundir el id de un dato con el hash de un dato:

• Por ejemplo, las listas son iterables ya que nos permite acceder a todos sus elementos de uno en uno y, por tanto, podemos recorrerla.

• Para visitar sus elementos podemos usar la indexación, y para recorrer toda la lista podemos usar un bucle:

  def recorrer_lista(l):
      i = 0
      while i < len(l):
          print(l[i])
          i += 1

• Se puede obtener un iterador a partir de cualquier dato iterable aplicando la función iter al iterable.

  (Recordemos que todo iterable debe tener asociado un iterador.)

• Ejemplo de uso de iter y next:

  >>> lista = [1, 2, 3]
  >>> it = iter(lista)
  >>> next(it)
  1
  >>> next(it)
  2
  >>> next(it)
  3
  >>> next(it)
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  StopIteration

• Si se le pasa un dato no iterable, iter lanza una excepción TypeError:

  >>> it = iter(9)
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: 'int' object is not iterable

• Los iteradores son iterables perezosos de un solo uso:

  • Son perezosos porque van generando sus elementos a medida que los va entregando, en lugar de generarlos todos a la vez primero.

  • Son de un solo uso porque cada elemento sólo se entrega una vez.

• Además, los iteradores son iterables que actúan como sus propios iteradores:

  • Por tanto, cuando llamamos a iter pasándole un iterador, se devuelve el mismo iterador:

    >>> lista = [1, 2, 3, 4]
    >>> it = iter(lista)
    >>> it
    <list_iterator object at 0x7f3c49aa9080>
    >>> it2 = iter(it)
    >>> it2
    <list_iterator object at 0x7f3c49aa9080>
    >>> it == it2
    True

  • En consecuencia, podemos usar un iterador en cualquier sitio donde se espere un iterable.

• Funciones como map y filter devuelven iteradores porque, al ser perezosos, son más eficientes en memoria que si devolvieran toda una lista o tupla.

  Por ejemplo: ¿qué ocurre si sólo necesitamos los primeros elementos del resultado de un map?

• Los iteradores se pueden convertir en listas o tuplas usando las funciones list y tuple:

  >>> l = [1, 2, 3]
  >>> iterador = iter(l)
  >>> t = tuple(iterador)
  >>> t
  (1, 2, 3)

• Las expresiones generadoras, ya conocidas por nosotros, también son expresiones que devuelven un iterador:

  ⟨expr_gen⟩ ::= (⟨expresión⟩ (for ⟨identificador⟩ in ⟨secuencia⟩ [if ⟨condición⟩])+)

• Ejemplo:

  >>> cuadrados = (x ** 2 for x in range(1, 10))
  >>> cuadrados
  <generator object <genexpr> at 0x7f6a0fc7db48>
  >>> next(cuadrados)
  1
  >>> next(cuadrados)
  4
  >>> next(cuadrados)
  9

• Ejemplos:

for i in range(0, 4):
    print(i)

0
1
2
3

for x in ['hola', 23.5, 10, [1, 2]]:
    print(x * 2)

'holahola'
47.0
20
[1, 2, 1, 2]

• Al recorrer el iterable, la variable va almacenando en cada iteración del bucle el valor del elemento que en ese momento se está visitando.

• Si estamos recorriendo una secuencia y necesitamos recuperar tanto el valor como el índice de cada elemento, podemos usar la función enumerate.

• Esta función devuelve un iterador que va generando tuplas que contienen, además del elemento, el valor correspondiente de un contador numérico.

• Las tuplas que devuelve el iterador llevan el contador en la primera posición y el elemento de la secuencia en la segunda posición.

• Por defecto, el contador empieza desde 0 y se va incrementando de uno en uno, por lo que coincide con el índice del elemento en la secuencia:

  >>> for i, e in enumerate(['a', 'b', 'c']):
  ...     print('El elemento en la posición ' + str(i) + ' es ' + str(e))
  ...
  El elemento en la posición 0 es a
  El elemento en la posición 1 es b
  El elemento en la posición 2 es c

• Existen iterables e iteradores incluso donde uno menos se lo podría esperar.

• Por ejemplo, los archivos abiertos también son iterables, ya que se pueden recorrer línea a línea usando un iterador:

  with open('archivo.txt') as f:
      for linea in f:
          print(linea)

• Esta forma de recorrer los archivos, además de resultar simple y elegante, también resulta muy eficiente, ya que se va recuperando cada línea de una en una en lugar de todas a la vez.

• itertools.cycle(⟨iterador⟩) devuelve un nuevo iterador que va generando sus elementos del primero al último, repitiéndolos indefinidamente:

  itertools.cycle([1, 2, 3, 4]) \Rightarrow 1, 2, 3, 4, 1, 2, 3, 4, …

• itertools.repeat(⟨elem⟩[, ⟨n⟩]) devuelve ⟨n⟩ veces el elemento ⟨elem⟩, o lo devuelve indefinidamente si no se indica ⟨n⟩:

  itertools.repeat('abc') \Rightarrow abc, abc, abc, abc, abc, abc, abc, …

  itertools.repeat('abc', 5) \Rightarrow abc, abc, abc, abc, abc

• Además de estas operaciones, las secuencias admiten comparaciones con los operadores ==, !=, <, <=, > y >=.

• Dos secuencias \underline{s} y \underline{t} son iguales (\underline{s} == \underline{t}) si:

  • Son del mismo tipo (type(s) == type(t)).

  • Tienen la misma longitud (len(s) == len(t)).

  • Contienen los mismos elementos en el mismo orden
    (s[0] == t[0], s[1] == t[1], etcétera).

• Por supuesto, las dos secuencias son distintas (\underline{s} != \underline{t}) si no son iguales.

• Se pueden comparar dos secuencias con los operadores <, <=, > y >= para comprobar si una es menor (o igual) o mayor (o igual) que la otra si:

  • Son del mismo tipo (si no son del mismo tipo, lanza una excepción).

  • No son rangos.

• Las comparaciones <, <=, > y >= se hacen lexicográficamente elemento a elemento, como en un diccionario.

• Por ejemplo, 'adios' < 'hola' porque adios aparece antes que hola en el diccionario.

• Con el resto de las secuencias se actúa igual que con las cadenas.

  Dadas dos secuencias \underline{s} y \underline{t}, para ver si \underline{s} < \underline{t} se procede así:

  • Se empieza comparando el primer elemento de \underline{s} con el primero de \underline{t}.

  • Si son iguales, se pasa al siguiente hasta encontrar algún elemento de \underline{s} que sea distinto a su correspondiente de \underline{t}.

  • Si llegamos al final de \underline{s} sin haber encontrado ningún elemento distinto a su correspondiente en \underline{t}, es porque \underline{s} == \underline{t}.

  • En cuanto se encuentre un elemento de \underline{s} que no es igual a su correspondiente de \underline{s}, se comparan esos elementos y se devuelve el resultado de esa comparación.

• Los rangos no se pueden comparar con <, <=, > o >=.

• Ejemplos:

  >>> (1, 2, 3) == (1, 2, 3)
  True
  >>> (1, 2, 3) != (1, 2, 3)
  False
  >>> (1, 2, 3) == (3, 2, 1)
  False
  >>> (1, 2, 3) < (3, 2, 1)
  True
  >>> (1, 2, 3) < (1, 2, 4)
  True
  >>> (1, 2, 3) < (1, 2, 4, 5)
  True
  >>> 'hola' < 'adios'
  False
  >>> range(0, 3) < range(3, 6)
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: '<' not supported between instances of 'range' and 'range'

• Sintaxis:

  ⟨f_string⟩ ::= (⟨carácter_literal⟩ | {{ | }} | ⟨sustitución⟩)*
  ⟨sustitución⟩ ::= {⟨expresión⟩ [!⟨conversión⟩] [:⟨especif⟩]}
  ⟨conversión⟩ ::= s | r | a
  ⟨especif⟩ ::= (⟨carácter_literal⟩ | NULL | ⟨sustitución⟩)*
  ⟨carácter_literal⟩ ::= ⟨cualquier carácter Unicode excepto {, } o NULL⟩

• Las partes de la cadena que van fuera de las llaves se tratan literalmente, excepto las dobles llaves {{ y }}, que son sustituidas por una sola llave.

• Una { marca el comienzo de un campo de sustitución (⟨sustitución⟩), que empieza con una expresión.

• Tras la expresión puede venir un conversión (⟨conversión⟩), introducida por una exclamación !.

• También puede añadirse un especificador de formato (⟨especif⟩) después de dos puntos :.

• El campo de sustitución termina con una }.

• Las expresiones en un literal de cadena formateada son tratadas como cualquier otra expresión Python encerrada entre paréntesis, con algunas excepciones:

  • No se permiten expresiones vacías.

  • Las expresiones lambda deben ir entre paréntesis.

• Los campos de sustitución pueden contener saltos de línea pero no comentarios.

• Si se indica una conversión, el resultado de evaluar la expresión se convierte antes de aplicar el formateado.

  La conversión !s llama a la función str sobre el resultado, !r llama a repr y !a llama a ascii.

• A continuación, el resultado es formateado usando la función format.

• Finalmente, el resultado del formateado es incluido en el valor final de la cadena completa.

• La sintaxis general de un especificador de formato es:

  ⟨especif⟩ ::= [[⟨relleno⟩]⟨alig⟩][⟨signo⟩][#][0][⟨ancho⟩][⟨grupos⟩][.⟨precision⟩][⟨tipo⟩]
  ⟨relleno⟩ ::= ⟨cualquier carácter⟩
  ⟨alig⟩ ::= < | > | = | ^
  ⟨signo⟩ ::= + | - | ⟨espacio⟩
  ⟨ancho⟩ ::= ⟨dígito⟩+
  ⟨grupos⟩ ::= _ | ,
  ⟨precision⟩ ::= ⟨dígito⟩+
  ⟨tipo⟩ ::= b | c | d | e | E | f | F | g | G | n | o | s | x | X | %

• Los especificadores de formato de nivel superior pueden incluir campos de sustitución anidados.

• Estos campos anidados pueden incluir, a su vez, sus propios campos de conversión y sus propios especificadores de formato, pero no pueden incluir más campos de sustitución anidados.

• Para más información, consultar https://docs.python.org/3.7/library/string.html#format-specification-mini-language

• Ejemplos de cadenas formateadas:

  >>> nombre = 'Pepe'
  >>> f'El nombre es: {nombre}'              # Se sustituye la variable por su valor
  'El nombre es: Pepe'
  >>> apellidos = 'Pérez'
  >>> f'El nombre es: {nombre} {apellidos}'  # Igual
  'El nombre es: Pepe Pérez'
  >>> f'El nombre es: {nombre + apellidos}'  # Se puede usar cualquier expresión
  'El nombre es: Pepe Pérez'
  >>> f'Formato con anchura: {nombre:10}'    # Las cadenas se alinean a la izquierda
  'Formato con anchura: Pepe      '
  >>> f'Formato con anchura: {nombre:<10}'   # Igual que lo anterior
  'Formato con anchura: Pepe      '
  >>> f'Formato con anchura: {nombre:>10}'   # Alinea a la derecha
  'Formato con anchura:       Pepe'
  >>> f'Formato con anchura: {nombre:^10}'   # Alinea al centro
  'Formato con anchura:    Pepe   '

• Ejemplos de cadenas formateadas con números positivos:

  >>> x, y = 400, 300
  >>> f'La suma de {x} y {y} es {x + y}' # Se puede usar cualquier expresión
  'La suma de 400 y 300 es 700'
  >>> f'Formato con anchura: {x:10}'     # Los números se alinean a la derecha
  'Formato con anchura:        400'
  >>> f'Formato con anchura: {x:>10}'    # Igual que lo anterior
  'Formato con anchura:        400'
  >>> f'Formato con anchura: {x:2}'      # Ancho demasiado pequeño, se ignora
  'Formato con anchura: 400'
  >>> f'Formato con anchura: {x:<10}'    # Alinea a la izquierda
  'Formato con anchura: 400       '
  >>> f'Formato con anchura: {x:>10}'    # Alinea a la derecha
  'Formato con anchura:        400'
  >>> f'Formato con anchura: {x:^10}'    # Alinea al centro
  'Formato con anchura:    400    '
  >>> f'Formato con anchura: {x:=10}'    # En positivos no hay diferencia con >
  'Formato con anchura:        400'
  >>> f'Formato con anchura: {x:@<10}'   # Alinea a la izquierda, rellena con @
  'Formato con anchura: 400@@@@@@@'
  >>> f'Formato con anchura: {x:@>10}'   # Alinea a la derecha, rellena con @
  'Formato con anchura: @@@@@@@400'
  >>> f'Formato con anchura: {x:@^10}'   # Alinea al centro, rellena con @
  'Formato con anchura: @@@400@@@@'
  >>> f'Formato con anchura: {x:@=10}'   # En positivos no hay diferencia con >
  'Formato con anchura: @@@@@@@400'

• Ejemplos de cadenas formateadas con números negativos:

  >>> z = -400
  >>> f'Formato con anchura: {z:10}'   # A la derecha, signo junto al nº
  'Formato con anchura:       -400'
  >>> f'Formato con anchura: {z:<10}'  # A la izquierda, signo junto al nº
  'Formato con anchura: -400      '
  >>> f'Formato con anchura: {z:>10}'  # A la derecha, signo junto al nº
  'Formato con anchura:       -400'
  >>> f'Formato con anchura: {z:^10}'  # Al centro, signo junto al nº
  'Formato con anchura:    -400   '
  >>> f'Formato con anchura: {z:=10}'  # A la derecha, signo junto al relleno
  'Formato con anchura: -      400'
  >>> f'Formato con anchura: {z:010}'  # A la derecha, signo junto al relleno
  'Formato con anchura: -000000400'
  >>> f'Formato con anchura: {z:0<10}' # A la izquierda, signo junto al nº
  'Formato con anchura: -400000000'
  >>> f'Formato con anchura: {z:0>10}' # A la derecha, signo junto al nº
  'Formato con anchura: 000000-400'
  >>> f'Formato con anchura: {z:0^10}' # Al centro, signo junto al nº
  'Formato con anchura: 000-400000'
  >>> f'Formato con anchura: {z:0=10}' # A la derecha, signo junto al relleno
  'Formato con anchura: -000000400'
  >>> f'Formato con anchura: {z:@<10}' # A la izquierda, signo junto al nº
  'Formato con anchura: -400@@@@@@'
  >>> f'Formato con anchura: {z:@>10}' # A la derecha, signo junto al nº
  'Formato con anchura: @@@@@@-400'
  >>> f'Formato con anchura: {z:@^10}' # Al centro, signo junto al nº
  'Formato con anchura: @@@-400@@@'
  >>> f'Formato con anchura: {z:@=10}' # A la derecha, signo junto al relleno
  'Formato con anchura: -@@@@@@400'

• Ejemplos de cadenas formateadas con números en coma flotante:

  >>> from math import pi
  >>> f'El valor de pi es {pi:6.3}'     # Ancho 6, precisión 3
  'El valor de pi es   3.14'
  >>> f'El valor de pi es {pi:10.3}'    # Ancho 10, precisión 3
  'El valor de pi es       3.14'
  >>> f'El valor de pi es {pi:<10.3}'   # A la izquierda
  'El valor de pi es 3.14      '
  >>> f'El valor de pi es {pi:>10.3}'   # A la derecha
  'El valor de pi es       3.14'
  >>> f'El valor de pi es {pi:^10.3}'   # Al centro
  'El valor de pi es    3.14   '
  >>> f'El valor de pi es {pi:=10.3}'   # A la derecha
  'El valor de pi es       3.14'
  >>> f'El valor de pi es {pi:10.3f}'   # 3 dígitos en la parte fraccionaria
  'El valor de pi es      3.142'
  >>> f'El valor de pi es {pi:<10.3f}'  # A la izquierda
  'El valor de pi es 3.142     '
  >>> f'El valor de pi es {pi:>10.3f}'  # A la derecha
  'El valor de pi es      3.142'
  >>> f'El valor de pi es {pi:^10.3f}'  # Al centro
  'El valor de pi es   3.142   '
  >>> f'El valor de pi es {pi:=10.3f}'  # A la derecha
  'El valor de pi es      3.142'
  >>> f'El valor de pi es {-pi:=10.3f}' # Los negativos, igual que los enteros
  'El valor de pi es -    3.142'

• Más ejemplos:

  >>> nombre = "Fred"
  >>> f"Dice que su nombre es {nombre!r}."
  "Dice que su nombre es 'Fred'."
  >>> f"Dice que su nombre es {repr(nombre)}."  # repr es equivalente a !r
  "Dice que su nombre es 'Fred'."
  >>> ancho = 10
  >>> precision = 4
  >>> value = decimal.Decimal("12.34567")
  >>> f"result: {value:{ancho}.{precision}}"  # campos anidados
  'result:      12.35'
  >>> import datetime
  >>> hoy = datetime.datetime(year=2017, month=1, day=27)
  >>> f"{hoy:%B %d, %Y}"  # usando especificador de formato de fecha
  'January 27, 2017'
  >>> numero = 1024
  >>> f"{numero:#0x}"  # usando especificador de formato de enteros
  '0x400'

• El lenguaje de las expresiones regulares es relativamente pequeño y restringido, por lo que no es posible usarlo para realizar cualquier tipo de procesamiento de cadenas.

• Además, hay procesamientos que se pueden realizar con regexes pero las expresiones que resultan se vuelven muy complicadas.

• En estos casos, es mejor escribir directamente código Python ya que, aunque el código resultante pueda resultar más lento, probablemente resulte más fácil de leer.

• Para más información sobre cómo crear y usar expresiones regulares, consultar:

  • Tutorial de introducción en https://docs.python.org/3/howto/regex.html

  • Documentación del módulo re en https://docs.python.org/3/library/re.html

• Observar que lo que construye la tupla es realmente la coma, no los paréntesis.

• Los paréntesis son opcionales, excepto en dos casos:

  • La tupla vacía: ()

  • Cuando son necesarios para evitar ambigüedad.

    Por ejemplo, f(a, b, c) es una llamada a una función con tres argumentos, mientras que f((a, b, c)) es una llamada a una función con un único argumento que es una tupla de tres elementos.

• Las tuplas implementan todas las operaciones comunes de las secuencias.

• En general, las tuplas se pueden considerar como la versión inmutable de las listas.

• Además, las tuplas son hashables si sus elementos también lo son.

• En memoria, las tuplas se almacenan mediante una estructura de datos donde sus elementos se identifican mediante un índice, que es un número entero que indica la posición que ocupa el elemento dentro de la tupla.

• Por ejemplo, la siguiente tupla:

  t = (1, 2, 3)

  se almacenaría de la siguiente forma según lo representa la herramienta Pythontutor:

• El contenido de un rango r vendrá determinado por la fórmula: r[i] = start + step \cdot i donde i \geq 0. Además:

  • Si step > 0, se impone también la restricción r[i] < \text{\textit{stop}}.

  • Si step < 0, se impone también la restricción r[i] > \text{\textit{stop}}.

• Un rango es vacío cuando r[0] no satisface las restricciones anteriores.

• Los rangos admiten índices negativos, pero se interpretan como si se indexara desde el final de la secuencia usando índices positivos.

• Los rangos implementan todas las operaciones de las secuencias, excepto la concatenación y la repetición.

  Esto es debido a que los rangos sólo pueden representar secuencias que siguen un patrón muy estricto, y las repeticiones y las concatenaciones a menudo violan ese patrón.

• Los rangos son perezosos y además ocupan mucha menos memoria que las listas o las tuplas (sólo hay que almacenar start, stop y step).

• La forma normal de un rango es una expresión en la que se llama a la función range con los argumentos necesarios para construir el rango:

  >>> range(10)
  range(0, 10)
  >>> range(0, 10)
  range(0, 10)
  >>> range(0, 10, 1)
  range(0, 10)

  >>> range(0, 30, 5)
  range(0, 30, 5)
  >>> range(0, -10, -1)
  range(0, -10, -1)
  >>> range(4, -5, -2)
  range(4, -5, -2)

• Para ver con claridad todos los elementos de un rango, podemos convertirlo en una tupla o una lista. Por ejemplo:

  >>> list(range(10))
  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  >>> list(range(1, 11))
  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  >>> list(range(0, 30, 5))
  [0, 5, 10, 15, 20, 25]
  >>> list(range(0, 10, 3))
  [0, 3, 6, 9]
  >>> list(range(0, -10, -1))
  [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
  >>> list(range(0))
  []
  >>> list(range(1, 0))
  []

• Dos rangos son considerados iguales si representan la misma secuencia de valores, sin importar si tienen distintos valores de start, stop o step.

• Por ejemplo:

  >>> range(20) == range(0, 20)
  True
  >>> range(0, 20) == range(0, 20, 2)
  False
  >>> range(0, 3, 2) == range(0, 4, 2)
  True
  >>> range(0) == range(2, 1, 3)
  True

• El rango vacío es un valor que no tiene expresión canónica, ya que cualquiera de las siguientes expresiones representan al rango vacío tan bien como cualquier otra:

  • range(0).

  • range(a,\;a), donde a es cualquier entero.

  • range(a,\;b,\;c), donde a \geq b y c > 0.

  • range(a,\;b,\;c), donde a \leq b y c < 0.

>>> range(3, 3) == range(4, 4)
True
>>> range(4, 3) == range(3, 4, -1)
True

• La función list construye una lista cuyos elementos son los mismos (y están en el mismo orden) que los elementos de ⟨iterable⟩.

• ⟨iterable⟩ puede ser:

  • una secuencia,

  • un contenedor sobre el que se pueda iterar, o

  • un iterador.

• Si se llama sin argumentos, devuelve una lista vacía.

• Por ejemplo:

  >>> list('hola')
  ['h', 'o', 'l', 'a']
  >>> list((1, 2, 3))
  [1, 2, 3]

• En memoria, las listas se almacenan mediante una estructura de datos donde sus elementos se identifican mediante un índice, que es un número entero que indica la posición que ocupa el elemento dentro de la lista.

• Por ejemplo, la siguiente lista:

  lst = [1, 2, 3]

  se almacenaría de la siguiente forma según lo representa la herramienta Pythontutor:

• Por ejemplo, la siguiente expresión generadora:

  res_gen = (x ** 2 for x in range(0, 10000000000000))

  es mucho más eficiente en tiempo y espacio que la lista por comprensión:

  res_list = [x ** 2 for x in range(0, 10000000000000)]

  ya que la expresión generadora devuelve un iterador que irá generando los valores de uno en uno a medida que los vayamos recorriendo con next(res_gen).

  En cambio, la lista por comprensión genera todos los valores de la lista a la vez y los almacena todos juntos en la memoria.

• A cambio, la ventaja de tener una lista frente a tener un iterador es que podemos acceder directamente a cualquier elemento de la lista mediante la indexación.

• Las listas por comprensión, al igual que las expresiones generadoras, determinan su propio ámbito.

• Ese ámbito abarca toda la lista por comprensión, de principio a fin.

• Los identificadores que aparecen en la cláusula for se consideran variables ligadas en la lista por comprensión.

• Esos identificadores se van ligando, uno a uno, a cada elemento de la secuencia indicada en la cláusula in.

• Como son variables ligadas, cumplen estas dos propiedades:

  1. Se pueden renombrar (siempre de forma consistente) sin que la lista por comprensión cambie su significado.

     Por ejemplo, las dos listas por comprensión siguientes son equivalentes, puesto que producen el mismo resultado:

     [x for x in (1, 2, 3)]

     [y for y in (1, 2, 3)]

  2. No se pueden usar fuera de la lista por comprensión, ya que estarían fuera de su ámbito y no serían visibles.

     Por ejemplo, lo siguiente daría un error de nombre:

     >>> e = [x for x in (1, 2, 3)]
     >>> x       # Intento acceder a la 'x' de la lista por comprensión
     Traceback (most recent call last):
       File "<stdin>", line 1, in <module>
     NameError: name 'x' is not defined

• La copia superficial (a diferencia de la copia profunda) significa que sólo se copia el objeto sobre el que se aplica la copia, no sus elementos.

• Por tanto, al crear la copia superficial, se crea sólo un nuevo objeto, donde se copiarán las referencias de los elementos del objeto original.

• Esto influye, sobre todo, cuando los elementos de una colección mutable también son objetos mutables.

• Por ejemplo, si tenemos listas dentro de otra lista, y copiamos ésta última con .copy(), la nueva lista compartirá elementos con la lista original:

  >>> x = [[1, 2], [3, 4]]   # los elementos de «x» también son listas
  >>> y = x.copy()           # «y» es una copia de «x»
  >>> x is y
  False                      # no son la misma lista
  >>> x[0] is y[0]
  True                       # sus elementos no se han copiado,
  >>> x[0].append(9)         # sino que están compartidos por «x» e «y»
  >>> x
  [[1, 2, 99], [3, 4]]
  >>> y
  [[1, 2, 99], [3, 4]]

• El método sort permite ordenar los elementos de la secuencia de forma ascendente o descendente:

  >>> x = [3, 6, 2, 9, 1, 4]
  >>> x.sort()
  >>> x
  [1, 2, 3, 4, 6, 9]
  >>> x.sort(reverse=True)
  >>> x
  [9, 6, 4, 3, 2, 1]

• Cuando decimos que un conjunto no está ordenado, queremos decir que los elementos que contiene no se encuentran situados en una posición concreta.

  Es lo contrario de lo que ocurre con las sencuencias, donde cada elemento se encuentra en una posición indicada por su índice y podemos acceder a él usando la indexación.

• Además, en un conjunto no puede haber elementos repetidos (un elemento concreto sólo puede estar una vez dentro de un conjunto, es decir, o está una vez o no está).

• En resumen:

  En un conjunto:

  Un elemento concreto, o está una vez, o no está.

  Si está, no podemos saber en qué posición (no tiene sentido preguntárselo).

• Existen dos tipos predefinidos de conjuntos: set y frozenset.

• El tipo set es mutable, es decir, que su contenido puede cambiar usando métodos como add y remove.

  Como es mutable, no es hashable y, por tanto, no puede usarse como clave de un diccionario o como elemento de otro conjunto.

• El tipo frozenset es inmutable y hashable. Por tanto, su contenido no se puede cambiar una vez creado y puede usarse como clave de un diccionario o como elemento de otro conjunto.

• Los dos tipos de conjuntos se crean con las funciones set([⟨iterable⟩]) y frozenset([⟨iterable⟩]):

  • Si se llaman sin argumentos, devuelven un conjunto vacío:

    • set() devuelve un conjunto vacío de tipo set.

    • frozenset() devuelve un conjunto vacío de tipo frozenset.

    >>> set()
    set()
    >>> frozenset()
    frozenset()

    Como se ve, esas son, precisamente, las formas normales de un conjunto vacío de tipo set y frozenset.

  • Si se les pasa un iterable (como por ejemplo, una lista), devuelve un conjunto formado por los elementos del iterable:

    >>> set([4, 3, 2, 2, 4])
    {2, 3, 4}
    >>> frozenset([4, 3, 2, 2, 4])
    frozenset({2, 3, 4})

• Además, existe una sintaxis especial para escribir literales de conjuntos no vacíos de tipo set, que consiste en encerrar sus elementos entre llaves y separados por comas: {'pepe', 'juan'}.

  >>> x = {'pepe', 'juan'}  # un literal de tipo set, como set(['pepe', 'juan'])
  >>> x
  {'pepe', 'juan'}
  >>> type(x)
  <class 'set'>

  Esa es, precisamente, la forma normal de un conjunto no vacío y, por tanto, la que se usa cuando se visualiza desde el intérprete o se imprime con print.

• Por tanto, para crear conjuntos congelados usando frozenset podemos usar esa sintaxis en lugar de usar listas como hicimos antes:

  >>> frozenset({4, 3, 2, 2, 4})
  frozenset({2, 3, 4})

• También podría usarse con la función set, pero entonces estaríamos creando un nuevo conjunto igual que el anterior, aunque no idéntico (es decir, sería una copia del original):

  >>> s = {4, 3, 2, 2, 4}
  >>> s
  {2, 3, 4}
  >>> t = set(s)
  >>> t
  {2, 3, 4}
  >>> s == t
  True
  >>> s is t
  False

• En memoria, los conjuntos se almacenan mediante una estructura de datos donde sus elementos no se identifican mediante ningún índice o clave especial.

• Por ejemplo, el siguiente conjunto:

  d = {1, 2, 3}

  se almacenaría de la siguiente forma según lo representa la herramienta Pythontutor:

• Los conjuntos por comprensión, al igual que las expresiones generadoras y las listas por comprensión, determinan su propio ámbito.

• Ese ámbito abarca todo el conjunto por comprensión, de principio a fin.

• Los identificadores que aparecen en la cláusula for se consideran variables ligadas en el conjunto por comprensión.

• Esos identificadores se van ligando, uno a uno, a cada elemento de la secuencia indicada en la cláusula in.

• Como son variables ligadas, cumplen estas dos propiedades:

  1. Se pueden renombrar (siempre de forma consistente) sin que el conjunto por comprensión cambie su significado.

     Por ejemplo, los dos conjuntos por comprensión siguientes son equivalentes, puesto que producen el mismo resultado:

     {x for x in (1, 2, 3)}

     {y for y in (1, 2, 3)}

  2. No se pueden usar fuera del conjunto por comprensión, ya que estarían fuera de su ámbito y no serían visibles.

     Por ejemplo, lo siguiente daría un error de nombre:

     >>> e = {x for x in (1, 2, 3)}
     >>> x       # Intento acceder a la 'x' del conjunto por comprensión
     Traceback (most recent call last):
       File "<stdin>", line 1, in <module>
     NameError: name 'x' is not defined

• Tanto set como frozenset admiten comparaciones entre conjuntos.

• Suponiendo que a y b son conjuntos:

  • a == b si y sólo si cada elemento de a pertenece también a b, y viceversa; es decir, si cada uno es un subconjunto del otro.

  • a <= b si y sólo si a es un subconjunto de b (es decir, si cada elemento de a está también en b).

  • a < b si y sólo si a es un subconjunto propio de b (es decir, si a es un subconjunto de b, pero no es igual a b).

  • a >= b si y sólo si a es un superconjunto de b (es decir, si cada elemento de b está también en a).

  • a > b si y sólo si a es un superconjunto propio de b (es decir, si a es un superconjunto de b, pero no es igual a b).

• Los diccionarios se pueden crear:

  • Con una pareja de llaves:

    {}

    que representan el diccionario vacío.

  • Encerrando entre llaves una lista de parejas ⟨clave⟩:⟨valor⟩ separadas por comas:

    {'juan': 4098, 'pepe': 4127}

    Esa es precisamente la forma normal de un diccionario y, por tanto, la que se usa cuando se visualiza desde el intérprete o se imprime con print.

  • Usando la función dict.

• Por ejemplo:

  >>> v1 = {}                                          # diccionario vacío
  >>> v2 = dict()                                      # también diccionario vacío
  >>> v1 == v2
  True                                                 # son iguales
  >>> a = {'uno': 1, 'dos': 2, 'tres': 3}              # literal
  >>> b = dict(uno=1, dos=2, tres=3)                   # argumentos con nombre
  >>> c = dict([('dos', 2), ('uno', 1), ('tres', 3)])  # lista de tuplas
  >>> d = dict({'tres': 3, 'uno': 1, 'dos': 2})        # crea una copia
  >>> e = dict(zip(['uno', 'dos', 'tres'], [1, 2, 3])) # con dos iterables
  >>> a == b and b == c and c == d and d == e          # todos son iguales
  True

• En memoria, los diccionarios se almacenan como tablas de dos columnas, la clave y el valor.

• Por ejemplo, el siguiente diccionario:

  d = {'a': 1, 'b': 2, 'c': 3}

  se almacenaría de la siguiente forma según lo representa la herramienta Pythontutor:

• Las claves de un diccionario deben cumplir dos restricciones:

  1. Deben ser únicas en ese diccionario.

  2. Deben ser hashables.

• Si se intenta crear un diccionario con claves repetidas, sólo se almacenará uno de los elementos que tengan la misma clave (los demás se ignoran):

  >>> a = {'perro': 'dog', 'gato': 'cat', 'perro': 'doggy'}
  >>> a
  {'perro': 'doggy', 'gato': 'cat'}

  Como se ve, la clave 'perro' está repetida y, por tanto, sólo se almacena uno de los dos elementos con clave repetida, que siempre es el último que se va a insertar en el diccionario.

  En este caso, se almacena el elemento 'perro': 'doggy' y se ignora el 'perro': 'dog'.

• Desde la versión 3.7 de Python, los elementos dentro de un diccionario se almacenan en el orden en el que se van insertando dentro del diccionario, aunque ese orden sólo tiene importancia en determinadas situaciones concretas.

• Dos diccionarios se consideran iguales si ambos contienen los mismos elementos, es decir, si tienen las mismas parejas ⟨clave⟩:⟨valor⟩, sin importar el orden en el que aparezcan los elementos en el diccionario:

  >>> {'a': 1, 'b': 2} == {'b': 2, 'a': 1}
  True

• Para acceder a un elemento del diccionario se usa una sintaxis idéntica a la de la indexación, salvo que, en este caso, en lugar de usar el índice o posición del elemento, se usa la clave:

  >>> a = {'perro': 'dog', 'gato': 'cat'}
  >>> a['perro']
  'dog'

• Si se intenta acceder a un elemento usando una clave que no existe, se lanza una excepción de tipo KeyError:

  >>> a['caballo']
  Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  KeyError: 'caballo'

• Los diccionarios por comprensión, al igual que los conjuntos por comprensión, las expresiones generadoras y las listas por comprensión, determinan su propio ámbito.

• Ese ámbito abarca todo el diccionario por comprensión, de principio a fin.

• Los identificadores que aparecen en la cláusula for se consideran variables ligadas en el diccionario por comprensión.

• Esos identificadores se van ligando, uno a uno, a cada elemento de la secuencia indicada en la cláusula in.

• Como son variables ligadas, cumplen estas dos propiedades:

  1. Se pueden renombrar (siempre de forma consistente) sin que el diccionario por comprensión cambie su significado.

     Por ejemplo, los dos diccionarios por comprensión siguientes son equivalentes, puesto que producen el mismo resultado:

     {x: x ** 2 for x in (1, 2, 3)}

     {y: y ** 2 for y in (1, 2, 3)}

  2. No se pueden usar fuera del diccionario por comprensión, ya que estarían fuera de su ámbito y no serían visibles.

     Por ejemplo, lo siguiente daría un error de nombre:

     >>> e = {x: x ** 2 for x in (1, 2, 3)}
     >>> x       # Intento acceder a la 'x' del diccinario por comprensión
     Traceback (most recent call last):
       File "<stdin>", line 1, in <module>
     NameError: name 'x' is not defined

• Si, además de acceder a las claves, necesitamos también acceder a los valores del diccionario mientras lo recorremos, podemos:

  • Acceder al valor a partir de la clave usando indexación:

    >>> for k in d:
    ...     print(k, d[k])
    ...
    a 1
    b 2

  • Usar el método items sobre el diccionario (el cual devuelve un objeto que, al iterar sobre él, genera una secuencia de tuplas (⟨clave⟩, ⟨valor⟩)), y combinarlo con el desempaquetado de tuplas:

    >>> d.items()
    dict_items([('a', 1), ('b', 2)]
    >>> for k, v in d.items():
    ...     print(k, v)
    ...
    a 1
    b 2

• Otros métodos útiles para recorrer un diccionario son keys y values.

• En la práctica, no resulta muy útil usar keys, ya que se puede hacer lo mismo recorriendo directamente el propio diccionario, como ya sabemos:

  >>> for k in d:
  ...     print(k)
  ...
  a
  b

• Podemos encontrarnos lo siguiente:

  • Lo que hay entre ángulos (como <raiz>) es una etiqueta.

  • Lo que hay entre dos etiquetas (como el 7 en <nota>7</nota>) es el texto de la etiqueta.

  • Lo que hay dentro de la etiqueta (como numero="111") es un atributo de la etiqueta.

    numero="111" es un atributo de la primera etiqueta <alumno>.

    numero es el nombre del atributo.

    111 es el valor del atributo numero.

  • Puede haber etiquetas con uno o varios atributos y etiquetas sin atributos.

• Ese documento representaría la siguiente estructura jerárquica:

• Se observa que:

  • Cada nodo representa una etiqueta del documento XML.

  • Si una etiqueta contiene a otra, su correspondiente nodo en el árbol tendrá un hijo que representa a la etiqueta que contiene.

  • Los hijos de un nodo están ordenados por la posición que ocupan dentro de su etiqueta padre.

• Los nodos del árbol se representan internamente mediante objetos de tipo Element, los cuales disponen de ciertos atributos y responden a ciertos métodos.

  ¡Cuidado! Aquí, cuando hablamos de atributos, nos referimos a información que contiene el objeto (una cualidad del objeto según el paradigma orientado a objetos) y a la cual se puede acceder usando el operador punto (.), no a los atributos que pueda tener una etiqueta según consten en el documento XML.

• Los objetos de tipo Element disponen de los siguientes atributos:

  • tag: una cadena que representa a la etiqueta del nodo (por ejemplo: si la etiqueta es <alumno>, entonces tag contendrá 'alumno').

  • attrib: un diccionario que representa a los atributos de esa etiqueta en el documento XML.

  • text: una cadena que representa el contenido del nodo, es decir, el texto que hay entre <etiqueta> y </etiqueta>.

• Por ejemplo, si tenemos la siguiente etiqueta en el documento XML:

  <telefono tipo="movil">666555444</telefono>

  y la variable nodo contiene el nodo (es decir, el objeto Element) que representa a dicha etiqueta en el árbol, entonces:

  • nodo.tag valdrá 'telefono'.

  • nodo.attrib valdrá {'tipo': 'movil'}.

  • nodo.text valdrá '666555444'.

• En nuestro caso, raiz es un objeto de tipo Element que, además, representa al nodo raíz del árbol XML.

• Por tanto, tendríamos lo siguiente:

  >>> raiz.tag
  'raiz'
  >>> raiz.attrib
  {}
  >>> raiz.text
  '\n    '              # ¿Por qué?

• Los objetos Element son iterables. Por ejemplo, el nodo raíz tiene nodos hijos (nodos que «cuelgan» directamente del nodo raíz) sobre los cuales se puede iterar desde el objeto raiz:

  >>> for hijo in raiz:
  ...     print(hijo.tag, hijo.attrib)
  ...
  alumno {'numero': '111'}
  alumno {'numero': '222'}
  madre {}

• Los hijos están anidados, y podemos acceder a nodos concretos a través de su índice (es decir, que los objetos Element son indexables):

  >>> raiz[0]       # el primer hijo directo de raiz
  <Element 'alumno' at 0x7f929c29cf90>
  >>> raiz[0][2]    # el tercer hijo directo del primer hijo directo de raiz
  <Element 'telefono' at 0x7f929c29d180>
  >>> raiz[0][2].text
  '666555444'

• Los objetos de tipo Element disponen de métodos útiles para iterar recursivamente sobre todos los subárboles situados debajo de él (sus hijos, los hijos de sus hijos, y así sucesivamente).

• Por ejemplo, el método iter devuelve un iterador que recorre todos los nodos del árbol desde el nodo actual (el nodo sobre el que se invoca al método) en un orden primero en profundidad.

• Eso quiere decir que va visitando los nodos en el mismo orden en el que se encuentran escritos en el documento XML, incluyendo el propio nodo sobre el que se invoca.

• El método findall devuelve una lista con los nodos que tengan una cierta etiqueta y que sean hijos directos del nodo sobre el que se invoca.

  Puede devolver una lista vacía si no hay nodos que cumplan la condición.

• El método find devuelve el primer hijo directo del nodo sobre el que se invoca, siempre que tenga una cierta etiqueta indicada como argumento.

  Puede devolver None si el nodo no tiene ningún hijo con esa etiqueta.

• El método get devuelve el valor de algún atributo de la etiqueta asociada a ese nodo:

  >>> for alumno in raiz.findall('alumno'):
  ...     numero = alumno.get('numero')
  ...     dni = alumno.find('dni').text
  ...     print(numero, dni)
  ...
  111 12312312A
  222 44455566B

• Si la etiqueta no tiene el atributo indicado en el argumento de get, éste devuelve None o el valor que se haya indicado en el segundo argumento:

  >>> alumno = raiz[0]
  >>> alumno.get('numero')
  111
  >>> alumno.get('altura')
  None
  >>> alumno.get('altura', 0)
  0
  >>> alumno.get('numero', 0)
  111

• También disponemos de la función dump que devuelve la cadena correspondiente al nodo que se le pase como argumento:

  >>> ET.dump(raiz[0][2])
  <telefono>666555444</telefono>

• Para una especificación más sofisticada de los elementos a encontrar, se pueden usar las expresiones XPath con los métodos find y findall:

  Sintaxis	Significado
  etiqueta	Selecciona todos los nodos hijo con la etiqueta etiqueta. Por ejemplo, pepe selecciona todos los nodos hijo llamados pepe, y pepe/juan selecciona todos los nietos llamados juan en todos los hijos llamados pepe.
  *	Selecciona todos los nodos hijo inmediatos. Por ejemplo, */pepe selecciona todos los nietos llamados pepe.
  .	Selecciona el nodo actual. Se usa, sobre todo, al principio de la ruta para indicar que es una ruta relativa.
  //	Selecciona todos los subnodos en cualquier nivel por debajo de un nodo. Por ejemplo, .//pepe selecciona todos los nodos pepe que haya en todo el árbol.
  ..	Selecciona el nodo padre. Devuelve None si se intenta acceder a un ancestro del nodo de inicio (aquel sobre el que se ha llamado al método find).

• Continuación de las expresiones XPath:

  Sintaxis	Significado
  [@atrib]	Selecciona todos los nodos que tienen el atributo atrib.
  [@atrib='valor']	Selecciona todos los nodos que tienen el valor valor en el atributo atrib. El valor no puede contener apóstrofes.
  [@atrib!='valor']	Selecciona todos los nodos que tienen el valor valor en el atributo atrib. El valor no puede contener apóstrofes.
  [etiqueta]	Selecciona todos los nodos que tienen un hijo inmediato llamado etiqueta.
  [posición]	Selecciona todos los nodos situados en cierta posición. Ésta puede ser un entero (1 es la primera posición), la expresión last() (la última posición) o una posición relativa a la última posición (por ejemplo, last() - 1).

• Por ejemplo, supongamos que queremos sumarle 1 a la nota de cada alumno y añadir un atributo modificado a la etiqueta nota:

  >>> for nota in raiz.iter('nota'):
  ...     nueva_nota = int(nota.text) + 1
  ...     nota.text = str(nueva_nota)
  ...     nota.set('modificado', 'si')
  ...
  >>> arbol.write('salida.xml')

• Nuestro XML tendría ahora el siguiente aspecto:

  <?xml version="1.0"?>
  <raiz>
      <alumno numero="111">
          <dni>12312312A</dni>
          <nombre>
              <propio>Juan</propio>
              <apellidos>García González</apellidos>
          </nombre>
          <telefono>666555444</telefono>
          <nota modificado="si">8</nota>
      </alumno>
      <alumno numero="222">
          <dni>44455566B</dni>
          <nombre>
              <propio>María</propio>
              <apellidos>Pérez Rodríguez</apellidos>
          </nombre>
          <telefono>696969696</telefono>
          <nota modificado="si">10</nota>
      </alumno>
      <madre>
          <dni>22222222C</dni>
      </madre>
  </raiz>

• Podemos insertar nuevos nodos hijos de un determinado nodo con los métodos append o insert, como si el nodo fuese una lista.

• Para ello, primero normalmente crearemos el nodo que vamos a insertar usando Element(etiqueta).

• Por ejemplo, añadimos el teléfono a la única madre que tenemos en el documento XML:

  telefono = ET.Element('telefono')
  telefono.text = '956366666'
  madre = raiz.find('madre')
  madre.append(telefono)

• Tras estas operaciones, ahora tendríamos:

• Podríamos haber usado insert en lugar de append para cambiar la posición donde situar el nodo hijo.

• Por ejemplo, si queremos situar el teléfono antes que el DNI, podríamos hacer:

  telefono = ET.Element('telefono')
  telefono.text = '956366666'
  madre = raiz.find('madre')
  madre.insert(0, telefono)

• Tras estas operaciones, ahora tendríamos:

• Podemos eliminar elementos con el método remove. Por ejemplo, supongamos que queremos eliminar todos los alumnos con una nota inferior a 9:

  >>> for alumno in raiz.findall('alumno'):
  ...     # se usa findall para que no afecte el borrado durante el recorrido
  ...     nota = int(alumno.find('nota').text)
  ...     if nota < 9:
  ...         raiz.remove(alumno)
  ...
  >>> arbol.write('salida.xml')

• Tener en cuenta que la modificación concurrente mientras se hace una iteración puede dar problemas, lo mismo que ocurre cuando se modifican listas o diccionarios mientras se itera sobre ellos.

• Por ello, el ejemplo primero recoge todos los elementos con findall y sólo entonces itera sobre la lista que devuelve.

• Si usáramos iter en lugar de findall se podrían dar problemas debido a que iter va devolviendo perezosamente los nodos (es un iterador) y el conjunto de nodos que devuelve podría verse afectado por los borrados.

• Nuestro XML tendría ahora el siguiente aspecto:

  <?xml version="1.0"?>
  <raiz>
      <alumno numero="222">
          <dni>44455566B</dni>
          <nombre>
              <propio>María</propio>
              <apellidos>Pérez Rodríguez</apellidos>
          </nombre>
          <telefono>696969696</telefono>
          <nota modificado="si">10</nota>
      </alumno>
      <madre>
          <dni>22222222C</dni>
      </madre>
  </raiz>

• Si lo que queremos es mover un nodo (es decir, cambiar un nodo de sitio), podemos combinar los efectos de append e insert con remove.

• Por ejemplo, si queremos mover la etiqueta <madre> dentro de la etiqueta <alumno>, podríamos hacer:

  madre = raiz.find('madre')
  raiz.remove(madre)
  alumno = raiz.find('alumno')
  alumno.append(madre)

• Nuestro XML tendría ahora el siguiente aspecto:

  <?xml version="1.0"?>
  <raiz>
      <alumno numero="222">
          <dni>44455566B</dni>
          <nombre>
              <propio>María</propio>
              <apellidos>Pérez Rodríguez</apellidos>
          </nombre>
          <telefono>696969696</telefono>
          <nota modificado="si">10</nota>
          <madre>
              <dni>22222222C</dni>
          </madre>
      </alumno>
  </raiz>

• La función SubElement también proporciona una forma muy conveniente de crear sub-elementos de un elemento dado:

  >>> a = ET.Element('a')
  >>> b = ET.SubElement(a, 'b')
  >>> c = ET.SubElement(a, 'c')
  >>> d = ET.SubElement(c, 'd')
  >>> ET.dump(a)
  <a><b /><c><d /></c></a>