Django框架全面讲解二

最新推荐文章于 2021-03-20 18:24:11 发布
最新推荐文章于 2021-03-20 18:24:11 发布
阅读量306 收藏 4
点赞数
分类专栏： Django
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43278089/article/details/90522168
版权
Django框架全面讲解二
七、中间件（MiddleWare）

django 中的中间件（middleware），在django中，中间件其实就是一个类，在请求到来和结束后，django会根据自己的规则在合适的时机执行中间件中相应的方法。

在django项目的settings模块中，有一个 MIDDLEWARE_CLASSES 变量，其中每一个元素就是一个中间件，如下图

img

中间件中可以定义五个方法，分别是：

  • process_request(self,request)
  • process_view(self, request, callback, callback_args, callback_kwargs)
  • process_template_response(self,request,response)
  • process_exception(self, request, exception)
  • process_response(self, request, response

分析源码得知前二个方法是从前往后执行的，后三个方法是从后往前执行的

img

所以前两个方法是请求进来的，后三个方法是请求出去的

一张图告诉你中间件的运行流程

img

自定义中间件

1、创建中间件类

class Middle_Test(object):
       
    def process_request(self,request):
        pass
    def process_view(self, request, callback, callback_args, callback_kwargs):
        1
        pass
    def process_exception(self, request, exception):
        pass
    def process_response(self, request, response):
        return response

2、注册中间件

MIDDLEWARE_CLASSES = (
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'sparks.middleware.auth.Middle_Test',
)
八、 Form
1.使用 forms 模块生成表单，主要处理GET请求
	1.forms模块的作用
		通过forms模块，允许将表单与class结合(表单与实体类结合)，允许通过class生成表单
	2.使用forms模块
		1.在应用中创建 forms.py 文件
		2.导入forms模块
			from django import forms
		3.创建class，一个class对应生成一个表单
			class ClassName(forms.Form):
				pass
		4.创建属性
			一个属性对应到表单中生成一个控件
	3.在模板中解析 form 对象
		1.注意
			在模板中，需要：
				1.自定义 <form></form>
				2.自定义 提交按钮
		2.处理方法
			1.在 views 中创建 form 的对象并发送到模板上
				form = RemarkForm()
				return render(request,'xxx.html',locals())
			2.在模板中进行解析
				1.手动解析
					{% for field in form %}
						{{field}} :
							表示的就是form对象中的一个独立属性
							表示的也就是一个独立的控件
						{{field.label}}:
							表示的是控件中的label的值
					{% endfor %}
				2.自动解析
					1.{{form.as_p}}
						将form对象中的每个属性使用p标记包裹起来再显示
					2.{{form.as_ul}}
						将form对象中的每个属性使用li标记包裹起来，再显示
						注意：必须手动提供<ol> 或 <ul>
					3.{{form.as_table}}
						将form对象中的每个属性用tr标记包裹起来，再显示
						注意：必须手动提供<table>

2.通过 forms.Form 获取表单数据 - POST
    1.通过 forms.Form 的构造函数来接收post数据
    	form = RemarkForm(request.POST)
    2.必须使form通过验证后再获取数据
    	form.is_valid()
    		返回True:提交的数据以及表单已通过所有的验证，允许取值
    		返回False:未通过验证，则不能正常取值
    3.获取表单中的数据
    	通过 form.cleaned_data 来获取提交的数据

form.py

from django import forms

#声明ChoiceField要用到的数据
TOPIC_CHOICE = (
    ('1', '好评'),
    ('2', '中评'),
    ('3', '差评'),
)


class RemarkForm(forms.Form):
    #评论标题
    # forms.CharField() - 文本框
    # label : 控件前的文本标签
    subject = forms.CharField(label='标题')
    #电子邮箱
    # forms.EmailField() - Email框
    # label : 控件前的文本标签
    email = forms.EmailField(label='邮箱')
    #品论内容
    # widget=Textarea : 将当前的单行文本框变为多行文本域
    message = forms.CharField(label='内容', widget=forms.Textarea)
    #品论级别
    # forms.ChoiceField() - 下拉列表框
    # choices : 表示当前下拉列表框中的数据,取值为元组或列表
    topic = forms.ChoiceField(label='级别', choices=TOPIC_CHOICE)
    #是否保存-复选框
    isSaved = forms.BooleanField(label='是否保存')

views.py

def form_register(request):
    if request.method == 'GET':
        form = RegisterForm()
        return render(request,'07-form-register.html',locals())
    else:
        # 将request.POST中的数据提交给RegisterForm()
        form = RegisterForm(request.POST)
        # 将数据通过验证
        if form.is_valid():
        # 验证过后获取数据并保存进数据库
        	au = Author(**form.cleaned_data)
        	au.save()
        	return HttpResponse("Register OK")

html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        #id_subject{
        border:none;
        border-bottom:1px solid #000;
        outline:none;
        }
    </style>
