django

Django

概述

python有许多不同的WEB框架，django是最具有代表性的一位，许多成功的网站和APP都基于django

django是一个开源的web应用框架，由python编写

django采用了MVC的软件设计模式，既模型M，视图V，和控制器C

MVC框架和MTV框架

MVC （Model View Controller）是软件工程中的一种软件架构模式；把软件分为了三个基本部分：模型（Model） 视图（View）和 控制器（controller）具有耦合度低，重用性高，生命周期成本低等优点。

Django框架的设计模式借鉴了MVC框架的思想，也是分成三部分，来降低各个部分之间的耦合性。

Django框架的不同之处在于它拆分的三部分为：Model（模型）、Template（模板）和View（视图），也就是MTV框架。

Django的MTV模式

• Model(模型)：负责业务对象与数据库的对象(ORM)
• Template(模版)：负责如何把页面展示给用户
• View(视图)：负责业务逻辑，并在适当的时候调用Model和Template

此外，Django还有一个urls分发器，它的作用是将一个个URL的页面请求分发给不同的view处理，view再调用相应的Model和Template

Django框架图示

前端状态码的返回

1xx  请求接受了需进一步处理
2xx  成功
3xx  重定向  
4xx  请求的错误
5xx  服务器错误

url

# url的组成
协议  域名(ip)  端口(http默认80  https 443 )   路径  查询参数(?k1=v1&k2=v2) 

请求的格式(request)

"请求方法 路径 HTTP/1.1

采用方式:键值对

k2:v2

web框架的功能

web框架的功能:

1. socket收发消息
2. 根据不同的路径返回不同的内容 
3. 返回动态页面(字符串的替换  模板渲染) 

django的常用命令

安装ajango

# 指定安装的版本为1.11.25  -i参数指定下载源，默认国外官方，这里改成清华源
pip install django==1.11.25 -i https://pypi.tuna.tsinghua.edu.cn/simple/

创建django项目

# 创建项目
django-admin startproject mypro

django启动

 python manage.py runserver
 python  manage.py  runserver 80  # 127.0.0.1:80
 python manage.py runserver 0.0.0.0:80   # 指定ip:port

startproject的做的事情

mysite/
    manage.py
    mysite/
        __init__.py
        settings.py
        urls.py
        wsgi.py

• 外部mysite/根目录只是您的项目的容器。它的名称与Django无关；您可以将其重命名为任何喜欢的名称

• manage.py：一个命令行实用程序，可让您以各种方式与该Django项目进行交互。您可以manage.py在django-admin和manage.py中阅读有关的所有详细信息 。

• 内部mysite/目录是项目的实际Python包。它的名称是Python包名称，您需要使用它来导入其中的任何内容（例如mysite.urls）。

• mysite/settings.py：此Django项目的设置/配置。 Django设置将告诉您所有设置的工作方式

• mysite/urls.py：此Django项目的URL声明；Django支持的网站的“目录”。您可以在URL调度程序中阅读有关URL的更多信息。

• mysite/wsgi.py：兼容WSGI的Web服务器为您的项目提供服务的入口点。有关更多详细信息，请参见如何使用WSGI进行部署。

创建app程序

项目和应用之间有什么区别？应用程序是执行某项操作的Web应用程序，例如Weblog系统，公共记录数据库或简单的民意调查应用程序。项目是特定网站的配置和应用程序的集合。一个项目可以包含多个应用程序。一个应用程序可以在多个项目中。

创建应用注意 当与manage.py处于同一层目录

python .\manage.py startapp polls

数据库迁移 注入

python manage.py  makemigrations  # 检测已经注册app下的models.py的变更记录
python manage.py migrate   # 数据库迁移(生效到数据库中) 

django的配置

• BASE_DIR 整个项目的根目录

• INSTALLED_APPS 注册的程序APP 如果创建了新的APP这里则需要添加,不添加无法使用 默认包括了以下 Django 的自带应用：

  • django.contrib.admin – 管理员站点， 你很快就会使用它。
  • django.contrib.auth – 认证授权系统。
  • django.contrib.contenttypes – 内容类型框架。
  • django.contrib.sessions – 会话框架。
  • django.contrib.messages – 消息框架。
  • django.contrib.staticfiles – 管理静态文件的框架。

  这些应用被默认启用是为了给常规项目提供方便。

  'app01.apps.App01Config',  # app01 添加如下
  

• MIDDLEWARE 中间件配置

  django.middleware.csrf.CsrfViewMiddleware  # 注册掉后可以提交post请求
  

• TEMPLATES 模板目录

  'DIRS': [os.path.join(BASE_DIR, 'templates')] # 静态文件存放的目录(html)
  

• TIME_ZONE 为你自己时区

  TIME_ZONE = 'Asia/Shanghai'  # 设置时区为上海
  USE_TZ = False  # 关闭随模板时间 
  

• 定义自定义显示时间

  USE_L10N = False  # 设置为False 默认为True
  DATETIME_FORMAT = 'Y-m-d H:i:s'  # 年月日 时分秒
  DATE_FORMAT = 'Y-m-d'  # 年月日
  TIME_FORMAT = 'H:i:s'  # 时分秒
  

• DATABASES 数据库配置

  • ENGINE – 可选值有 'django.db.backends.sqlite3'，'django.db.backends.postgresql'，'django.db.backends.mysql'，或 'django.db.backends.oracle'。其它 可用后端。
  • NAME - 数据库的名称。如果使用的是 SQLite，数据库将是你电脑上的一个文件，在这种情况下， NAME 应该是此文件的绝对路径，包括文件名。默认值 os.path.join(BASE_DIR, 'db.sqlite3') 将会把数据库文件储存在项目的根目录。

  如果你不使用 SQLite，则必须添加一些额外设置，比如 USER 、 PASSWORD 、 HOST 等等。想了解更多数据库设置方面的内容，请看文档：DATABASES 。

  注意: 配置时注意提前创建好对应库

  DATABASES = {
      'default': {
          'ENGINE': 'django.db.backends.mysql', # 属于什么数据库(例如:mysql)
          'NAME': 'bookmanager',   # 数据库的名称
          'HOST': '127.0.0.1',     # 数据库地址
          'PORT': 3306,            # port
          'USER': 'user',          # 用户
          'PASSWORD': 'password'   # 密码
      }
  }
  
  # 使用pymysql替换MySQLdb模块
  import pymysql
  pymysql.install_as_MySQLdb()
  

• 静态文件的配置(如CSS,js,image)

STATIC_URL = '/static/'  # 静态文件的别名
STATICFILES_DIRS = [
    os.path.join(BASE_DIR, 'static')
]

