Learn python, from entry to give up (52)
virtual environment
How many projects can be opened and run on your machine without hassle
1. Download all the modules you need to use. If there are different versions of the same module, download and replace each time.
2. Prepare multiple interpreter environments in advance and switch for different projects
django version difference
-
The route matching method is different
url() supports regular expressions
The first parameter of path() does not support regular expressionsIf you want to use regular, there is also a method
from django.urls import path,re_path
-
The path method provides the converter function
path('index/<int:id>/', index)
Match the data in the corresponding position and automatically convert the type
There are five converters to choose from
view function return value
The view function must return an HttpResonse object
HttpResponse class HttpResponse(...): pass render def render(...): return HttpResponse(...) redirect def redirect(...):
JsonResponse object
user_dict = {'name': 'jason', 'pwd': 123, 'hobby': 'study well'} return JsonResponse(user_dict,json_dumps_params={'ensure_ascii':False}) class JsonResponse(HttpResponse): def __init__(self, data,json_dumps_params=None, **kwargs): data = json.dumps(data, **json_dumps_params)
Using JsonResponse is not the original json module, django has expanded the range of json serialized data types
form upload file
If the data uploaded in the form contains files, then you need to do the following things
1.method must be post
2.enctype must be modified to multipart/form-data
The default is application/x-www-form-urlencoded
3. The backend needs to use request.FILES to obtain
django will automatically encapsulate it into different methods for you according to the data type
request other methods
request.method
request.POST
request.GET
request.FILES
request.body
Stores the most primitive binary data received
The methods of request.POST, request.GET, request.FILES actually obtain data from the body and parse the stored data.
request.path
get path
request.path_info
get path
request.get_full_path()
Get the path and also get the parameters carried behind the path
FBV and CBV
-
FBV: Function-Based Views
url(r'^index/',Function name)
-
CBV: Class-Based Views
from django import views class MyLoginView(views.View): def get(self, request): return HttpResponse("from CBV get view") def post(self, request): return HttpResponse("from CBV post view") url(r'^ab_cbv/', views.MyLoginView.as_view())
If the request method is GET, the get method in the class will be automatically executed
If the request method is POST, the post method in the class will be automatically executed.
CBV source code analysis
-
route matching
The class name point attribute as_view and also add parentheses
as_view may be a normal static method
as_view may be a method bound to a class -
The order in which objects look up properties
Start with the object itself, then the class that produced the object, then the parent classes
MyLoginView.as_view()
First find it from MyLoginView we wrote ourselves
I didn't go to the parent class Views to find it -
The function name with parentheses has the highest execution priority
url(r'^ab_cbv/', views.MyLoginView.as_view())
When the project is started, the as_view method will be executed, and viewing the source code returns a closure function name view.
def as_view(cls): def view(cls): pass return view url(r'^ab_cbv/', views.view)
CBV and FBV are essentially the same in route matching
-
Execute the view function after the route is matched successfully
def view(): self = cls() return self.dispatch(request, *args, **kwargs)
-
Execute the dispatch method
Need to pay attention to the search order
def dispatch(): handler = getattr(self, request.method.lower()) return handler(request, *args, **kwargs)
Viewing the source code can also be modified, but try not to do so, it is easy to generate bug s
template syntax pass by value
The template syntax provided by django has only two symbols
{{}}: Mainly used for variable-related operations (references)
{%%}: Mainly used for logic related operations (loop, judgment)
Two ways to pass values
-
biography by name
It is suitable for situations with less data volume, which can save resources
return render(request, 'ab_temp.html', {'name':name})
-
Pack and pass value
Suitable for large amounts of data, but will waste resources
locals() passes all names in the current namespace to the html page
return render(request, 'ab_temp.html', locals())
range of values passed
Basic data types can be
Function name
The template syntax will be automatically executed with parentheses and the return value of the function will be displayed on the page
Does not support parameter passing (template syntax will automatically ignore parameterized functions)
file name
Display file IO objects directly
class name
Automatically parenthesized instantiation into an object
object name
Directly display the address of the object and have the ability to call properties and methods
django template syntax has only one way to evaluate the value of container type period
You can click both the key and the index. django internal automatic identification
{{ data1.info.pro.3.msg }}