Ho urlda parte dell'utente e devo rispondere con l'HTML recuperato.

Come posso verificare se l'URL non è corretto o no?

Per esempio :

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

Come possiamo raggiungere questo risultato ?

regex di convalida dell'URL di django ( origine ):

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

In realtà, penso che questo sia il modo migliore.

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

Se imposti verify_existssu True, verificherà effettivamente che l'URL esista, altrimenti controllerà solo se è formato correttamente.

modifica: ah sì, questa domanda è un duplicato di questa: come posso verificare se esiste un URL con i validatori di Django?

Usa il pacchetto validatori :

>>> 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
>>>

Installalo da PyPI con pip ( pip install validators).

Una versione True o False, basata sulla risposta @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))

dà:

True
False
False
False

Al giorno d'oggi, utilizzo quanto segue, sulla base della risposta di Padam:

$ python --version
Python 3.6.5

Ed è così che appare:

from urllib.parse import urlparse

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

Basta usare is_url("http://www.asdf.com") .

Spero che sia d'aiuto!

Nota - lepl non è più supportato, mi dispiace (puoi usarlo e penso che il codice seguente funzioni, ma non riceverà aggiornamenti).

rfc 3696 http://www.faqs.org/rfcs/rfc3696.html definisce come farlo (per URL http ed email). ho implementato i suoi consigli in Python usando lepl (una libreria parser). vedere http://acooke.org/lepl/rfc3696.html

usare:

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

Sono arrivato su questa pagina cercando di trovare un modo sano per convalidare le stringhe come URL "validi". Condivido qui la mia soluzione usando python3. Non sono necessarie librerie aggiuntive.

Vedi https://docs.python.org/2/library/urlparse.html se stai usando python2.

Vedi https://docs.python.org/3.0/library/urllib.parse.html se stai usando python3 come me.

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 (schema = '', netloc = '', percorso = 'dkakasdkjdjakdjadjfalskdjfalk', params = '', query = '', fragment = '')

ParseResult (schema = 'https', netloc = 'stackoverflow.com', percorso = '', params = '', query = '', fragment = '')

La stringa "dkakasdkjdjakdjadjfalskdjfalk" non ha schema o netloc.

" https://stackoverflow.com " è probabilmente un URL valido.

Ecco una funzione più 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])

MODIFICARE

Come sottolineato da @Kwame, il codice seguente convalida l'URL anche se .como .coecc non sono presenti.

sottolineato anche da @Blaise, URL come https://www.google sono un URL valido e devi eseguire un controllo DNS per verificare se si risolve o meno, separatamente.

Questo è semplice e funziona:

Quindi min_attrcontiene l'insieme di stringhe di base che deve essere presente per definire la validità di un URL, ovvero http://parte e google.comparte.

urlparse.schemenegozi http://e

urlparse.netloc memorizzare il nome di 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()restituisce true se tutte le variabili al suo interno restituiscono true. Quindi, se result.schemee result.netlocè presente, cioè ha un valore, l'URL è valido e quindi restituisce True.

Convalida l'URL con urllibe regex simile a Django

La regex di convalida dell'URL di Django era in realtà piuttosto buona, ma avevo bisogno di modificarla un po 'per il mio caso d'uso. Sentiti libero di adattarlo al tuo!

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

Spiegazione

• Il codice convalida solo schemee netlocparte di un determinato URL. (Per farlo correttamente, ho diviso l'URL con urllib.parse.urlparse()nelle due parti corrispondenti che vengono quindi abbinate ai termini regex corrispondenti.)

• La netlocparte si ferma prima della prima occorrenza di una barra /, quindi i portnumeri fanno ancora parte del netloc, ad esempio:

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

• Vengono convalidati anche gli indirizzi IPv4

Supporto IPv6

Se desideri che lo strumento di convalida URL funzioni anche con gli indirizzi IPv6, procedi come segue:

• Aggiungi is_valid_ipv6(ip)dalla risposta di Markus Jarderot , che ha un'ottima espressione regolare del validatore IPv6
• Aggiungi and not is_valid_ipv6(domain)all'ultimoif

Esempi

Ecco alcuni esempi di regex per la parte netloc(aka domain) in azione:

• IPv4 e alfanumerico: https://regex101.com/r/A326u1/5
• IPv6: https://regex101.com/r/lKIIgq/1 (con la regex dalla risposta di Markus Jarderot )

Tutte le soluzioni precedenti riconoscono una stringa come " http://www.google.com/path,www.yahoo.com/path " come valida. Questa soluzione funziona sempre come dovrebbe

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)