Args:
    ip_address (str): Adresse IPv4 au format '192.168.1.1'
    
Returns:
    int: Représentation entière de l'adresse IPv4
"""
octets = ip_address.split('.')

# Vérification de la validité de l'adresse IP
if len(octets) != 4:
    raise ValueError("Format d'adresse IPv4 invalide")

# Conversion des octets en entiers et vérification des plages
octets_int = []
for octet in octets:
    o = int(octet)
    if o < 0 or o > 255:
        raise ValueError(f"Valeur d'octet invalide: {o}")
    octets_int.append(o)

# Calcul de l'entier final
return (octets_int[0] << 24) | (octets_int[1] << 16) | (octets_int[2] << 8) | octets_int[3]

</SyntaxHighlighter>

### Convertir un entier en adresse IPv4

<SyntaxHighlighter language="python">
```python
def int_to_ip(ip_int):
    """
    Convertit un entier 32 bits en adresse IPv4.
    
    Args:
        ip_int (int): Entier 32 bits représentant une adresse IPv4
        
    Returns:
        str: Adresse IPv4 au format '192.168.1.1'
    """
    # Vérification de la plage valide pour une adresse IPv4
    if ip_int < 0 or ip_int > 4294967295:  # 2^32 - 1
        raise ValueError("L'entier doit être compris entre 0 et 2^32 - 1")
    
    # Extraction des octets
    octet1 = (ip_int >> 24) & 255
    octet2 = (ip_int >> 16) & 255
    octet3 = (ip_int >> 8) & 255
    octet4 = ip_int & 255
    
    # Construction de l'adresse IP
    return f"{octet1}.{octet2}.{octet3}.{octet4}"

Conversion entier vers IP

print(int_to_ip(3232235777)) # Output: 192.168.1.1 print(int_to_ip(2130706433)) # Output: 127.0.0.1 print(int_to_ip(167772161)) # Output: 10.0.0.1

</SyntaxHighlighter>

## Utilisation de la bibliothèque standard

Python offre également une solution via la bibliothèque standard `socket` pour effectuer ces conversions:

<SyntaxHighlighter language="python">
```python
import socket
import struct

# Conversion IP vers entier
def ip_to_int_socket(ip_address):
    return struct.unpack('!I', socket.inet_aton(ip_address))[0]

# Conversion entier vers IP
def int_to_ip_socket(ip_int):
    return socket.inet_ntoa(struct.pack('!I', ip_int))

# Exemples
print(ip_to_int_socket("192.168.1.1"))  # Output: 3232235777
print(int_to_ip_socket(3232235777))     # Output: 192.168.1.1

Args:
    ip (str): Adresse IP à vérifier
    subnet (str): Adresse du sous-réseau
    mask (int): Masque de sous-réseau en notation CIDR (ex: 24 pour /24)

Returns:
    bool: True si l'IP appartient au sous-réseau, False sinon
"""
ip_int = ip_to_int(ip)
subnet_int = ip_to_int(subnet)

# Création du masque binaire
cidr_mask = (0xFFFFFFFF << (32 - mask)) & 0xFFFFFFFF

# Comparaison des réseaux
return (ip_int & cidr_mask) == (subnet_int & cidr_mask)

Exemple

print(is_in_subnet(“192.168.1.5”, “192.168.1.0”, 24)) # Output: True print(is_in_subnet(“192.168.2.1”, “192.168.1.0”, 24)) # Output: False

</SyntaxHighlighter>

### 2. Itération sur un bloc d'adresses IP

<SyntaxHighlighter language="python">
```python
def ip_range(start_ip, end_ip):
    """
    Génère toutes les adresses IP dans une plage donnée.
    
    Args:
        start_ip (str): Adresse IP de début
        end_ip (str): Adresse IP de fin
    
    Yields:
        str: Adresses IP de la plage
    """
    start_int = ip_to_int(start_ip)
    end_int = ip_to_int(end_ip)
    
    if start_int > end_int:
        raise ValueError("L'adresse IP de début doit être inférieure à l'adresse IP de fin")
    
    for ip_int in range(start_int, end_int + 1):
        yield int_to_ip(ip_int)

# Exemple
for ip in ip_range("192.168.1.1", "192.168.1.5"):
    print(ip)
# Output:
# 192.168.1.1
# 192.168.1.2
# 192.168.1.3
# 192.168.1.4
# 192.168.1.5

def int_to_ip_fast(ip_int): return f”{(ip_int >> 24) & 255}.{(ip_int >> 16) & 255}.{(ip_int >> 8) & 255}.{ip_int & 255}”

</SyntaxHighlighter>

Ces versions sacrifient la validation au profit de la performance, elles sont donc à utiliser uniquement dans des contextes où les entrées sont déjà validées.

## Conclusion

La conversion entre adresses IPv4 et entiers 32 bits est une opération fondamentale dans de nombreux domaines liés aux réseaux informatiques. Python offre plusieurs approches pour réaliser ces conversions, de l'implémentation manuelle à l'utilisation de la bibliothèque standard.

Ces fonctions peuvent être intégrées dans divers outils réseau comme:
- Des scanners de réseau
- Des outils d'analyse de logs
- Des systèmes de détection d'intrusion
- Des applications de surveillance réseau

En maîtrisant ces conversions, vous disposez d'une compétence essentielle pour le développement d'applications réseau en Python.

<EmailSubscribe 
  title="Recevez plus d'astuces Python"
  description="Abonnez-vous pour recevoir régulièrement des tutoriels et astuces sur Python et la programmation réseau."
  buttonText="Je m'abonne"
/>