This document is for an old version of Python that is no longer supported. You should upgrade, and read the Python documentation for the current stable release.

# `ipaddress` — Biblioteca de manipulación IPv4/IPv6

Código fuente: Lib/ipaddress.py

`ipaddress` proporciona las capacidades para crear, manipular y operar en direcciones y redes IPv4 e IPv6.

Las funciones y clases de este módulo facilitan el control de varias tareas relacionadas con las direcciones IP, incluido comprobar si dos hosts están en la misma subred o no, iterar sobre todos los hosts de una subred determinada, comprobar si una cadena de caracteres representa o no una dirección IP válida o una definición de red, etc.

Esta es la referencia completa de la API del módulo: para obtener información general y una introducción, véase Introducción al modulo ipaddress.

Nuevo en la versión 3.3.

## Funciones de fábrica de conveniencia

El módulo `ipaddress` proporciona funciones de fábrica para crear convenientemente direcciones IP, redes e interfaces:

`ipaddress.``ip_address`(address)

  Return an `IPv4Address` or `IPv6Address` object depending on the IP address passed as argument. Either IPv4 or IPv6 addresses may be supplied; integers less than `2**32` will be considered to be IPv4 by default. A `ValueError` is raised if address does not represent a valid IPv4 or IPv6 address.

      >>> ipaddress.ip_address('192.168.0.1')
      IPv4Address('192.168.0.1')
      >>> ipaddress.ip_address('2001:db8::')
      IPv6Address('2001:db8::')

`ipaddress.``ip_network`(address, strict=True)

  Return an `IPv4Network` or `IPv6Network` object depending on the IP address passed as argument. address is a string or integer representing the IP network. Either IPv4 or IPv6 networks may be supplied; integers less than `2**32` will be considered to be IPv4 by default. strict is passed to `IPv4Network` or `IPv6Network` constructor. A `ValueError` is raised if address does not represent a valid IPv4 or IPv6 address, or if the network has host bits set.

      >>> ipaddress.ip_network('192.168.0.0/28')
      IPv4Network('192.168.0.0/28')

`ipaddress.``ip_interface`(address)

  Return an `IPv4Interface` or `IPv6Interface` object depending on the IP address passed as argument. address is a string or integer representing the IP address. Either IPv4 or IPv6 addresses may be supplied; integers less than `2**32` will be considered to be IPv4 by default. A `ValueError` is raised if address does not represent a valid IPv4 or IPv6 address.

Una desventaja de estas funciones de conveniencia es que la necesidad de manejar ambos formatos IPv4 e IPv6 significa que los mensajes de error proveen información mínima sobre el error preciso, ya que las funciones no saben si se pretendía usar el formato IPv4 o IPv6. Un reporte de error más detallado se puede obtener llamando directamente a los constructores de clase específicos para la versión apropiada.

## Direcciones IP

### Objetos de dirección

Los objetos `IPv4Address` y `IPv6Address` comparten muchos atributos comunes. Algunos atributos que son sólo significativos para direcciones IPv6 también están implementados para los objetos `IPv4Address`, para que sea más fácil escribir código que maneje ambas versiones de IP correctamente. Los objetos de dirección son hashable, por lo que se pueden utilizar como claves en diccionarios.

