python学习点滴记录-Day18-django-orm

时间 2019-11-14

标签 python 学习点滴记录 day18 day django orm 栏目 Python 繁體版

原文原文链接

第18天课程内容：html

模板语言的经常使用标签
自定义过滤器与标签
模板语言之继承
ORM的查询API
单表查询之双下划线
一对多的添加数据方法

mtv补充python

遇到的问题：mysql

一、修改pycharm链接数据库改成mysql时遇到的问题git

解决：web

须要在项目的__init__.py文件中加sql
import pymysql

pymysql.install_as_MySQLdb()
二、post提交表单数据时，默认会提示403 forbidden，须要在form表单处添加{% csrf_token %}，render方法会为它渲染一个随机字符串一并提交给服务端作验证，就能够解决了；数据库

也能够临时在settings里注释掉关于csrf的配置。（不推荐）django

自定义标签和过滤器

django提供的标签与过滤器毕竟有限，更多的是须要本身去自定义标签和过滤器，如下是过程：app

一、在settings中的INSTALLED_APPS配置当前app，否则django没法找到自定义的simple_tag.ide

二、在app中建立templatetags模块(模块名只能是templatetags)

三、建立任意 .py 文件，如：my_tags.py
from django import template
from django.utils.safestring import mark_safe

register = template.Library()
# 以上为固定格式
@register.filter #自定义过滤器
def multi(x,y):
    return x*y

@register.simple_tag#自定义标签
def mult_tag(x,y,z):
    return x**y**z
四、在使用自定义simple_tag和filter的html文件中导入以前建立的 my_tags.py

{% load my_tags %}　

五、使用simple_tag和filter（如何调用）
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>