</head>
<body>
      {% comment '手动解析' %}
    <form action="/06-form/" method="post">
      {% csrf_token %}
      {% for field in form %}
        <p>
          {{ field.label }}:{{ field }}
        </p>
      {% endfor %}
      <p>
        <input type="submit">
      </p>
    </form>
    {% endcomment %}

    {% comment '自动解析- {{ form.as_p }}' %}
    <form action="/06-form/" method="post">
      {{ form.as_p }}
      <p>
        <input type="submit">
      </p>
    </form>
    {% endcomment %}  
    
</body>

1.使用 forms 模块
	2.forms模块的高级处理
		将 Models 和 Forms 结合到一起使用
		1.在 forms.py 中创建 class ，继承自 forms.ModelForm
		2.创建内部类Meta，去关联 Model
			1.model : 指定要关联的实体类
			2.fields : 指定从Model中取哪些字段生成控件
				1.取值 "__all__",表示全部属性都要生成控件
				2.取值 列表，声明允许生成控件的属性名
			3.labels : 指定每个属性所关联的label，取值为字典
				labels = {
					'属性名':'label文本',
					'属性名':'label文本',
				}
	3.内置小部件 - widget
		1.什么是小部件
			小部件，表示的就是生成到网页上的控件类型以及其他的html属性
		2.常用小部件类型
			1.TextInput : type='text'
			2.PasswordInput : type='password'
			3.NumberInput : type='number'
			4.EmailInput : type='email'
			5.URLInput : type='url'
			6.HiddenInput : type='hidden'
			7.CheckboxInput : type='checkbox'
			8.Textarea : <textarea></textarea>
			9.Select : <select></select>
		3.小部件的使用
			1.继承自 forms.Form 类
				1.基本版
					只指定控件的类型
					class RemarkForm(forms.Form):
						属性 = forms.CharField(
							label='文本',
							widget=forms.小部件类型
						)
				2.高级版
					指定控件类型的基础上还允许设置一些相关的HTML属性到控件上
					属性 = forms.CharField(
						label = '文本',
						widget = forms.小部件类型(
							attrs = {
								'html属性名':'属性值',
								'html属性名':'属性值',
							}
						)
					)
			2.继承自 forms.ModelForm 类
				class XXXForm(forms.ModelForm):
					class Meta:
						model = xxxx
						fields = "__all__" 或 []
						labels = {
							'属性1':'标签1',
						}
						#指定小部件
						widgets = {
							"属性1":forms.小部件类型(
								attrs = {
									'属性':'值',
								}
							),
						}

form.py

class WidgetForm2(forms.ModelForm):
    class Meta:
        #指定关联的实体
        model = Author
        #指定要显示的字段
        fields = ['name','age','email']
        #指定字段对应的标签
        labels = {
        'name':'用户姓名',
        'age':'用户年龄',
        'email':'用户邮箱',
        }
        #指定字段对应的小部件
        widgets = {
        'age':forms.NumberInput(
            attrs = {
            'placeholder':'请输入年龄',
            'class':'form-control',
            }
        ),
        'email':forms.EmailInput(
            attrs = {
            'placeholder':'请输入您的电子邮箱',
            'class':'form-control',
            }
        )
    }

views.py