class `ipaddress.``IPv4Address`(address)

  Construye una dirección IPv4. Se genera un `AddressValueError` si address no es una dirección IPv4 válida.

  Lo siguiente constituye una dirección IPv4 válida:

  1. A string in decimal-dot notation, consisting of four decimal integers in the inclusive range 0–255, separated by dots (e.g. `192.168.0.1`). Each integer represents an octet (byte) in the address. Leading zeroes are not tolerated to prevent confusion with octal notation.

  2. Un entero que cabe en 32 bits.

  3. Un entero empaquetado en un objeto `bytes` de longitud 4 (el octeto más significativo primero).

      >>> ipaddress.IPv4Address('192.168.0.1')
      IPv4Address('192.168.0.1')
      >>> ipaddress.IPv4Address(3232235521)
      IPv4Address('192.168.0.1')
      >>> ipaddress.IPv4Address(b'\xC0\xA8\x00\x01')
      IPv4Address('192.168.0.1')

  Distinto en la versión 3.8: Leading zeros are tolerated, even in ambiguous cases that look like octal notation.

  Distinto en la versión 3.10: Leading zeros are no longer tolerated and are treated as an error. IPv4 address strings are now parsed as strict as glibc `inet_pton()`.

  Distinto en la versión 3.9.5: The above change was also included in Python 3.9 starting with version 3.9.5.

  Distinto en la versión 3.8.12: The above change was also included in Python 3.8 starting with version 3.8.12.

  `version`

    El número de versión apropiado: `4` para IPv4, `6` para IPv6.

  `max_prefixlen`

    El número total de bits en la representación de la dirección para esta versión: `32` para IPv4, `128` para IPv6.

    El prefijo define el número de bits iniciales en una dirección que son comparados para determinar si una dirección es o no parte de una red.

  `compressed`
  `exploded`

    La representación de cadena de caracteres en notación decimal con puntos. Los ceros a la izquierda nunca se incluyen en la representación.

    Como IPv4 no define una notación abreviada para direcciones con octetos establecidos en cero, estos dos atributos son siempre los mismos que `str(addr)` para direcciones IPv4. Exponer estos atributos hace que sea más fácil escribir código de visualización que pueda manejar direcciones IPv4 e IPv46.

  `packed`

    La representación binaria de esta dirección - un objeto `bytes` de la longitud apropiada (octeto más significativo primero). Esta es 4 bytes para IPv4 y 16 bytes para IPv6.

  `reverse_pointer`

    El nombre del registro PTR DNS inverso para la dirección IP, por ejemplo:

        >>> ipaddress.ip_address("127.0.0.1").reverse_pointer
        '1.0.0.127.in-addr.arpa'
        >>> ipaddress.ip_address("2001:db8::1").reverse_pointer
        '1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa'

    Este es el nombre que podría usarse para realizar una búsqueda PTR, no el nombre de host resuelto en sí.

    Nuevo en la versión 3.5.

  `is_multicast`

    `True` si la dirección está reservada para uso de multidifusión. Véase RFC 3171 (para IPv4) o RFC 2373 (para IPv6).

  `is_private`

    `True` if the address is defined as not globally reachable by iana-ipv4-special-registry (for IPv4) or iana-ipv6-special-registry (for IPv6) with the following exceptions:

    - `is_private` is `False` for the shared address space (`100.64.0.0/10`)

    - For IPv4-mapped IPv6-addresses the `is_private` value is determined by the semantics of the underlying IPv4 addresses and the following condition holds (see `IPv6Address.ipv4_mapped`):

          address.is_private == address.ipv4_mapped.is_private

    `is_private` has value opposite to `is_global`, except for the shared address space (`100.64.0.0/10` range) where they are both `False`.

    Distinto en la versión 3.9.20: Fixed some false positives and false negatives.

    - `192.0.0.0/24` is considered private with the exception of `192.0.0.9/32` and `192.0.0.10/32` (previously: only the `192.0.0.0/29` sub-range was considered private).

    - `64:ff9b:1::/48` is considered private.

    - `2002::/16` is considered private.

    - There are exceptions within `2001::/23` (otherwise considered private): `2001:1::1/128`, `2001:1::2/128`, `2001:3::/32`, `2001:4:112::/48`, `2001:20::/28`, `2001:30::/28`. The exceptions are not considered private.

  `is_global`

    `True` if the address is defined as globally reachable by iana-ipv4-special-registry (for IPv4) or iana-ipv6-special-registry (for IPv6) with the following exception:

    For IPv4-mapped IPv6-addresses the `is_private` value is determined by the semantics of the underlying IPv4 addresses and the following condition holds (see `IPv6Address.ipv4_mapped`):

        address.is_global == address.ipv4_mapped.is_global

    `is_global` has value opposite to `is_private`, except for the shared address space (`100.64.0.0/10` range) where they are both `False`.

    Nuevo en la versión 3.4.

    Distinto en la versión 3.9.20: Fixed some false positives and false negatives, see `is_private` for details.

  `is_unspecified`

    `True` si la dirección no está especificada. Véase RFC 5735 (para IPv4) o RFC 2373 (para IPv6).

  `is_reserved`

    `True` si la dirección está reservada por la IETF.

  `is_loopback`

    `True` si esta es una dirección de loopback. Véase RFC 3330 (para IPv4) o RFC 2373 (para IPv6).

  `is_link_local`

    `True` si la dirección está reservada para uso de enlace-local. Véase RFC 3927.

`IPv4Address.``__format__`(fmt)

  Retorna una representación en cadena de caracteres de la dirección IP, controlada por una cadena de formato explícito. fmt puede ser uno de los siguientes: `'s'`, la opción predeterminada, equivalente a `str()`, `'b'` para una cadena binaria con relleno de ceros, `'X'` o `'x'` para una representación hexadecimal en mayúsculas o minúsculas, o `'n'`, que es equivalente a `'b'` para direcciones IPv4 y `'x'` para IPv6. Para representaciones binarias y hexadecimales, el especificador de formulario `'#'` y la opción de agrupación `'_'` están disponibles. `__format__` es utilizado por `format`, `str.format` y f-strings.

      >>> format(ipaddress.IPv4Address('192.168.0.1'))
      '192.168.0.1'
      >>> '{:#b}'.format(ipaddress.IPv4Address('192.168.0.1'))
      '0b11000000101010000000000000000001'
      >>> f'{ipaddress.IPv6Address("2001:db8::1000"):s}'
      '2001:db8::1000'
      >>> format(ipaddress.IPv6Address('2001:db8::1000'), '_X')
      '2001_0DB8_0000_0000_0000_0000_0000_1000'
      >>> '{:#_n}'.format(ipaddress.IPv6Address('2001:db8::1000'))
      '0x2001_0db8_0000_0000_0000_0000_0000_1000'

  Nuevo en la versión 3.9.

