netwatch.py/netaddr-0.7.10/netaddr/tests/3.x/ip/tutorial.txt

=IP Address Tutorial=

Copyright (c) 2008-2012, David P. D. Moss. All rights reserved.

This unit test serves as both testing of the netaddr API and an executable tutorial courtesy of the doctest and unittest modules in the Python standard library.

Let's start with the standard module import.

{{{

>>> from netaddr import *
>>> import pprint

}}}

You can safely import everything from the netaddr namespace as care has been taken to only export the necessary classes, functions and constants. 

You can always hand pick them if you are unsure about possible name clashes.

We install the standard library module `pprint` to help format some output.


==Basic IP Address Operations==

This IP object represents a single address.

{{{

>>> ip = IPAddress('192.0.2.1')

>>> ip.version
4

}}}

Standard `repr()` access returns a Python statement that can reconstruct an equivalent IP address object from scratch if executed in the Python interpreter.

{{{

>>> repr(ip)
"IPAddress('192.0.2.1')"

>>> ip
IPAddress('192.0.2.1')

}}}

Access in the string context returns the IP object as a string value.

{{{

>>> str(ip)
'192.0.2.1'

>>> '%s' % ip
'192.0.2.1'

>>> ip.format()  # only really useful for IPv6 addresses.
'192.0.2.1'

}}}

==IP Address Numerical Representations==

You can view an IP address in various other formats.

{{{

>>> int(ip) == 3221225985
True

>>> hex(ip)
'0xc0000201'

>>> ip.bin
'0b11000000000000000000001000000001'

>>> ip.bits()
'11000000.00000000.00000010.00000001'

>>> ip.words == (192, 0, 2, 1)
True

}}}

==Representing IP Subnets==

IPNetwork objects are used to represent subnets that accept netmasks and CIDR prefixes.

{{{

>>> ip = IPNetwork('192.0.2.1')

>>> ip.ip
IPAddress('192.0.2.1')

>>> ip.network, ip.broadcast
(IPAddress('192.0.2.1'), IPAddress('192.0.2.1'))

>>> ip.netmask, ip.hostmask
(IPAddress('255.255.255.255'), IPAddress('0.0.0.0'))

>>> ip.size
1

}}}

In this case, the network and broadcast address are the same, akin to a host route.

{{{

>>> ip = IPNetwork('192.0.2.0/24')

>>> ip.ip
IPAddress('192.0.2.0')

>>> ip.network, ip.broadcast
(IPAddress('192.0.2.0'), IPAddress('192.0.2.255'))

>>> ip.netmask, ip.hostmask
(IPAddress('255.255.255.0'), IPAddress('0.0.0.255'))

>>> ip.size
256

}}}

And finally, this IPNetwork object represents an IP address that belongs to a given IP subnet.

{{{

>>> ip = IPNetwork('192.0.3.112/22')

>>> ip.ip
IPAddress('192.0.3.112')

>>> ip.network, ip.broadcast
(IPAddress('192.0.0.0'), IPAddress('192.0.3.255'))

>>> ip.netmask, ip.hostmask
(IPAddress('255.255.252.0'), IPAddress('0.0.3.255'))

>>> ip.size
1024

}}}

Internally, each IPNetwork object only stores 3 values :-

  * the IP address value as an unsigned integer
  * a reference to the IP protocol module for the IP version being represented
  * the network CIDR prefix bitmask
  
All the other values are calculated on-the-fly as they are accessed.

It is possible to adjust the IP address value and the CIDR prefix after object instantiation.

{{{

>>> ip = IPNetwork('0.0.0.0/0')

>>> ip
IPNetwork('0.0.0.0/0')

>>> ip.value = 3221225985

>>> ip
IPNetwork('192.0.2.1/0')

>>> ip.prefixlen
0

>>> ip.prefixlen = 23

>>> ip
IPNetwork('192.0.2.1/23')

}}}

There is also a property that lets you access the *true* CIDR address which removes all host bits from the network address based on the CIDR subnet prefix.

{{{

>>> ip.cidr
IPNetwork('192.0.2.0/23')

}}}

This is handy for specifying some networking configurations correctly.

If you want to access information about each of the various IP addresses that form the IP subnet, this is available by performing pass through calls to sub methods of each `IPAddress` object.

For example if you want to see a binary digit representation of each address you can do the following.