URL调度(路由)

官方文档: https://docs.djangoproject.com/zh-hans/2.2/topics/http/urls/

摘录博客:https://www.cnblogs.com/maple-shaw/articles/9282718.html

URL配置(URLconf)就像Django所支撑网站的目录.

它的本质是URL 与要 为该URL调用的试图函数之间的映射表

URLconf配置

基本格式

urlpatterns = [
	url(正则表达式,View视图, 参数, 别名),
]

示例

urlpatterns = [
    url(r'^book/$',views.book,name='book'),
    url(r'^book_add/$', views.BookAdd.as_view(), name='book_add'),
    url(r'^book_edit/(?P<pk>\d+)/$', views.BookEdit.as_view(), name='book_edit'),
    url(r'^(\w+)/del/(\d+)/$',views.delete, name='del'),
]

参数说明

• 正则表达式: 一个正则表达式字符串
• views试图: 一个可调用对象,通常为一个视图函数
• 参数: 可选的要传递给视图函数的默认参数 (字典形式)
• 别名: 一个可选的name参数

注意：

Django 2.0版本中的路由系统是下面的写法（官方文档）：

2.0版本path函数

2.0版本中re_path和1.11版本的url是一样的用法。

URLconfs中使用的函数 path（route，view，kwargs = None，name = None )

例如：

from django.urls import include, path

urlpatterns = [
    path('index/', views.index, name='main-view'),
    path('bio/<username>/', views.bio, name='bio'),
    path('articles/<slug:title>/', views.article, name='article-detail'),
    path('articles/<slug:title>/<int:section>/', views.section, name='article-section'),
    path('weblog/', include('blog.urls')),
]

route

route 是一个匹配 URL 的准则（类似正则表达式）。当 Django 响应一个请求时，它会从 urlpatterns 的第一项开始，按顺序依次匹配列表中的项，直到找到匹配的项。

这些准则不会匹配 GET 和 POST 参数或域名。例如，URLconf 在处理请求 https://www.example.com/myapp/ 时，它会尝试匹配 myapp/ 。处理请求 https://www.example.com/myapp/?page=3 时，也只会尝试匹配 myapp/。

view

当 Django 找到了一个匹配的准则，就会调用这个特定的视图函数，并传入一个 HttpRequest 对象作为第一个参数，被“捕获”的参数以关键字参数的形式传入。稍后，我们会给出一个例子。

kwargs

任意个关键字参数可以作为一个字典传递给目标视图函数。本教程中不会使用这一特性。

name

为你的 URL 取名能使你在 Django 的任意地方唯一地引用它，尤其是在模板中。这个有用的特性允许你只改一个文件就能全局地修改某个 URL 模式。

正则表达式详解

基本配置

from django.conf.urls import url

from . import views

urlpatterns = [
    url(r'^articles/2003/$', views.special_case_2003),
    url(r'^articles/([0-9]{4})/$', views.year_archive),
    url(r'^articles/([0-9]{4})/([0-9]{2})/$', views.month_archive),
    url(r'^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail),
]

注意事项

1. urlpatterns中的元素按照书写顺序从上往下逐一匹配正则表达式，一旦匹配成功则不再继续。
2. 若要从URL中捕获一个值，只需要在它周围放置一对圆括号（分组匹配）。
3. 不需要添加一个前导的反斜杠，因为每个URL 都有。例如，应该是^articles 而不是 ^/articles。
4. 每个正则表达式前面的’r’ 是可选的但是建议加上。

补充说明

# 是否开启URL访问地址后面不为/跳转至带有/的路径的配置项
APPEND_SLASH=True

Django settings.py配置文件中默认没有 APPEND_SLASH 这个参数，但 Django 默认这个参数为 APPEND_SLASH = True。 其作用就是自动在网址结尾加’/’。

其效果就是：

我们定义了urls.py：

from django.conf.urls import url
from app01 import views

urlpatterns = [
    url(r'^blog/$', views.blog),
]

访问 http://www.example.com/blog 时，默认将网址自动转换为 http://www.example/com/blog/ 。

如果在settings.py中设置了 APPEND_SLASH=False，此时我们再请求 http://www.example.com/blog 时就会提示找不到页面。

分组命名匹配

上面的示例中使用的是简单的正则表达式分组匹配(通过圆括号) 来捕获url中的值以位置传参的形式传递给视图

高级的用法中,可以使用分组命名匹配的正则表达式来捕获url中的值并以关键字参数的形式传递给视图

在python的匹配模式中,分组命名正则表达式组的语法是(?P<name>pattern),其中name为分组的名称,pattern是要匹配的模式

下面是已URLconf命名组的重写:

from django.conf.urls import url

from . import views

urlpatterns = [
    url(r'^articles/2003/$', views.special_case_2003),
    url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),
    url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$', views.month_archive),
    url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/(?P<day>[0-9]+)/$', views.article_detail),
]

这个实现与前面的示例完全相同,只有一个细微的差别: 捕获的值作为关键字参数而不是位置参数传递给是凸函数

例如:相当于URL /articles/2017/12/相当于以下的方式调用视图函数

views.month_archive(request, year="2017",month="12")

在实际应用中，使用分组命名匹配的方式可以让你的URLconf 更加明晰且不容易产生参数顺序问题的错误，但是有些开发人员则认为分组命名组语法太丑陋、繁琐。

至于究竟应该使用哪一种，你可以根据自己的喜好来决定。

URLconf中的配置

URLconf 在请求的url中查找,将它当作一个普通的字符串. 不包括GET和POST参数以及域名

例如:

http://www.example.com/myapp/ get请求中 , URLconf将查找myapp

http://www.example.com/myapp/?page=3 请求中，URLconf 仍将查找 /myapp/ 。

urlconf不检查请求的方法. 换句话来讲,所有的请求方法 ---- 同一个URL的POST,GET,HEAD等等都将会路由到相同的函数下

捕获到的参数永远都是字符串

每个在URLconf中捕获的参数都作为一个普通的字符串传递给视图,无论正则表达式使用的什么匹配方式,

例如:

url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),

传递给视图函数views.year_archive()中的year永远是一个字符串

视图函数指定默认值

from django.conf.urls import url
from . import views

urlpatterns = [
    url(r'^blog/$', views.page),
    url(r'^blog/page(?P<num>[0-9]+)/$', views.page),
]

# views.py中，可以为num指定默认值
def page(request, num="1"):
    pass

在上面的例子中，两个URL模式指向相同的view - views.page - 但是第一个模式并没有从URL中捕获任何东西。