class `ipaddress.``IPv6Address`(address)

  Construye una dirección IPv6. Se genera un `AddressValueError` si address no es una dirección IPv6 válida.

  Lo siguiente constituye una dirección IPv6 válida:

  1. Una cadena de caracteres que consta de 8 grupos de cuatro dígitos hexadecimales, cada grupo representa 16 bits. Los grupos son separados por dos puntos. Esto describe una notación completa (larga). La cadena también puede ser comprimida (notación corta) de varias maneras. Véase RFC 4291 para más detalles. Por ejemplo, `"0000:0000:0000:0000:0000:0abc:0007:0def"` puede ser comprimida a `"::abc:7:def"`.

     Opcionalmente, la cadena de caracteres también puede tener un ID alcance, expresado con un sufijo `%scope_id`. Si está presente, el ID de alcance no debe estar vacío y no puede contener `%`. Consulte RFC 4007 para obtener más detalles. Por ejemplo, `fe80::1234% 1` podría identificar la dirección `fe80::1234` en el primer enlace del nodo.

  2. Un entero que cabe en 128 bits.

  3. Un entero empaquetado en un objeto `bytes` de longitud 16, big-endian.

      >>> ipaddress.IPv6Address('2001:db8::1000')
      IPv6Address('2001:db8::1000')
      >>> ipaddress.IPv6Address('ff02::5678%1')
      IPv6Address('ff02::5678%1')

  `compressed`

  La forma abreviada de la representación de la dirección, omitiendo los ceros a la izquierda en los grupos y la secuencia más larga de grupos que consisten completamente de ceros colapsada en un sólo grupo vacío.

  Este es también el valor retornado por `str(addr)` para direcciones IPv6.

  `exploded`

  La forma larga de la representación de la dirección, incluidos todos los ceros iniciales y los grupos que consisten completamente de ceros.

  Para los siguientes atributos, véase la documentación correspondiente de la clase `IPv4Address`:

  `packed`
  `reverse_pointer`
  `version`
  `max_prefixlen`
  `is_multicast`
  `is_private`
  `is_global`
  `is_unspecified`
  `is_reserved`
  `is_loopback`
  `is_link_local`

    Nuevo en la versión 3.4: is_global

  `is_site_local`

    `True` si la dirección está reservada para el uso local del sitio. Tenga en cuenta que el espacio de direcciones locales del sitio ha quedado en desuso por RFC 3879. Utilice `is_private` para probar si esta dirección está en el espacio de direcciones locales únicas según lo definido por RFC 4193.

  `ipv4_mapped`

    Para las direcciones que parecen ser direcciones IPv4 mapeadas (comenzando con `::FFFF/96`), esta propiedad informará la dirección IPv4 incrustada. Para cualquier otra dirección, esta propiedad será `None`.

  `scope_id`

    Para las direcciones con alcance como es definido por RFC 4007, esta propiedad identifica la zona particular del alcance de la dirección a la que pertenece dicha dirección, como una cadena de caracteres. Cuando no se especifica ninguna zona de alcance, esta propiedad será `None`.

  `sixtofour`

    Para las direcciones que parecen ser direcciones 6to4 (comenzando con `2002::/16`) según lo definido por RFC 3056, esta propiedad reportará la dirección IPv4 incrustada. Para cualquier otra dirección, esta propiedad será `None`.

  `teredo`

    Para las direcciones que parecen ser direcciones Teredo (comenzando con `2001::/32`) según lo definido en RFC 4380, esta propiedad reportará el par de direcciones IP `(servidor, cliente)` incrustadas. Para cualquier otra dirección, esta propiedad será `None`.

`IPv6Address.``__format__`(fmt)

  Consulta en `IPv4Address` la documentación de atributos correspondiente.

  Nuevo en la versión 3.9.

### Conversión a cadenas de caracteres y enteros

