Agregar parámetros a la URL dada en Python

Supongamos que me dieron una URL.
Puede que ya tenga parámetros GET (p http://example.com/search?q=question. Ej. ) O puede que no (p http://example.com/. Ej .).

Y ahora necesito agregarle algunos parámetros {'lang':'en','tag':'python'}. En el primer caso voy a tener http://example.com/search?q=question&lang=en&tag=pythony en el segundo - http://example.com/search?lang=en&tag=python.

¿Hay alguna forma estándar de hacer esto?

Hay un par de peculiaridades con los módulos urlliby urlparse. Aquí hay un ejemplo de trabajo:

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, el resultado de urlparse(), es de solo lectura y necesitamos convertirlo a a listantes de que podamos intentar modificar sus datos.

Por qué

No estoy satisfecho con todas las soluciones en esta página ( vamos, ¿dónde está nuestro elemento favorito de copiar y pegar? ), Así que escribí el mío basado en las respuestas aquí. Intenta ser completo y más pitónico. He agregado un controlador para los valores dict y bool en los argumentos para que sean más amigables con el lado del consumidor ( JS ), pero aún son opcionales, puede descartarlos.

Cómo funciona

Prueba 1: Agregar nuevos argumentos, manejar matrices y valores Bool:

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'

Prueba 2: reescribiendo argumentos existentes, manejando valores DICT:

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'

Hablar es barato. Muéstrame el código.

Código en sí mismo. He tratado de describirlo en detalle:

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

Tenga en cuenta que puede haber algunos problemas, si encuentra uno, avíseme y lo mejoraremos

Desea utilizar la codificación de URL si las cadenas pueden tener datos arbitrarios (por ejemplo, se necesitarán codificar caracteres como símbolos de unión, barras inclinadas, etc.).

Echa un vistazo a urllib.urlencode:

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

En python3:

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

También puede usar el módulo furl https://github.com/gruns/furl

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

Subcontratarlo a la biblioteca de solicitudes de prueba de batalla .

Así es como lo haré:

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)

Si está utilizando las solicitudes lib :

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

Sí: usa urllib .

De los ejemplos en la documentación:

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

Basado en esta respuesta, una línea para casos simples (código Python 3):

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)

o:

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

Esto me parece más elegante que las dos respuestas principales:

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'

Las cosas más importantes que no me gustan en las respuestas principales (sin embargo, son buenas):

• Łukasz: tener que recordar el índice en el que query está en los componentes de la URL
• Sapphire64: la forma muy detallada de crear la actualización ParseResult

Lo malo de mi respuesta es la dictfusión mágicamente usando el desempaquetado, pero prefiero eso a actualizar un diccionario ya existente debido a mi prejuicio contra la mutabilidad.

Me gustó la versión Łukasz, pero dado que las funciones urllib y urllparse son algo incómodas de usar en este caso, creo que es más sencillo hacer algo como esto:

params = urllib.urlencode(params)

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

Use las diversas urlparsefunciones para separar la URL existente, urllib.urlencode()en el diccionario combinado, y luego urlparse.urlunparse()volver a armar todo.

O simplemente tome el resultado urllib.urlencode()y concatenelo a la URL de manera apropiada.

Otra respuesta más:

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

Así es como lo implementé.

import urllib

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

Trabajado como un encanto. Sin embargo, me hubiera gustado una forma más limpia de implementar esto.

Otra forma de implementar lo anterior es ponerlo en un método.

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

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