Multiple URL segment in Flask and other Python fra

Question

I'm building an application in both Bottle and Flask to see which I am more comfortable with as Django is too much 'batteries included'.

I have read through the routing documentation of both, which is very clear and understandable but I am struggling to find a way of dealing with an unknown, possibly unlimited number of URL segments. ie:

http://www.example.com/seg1/seg2/seg3/seg4/seg5.....

I was looking at using something like

@app.route(/< path:fullurl >)

using regex to remove unwanted characters and splitting the fullurl string into a list the same length as the number of segments, but this seems incredibly inefficient.

Most PHP frameworks seem to have a method of building an array of the segment variable names regardless of the number but neither Flask, Bottle or Django seem to have a similar option, I seem to need to specify an exact number of segments to capture variables. A couple of PHP cms's seem to collect the first 9 segments immediately as variables and anything any longer gets passed as a full path which is then broken down in the way I mentioned above.

Am I not understanding the way things work in URL routing? Is the string splitting method really inefficient or the best way to do it? Or, is there a way of collecting an unknown number of segments straight into variables in Flask?

I'm pretty new on Python frameworks so a five year olds explanation would help,

many thanks.

Answer 1

I'm fairly new to Flask myself, but from what I've worked out so far, I'm pretty sure that the idea is that you have lots of small route/view methods, rather than one massive great switching beast.

For example, if you have urls like this:

http://example.com/unit/57/
http://example.com/unit/57/page/23/
http://example.com/unit/57/page/23/edit

You would route it like this:

@app.route('/unit/<int:unit_number>/')
def display_unit(unit_number):
    ...

@app.route('/unit/<int:unit_number>/page/<int:page_number>/')
def display_page(unit_number, page_number):
    ...

@app.route('/unit/<int:unit_number>/page/<int:page_number>/edit')
def page_editor(unit_number, page_number):
    ...

Doing it this way helps to keep some kind of structure in your application and relies on the framework to route stuff, rather than grabbing the URL and doing all the routing yourself. You could then also make use of blueprints to deal with the different functions.

I'll admit though, I'm struggling to think of a situation where you would need a possibly unlimited number of sections in the URL?

Answer 2

it works：

@app.route("/login/<user>/<password>")
def login(user, password):
    app.logger.error('An error occurred')
    app.logger.error(password)
    return "user : %s password : %s" % (user, password)

then:

http://example.com:5000/login/jack/hi

output:

user : jack password : hi

Answer 3

Splitting the string doesn't introduce any inefficiency to your program. Performance-wise, it's a negligible addition to the URL processing done by the framework. It also fits in a single line of code.

@app.route('/<path:fullurl>')
def my_view(fullurl):
    params = fullurl.split('/')