In Flask, what is "request.args" and how is it used?

Question

As a Flask beginner, I can't understand how request.args is used. I read somewhere that it is used to return values of query string (correct me if I'm wrong) and how many parameters request.args.get() takes.

I know that when I have to store submitted form data, I can use fname = request.form.get("firstname"). Here, only one parameter is passed, whereas the code below takes two parameters.

@app.route("/")
def home():
    cnx = db_connect()
    cur = cnx.cursor()
    output = []

    page = request.args.get('page', 1)

    try:
        page = int(page)
        skip = (page-1)*4
    except:
        abort(404)
   
    stmt_select = "select * from posts limit %s, 4;"
    values=[skip]

    cur.execute(stmt_select,values)
    x=cur.fetchall()

    for row in reversed(x):
        data = {
           "uid":row[0],
           "pid":row[1],
           "subject":row[2],
           "post_content":row[3],
           "date":datetime.fromtimestamp(row[4]),
        }
        output.append(data)
    
    next = page + 1
    previous = page-1
    if previous<1:
    previous=1
    return render_template("home.html", persons=output, next=next, previous=previous)

Please explain why it takes two parameters, and then what its use is.

score 159 · Accepted Answer · edited Sep 29 '21 at 19:46

159

According to the flask.Request.args documents.

flask.Request.args
A MultiDict with the parsed contents of the query string. (The part in the URL after the question mark).

So the args.get() is method get() for MultiDict, whose prototype is as follows:

get(key, default=None, type=None)

In newer version of flask (v1.0.x and v1.1.x), flask.Request.args is an ImmutableMultiDict(an immutable MultiDict), so the prototype and specific method above are still valid.

edited Sep 29 '21 at 19:46

Neuron

5,141
5
38
59

answered Jan 08 '16 at 07:21

luoluo

5,353
3
30
41

1

Things might have changed since the answer was posted. The documentation says: `By default an ImmutableMultiDict is returned from this function.` – Ahmad Ferdous May 29 '19 at 16:06
To import: from flask import request – Justin Furuness Feb 01 '22 at 22:36

score 46 · Answer 2 · edited Sep 29 '21 at 19:50

As a newbie using Flask and Python myself, I think some of the other answers here take for granted that you have a good understanding of the fundamentals. In case you or other readers don't, I'll give more context

... request.args returns a "dictionary" object for you. The "dictionary" object is similar to other collection-type of objects in Python, in that it can store many elements in one single object. Therefore the answer to your question

And how many parameters request.args.get() takes.

It will take only one object, a "dictionary" type of object (as stated in the previous answers). This "dictionary" object, however, can have as many elements as needed... (dictionaries have paired elements called Key, Value).

Other collection-type of objects besides "dictionaries", would be "tuple", and "list"... you can run a google search on those and "data structures" in order to learn other Python fundamentals. This answer is based Python; I don't have an idea if the same applies to other programming languages.

score 3 · Answer 3 · edited Jan 08 '19 at 10:14

3

request.args is a MultiDict with the parsed contents of the query string. From the documentation of get method:

get(key, default=None, type=None)

Return the default value if the requested data doesn’t exist. If type is provided and is a callable it should convert the value, return it or raise a ValueError if that is not possible.

edited Jan 08 '19 at 10:14

sr9yar

4,850
5
53
59

answered Jan 08 '16 at 07:29

r-m-n

14,192
4
69
68

4

Your links are broken. – deterjan Jun 15 '18 at 10:53
Just need to change the version number in the url, like this http://werkzeug.pocoo.org/docs/0.14/datastructures/#werkzeug.datastructures.MultiDict.get – sr9yar Jan 08 '19 at 08:52

score 3 · Answer 4 · answered May 18 '17 at 10:46

3

It has some interesting behaviour in some cases that is good to be aware of:

from werkzeug.datastructures import MultiDict

d = MultiDict([("ex1", ""), ("ex2", None)])

d.get("ex1", "alternive")
# returns: ''

d.get("ex2", "alternative")
# returns no visible output of any kind
# It is returning literally None, so if you do:
d.get("ex2", "alternative") is None
# it returns: True

d.get("ex3", "alternative")
# returns: 'alternative'

answered May 18 '17 at 10:46

Juha Untinen

1,806
1
24
40

1

This seems like exactly the behavior that one would expect - what are the interesting cases/behaviors you meant? – Nathan Apr 13 '18 at 03:38
1

`MultiDict.get(key, default=None, type=None)` doesn't return the default value in the event that the stored value is "falsey". It looks for the key, and if it doesn't find the key in the `my_dict.keys()` list, then it returns the default value provided. If you want a default value in the case that the key is either missing or "falsey", then you'd want something like: `"alternative" if not d.get("ext1", False) else d.get("ext1")` – Ian Burnette Oct 11 '18 at 18:48
Wow, years back. My point, like blackfedora mentions above, was that I expected `d.get("ex1", "alternative")` and `d.get("ex2", "alternative")` both to return the alternative value, since their actual value is falsy. – Juha Untinen Mar 30 '20 at 10:21
use `d.get("ex1") or "alternative"` to get "alternative" if "ex1" not in d or is a falsy value. d.get("ex1", "alternative") means get "alternative" as default value if "ex1" not in d. – Haili Sun May 12 '21 at 12:05

In Flask, what is "request.args" and how is it used?

4 Answers4

Linked