如果第一个模式匹配上了，page()函数将使用其默认参数num=“1”,如果第二个模式匹配，page()将使用正则表达式捕获到的num值。

路由分发 (include其他的URLconfs)

该函数采用完整的Python导入路径到该位置应“包括”到另一个URLconf模块的路径。（可选）还可以指定条目将包含在其中的应用程序名称空间和实例名称空间。

通常，应用程序名称空间应由包含的模块指定。如果设置了应用程序名称空间，则该namespace参数可用于设置其他实例名称空间。

include() 还接受返回URL模式的iterable或包含该iterable的2元组以及应用程序名称空间的名称作为参数。

语法格式

include（module，namespace = None）

include（pattern_list）

include（（pattern_list，app_namespace），namespace = None

参数：

• module -URLconf模块（或模块名称）
• 名称空间（str）-包含URL条目的实例名称空间
• pattern_list-path()和/或re_path()实例的可迭代。
• app_namespace（str）-包含URL条目的应用程序名称空间

函数 include() 允许引用其它 URLconfs。每当 Django 遇到 include() 时，它会截断与此项匹配的 URL 的部分，并将剩余的字符串发送到 URLconf 以供进一步处理。

当包括其它 URL 模式时你应该总是使用 include() ， admin.site.urls 是唯一例外。

from django.conf.urls import include, url

urlpatterns = [
   url(r'^admin/', admin.site.urls),
   url(r'^blog/', include('blog.urls')),  # 可以包含其他的URLconfs文件
]

URL的命名和反向解析

在一个真实的 Django 项目中，可能会有五个，十个，二十个，甚至更多应用。Django 如何分辨重名的 URL 呢？举个例子，polls 应用有 detail 视图，可能另一个博客应用也有同名的视图。Django 如何知道 {% url %} 标签到底对应哪一个应用的 URL 呢？

不需要写死URL代码了，只需要通过名字来调用当前的URL。

答案是：在根 URLconf 中添加命名空间。在 polls/urls.py 文件中稍作修改，加上 app_name 设置命名空间：

url(r'^home', views.home, name='home'),  # 给我的url匹配模式起名为 home
url(r'^index/(\d*)', views.index, name='index'),  # 给我的url匹配模式起名为index

模板使用

{% url 'home' %}

view视图使用

from django.urls import reverse

reverse("index", args=("2018", ))

参数传递

# 模板:
{% url 'pub_del' '10' %}    _>   # '/app01/publisher/del/10/'   位置传参
{% url 'pub_del' pk='10' %}    _>  # '/app01/publisher/del/10/'   关键字传参

# py文件:
from django.urls import reverse
reverse('pub_del',args=(11,))     # '/app01/publisher/del/11/'     位置传参
reverse('pub_del',kwargs={'pk':'11'})     # '/app01/publisher/del/11/'   关键字传参

例子：

考虑下面的URLconf：

from django.conf.urls import url

from . import views

urlpatterns = [
    # ...
    url(r'^articles/([0-9]{4})/$', views.year_archive, name='news-year-archive'),
    # ...
]

根据这里的设计，某一年nnnn对应的归档的URL是/articles/nnnn/。

你可以在模板的代码中使用下面的方法获得它们：

<a href="{% url 'news-year-archive' 2012 %}">2012 Archive</a>

<ul>
{% for yearvar in year_list %}
<li><a href="{% url 'news-year-archive' yearvar %}">{{ yearvar }} Archive</a></li>
{% endfor %}
</ul>

在Python 代码中，这样使用：

from django.urls import reverse
from django.shortcuts import redirect

def redirect_to_year(request):
    # ...
    year = 2006
    # ...
    return redirect(reverse('news-year-archive', args=(year,)))

如果出于某种原因决定按年归档文章发布的URL应该调整一下，那么你将只需要修改URLconf 中的内容。

在某些场景中，一个视图是通用的，所以在URL 和视图之间存在多对一的关系。对于这些情况，当反查URL 时，只有视图的名字还不够。

命名空间模式

namespace 避免name重名

即使不同的APP使用相同的URL名称，URL的命名空间模式也可以让你唯一反转命名的URL。

即使不同的APP使用相同的URL名称，URL的命名空间模式也可以让你唯一反转命名的URL。

举个例子：

project中的urls.py

from django.conf.urls import url, include
 
urlpatterns = [
    url(r'^app01/', include('app01.urls', namespace='app01')),
    url(r'^app02/', include('app02.urls', namespace='app02')),
]

app01中的urls.py

from django.conf.urls import url
from app01 import views
 
app_name = 'app01'
urlpatterns = [
    url(r'^(?P<pk>\d+)/$', views.detail, name='detail')
]

app02中的urls.py

from django.conf.urls import url
from app02 import views
 
app_name = 'app02'
urlpatterns = [
    url(r'^(?P<pk>\d+)/$', views.detail, name='detail')
]

现在，我的两个app中 url名称重复了，我反转URL的时候就可以通过命名空间的名称得到我当前的URL。

语法：

‘命名空间名称:URL名称’

模板中使用：

{% url 'app01:detail' pk=12 pp=99 %}

views中的函数中使用

v = reverse('app01:detail', kwargs={'pk':11})

这样即使app中URL的命名相同，我也可以反转得到正确的URL了。

视图

摘录博客: https://www.cnblogs.com/maple-shaw/articles/9285269.html

一个视图函数（类），简称视图，是一个简单的Python 函数（类），它接受Web请求并且返回Web响应。

响应可以是一张网页的HTML内容，一个重定向，一个404错误，一个XML文档，或者一张图片。

无论视图本身包含什么逻辑，都要返回响应。代码写在哪里也无所谓，只要它在你当前项目目录下面。除此之外没有更多的要求了——可以说“没有什么神奇的地方”。为了将代码放在某处，大家约定成俗将视图放置在项目（project）或应用程序（app）目录中的名为views.py的文件中。

一个简单的视图

下面是一个以HTML文档的形式返回当前日期和时间的视图：

from django.http import HttpResponse
import datetime

def current_datetime(request):
    now = datetime.datetime.now()
    html = "<html><body>It is now %s.</body></html>" % now
    return HttpResponse(html)

让我们来逐行解释下上面的代码：

• 首先，我们从 django.http模块导入了HttpResponse类，以及Python的datetime库。

• 接着，我们定义了current_datetime函数。它就是视图函数。每个视图函数都使用HttpRequest对象作为第一个参数，并且通常称之为request。

  注意，视图函数的名称并不重要；不需要用一个统一的命名方式来命名，以便让Django识别它。我们将其命名为current_datetime，是因为这个名称能够比较准确地反映出它实现的功能。

