Python_Django

时间  2019-12-09
标签 python django 栏目 Python 繁體版
原文   原文链接
MVC
  • 大部分开发语言中都有MVC框架
  • MVC框架的核心思想是：解耦
  • 下降各功能模块之间的耦合性，方便变动，更容易重构代码，最大程度上实现代码的重用
  • m表示model，主要用于对数据库层的封装
  • v表示view，用于向用户展现结果
  • c表示controller，是核心，用于处理请求、获取数据、返回结果
MVT
  • Django是一款python的web开发框架
  • 与MVC有所不一样，属于MVT框架
  • m表示model，负责与数据库交互
  • v表示view，是核心，负责接收请求、获取数据、返回结果
  • t表示template，负责呈现内容到浏览器

客户端 -> 视图View -> 模型Model -> Mysql -> 模型Model -> 视图View -> 模版Template -> 视图View -> 客户端css

clipboard.png

clipboard.png

Django环境

安装：html

pip install django==1.8.2

建立项目：前端

django-admin startproject test1

目录说明：python

clipboard.png

  • manage.py：一个命令行工具，可使你用多种方式对Django项目进行交互-
  • 内层的目录：项目的真正的Python包
  • _init _.py：一个空文件，它告诉Python这个目录应该被看作一个Python包
  • settings.py：项目的配置
  • urls.py：项目的URL声明
  • wsgi.py：项目与WSGI兼容的Web服务器入口

启动项目：mysql

python manage.py runserver 8181
扩展项目目录 
|-- app/                     # 应用主目录
    |-- templates/           # html 模板目录
        |-- app/
            |-- home.html    # 主页html
            |-- login.html   # 登录页html
            |-- about.html   # 关于页html
            |-- ...
    |-- static/              # 静态资源目录
        |-- js/              # js资源目录
            |-- lib/         # js library 资源目录
            |-- page1/       # 页面1 js资源目录
            |-- page2/       # 页面2 js资源目录
            |-- ...
        |-- css/             # css资源目录
        |-- images/          # 图片资源目录
        |-- ...



    |-- admin.py             # 配置模型models在django原生后台的管理
    |-- apps.py              # 应用级别的配置
    |-- forms.py             # 表单处理逻辑
    |-- managers.py          # 模型处理逻辑
    |-- models.py            # 模型定义
    |-- urls.py              # 路由设置
    |-- views.py             # 控制层
    |-- tests.py
先后端项目分离

后端：web

|-- app/                     # 应用主目录
    |-- admin.py             # 配置模型models在django原生后台的管理
    |-- apps.py              # 应用级别的配置
    |-- forms.py             # 表单处理逻辑
    |-- managers.py          # 模型处理逻辑
    |-- models.py            # 模型定义
    |-- urls.py              # 路由设置
    |-- views.py             # 控制层
    |-- tests.py

前端：ajax

|-- src/
    |-- app/
        |-- home/            # 主页工做目录
            |-- index.html   # html 入口文件
            |-- index.js     # js 入口文件
            |-- ...
        |-- login/           # 登录页工做目录
        |-- about/           # 关于页工做目录
        |-- ...
Django有关命令

django安装:正则表达式

pip install django==1.11.11
pip install -i yuan django=1.11.11

建立目录:sql

django-admin startproject filename

建立App:数据库

python manage.py startapp appname

启动项目:

python manage.py runserver # 127.0.0.1:8000
python manage.py runserver 80 # 127.0.0.1:80
python manage.py runserver 0.0.0.0:80 # 0.0.0.0:80

数据库相关:

python manage.py makemigrations # 记录modules的变化，将变动的记录更新到 对应App下到migrations
python manage.py migrate # 翻译成SQL语句，去数据库执行

Django基础使用

app的概念：一个大项目中划分红不少功能模块

配置静态目录 
# 在setting.py中， Static files (CSS, JavaScript, Images)
STATIC_URL = '/static/' # alise

STATIC_DIRS = [
    os.path.join(BASE_DIR, 'static'),
]
django基础三件套 
from django.shortcuts import HttpResponse, render

