day57

小小史迪仔

已于 2023-11-15 15:18:33 修改

阅读量468

点赞数

文章标签： django

于 2023-11-15 14:59:40 首次发布

本文链接：https://blog.csdn.net/qq_67257222/article/details/134419797

版权

今日内容概要

模板层

模板之过滤器
模板之标签(if else for)
模板之继承
导入模板

模型层

单表的操作
十几种常见的查询方法
基于下划线的查询方法
外键字段的增删改查
正反向查询(多表跨表)

模板之过滤器

语法：
{{obj|filter__name:param}}  变量名字|过滤器名称：变量

default：

如果一个变量是false或者为空，使用给定的默认值。否则，使用变量的值。例如：
{{ value|default:"nothing"}}

filesizeformat

将值格式化为一个 “人类可读的” 文件尺寸 （例如 '13 KB', '4.1 MB', '102 bytes', 等等）。例如：
{{ value|filesizeformat }}
如果 value 是 123456789，输出将会是 117.7 MB。

date

如果 value=datetime.datetime.now()
{{ value|date:"Y-m-d"}}

slice

如果 value=”hello world”
{{ value|slice:"2:-1"}}

truncatechars

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

safe

Django的模板中会对HTML标签和JS等语法标签进行自动转义，原因显而易见，这样是为了安全。但是有的时候我们可能不希望这些HTML元素被转义，比如我们做一个内容管理系统，后台添加的文章中是经过修饰的，这些修饰可能是通过一个类似于FCKeditor编辑加注了HTML修饰符的文本，如果自动转义的话显示的就是保护HTML标签的源文件。为了在Django中关闭HTML的自动转义有两种方式，如果是一个单独的变量我们可以通过过滤器“|safe”的方式告诉Django这段代码是安全的不必转义。比如

value="<a href="">点击</a>"


{{ value|safe}}


from django.utils.safestring import mark_safe
res = mark_safe('<h1>HELLO WORLD</h1>')

模板之标签

标签看起来像是这样的： {% tag %}
标签比变量更加复杂：一些在输出中创建文本，一些通过循环或逻辑来控制流程，一些加载其后的变量将使用到的额外信息到模版中。
一些标签需要开始和结束标签（例如{% tag %} ...标签内容 ... {% endtag %}）

for标签

遍历每一个元素
{% for person in person_list %}
    <p>{{ person.name }}</p>
{% endfor %}

可以利用{% for obj in list reversed %}反向完成循环。

遍历一个字典
{% for key,val in dic.items %}
    <p>{{ key }}:{{ val }}</p>
{% endfor %}

{% for foo in d.keys %}
    <p>{{ foo }}</p>
{% endfor %}

{% for foo in d.values %}
    <p>{{ foo }}</p>
{% endfor %}

{% for foo in d.items %}
    <p>{{ foo }}</p>
{% endfor %}

注：循环序号可以通过｛｛forloop｝｝显示 
forloop.counter            The current iteration of the loop (1-indexed) 当前循环的索引值（从1开始）
forloop.counter0           The current iteration of the loop (0-indexed) 当前循环的索引值（从0开始）
forloop.revcounter         The number of iterations from the end of the loop (1-indexed) 当前循环的倒序索引值（从1开始）
forloop.revcounter0        The number of iterations from the end of the loop (0-indexed) 当前循环的倒序索引值（从0开始）
forloop.first              True if this is the first time through the loop 当前循环是不是第一次循环（布尔值）
forloop.last               True if this is the last time through the loop 当前循环是不是最后一次循环（布尔值）
forloop.parentloop         本层循环的外层循环

for...empty

for 标签带有一个可选的{% empty %} 从句，以便在给出的组是空的或者没有被找到时，可以有所操作。
{% for person in person_list %}
    <p>{{ person.name }}</p>

{% empty %}
    <p>sorry,no person here</p>
{% endfor %}

if标签

# {% if %}会对一个变量求值，如果它的值是True（存在、不为空、且不是boolean类型的false值），对应的内容块会输出。

{% if num > 100 or num < 0 %}
    <p>无效</p>
{% elif num > 80 and num < 100 %}
    <p>优秀</p>
{% else %}
    <p>凑活吧</p>
{% endif %}

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

with

使用一个简单地名字缓存一个复杂的变量，当你需要使用一个“昂贵的”方法（比如访问数据库）很多次的时候是非常有用的

例如

d = {'username':'kevin','age':18,'info':'这个人有点意思','hobby':[111,222,333,{'info':'NB'}]}