• 这个视图会返回一个HttpResponse对象，其中包含生成的响应。每个视图函数都负责返回一个HttpResponse对象。

Django使用请求和响应对象来通过系统传递状态。

当浏览器向服务端请求一个页面时，Django创建一个HttpRequest对象，该对象包含关于请求的元数据。然后，Django加载相应的视图，将这个HttpRequest对象作为第一个参数传递给视图函数。

每个视图负责返回一个HttpResponse对象。

CBV和FBV

我们之前写过的都是基于函数的view，就叫FBV。还可以把view写成基于类的 就叫CBV。

FBV (function based view )

def index(request):
	# 逻辑
	return reponse

CBV (class based view )

from django.views import View
class PublisherAdd(View):
    
    def get(self,request,*args,**kwargs):
        # 处理GET请求的逻辑
        return response
    
    def post(self,request,*args,**kwargs):
        # 处理GET请求的逻辑
        return response

使用CBV时，urls.py中也做对应的修改：

url(r'^publisher/add/$', views.PublisherAdd.as_view(), name='pub_add'),

as_view()的流程:

1. self.request= request
2. 通过反射获取对应请求方式(GET)对应的方法(get)

给视图加装饰器

使用装饰器装饰FBV

FBV本身就是一个函数，所以和给普通的函数加装饰器无差：

def wrapper(func):
    def inner(*args, **kwargs):
        start_time = time.time()
        ret = func(*args, **kwargs)
        end_time = time.time()
        print("used:", end_time-start_time)
        return ret
    return inner


# FBV版添加班级
@wrapper
def add_class(request):
    if request.method == "POST":
        class_name = request.POST.get("class_name")
        models.Classes.objects.create(name=class_name)
        return redirect("/class_list/")
    return render(request, "add_class.html")

给CBV加装饰器的方法:

类中的方法与独立函数不完全相同，因此不能直接将函数装饰器应用于类中的方法 ，我们需要先将其转换为方法装饰器。

Django中提供了method_decorator装饰器用于将函数装饰器转换为方法装饰器。

from django.utils.decorators import method_decorator  # 推荐使用

1 加在方法上:

@method_decorator(timer)
def get(self, request, *args, **kwargs):

2 加在dispatch方法上

@method_decorator(timer)
def dispatch(self, request, *args, **kwargs):
    ret = super().dispatch(request, *args, **kwargs)
    return ret
    
@method_decorator(timer,name='dispatch')  # 推荐使用
class PublisherAdd(View):

3 加在类上

@method_decorator(timer,name='post')
@method_decorator(timer,name='get')
class PublisherAdd(View):

Request对象和Response对象

request对象

当一个页面被请求时，Django就会创建一个包含本次请求原信息的HttpRequest对象。
Django会将这个对象自动传递给响应的视图函数，一般视图函数约定俗成地使用 request 参数承接这个对象。

官方文档

request属性

所有的属性应该被认为是只读的，除非另有说明。

属性	含义
request.method	一个字符串，表示请求使用的HTTP 方法
request.GET	一个类似于字典的对象，包含 HTTP GET 的所有参数
request.POST	一个类似于字典的对象，如果请求中包含表单数据，编码是urlencode才有数据
request.path_info	返回用户访问url，不包含IP和端口 也不包含查询参数
request.body	请求体，byte类型 request.POST的数据就是从body里面提取到的
request.session	一个既可读又可写的类似于字典的对象，表示当前的会话。
request.COOKIES	一个标准的Python 字典，包含所有的cookie。键和值都为字符串。
request.FILES	一个类似于字典的对象，包含所有的上传文件信息。
request.META	一个标准的Python 字典，包含所有的HTTP 首部。具体的头部信息取决于客户端和服务器，

上传文件示例代码

def upload(request):
    """
    保存上传文件前，数据需要存放在某个位置。默认当上传文件小于2.5M时，django会将上传文件的全部内容读进内存。从内存读取一次，写磁盘一次。
    但当上传文件很大时，django会把上传文件写到临时文件中，然后存放到系统临时文件夹中。
    :param request: 
    :return: 
    """
    if request.method == "POST":
        # 从请求的FILES中获取上传文件的文件名，file为页面上type=files类型input的name属性值
        filename = request.FILES["file"].name
        # 在项目目录下新建一个文件
        with open(filename, "wb") as f:
            # 从上传的文件对象中一点一点读
            for chunk in request.FILES["file"].chunks():
                # 写入本地文件
                f.write(chunk)
        return HttpResponse("上传OK")

request方法

方法	含义
request.get_full_path()	返回 path，不包含IP和端口 包含查询参数
request.is_ajax()	是否ajax请求,返回布尔值

注意：键值对的值是多个的时候,比如checkbox类型的input标签，select标签，需要用：

request.POST.getlist("hobby")

response对象

与由Django自动创建的HttpRequest对象相比，HttpResponse对象是我们的职责范围了。我们写的每个视图都需要实例化，填充和返回一个HttpResponse。

HttpResponse类位于django.http模块中。

使用

传递字符串

from django.http import HttpResponse
response = HttpResponse("Here's the text of the Web page.")
response = HttpResponse("Text only, please.", content_type="text/plain")

设置或删除响应头信息

response = HttpResponse()
response['Content-Type'] = 'text/html; charset=UTF-8'
del response['Content-Type']

属性

HttpResponse.content：响应内容

HttpResponse.charset：响应内容的编码

HttpResponse.status_code：响应的状态码

方法

HttpReponse('字符串')  # 返回字符串
render(request,'模板的路径',{})   #  返回一个HTML页面 
redirect(重定向的地址)   重定向 # 响应头  Location:地址

JsonResponse对象

JsonResponse是HttpResponse的子类，专门用来生成JSON编码的响应。

from django.http import JsonResponse

response = JsonResponse({'foo': 'bar'})
print(response.content)

b'{"foo": "bar"}'

默认只能传递字典类型，如果要传递非字典类型需要设置一下safe关键字参数。

response = JsonResponse([1, 2, 3], safe=False)

Django shortcut functions

官方文档

render()

结合一个给定的模板和一个给定的上下文字典，并返回一个渲染后的 HttpResponse 对象。

参数：

• request： 用于生成响应的请求对象。
• template_name：要使用的模板的完整名称，可选的参数
• context：添加到模板上下文的一个字典。默认是一个空字典。如果字典中的某个值是可调用的，视图将在渲染模板之前调用它。
• content_type：生成的文档要使用的MIME类型。默认为 DEFAULT_CONTENT_TYPE 设置的值。默认为’text/html’
• status：响应的状态码。默认为200。
• useing: 用于加载模板的模板引擎的名称。