Para interoperar con interfaces de red como el módulo socket, las direcciones se deben convertir en cadenas de caracteres o enteros. Esto se gestiona usando las funciones `str()` e `int()` incorporadas:

    >>> str(ipaddress.IPv4Address('192.168.0.1'))
    '192.168.0.1'
    >>> int(ipaddress.IPv4Address('192.168.0.1'))
    3232235521
    >>> str(ipaddress.IPv6Address('::1'))
    '::1'
    >>> int(ipaddress.IPv6Address('::1'))
    1

Tenga en cuenta que las direcciones IPv6 con alcance se convierten en números enteros sin ID de zona de alcance.

### Operadores

Los objetos de dirección admiten algunos operadores. A menos que se indique lo contrario, los operadores solo se pueden aplicar entre objetos compatibles (es decir, IPv4 con IPv4, IPv6 con IPv6).

#### Operadores de comparación

Los objetos de dirección pueden compararse con el conjunto usual de operadores de comparación. Las mismas direcciones IPv6 con diferentes ID de zona de alcance no son iguales. Algunos ejemplos:

    >>> IPv4Address('127.0.0.2') > IPv4Address('127.0.0.1')
    True
    >>> IPv4Address('127.0.0.2') == IPv4Address('127.0.0.1')
    False
    >>> IPv4Address('127.0.0.2') != IPv4Address('127.0.0.1')
    True
    >>> IPv6Address('fe80::1234') == IPv6Address('fe80::1234%1')
    False
    >>> IPv6Address('fe80::1234%1') != IPv6Address('fe80::1234%2')
    True

#### Operadores aritméticos

Los enteros pueden ser sumados o restados de objetos de dirección. Algunos ejemplos:

    >>> IPv4Address('127.0.0.2') + 3
    IPv4Address('127.0.0.5')
    >>> IPv4Address('127.0.0.2') - 3
    IPv4Address('126.255.255.255')
    >>> IPv4Address('255.255.255.255') + 1
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ipaddress.AddressValueError: 4294967296 (>= 2**32) is not permitted as an IPv4 address

## Definiciones de red IP

Los objetos `IPv4Network` y `IPv6Network` proveen un mecanismo para definir e inspeccionar definiciones de redes IP. Una definición de red consiste en una máscara y una dirección de red, y como tal define un rango de direcciones IP que son iguales a la dirección de red cuando se enmascaran (AND binario) con la máscara. Por ejemplo, una definición de red con la máscara `255.255.255.0` y la dirección de red `192.168.1.0` consiste de las direcciones IP en el rango inclusivo `192.168.1.0` a `192.168.1.255`.

### Prefijo, máscara de red y máscara de host

Hay varias maneras equivalentes de especificar máscaras de red IP. Un prefijo es una notación que denota cuántos bits de orden superior se establecen en la máscara de red. Una máscara de red es una dirección IP con cierto número de bits de orden superior establecidos. Por lo tanto, el prefijo `/24` es equivalente a la máscara de red `255.255.255.0` en IPv4, o `ffff:ff00::` en IPv6. Además, una máscara del host es la inversa lógica de una máscara de red, y se utiliza a veces (por ejemplo en las listas de control de acceso de Cisco) para denotar una máscara de red. La máscara de host equivalente a `/24` en IPv4 es `0.0.0.255`.

### Objetos de red

Todos los atributos implementados por los objetos de dirección también se implementan mediante objetos de red. Además, los objetos de red implementan atributos adicionales. Todos estos son comunes entre `IPv4Network` y `IPv6Network`, por lo que para evitar la duplicación solo están documentados para `IPv4Network`. Los objetos de red son hashable, por lo que se pueden utilizar como claves en diccionarios.