# with起别名
{% with d.hobby.3.info as nb  %}
    <p>{{ nb }}</p>
    在with语法内就可以通过as后面的别名快速的使用到前面非常复杂获取数据的方式
    <p>{{ d.hobby.3.info }}</p>
{% endwith %}


{% with total=business.employees.count %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}
不要写成as

csrf_token

{% csrf_token%}
这个标签用于跨站请求伪造保护

模板的继承和导入

语法：{% include '模版名称' %}

　　如：{% include 'adv.html' %}

<div class="adv">
    <div class="panel panel-default">
        <div class="panel-heading">
            <h3 class="panel-title">Panel title</h3>
        </div>
        <div class="panel-body">
            Panel content
        </div>
    </div>
    <div class="panel panel-danger">
        <div class="panel-heading">
            <h3 class="panel-title">Panel title</h3>
        </div>
        <div class="panel-body">
            Panel content
        </div>
    </div>
    <div class="panel panel-warning">
        <div class="panel-heading">
            <h3 class="panel-title">Panel title</h3>
        </div>
        <div class="panel-body">
            Panel content
        </div>
    </div>
</div>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <link rel="stylesheet" href="/static/bootstrap-3.3.7-dist/css/bootstrap.min.css">
    {#    <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">#}
    <style>
        * {
            margin: 0;
            padding: 0;
        }

        .header {
            height: 50px;
            width: 100%;
            background-color: #369;
        }
    </style>
</head>
<body>
<div class="header"></div>

<div class="container">
    <div class="row">
        <div class="col-md-3">
            {% include 'adv.html' %}


        </div>
        <div class="col-md-9">
            {% block conn %}
                <h1>你好</h1>
            {% endblock %}

        </div>
    </div>

</div>

</body>
</html>

{% extends 'base.html' %}

{% block conn %}
    {{ block.super }}
是啊

{% endblock conn%}

模板继承

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

通过从下面这个例子开始，可以容易的理解模版继承：

<!DOCTYPE html>
<html lang="en">
<head>
    <link rel="stylesheet" href="style.css"/>
    <title>{% block title %}My amazing site{% endblock %}</title>
</head>

<body>
<div id="sidebar">
    {% block sidebar %}
        <ul>
            <li><a href="/">Home</a></li>
            <li><a href="/blog/">Blog</a></li>
        </ul>
    {% endblock %}
</div>

<div id="content">
    {% block content %}{% endblock %}
</div>
</body>
</html>

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

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

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

{% extends "base.html" %}
 
{% block title %}My amazing blog{% endblock %}
 
{% block content %}
{% for entry in blog_entries %}
    <h2>{{ entry.title }}</h2>
    <p>{{ entry.body }}</p>
{% endfor %}
{% endblock %}

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

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

<!DOCTYPE html>
<html lang="en">
<head>
    <link rel="stylesheet" href="style.css" />
    <title>My amazing blog</title>
</head>
 
<body>
    <div id="sidebar">
        <ul>
            <li><a href="/">Home</a></li>
            <li><a href="/blog/">Blog</a></li>
        </ul>
    </div>
 
    <div id="content">
        <h2>Entry one</h2>
        <p>This is my first entry.</p>
 
        <h2>Entry two</h2>
        <p>This is my second entry.</p>
    </div>
</body>
</html>

请注意，子模版并没有定义 `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` 标签。

模型层

测试脚本

测试脚本
- 当我们只想要测试Django中的某一个py文件的内容时，我们可以不需要书写前后端交互的形式，而是直接写一个测试脚本即可
测试环境的准备
- 在测试文件中书写下面内容
这内容其实就是最外部 manage.py 文件中的上面几句话，去manage.py中拷贝前四行代码然后自己写两行
- 脚本代码无论是写在应用下的 tests.py文件还是自己新建文件，将内容写在新文件中，都会生效

from django.test import TestCase

# Create your tests here.
import os

if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "day07.settings")

    import django
    django.setup()
    
    # 在下面书写我们需要测试的代码
    # 即所有的测试代码都必须等待环境准备完毕之后才能书写

单表操作