{{{

>>> ip.ip.bits()
'11000000.00000000.00000010.00000001'

>>> ip.network.bits()
'11000000.00000000.00000010.00000000'

>>> ip.netmask.bits()
'11111111.11111111.11111110.00000000'

>>> ip.broadcast.bits()
'11000000.00000000.00000011.11111111'

}}}

==IPv6 support==

Full support for IPv6 addressing is provided as well. To prove this, let's try a few examples.

{{{

>>> ip = IPAddress(0, 6)

>>> ip
IPAddress('::')

>>> ip = IPNetwork('fe80::dead:beef/64')

>>> str(ip), ip.prefixlen, ip.version
('fe80::dead:beef/64', 64, 6)

>>> int(ip.ip) == 338288524927261089654018896845083623151
True

>>> hex(ip.ip)
'0xfe8000000000000000000000deadbeef'

}}}

Bit-style output isn't as quite as friendly as hexadecimal for such a long numbers, but here the proof that it works!

{{{

>>> ip.ip.bits()
'1111111010000000:0000000000000000:0000000000000000:0000000000000000:0000000000000000:0000000000000000:1101111010101101:1011111011101111'

}}}

Here are some networking details for an IPv6 subnet.

{{{

>>> ip.network, ip.broadcast, ip.netmask, ip.hostmask
(IPAddress('fe80::'), IPAddress('fe80::ffff:ffff:ffff:ffff'), IPAddress('ffff:ffff:ffff:ffff::'), IPAddress('::ffff:ffff:ffff:ffff'))

}}}

==IPv4 / IPv6 Interoperability==

It is likely that with IPv6 becoming more prevalent, you'll want to be able to interoperate between IPv4 and IPv6 address seemlessly.

Here are a couple of methods that help achieve this.

===IPv4 to IPv6===

{{{

>>> IPAddress('192.0.2.15').ipv4()
IPAddress('192.0.2.15')

>>> IPAddress('192.0.2.15').ipv6()
IPAddress('::ffff:192.0.2.15')

>>> IPAddress('192.0.2.15').ipv6(ipv4_compatible=True)
IPAddress('::192.0.2.15')

>>> IPAddress('192.0.2.15').ipv6(True)
IPAddress('::192.0.2.15')

>>> ip = IPNetwork('192.0.2.1/23')

>>> ip.ipv4()
IPNetwork('192.0.2.1/23')

>>> ip.ipv6()
IPNetwork('::ffff:192.0.2.1/119')

>>> ip.ipv6(ipv4_compatible=True)
IPNetwork('::192.0.2.1/119')

}}}

===IPv6 to IPv4===

{{{

>>> IPNetwork('::ffff:192.0.2.1/119').ipv4()
IPNetwork('192.0.2.1/23')

>>> IPNetwork('::192.0.2.1/119').ipv4()
IPNetwork('192.0.2.1/23')

}}}

Note that the IP object returns IPv4 "mapped" addresses by default in preference to IPv4 "compatible" ones. This has been chosen purposefully as the latter form has been deprecated (see RFC 4291 for details).

==List Operations On IP Objects==

If you treat an IP network object as if it were a standard Python list object it will give you access to a list of individual IP address objects. This of course is illusory and they are not created until you access them.

{{{

>>> ip = IPNetwork('192.0.2.16/29')

}}}

Accessing an IP object using the list() context invokes the default generator which returns a list of all IP objects in the range specified by the IP object's subnet.

{{{

>>> ip_list = list(ip)

>>> len(ip_list)
8

>>> ip_list
[IPAddress('192.0.2.16'), IPAddress('192.0.2.17'), ..., IPAddress('192.0.2.22'), IPAddress('192.0.2.23')]

}}}

The length of that list is 8 individual IP addresses.

{{{

>>> len(ip)
8

}}}

You can use standard index access to IP addresses in the subnet.

{{{

>>> ip[0]
IPAddress('192.0.2.16')

>>> ip[1]
IPAddress('192.0.2.17')

>>> ip[-1]
IPAddress('192.0.2.23')

}}}

You can even uses extended slices on IP addresses in the subnet.

{{{

>>> ip[0:4]
<generator object ...>

}}}

The slice is actually a generator function. This is to save time and system resources. Some slices can obviously end up being extremely large for some subnets! 

Here is how you'd access all elements in a slice.

{{{

>>> list(ip[0:4])
[IPAddress('192.0.2.16'), IPAddress('192.0.2.17'), IPAddress('192.0.2.18'), IPAddress('192.0.2.19')]

}}}

