Python'da verilen URL'ye parametreler ekleyin

Bana bir URL verildiğini varsayalım.
Zaten GET parametrelerine sahip olabilir (örneğin http://example.com/search?q=question) veya olmayabilir (örneğin http://example.com/).

Ve şimdi buna benzer bazı parametreler eklemem gerekiyor {'lang':'en','tag':'python'}. İlk durumda sahip olacağım http://example.com/search?q=question&lang=en&tag=pythonve ikinci durumda - http://example.com/search?lang=en&tag=python.

Bunu yapmanın standart bir yolu var mı?

urllibVe urlparsemodülleri ile ilgili birkaç tuhaflık var . İşte çalışan bir örnek:

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, Sonucu urlparse(), salt okunur ve biz dönüştürmek gerekir listonun verileri değiştirmek için deneyebilirsiniz önce.

Neden

Bu sayfadaki tüm çözümlerden memnun kalmadım ( hadi, en sevdiğimiz kopyala-yapıştır şeyimiz nerede? ) Bu yüzden buradaki cevaplara dayanarak kendi çözümümü yazdım. Tam ve daha fazla Pythonic olmaya çalışır. Daha tüketici tarafı ( JS ) dostu olması için argümanlara dict ve bool değerleri için bir işleyici ekledim , ancak bunlar henüz isteğe bağlıdır, bunları bırakabilirsiniz.

Nasıl çalışır

Test 1: Yeni bağımsız değişkenler ekleme, Dizileri ve Bool değerlerini işleme:

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: Mevcut bağımsız değişkenleri yeniden yazmak, DICT değerlerini ele almak:

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'

Konuşma ucuz. Bana kodu göster.

Kendini kodlayın. Ayrıntılı olarak anlatmaya çalıştım:

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

Lütfen bazı sorunlar olabileceğini unutmayın, bir tane bulursanız lütfen bana bildirin ve bu şeyi daha iyi hale getirelim

Dizelerde rastgele veriler varsa (örneğin, ve işaretleri, eğik çizgiler, vb. Gibi karakterlerin kodlanması gerekir) URL kodlamasını kullanmak istersiniz.

Urllib.urlencode'a bakın:

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

Python3'te:

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

Ayrıca furl modülünü https://github.com/gruns/furl kullanabilirsiniz

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

Bunu savaşta test edilmiş istekler kitaplığına dış kaynak olarak verin .

Ben böyle yapacağım:

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)

İstekler lib kullanıyorsanız :

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

Evet: urllib kullan .

Gönderen örneklerde belgelerinde:

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

Bu yanıta dayanarak, basit durumlar için tek satırlık (Python 3 kodu):

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)

veya:

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

Bunu en iyi iki cevaptan daha zarif buluyorum:

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'

En iyi cevaplarda hoşlanmadığım en önemli şeyler (yine de iyidirler):

• Łukasz: queryURL bileşenlerinde bulunduğu dizini hatırlamak zorunda
• Sapphire64: güncellenmiş olanı oluşturmanın en ayrıntılı yolu ParseResult

Cevabımın kötü yanı, dictpaketten çıkarmayı kullanarak sihirli görünümlü birleştirme, ancak bunu, değişkenliğe karşı önyargım nedeniyle zaten var olan bir sözlüğü güncellemeye tercih ediyorum.

Łukasz sürümünü beğendim, ancak urllib ve urllparse işlevlerinin bu durumda kullanımı biraz garip olduğundan, bunun gibi bir şey yapmanın daha kolay olduğunu düşünüyorum:

params = urllib.urlencode(params)

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

urlparseMevcut URL'yi urllib.urlencode()birleşik sözlükte ayırmak için çeşitli işlevleri kullanın , ardındanurlparse.urlunparse() hepsini tekrar bir araya getirin.

Ya da sonucunu alıp urllib.urlencode()uygun şekilde URL'ye birleştirin.

Yine başka bir cevap:

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

İşte bunu nasıl uyguladım.

import urllib

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

Büyüleyici gibi çalıştı. Ancak, bunu uygulamanın daha temiz bir yolunu isterdim.

Yukarıdakileri uygulamanın başka bir yolu, onu bir yönteme koymaktır.

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

Python 2.5'te

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"