一个简单的例子：

from django.shortcuts import render

def my_view(request):
    # 视图的代码写在这里
    return render(request, 'myapp/index.html', {'foo': 'bar'})

上面的代码等于：

from django.http import HttpResponse
from django.template import loader

def my_view(request):
    # 视图代码写在这里
    t = loader.get_template('myapp/index.html')
    c = {'foo': 'bar'}
    return HttpResponse(t.render(c, request))

redirect()

参数可以是：

• 一个模型：将调用模型的get_absolute_url() 函数
• 一个视图，可以带有参数：将使用urlresolvers.reverse 来反向解析名称
• 一个绝对的或相对的URL，将原封不动的作为重定向的位置。

默认返回一个临时的重定向；传递permanent=True 可以返回一个永久的重定向。

示例:

你可以用多种方式使用redirect() 函数。

传递一个具体的ORM对象（了解即可）

将调用具体ORM对象的get_absolute_url() 方法来获取重定向的URL：

from django.shortcuts import redirect
 
def my_view(request):
    ...
    object = MyModel.objects.get(...)
    return redirect(object)

传递一个视图的名称

def my_view(request):
    ...
    return redirect('some-view-name', foo='bar')

传递要重定向到的一个具体的网址

def my_view(request):
    ...
    return redirect('/some/url/')

当然也可以是一个完整的网址

def my_view(request):
    ...
    return redirect('http://example.com/')

默认情况下，redirect() 返回一个临时重定向。以上所有的形式都接收一个permanent 参数；如果设置为True，将返回一个永久的重定向：

def my_view(request):
    ...
    object = MyModel.objects.get(...)
    return redirect(object, permanent=True)　　

模板

• 官方文档: https://docs.djangoproject.com/en/1.11/ref/templates/language/

• 摘录博客: https://www.cnblogs.com/maple-shaw/articles/9333821.html

常用语法

{{ 变量 }}  # 表示变量，在模板渲染的时候替换成值
{%  %}   # 表示逻辑相关的代码

点（.）在模板语言中有特殊的含义，用来获取对象的相应属性值。

模板中支持的写法：

{{  变量 }}   没有 []  ()  写法

{{ 变量.   }}    .索引  .key   .属性 .方法

注：当模板系统遇到一个（.）时，会按照如下的顺序去查询：

1. 在字典中查询
2. 属性或者方法
3. 数字索引

Filters 过滤器

翻译为过滤器，用来修改变量的显示结果。

语法： {{ value|filter_name:参数 }}

':'左右没有空格没有空格没有空格

内置的过滤器

default 默认值

{{ xxx|default:"没有这个变量" }}  # 变量不存在或者为空时候使用默认值
# 注：TEMPLATES的OPTIONS可以增加一个选项：string_if_invalid：'找不到'，可以替代default的的作用。

filesizeformat 格式化文件大小

将值格式化为一个 “人类可读的” 文件大小 （例如 ‘13 KB’, ‘4.1 MB’, ‘102 bytes’, 等等）。例如：

{{ value|filesizeformat }}

如果 value 是 123456789，输出将会是 117.7 MB。

add 计算 拼接

{{ a|add:b }}  # 数字的加减法  字符串的拼接  列表的拼接

{{ value|add:"2" }}
# value是数字4，则输出结果为6。

{{ first|add:second }}
# 如果first是 [1,.2,3] ，second是 [4,5,6] ，那输出结果是 [1,2,3,4,5,6] 。

length 统计长度

{{ [1,32,]|length }}   # 2 
# 返回value的长度，如 value=['a', 'b', 'c', 'd']的话，就显示4.

slice 切片

{{ l1|slice:'::-1' }}
{{value|slice:"2:-1"}}

first 取第一个元素

{{ value|first }}

last 取最后一个元素

{{ value|last }}

join 字符串拼接

使用字符串拼接列表。同python的str.join(list)。

{{ value|join:" // " }}

truncatechars truncatewords

如果字符串字符多于指定的字符数量，那么会被截断。截断的字符串将以可翻译的省略号序列（“…”）结尾。

参数：截断的字符数

{{ "如果字符串字符多于指定的字符数量，那么会被截断。截断的字符串将以可翻译的省略号"|truncatechars:'10' }}

{{ "如果 字符串 字符 多于 指定的字符数量，那么会被截断。截断的字符串将以可翻译的省略号"|truncatewords:'4' }}

date

日期格式化

{{ now|date:'Y-m-d H:i:s' }}

safe

# 告诉django,当前的内容是安全的,不需要做转义
value = "<a href='#'>点我</a>"
{{ value|safe}}

自定义filter

自定义过滤器只是带有一个或两个参数的Python函数:

• 变量（输入）的值 - -不一定是一个字符串
• 参数的值 - 这可以有一个默认值，或完全省略

例如，在过滤器{{var | foo：“bar”}}中，过滤器foo将传递变量var和参数**“bar”**。

自定义filter代码文件摆放位置：

app01/
    __init__.py
    models.py
    templatetags/  # 在app01下面新建一个package package
        __init__.py
        app01_filters.py  # 建一个存放自定义filter的py文件
    views.py

编写自定义filter

from django import template
register = template.Library()


@register.filter
def fill(value, arg):
    return value.replace(" ", arg)


@register.filter(name="addSB")
def add_sb(value):
    return "{} SB".format(value)

使用自定义filter