Extended slicing is also supported.

{{{

>>> list(ip[0::2])
[IPAddress('192.0.2.16'), IPAddress('192.0.2.18'), IPAddress('192.0.2.20'), IPAddress('192.0.2.22')]

}}}

List reversal.

{{{

>>> list(ip[-1::-1])
[IPAddress('192.0.2.23'), IPAddress('192.0.2.22'), ..., IPAddress('192.0.2.17'), IPAddress('192.0.2.16')]

}}}

Use of generators ensures working with large IP subnets is efficient.

{{{

>>> for ip in IPNetwork('192.0.2.0/23'):
...    print('%s' % ip)
...
192.0.2.0
192.0.2.1
192.0.2.2
192.0.2.3
...
192.0.3.252
192.0.3.253
192.0.3.254
192.0.3.255

}}}

In IPv4 networks you only usually assign the addresses between the network and broadcast addresses to actual host interfaces on systems.

Here is the iterator provided for accessing these IP addresses :-

{{{

>>> for ip in IPNetwork('192.0.2.0/23').iter_hosts():
...     print('%s' % ip)
...
192.0.2.1
192.0.2.2
192.0.2.3
192.0.2.4
...
192.0.3.251
192.0.3.252
192.0.3.253
192.0.3.254

}}}

==Sorting Collection Of IP Objects==

It is fairly common and useful to be able to sort IP addresses correctly (in numerical order).

Here is how sorting works with individual addresses.

{{{

>>> import random

>>> ip_list = list(IPNetwork('192.0.2.128/28'))

>>> random.shuffle(ip_list)

>>> sorted(ip_list)
[IPAddress('192.0.2.128'), IPAddress('192.0.2.129'), ..., IPAddress('192.0.2.142'), IPAddress('192.0.2.143')]

}}}

You can just as easily sort IP subnets at the same time, including combinations of IPv4 and IPv6 addresses as well.

{{{

>>> ip_list = [
... IPAddress('192.0.2.130'),
... IPAddress('10.0.0.1'),
... IPNetwork('192.0.2.128/28'),
... IPNetwork('192.0.3.0/24'),
... IPNetwork('192.0.2.0/24'),
... IPNetwork('fe80::/64'),
... IPAddress('::'),
... IPNetwork('172.24/12')]

>>> random.shuffle(ip_list)

>>> ip_list.sort()

>>> pprint.pprint(ip_list)
[IPAddress('10.0.0.1'),
 IPNetwork('172.24.0.0/12'),
 IPNetwork('192.0.2.0/24'),
 IPNetwork('192.0.2.128/28'),
 IPAddress('192.0.2.130'),
 IPNetwork('192.0.3.0/24'),
 IPAddress('::'),
 IPNetwork('fe80::/64')]

}}}

Notice how IPv4 is ordered before IPv6 and overlapping subnets sort in order from largest subnet to smallest.

==Merging IP Addresses And Subnets==

Another useful operation is the ability to summarize groups of IP subnets and addresses, merging them together where possible to create the smallest possible list of CIDR subnets.

Here is how to do this using the `cidr_merge()` function.

First we create a list of IP objects that is a good mix of individual addresses and subnets, along with some string based IP address values for good measure. To make things more challenging some IPv6 addresses have been included as well.

{{{

>>> ip_list = [ip for ip in IPNetwork('fe80::/120')]

>>> ip_list.append(IPNetwork('192.0.2.0/24'))

>>> ip_list.extend([str(ip) for ip in IPNetwork('192.0.3.0/24')])

>>> ip_list.append(IPNetwork('192.0.4.0/25'))

>>> ip_list.append(IPNetwork('192.0.4.128/25'))

>>> len(ip_list)
515

>>> cidr_merge(ip_list)
[IPNetwork('192.0.2.0/23'), IPNetwork('192.0.4.0/24'), IPNetwork('fe80::/120')]

}}}

==Dealing With Arbitrary Lists Of IP Objects==

While CIDR subnets are a useful construct, sometimes it is necessarily (particularly with IPv4 which predates the CIDR specification) to be able to generate lists of IP addresses that have an arbitrary start and end address that do not fall on bit mask boundaries.

The iter_iprange() function allow you to do just this.

