I have to map the network of my company. After testing several solutions, I decided to create my own tools.
First problem: List all possible addresses in the range used.
After some research, I discovered Brandon Sterne‘s cidr.py. To facilitate its integration into my project, I decided to convert it to use object-oriented programming and adapt to my needs.
Here is the result.

#!/usr/bin/env python
# -*- coding: utf-8 -*-

#| CIDR Block Converter.
#| Copyright (c) BackFromHell
#| Licensed under GPLv3.

#| The procedural version was make by Brandon Sterne
#| See the original copyright and license
#| Copyright (c) 2007 Brandon Sterne
#| Licensed under the MIT license.
#| http://brandon.sternefamily.net/files/mit-license.txt
#| CIDR Block Converter - 2007

#| Changelog
#| 0.0 Original version of Brandon Sterne.
#| 0.1 Go to object.
#| 0.2 Add getNetworkAddress to get the netword address from the CIDR Block.
#|     Add getBroadcastAddress to get the broadcast address from the CIDR 
#|     Block.
#|     Rename printCDR to All_IP.
#|     Add getNextIP to get the next IP from the CIDR Block.
#| 0.3 ALL_IP return now a table of IPs.
#| 0.4 Code cleaning.
#| 0.5 Add OptionParser as options for processing command line options
#|      and arguments 


import re
from optparse import OptionParser


