DJANGO学习笔记

IF标签.注意表达式里面键值要有空格

{% if 条件表达式1 %}
...
{% elif 条件表达式2 %}
...
{% elif 条件表达式3 %}
...
{% else %}
...
{% endif %}

locals

#locals() 函数会以字典类型返回当前位置的全部局部变量。
def runoob(arg):    # 两个局部变量：arg、z
     z = 1
     print (locals())

runoob(4)

#结果
{'z': 1, 'arg': 4}      # 返回一个名字/值对的字典

for

1、语法

{% for 变量 in 可迭代 %}
...循环语句
{% empty %}
....无可迭代时填充
{% endfor%}


2、内置变量-forloop

forloop.counter 从1开始索引
forloop.counter0 从0开始索引
forloop.revcounter 从1开始索引，迭代次数
forloop.revcounter0 从0开始索引，迭代次数
forloop.first 第一条出现时
foloop.last 最后一条出现时
forloop.parent

过滤器

{{变量|过滤器1:参数1|过滤器2:参数2}}

lower	转化成小写
upper	转化成大写
safe	默认不对变量内字符转义
truncatechars:"n"	截取多少字符

模板继承extends

导入：{% extends "tempalteName" %}
重写：
{% block block_name %}
HTML
{% endblock block_name %}

调用图片

第一步：初始化
{% static %}

第二步：调用标签
语法：{% static "静态地址" %}

数据迁移

#生成迁移命令
python3 manage.py makemigrations
#执行迁移
python3 manage.py migrate

增删改查

对象：MyModel.objects
方法：
all()#查询全部纪录
get()#查询符合条件的单一纪录
filter()#查询符合条件的多条纪录
exclude()##查询符合条件之外的全部纪录

一、ALL
如果需要，可以输出字符串
在类下面加：
def __str__(self):
    return "书名%s"%s

1、正常输出：
MyModel.objects.all()
2、返回指定列：字典
values("列1","列2")
等同于 select 列1，列2 from XXX
返回为字典
eg:book=models.Book.objects.values("title","pub")
3、返回指定列：元组
values_list("列1","列2")
4、排序查询order_by
MyModel.objects.order_by("-列","列")
-表示降序，不加则升序

二、筛选
eg:books = models.Book.objects.filter(属性1=值1，属性2=值2)
查询谓词：
__exact：等值匹配
__contains：包含指定值
__startswith：以xxx开始
__endswith：以xxx结束
__gt：大于指定值
__gte：大于等于
__lt：小于
__lte：小于等于
__in：查找数据是否在指定范围内
__range：查找数据是否在指定的区间范围内

三、get
models.Book.object.get(id=10)
四、改
单个：
abook=models.Book.object.get(id=10)
abook.price=100
abook.save()
多个：
指定条件：
books=models.Book.object.filter(id__gt=3)
books.update(price=12)
全部：
books=models.Book.object.all()
books.update(price=12)



五、删除
单个：
books=models.Books.object.get(id=1)
books.delete()
多个：
books=models.Books.object.all()
books.delete()


六、聚合查询
1、不带分组
from django.db.models import *
Sum/Avg/Count/Max/Min
语法：
MyModel.objects.aggregate(结果变量名=聚合函数)
返回结果为字典{"结果名","值"}
eg:查询平均值
from django.db.models import Avg
models.Book.objects.arggregate(myAvg=Avg)
eg:统计所有
from django.db.models import Count
models.Book.objects.arggregate(myAvg=Count("market_price"))
2、分组结合
querySet.annotate
先做查询，后做集合
eg:
pub_count_set=pub_set.annotate(myCount=Count("pub"))

F对象

一、需求：把每一本书原来的价格涨10块钱
from django.db.models import F
books=models.Book.objects.all()
books.update(market_price=F("market_price")+10)
二、字段值进行比较:查询零售价大于定价的书
from django.db.models import F
books=models.Book.objects.filter(market_price__=F("price"))

Q对象