{# 先导入我们自定义filter那个文件 #}
{% load app01_filters %}

{# 使用我们自定义的filter #}
{{ somevariable|fill:"__" }}
{{ d.name|addSB }}

Tags

for

<ul>
{% for user in user_list %}
    <li>{{ user.name }}</li>
{% endfor %}
</ul>

for循环可用的一些参数：

变量	描述
forloop.counter	循环的当前迭代（1索引）
forloop.counter0	循环的当前迭代（0索引）
forloop.revcounter	从循环末尾开始的迭代次数（1索引）
forloop.revcounter0	从循环末尾开始的迭代次数（0索引）
forloop.first	如果这是第一次循环，则为真
forloop.last	如果这是最后一次循环，则为true
forloop.parentloop	对于嵌套循环，这是围绕当前循环的循环

for … empty

<ul>
{% for user in user_list %}
    <li>{{ user.name }}</li>
{% empty %}
    <li>空空如也</li>
{% endfor %}
</ul>

if,elif和else

{% if user_list %}
  用户人数：{{ user_list|length }}
{% elif black_list %}
  黑名单数：{{ black_list|length }}
{% else %}
  没有用户
{% endif %}

当然也可以只有if和else

{% if user_list|length > 5 %}
  七座豪华SUV
{% else %}
    黄包车
{% endif %}

if语句支持 and 、or、==、>、<、!=、<=、>=、in、not in、is、is not判断。

if 判断不支持算数运算 不支持连续判断

with

定义一个中间变量

{% with total=business.employees.count %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}

csrf_token

这个标签用于跨站请求伪造保护。

在form标签中使用{% csrf_token %}标签,就可以提交POST请求.

在页面的form表单里面写上{% csrf_token %}

注释

{# ... #}

注意事项

1. Django的模板语言不支持连续判断，即不支持以下写法：

{% if a > b > c %}
...
{% endif %}

\2. Django的模板语言中属性的优先级大于方法

def xx(request):
    d = {"a": 1, "b": 2, "c": 3, "items": "100"}
    return render(request, "xx.html", {"data": d})

如上，我们在使用render方法渲染一个页面的时候，传的字典d有一个key是items并且还有默认的 d.items() 方法，此时在模板语言中:

{{ data.items }}

默认会取d的items key的值。

母版

注意：我们通常会在母板中定义页面专用的CSS块和JS块，方便子页面替换。

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="x-ua-compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Title</title>
  {% block page-css %}
  
  {% endblock %}
</head>
<body>

<h1>这是母板的标题</h1>

{% block page-main %}

{% endblock %}
<h1>母板底部内容</h1>
{% block page-js %}

{% endblock %}
</body>
</html>

继承母板

在子页面中在页面最上方使用下面的语法来继承母板。

{% extends 'layouts.html' %}

块 block

通过在母板中使用{% block xxx %}来定义"块"。

在子页面中通过定义母板中的block名来对应替换母板中相应的内容。

{% block page-main %}
  <p>世情薄</p>
  <p>人情恶</p>
  <p>雨送黄昏花易落</p>
{% endblock %}

组件

可以将常用的页面内容如导航条，页尾信息等组件保存在单独的文件中，然后在需要使用的地方按如下语法导入即可。

{% include 'navbar.html' %}

静态文件相关

{% load static %}
<img src="{% static "images/hi.jpg" %}" alt="Hi!" />

引用JS文件时使用：

{% load static %}
<script src="{% static "mytest.js" %}"></script>

某个文件多处被用到可以存为一个变量

{% load static %}
{% static "images/hi.jpg" as myphoto %}
<img src="{{ myphoto }}"></img>

使用get_static_prefix

{% load static %}
<img src="{% get_static_prefix %}images/hi.jpg" alt="Hi!" />

或者

{% load static %}
{% get_static_prefix as STATIC_PREFIX %}

<img src="{{ STATIC_PREFIX }}images/hi.jpg" alt="Hi!" />
<img src="{{ STATIC_PREFIX }}images/hi2.jpg" alt="Hello!" />

ORM 模型

ORM概念

对象关系映射 全称(Object Relational Mapping) 简称ORM 模式是一种为了解决面向对象与关系型数据库存在的互不匹配的现象的技术.

简单来说, ORM是通过使用描述对象和数据库之间映射的元数据, 将程序中的对象自动持久化到关系数据库中

ORM在业务逻辑层面和数据库之间充当了桥梁的作用

ORM由来

让我们从O/R开始。字母O起源于"对象"(Object)，而R则来自于"关系"(Relational)。

几乎所有的软件开发过程中都会涉及到对象和关系数据库。在用户层面和业务逻辑层面，我们是面向对象的。当对象的信息发生变化的时候，我们就需要把对象的信息保存在关系数据库中。

按照之前的方式来进行开发就会出现程序员会在自己的业务逻辑代码中夹杂很多SQL语句用来增加、读取、修改、删除相关数据，而这些代码通常都是极其相似或者重复的。

ORM的优势

ORM解决的主要问题是对象和关系的映射。它通常将一个类和一张表一一对应，类的每个实例对应表中的一条记录，类的每个属性对应表中的每个字段。

ORM提供了对数据库的映射，不用直接编写SQL代码，只需操作对象就能对数据库操作数据。

让软件开发人员专注于业务逻辑的处理，提高了开发效率。

ORM的劣势

ORM的缺点是会在一定程度上牺牲程序的执行效率。

ORM的操作是有限的，也就是ORM定义好的操作是可以完成的，一些复杂的查询操作是完成不了。

ORM用多了SQL语句就不会写了，关系数据库相关技能退化…

ORM总结

ORM只是一种工具，工具确实能解决一些重复，简单的劳动。这是不可否认的。

但我们不能指望某个工具能一劳永逸地解决所有问题，一些特殊问题还是需要特殊处理的。

但是在整个软件开发过程中需要特殊处理的情况应该都是很少的，否则所谓的工具也就失去了它存在的意义。

Django中的ORM

Django项目使用MySQL数据库

1. 在Django项目的settings.py文件中，配置数据库连接信息：

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'bookmanager',
        'HOST': '127.0.0.1',
        'PORT': 3306,
        'USER': 'root',
        'PASSWORD': "123456"
    }
}

2. 在与Django项目同名的目录下的__init__.py文件中写如下代码，告诉Django使用pymysql模块连接MySQL数据库:

import pymysql

pymysql.install_as_MySQLdb()

注：数据库迁移的时候出现一个警告

原因是因为: 数据库没有设置严格模式

WARNINGS: 
?: (mysql.W002) MySQL Strict Mode is not set for database connection 'default'
HINT: MySQL's Strict Mode fixes many data integrity problems in MySQL, such as data truncation upon insertion, by escalating warnings into errors. It is strongly recommended you activate it.

在配置中多加一个OPTIONS参数：Django官网解释

 'OPTIONS': {
    'init_command': "SET sql_mode='STRICT_TRANS_TABLES'"},

Model

在Django中model是你数据的单一、明确的信息来源。它包含了你存储的数据的重要字段和行为。通常，一个模型（model）映射到一个数据库表。

基本情况：

• 每个模型都是一个Python类，它是django.db.models.Model的子类。
• 模型的每个属性都代表一个数据库字段。
• 综上所述，Django为您提供了一个自动生成的数据库访问API，详询官方文档链接。

快速入门

下面这个例子定义了一个 Person 模型，包含 first_name 和 last_name。

from django.db import models
 
class Person(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)

first_name 和 last_name 是模型的字段。每个字段被指定为一个类属性，每个属性映射到一个数据库列。

上面的 Person 模型将会像这样创建一个数据库表：

CREATE TABLE myapp_person (
    "id" serial NOT NULL PRIMARY KEY,
    "first_name" varchar(30) NOT NULL,
    "last_name" varchar(30) NOT NULL
);

一些说明：

• 表myapp_person的名称是自动生成的，如果你要自定义表名，需要在model的Meta类中指定 db_table 参数，强烈建议使用小写表名，特别是使用MySQL作为数据库时。
• id字段是自动添加的，如果你想要指定自定义主键，只需在其中一个字段中指定 primary_key=True 即可。如果Django发现你已经明确地设置了Field.primary_key，它将不会添加自动ID列。
• 本示例中的CREATE TABLE SQL使用PostgreSQL语法进行格式化，但值得注意的是，Django会根据配置文件中指定的数据库类型来生成相应的SQL语句。
• Django支持MySQL5.5及更高版本。

字段

常用字段

AutoField

自增的整形字段，必填参数primary_key=True，则成为数据库的主键。无该字段时，django自动创建。

一个model不能有两个AutoField字段。

IntegerField

一个整数类型。数值的范围是 -2147483648 ~ 2147483647。

CharField

字符类型，必须提供max_length参数。max_length表示字符的长度。

DateField

日期类型，日期格式为YYYY-MM-DD，相当于Python中的datetime.date的实例。

参数：

• auto_now：每次修改时修改为当前日期时间。
• auto_now_add：新创建对象时自动添加当前日期时间。

auto_now和auto_now_add和default参数是互斥的，不能同时设置。

DatetimeField

日期时间字段，格式为YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]，相当于Python中的datetime.datetime的实例。