HttpResponse
render
redirect // 返回一条命令，浏览器再去请求重定向的地址
使用PY连接MySql

使用pymysql模块

  1. 导入pymysql模块
  2. 建立链接
  3. 获取执行命令的游标
  4. 用游标去执行SQL语句
  5. 获取SQL语句的执行结果
  6. 关闭游标
  7. 关闭链接
ORM

类似的数据，一类的数据放在同一张表中。具备相同属性，放在同一张表中。

ORM      DB
类       数据表
属性     字段
对象     数据行

优势：开发效率高；不用直接写SQL语句；后端数据库变更，ORM适配。
缺点：执行效率低；SQL语句可能不是最优。

建立视图与ORM的app

不一样的功能放在不一样的包中

> python manage.py startapp appname
  • 从新在使用的地方引入新的views的视图
  • 在settings.py中从新配置，在字段INSTALL_APPS增长: app.apps.AppConfig
Django使用mysql
  1. 手动建立一个数据库create database djsite

  2. 配置Django链接数据库，可使用多个数据库（读写分离，主从服务器）

    DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'djsite',
        'HOST': '127.0.0.1',
        'PROT': 3306,
        'USER': 'root',
        'PASSWORD': ''
    }
}

  3. 使用第三方的包链接数据库：pymysql, MySQLDb(支持py2)，在djsite项目的__init__.py中告知Django使用pymysql

    import pymysql

pymysql.install_as_MySQLdb()

  4. 建立一张表，在app/models.py的文件中建立类

    from django.db import models

# Create your models here.

class User(models.Model):
    id = models.AutoField(primary_key=True) # id 主键
    email = models.CharField(max_length=32) # varchar(32)
    pwd = models.CharField(max_length=32) # varchar(32)
  5. 使用ORM
    把models.py中变动的记录下来：python manage.py makemigrations
    变动的记录建立成数据库语句执行：python manage.py migrate

  6. 视图中使用

    User.objects.filter(emial=, pwd=) # 查询数据库中的字段
模版语言

展现：

{{name}}

for循环：

{%for item in press_list%}
    <tr>
        <td>{{forloop.counter}}</td>
        <td>{{item.id}}</td>
        <td>{{item.name}}</td>
        <td><a href="/del_press/?id={{item.id}}">删除</a></td>
    </tr>
{%endfor%}
配置settings.py

数据库相关配置:

ENGIGE # 引擎相关  mysql sqllite3
NAME # 数据库名字
HOST # IP
PORT # 端口 3306
USER # 用户名
PASSWORD # 密码, ''

静态文件相关:

STATIC_URL = 'static' # 别名
STATICFILE_DIRS = [ # 静态文件地址
    os.path.join(BASE_DIR, 'static')
]

APP:

INSTALL_APP = [
    'app01.apps.App01Config' # 告知django新建了一个名叫app01的应用
    # appName.appFile.appClass
]
ORM关系 
class -> 数据表
object -> 行
attr -> 字段

图书管理系统

表的设计

出版社
    id, name
做者
    id, name
书
    id, title, 出版社_id(一对多，一本书只能选择一个出版社),
做者和书(多对多的关系，多一张关系表)
    id, 书_id, 做者_id
CURD

模型：

class Press(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)

views.py中CURD操做:

def press_list(request):
    press_list = Press.objects.all().order_by('id')

    return render(request, 'press_list.html', {'press_list': press_list})

def add_list(request):
    if request.method == 'POST':
        press_name = request.POST.get('name')
        Press.objects.create(name=press_name)
        return redirect('/press_list/')

    return render(request, 'add_list.html')

def del_list(request):
    del_id = request.GET.get('id')
    Press.objects.filter(id=del_id).delete()

    return redirect('/press_list/')

def edit_press(request):
    edit_id = request.POST.get('id')
    edit_press = Press.objects.get(id=edit_id)
    if request.method == 'POST':
        new_name = request.POST.get('name')
        edit_press.name = new_name
        edit_press.save() # 注意保存
        return redirect('/press_list/')
        
    return render(request, 'edit_list.html', {'edit_item', edit_press})

