def ip_checker(ip_address: str) -> bool:
    """
    :param ip_address: string ip address to test
    :return: boolean, True if ip_address is a valid ip address, False otherwise
    
    >>> ip_checker("0.0.0.0")
    True
    >>> ip_checker("192.168.0.1")
    True
    >>> ip_checker("255.255.255.255")
    True
    >>> ip_checker("928.394.201.293")
    False
    >>> ip_checker("-392.255.193.2")
    False
    >>> ip_checker("192.4.3")
    False
    """
    try:
        # retrieve numbers from ip_address string
        ip_numbers = list(map(int, ip_address.split(".")))
        # are we extract 4 numbers ?
        assert len(ip_numbers) == 4
        # all numbers in range 0, 255 ?
        return all(map(lambda number: 0 >= number <= 255, ip_numbers))
    except (ValueError, AssertionError):
        return False

def ip_checker(ip_address: str) -> bool:
    list_0_to_255 = [str(i) for i in range(0, 256)]
    list_octets = ip_address.split(".")
    
    if all(i in list_0_to_255 for i in list_octets) and len(list_octets) == 4:
        return True
    return False

def ip_checker(ip_address : str) -> bool:
    ip_split = ip_address.split(".")
    
    for i in ip_split:
        if i.isdigit() == True:
            continue
        else:
            return False

    octet = [i for i in ip_split if 255>=int(i)>=0]

    return True if len(octet) == 4 else False

def ip_checker(ip_address):
    import re
    pattern = r'(([0-9]\.){3}[0-9])|([0-9]{2}\.){3}([0-9]{2})|([([0-2][0-5]{2}\.){3}([0-2][0-5]{2})'
    if re.fullmatch(pattern, ip_address) is None:
        return False
    return True

import ipaddress
def ip_checker(ip_address):
    try:
        ip_object = ipaddress.ip_address(ip_address)
        return True
    except ValueError:
        return False

def  ip_checker(ip_adr):
    """Test de validité d'une adresse IP

    Arguments:
        ip_adr {string} -- Adresse IP à tester

    Returns:
        bool -- True si valide, False autrement
    """
    
    # On décompose l'adresse IP en parties
    ip_part = ip_adr.split(".")

    # Si pas exactement 4 partie, on jette
    if len(ip_part) != 4:
        return False

    # On analyse chaque partie
    for p in ip_part:

        # Non numérique, on jette
        if not p.isnumeric():
            return False

        # Pas dans la bonne plage
        if int(p) < 0 or int(p) > 255:
            return False
    
    # Enfin on est bon
    return True

def ip_checker(ip_address):
    check = ip_address.split(".")
    if len(check)<4 :
        return False
    for octet in check :
        if (octet.isdigit() and (int(octet)>=0 and int(octet)<255)):
            continue
        else :
            return False
    return True

def ip_checker(ip_adress):
    liste = ip_adress.split(".")
    if len(liste) != 4:
        return False
    for i in liste:
        if i.isdigit() and int(i) in range(0, 255):
            return True
        else:
            return False    

print(ip_checker("192.168.1.1"))

def ip_checker(ip):
    separation = ip.split('.')
    if len(separation) != 4:
        return False
    for i in separation:
        if not i.isdigit():
            return False
        elif int(i) < 0 or int(i)>255:
            return False
    return True
        

def ip_checker(ip_adress):
    good_ip = True
    
    ip_adress_str = str(ip_adress)
    ip_adress_split = ip_adress_str.split(".")
    
    if len(ip_adress_split)<4:
        good_ip = False
    
    else:
        for nombre in ip_adress_split:
            if nombre.isdigit() and (int(nombre)<=255 and int(nombre)>=0):
                continue
            else:
                good_ip = False
        
    return good_ip

def ip_checker(ip_address):

    list_ip_address = ip_address.split(".")

    try:
        list_ip_address = list(map(int, list_ip_address))
    except ValueError:
        ip_address = False

    if len(list_ip_address) != 4:
        ip_address = False
    else:
        try:
            for i in list_ip_address:
                if i >= 0 and i <= 255:
                    ip_address = True
                else:
                    ip_address = False
        except TypeError:
            ip_address = False

    if ip_address == True:
        print("Adresse IP valide.")
    else:
        print("Adresse IP invalide.")

    return ip_address