Django (web framework): How can I implement a urlpattern that passes a list of strings to the view?

Question

Alexander Todorov · Answer

If you want to catch any URL that matches 3 levels then:

url(r'^(?P%3CstringA%3E.*)/(?P%3CstringB%3E.*)/(?P%3CstringN%3E.*)/$', 'views.myview'),

def myview(request, stringA, stringB, stringN):
    return render(request, 'template.html')

where the actual values are in the view parameters. This will match both: 
http://example.com/one/two/three/
http://example.com/a/b/c/

OTOH if you want to match verbatim just do:

url(r'^stringA/stringB/stringN/$', 'views.myview'),

def myview(request):
    return render(request, 'template.html')

If you need to match another string sequence just define a new URL pattern in urls.py and point it to the same (or another) view function.

Maksudur Rahman Maateen · Answer

There are different ways to pass data between views. Actually this is not much different that the problem of passing data between 2 different scripts & of course some concepts of inter-process communication come in as well. Some things that come to mind are -

1. GET request - First request hits view1-%3Esend data to browser -%3E browser redirects to view2
2. POST request - (as you suggested) Same flow as above but is suitable when more data is involved
3. Django session variables - This is the simplest to implement
4. Client-side cookies - Can be used but there is limitations of how much data can be stored.
5. Shared memory at web server level- Tricky but can be done.
6. REST API's - If you can have a stand-alone server, then that server can REST API's to invoke views.
7. Message queues - Again if a stand-alone server is possible maybe even message queues would work. i.e. first view (API) takes requests and pushes it to a queue and some other process can pop messages off and hit your second view (another API). This would decouple first and second view API's and possibly manage load better.
8. Cache - Maybe a cache like memcached [ http://memcached.org/ ] can act as mediator. But then if one is going this route, its better to use Django sessions as it hides a whole lot of implementation details but if scale is a concern, memcached or redis [ http://redis.io/ ] are good options.
9. Persistent storage - store data in some persistent storage mechanism like mysql. This decouples your request taking part (probably a client facing API) from processing part by having a DB in the middle.
10. NoSql storages - if speed of writes are in other order of hundreds of thousands per sec, then MySql performance would become bottleneck (there are ways to get around by tweaking mysql config but its not easy). Then considering NoSql DB's could be an alternative. e.g: dynamoDB, Redis, HBase etc.
11. Stream Processing - like Storm [ http://storm.apache.org/ ] or AWS Kinesis [ http://docs.aws.amazon.com/streams/latest/dev/introduction.html ] could be an option if your use-case is real-time computation. In fact you could use AWS Lambda [ https://aws.amazon.com/documentation/lambda/ ] in the middle as a server-less compute module which would read off and call your second view API.
12. Write data into a file - then the next view can read from that file (real ugly). This probably should never ever be done but putting this point here as something that should not be done.
I can’t think of any more. I’ll update if i get any. Hope this helps in someway.

Source: Django Passing data between views [ http://stackoverflow.com/a/7763238/3731207 ]

Manan · Answer

Django is one of the best Python web frameworks out there. There. I said it.

First of all, one of the things I really, really like about Django is its ORM. What’s that? ORM stands for Object Relational Mapping and trust me, it only sounds cool and complex but is fairly easy. So ORM is basically just a way for you to structure your database without even knowing a database query language.

For example if you were creating a Blog for yourself, you’d probably have a defined way of what your post would have. Let’s say a title, the body, a date when it was published and an image thumbnail. Traditionally, if you were using a language such as PHP, you’d have to create a database in a database management system like this -

[code]CREATE TABLE "post" (
	"id" integer NOT NULL PRIMARY KEY AUTOINCREMENT, 
	"title" varchar(100) NOT NULL, 
	"body" text NOT NULL, 
	"thumbnail" varchar(100) NOT NULL,
	"timestamp" datetime NOT NULL
);
[/code]For those of you familiar with MySQL, this will look quite simple. But what happens when you’ve got users and newsletters and email assigned to them and then you’ve got to structure and assign them to everything? Yeah, Django makes it real easy.

So the same code above in Django’s ORM would be -

[code]from django.db import models

class Post(models.Model):
	title = models.CharField(max_length=100)
	body = models.TextField()
	thumbnail = models.ImageField()
	timestamp = models.DateTimeField(auto_now_add=True)
[/code]Look me in the eye and tell me that this doesn’t look better than the MySQL code.

Now for the queries. Ah, how I love you Django. Take a look (to get all the entries in a database) -

[code]SELECT "post"."id", "post"."title", "post"."body", "post"."thumbnail", "post"."timestamp" FROM "post"
[/code]Django -

[code]from post.models import Post
Post.objects.all()
[/code]Look at that. Just look. Point being - Django’s ORM is amazing.

Next. The views.

A lot of people choose Flask or Pyramid over Django due to them being more “flexible”. I ask them, how was Django hindering you. I mean it - you can build almost any sort of web application with it but a downside is that there will be a proper and specific way of doing so. Personally, I like this. It enforces some checks on you to make it difficult to write bad Django code. And that’s good. But for some people who like their liberty, they might prefer Flask where there’s about a million ways to do simple thing. For example if you’ve got the same database with a lot of posts and you want to display all of them using an HTML template, here’s what the Django code will look like -

[code]from django.views.generic import ListView
from post.models import Post

class PostListView(ListView):
	model = Post
	template_name = "posts.html"
	context_object_name = "posts"
	paginate_by = 10
[/code]So. Damn. Clean. Now doing the same in flask would be a whole lot of code because Flask doesn’t have an ORM. So you’re going to have to use a third party port for SQL-Alchemy or something like that to create your database table, query it, and get the posts in a list. A big no from my side. And that’s not to include cool features like pagination, truncation, date functions, string functions and a whole bunch of template tags that come included with Django -

[code]%3C!DOCTYPE html%3E
%3Chtml lang='en'%3E
	%3Chead%3E
		%3Ctitle%3EBlog%3C/title%3E
	%3C/head%3E
	%3Cbody%3E
		{% for post in posts %}
			%3Ch1%3E{{ post.title | title }}%3C/h1%3E
			%3Cbr%3E
			%3Csmall%3E{{ post.timestamp | date }}%3C/small%3E
			%3Cbr%3E
			%3Cimg src="{{ post.thumbnail.url }}"%3E%3Cbr%3E
			%3Cp%3E{{ post.body | linebreaks }}%3C/p%3E
			%3Chr /%3E
		{% endfor %}
	%3C/body%3E
%3C/html%3E
[/code]Over all, Django is super fun and easy to use. 10/10, definitely recommend.

Diave · Answer

In Django REST Framework (DRF), you can implement pagination by using the built-in pagination classes provided by DRF. Here's a simple example of how you can implement pagination in a DRF view:

```python

# http://views.py

from rest_framework.pagination import PageNumberPagination

from rest_framework.response import Response

from rest_framework.views import APIView

from .models import YourModel

from .serializers import YourModelSerializer

class YourModelListView(APIView):

def get(self, request):

queryset = YourModel.objects.all()

# Initialize the pagination class

paginator = PageNumberPagination()

# Set the pagination style and configure pagination settings

paginator.page_size = 10 # Number of items per page

# Paginate the queryset

paginated_queryset = paginator.paginate_queryset(queryset, request)

# Serialize the paginated queryset

serializer = YourModelSerializer(paginated_queryset, many=True)

# Return paginated response

return paginator.get_paginated_response(serializer.data)

```

In this example:

- We import the necessary modules from DRF (`PageNumberPagination`) along with the model and serializer related to your application.

- We define a view class `YourModelListView` which inherits from DRF's `APIView`.

- In the `get` method of the view, we retrieve the queryset for your model.

- We instantiate the `PageNumberPagination` class and configure the pagination settings, such as `page_size` which determines the number of items per page.

- We use the `paginate_queryset` method to paginate the queryset based on the request.

- Then, we serialize the paginated queryset using your serializer.

- Finally, we return the paginated response using `get_paginated_response` method of the paginator.

This setup allows you to easily paginate your API responses in Django REST Framework. Adjust the pagination class and settings as per your project requirements.

Md. Mohaiminul Hasan Khan · Answer

Use session. Let’s say you have and argument variable called ‘test’ and the value is 123. The following code will assign that to your session variables list.

[code]request.session[‘test’] = 123
[/code]Now you can browse the whole website it is still going to be available. Write the following code in ANY view to capture the value of test:

[code]test = request.session[‘test’]
[/code]So basically what you are doing is when you have a variable ‘test’, you are assigning the value 123 to a session variable called ‘test’. And when you need it, you just take that session variable and assign it to another variable ‘test’.

Do some trial and error by changing variable names to understand how this works. Good luck.

Ruperto Arrieta Jr · Answer

from

https://docs.djangoproject.com/en/3.1/topics/http/urls/
a Urlpattern is an entry on a list called `urlpatterns`

The `urlpatterns` list is really a routing map of URLs to views.

Basically, an http request to a Django server is routed to the correct view_function to handle the request by using the Urlpattern with a matching path

A Urlpattern is actually a url-view_function pair

Example in a file urls.py

Here’s a sample URLconf:

[code]from django.urls import path

from . import views

urlpatterns = [
    path('articles/2003/', views.special_case_2003),
    path('articles/%3Cint:year%3E/', views.year_archive),
    path('articles/%3Cint:year%3E/%3Cint:month%3E/', views.month_archive),
    path('articles/%3Cint:year%3E/%3Cint:month%3E/%3Cslug:slug%3E/', views.article_detail),
]

[/code]in above example, the first Urlpattern

[code]path('articles/2003/', views.special_case_2003),
[/code]is a url-view_function pair where the url is

[code]'articles/2003/'
[/code]and the view_function is

[code]views.special_case_2003
[/code]The http request http://%3CdjangoServer%3Earticles/2003/ matches this Urlpattern so

‘views.special_case_2003′ will be executed

i.e. the Urlpattern determines the route to the specific view_function to be executed given a requested url in the Django server.

Daniel Chvatik · Answer

You don’t, [code ]render_to_string[/code] takes a template name and some optional context for the template, not a URL.

https://docs.djangoproject.com/en/3.2/topics/templates/#django.template.loader.render_to_string

Divyesh Aegis · Answer

Django has included the top python framework and it’s great for making database-driven sites.

Today, the Django platform unites over several developers across huge countries.

I say, there no require to rewrite previous code because Django provides you to get together your website like a structure set.

User with a real understanding of Django idea it’s a less content system. It actual, it’s a software tool patterned to develop and explore web apps.

Support

* It supports CRM systems
 * CMS with other commercial tools
 * Mailing solutions
 * Advance technology support for ML, data science, etc…
Advantages

* An application can be included based on project requirement.
 * Several new things have been guided to accurate and many other things to be implemented.
 * Django provides you to custom the interface with third-party casing and add control panel unique to your requires.
Read more -

Why Django Is The Popular Python Framework Among Web Developers? [ https://www.codementor.io/divyeshaegis/why-django-is-the-popular-python-framework-among-web-developers-u65jx5p01 ]

Ninja Kissmo · Answer

The [code ]as_view()[/code] method in Django class-based views transforms a class-based view into a callable function that can be used in URL patterns. It bridges the gap between Django's URL routing system, which expects callable view functions, and the class-based view's object-oriented structure. By using [code ]as_view()[/code], developers can map class-based views to specific URLs, making them accessible to users. This method simplifies the integration of class-based views into Django projects, enabling clean, organized, and reusable view logic while maintaining compatibility with Django's URL configuration conventions.

Alessandro Forghieri · Answer

Django URLs have no features distinguishing them from any other URL. So you go the usual route, with a GET request & stick your string in the query fragment:

[code]https://blabla/fuu/bar?par_1=urlencodedvalue1&par_2=urlencodedvalue1
[/code]Of course the server side code must konw about and be willing to read par_1, par_2 and co. That should go without saying.

Daniel Chvatik · Answer

There are a few ways depending on what you mean by current url.

All these require this context preprocessor to be enabled (which is the default)

[code]django.template.context_processors.request
[/code]Template variables

[code]{{ request.path }}
[/code]this gets you the current relative path without query params

[code]{{ request.get_full_path }}
[/code]this gets you the current relative path with query params

[code]{{ request.build_absolute_uri }}
[/code]this will get you the url including domain name

Depending on how you plan to use it in the template, you may also need to url encode the variable like this:

[code]{{ request.get_full_path|urlencode }}
[/code]

Andrew Evans · Answer

There are a couple ways. If you are storing your model in PostgreSQL, use the specialized fields (PostgreSQL specific model fields). Here is an example Speed up Django & Postgres with simple JSON field.

If you are not using PostgreSQL, just use the json module to store the data as a dict or string. You could even use Django to write an import and export that does this work for you (Writing custom model fields). It is really just a few lines.

If you are not using PostgreSQL, just use the json module to store the data as a dict or string. You could even use Django to write an import and export that does this work for you (Writing custom model fields [ https://docs.djangoproject.com/en/2.2/howto/custom-model-fields/ ]). It is really just a few lines.

Fahiz Kp · Answer

from django.contrib import admin

from django.urls import path,include

from app_name import views

urlpatterns = [

path('admin/', admin.site.urls),

path(‘login/’,‘views.login’,name=’login’)

]

P-Kak · Answer

Yaa..

I can't explain as single reply.

I hope you're familiar about different of class based views nd function based approach.

I am sending django documentation.i hope you will understand…

In this documentation there's a introduction to class based views.you can start from that for better understanding

https://docs.djangoproject.com

Anonymous · Answer

Here is a short list that will help:

* use NGINX (or a CDN) to serve compressed static assets
* use NGINX to round-robin over multiple web servers running Django+Gunicorn
* make sure your files like favicon, robots.txt, exist and are not 404ing
* use database indexes wisely for complex queries (avoid full-table scans)
* cache complicated query results in Memcache/Redis
* use Redis for sorts/cache/pub/sub (it's really fast)
* minify the entire front-end
* use Celery (or similar) to offload applicable requests to async queues
* use django-debug-toolbar to find bottle necks
* store sessions in Redis, not a SQL table
* consider configuring Gunicorn to use Gevent instead of threads (not always possible)
* configure NGINX timeouts correctly, do not let requests hang for more than a few seconds

In my impression, the most important design decision you can make off the bat: Try to create client-side single page apps using backbone.js routers (or something similar). This will avoid full-page reloads (bypassing Django's template generation / ORM queries) and force a lot of work to be done in the client's browser. This may require a RESTAPI, and if so use Tastypie or DjangoRestFramework.

Daniel Chvatik · Answer

Lists, by their very definition, have an order, that’s what makes them lists. So an unordered list doesn’t make sense. But you probably get what you are looking for by using a [code ]set[/code], which does not have a defined order is it’s membership (although most implementations seem to give it an order anyway). The question also begs, why would you want an unordered list?

Maksim (Django Deep Dive) · Answer

In order to pass information from templates, you need to use django forms. Specify in the forms the url where you need to send data:

%3Cform action='/create_student/' method='post'%3E

Create url with a view for it:

path('create_student/', create_student, name='create_student')

Create a view which will receive the post request data:

def create_student(request):

if (request.method == 'POST'):

form = Form(request.POST)

and access data using form.cleaned_data

https://youtu.be/pLMH_wzyTjk

Daniel Chvatik · Answer

There are many options and best depends on your use case and requirements. You could:

* Use a JSON field (but this requires Postgres as your DB engine). This is probably the best all around solution.
 * Use a char field and concatenate the strings there, but this can make queries trickier, although there are some cases where this can be advantageous
 * Use many-to-many relationship between your model and another model holding the strings, using a through model to keep track of order etc. This is a lot of effort and probably not worth it except in certain edge cases.

Anonymous · Answer

JSON serialization might not be too bad.  To that end there is a JSONField in django-extensions.

Some considerations are that you won't be able to query on individual instructions, and there's a performance hit to serializing/deserializing that might be a factor.

Another alternative might be to use a separate datastore such as redis or mongo (keyed by the primary key of your traditional main model).

All that said, creating an Instruction model might still be the best, in that it does the job (for a given performance profile), and doesn't introduce any unusual design.

Vineet Daniel · Answer

★★★★

1. faster development
2. slow performance (default installation and configuration..needs optimization)