字段类型，详情可点击查询官网。

字段类型

    AutoField(Field)
        - int自增列，必须填入参数 primary_key=True

    BigAutoField(AutoField)
        - bigint自增列，必须填入参数 primary_key=True

        注：当model中如果没有自增列，则自动会创建一个列名为id的列
        from django.db import models

        class UserInfo(models.Model):
            # 自动创建一个列名为id的且为自增的整数列
            username = models.CharField(max_length=32)

        class Group(models.Model):
            # 自定义自增列
            nid = models.AutoField(primary_key=True)
            name = models.CharField(max_length=32)

    SmallIntegerField(IntegerField):
        - 小整数 -32768 ～ 32767

    PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正小整数 0 ～ 32767

    IntegerField(Field)
        - 整数列(有符号的) -2147483648 ～ 2147483647

    PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正整数 0 ～ 2147483647

    BigIntegerField(IntegerField):
        - 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807

    BooleanField(Field)
        - 布尔值类型

    NullBooleanField(Field):
        - 可以为空的布尔值

    CharField(Field)
        - 字符类型
        - 必须提供max_length参数， max_length表示字符长度

    TextField(Field)
        - 文本类型

    EmailField(CharField)：
        - 字符串类型，Django Admin以及ModelForm中提供验证机制

    IPAddressField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制

    GenericIPAddressField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
        - 参数：
            protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
            unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启此功能，需要protocol="both"

    URLField(CharField)
        - 字符串类型，Django Admin以及ModelForm中提供验证 URL

    SlugField(CharField)
        - 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号）

    CommaSeparatedIntegerField(CharField)
        - 字符串类型，格式必须为逗号分割的数字

    UUIDField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证

    FilePathField(Field)
        - 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能
        - 参数：
                path,                      文件夹路径
                match=None,                正则匹配
                recursive=False,           递归下面的文件夹
                allow_files=True,          允许文件
                allow_folders=False,       允许文件夹

    FileField(Field)
        - 字符串，路径保存在数据库，文件上传到指定目录
        - 参数：
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件，默认django.core.files.storage.FileSystemStorage

    ImageField(FileField)
        - 字符串，路径保存在数据库，文件上传到指定目录
        - 参数：
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件，默认django.core.files.storage.FileSystemStorage
            width_field=None,   上传图片的高度保存的数据库字段名（字符串）
            height_field=None   上传图片的宽度保存的数据库字段名（字符串）

    DateTimeField(DateField)
        - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]

    DateField(DateTimeCheckMixin, Field)
        - 日期格式      YYYY-MM-DD

    TimeField(DateTimeCheckMixin, Field)
        - 时间格式      HH:MM[:ss[.uuuuuu]]

    DurationField(Field)
        - 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型

    FloatField(Field)
        - 浮点型

    DecimalField(Field)
        - 10进制小数
        - 参数：
            max_digits，小数总长度
            decimal_places，小数位长度

    BinaryField(Field)
        - 二进制类型

示例

class User(models.Model):
    uid = models.AutoField(primary_key=True)
    name = models.CharField(verbose_name='用户名',max_length=32,db_column='username',unique=True)  # varchar(32)
    age = models.IntegerField(verbose_name='年龄',blank=True, null=True)  # 整数
    bitrh = models.DateTimeField(verbose_name='生日',auto_now=True)
    # auto_now_add=True  新增数据时保存当前的时间
    # auto_now=True      新增和编辑数据时保存当前的时间
    phone = MyCharField(11,verbose_name='手机号')
    gender = models.BooleanField(choices=((True,'男'),(False,'女')))
  

# 外键
class Book(models.Model):
    title = models.CharField(max_length=32)
    pub = models.ForeignKey('Publisher', on_delete=models.CASCADE)
    # CASCADE 级连删除   on_delete 2.0 版本后是必填项
    # SET
    # SET_DEFAULT
    # SET_NULL    null=True
    # DO_NOTHING
    # PROTECT

自定义字段

Django字段与数据库字段类型的对应关系

class UnsignedIntegerField(models.IntegerField):
    def db_type(self, connection):
        return 'integer UNSIGNED'

# PS: 返回值为字段在数据库中的属性。
# Django字段与数据库字段类型对应关系如下：
    'AutoField': 'integer AUTO_INCREMENT',
    'BigAutoField': 'bigint AUTO_INCREMENT',
    'BinaryField': 'longblob',
    'BooleanField': 'bool',
    'CharField': 'varchar(%(max_length)s)',
    'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
    'DateField': 'date',
    'DateTimeField': 'datetime',
    'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
    'DurationField': 'bigint',
    'FileField': 'varchar(%(max_length)s)',
    'FilePathField': 'varchar(%(max_length)s)',
    'FloatField': 'double precision',
    'IntegerField': 'integer',
    'BigIntegerField': 'bigint',
    'IPAddressField': 'char(15)',
    'GenericIPAddressField': 'char(39)',
    'NullBooleanField': 'bool',
    'OneToOneField': 'integer',
    'PositiveIntegerField': 'integer UNSIGNED',
    'PositiveSmallIntegerField': 'smallint UNSIGNED',
    'SlugField': 'varchar(%(max_length)s)',
    'SmallIntegerField': 'smallint',
    'TextField': 'longtext',
    'TimeField': 'time',
    'UUIDField': 'char(32)',