ORM语句：

className.objects.all()
className.filter()
className.objects.get()
className.objects.create(name='')
className.objects.filter(id=id).delete()

# 更改
obj = className.objects.get(id=id)
obj.name = newName
obj.save() # 注意保存
# 书籍表结构：
#    id, title, 关系字段(外键)

create table_book(
    id int primary_key auto_increment,
    title varchar(30) not null
    press_id int not null,
    constraint fk_press foreign key(press_id) references press(id) on delete cascade update cascade
)

ORM使用外键：

class Book(models.Model):
    id = models.AutoField(primary_key=True)
    title = models.CharField(max_length=30)
    press = models.ForeignKey(to='Press', on_delete=models.CASCADE) # 外键， 关联Press表

外键查询：

book_obj.press # 书籍关联的出版社对象
book_obj.press_id # 数据库中实际存在的字段值

外键修改：

book_obj = Book.objects.create(title='', press=)
book_obj = Book.objects.create(title='', press_id=)

ORM已经存在的表，再次更改字段，没有默认值，有必须填写，Django会提示手动输入默认值。

null=True
default=默认值

price = Press.IntegerField(null=True)
price = Press.IntegerField(default=100)
# 做者表，多对多结构：
# SQL语句：
create table author(id int primary_key auto_increment; name varchar(32) not null);
create table authorToBook(
    id int primary_key auto_increment,
    author_id int not null,
    book_id int not null,
    constraint fk_author foreign key(author_id) references author(id) on delete on update cascade,
    constraint fk_book foreign key(book_id) references book(id) on delete on update cascade
);
对多对的关系查询的使用

模型：

# ORM建立二张表:
class Author(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)

class AuthorToBook(models.Model):
    id = models.AutoField(primary_key=True)
    author = models.ForeignKey(to='Author', on_delete=models.CASCADE)
    book = models.ForeignKey(to='Book', on_delete=models.CASCADE)

# Django中包含多对多的关系字段`ManyToManyField`：
class Author(models.Model):
    id = models.AutoField(primary_key=True)
    name = models.CharField(max_length=32)
    books = models.ManyToManyField(to='Book') # Django包含多对多字段

视图：

def author_list(request):
    author_data = Author.objects.all()

    # for item in author_data:
    #     print(item.books.all()) # 连表查询，使用all()查询出数据来
    return render(request, 'author_list.html', {'author_data': author_data})

界面：

<table>
        <tr>
            <th>序号</th>
            <th>做者id</th>
            <th>做者名字</th>
            <th>做者做品</th>
        </tr>
        {% for author in author_data %}
        <tr>
            <td>{{forloop.counter}}</td>
            <td>{{author.id}}</td>
            <td>{{author.name}}</td>
            <td>
            {% for book in data.books.all %}
                {% if forloop.last %}
                    《{{book.title}}》
                {% else %}
                    《{{book.title}}》,
                {% endif %}
            {% empty %}
                暂无做品
            {% enfor %}
            </td>
        </tr>
        {% endfor %}
    </table>

查询多对多的关系字段：

author_obj.books.all()

修改：

author_obj.set(['book1', 'book2'])
author_obj.add('book1', 'book2', 'book3')

清除:

author_obj.clear() # 清除对应关系
ORM操做

查:

from app01.models import User, Press, Book, Author

Press.object.all() # 查询全部出版社对象(对象列表queryset)
Press.object.filter(条件) # 查询全部知足条件的对象
Press.object.get(条件) # 查询有且只有一个对象

# 属性
press_obj.id
press_obj.name

# 外键属性
book_obj.id
book_obj.press # 关联对象
book_obj.press.id

# 多对多属性
author_obj.books # 管理对象
author_obj.books.all() # 做者关联的全部书籍对象

增:

from app01.models import User, Press, Book, Author

new_press_obj = Press.object.create(name='')

