Lo tengo urldel usuario y tengo que responder con el HTML obtenido.

¿Cómo puedo comprobar si la URL está mal formada o no?

Por ejemplo :

url='google'  // Malformed
url='google.com'  // Malformed
url='http://google.com'  // Valid
url='http://google'   // Malformed

¿Cómo podemos lograrlo?

regex de validación de URL de django ( fuente ):

import re
regex = re.compile(
        r'^(?:http|ftp)s?://' # http:// or https://
        r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' #domain...
        r'localhost|' #localhost...
        r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})' # ...or ip
        r'(?::\d+)?' # optional port
        r'(?:/?|[/?]\S+)$', re.IGNORECASE)

print(re.match(regex, "http://www.example.com") is not None) # True
print(re.match(regex, "example.com") is not None)            # False

De hecho, creo que esta es la mejor forma.

from django.core.validators import URLValidator
from django.core.exceptions import ValidationError

val = URLValidator(verify_exists=False)
try:
    val('http://www.google.com')
except ValidationError, e:
    print e

Si se establece verify_existsque True, en realidad va a comprobar que existe la URL, de lo contrario sólo comprobar si está correctamente formado.

editar: ah sí, esta pregunta es un duplicado de esto: ¿Cómo puedo verificar si existe una URL con los validadores de Django?

Utilice el paquete de validadores :

>>> import validators
>>> validators.url("http://google.com")
True
>>> validators.url("http://google")
ValidationFailure(func=url, args={'value': 'http://google', 'require_tld': True})
>>> if not validators.url("http://google"):
...     print "not valid"
... 
not valid
>>>

Instálelo desde PyPI con pip ( pip install validators).

Una versión verdadera o falsa, basada en la respuesta de @DMfll:

try:
    # python2
    from urlparse import urlparse
except:
    # python3
    from urllib.parse import urlparse

a = 'http://www.cwi.nl:80/%7Eguido/Python.html'
b = '/data/Python.html'
c = 532
d = u'dkakasdkjdjakdjadjfalskdjfalk'

def uri_validator(x):
    try:
        result = urlparse(x)
        return all([result.scheme, result.netloc, result.path])
    except:
        return False

print(uri_validator(a))
print(uri_validator(b))
print(uri_validator(c))
print(uri_validator(d))

Da:

True
False
False
False

Hoy en día, uso lo siguiente, basado en la respuesta de Padam:

$ python --version
Python 3.6.5

Y así es como se ve:

from urllib.parse import urlparse

def is_url(url):
  try:
    result = urlparse(url)
    return all([result.scheme, result.netloc])
  except ValueError:
    return False

Solo usa is_url("http://www.asdf.com").

¡Espero eso ayude!

nota : lepl ya no es compatible, lo siento (puede usarlo y creo que el código siguiente funciona, pero no recibirá actualizaciones).

rfc 3696 http://www.faqs.org/rfcs/rfc3696.html define cómo hacer esto (para http URL y correo electrónico). Implementé sus recomendaciones en Python usando lepl (una biblioteca de analizador). ver http://acooke.org/lepl/rfc3696.html

usar:

> easy_install lepl
...
> python
...
>>> from lepl.apps.rfc3696 import HttpUrl
>>> validator = HttpUrl()
>>> validator('google')
False
>>> validator('http://google')
False
>>> validator('http://google.com')
True

Aterricé en esta página tratando de encontrar una forma sensata de validar cadenas como URL "válidas". Comparto aquí mi solución usando python3. No se requieren bibliotecas adicionales.

Consulte https://docs.python.org/2/library/urlparse.html si está utilizando python2.

Consulte https://docs.python.org/3.0/library/urllib.parse.html si está usando python3 como yo.

import urllib
from pprint import pprint

invalid_url = 'dkakasdkjdjakdjadjfalskdjfalk'
valid_url = 'https://stackoverflow.com'
tokens = [urllib.parse.urlparse(url) for url in (invalid_url, valid_url)]

for token in tokens:
    pprint(token)

min_attributes = ('scheme', 'netloc')  # add attrs to your liking
for token in tokens:
    if not all([getattr(token, attr) for attr in min_attributes]):
        error = "'{url}' string has no scheme or netloc.".format(url=token.geturl())
        print(error)
    else:
        print("'{url}' is probably a valid url.".format(url=token.geturl()))

ParseResult (esquema = '', netloc = '', ruta = 'dkakasdkjdjakdjadjfalskdjfalk', params = '', consulta = '', fragmento = '')

ParseResult (esquema = 'https', netloc = 'stackoverflow.com', ruta = '', params = '', consulta = '', fragmento = '')

La cadena 'dkakasdkjdjakdjadjfalskdjfalk' no tiene esquema ni netloc.

' https://stackoverflow.com ' es probablemente una URL válida.

Aquí hay una función más concisa:

from urllib.parse import urlparse

min_attributes = ('scheme', 'netloc')


def is_valid(url, qualifying=min_attributes):
    tokens = urlparse(url)
    return all([getattr(tokens, qualifying_attr)
                for qualifying_attr in qualifying])

EDITAR

Como señaló @Kwame, el siguiente código valida la URL incluso si no están presentes .como .coetc.

También señaló @Blaise, URL como https://www.google es una URL válida y debe hacer una verificación de DNS para verificar si se resuelve o no, por separado.

Esto es simple y funciona:

Por tanto, min_attrcontiene el conjunto básico de cadenas que debe estar presente para definir la validez de una URL, es decir, http://parte y google.comparte.

urlparse.schemetiendas http://y

urlparse.netloc almacenar el nombre de dominio google.com

from urlparse import urlparse
def url_check(url):

    min_attr = ('scheme' , 'netloc')
    try:
        result = urlparse(url)
        if all([result.scheme, result.netloc]):
            return True
        else:
            return False
    except:
        return False

