Fügen Sie der angegebenen URL in Python Parameter hinzu

Angenommen, ich habe eine URL erhalten.
Es hat möglicherweise bereits GET-Parameter (z. B. http://example.com/search?q=question) oder nicht (z http://example.com/. B. ).

Und jetzt muss ich einige Parameter hinzufügen, wie {'lang':'en','tag':'python'}. Im ersten Fall werde ich haben http://example.com/search?q=question&lang=en&tag=pythonund im zweiten - http://example.com/search?lang=en&tag=python.

Gibt es eine Standardmethode, um dies zu tun?

Es gibt ein paar Macken mit den Modulen urllibund urlparse. Hier ist ein Arbeitsbeispiel:

try:
    import urlparse
    from urllib import urlencode
except: # For Python 3
    import urllib.parse as urlparse
    from urllib.parse import urlencode

url = "http://stackoverflow.com/search?q=question"
params = {'lang':'en','tag':'python'}

url_parts = list(urlparse.urlparse(url))
query = dict(urlparse.parse_qsl(url_parts[4]))
query.update(params)

url_parts[4] = urlencode(query)

print(urlparse.urlunparse(url_parts))

ParseResult, Das Ergebnis urlparse(), ist schreibgeschützt und wir müssen sie ein konvertieren , listbevor wir seine Daten können versuchen , zu ändern.

Warum

Ich war nicht mit allen Lösungen auf dieser Seite zufrieden ( komm schon, wo ist unser Lieblings-Copy-Paste-Ding? ), Also habe ich meine eigenen basierend auf den Antworten hier geschrieben. Es versucht, vollständiger und pythonischer zu sein. Ich habe einen Handler für dict- und bool- Werte in Argumenten hinzugefügt , um verbraucherseitiger ( JS ) zu sein, aber sie sind noch optional. Sie können sie löschen.

Wie es funktioniert

Test 1: Hinzufügen neuer Argumente, Umgang mit Arrays und Bool-Werten:

url = 'http://stackoverflow.com/test'
new_params = {'answers': False, 'data': ['some','values']}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test?data=some&data=values&answers=false'

Test 2: Umschreiben vorhandener Argumente, Behandeln von DICT-Werten:

url = 'http://stackoverflow.com/test/?question=false'
new_params = {'question': {'__X__':'__Y__'}}

add_url_params(url, new_params) == \
    'http://stackoverflow.com/test/?question=%7B%22__X__%22%3A+%22__Y__%22%7D'

Reden ist billig. Zeig mir den Code.

Code selbst. Ich habe versucht, es im Detail zu beschreiben:

from json import dumps

try:
    from urllib import urlencode, unquote
    from urlparse import urlparse, parse_qsl, ParseResult
except ImportError:
    # Python 3 fallback
    from urllib.parse import (
        urlencode, unquote, urlparse, parse_qsl, ParseResult
    )


def add_url_params(url, params):
    """ Add GET params to provided URL being aware of existing.

    :param url: string of target URL
    :param params: dict containing requested params to be added
    :return: string with updated URL

    >> url = 'http://stackoverflow.com/test?answers=true'
    >> new_params = {'answers': False, 'data': ['some','values']}
    >> add_url_params(url, new_params)
    'http://stackoverflow.com/test?data=some&data=values&answers=false'
    """
    # Unquoting URL first so we don't loose existing args
    url = unquote(url)
    # Extracting url info
    parsed_url = urlparse(url)
    # Extracting URL arguments from parsed URL
    get_args = parsed_url.query
    # Converting URL arguments to dict
    parsed_get_args = dict(parse_qsl(get_args))
    # Merging URL arguments dict with new params
    parsed_get_args.update(params)

    # Bool and Dict values should be converted to json-friendly values
    # you may throw this part away if you don't like it :)
    parsed_get_args.update(
        {k: dumps(v) for k, v in parsed_get_args.items()
         if isinstance(v, (bool, dict))}
    )

    # Converting URL argument to proper query string
    encoded_get_args = urlencode(parsed_get_args, doseq=True)
    # Creating new parsed result object based on provided with new
    # URL arguments. Same thing happens inside of urlparse.
    new_url = ParseResult(
        parsed_url.scheme, parsed_url.netloc, parsed_url.path,
        parsed_url.params, encoded_get_args, parsed_url.fragment
    ).geturl()

    return new_url

Bitte beachten Sie, dass es einige Probleme geben kann. Wenn Sie eines finden, lassen Sie es mich bitte wissen und wir werden diese Sache verbessern

Sie möchten die URL-Codierung verwenden, wenn die Zeichenfolgen beliebige Daten enthalten können (z. B. müssen Zeichen wie kaufmännisches Und, Schrägstriche usw. codiert werden).

Überprüfen Sie urllib.urlencode:

>>> import urllib
>>> urllib.urlencode({'lang':'en','tag':'python'})
'lang=en&tag=python'

In Python3:

from urllib import parse
parse.urlencode({'lang':'en','tag':'python'})

Sie können auch das Furl-Modul https://github.com/gruns/furl verwenden

>>> from furl import furl
>>> print furl('http://example.com/search?q=question').add({'lang':'en','tag':'python'}).url
http://example.com/search?q=question&lang=en&tag=python

Lagern Sie es in die Bibliothek für kampferprobte Anfragen aus .

So werde ich es machen:

from requests.models import PreparedRequest
url = 'http://example.com/search?q=question'
params = {'lang':'en','tag':'python'}
req = PreparedRequest()
req.prepare_url(url, params)
print(req.url)

Wenn Sie die Anfragen lib verwenden :

import requests
...
params = {'tag': 'python'}
requests.get(url, params=params)

Ja: benutze urllib .

Aus den Beispielen in der Dokumentation:

>>> import urllib
>>> params = urllib.urlencode({'spam': 1, 'eggs': 2, 'bacon': 0})
>>> f = urllib.urlopen("http://www.musi-cal.com/cgi-bin/query?%s" % params)
>>> print f.geturl() # Prints the final URL with parameters.
>>> print f.read() # Prints the contents

Basierend auf dieser Antwort Einzeiler für einfache Fälle (Python 3-Code):

from urllib.parse import urlparse, urlencode


url = "https://stackoverflow.com/search?q=question"
params = {'lang':'en','tag':'python'}

url += ('&' if urlparse(url).query else '?') + urlencode(params)

oder:

url += ('&', '?')[urlparse(url).query == ''] + urlencode(params)

Ich finde das eleganter als die beiden Top-Antworten:

from urllib.parse import urlencode, urlparse, parse_qs

def merge_url_query_params(url: str, additional_params: dict) -> str:
    url_components = urlparse(url)
    original_params = parse_qs(url_components.query)
    # Before Python 3.5 you could update original_params with 
    # additional_params, but here all the variables are immutable.
    merged_params = {**original_params, **additional_params}
    updated_query = urlencode(merged_params, doseq=True)
    # _replace() is how you can create a new NamedTuple with a changed field
    return url_components._replace(query=updated_query).geturl()

assert merge_url_query_params(
    'http://example.com/search?q=question',
    {'lang':'en','tag':'python'},
) == 'http://example.com/search?q=question&lang=en&tag=python'

Die wichtigsten Dinge, die ich in den Top-Antworten nicht mag (sie sind trotzdem gut):

• Łukasz: muss sich den Index merken, an dem sich der queryin den URL-Komponenten befindet
• Sapphire64: Die sehr ausführliche Art, das aktualisierte zu erstellen ParseResult

Was an meiner Antwort schlecht ist, ist die magisch aussehende dictZusammenführung beim Entpacken, aber ich ziehe es vor, ein bereits vorhandenes Wörterbuch zu aktualisieren, weil ich Vorurteile gegen Veränderlichkeit habe.

Ich mochte die Łukasz-Version, aber da die Verwendung der Funktionen urllib und urllparse in diesem Fall etwas umständlich ist, ist es meiner Meinung nach einfacher, so etwas zu tun:

params = urllib.urlencode(params)

if urlparse.urlparse(url)[4]:
    print url + '&' + params
else:
    print url + '?' + params

Verwenden Sie die verschiedenen urlparseFunktionen, um die vorhandene URL urllib.urlencode()im kombinierten Wörterbuch auseinander zu reißen urlparse.urlunparse()und alles wieder zusammenzusetzen.

Oder nehmen Sie einfach das Ergebnis von urllib.urlencode()und verknüpfen Sie es entsprechend mit der URL.

Noch eine Antwort:

def addGetParameters(url, newParams):
    (scheme, netloc, path, params, query, fragment) = urlparse.urlparse(url)
    queryList = urlparse.parse_qsl(query, keep_blank_values=True)
    for key in newParams:
        queryList.append((key, newParams[key]))
    return urlparse.urlunparse((scheme, netloc, path, params, urllib.urlencode(queryList), fragment))

Hier ist, wie ich es implementiert habe.

import urllib

params = urllib.urlencode({'lang':'en','tag':'python'})
url = ''
if request.GET:
   url = request.url + '&' + params
else:
   url = request.url + '?' + params    

Lief wie am Schnürchen. Ich hätte mir jedoch einen saubereren Weg gewünscht, um dies umzusetzen.

Eine andere Möglichkeit, das oben Gesagte zu implementieren, besteht darin, es in eine Methode zu integrieren.

import urllib

def add_url_param(request, **params):
   new_url = ''
   _params = dict(**params)
   _params = urllib.urlencode(_params)

   if _params:
      if request.GET:
         new_url = request.url + '&' + _params
      else:
         new_url = request.url + '?' + _params
   else:
      new_url = request.url

   return new_ur

In Python 2.5

import cgi
import urllib
import urlparse

def add_url_param(url, **params):
    n=3
    parts = list(urlparse.urlsplit(url))
    d = dict(cgi.parse_qsl(parts[n])) # use cgi.parse_qs for list values
    d.update(params)
    parts[n]=urllib.urlencode(d)
    return urlparse.urlunsplit(parts)

url = "http://stackoverflow.com/search?q=question"
add_url_param(url, lang='en') == "http://stackoverflow.com/search?q=question&lang=en"