# 外键的增长
Book.object.create(title='', prece='', press_id=press_obj.id)
Book.object.create(title='', prece='', press=press_obj)

# 多对多关系的增长
new_author_obj = Author.object.create(name='')
new_author_obj.books.set([press_id, press_id])
new_author_obj.books.set([book1, book2])
new_author_obj.books.add(book1, book2)

删:

book_obj.delete(条件) # 删除知足条件单个对象
Press.object.filter(条件).delete() # 删除知足条件的多个对象

改:

press_obj.name = ''
press_obj.save() # 注意修改保存

Press.object.filter(条件).update() # 修改知足条件的多个对象

# 外键的修改
book_obj.press = press_obj
book_obj.save()
book_obj.press_id = press_obj.id

# 多对多字段的修改
author_obj.name = ''
author_obj.save()

author_obj.books.set([press_id, press_id])
文件上传 
f_dict = request.FILES.get('name') # 文件字典
    print(f_dict)
    with open(f_dict, 'wb') as f:
        for chunk in f_dict.chunk():
            f.write(chunk)

模版语言

变量相关:{{}}
逻辑相关:{% %}

点.在模版语言中，有特殊的含义，顺序为：

  1. 字典查询
  2. 属性或方法查询
  3. 数字索引查询
{{name}}
{{dict1.name}}
{{list1.0}}

模版语言中方法不用加()执行，Django自动调用，只能调用不带参数的方法。

filter 
# {{变量名|方法|参数}}
{{name|fun}}
{{ value|add:"2" }} # 支持链式操做
{{ value|date:"D d M Y" }} {{ value|time:"H:i" }}
  • 过滤器后加个冒号，再紧跟参数，中间不能有空格。
  • 支持一个参数。

if语句支持过滤器, and, or, ==, <, >, in, !=, is, is not, not in, <=, >=

自定义filter
  1. 在app中新建一个templatetags包（名字固定，不能变，只能是这个），和views.py、models.py等文件处于同一级别目录下。这是一个包！不要忘记建立__init__.py文件以使得该目录能够做为Python的包。

  2. 在建立的包中，建立.py文件做为过滤器文件

    from django import template

# 生成注册实例
register = template.Library()

@register.filter # 告知模版语言，自定义的filter
def counter(val):
    '''
        counter
        :params {val} 管道符参数
        :return {}
    '''
    return val + 'counter'

  3. 在.html视图文件中导入，并使用。

    # 导入filter模块
{%  load counter  %}
# 使用该过滤器
{{ret|counter}}
  4. 须要重启django项目。
csrf

CSRF通常是POST请求：

{% csrf_token %}
  • <form>...</form>标签；
  • 使用POST的方法时，必须添加{% csrf_token %}标签，用于处理csrf安全机制；
  • {{ form }}表明Django为你生成其它全部的form标签元素，提交按钮须要手动添加；
母板与继承 
# 子页面中继承父页面
{% extends 'list/base.html' %}

# 父级页面`base.html`
{% block contenter %}
{% endblock %}

# 子页面
{% block contenter %}
{% endblock %}
组件 
# 引入组件
{% include 'nav.html' %}
静态文件 
{% load static %}

<link href="{% static % 'bootstrap-3.3.7/css/bootstrap.css'}" />

{% load static %}
{% get_static_prefix %} # 去settings.py中获取STATIC_URL的value值
自定义inclusion_tags
  1. 在app下建立一个templatetags的python包
  2. 在包下写py文件，mytags

  3. 编辑文件

    from django import template
register = template.Library()

  4. 定义函数，能够接收参数，须要返回字典

    @register.include_tag(filename) # 组件名字
def pagination(total):
    return {'total': total}
  5. 在模版文件中使用字典参数，进行渲染

  6. 使用

    {% load mytags %}
{ pagination 10 }

Django中的视图