</head>
<body>
{#自定义过滤器：在经过render方法渲染页面时只支持接受2个参数#}
{% load Mytag %}
<h2>{{ n1|multi:2 }}</h2>
<hr>
{#自定义标签:能够接受多个参数，经过render方法渲染页面时也没问题#}
<h1>{% mult_tag 2 6 2%}</h1>

</body>
</html>
注意：filter能够用在if等语句后，simple_tag不能够

{ % if num|filter_multi: 30 > 100 % }
{{ num|filter_multi: 30 }}

{ % endif % }

总结：
tempalte（模板层）：
        
        功能： 为了更有逻辑的将数据库中的数据渲染到模板中
        
        模板语法     
              变量 {{ }}
            
                  　　深度查询： 句点符 .
　　                  过滤器： {{var|filter_name:参数}} 　标签 {% url %} 　　 {% for i in obj %} {% endfor %} 　　 {% if %} {%endif%} 　　 {% with %} 　　 {% csrf_token%} 自定义过滤器与标签： 定义流程： 1、在settings中的INSTALLED_APPS配置当前app，否则django没法找到自定义的simple_tag. 2、在app中建立templatetags模块(模块名只能是templatetags) 3、建立任意 .py 文件，如：my_tags.py： from django import template from django.utils.safestring import mark_safe register = template.Library() # register的名字是固定的,不可改变  @register.filter # 定义过滤器 def multi(x,y): return x*y @register.simple_tag # 定义标签 def multi_tag(x,y,z): return x*y*z 4、在使用自定义simple_tag和filter的html文件中导入以前建立的 my_tags.py {% load my_tags %}　 5、使用simple_tag和filter（如何调用） 总结区别： 1、自定义filter只能接受两个参数 2、自定义simple_tag不能与if使用 
模板继承 (extend)

Django模版引擎中最强大也是最复杂的部分就是模版继承了。模版继承可让您建立一个基本的“骨架”模版，它包含您站点中的所有元素，而且能够定义可以被子模版覆盖的 blocks 。

经过从下面这个例子开始，能够容易的理解模版继承：

View Code

这个模版，咱们把它叫做 base.html，它定义了一个能够用于两列排版页面的简单HTML骨架。“子模版”的工做是用它们的内容填充空的blocks。

在这个例子中， block 标签订义了三个能够被子模版内容填充的block。 block 告诉模版引擎：子模版可能会覆盖掉模版中的这些位置。

子模版可能看起来是这样的：

View Code

extends 标签是这里的关键。它告诉模版引擎，这个模版“继承”了另外一个模版。当模版系统处理这个模版时，首先，它将定位父模版——在此例中，就是“base.html”。

那时，模版引擎将注意到 base.html 中的三个 block 标签，并用子模版中的内容来替换这些block。根据 blog_entries 的值，输出可能看起来是这样的：

View Code

请注意，子模版并无定义 sidebar block，因此系统使用了父模版中的值。父模版的 {% block %} 标签中的内容老是被用做备选内容（fallback）。

这种方式使代码获得最大程度的复用，而且使得添加内容到共享的内容区域更加简单，例如，部分范围内的导航。

这里是使用继承的一些提示：

若是你在模版中使用 {% extends %} 标签，它必须是模版中的第一个标签。其余的任何状况下，模版继承都将没法工做。

在base模版中设置越多的 {% block %} 标签越好。请记住，子模版没必要定义所有父模版中的blocks，因此，你能够在大多数blocks中填充合理的默认内容，而后，只定义你须要的那一个。多一点钩子总比少一点好。

若是你发现你本身在大量的模版中复制内容，那可能意味着你应该把内容移动到父模版中的一个 {% block %} 中。

If you need to get the content of the block from the parent template, the {{ block.super }} variable will do the trick. This is useful if you want to add to the contents of a parent block instead of completely overriding it. Data inserted using {{ block.super }} will not be automatically escaped (see the next section), since it was already escaped, if necessary, in the parent template.

为了更好的可读性，你也能够给你的 {% endblock %} 标签一个名字。例如：
{% block content %}
...
{% endblock content %}　　
在大型模版中，这个方法帮你清楚的看到哪个　 {% block %} 标签被关闭了。

最后，请注意您并不能在一个模版中定义多个相同名字的 block 标签。这个限制的存在是由于block标签的做用是“双向”的。这个意思是，block标签不只提供了一个坑去填，它还在 _父模版_中定义了填坑的内容。若是在一个模版中有两个名字同样的 block 标签，模版的父模版将不知道使用哪一个block的内容。

ORM相关

ORM

映射关系：

　　　  表名  <－－－－－－－> 类名

       字段  <－－－－－－－> 属性

　　　　表记录 <－－－－－－－>类实例对象

建立表(创建模型)

实例：咱们来假定下面这些概念，字段和关系

做者模型：一个做者有姓名和年龄。

做者详细模型：把做者的详情放到详情表，包含生日，手机号，家庭住址等信息。做者详情模型和做者模型之间是一对一的关系（one-to-one）

出版商模型：出版商有名称，所在城市以及email。

书籍模型：书籍有书名和出版日期，一本书可能会有多个做者，一个做者也能够写多本书，因此做者和书籍的关系就是多对多的关联关系(many-to-many);一本书只应该由一个出版商出版，因此出版商和书籍是一对多关联关系(one-to-many)。

模型创建以下：

class Author(models.Model):
    nid = models.AutoField(primary_key=True)
    name=models.CharField( max_length=32)
    age=models.IntegerField()
 
    # 与AuthorDetail创建一对一的关系
    authorDetail=models.OneToOneField(to="AuthorDetail")
 
class AuthorDetail(models.Model):
 
    nid = models.AutoField(primary_key=True)
    birthday=models.DateField()
    telephone=models.BigIntegerField()
    addr=models.CharField( max_length=64)
    
class Publish(models.Model):
    nid = models.AutoField(primary_key=True)
    name=models.CharField( max_length=32)
    city=models.CharField( max_length=32)
    email=models.EmailField()
 
 
class Book(models.Model):
 
    nid = models.AutoField(primary_key=True)
    title = models.CharField( max_length=32)
    publishDate=models.DateField()
    price=models.DecimalField(max_digits=5,decimal_places=2)
    keepNum=models.IntegerField()<br>    commentNum=models.IntegerField()
 
    # 与Publish创建一对多的关系,外键字段创建在多的一方
    publish=models.ForeignKey(to="Publish",to_field="nid")
 
    # 与Author表创建多对多的关系,ManyToManyField能够建在两个模型中的任意一个，自动建立第三张表
    authors=models.ManyToManyField(to='Author')

经过logging能够查看翻译成的sql语句

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

注意事项：

一、表的名称myapp_modelName，是根据模型中的元数据自动生成的，也能够覆写为别的名称　　

二、id 字段是自动添加的

三、对于外键字段，Django 会在字段名上添加"_id" 来建立数据库中的列名

四、这个例子中的CREATE TABLE SQL 语句使用PostgreSQL 语法格式，要注意的是Django 会根据settings 中指定的数据库类型来使用相应的SQL 语句。

五、定义好模型以后，你须要告诉Django _使用_这些模型。你要作的就是修改配置文件中的INSTALL_APPSZ中设置，在其中添加models.py所在应用的名称。

六、外键字段 ForeignKey 有一个 null=True 的设置(它容许外键接受空值 NULL)，你能够赋给它空值 None 。

字段选项

每一个字段有一些特有的参数，例如，CharField须要max_length参数来指定VARCHAR数据库字段的大小。还有一些适用于全部字段的通用参数。这些参数在文档中有详细定义，这里咱们只简单介绍一些最经常使用的：

(1)null

若是为True，Django 将用NULL 来在数据库中存储空值。 默认值是 False.

(1)blank

若是为True，该字段容许不填。默认为False。
要注意，这与 null 不一样。null纯粹是数据库范畴的，而 blank 是数据验证范畴的。
若是一个字段的blank=True，表单的验证将容许该字段是空值。若是字段的blank=False，该字段就是必填的。

(2)default

字段的默认值。能够是一个值或者可调用对象。若是可调用 ，每有新对象被建立它都会被调用。

(3)primary_key

若是为True，那么这个字段就是模型的主键。若是你没有指定任何一个字段的primary_key=True，
Django 就会自动添加一个IntegerField字段作为主键，因此除非你想覆盖默认的主键行为，
不然不必设置任何一个字段的primary_key=True。

(4)unique

若是该值设置为 True, 这个数据字段的值在整张表中必须是惟一的

(5)choices
由二元组组成的一个可迭代对象（例如，列表或元组），用来给字段提供选择项。 若是设置了choices ，默认的表单将是一个选择框而不是标准的文本框，并且这个选择框的选项就是choices 中的选项。

这是一个关于 choices 列表的例子：

YEAR_IN_SCHOOL_CHOICES = (
    ('FR', 'Freshman'),
    ('SO', 'Sophomore'),
    ('JR', 'Junior'),
    ('SR', 'Senior'),
    ('GR', 'Graduate'),
)
每一个元组中的第一个元素，是存储在数据库中的值；第二个元素是在管理界面或 ModelChoiceField 中用做显示的内容。 在一个给定的 model 类的实例中，想获得某个 choices 字段的显示值，就调用 get_FOO_display 方法(这里的 FOO 就是 choices 字段的名称 )。例如：

from django.db import models

class Person(models.Model):
    SHIRT_SIZES = (
        ('S', 'Small'),
        ('M', 'Medium'),
        ('L', 'Large'),
    )
    name = models.CharField(max_length=60)
    shirt_size = models.CharField(max_length=1, choices=SHIRT_SIZES)


>>> p = Person(name="Fred Flintstone", shirt_size="L")
>>> p.save()
>>> p.shirt_size
'L'
>>> p.get_shirt_size_display()
'Large'

View Code

一旦你创建好数据模型以后，django会自动生成一套数据库抽象的API，可让你执行关于表记录的增删改查的操做。

查询表记录

查询相关API

<1> all():                 查询全部结果
 
<2> filter(**kwargs):      它包含了与所给筛选条件相匹配的对象
 
<3> get(**kwargs):         返回与所给筛选条件相匹配的对象，返回结果有且只有一个，
                           若是符合筛选条件的对象超过一个或者没有都会抛出错误。
 
<5> exclude(**kwargs):     它包含了与所给筛选条件不匹配的对象
 
<4> values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后获得的并非一系列
                           model的实例化对象，而是一个可迭代的字典序列
 
<9> values_list(*field):   它与values()很是类似，它返回的是一个元组序列，values返回的是一个字典序列
 
<6> order_by(*field):      对查询结果排序
 
<7> reverse():             对查询结果反向排序
 
<8> distinct():            从返回结果中剔除重复纪录
 
<10> count():              返回数据库中匹配查询(QuerySet)的对象数量。
 
<11> first():              返回第一条记录
 
<12> last():               返回最后一条记录
 
<13> exists():             若是QuerySet包含数据，就返回True，不然返回False

双下划线之单表查询

models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值
 
models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于十一、2二、33的数据
models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
 
models.Tb1.objects.filter(name__contains="ven")
models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
 
models.Tb1.objects.filter(id__range=[1, 2])      # 范围bettwen and
 
startswith，istartswith, endswith, iendswith

基于对象的跨表查询

一对多查询（Publish 与 Book）

正向查询(按字段：publish)：

# 查询nid=1的书籍的出版社所在的城市<br>
book_obj=Book.objects.get(nid=1)<br>print(book_obj.publish.city) # book_obj.publish 是nid=1的书籍对象关联的出版社对象

反向查询(按表名：book_set)：

# 查询 人民出版社出版过的全部书籍
 
    publish=Publish.objects.get(name="人民出版社")
 
    book_list=publish.book_set.all()  # 与人民出版社关联的全部书籍对象集合
 
    for book_obj in book_list:
        print(book_obj.title)

一对一查询(Author 与 AuthorDetail)

正向查询(按字段：authorDetail)：

# 金瓶眉全部做者的名字以及手机号
 
    book_obj=Book.objects.filter(title="金瓶眉").first()
 
    authors=book_obj.authors.all()
 
    for author_obj in authors:
 
        print(author_obj.name,author_obj.authorDetail.telephone)

反向查询(按表名：book_set)：

# 查询egon出过的全部书籍的名字
 
    author_obj=Author.objects.get(name="egon")
    book_list=author_obj.book_set.all() #与egon做者相关的全部书籍
 
    for book_obj in book_list:
        print(book_obj.title)

注意：

你能够经过在 ForeignKey() 和ManyToManyField的定义中设置 related_name 的值来覆写 FOO_set 的名称。例如，若是 Article model 中作一下更改： publish = ForeignKey(Blog, related_name='bookList')，那么接下来就会如咱们看到这般：

# 查询 人民出版社出版过的全部书籍
 
   publish=Publish.objects.get(name="人民出版社")
 
   book_list=publish.bookList.all()  # 与人民出版社关联的全部书籍对象集合

基于双下划线的跨表查询

Django 还提供了一种直观而高效的方式在查询(lookups)中表示关联关系，它能自动确认 SQL JOIN 联系。要作跨关系查询，就使用两个下划线来连接模型(model)间关联字段的名称，直到最终连接到你想要的 model 为止。

# 练习1:  查询人民出版社出版过的全部书籍的名字与价格(一对多)

    # 正向查询 按字段:publish

    queryResult=Book.objects
　　　　　　　　　　　　.filter(publish__name="人民出版社")
　　　　　　　　　　　　.values_list("title","price")

    # 反向查询 按表名:book

    queryResult=Publish.objects
　　　　　　　　　　　　　　.filter(name="人民出版社")
　　　　　　　　　　　　　　.values_list("book__title","book__price")



# 练习2: 查询egon出过的全部书籍的名字(多对多)

    # 正向查询 按字段:authors:
    queryResult=Book.objects
　　　　　　　　　　　　.filter(authors__name="yuan")
　　　　　　　　　　　　.values_list("title")

    # 反向查询 按表名:book
    queryResult=Author.objects
　　　　　　　　　　　　　　.filter(name="yuan")
　　　　　　　　　　　　　　.values_list("book__title","book__price")


# 练习3: 查询人民出版社出版过的全部书籍的名字以及做者的姓名


    # 正向查询
    queryResult=Book.objects
　　　　　　　　　　　　.filter(publish__name="人民出版社")
　　　　　　　　　　　　.values_list("title","authors__name")
    # 反向查询
    queryResult=Publish.objects
　　　　　　　　　　　　　　.filter(name="人民出版社")
　　　　　　　　　　　　　　.values_list("book__title","book__authors__age","book__authors__name")


# 练习4: 手机号以151开头的做者出版过的全部书籍名称以及出版社名称

    queryResult=Book.objects
　　　　　　　　　　　　.filter(authors__authorDetail__telephone__regex="151")
　　　　　　　　　　　　.values_list("title","publish__name")

注意：

反向查询时，若是定义了related_name ，则用related_name替换表名，例如： publish = ForeignKey(Blog, related_name='bookList')：

# 练习1:  查询人民出版社出版过的全部书籍的名字与价格(一对多)
 
    # 反向查询 再也不按表名:book,而是related_name:bookList
 
    queryResult=Publish.objects
　　　　　　　　　　　　　　.filter(name="人民出版社")
　　　　　　　　　　　　　　.values_list("bookList__title","bookList__price")