all()devuelve verdadero si todas las variables dentro de él devuelven verdadero. Entonces, si result.schemey result.netlocestá presente, es decir, tiene algún valor, entonces la URL es válida y, por lo tanto, regresa True.

Validar URL con urllibuna expresión regular similar a Django

La expresión regular de validación de URL de Django era bastante buena, pero necesitaba modificarla un poco para mi caso de uso. ¡No dudes en adaptarlo al tuyo!

Python 3.7

import re
import urllib

# Check https://regex101.com/r/A326u1/5 for reference
DOMAIN_FORMAT = re.compile(
    r"(?:^(\w{1,255}):(.{1,255})@|^)" # http basic authentication [optional]
    r"(?:(?:(?=\S{0,253}(?:$|:))" # check full domain length to be less than or equal to 253 (starting after http basic auth, stopping before port)
    r"((?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+" # check for at least one subdomain (maximum length per subdomain: 63 characters), dashes in between allowed
    r"(?:[a-z0-9]{1,63})))" # check for top level domain, no dashes allowed
    r"|localhost)" # accept also "localhost" only
    r"(:\d{1,5})?", # port [optional]
    re.IGNORECASE
)
SCHEME_FORMAT = re.compile(
    r"^(http|hxxp|ftp|fxp)s?$", # scheme: http(s) or ftp(s)
    re.IGNORECASE
)

def validate_url(url: str):
    url = url.strip()

    if not url:
        raise Exception("No URL specified")

    if len(url) > 2048:
        raise Exception("URL exceeds its maximum length of 2048 characters (given length={})".format(len(url)))

    result = urllib.parse.urlparse(url)
    scheme = result.scheme
    domain = result.netloc

    if not scheme:
        raise Exception("No URL scheme specified")

    if not re.fullmatch(SCHEME_FORMAT, scheme):
        raise Exception("URL scheme must either be http(s) or ftp(s) (given scheme={})".format(scheme))

    if not domain:
        raise Exception("No URL domain specified")

    if not re.fullmatch(DOMAIN_FORMAT, domain):
        raise Exception("URL domain malformed (domain={})".format(domain))

    return url

Explicación

• El código solo valida la parte schemey la netlocparte de una URL determinada. (Para hacer esto correctamente, divido la URL urllib.parse.urlparse()en las dos partes correspondientes que luego se combinan con los términos de expresiones regulares correspondientes).

• La netlocparte se detiene antes de la primera aparición de una barra /, por lo que los portnúmeros siguen siendo parte de netloc, por ejemplo:

  https://www.google.com:80/search?q=python
  ^^^^^   ^^^^^^^^^^^^^^^^^
    |             |      
    |             +-- netloc (aka "domain" in my code)
    +-- scheme

• Las direcciones IPv4 también se validan

Soporte IPv6

Si desea que el validador de URL también funcione con direcciones IPv6, haga lo siguiente:

• Agregue is_valid_ipv6(ip)de la respuesta de Markus Jarderot , que tiene una expresión regular de validación de IPv6 realmente buena
• Agregar and not is_valid_ipv6(domain)al últimoif

Ejemplos

Aquí hay algunos ejemplos de la expresión regular para la parte netloc(también conocida como domain) en acción:

• IPv4 y alfanumérico: https://regex101.com/r/A326u1/5
• IPv6: https://regex101.com/r/lKIIgq/1 (con la expresión regular de la respuesta de Markus Jarderot )

Todas las soluciones anteriores reconocen una cadena como " http://www.google.com/path,www.yahoo.com/path " como válida. Esta solución siempre funciona como debería

import re

# URL-link validation
ip_middle_octet = u"(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5]))"
ip_last_octet = u"(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))"

URL_PATTERN = re.compile(
                        u"^"
                        # protocol identifier
                        u"(?:(?:https?|ftp|rtsp|rtp|mmp)://)"
                        # user:pass authentication
                        u"(?:\S+(?::\S*)?@)?"
                        u"(?:"
                        u"(?P<private_ip>"
                        # IP address exclusion
                        # private & local networks
                        u"(?:localhost)|"
                        u"(?:(?:10|127)" + ip_middle_octet + u"{2}" + ip_last_octet + u")|"
                        u"(?:(?:169\.254|192\.168)" + ip_middle_octet + ip_last_octet + u")|"
                        u"(?:172\.(?:1[6-9]|2\d|3[0-1])" + ip_middle_octet + ip_last_octet + u"))"
                        u"|"
                        # IP address dotted notation octets
                        # excludes loopback network 0.0.0.0
                        # excludes reserved space >= 224.0.0.0
                        # excludes network & broadcast addresses
                        # (first & last IP address of each class)
                        u"(?P<public_ip>"
                        u"(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])"
                        u"" + ip_middle_octet + u"{2}"
                        u"" + ip_last_octet + u")"
                        u"|"
                        # host name
                        u"(?:(?:[a-z\u00a1-\uffff0-9_-]-?)*[a-z\u00a1-\uffff0-9_-]+)"
                        # domain name
                        u"(?:\.(?:[a-z\u00a1-\uffff0-9_-]-?)*[a-z\u00a1-\uffff0-9_-]+)*"
                        # TLD identifier
                        u"(?:\.(?:[a-z\u00a1-\uffff]{2,}))"
                        u")"
                        # port number
                        u"(?::\d{2,5})?"
                        # resource path
                        u"(?:/\S*)?"
                        # query string
                        u"(?:\?\S*)?"
                        u"$",
                        re.UNICODE | re.IGNORECASE
                       )
def url_validate(url):   
    """ URL string validation
    """                                                                                                                                                      
    return re.compile(URL_PATTERN).match(url)