def widget2_views(request):
    if request.method == 'GET':
        form = WidgetForm2()
        return render(request,'08-widget1.html',locals())
    else:
		# 将request.POST中的数据提交给RegisterForm()
        form = RegisterForm(request.POST)
        # 将数据通过验证
        if form.is_valid():
        # 验证过后获取数据并保存进数据库
        	au = Author(**form.cleaned_data)
        	au.save()
        	return HttpResponse("Register OK")

html

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<style>
    input.form-control{
    border:1px solid #000;
    width:300px;
    height:30px;
    box-sizing:border-box;
    padding:3px 10px;
    outline:none;
    }
</style>
</head>
<body>
    <form action="/09-widget2">
        {{ form.as_p }}
    </form>
</body>
</html>
九、 认证系统（auth）

auth模块是Django提供的标准权限管理系统,可以提供用户身份认证, 用户组管理,并且可以和admin模块配合使用.

在INSTALLED_APPS中添加’django.contrib.auth’使用该APP, auth模块默认启用.

新建用户

from django.contrib.auth.models import User

user = User.objects.create_user(username, email, password)
user.save()

# 不存储用户密码明文而是存储一个Hash值

认证用户

from django.contrib.auth import authenticate

user = authenticate(username=username, password=password)

# 认证用户的密码是否有效, 若有效则返回代表该用户的user对象, 若无效则返回None.
# 该方法不检查is_active标志位.

修改密码：

user.set_password(new_password)

# 以下实例为先认证通过后才可以修改密码
user = auth.authenticate(username=username, password=old_password)
if user is not None:
    user.set_password(new_password)
    user.save()

登录

from django.contrib.auth import login

# login向session中添加SESSION_KEY, 便于对用户进行跟踪:
'login(request, user)'

# login不进行认证,也不检查is_active标志位
# 实例
user = authenticate(username=username, password=password)
if user is not None:
    if user.is_active:
        login(request, user)

退出登录

# logout会移除request中的user信息, 并刷新session

from django.contrib.auth import logout

def logout_view(request):
    logout(request)

只允许登录的用户访问

@login_required装饰器装饰的view函数会先通过session key检查是否登录, 已登录用户可以正常的执行操作, 未登录用户将被重定向到login_url指定的位置，若未指定login_url参数, 则重定向到settings.LOGIN_URL

from django.contrib.auth.decorators import login_required

@login_required(login_url='/accounts/login/')
def userinfo(request):
    ...

# settings 配置
LOGIN_URL = '/index/'
# views
@login_required
def userinfo(request):
    ...
十、 跨站请求伪造（csrf）

django为用户实现防止跨站请求伪造的功能，通过中间件 django.middleware.csrf.CsrfViewMiddleware 来完成。而对于django中设置防跨站请求伪造功能有分为全局和局部。

全局：

中间件 django.middleware.csrf.CsrfViewMiddleware

局部：

  • @csrf_protect，为当前函数强制设置防跨站请求伪造功能，即便settings中没有设置全局中间件。
  • @csrf_exempt，取消当前函数防跨站请求伪造功能，即便settings中设置了全局中间件。

注：from django.views.decorators.csrf import csrf_exempt,csrf_protec

应用

1、普通表单

# veiw中设置返回值：
return render(request, 'xxx.html', data)
   