自定义char类型字段

class MyCharField(models.Field):
    """
    自定义的char类型的字段类
    """
    def __init__(self, max_length, *args, **kwargs):
        self.max_length = max_length
        super(MyCharField, self).__init__(max_length=max_length, *args, **kwargs)
 
    def db_type(self, connection):
        """
        限定生成数据库表的字段类型为char，长度为max_length指定的值
        """
        return 'char(%s)' % self.max_length

使用自定义char类型字段：

class User(models.Model):
    uid = models.AutoField(primary_key=True)
    # 使用自定义的char类型的字段
    phone = MyCharField(11,verbose_name='手机号')

字段参数

    null                数据库中字段是否可以为空
    db_column           数据库中字段的列名
    default             数据库中字段的默认值
    primary_key         数据库中字段是否为主键
    db_index            数据库中字段是否可以建立索引
    unique              数据库中字段是否可以建立唯一索引
    unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引
    unique_for_month    数据库中字段【月】部分是否可以建立唯一索引
    unique_for_year     数据库中字段【年】部分是否可以建立唯一索引
 
    verbose_name        Admin中显示的字段名称
    blank               Admin中是否允许用户输入为空
    editable            Admin中是否可以编辑
    help_text           Admin中该字段的提示信息
    choices             Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
                        如：gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)
 
    error_messages      自定义错误信息（字典类型），从而定制想要显示的错误信息；
                        字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date
                        如：{'null': "不能为空.", 'invalid': '格式错误'}
 
    validators          自定义错误验证（列表类型），从而定制想要的验证规则
                        from django.core.validators import RegexValidator
                        from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\
                        MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
                        如：
                            test = models.CharField(
                                max_length=32,
                                error_messages={
                                    'c1': '优先错信息1',
                                    'c2': '优先错信息2',
                                    'c3': '优先错信息3',
                                },
                                validators=[
                                    RegexValidator(regex='root_\d+', message='错误了', code='c1'),
                                    RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),
                                    EmailValidator(message='又错误了', code='c3'), ]
                            )

Model Meta参数

class UserInfo(models.Model):
    nid = models.AutoField(primary_key=True)
    username = models.CharField(max_length=32)
 
    class Meta:
        # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名
        db_table = "table_name"
 
        # admin中显示的表名称
        verbose_name = '个人信息'
 
        # verbose_name加s
        verbose_name_plural = '所有用户信息'
 
        # 联合索引 
        index_together = [
            ("pub_date", "deadline"),   # 应为两个存在的字段
        ]
 
        # 联合唯一索引
        unique_together = (("driver", "restaurant"),)   # 应为两个存在的字段

必会的13中方法

import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "bookmanager.settings")
import django
django.setup()

from app02 import models

# all()  获取所有的数据  QuerySet   [ 对象,对象]
ret = models.User.objects.all()

# get()  获取一条数据  对象    查询不到或者多个的时候就报错
ret = models.User.objects.get(pk=1)

# filter()  获取满足条件的所有对象  QuerySet   [ 对象,对象]
ret = models.User.objects.filter(pk=1)

# exclude()  获取不满足条件的所有对象  QuerySet   [ 对象,对象]
ret = models.User.objects.exclude(pk=1)

# order_by() 排序  QuerySet   [ 对象,对象]   默认升序  降序给字段前+负号
ret = models.User.objects.order_by('age','uid')

# reverse() 反转  QuerySet   [ 对象,对象]  对已经排序的QuerySet生效
ret = models.User.objects.all().order_by('uid').reverse()

#  values()   不加参数 获取所有的字段名和值   QuerySet   [ 字典,字典]
#  values('uid','name')    指定参数   获取指定字段的名和值
ret  = models.User.objects.all().values('uid','name')
# for i in ret:
# #     print(i)
# #     print(i['uid'],i['name']) # i.uid i.name


#  values_list()   不加参数 获取所有的字段值   QuerySet   [ (),()]
#  values_list('name','uid')    指定参数   获取指定字段的值
ret  = models.User.objects.all().values_list('name','uid')
# for i in ret:
#     print(i)

# distinct  去重
ret  = models.User.objects.all().values('age').distinct()

#  first  取第一个元素  没有的话就是None
ret  = models.User.objects.filter(name='alex',age=85).first()

#  last  取最后一个元素  没有的话就是None
ret  = models.User.objects.filter(name='alex',age=85).last()

#  count  计数  len() __len__  count 比 len效率高
ret  = models.User.objects.all().count()

# exists  判断查询结果是否存在
ret = models.User.objects.filter(name='alex',age=84).exists()

print(ret)


"""
返回是QuerySet
all  
filter
exclude
order_by
reverse
values
values_list
distinct

返回对象
get
first
last 

返回数字
count

返回布尔值
exists
"""

单表查询双下划线

ret = models.User.objects.filter(pk=2)
ret = models.User.objects.filter(pk__gt=2)  # greater than  大于
ret = models.User.objects.filter(pk__gte=2)  # greater than  equal  大于等于
ret = models.User.objects.filter(pk__lt=2)  # less than  小于
ret = models.User.objects.filter(pk__lte=2)  # less than equal 小于等于
ret = models.User.objects.filter(pk__in=[1,3])  # 成员判断
ret = models.User.objects.filter(pk__range=[1,3])  # 范围
ret = models.User.objects.filter(name__contains='alex')  # like
ret = models.User.objects.filter(name__icontains='alex')  # 忽略大小写  包含

ret = models.User.objects.filter(name__startswith='alex')  # 以某某开头
ret = models.User.objects.filter(name__istartswith='alex')  # 以某某开头  忽略大小写

ret = models.User.objects.filter(name__endswith='alex')  # 以某某开头
ret = models.User.objects.filter(name__iendswith='alex')  # 以某某开头 忽略大小写

ret = models.User.objects.filter(age__isnull=False)  # name字段是否为null

ret = models.User.objects.filter(bitrh__year='2020')  # year

ret = models.User.objects.filter(bitrh__contains='2020-11-17')

使用自定义文件 运行django环境

import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "bookmanager.settings")
import django
django.setup()

from app02 import models