{{{

>>> ip_list = list(iter_iprange('192.0.2.1', '192.0.2.14'))

>>> len(ip_list)
14

>>> ip_list
[IPAddress('192.0.2.1'), IPAddress('192.0.2.2'), ..., IPAddress('192.0.2.13'), IPAddress('192.0.2.14')]

}}}

It is equally nice to know what the actual list of CIDR subnets is that would correctly cover this non-aligned range of addresses.

Here `cidr_merge()` comes to the rescue.

{{{

>>> cidr_merge(ip_list)
[IPNetwork('192.0.2.1/32'), IPNetwork('192.0.2.2/31'), IPNetwork('192.0.2.4/30'), IPNetwork('192.0.2.8/30'), IPNetwork('192.0.2.12/31'), IPNetwork('192.0.2.14/32')]

}}}

==IP Subnetting And Supernetting==

It is quite common to have a large CIDR subnet that you may want to split up into multiple smaller component blocks to better manage your networks.

{{{

>>> ip = IPNetwork('172.24.0.0/16')

>>> ip.subnet(23)
<generator object ...>

}}}

Again this method produces and iterator because of the possibility for a large number of return values.

{{{

>>> subnets = list(ip.subnet(23))

>>> len(subnets)
128

>>> subnets
[IPNetwork('172.24.0.0/23'), IPNetwork('172.24.2.0/23'), IPNetwork('172.24.4.0/23'), ..., IPNetwork('172.24.250.0/23'), IPNetwork('172.24.252.0/23'), IPNetwork('172.24.254.0/23')]

}}}

It is also possible to retrieve the list of supernets that a given IP address or subnet belongs to (with an optional limit).
 
{{{

>>> ip = IPNetwork('192.0.2.114')

>>> supernets = ip.supernet(22)

>>> pprint.pprint(supernets)
[IPNetwork('192.0.0.0/22'),
 IPNetwork('192.0.2.0/23'),
 IPNetwork('192.0.2.0/24'),
 IPNetwork('192.0.2.0/25'),
 IPNetwork('192.0.2.64/26'),
 IPNetwork('192.0.2.96/27'),
 IPNetwork('192.0.2.112/28'),
 IPNetwork('192.0.2.112/29'),
 IPNetwork('192.0.2.112/30'),
 IPNetwork('192.0.2.114/31')]

}}}

This method returns a list because the potential list of values is of a predictable size (no more than 31 CIDRs for an IPv4 address and 127 for IPv6).

==Dealing With Less Common IP Network Specifications==

Until the advent of the CIDR specification it was common to infer the netmask of an IPv4 address based on its first octet using an set of classful rules.

It is common to come across these in various RFCs and they are well supported by a number of software libraries. Rather than leave out this important (mainly historical) set of rules they are catered for using the cidr_abbrev_to_verbose() function.

Here is an example of these rules for the whole of the IPv4 address space.

{{{

>>> cidrs = [cidr_abbrev_to_verbose(octet) for octet in range(0, 256)]

>>> pprint.pprint(cidrs)
['0.0.0.0/8',
...
 '127.0.0.0/8',
 '128.0.0.0/16',
...
 '191.0.0.0/16',
 '192.0.0.0/24',
...
 '223.0.0.0/24',
 '224.0.0.0/4',
...
 '239.0.0.0/4',
 '240.0.0.0/32',
...
 '255.0.0.0/32']

>>> len(cidrs)
256

}}}

==IP Address Categories==

IP addresses fall several broad categories and not all are suitable for assignment as system interface addresses.

Unicast

{{{

>>> IPAddress('192.0.2.1').is_unicast()
True

>>> IPAddress('fe80::1').is_unicast()
True

}}}

Multicast

{{{

>>> IPAddress('239.192.0.1').is_multicast()
True

>>> IPAddress('ff00::1').is_multicast()
True

}}}

Private

{{{

>>> IPAddress('172.24.0.1').is_private()
True

>>> IPAddress('10.0.0.1').is_private()
True

>>> IPAddress('192.168.0.1').is_private()
True

}}}

Reserved

{{{

>>> IPAddress('253.0.0.1').is_reserved()
True

}}}

Public (Internet) addresses.

Note that not all of these may be allocated by the various regional Internet registrars.

{{{

>>> ip = IPAddress('62.125.24.5')

>>> ip.is_unicast() and not ip.is_private()
True

}}}

There are also other types of addresses that have specific functions e.g. masking

Netmasks

{{{

>>> IPAddress('255.255.254.0').is_netmask()
True

}}}

Hostmasks