# html中设置Token:
{% csrf_token %}
十一、2.cookies 和 session
2.cookies 和 session
	1.cookies
		1.django 中使用 cookies
			1.设置cookies的值(将数据保存到客户端)
				语法：
					响应对象.set_cookie(key,value,expires)
					key:cookie的名字
					value:cookie的值
					expires:保存时间，以s为单位
				1.不使用模板
					resp = HttpResponse('响应给客户端的一句话')
					resp.set_cookie(key,value,expires)
					return resp
				2.使用模板
					resp = render(request,'xxx.html',locals())
					resp.set_cookie(key,value,expires)
					return resp
				3.使用重定向
					resp = redirect('/地址/')
					resp.set_cookie(key,value,expires)
					return resp
			2.获取cookies的值
				伴随着请求对象到达服务器之后再获取cookie的值
				request.COOKIES:封装了当前访问站点下的所有的cookie的信息
			3.删除cookie的值
				通过响应对象通知客户端删除数据
				resp.delete_cookie(key)
			
	2.session
		1.设置 session 的值
			request.session['key'] = 值
		2.获取 session 的值
			value = request.session['key']
			value = request.session.get('key')
		3.删除 session 的值
			del request.session['key']
		4.有关 session 的配置
			在 settings.py 中，有关session的设置
			1.SESSION_COOKIE_AGE
				作用：设置sessionID在cookies中的存活时间
				ex:
					SESSION_COOKIE_AGE=60*30
			2.SESSION_EXPIRE_AT_BROWSER_CLOSE
				作用：设置浏览器关闭时则清除服务器上对应的session空间

				ex:
					SESSION_EXPIRE_AT_BROWSER_CLOSE = True
十二、Session

Django中默认支持Session，其内部提供了5种类型的Session供开发者使用：

  • 数据库（默认）
  • 缓存
  • 文件
  • 缓存+数据库
  • 加密cookie

1.数据库Session

Django默认支持Session，并且默认是将Session数据存储在数据库中，即：django_session 表中。
 
a. 配置 settings.py
 
    SESSION_ENGINE = 'django.contrib.sessions.backends.db'   # 引擎（默认）
     
    SESSION_COOKIE_NAME ＝ "sessionid"                       # Session的cookie保存在浏览器上														时的key，即：sessionid＝随机字符串（默认）
    SESSION_COOKIE_PATH ＝ "/"                               # Session的cookie保存的路径（默认）
    SESSION_COOKIE_DOMAIN = None                             # Session的cookie保存的域名（默认）
    SESSION_COOKIE_SECURE = False                            # 是否Https传输cookie（默认）
    SESSION_COOKIE_HTTPONLY = True                           # 是否Session的cookie只支持http传输（默认）
    SESSION_COOKIE_AGE = 1209600                             # Session的cookie失效日期（2周）（默认）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                  # 是否关闭浏览器使得Session过期（默认）
    SESSION_SAVE_EVERY_REQUEST = False                       # 是否每次请求都保存Session，默认修改之后才保存（默认）
 
 
 
b. 使用
 
    def index(request):
        # 获取、设置、删除Session中数据
        request.session['k1']
        request.session.get('k1',None)
        request.session['k1'] = 123
        request.session.setdefault('k1',123) # 存在则不设置
        del request.session['k1']
 
        # 所有 键、值、键值对
        request.session.keys()
        request.session.values()
        request.session.items()
        request.session.iterkeys()
        request.session.itervalues()
        request.session.iteritems()
 
 
        # 用户session的随机字符串
        request.session.session_key
 
        # 将所有Session失效日期小于当前日期的数据删除
        request.session.clear_expired()
 
        # 检查 用户session的随机字符串 在数据库中是否
        request.session.exists("session_key")
 
        # 删除当前用户的所有Session数据
        request.session.delete("session_key")
 
        ...

2、缓存Session

a. 配置 settings.py
 
    SESSION_ENGINE = 'django.contrib.sessions.backends.cache'  # 引擎
    SESSION_CACHE_ALIAS = 'default'                            # 使用的缓存别名（默认内存缓存，也可以是memcache），此处别名依赖缓存的设置
 
 
    SESSION_COOKIE_NAME ＝ "sessionid"                        # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串
    SESSION_COOKIE_PATH ＝ "/"                                # Session的cookie保存的路径
    SESSION_COOKIE_DOMAIN = None                              # Session的cookie保存的域名
    SESSION_COOKIE_SECURE = False                             # 是否Https传输cookie
    SESSION_COOKIE_HTTPONLY = True                            # 是否Session的cookie只支持http传输
    SESSION_COOKIE_AGE = 1209600                              # Session的cookie失效日期（2周）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                   # 是否关闭浏览器使得Session过期
    SESSION_SAVE_EVERY_REQUEST = False                        # 是否每次请求都保存Session，默认修改之后才保存
 
 
 
