Saya dapatkan urldari pengguna dan saya harus membalas dengan HTML yang diambil.

Bagaimana cara memeriksa URL yang salah atau tidak?

Sebagai contoh :

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

Bagaimana kita bisa mencapai hal ini ?

regex validasi url django ( sumber ):

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

Sebenarnya, menurut saya ini adalah cara terbaik.

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

Jika Anda menyetel verify_existske True, itu akan benar-benar memverifikasi bahwa URL itu ada, jika tidak maka hanya akan memeriksa apakah itu dibentuk dengan benar.

edit: ah ya, pertanyaan ini adalah duplikat dari ini: Bagaimana saya dapat memeriksa apakah sebuah URL ada dengan validator Django?

Gunakan paket validator :

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

Instal dari PyPI dengan pip ( pip install validators).

Versi Benar atau Salah, berdasarkan jawaban @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))

Memberikan:

True
False
False
False

Saat ini, saya menggunakan yang berikut ini, berdasarkan jawaban Padam:

$ python --version
Python 3.6.5

Dan seperti inilah tampilannya:

from urllib.parse import urlparse

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

Gunakan saja is_url("http://www.asdf.com").

Semoga membantu!

note - lepl tidak lagi didukung, maaf (Anda dipersilakan untuk menggunakannya, dan saya pikir kode di bawah ini berfungsi, tetapi tidak akan mendapatkan pembaruan).

rfc 3696 http://www.faqs.org/rfcs/rfc3696.html menjelaskan cara melakukannya (untuk http url dan email). saya mengimplementasikan rekomendasinya dalam python menggunakan lepl (pustaka parser). lihat http://acooke.org/lepl/rfc3696.html

menggunakan:

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

Saya membuka halaman ini mencoba mencari cara yang masuk akal untuk memvalidasi string sebagai url "valid". Saya bagikan di sini solusi saya menggunakan python3. Tidak diperlukan perpustakaan tambahan.

Lihat https://docs.python.org/2/library/urlparse.html jika Anda menggunakan python2.

Lihat https://docs.python.org/3.0/library/urllib.parse.html jika Anda menggunakan python3 seperti saya.

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

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

String 'dkakasdkjdjakdjadjfalskdjfalk' tidak memiliki skema atau netloc.

' https://stackoverflow.com ' mungkin adalah url yang valid.

Berikut ini fungsi yang lebih ringkas:

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

EDIT

Seperti yang ditunjukkan oleh @Kwame, kode di bawah ini memvalidasi url meskipun .comor .coetc tidak ada.

juga ditunjukkan oleh @Blaise, URL seperti https://www.google adalah URL yang valid dan Anda perlu melakukan pemeriksaan DNS untuk memeriksa apakah itu menyelesaikan atau tidak, secara terpisah.

Ini sederhana dan berhasil:

Jadi min_attrberisi kumpulan string dasar yang perlu ada untuk menentukan validitas URL, yaitu http://bagian dan google.combagian.

urlparse.schemetoko http://dan

urlparse.netloc simpan nama domain 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()mengembalikan nilai benar jika semua variabel di dalamnya mengembalikan nilai benar. Jadi jika result.schemedan result.netlocada yaitu memiliki beberapa nilai maka URL tersebut valid dan karenanya kembali True.

Validasi URL dengan urllibdan ekspresi reguler seperti Django

Regex validasi URL Django sebenarnya cukup bagus tetapi saya perlu mengubahnya sedikit untuk kasus penggunaan saya. Jangan ragu untuk menyesuaikannya dengan milik Anda!

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

Penjelasan

• Kode hanya memvalidasi schemedan netlocbagian dari URL tertentu. (Untuk melakukan ini dengan benar, saya membagi URL dengan urllib.parse.urlparse()di dua bagian sesuai yang kemudian dicocokkan dengan istilah regex yang sesuai.)

• Bagian netlocberhenti sebelum kemunculan pertama garis miring /, jadi portangka masih menjadi bagian dari netloc, misalnya:

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

• Alamat IPv4 juga divalidasi

Dukungan IPv6

Jika Anda ingin validator URL juga berfungsi dengan alamat IPv6, lakukan hal berikut:

• Tambahkan is_valid_ipv6(ip)dari jawaban Markus Jarderot , yang memiliki regex validator IPv6 yang sangat bagus
• Tambahkan and not is_valid_ipv6(domain)ke yang terakhirif

Contoh

Berikut beberapa contoh regex untuk bagian netloc(alias domain) yang sedang bekerja:

• IPv4 dan alfanumerik: https://regex101.com/r/A326u1/5
• IPv6: https://regex101.com/r/lKIIgq/1 (dengan regex dari jawaban Markus Jarderot )

Semua solusi di atas mengenali string seperti " http://www.google.com/path,www.yahoo.com/path " sebagai valid. Solusi ini selalu berfungsi sebagaimana mestinya

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)