一个视图函数（类）称之为视图，它接受Web请求而且返回Web响应。
响应能够是一张网页的HTML内容，一个重定向，一个404错误，一个XML文档，或者一张图片。
不管视图自己包含什么逻辑，都要返回响应。为了将代码规范，约定俗成将视图放置在项目(project)或应用程序(app)目录中命名为view.py文件中。

FBV(Function Based View) 
def login(request):
    # return HttpResponse('ok')
    # print(request.POST, 'post')
    # print(request.Method, 'method')
    # print(request.GET, 'get')
    return render(request, 'login.html', {'ret': 'test'})
CBV(class Based View) 
from django.views import View

class AddPress(View):
    def get(self, request):
        return render(request, 'add_press.html')

    def post(self, request):
        press_name = request.POST.get('name')
        Press.objects.create(name=press_name)
        return rediract('/press_list/')

在url.py中使用

url(r'/add_press/', views.AddPress.as_view())

流程：

  1. views.AddPress.as_view()获取源码的view函数

  2. 当请求到来的时候执行view函数
    实例化本身定义的类赋值给self

    self = cls(**initkwargs)

    self.request = request
    执行父类中的self.dispatch(request, *args, **kwargs)

  3. self.dispatch(request, *args, **kwargs)
    判断请求方式是否被容许

    handler = 容许的请求下经过**反射**获取本身定义的类中的`get`, `post`方法

    不容许的状况下

    handler = 不容许的状况, 父类中的http_method_not_allowed方法

    执行handler方法
    返回HttpResponse对象

  4. 把返回HttpResponse对象返回给Django
requset和response对对象：

requset对象：

['COOKIES', 'FILES', 'GET', 'META', 'POST', 'body', 'build_absolute_uri', 'close', 'content_params', 'content_type', 'csrf_processing_done', 'encoding', 'environ', 'get_full_path', 'get_host', 'get_port', 'get_raw_uri', 'get_signed_cookie', 'is_ajax', 'is_secure', 'method', 'parse_file_upload', 'path', 'path_info', 'read', 'readline', 'readlines', 'resolver_match', 'scheme', 'session', 'upload_handlers', 'user', 'xreadlines']

requset经常使用的对象:

requset.method
requset.GET
requset.POST
requset.FILES
requset.COOKIES
requset.path_info
requset.body
requset.scheme # 协议
requset.encoding # 编码
requset.META # 元数据

requset.get_host() # ip:host
requset.is_ajax() # 是不是ajax请求

response对象：

from django.shortcuts import redner, HttpResponse, redirect

HttpResponse('字符串')
redner(requset, 'xxx.html', {ret: ret})
redirect('跳转地址') # Location

# 返回json数据，序列化
from django.http import JsonResponse
def json_data(request):
    ret = {'name': 'su', 'age': 30}
    # return HttpResponse(json.dumps(ret)) # Content-Type: text/html charset=utf-8
    return HttpResponse(json.dumps(ret), content_type: 'application/json')
    return JsonResponse(ret) # Content-Type: application/json

路由

URL是Web服务的入口，用户经过浏览器发送过来的任何请求，都是发送到一个制定的URL地址，而后被响应。

urlpatterns中的元素按照书写顺序从上往下逐一匹配正则表达式，一旦匹配成功则再也不继续。

分组 
url(r'^test/(\d{4})/\d{2}$', views.test) # test函数接收到正则匹配分组的参数

命名分组：

url(r'^test/(?P<year>\d{4})/\d{2}$', views.test) # test函数接收到正则匹配分组的year参数，也能够经过`args`或`**kwargs`来获取参数
视图默认参数 
# URLconf
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),
]

# View (in blog/views.py)
def page(request, num="1"): # 当没有传递使用num=1
    pass
路由转发

一般，在每一个app里，各自建立一个urls.py路由模块， 而后从根路由出发，将app所属的url请求，所有转发相应的urls.py模块中。

项目目录的url.py下:

from django.conf.urls import include, url

urlpatterns = [
    url(r'^community/', include('app.aggregator.urls')),
    url(r'^contact/', include('app.contact.urls')),
]

app/aggregator/urls.py下：

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

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