b. 使用
 
    同上

3、文件Session

a. 配置 settings.py
 
    SESSION_ENGINE = 'django.contrib.sessions.backends.file'    # 引擎
    SESSION_FILE_PATH = None                                    # 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir()                                                            # 如：/var/folders/d3/j9tj0gz93dg06bmwxmhh6_xm0000gn/T
 
 
    SESSION_COOKIE_NAME ＝ "sessionid"                          # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串
    SESSION_COOKIE_PATH ＝ "/"                                  # Session的cookie保存的路径
    SESSION_COOKIE_DOMAIN = None                                # Session的cookie保存的域名
    SESSION_COOKIE_SECURE = False                               # 是否Https传输cookie
    SESSION_COOKIE_HTTPONLY = True                              # 是否Session的cookie只支持http传输
    SESSION_COOKIE_AGE = 1209600                                # Session的cookie失效日期（2周）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                     # 是否关闭浏览器使得Session过期
    SESSION_SAVE_EVERY_REQUEST = False                          # 是否每次请求都保存Session，默认修改之后才保存
 
b. 使用
 
    同上

4、缓存 + 数据库 Session

数据库用于做持久化，缓存用于提高效率
 
a. 配置 settings.py
 
    SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'        # 引擎
 
b. 使用
 
    同上

5、加密cookie Session

a. 配置 settings.py
     
    SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'   # 引擎
 
b. 使用
 
    同上
十三、缓存

由于Django是动态网站，所有每次请求均会去数据进行相应的操作，当程序访问量大时，耗时必然会更加明显，最简单解决方式是使用：缓存，缓存将一个某个views的返回值保存至内存或者memcache中，5分钟内再有人来访问时，则不再去执行view中的操作，而是直接从内存或者Redis中之前缓存的内容拿到，并返回。

Django中提供了6种缓存方式：

  • 开发调试
  • 内存
  • 文件
  • 数据库
  • Memcache缓存（python-memcached模块）
  • Memcache缓存（pylibmc模块）

和数据库类似，缓存的具体操作都是一样的，使用不同的方式只需要将配置改掉即可

1、配置

a、开发调试

# 此为开始调试用，实际内部不做任何操作
    # 配置：
        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.dummy.DummyCache',     # 引擎
                'TIMEOUT': 300,                                               # 缓存超时时间（默认300，None表示永不过期，0表示立即过期）
                'OPTIONS':{
                    'MAX_ENTRIES': 300,                                       # 最大缓存个数（默认300）
                    'CULL_FREQUENCY': 3,                                      # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
                },
                'KEY_PREFIX': '',                                             # 缓存key的前缀（默认空）
                'VERSION': 1,                                                 # 缓存key的版本（默认1）
                'KEY_FUNCTION' 函数名                                          # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
            }
        }


    # 自定义key
    def default_key_func(key, key_prefix, version):
        """
        Default function to generate keys.

        Constructs the key used by all other methods. By default it prepends
        the `key_prefix'. KEY_FUNCTION can be used to specify an alternate
        function with custom key making behavior.
        """
        return '%s:%s:%s' % (key_prefix, version, key)

    def get_key_func(key_func):
        """
        Function to decide which key function to use.

        Defaults to ``default_key_func``.
        """
        if key_func is not None:
            if callable(key_func):
                return key_func
            else:
                return import_string(key_func)
        return default_key_func

b、内存

# 此缓存将内容保存至内存的变量中
    # 配置：
        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
                'LOCATION': 'unique-snowflake',
            }
        }

    # 注：其他配置同开发调试版本

c、文件

# 此缓存将内容保存至文件
    # 配置：

        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
                'LOCATION': '/var/tmp/django_cache',
            }
        }
    # 注：其他配置同开发调试版本

d、数据库

# 此缓存将内容保存至数据库

    # 配置：
        CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
                'LOCATION': 'my_cache_table', # 数据库表
            }
        }

    # 注：执行创建表命令 python manage.py createcachetable

e、Memcache缓存（python-memcached模块）