class `ipaddress.``IPv4Network`(address, strict=True)

  Construye una definición de red IPv4. address puede ser uno de los siguientes:

  1. Una cadena de caracteres de una dirección IP y una máscara opcional, separadas por una barra diagonal (`/`). La dirección IP es la dirección de red, y la máscara puede ser un número único, lo que significa que es un prefijo, o una representación de una dirección IPv4. Si es la última, la máscara se interpreta como una máscara de red si comienza con un campo distinto de cero, o como una máscara de host si comienza con un campo igual a cero, con la única excepción de una máscara con todos ceros que es tratada como una máscara de red. Si no se proporciona una máscara, se considera `\32`.

     Por ejemplo, las siguientes especificaciones de address son equivalentes: `192.168.1.0/24`, `192.168.1.0/255.255.255.0` y `192.168.1.0/0.0.0.255`.

  2. Un entero que cabe en 32 bits. Este es equivalente a una red de una sola dirección, siendo address la dirección de red y `/32` la máscara.

  3. Un entero empaquetado en un objeto `bytes` de longitud 4, big-endian. La interpretación es similar a un entero address.

  4. Una tupla con dos elementos con una descripción de dirección y una máscara de red, donde la descripción de dirección es una cadena de caracteres, un entero de 32 bits, un entero empaquetado de 4 bytes, o un objeto IPv4Address existente; y una máscara de red es un entero que representa la longitud del prefijo (por ejemplo `24`) o una cadena de caracteres que representa la máscara de prefijo (por ejemplo `255.255.255.0`).

  Se genera un `AddressValueError` si address no es una dirección IPv4 válida. Se genera un `NetmaskValueError` si la máscara no es válida para un dirección IPv4.

  Si strict es `True` y los bits de host están establecidos en la dirección proporcionada, se genera `ValueError`. De lo contrario, los bits de host se enmascaran para determinar la dirección de red adecuada.

  A menos que se indique lo contrario, todos los métodos de red que acepten otros objetos de red/dirección generarán `TypeError` si la versión IP del argumento es incompatible con `self`.

  Distinto en la versión 3.5: Se agregó la forma de tupla con dos elementos para el parámetro address del constructor.

  `version`
  `max_prefixlen`

    Consulta en `IPv4Address` la documentación de atributos correspondiente.

  `is_multicast`
  `is_private`
  `is_unspecified`
  `is_reserved`
  `is_loopback`
  `is_link_local`

    Estos atributos son verdaderos para la red en su conjunto si son verdaderos tanto para la dirección de red como para la dirección de difusión.

  `network_address`

    La dirección de red para la red. La dirección de red y la longitud del prefijo juntas definen de forma única una red.

  `broadcast_address`

    La dirección de difusión para la red. Los paquetes enviados a la dirección de difusión deberían ser recibidos por cada host en la red.

  `hostmask`

    La máscara de host, como un objeto `IPv4Address`.

  `netmask`

    La máscara de red, como un objeto `IPv4Address`.

  `with_prefixlen`
  `compressed`
  `exploded`

    Una representación en cadena de caracteres de la red, con la máscara en notación de prefijo.

    `with_prefixlen` y `compressed` son siempre lo mismo que `str(network)`. `exploded` usa la forma completa de la dirección de red.

  `with_netmask`

    Una representación en cadena de caracteres de la red, con la máscara en notación de máscara de red.

  `with_hostmask`

    Una representación de cadena de caracteres de la red, con la máscara en notación de máscara de host.

  `num_addresses`

    El número total de direcciones en la red.

  `prefixlen`

    Longitud del prefijo de red, en bits.

  `hosts`()

    Retorna un iterador a través de los hosts utilizables de la red. Los hosts utilizables son todas las direcciones IP que pertenecen a la red, excepto la propia dirección de red y la dirección de difusión de red. Para las redes con una longitud de máscara de 31, la dirección de red y la dirección de difusión de red también se incluyen en el resultado. Las redes con una máscara de 32 retornarán una lista que contiene la única dirección de host.

        >>> list(ip_network('192.0.2.0/29').hosts())
        [IPv4Address('192.0.2.1'), IPv4Address('192.0.2.2'),
         IPv4Address('192.0.2.3'), IPv4Address('192.0.2.4'),
         IPv4Address('192.0.2.5'), IPv4Address('192.0.2.6')]
        >>> list(ip_network('192.0.2.0/31').hosts())
        [IPv4Address('192.0.2.0'), IPv4Address('192.0.2.1')]
        >>> list(ip_network('192.0.2.1/32').hosts())
        [IPv4Address('192.0.2.1')]

  `overlaps`(other)

    `True` si esta red está parcial o totalmente contenida en other u other está totalmente contenida en esta red.

  `address_exclude`(network)

    Calcula las definiciones de red que resultan de eliminar network de esta red. Retorna un iterador de objetos de red. Se genera `ValueError` si network no está completamente contenida en esta red.

        >>> n1 = ip_network('192.0.2.0/28')
        >>> n2 = ip_network('192.0.2.1/32')
        >>> list(n1.address_exclude(n2))
        [IPv4Network('192.0.2.8/29'), IPv4Network('192.0.2.4/30'),
         IPv4Network('192.0.2.2/31'), IPv4Network('192.0.2.0/32')]

  `subnets`(prefixlen_diff=1, new_prefix=None)

    Las subredes que se unen para crear la definición de red actual, en función de los valores de argumento. prefixlen_diff es la cantidad en la que debería aumentarse nuestra longitud de prefijo. new_prefix es el nuevo prefijo deseado de las subredes; debe ser más grande que nuestro prefijo. Se debe establecer uno y solo uno de prefixlen_diff y new_prefix. Retorna un iterador de objetos de red.

        >>> list(ip_network('192.0.2.0/24').subnets())
        [IPv4Network('192.0.2.0/25'), IPv4Network('192.0.2.128/25')]
        >>> list(ip_network('192.0.2.0/24').subnets(prefixlen_diff=2))
        [IPv4Network('192.0.2.0/26'), IPv4Network('192.0.2.64/26'),
         IPv4Network('192.0.2.128/26'), IPv4Network('192.0.2.192/26')]
        >>> list(ip_network('192.0.2.0/24').subnets(new_prefix=26))
        [IPv4Network('192.0.2.0/26'), IPv4Network('192.0.2.64/26'),
         IPv4Network('192.0.2.128/26'), IPv4Network('192.0.2.192/26')]
        >>> list(ip_network('192.0.2.0/24').subnets(new_prefix=23))
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
            raise ValueError('new prefix must be longer')
        ValueError: new prefix must be longer
        >>> list(ip_network('192.0.2.0/24').subnets(new_prefix=25))
        [IPv4Network('192.0.2.0/25'), IPv4Network('192.0.2.128/25')]

  `supernet`(prefixlen_diff=1, new_prefix=None)

    La superred que contiene esta definición de red, dependiendo de los valores de los argumentos. prefixlen_diff es la cantidad en la que debería reducirse la longitud de nuestro prefijo. new_prefix es el nuevo prefijo deseado de la superred; debe ser más pequeño que nuestro prefijo. Se debe establecer uno y solo uno de prefixlen_diff y new_prefix. Retorna un único objeto de red.

        >>> ip_network('192.0.2.0/24').supernet()
        IPv4Network('192.0.2.0/23')
        >>> ip_network('192.0.2.0/24').supernet(prefixlen_diff=2)
        IPv4Network('192.0.0.0/22')
        >>> ip_network('192.0.2.0/24').supernet(new_prefix=20)
        IPv4Network('192.0.0.0/20')

  `subnet_of`(other)

    Retorna `True` si esta red es una subred de other.

        >>> a = ip_network('192.168.1.0/24')
        >>> b = ip_network('192.168.1.128/30')
        >>> b.subnet_of(a)
        True

    Nuevo en la versión 3.7.

  `supernet_of`(other)

    Retorna `True` si esta red es una superred de other.

        >>> a = ip_network('192.168.1.0/24')
        >>> b = ip_network('192.168.1.128/30')
        >>> a.supernet_of(b)
        True

    Nuevo en la versión 3.7.

  `compare_networks`(other)

    Compara esta red con other. En esta comparación solo se consideran las direcciones de red; los bits de host no. Retorna `-1`, `0` o `1`.

        >>> ip_network('192.0.2.1/32').compare_networks(ip_network('192.0.2.2/32'))
        -1
        >>> ip_network('192.0.2.1/32').compare_networks(ip_network('192.0.2.0/32'))
        1
        >>> ip_network('192.0.2.1/32').compare_networks(ip_network('192.0.2.1/32'))
        0

    Obsoleto desde la versión 3.7: Utiliza el mismo algoritmo de ordenación y comparación que «<», «==», y «>»