地址栏访问方式：127.0.0.1:8000/app/test, test是app下定义的路由

命名URL和URL反向解析

命名：

url(r'press_list/', views.press_list, name='press_list') # 命名
url(r'^home/(\d{4})/(\d{2})/$', views.home, name=home) # 分组
url(r'^home/(?P<year>\d{4})/(?P<month>\d{2})/$', views.home, name=home) # 命名分组

反向：

# 视图中应用
from django.shortcuts import redirect, reverse

def press_list():
    # reverse('press_list') -> /press_list/
    redirect(reverse('press_list'))

    # url(r'^home/(\d{4})/(\d{2})/$')
    redirect(reverse('home', args=('2018', '12'))) # 分组，须要传递参数 'app/home/2018/12'

    # url(r'^home/(?P<year>\d{4})/(?P<month>\d{2})/$', views.home, name=home)
    redirect(reverse('home', kwargs={'year': 2018, 'month': 12})) # 命名分组
# 模版中应用
{% url 'press_list' %}  # 命名
{% url 'home' '2018' '11' %}  # 分组
{% url 'home' year='2018' month='10' %}  # 命名分组
命名空间 namespace 
# urls
url(r'^app01/', include('app01.urls', namespace='app01'))
url(r'^app02/', include('app02.urls', namespace='app02'))
# 视图中使用
def home(request):
    reverse('app01:home')
    return HttpResponse('ok')
def delete(request, table, del_id):
    table_class = getattr(models, table.capitalize()) # getattr() 字符串映射到对象
    table_class.objects.get(id=del_id).delete()

    return redirect(reverse(table)) # reverse 反向解析

ORM