{{{

>>> IPAddress('0.0.1.255').is_hostmask()
True

}}}

Loopback addresses

{{{

>>> IPAddress('127.0.0.1').is_loopback()
True

>>> IPAddress('::1').is_loopback()
True

}}}

==IP address comparisons==

IP objects can be compared with each other. As an IP object can represent both an individual IP address and an implicit network, it pays to get both sides of your comparison into the same terms before you compare them to avoid any odd results.

Here are some comparisons of individual IP address to get the ball rolling.

{{{

>>> IPAddress('192.0.2.1') == IPAddress('192.0.2.1')
True

>>> IPAddress('192.0.2.1') < IPAddress('192.0.2.2')
True

>>> IPAddress('192.0.2.2') > IPAddress('192.0.2.1')
True

>>> IPAddress('192.0.2.1') != IPAddress('192.0.2.1')
False

>>> IPAddress('192.0.2.1') >= IPAddress('192.0.2.1')
True

>>> IPAddress('192.0.2.2') >= IPAddress('192.0.2.1')
True

>>> IPAddress('192.0.2.1') <= IPAddress('192.0.2.1')
True

>>> IPAddress('192.0.2.1') <= IPAddress('192.0.2.2')
True

}}}

Now lets try something a little more interesting.

{{{

>>> IPNetwork('192.0.2.0/24') == IPNetwork('192.0.2.112/24')
True

}}}

Hmmmmmmmm... looks a bit odd doesn't it? That's because by default, IP objects compare their subnets (or lower and upper boundaries) rather than their individual IP address values.

The solution to this situation is very simple. Knowing this default behaviour, just be explicit about exactly which portion of each IP object you'd like to compare using pass-through properties.

{{{

>>> IPNetwork('192.0.2.0/24').ip == IPNetwork('192.0.2.112/24').ip
False

>>> IPNetwork('192.0.2.0/24').ip < IPNetwork('192.0.2.112/24').ip
True

That's more like it. You can also be explicit about comparing networks in this way if you so wish (although it is not strictly necessary).

>>> IPNetwork('192.0.2.0/24').cidr == IPNetwork('192.0.2.112/24').cidr
True

Armed with this information here are some examples of network comparisons.

>>> IPNetwork('192.0.2.0/24') == IPNetwork('192.0.3.0/24')
False

>>> IPNetwork('192.0.2.0/24') < IPNetwork('192.0.3.0/24')
True

>>> IPNetwork('192.0.2.0/24') < IPNetwork('192.0.3.0/24')
True

}}}

This will inevitably raise questions about comparing IPAddress (scalar) objects and IPNetwork (vector) objects with each other (or at least it should).

Here is how netaddr chooses to address this situation.

{{{

>>> IPAddress('192.0.2.0') == IPNetwork('192.0.2.0/32')
False

>>> IPAddress('192.0.2.0') != IPNetwork('192.0.2.0/32')
True

}}}

An IP network or subnet is different from an individual IP address and therefore cannot be (directly) compared.

If you want to compare them successfully, you must be explicit about which aspect of the IP network you wish to match against the IP address in question.

You can use the index of the first or last address if it is a /32 like so :-

{{{

>>> IPAddress('192.0.2.0') == IPNetwork('192.0.2.0/32')[0]
True

>>> IPAddress('192.0.2.0') == IPNetwork('192.0.2.0/32')[-1]
True

>>> IPAddress('192.0.2.0') != IPNetwork('192.0.2.0/32')[0]
False

}}}

You can also use the base address if this is what you wish to compare :-

{{{

>>> IPAddress('192.0.2.0') == IPNetwork('192.0.2.0/32').ip
True

>>> IPAddress('192.0.2.0') != IPNetwork('192.0.2.0/32').ip
False

}}}

While this may seem a bit pointless at first, netaddr strives to keep IP addresses and network separate from one another while still allowing reasonable interoperability.

==Interaction with DNS==

It is a common administrative task to Generating reverse IP lookups for DNS. This is particularly arduous for IPv6 addresses.

Here is how you do this using the IP object's `reverse_dns()` method.

{{{

>>> IPAddress('172.24.0.13').reverse_dns
'13.0.24.172.in-addr.arpa.'

>>> IPAddress('fe80::feeb:daed').reverse_dns
'd.e.a.d.b.e.e.f.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.e.f.ip6.arpa.'

}}}

Note that ip6.int is not used as this has been deprecated (see RFC 3152 for details).