class `ipaddress.``IPv6Network`(address, strict=True)

  Construye una definición de red IPv6. address puede ser uno de los siguientes:

  1. Una cadena de caracteres que consta de una dirección IP y una longitud de prefijo opcional, separadas por una barra diagonal (`/`). La dirección IP es la dirección de red y la longitud del prefijo debe ser un solo número, el prefijo. Si no se proporciona ninguna longitud de prefijo, se considera que es `/128`.

     Note that currently expanded netmasks are not supported. That means `2001:db00::0/24` is a valid argument while `2001:db00::0/ffff:ff00::` is not.

  2. Un entero que cabe en 128 bits. Este es equivalente a una red de una sola dirección, siendo address la dirección de red y `/128` la máscara.

  3. Un entero empaquetado en un objeto `bytes` de longitud 16, big-endian. La interpretación es similar a un entero address.

  4. Una tupla con dos elementos con una descripción de dirección y una máscara de red, donde la descripción de dirección es una cadena de caracteres, un entero de 128 bits, un entero empaquetado de 16 bytes, o un objeto IPv6Address existente; y una máscara de red es un entero que representa la longitud del prefijo.

  Se genera un `AddressValueError` si address no es una dirección IPv6 válida. Se genera un `NetmaskValueError` si la máscara no es válida para una dirección IPv6.

  Si strict es `True` y los bits de host están establecidos en la dirección proporcionada, se genera `ValueError`. De lo contrario, los bits de host se enmascaran para determinar la dirección de red adecuada.

  Distinto en la versión 3.5: Se agregó la forma de tupla con dos elementos para el parámetro address del constructor.

  `version`
  `max_prefixlen`
  `is_multicast`
  `is_private`
  `is_unspecified`
  `is_reserved`
  `is_loopback`
  `is_link_local`
  `network_address`
  `broadcast_address`
  `hostmask`
  `netmask`
  `with_prefixlen`
  `compressed`
  `exploded`
  `with_netmask`
  `with_hostmask`
  `num_addresses`
  `prefixlen`
  `hosts`()

    Retorna un iterador sobre los hosts utilizables de la red. Los hosts utilizables son todas las direcciones IP que pertenecen a la red, excepto la dirección anycast Subnet-Router. Para las redes con una longitud de máscara de 127, la dirección anycast Subnet-Router también se incluye en el resultado. Las redes con una máscara de 128 retornarán una lista que contiene la única dirección de host.

  `overlaps`(other)
  `address_exclude`(network)
  `subnets`(prefixlen_diff=1, new_prefix=None)
  `supernet`(prefixlen_diff=1, new_prefix=None)
  `subnet_of`(other)
  `supernet_of`(other)
  `compare_networks`(other)

    Consulta en `IPv4Network` la documentación de atributos correspondiente.

  `is_site_local`

    Este atributo es verdadero para la red en su conjunto si es verdadero tanto para la dirección de red como para la dirección de difusión.