字段类型
类型 说明
AutoField 自增整数类型字段。Django会自动添加字段: `id = models.AutoField(primary_key=True),从1开始计数。主键
BooleanField 布尔值类型。默认值是None。在HTML表单中表现为CheckboxInput标签，若是要接受null只，使用NullBooleanFiled
CharField 字符串类型。 必须接受字段max_length,表示字符串长度不能超过该值，默认的标签Input text,最经常使用的filed。
DateField class DateField(auto_now=False, auto_now_add=False, **options)日期类型。一个Python中的datetime.date的实例。在HTML中表现为TextInput标签。Django会帮你自动添加一个JS的日历表和一个“Today”快捷方式，以及附加的日期合法性验证。两个重要参数：（参数互斥，不能共存） auto_now: 每当对象被保存时将字段设为当前日期，经常使用于保存最后修改时间。auto_now_add：每当对象被建立时，设为当前日期，经常使用于保存建立日期(注意，是不可修改的)。设置上面两个参数就至关于给field添加了editable=False和blank=True属性。若是想具备修改属性，请用default参数。例：pub_time = models.DateField(auto_now_add=True)，自动添加发布时间。
EmailField 邮箱类型，默认max_length最大长度254位。
FileField class FileField(upload_to=None, max_length=100, **options)上传文件类型
ImageField 图像类型
FilePathField 文件路径信息。以字符串的形式存在，默认最大长度100，能够经过max_length参数设置。
IntegerField 整数类型，最经常使用的字段之一。取值范围-2147483648到2147483647。在HTML中表现为NumberInput标签。
GenericIPAddressField class GenericIPAddressField(protocol='both', unpack_ipv4=False, **options)[source]IPV4或者IPV6地址，字符串形式
TextField 大量文本内容，在HTML中表现为Textarea标签
URLField 一个用于保存URL地址的字符串类型，默认最大长度200。
UUIDField 用于保存通用惟一识别码（Universally Unique Identifier）的字段。使用Python的UUID类

UUIDField: 须要设置default参数

import uuid
from django.db import models

def MyUUIDModel(models.Model):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    # other filed
Meta配置 
class UserInfo(models.Model):
    nid = models.AutoField(primary_key=True)
    username = models.CharField(max_length=32)

    # 表进行相关配置
    class Mate:
        db_table = 'table_name' # 数据库中生成的表名，默认：appname + 下划线 + 类名
        verbose_name = '我的信息' # admin中显示的表名称
        index_together = [ # 联合索引
            ('pub_date', 'deadline') # 应为两个存在的字段
        ]
        unique_together = (('driver', 'restaurant'),) # 联合惟一索引
查询数据的13个方法

django ORM操做

import os

if __name__ == '__main__':
    os.environ.setdefault(‘DJANGO_SETTINGS_MODULE’, ‘project_name.settings’) # 设定配置文件
    import django
    django.setup()

    from appname import models # 导入app中的模块

    # all() 全部对象列表
    # p = models.Person.objects.all()

    # get() 获取多个对象列表
    # p = models.Person.objects.get(id=id) # 查询不到报错

    
    # filter() 知足条件的对象列表
    # p = models.Person.objects.filter(id=1)

    # exclude() 不知足条件的对象列表
    # p = models.Person.objects.exclude()

    # values() # 取具体的数据的对象列表。 字典形式key: val
    # 没有指定参数，是全部的表的字段，能够制定某些字段。
    # p = models.Person.objects.all().values()
    # p = models.Person.objects.all().values('id', 'name')

    # values_list() # 取具体的数据的对象列表。元祖形式 val
    # 没有指定参数，是全部的表的字段，能够制定某些字段。
    # p = models.Person.objects.all().values_list()

    # order_by() # 排序
    # p = models.Person.objects.all().order_by('id')
    # p = models.Person.objects.all().order_by('-id') # 降序
    # p = models.Person.objects.all().order_by('age', 'id') # 多个字段排序

    # reverse() # 反序
    # p = models.Person.objects.all().order_by().reverse() # 须要进行排序后再反转

    # distinct() # 去重

    # count() # 统计
    # p = models.Person.objects.all().count()

    # first(), last()
    # p = models.Person.objects.all().first()
    # p = models.Person.objects.filter().first()

    # exists() # 是否存在数据
    # p = models.Person.objects.all().exists()
    print(p)
单表查询 
import os
import sys

if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "djsite.settings")
    import django
    django.setup()

    from app01 import models

    ret = models.Person.objects.filter(id__gt=1) # 大于
    ret = models.Person.objects.filter(id__lt=4) # 小于
    ret = models.Person.objects.filter(id__gte=1) # 大于等于
    ret = models.Person.objects.filter(id__lte=1) # 小于等于
    ret = models.Person.objects.filter(id__in=[1, 3]) # 小于等于

    ret = models.Person.objects.filter(id__in=[1, 3]) # id=1, id=3
    ret = models.Person.objects.filter(id__lt=1, id__gt=3) # 1 < x < 3
    ret = models.Person.objects.filter(id__range=[1, 3])

    ret = models.Person.objects.filter(name__contains='e') # name包含e，模糊查询
    ret = models.Person.objects.filter(name__icontains='e') # name包含e，忽略大小写，模糊查询

    ret = models.Person.objects.filter(name__startswith='e') # 开头包含e
    ret = models.Person.objects.filter(name__istartswith='e') # 开头包含e，忽略大小写

    ret = models.Person.objects.filter(name__endswith='e') # 结尾包含e
    ret = models.Person.objects.filter(name__iendswith='e') # 结尾包含e，忽略大小写

    ret = models.Person.objects.filter(birth_year=2018) # 2018年份
    ret = models.Person.objects.filter(birth_month=12) # 12月份
    ret = models.Person.objects.filter(birth_day=12) # 天数

    print(ret, 'ret')
外键查询

django终端打印SQL语句：

# 配置在`settings.py`中
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}
#!/usr/bin/env python
import os
import sys

if __name__ == '__main__':
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'djsite.settings')

    import django

    django.setup()

    from app import models

    book_obj = models.Book.objects.get(id=2)

    obj1 = models.Book.objects.filters(publisher__name='xxxx') # INNER JOIN 联表查询
    obj2 = models.Book.objects.all().values('title', 'publisher__name') # 表名__字段名

多对多的查询

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程