==Non standard IP address range types==

As CIDR is a relative newcomer given the long history of IP version 4 you are quite likely to come across systems and documentation which make reference to IP address ranges in formats other than CIDR. Converting from these arbitrary range types to CIDR and back again isn't a particularly fun task. Fortunately, netaddr tries to make this job easy for both you and your end users with two purpose built classes.

===Arbitrary IP Address Ranges===

You can represent an arbitrary IP address range using a lower and upper bound address in the form of an IPRange object.

{{{

>>> r1 = IPRange('192.0.2.1', '192.0.2.15')

>>> r1
IPRange('192.0.2.1', '192.0.2.15')

}}}

You can iterate across and index these ranges just like and IPNetwork object.

Importantly, you can also convert it to it's CIDR equivalent.

{{{

>>> r1.cidrs()
[IPNetwork('192.0.2.1/32'), IPNetwork('192.0.2.2/31'), IPNetwork('192.0.2.4/30'), IPNetwork('192.0.2.8/29')]

}}}

Here is how individual IPRange and IPNetwork compare.

{{{

>>> IPRange('192.0.2.0', '192.0.2.255') != IPNetwork('192.0.2.0/24')
False

>>> IPRange('192.0.2.0', '192.0.2.255') == IPNetwork('192.0.2.0/24')
True

}}}

You may wish to compare an IP range against a list of IPAddress and IPNetwork
objects.

{{{

>>> r1 = IPRange('192.0.2.1', '192.0.2.15')

>>> addrs = list(r1)

>>> addrs 
[IPAddress('192.0.2.1'), IPAddress('192.0.2.2'), IPAddress('192.0.2.3'), IPAddress('192.0.2.4'), IPAddress('192.0.2.5'), IPAddress('192.0.2.6'), IPAddress('192.0.2.7'), IPAddress('192.0.2.8'), IPAddress('192.0.2.9'), IPAddress('192.0.2.10'), IPAddress('192.0.2.11'), IPAddress('192.0.2.12'), IPAddress('192.0.2.13'), IPAddress('192.0.2.14'), IPAddress('192.0.2.15')]

>>> r1 == addrs  
False

}}}

Oops! Not quite what we were looking for or expecting.

The way to do this is to get either side of the comparison operation into the same terms.

{{{

>>> list(r1) == addrs
True

}}}

That's more like it.

The same goes for IPNetwork objects.

{{{

>>> subnets = r1.cidrs()

>>> subnets
[IPNetwork('192.0.2.1/32'), IPNetwork('192.0.2.2/31'), IPNetwork('192.0.2.4/30'), IPNetwork('192.0.2.8/29')]

>>> r1 == subnets
False

>>> r1.cidrs() == subnets
True

}}}

The above works if the list you are comparing contains one type or the other, but what if you have a mixed list of IPAddress, IPNetwork and string addresses?

Time for some slightly more powerful operations. Let's make use of a new class for dealing with groups of IP addresses and subnets. The IPSet class.

{{{

>>> ips = [IPAddress('192.0.2.1'), '192.0.2.2/31', IPNetwork('192.0.2.4/31'), IPAddress('192.0.2.6'), IPAddress('192.0.2.7'), '192.0.2.8', '192.0.2.9', IPAddress('192.0.2.10'), IPAddress('192.0.2.11'), IPNetwork('192.0.2.12/30')]

>>> s1 = IPSet(r1.cidrs()) 

>>> s2 = IPSet(ips)

>>> s2
IPSet(['192.0.2.1/32', '192.0.2.2/31', '192.0.2.4/30', '192.0.2.8/29'])

>>> s1 == s2
True

}}}

Let's remove one of the element from one of the IPSet objects and see what happens.

{{{

>>> s2.pop()
IPNetwork('192.0.2.4/30')

>>> s1 == s2
False

}}}

This is perhaps a somewhat contrived example but it just shows you some of the capabilities on offer.

See the IPSet tutorial in the wiki for more details on that class.

===IP Globs===

netaddr also supports a user friendly form of specifying IP address ranges using a glob style syntax. Please note that at the current time this only supports IPv4.

{{{

>>> IPGlob('192.0.2.*') == IPNetwork('192.0.2.0/24')
True

IPGlob('192.0.2.*') != IPNetwork('192.0.2.0/24')
False

}}}

As IPGlob is a subclass of IPRange, all of the same operations apply.