from jdango.db.models import Q
Q(条件1)|Q(条件2)：条件1或条件2都成立
Q(条件1)&Q(条件2)：条件1和条件2都成立
Q(条件1)&~Q(条件2)：条件1成立，条件2不成立

原生SQL执行

方法一：只能查询
MyModel.objects.raw('sql语句')

方法二：导入游标
from django.db import connection
with connection.cursor() as cur:
    cur.execute('sql语句')

后台管理

一、创建账号：
python3 manage.py createsuperuser

二、admin.py注册类：
from . import models
class BookManage(admin.ModelAdmin):
    list_display = ["id", "title","pub","price"]
admin.site.register(models.Book, BookManage)
admin.site.register(models.Author)
三、其它设置
list_display/list_display_links/list_filter/searcha_fields/list_editable

数据映射

from .import models
一、一对一
#模型创建
author = models.OneToOneField(Author, on_delete=models.DO_NOTHING)
#创建关联
author1=models.Author.objects.create(name="张三")
wife1=models.Wife.object.create(name="张夫人",author=author1)


#正向查询关联
wife=models.Wife.objects.create(name="xxx")
wife.author

#反向查询,小写，要用try
author1.wife

二、一对多
from django.db import models

#创建类
class Publisher(models.Model):
"""出版社"""
    name=models.CharField("名称",max_lenght=50,unique=True)
    pubNew = models.ForeignKey(Publisher, verbose_name="出版社", to_field="name", on_delete=models.CASCADE, null=True)

#查询
多查一
abook=models.Book.objects.get(id=1)
abook.publisher.name
一查多
pub1=models.Publisher.objects.get(name="XXX")
books=pub1.book_set.all()
book_set就是管理器对象，也就是类名小写
"""
author.book_set.all()
author.book_set.filter()
author.book_set.create(...)创建新书并关联
author.book_set.add(book) 添加已有书的当前作者
author.book_set.clear() 删除author所有关联的书
author.book_set.remove() 删除所author所有关联的书
"""

三、多对多
#创建类
属性=models.ManyTOmanyField(Mymodel)
eg:
一个作者可以出版多本书，一本书可以被多个作者编写
class Author(models.Model):
    name....
class Book(models.Model):
    title....
    authors=models.ManyToManyField(Author)

#创建数据

第一步：创建两个作者
author1=models.Author.object.create(name="AAA")
author2=models.Author.object.create(name="BBB")

第二步：AAA和BBB同时写了一本书 Python
book1=author2.book_set.create(title="Python") #创建一本书，并且中间表也创建了纪录
author2.book_set.add(book1)

#查询
通过书查作者
book1=models.Book.objects.get(title="Pythons")
book1.authors.all()
通过作者查书
wei=models.Author.object.get(id=2)
wei.book_set.all()

COOKIES&&SESSION

一、设置COOKIE

HttpResponse.set_cookie(key,value="",max_age=None,expires=None)
key:cookie名字
value:cookie值
max_age:存活时间，单位秒
expires:具体过期时间
当不指定max_age和expires时，关闭浏览器数据失效
eg:

二、删除COOKIE

HttpResponse.delete_cookie(key)

三、获取COOKIE
value=request.COOKIES.get("cookies名","值名")
四、查看站点COKKIE：
dic=request.COOKIES
print(dic)

三、保存SESSION
request.session["key"]=value
四、获取
value=request.session["key"]
value=request.session("key","default_value")
五、删除
del request.session["key"]

中间键

from django.utils.deprecation import MiddlewareMixin

from django.http import HttpResponse
from django.http import Http404


class MyMW(MiddlewareMixin):
    def process_request(self, request):
        print("请求：中间键 process_request running")
        # if request.method == "GET":
        #     return HttpResponse("canot get")

    def process_view(self, request, callback, callback_args, call_kwargs):
        print("请求：中间键 process_view running")

    def process_response(self, request, response):
        print("请求：中间键 process_response running")
        return response

    def process_exception(self, request, exception):
        print("请求：中间键 process_exception running")

    def process_template_response(self, request, response):
        print("请求：中间键 process_process_template_response running")