Mam urlod użytkownika i muszę odpowiedzieć pobranym kodem HTML.

Jak mogę sprawdzić, czy adres URL jest nieprawidłowy, czy nie?

Na przykład :

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

Jak możemy to osiągnąć?

wyrażenie regularne sprawdzania poprawności adresu URL django ( źródło ):

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

Właściwie myślę, że to najlepszy sposób.

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

Jeśli ustawisz verify_existsna True, faktycznie zweryfikuje, czy adres URL istnieje, w przeciwnym razie po prostu sprawdzi, czy został poprawnie utworzony.

edit: ach tak, to pytanie jest powtórzeniem tego: Jak mogę sprawdzić, czy istnieje adres URL z walidatorami Django?

Skorzystaj z pakietu walidatorów :

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

Zainstaluj go z PyPI za pomocą pip ( pip install validators).

Wersja True or False, oparta na odpowiedzi @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))

Daje:

True
False
False
False

Obecnie używam następujących, w oparciu o odpowiedź Padama:

$ python --version
Python 3.6.5

A tak to wygląda:

from urllib.parse import urlparse

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

Po prostu użyj is_url("http://www.asdf.com") .

Mam nadzieję, że to pomoże!

Uwaga - lepl nie jest już obsługiwany, przepraszam (możesz go używać i myślę, że poniższy kod działa, ale nie otrzyma aktualizacji).

rfc 3696 http://www.faqs.org/rfcs/rfc3696.html definiuje, jak to zrobić (dla adresów URL http i e-maili). Zaimplementowałem jego zalecenia w Pythonie przy użyciu lepl (biblioteki parsera). zobacz http://acooke.org/lepl/rfc3696.html

używać:

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

Wylądowałem na tej stronie, próbując znaleźć rozsądny sposób weryfikacji ciągów znaków jako „prawidłowych” adresów URL. Udostępniam tutaj moje rozwiązanie za pomocą python3. Nie są wymagane żadne dodatkowe biblioteki.

Zobacz https://docs.python.org/2/library/urlparse.html jeśli używasz python2.

Zobacz https://docs.python.org/3.0/library/urllib.parse.html, jeśli używasz python3 tak jak ja.

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 (schemat = '', netloc = '', ścieżka = 'dkakasdkjdjakdjadjfalskdjfalk', params = '', zapytanie = '', fragment = '')

ParseResult (schemat = 'https', netloc = 'stackoverflow.com', path = '', params = '', query = '', fragment = '')

Ciąg „dkakasdkjdjakdjadjfalskdjfalk” nie ma schematu ani funkcji netloc.

„ https://stackoverflow.com ” to prawdopodobnie prawidłowy adres URL.

Oto bardziej zwięzła funkcja:

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

EDYTOWAĆ

Jak wskazał @Kwame, poniższy kod sprawdza poprawność adresu URL, nawet jeśli nie ma .comlub .coitp.

wskazany również przez @Blaise, adresy URL takie jak https://www.google to prawidłowy adres URL i musisz osobno sprawdzić DNS, aby sprawdzić, czy rozwiązuje się, czy nie.

To jest proste i działa:

min_attrZawiera więc podstawowy zestaw ciągów, które muszą być obecne, aby określić ważność adresu URL, tj. http://Część igoogle.com część.

urlparse.scheme sklepy http:// i

urlparse.netloc przechowywać nazwę domeny 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()zwraca prawdę, jeśli wszystkie zmienne wewnątrz niej zwracają prawdę. Więc jeśli result.schemei result.netlocjest obecne, tj. Ma jakąś wartość, to adres URL jest prawidłowy i dlatego zwraca True.

Sprawdź poprawność adresu URL za pomocą urllibi regex podobnego do Django

Wyrażenie regularne sprawdzania poprawności adresu URL w Django było w rzeczywistości całkiem dobre, ale musiałem go trochę poprawić w moim przypadku użycia. Zapraszam do dostosowania go do swojego!

Python 3.7.0

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

Wyjaśnienie

• Kod weryfikuje tylko schemei netlocczęść podanego adresu URL. (Aby zrobić to poprawnie, rozdzielam adres URL urllib.parse.urlparse()na dwie części, które są następnie dopasowywane do odpowiednich wyrażeń regularnych).

• netlocCzęść zatrzymuje się przed pierwszym pojawieniem się cięciem /, więc portliczba nadal częścią netloc, na przykład:

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

• Sprawdzane są również adresy IPv4

Obsługa IPv6

Jeśli chcesz, aby walidator adresów URL działał również z adresami IPv6, wykonaj następujące czynności:

• Dodaj is_valid_ipv6(ip)z odpowiedzią Markusa Jarderot użytkownika , który ma naprawdę dobrą IPv6 walidatora regex
• Dodaj and not is_valid_ipv6(domain)do ostatniegoif

Przykłady

Oto kilka przykładów wyrażenia regularnego dla netloc(aka domain) części w akcji:

• IPv4 i alfanumeryczne: https://regex101.com/r/A326u1/5
• IPv6: https://regex101.com/r/lKIIgq/1 (z wyrażeniem regularnym z odpowiedzi Markusa Jarderota )

Wszystkie powyższe rozwiązania uznają ciąg, taki jak „ http://www.google.com/path,www.yahoo.com/path ”, za prawidłowy. To rozwiązanie zawsze działa tak, jak powinno

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)