### Operadores

Los objetos de red admiten algunos operadores. A menos que se indique lo contrario, los operadores solo se pueden aplicar entre objetos compatibles (es decir, IPv4 con IPv4, IPv6 con IPv6).

#### Operadores lógicos

Los objetos de red pueden compararse con el conjunto usual de operadores lógicos. Los objetos de red son ordenados primero por dirección de red, y después por máscara de red.

#### Iteración

Los objetos de red se pueden iterar para listar todas las direcciones que pertenecen a la red. Para la iteración, se retornan todos los hosts, incluyendo hosts inutilizables (para hosts utilizables, se usa el método `hosts()`). Un ejemplo:

    >>> for addr in IPv4Network('192.0.2.0/28'):
    ...     addr
    ...
    IPv4Address('192.0.2.0')
    IPv4Address('192.0.2.1')
    IPv4Address('192.0.2.2')
    IPv4Address('192.0.2.3')
    IPv4Address('192.0.2.4')
    IPv4Address('192.0.2.5')
    IPv4Address('192.0.2.6')
    IPv4Address('192.0.2.7')
    IPv4Address('192.0.2.8')
    IPv4Address('192.0.2.9')
    IPv4Address('192.0.2.10')
    IPv4Address('192.0.2.11')
    IPv4Address('192.0.2.12')
    IPv4Address('192.0.2.13')
    IPv4Address('192.0.2.14')
    IPv4Address('192.0.2.15')

#### Redes como contenedores de direcciones

Los objetos de red pueden actuar como contenedores de direcciones. Algunos ejemplos:

    >>> IPv4Network('192.0.2.0/28')[0]
    IPv4Address('192.0.2.0')
    >>> IPv4Network('192.0.2.0/28')[15]
    IPv4Address('192.0.2.15')
    >>> IPv4Address('192.0.2.6') in IPv4Network('192.0.2.0/28')
    True
    >>> IPv4Address('192.0.3.6') in IPv4Network('192.0.2.0/28')
    False

## Objetos de interfaz

Los objetos de interfaz son hashable, por lo que se pueden utilizar como claves en diccionarios.

class `ipaddress.``IPv4Interface`(address)

  Construye una interfaz IPv4. El significado de address es el mismo que en el constructor de `IPv4Network`, excepto que las direcciones de host arbitrarias son siempre aceptadas.

  `IPv4Interface` es una subclase de `IPv4Address`, así que hereda todos los atributos de esa clase. Adicionalmente, los siguientes atributos están disponibles:

  `ip`

    La dirección (`IPv4Address`) sin información de red.

        >>> interface = IPv4Interface('192.0.2.5/24')
        >>> interface.ip
        IPv4Address('192.0.2.5')

  `network`

    La red (`IPv4Network`) a la que pertenece esta interfaz.

        >>> interface = IPv4Interface('192.0.2.5/24')
        >>> interface.network
        IPv4Network('192.0.2.0/24')

  `with_prefixlen`

    Una representación en cadena de caracteres de la interfaz con la máscara en notación de prefijo.

        >>> interface = IPv4Interface('192.0.2.5/24')
        >>> interface.with_prefixlen
        '192.0.2.5/24'

  `with_netmask`

    Una representación en cadena de caracteres de la interfaz con la red como una máscara de red.

        >>> interface = IPv4Interface('192.0.2.5/24')
        >>> interface.with_netmask
        '192.0.2.5/255.255.255.0'

  `with_hostmask`

    Una representación de la interfaz con la red como una máscara de host.

        >>> interface = IPv4Interface('192.0.2.5/24')
        >>> interface.with_hostmask
        '192.0.2.5/0.0.0.255'