#| CIDRConverter : Convert CIDR block to a list of IP's
# --------------------------------------------------------------------------
class CIDRConverter(object):
    """CIDRConverter list all the IP of a CIDR block"""
    CIDRBlock = None
    IPIndex = None
    NetworkAddress = None
    BroadcastAddress = None
    
    baseIP = None
    subnet = None
    
    #| The object constructor
    # ----------------------------------------------------------------------------------
    def __init__(self, CIDRBlock = None):
	"""The object constructor"""
	if CIDRBlock is not None:
	    self.setCIDRBlock(CIDRBlock)
	    
    #| Init the CIDR Block and other informations
    # --------------------------------------------------------------------------------------------
    def setCIDRBlock(self, CIDRBlock):
	"""Init the CIDR Block and other informations"""
	if not self.validateCIDRBlock(CIDRBlock):
	    return False
	else:
	    self.CIDRBlock = CIDRBlock
	    parts = self.CIDRBlock.split("/")
            self.baseIP = self.IP2bin(parts[0])
    	    self.subnet = int(parts[1])
	    # Python string-slicing weirdness:
	    # "myString"[:-1] -> "myStrin" but "myString"[:0] -> ""
	    # if a subnet of 32 was specified simply print the single IP
	    if self.subnet == 32:
    		self.NetworkAddress = self.bin2IP(self.baseIP)
    		self.BroadcastAddress = self.NetworkAddress
	    # for any other size subnet, print a list of IP addresses by 
	    # concatenating the prefix with each of the suffixes 
	    # in the subnet
	    else:
    		IPPrefix = self.baseIP[:-(32-self.subnet)]
    		self.NetworkAddress = self.bin2IP(IPPrefix+self.dec2bin(0, 
    		    		               (32-self.subnet)))
        	self.BroadcastAddress = self.bin2IP(IPPrefix+self.dec2bin(
    		    		               (2**(32-self.subnet))-1, (32
    		    		               -self.subnet)))
	    return True
	    
    #| Get the netword address from the CIDR Block
    # ----------------------------------------------------------------------------------
    def getNetworkAddress(self):
	"""Get the netword address from the CIDR Block"""
	return self.NetworkAddress
	
    #| Get the broadcast address from the CIDR Block
    # -----------------------------------------------------------------------------------
    def getBroadcastAddress(self):
	"""Get the broadcast address from the CIDR Block"""
	return self.BroadcastAddress
	
    #| Return the list of IP addresses based on the CIDR block specified
    # ----------------------------------------------------------------------------------
    def All_IP(self):
	"""Return the list of IP addresses based on the CIDR block\ 
	specified"""
	IPs=[]
	IP = self.getNextIP()
	while (IP is not None):
	  IPs.append(IP)
	  IP = self.getNextIP()
	return IPs
        
    #| Get the next IP in the CIDR Block
    # ----------------------------------------------------------------------------------
    def getNextIP(self):
	"""Get the next IP in the CIDR Block"""
	# Python string-slicing weirdness:
	# "myString"[:-1] -> "myStrin" but "myString"[:0] -> ""
	# if a subnet of 32 was specified simply print the single IP
	if self.subnet == 32:
	    if self.IPIndex is None:
    		return self.bin2IP(self.baseIP)
    		self.IPIndex = 0
    	    else:
    		return None
	# for any other size subnet, print a list of IP addresses by 
	# concatenating the prefix with each of the suffixes in the subnet
	else:
	    if self.IPIndex is None:
		self.IPIndex = 0
	    else:
		self.IPIndex += 1
    	    IPPrefix = self.baseIP[:-(32-self.subnet)]
    	    if (self.IPIndex < (2**(32-self.subnet))):
    	        return self.bin2IP(IPPrefix+self.dec2bin(self.IPIndex, (32-
    	            	        self.subnet)))
    	    else:
    		return None
    		
    #| Input validation routine for the CIDR block specified
    # ----------------------------------------------------------------------------------
    def validateCIDRBlock(self,CIDRBlock):
	"""Input validation routine for the CIDR block specified"""
	# appropriate format for CIDR block ($prefix/$subnet)
	CIDRBlockPattern =\
	 re.compile("^([0-9]{1,3}\.){0,3}[0-9]{1,3}(/[0-9]{1,2}){1}$")
	if not CIDRBlockPattern.match(CIDRBlock):
    	    print "Error: Invalid CIDR format!"
    	    return False
	# extract prefix and subnet size
	prefix, subnet = CIDRBlock.split("/")
	# each Quad has an appropriate value (1-255)
	Quads = prefix.split(".")
        for Quad in Quads:
	    if (int(Quad) < 0) or (int(Quad) > 255):
    	        print "Error: Quad "+str(Quad)+" wrong size."
        	return False
        # subnet is an appropriate value (1-32)
	if (int(subnet) < 1) or (int(subnet) > 32):
    	    print "Error: subnet "+str(subnet)+" wrong size."
    	    return False
	# passed all checks -> return True
	return True

    #| Convert an IP address from its dotted-Quad format to its
    # ----------------------------------------------------------------------------------
    def IP2bin(self,IP):
	"""Convert an IP address from its dotted-Quad format to its \
	(32 binary digit representation)"""
	bin = ""
        inQuads = IP.split(".")
	outQuads = 4
        for Quad in inQuads:
	    if Quad != "":
    	        bin += self.dec2bin(int(Quad),8)
        	outQuads -= 1
        while outQuads > 0:
	    bin += "00000000"
    	    outQuads -= 1
	return bin

    #| Convert a decimal number to binary representation
    # ----------------------------------------------------------------------------------
    def dec2bin(self,dec,binlen=None):
	"""Convert a decimal number to binary representation. If bin is\
	specified, left-pad the binary number with 0s to that length"""
	bin = ""
        while dec>0:
	    if dec&1:
    	        bin = "1"+bin
    	    else:
        	bin = "0"+bin
    	    dec >>= 1
	if binlen is not None:
    	    while len(bin)<binlen:
        	bin = "0"+bin
	if bin == "": bin = "0"
	return bin

    #| Convert a binary string into an IP address
    # ----------------------------------------------------------------------------------
    def bin2IP(self,bin):
	"""Convert a binary string into an IP address"""
	IP = ""
        for i in range(0,len(bin),8):
	    IP += str(int(bin[i:i+8],2))+"."
        return IP[:-1]


if __name__ == "__main__":
    Parser = OptionParser(
        usage="usage: %prog [options] <prefix>/<subnet>\ 
                \ne.g. cidr.py 10.1.1.1/28";,
        version="%prog 0.5")
    options, arguments = Parser.parse_args()
    if len(arguments) != 1:
      Parser.error("incorrect number of arguments")
    print "%s %s" %(options, arguments)
    # get the CIDR block from the command line args
    cidrBlock = arguments[0]
    CIDR=CIDRConverter()
    if not CIDR.setCIDRBlock(cidrBlock):
	Parser.error("incorrect CIDR format")
    else:
        for IP in CIDR.All_IP():
	    print "> %s" %(IP)
	print "The network   : %s" %(CIDR.getNetworkAddress())
	print "The broadcast : %s" %(CIDR.getBroadcastAddress())