# 此缓存使用python-memcached模块连接memcache

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
            'LOCATION': '127.0.0.1:11211',
        }
    }

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
            'LOCATION': 'unix:/tmp/memcached.sock',
        }
    }   

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
            'LOCATION': [
                '172.19.26.240:11211',
                '172.19.26.242:11211',
            ]
        }
    }

f、Memcache缓存（pylibmc模块）

# 此缓存使用pylibmc模块连接memcache
    
    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
            'LOCATION': '127.0.0.1:11211',
        }
    }

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
            'LOCATION': '/tmp/memcached.sock',
        }
    }   

    CACHES = {
        'default': {
            'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
            'LOCATION': [
                '172.19.26.240:11211',
                '172.19.26.242:11211',
            ]
        }
    }

2、应用

a. 全站使用

使用中间件，经过一系列的认证等操作，如果内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户，当返回给用户之前，判断缓存中是否已经存在，如果不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存

    MIDDLEWARE = [
        'django.middleware.cache.UpdateCacheMiddleware',
        # 其他中间件...
        'django.middleware.cache.FetchFromCacheMiddleware',
    ]

    CACHE_MIDDLEWARE_ALIAS = ""
    CACHE_MIDDLEWARE_SECONDS = ""
    CACHE_MIDDLEWARE_KEY_PREFIX = ""

b. 单独视图缓存

方式一：
        from django.views.decorators.cache import cache_page

        @cache_page(60 * 15)
        def my_view(request):
            ...

    方式二：
        from django.views.decorators.cache import cache_page

        urlpatterns = [
            url(r'^foo/([0-9]{1,2})/$', cache_page(60 * 15)(my_view)),
        ]

c、局部视图使用

a. 引入TemplateTag

        {% load cache %}

    b. 使用缓存

        {% cache 5000 缓存key %}
            缓存内容
        {% endcache %}

注：如果出现多个url匹配同一个view函数的情况，缓存机制会根据每一个不同的url做单独的缓存