class `ipaddress.``IPv6Interface`(address)

  Construye una interfaz IPv6. El significado de address es el mismo que en el constructor de `IPv6Network`, excepto que las direcciones de host arbitrarias son siempre aceptadas.

  `IPv6Interface` es una subclase de `IPv6Address`, así que hereda todos los atributos de esa clase. Adicionalmente, los siguientes atributos están disponibles:

  `ip`
  `network`
  `with_prefixlen`
  `with_netmask`
  `with_hostmask`

    Consulta en `IPv4Interface` la documentación de atributos correspondiente.

### Operadores

Los objetos de interfaz admiten algunos operadores. A menos que se indique lo contrario, los operadores solo se pueden aplicar entre objetos compatibles (es decir, IPv4 con IPv4, IPv6 con IPv6).

#### Operadores lógicos

Los objetos de interfaz pueden compararse con el conjunto usual de operadores lógicos.

Para la comparación de igualdad (`==` and `!=`), tanto la dirección IP como la red deben ser iguales para que los objetos sean iguales. Una interfaz no será igual a ningún objeto de dirección o de red.

Para el ordenamiento (`<`, `>`, etc.) las reglas son diferentes. Los objetos de interfaz y de dirección con la misma versión de IP se pueden comparar, y los objetos de dirección siempre se ordenarán antes que los objetos de interfaz. Dos objetos de interfaz se comparan primero por sus redes y, si son iguales, luego por sus direcciones IP.

## Otras funciones a nivel de módulo

El módulo también provee las siguientes funciones a nivel de módulo:

`ipaddress.``v4_int_to_packed`(address)

  Representa una dirección como 4 bytes empaquetados en orden de red (big-endian). address es una representación en entero de una dirección IPv4. Se genera un `ValueError` si el entero es negativo o demasiado grande para ser una dirección IPv4.

      >>> ipaddress.ip_address(3221225985)
      IPv4Address('192.0.2.1')
      >>> ipaddress.v4_int_to_packed(3221225985)
      b'\xc0\x00\x02\x01'

`ipaddress.``v6_int_to_packed`(address)

  Representa una dirección como 16 bytes empaquetados en orden de red (big-endian). address es una representación en entero de una dirección IPv6. Se genera un `ValueError` si el entero es negativo o demasiado grande para ser una dirección IPv6.

`ipaddress.``summarize_address_range`(first, last)

  Retorna un iterador del rango de red resumido dadas la primera y la última dirección IP. first es la primera `IPv4Address` o `IPv6Address` en el rango y last es la última `IPv4Address` o `IPv6Address` en el rango. Se genera un `TypeError` si first o last no son direcciones IP o no son de la misma versión. Se genera un `ValueError` si last no es mayor que first o si la versión de first no es 4 o 6.

      >>> [ipaddr for ipaddr in ipaddress.summarize_address_range(
      ...    ipaddress.IPv4Address('192.0.2.0'),
      ...    ipaddress.IPv4Address('192.0.2.130'))]
      [IPv4Network('192.0.2.0/25'), IPv4Network('192.0.2.128/31'), IPv4Network('192.0.2.130/32')]

`ipaddress.``collapse_addresses`(addresses)

  Retorna un iterador de los objetos colapsados `IPv4Network` o `IPv6Network`. addresses es un iterador de objetos `IPv4Network` o `IPv6Network`. Se genera un `TypeError` si addresses contiene objetos de versiones distintas.

      >>> [ipaddr for ipaddr in
      ... ipaddress.collapse_addresses([ipaddress.IPv4Network('192.0.2.0/25'),
      ... ipaddress.IPv4Network('192.0.2.128/25')])]
      [IPv4Network('192.0.2.0/24')]

`ipaddress.``get_mixed_type_key`(obj)

  Retorna una clave adecuada para ordenar entre redes y direcciones. Los objetos de dirección y red no son ordenables por defecto; son fundamentalmente diferentes, así que la expresión:

      IPv4Address('192.0.2.0') <= IPv4Network('192.0.2.0/24')

  no tiene sentido. Sin embargo, hay veces donde se desearía hacer que `ipaddress` las ordene de cualquier forma. Si se necesita hacer esto, se puede usar esta función como el argumento key de `sorted()`.

  obj es un objeto de red o de dirección.

## Excepciones personalizadas

Para soportar un reporte de errores más específico desde los constructores de clase, el módulo define las siguientes excepciones:

exception `ipaddress.``AddressValueError`(ValueError)

  Cualquier valor de error relacionado a la dirección.

exception `ipaddress.``NetmaskValueError`(ValueError)

  Cualquier valor de error relacionado a la máscara de red.