CODEWITHSUNDEEP
pythondjangoparsingurl
niteshb
niteshb

Reputation: 2839

Retrieving parameters from a URL

Given a URL like the following, how can I parse the value of the query parameters? For example, in this case I want the value of some_key .

/some_path?some_key=some_value'

I am using Django in my environment; is there a method on the request object that could help me?

I tried using self.request.get('some_key') but it is not returning the value some_value as I had hoped.

Upvotes: 265

Views: 332953

Answers (21)

N K Shukla
N K Shukla

Reputation: 352

NOT using Django and tried on Python 3.9. It can also be retrieved using the below code snippet in the handler:

considering URL as-

http://localhost:8081/api/v1/users?query_key=abcdef12345

and handler method as:

@routes.get('/api/v1/users')
async def handler_users(request):
    query_key = request.url.query['query_key']

Upvotes: 0

user2665694
user2665694

Reputation:

The urlparse module provides everything you need:

urlparse.parse_qs()

Upvotes: 4

phaestos
phaestos

Reputation: 23

You can use only request.GET.get() method

urls.py:

    path('some_path', views.func),

views.py:

def func(request):
    some_key = request.GET.get('some_key', None)
    ...

Upvotes: 0

haccks
haccks

Reputation: 106102

Parsing it in raw python:

path = '/some_path?k1=v1&k2=v2&k3=v3'
_, query_string = path.split('?')
params  = dict(param.split('=') for param in query_string.split('&'))
print(params)

Output:

{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

Upvotes: 2

systempuntoout
systempuntoout

Reputation: 74134

This is not specific to Django, but for Python in general. For a Django specific answer, see this one from @jball037

Python 2:

import urlparse

url = 'https://www.example.com/some_path?some_key=some_value'
parsed = urlparse.urlparse(url)
captured_value = urlparse.parse_qs(parsed.query)['some_key'][0]

print captured_value

Python 3:

from urllib.parse import urlparse
from urllib.parse import parse_qs

url = 'https://www.example.com/some_path?some_key=some_value'
parsed_url = urlparse(url)
captured_value = parse_qs(parsed_url.query)['some_key'][0]

print(captured_value)

parse_qs returns a list. The [0] gets the first item of the list so the output of each script is some_value

Here's the 'parse_qs' documentation for Python 3

Upvotes: 457

curveball
curveball

Reputation: 4505

I didn't want to mess with additional libraries. Simple ways suggested here didn't work out either. Finally, not on the request object, but I could get a GET parameter w/o all that hassle via self.GET.get('XXX'):

...
def get_context_data(self, **kwargs):
    context = super(SomeView, self).get_context_data(**kwargs)
    context['XXX'] = self.GET.get('XXX')
...

Python 2.7.18, Django 1.11.20

Upvotes: 0

Husky
Husky

Reputation: 6206

Most answers here suggest using parse_qs to parse an URL string. This method always returns the values as a list (not directly as a string) because a parameter can appear multiple times, e.g.:

http://example.com/?foo=bar&foo=baz&bar=baz

Would return:

{'foo': ['bar', 'baz'], 'bar' : ['baz']}

This is a bit inconvenient because in most cases you're dealing with an URL that doesn't have the same parameter multiple times. This function returns the first value by default, and only returns a list if there's more than one element.

from urllib import parse

def parse_urlargs(url):
    query = parse.parse_qs(parse.urlparse(url).query)
    return {k:v[0] if v and len(v) == 1 else v for k,v in query.items()}

For example, http://example.com/?foo=bar&foo=baz&bar=baz would return:

{'foo': ['bar', 'baz'], 'bar': 'baz'}

Upvotes: 3

Oren_C
Oren_C

Reputation: 761

I see there isn't an answer for users of Tornado:

key = self.request.query_arguments.get("key", None)

This method must work inside an handler that is derived from: 

tornado.web.RequestHandler

None is the answer this method will return when the requested key can't be found. This saves you some exception handling.

Upvotes: 0

Vivek
Vivek

Reputation: 599

parameters = dict([part.split('=') for part in get_parsed_url[4].split('&')])

This one is simple. The variable parameters will contain a dictionary of all the parameters.

Upvotes: 0

Cris
Cris

Reputation: 2943

import urlparse
url = 'http://example.com/?q=abc&p=123'
par = urlparse.parse_qs(urlparse.urlparse(url).query)

print par['q'][0], par['p'][0]

Upvotes: 66

jball037
jball037

Reputation: 1800

I'm shocked this solution isn't on here already. Use: 

request.GET.get('variable_name')

This will "get" the variable from the "GET" dictionary, and return the 'variable_name' value if it exists, or a None object if it doesn't exist.

Upvotes: 91

Anatoly E
Anatoly E

Reputation: 1141

for Python > 3.4

from urllib import parse
url = 'http://foo.appspot.com/abc?def=ghi'
query_def=parse.parse_qs(parse.urlparse(url).query)['def'][0]

Upvotes: 74

Corvax
Corvax

Reputation: 810

There is a nice library w3lib.url

from w3lib.url import url_query_parameter
url = "/abc?def=ghi"
print url_query_parameter(url, 'def')
ghi

Upvotes: 2

Asym
Asym

Reputation: 1938

In pure Python:

def get_param_from_url(url, param_name):
    return [i.split("=")[-1] for i in url.split("?", 1)[-1].split("&") if i.startswith(param_name + "=")][0]

Upvotes: 8

Mayank Jaiswal
Mayank Jaiswal

Reputation: 13106

There is a new library called furl. I find this library to be most pythonic for doing url algebra. To install:

pip install furl

Code:

from furl import furl
f = furl("/abc?def='ghi'") 
print f.args['def']

Upvotes: 37

chachan
chachan

Reputation: 2452

There's not need to do any of that. Only with

self.request.get('variable_name')

Notice that I'm not specifying the method (GET, POST, etc). This is well documented and this is an example

The fact that you use Django templates doesn't mean the handler is processed by Django as well

Upvotes: 4

George
George

Reputation: 6104

import cgitb
cgitb.enable()

import cgi
print "Content-Type: text/plain;charset=utf-8"
print
form = cgi.FieldStorage()
i = int(form.getvalue('a'))+int(form.getvalue('b'))
print i

Upvotes: 3

iCanHasFay
iCanHasFay

Reputation: 670

I know this is a bit late but since I found myself on here today, I thought that this might be a useful answer for others.

import urlparse
url = 'http://example.com/?q=abc&p=123'
parsed = urlparse.urlparse(url)
params = urlparse.parse_qsl(parsed.query)
for x,y in params:
    print "Parameter = "+x,"Value = "+y

With parse_qsl(), "Data are returned as a list of name, value pairs."

Upvotes: 21

sciweb
sciweb

Reputation: 51

Btw, I was having issues using parse_qs() and getting empty value parameters and learned that you have to pass a second optional parameter 'keep_blank_values' to return a list of the parameters in a query string that contain no values. It defaults to false. Some crappy written APIs require parameters to be present even if they contain no values

for k,v in urlparse.parse_qs(p.query, True).items():
  print k

Upvotes: 0

inspectorG4dget
inspectorG4dget

Reputation: 114035

def getParams(url):
    params = url.split("?")[1]
    params = params.split('=')
    pairs = zip(params[0::2], params[1::2])
    answer = dict((k,v) for k,v in pairs)

Hope this helps

Upvotes: 6

Senthil Kumaran
Senthil Kumaran

Reputation: 56941

The url you are referring is a query type and I see that the request object supports a method called arguments to get the query arguments. You may also want try self.request.get('def') directly to get your value from the object..

Upvotes: 7

Related Questions