单表的操作
create
update
delete
all
first
filter
# django自带的sqlite3数据库对日期格式不是很敏感 处理的时候容易出错
# 增
    # res = models.User.objects.create(name='jason',age=18,register_time='2002-1-21')
    # print(res)
    # import datetime
    # ctime = datetime.datetime.now()
    # user_obj = models.User(name='egon',age=84,register_time=ctime)
    # user_obj.save()

    # 删
    # res = models.User.objects.filter(pk=2).delete()
    # print(res)
    """
    pk会自动查找到当前表的主键字段 指代的就是当前表的主键字段
    用了pk之后 你就不需要指代当前表的主键字段到底叫什么了
        uid
        pid
        sid
        ...
    """
    # user_obj = models.User.objects.filter(pk=1).first()
    # user_obj.delete()

    # 修改
    # models.User.objects.filter(pk=4).update(name='egonDSB')

    # user_obj = models.User.objects.get(pk=4)
    # user_obj = models.User.objects.filter(pk=6)
    """
    get方法返回的直接就是当前数据对象
    但是该方法不推荐使用
        一旦数据不存在该方法会直接报错
        而filter则不会
            所以我们还是用filter
    """
    # user_obj.name = 'egonPPP'
    # user_obj.save()

常见的十几种查询方法

1.all()  查询所有数据

2.filter()     带有过滤条件的查询
3.get()        直接拿数据对象 但是条件不存在直接报错
4.first()      拿queryset里面第一个元素
res = models.User.objects.all().first()
print(res)
res = models.User.objects.all().last()
print(res)

values value_list
select username,password from user
<QuerySet [{'username': 'kevin1', 'password': '123', 'age': 20},
res = models.User.objects.values('username', 'password','age') # 指定查询的字段，返回的是列表套字典
print(res)

<QuerySet [('kevin1', '123', 20), ('kevin2', '123', 20), ('kevin3', '123', 20), ('kevin4', '123', 20)]>
res = models.User.objects.values_list('username', 'password', 'age')  # 指定查询的字段，返回的是列表套字典
print(res)
注意：返回的结果只有是QuerySet对象的时候，才有query属性，才能看sql语句
print(res.query) # SELECT "app01_user"."username", "app01_user"."password", "app01_user"."age" FROM "app01_user"

res=models.User.objects.create() # 插入成功的这条记录对象
print(res.query)

第二种方式查看ORM的原生sql语句

去重, 每一条数据都要完全一样，如果说带主键，一定不会重复
res = models.User.objects.all().values('password', 'age').distinct()
print(res)

排序
order by age asc/desc
res = models.User.objects.all().order_by('age')  # 默认是升序排列
res = models.User.objects.all().order_by('-age')  # 降序排列
res = models.User.objects.all().order_by('age', 'id')  # 降序排列
res = models.User.objects.all().order_by('age', '-id', '')  # 降序排列

print(res)

反转,先排序，数据要先有序才能翻转
res=models.User.objects.all().order_by('-age').reverse()
print(res)

git----->测试环境------>中文-------->

count
select count(*) from user
res = models.User.objects.count()
print(res)

exclude 排除
res=models.User.objects.exclude(username='kevin1')
print(res)

exist
res = models.User.objects.filter(pk=20).first()
print(res)

查看内部sql语句的方式

# 方式1
res = models.User.objects.values_list('name','age')  # <QuerySet [('jason', 18), ('egonPPP', 84)]>
print(res.query)
queryset对象才能够点击query查看内部的sql语句

# 方式2:所有的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',
        },
    }
}

基于双划线的查询

双下划线查询
    1 年龄大于35岁的数据
    res = models.User.objects.filter(age__gt=35)
    print(res)
    2 年龄小于35岁的数据
    res = models.User.objects.filter(age__lt=35)
    print(res)
    大于等于 小于等于
    res = models.User.objects.filter(age__gte=32)
    print(res)
    res = models.User.objects.filter(age__lte=32)
    print(res)

    年龄是18 或者 32 或者40
    res = models.User.objects.filter(age__in=[18,32,40])
    print(res)

    年龄在18到40岁之间的  首尾都要
    res = models.User.objects.filter(age__range=[18,40])
    print(res)

    查询出名字里面含有s的数据  模糊查询
    res = models.User.objects.filter(name__contains='s')
    print(res)

    是否区分大小写  查询出名字里面含有p的数据  区分大小写
    res = models.User.objects.filter(name__contains='p')
    print(res)
    忽略大小写
    res = models.User.objects.filter(name__icontains='p')
    print(res)

    res = models.User.objects.filter(name__startswith='j')
    res1 = models.User.objects.filter(name__endswith='j')

    print(res,res1)


    查询出注册时间是 2020 1月
    res = models.User.objects.filter(register_time__month='1')
    res = models.User.objects.filter(register_time__year='2020')