浅吻＠
关注
专栏目录
Django框架二
m0_43448734的博客
01-22 816
负责跟数据库之间进行通信映射图通过管理器方法调用查询方法。
浅学-Django框架（二）
码农米格的博客
09-17 269
Django框架0x06、Django 的请求与响应Django的请求Django 请求之GETDjango 请求之POST响应0x07、模板层模板的创建模板的应用模板的变量模版功能标签模板过滤器模板的继承 传送门：Django 框架（一） 系统环境：Django 3.2.4，python 3.8.0，mysql 5.7 0x06、Django 的请求与响应 Django的请求 请求有页面浏览器发起，通过 Http协议 传递给后端，交由视图函数处理。 Django 在接收到 http协议 的请求后，会
Django框架全面讲解
02-24
MVC是众所周知的模式，即：将应用程序分解成三个组成部分:model(模型),view(视图),和controller(控制器)。其中：M——管理应用程序的状态（通常存储到数据库中），并约束改变状态的行为（或者叫做“业务规则”）。C——接受外部用户的操作，根据操作访问模型获取数据，并调用“视图”显示这些数据。控制器是将“模型”和“视图”隔离，并成为二者之间的联系纽带。V——负责把数据格式化后呈现给用户。Django也是一个MVC框架。但是在Django中，控制器接受用户输入的部分由框架自行处理，所以Django里更关注的是模型（Model）、模板(Template)和视图（Views），称为M
openstack开发实践（二）：Django框架简介和Django应用的编写
weixin_41977332的博客
02-15 1886
Django框架简介 Django是Python最有代表性的一个网络框架。使用Django可以方便地实现一个功能全面、管理简便的网站或者APP后端。openstack中用来提供图形化界面服务的Dashboard就是利用Django框架进行开发，所以在介绍openstack dashboard开发之前，通过本篇文章针对Django应用开发进行讲解。 Django的MTV（模型-模板-视图）模式本质上...
基于Django ORM、一对一、一对多、多对多的全面讲解
09-18
在Python的Web开发框架Django中，ORM（Object-Relational Mapping）是一种将数据库操作转化为面向对象编程的技术，使得开发者可以使用Python代码直接操作数据库，而无需编写SQL语句。本篇文章将深入探讨Django ORM中...
python django 基础讲解
02-05
通过"python django基础讲解"的课件，你将能够建立起对Django的全面理解，具备开发基本Web应用的能力。如果你对Python的其他领域有兴趣，也可以在我的资源页找到更多相关的学习资料。记住，持续学习和实践是提升技能...
django框架详解
03-27
django框架详细............................................................................................................
Django框架全面讲解 -- 模板
qq_34802511的博客
08-04 199
Django框架全面讲解 -- 模板 1.模板的执行  模版的创建过程，对于模版，其实就是读取模版（其中嵌套着模版标签），然后将 Model 中获取的数据插入到模版中，最后将信息返回给用户。 # view.py def index(request): return render(request, 'index.html', {'title':'welcome'}) # index...
Django框架全面讲解 -- admin
shentong1的专栏
12-19 558
django amdin是django提供的一个后台管理页面，改管理页面提供完善的html和css，使得你在通过Model创建完数据库表之后，就可以对数据进行增删改查，而使用django admin 则需要以下步骤：创建后台管理员 配置url 注册和配置django admin后台管理页面 1、创建后台管理员python manage.py createsuperuser2、配置后台管理url（默认
Django框架全面讲解 -- 序列化
qq_34802511的博客
08-06 265
Django框架全面讲解 -- 序列化 关于Django中的序列化主要应用在将数据库中检索的数据返回给客户端用户，特别的Ajax请求一般返回的为Json格式。  Python中用于序列化的两个模块 json 用于【字符串】和 【python基本数据类型】 间进行转换 pickle 用于【python特有的类型】 和 【python基本数据类型】间进行转换   Json模块提供...
Django框架全面讲解 -- Django流程介绍
谨
04-22 275
Python的WEB框架有Django、Tornado、Flask 、Zope TurboGears、Web2py(Webpy)、Pylons等多种，Django相较与其他WEB框架其优势为：大而全，框架本身集成了ORM、模型绑定、模板引擎、缓存、Session等诸多功能。 流程 基本配置 路由系统 视图view 模板 Model 中间件 Form 认证系统 CSRF 分页 Co...
Django框架全面讲解 -- Django Views（视图函数）
qq_34802511的博客
08-04 238
Django框架全面讲解 -- Django Views（视图函数） http请求中产生两个核心对象：  　　http请求：HttpRequest对象  　　http响应：HttpResponse对象  1.HttpRequest对象  当请求一个页面时，Django 创建一个 HttpRequest对象包含原数据的请求。然后 Django 加载适当的视图，通过 HttpRequest作为视图函...
Django框架全面讲解（四）
虫无涯的博客
10-10 323
继文章：Django框架全面讲解（三） 目录十、 跨站请求伪造（csrf）十一、 分页11.1、 Django内置分页11.2、 自定义分页十二、 Cookie12.1、 获取Cookie12.2、 设置Cookie 十、 跨站请求伪造（csrf） django为用户实现防止跨站请求伪造的功能，通过中间件 django.middleware.csrf.CsrfViewMiddleware 来完成。而对于django中设置防跨站请求伪造功能有分为全局和局部。 全局： 　　中间件 django.middlewa
django admin search_fields placeholder 管理后台添加搜索框提示文字
jaket5219999的博客
03-20 1676
如图, Django admin后台生成的搜索框, 默认是没有提示文字的, 不够友好; 网上也没搜到什么好的示例, 于是自动动手实现了一个 0. 已经存在的app名为carousel, 大致相当于如下代码 $ python manage.py startapp carousel # settings.py ``` INSTALLED_APPS = [ ... 'carousel', ] ``` # carousel/models.py ``` from django.db i.....
Django框架详解：从MVC到MTV模式
“Django框架全面讲解” Django是一个高级的Python Web框架，它鼓励快速开发和清洁、实用的设计。基于MVC（模型-视图-控制器）架构模式，但Django将其重新诠释为MTV（模型-模板-视图）模式。在Django中，模型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值