框架Django

Posted 吃柚子的小白

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了框架Django相关的知识,希望对你有一定的参考价值。

一.基本命令

1.新建一个django project

django-admin.py startproject project_name
特别是在windows上如果报错,尝试使用django-admin代替django-admin.py

2.新建app

新建app需要切换到项目目录project_name下,即 cd project_name然后:
python manage.py startapp app_name
或django-admin.py startapp app_name

 

3.创建数据库表或更改数据库表或字段

Django 1.7.1及以上
1.创建更改的文件
python manage.py makemigrations
2.将生成的py文件应用到数据库
python manage.py migrate

旧版本Django1.6及以下
python manage.py syncdb

这种方法可以在SQL等数据库中创建与models.py代码对应的表,不需要自己手动执行SQL

4.使用开发服务器

开发服务器,一般修改代码后会自动重启,方便调试和开发,但是由于性能问题,建议只用在测试,不可用在生产环境

python manage.py runserver IP:PORT

5.清空数据库

python manage.py flush

6.创建超级管理员

python manage.py create superuser
修改用户密码
python manage.py changepassword username

7.导出数据 导入数据

python manage.py dumpdata appname > appname.json
python manage.py loaddata appname.json

8.Django项目环境终端

python manage.py shell

如果安装了bpython或ipython会自动调用它们的界面

这个命令和直接运行python或bpython进入shell的区别:可以在这个shell中调用当前项目的models.py中的API,对于操作数据和小测试都非常方便

9.数据库命令行

python manage.py dbshell

Django会自动进入settings.py中设置的数据库,如果是mysql或postgreSQL,则会要求输入数据库用户密码

10.更多命令

python manage.py

查看详细的命令列表

11.static静态文件配置

每个应用都需要配置static静态文件,在每个应用的目录下创建static文件夹,将每个应用所需的静态文件放在里面,在settings中加入

STATIC_ROOT=(
    os.path.join(BASE_DIR, "app_name/static")
)

{% load staticfiles %}
# <script src={% static "jquery-1.8.2.min.js" %}></script>
 

 

二.视图与网址

Django中网址写在urls.py文件中,用正则表达式对应view.py中的一个函数或者generic类

2.1定义视图函数


from django.shortcuts import render
def index(request):
    return render(request,\'index.html\')

定义一个index函数,第一个参数必须是request,与网页发来的请求有关,request变量中包含get或post的内容,用户浏览器,系统等信息在里面

2.2定义视图函数相关的URL网址,打开project_name/project_name/urls.py文件

from django.conf.urls import url,include
from django.contrib import admin
from blog import views
urlpatterns = [
    url(r\'^admin/\', admin.site.urls),
    url(r\'^$\',views.index),
    url(r\'^index/\',views.index),
    # url(r\'^(\\d{4})/$\',year_query) 如果想要获取匹配的值并传入后边的视图函数,可以把想要匹配的正则表达式加上括号,成为后边的视图函数的参数,并以位置参数的形式传入
    # url(r\'^(?P<year>\\d{4})/(?P<month>\\d{2})$\',views.year_query),  命名传入参数,以关键字参数传入
    # url(r\'reg/\',views.reg,name="register")
    url(r\'^blog/\',include(\'blog.urls\')) #新的应用需要添加对应的urls避免耦合,通过import include,并以该种形式实现对应应用的路由
]

路由分配系统

  功能:客服端访问的url的路径(path)与视图函数一一映射关系

  语法格式:

  urlpatterns = [

 

     url(正则表达式,views视图函数,参数,别名

    ]

  key: 通过路径分组传参数给视图函数

  向server端传参数方式:

  (1)通过数据:http://1277.0.0.1:8080/blog/?id=1200

  (2)通过路径:http://1277.0.0.1:8080/blog/1200

         url(r"blog/(\\d{4})")

2.3URL中的name

url(r\'^reg/\',views.reg,name="register")

简单说,name可以用于在templates,models,views……中得到对应的网址,相当于给网址取了个名字,只要名字不变,网址变了也能通过名字获得

我们注册页面用的是/reg/,如果以后网址进行了变更,比如改成了/new_client/,但在网页中,代码中很多地方都是写死的/reg/,如果是这样把网站写死了,会在更改了网址(正则)后,模板(templates),视图(views.py用于跳转),模型(models.py,获取对象对应的地址)用了此网址的,都需要进行相应的更改,十分繁琐

如果网址修改成了/new_client/,即urls.py进行了更改获取的网址也会动态地跟着改变,但是后面的name=\'register\'没有改变,这时{%url \'register\' %}就会渲染对应的网址成/new_client/

三.快捷函数

def login(request):
    if request.method=="POST":
        username=request.POST.get("username")
        pwd=request.POST.get("pwd")
        if username==\'xiaobai\' and pwd==\'123\':

            return redirect(\'/index/\')

    return render(request, "login.html")
#总结: render和redirect的区别:
#   1 if render的页面需要模板语言渲染,需要的将数据库的数据加载到html,那么所有的这一部分
#     除了写在yuan_back的视图函数中,必须还要写在login中,代码重复,没有解耦.

#   2 the most important: url没有跳转到/yuan_back/,而是还在/login/,所以当刷新后
#     又得重新登录.

四. Template

使用大括号来引用变量
<p>{{ a.1 }}</p>
<p>{{ a.0 }}</p>
<hr>
{% for person in querySet %}
    {{ person.name }}
{% endfor %}
<hr>
{% if i > 50 %}
    {{ i }}
{%else %}
    <p>50</p>
{% endif %}

==================

def index(request):

    i=65
    a=[11,22,33,44]
    d={"name":"xiaobai","age":22}
    class Person(object):
        def __init__(self,name):
            self.name=name

    p1=Person("xiaobai")
    p2=Person("xiaohei")
    p3=Person("xiaoming")

    querySet=[p1,p2,p3]
    return render(request,"index.html",locals())

五.创建模型models

1.新建项目和应用
django-admin.py startproject BookManage
cd BookManage
python manage.py startapp Book

2.添加应用
将新建的应用Book添加到settings.py中的INSTALLED_APPS中
INSTALLED_APPS = (
    \'django.contrib.admin\',
    \'django.contrib.auth\',
    \'django.contrib.contenttypes\',
    \'django.contrib.sessions\',
    \'django.contrib.messages\',
    \'django.contrib.staticfiles\',
 
    \'Book\',
)
3.修改models.py
class Book(models.Model):
    title=models.CharField(max_length=32)
    price=models.IntegerField()
    date=models.DateField()
    publish=models.CharField(max_length=32)
    author=models.CharField(max_length=32)
新建一个Book类,继承models.Model
4.创建数据表,使用SQLite3
cd BookManage
python manage.py makemigrations
python manage.py migrate

 六.标签的使用

{% if %}的使用

{% if i > 50 %}
    {{ i }}
{%else %}
    <p>50</p>
{% endif %}
==============
{% if %} 标签接受and,or或者not来测试多个变量值或者否定一个给定的变量
{% if %} 标签不允许同一标签里同时出现and和or,否则逻辑容易产生歧义,例如下面的标签是不合法的:

{% if obj1 and obj2 or obj3 %}

{% for %}的使用

<ul>
{% for obj in list %}
    <li>{{ obj.name }}</li>
{% endfor %}
</ul>
#在标签里添加reversed来反序循环列表:

    {% for obj in list reversed %}
    ...
    {% endfor %}

#{% for %}标签可以嵌套:

    {% for country in countries %}
        <h1>{{ country.name }}</h1>
        <ul>
         {% for city in country.city_list %}
            <li>{{ city }}</li>
         {% endfor %}
        </ul>
    {% endfor %}


#系统不支持中断循环,系统也不支持continue语句,{% for %}标签内置了一个forloop模板变量,
#这个变量含有一些属性可以提供给你一些关于循环的信息

1,forloop.counter表示循环的次数,它从1开始计数,第一次循环设为1:

    {% for item in todo_list %}
        <p>{{ forloop.counter }}: {{ item }}</p>
    {% endfor %}
2,forloop.counter0 类似于forloop.counter,但它是从0开始计数,第一次循环设为0
3,forloop.revcounter
4,forloop.revcounter0
5,forloop.first当第一次循环时值为True,在特别情况下很有用:

    
    {% for object in objects %}   
         {% if forloop.first %}<li class="first">{% else %}<li>{% endif %}   
         {{ object }}   
        </li>  
    {% endfor %}  
    
# 富有魔力的forloop变量只能在循环中得到,当模板解析器到达{% endfor %}时forloop就消失了
# 如果你的模板context已经包含一个叫forloop的变量,Django会用{% for %}标签替代它
# Django会在for标签的块中覆盖你定义的forloop变量的值
# 在其他非循环的地方,你的forloop变量仍然可用


#{% empty %}

{{li }}
      {%  for i in li %}
          <li>{{ forloop.counter0 }}----{{ i }}</li>
      {% empty %}
          <li>this is empty!</li>
      {% endfor %}

#         [11, 22, 33, 44, 55]
#            0----11
#            1----22
#            2----33
#            3----44
#            4----55

{% url %}引用配置的路由,与name方法连用

<form action="{% url "register"%}" >
          <input type="text">
          <input type="submit"value="提交">
          
</form>

6.1 加载标签库:自定义filter和simple_tag

6.1.1在应用目录下创建templatetags目录

6.1.2在templatetags目录下创建.py文件,如Mytag.py

语法格式:      {{obj|filter:param}}

   # 1  add          :   给变量加上相应的值
   #
   # 2  addslashes   :    给变量中的引号前加上斜线
   #
   # 3  capfirst     :    首字母大写
   #
   # 4  cut          :   从字符串中移除指定的字符
   #
   # 5  date         :   格式化日期字符串
   #
   # 6  default      :   如果值是False,就替换成设置的默认值,否则就是用本来的值
   #
   # 7  default_if_none:  如果值是None,就替换成设置的默认值,否则就使用本来的值
from django import template

register=template.Library() #register名字是固定的,不能任意定义

@register.filter
def multi(x,y):
    return x * y

@register.simple_tag
def multi_argu(x,y,z):
    return x * y * z

6.1.3在使用定义了simple_tag和filter的html文件中加载之前创建的Mytag.py:{% load Mytag%}

6.1.3使用simple_tag和filter

<h4>{{ d|date:"Y-m-d" }}</h4>
<h4>{{ w|truncatechars:5 }}</h4>
<h4>{{ w|truncatewords:5 }}</h4>
<h4>{{ s|default:"此处为空" }}</h4>
<h4>{{ i|multi:5 }}</h4>

<h4>{% multi_argu 4 5 6 %}</h4>


=========================

def index(request):
    i=10
    w="sadasljdlasjdlajsldajsljalsjldjasljdalsjljalsjldajskjad"
    d=datetime.datetime.now()
    s=""
    return render(request,"index.html",locals())
View Code

七.模板继承

在网站中,为了减少共用页面区域的重复和冗余代码,如导航,底部,访问统计代码等,Django提供了模板继承extend方法。模板集成就是先构造一个基础框架模板,而后在其子模板中对它所包含站点公用部分和定义块进行重载。

下面是base.html 和 index.html

"base.html"

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        .header{
            background-color: steelblue;
            height:48px;
            width:100%;
            position:fixed;
            top:0;
            left:0;

        }
        .left{
            position:fixed;
            top:48px;
            left:0;
            bottom:0;
            width:20%;
            background-color: palevioletred;
        }
        .right{
            overflow: scroll;
            position:fixed;
            top:48px;
            left:20%;
            bottom:0;
            width:80%;
            background-color: lightslategray;
        }
    </style>
</head>
<body>
    <div class="header"></div>
    <div class="content">
        <div class="left">
            <ul>
                <li>菜单一</li>
                <li>菜单二</li>
                <li>菜单三</li>
            </ul>
        </div>
        <div class="right">
            {% block con %}
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            <h1>bai</h1>
            {% endblock %}


            {% block page %}
            <h2>PAGE</h2>
            {% endblock %}
        </div>

    </div>



</body>
</html>

=======================================

{% extends "base.html" %}

{% block con %}
    {{ block.super }}  {# 继承con的所有内容并添加以下内容到con内容之后 #}
    <h3>xiao</h3>
    <h3>xiao</h3>
    <h3>xiao</h3>
    <h3>xiao</h3>
    <h3>xiao</h3>
    <h3>xiao</h3>
    <h3>xiao</h3>
    <h3>xiao</h3>
{% endblock %}

{% block page %}
    <h3>This is page</h3>
{% endblock %}

{% include "add.html" %}
View Code

八.数据库

1    django默认支持sqlite,mysql, oracle,postgresql数据库。

      sqlite

            django默认使用sqlite的数据库,默认自带sqlite的数据库驱动 , 引擎名称:django.db.backends.sqlite3

      mysql

            引擎名称:django.db.backends.mysql

2    mysql驱动程序

  •    MySQLdb(mysql python)
  •    mysqlclient
  •    MySQL
  •    PyMySQL(纯python的mysql驱动程序)

3     在django的项目中会默认使用sqlite数据库,在settings里有如下设置:

1    django默认支持sqlite,mysql, oracle,postgresql数据库。

     <1> sqlite

            django默认使用sqlite的数据库,默认自带sqlite的数据库驱动 , 引擎名称:django.db.backends.sqlite3

     <2> mysql

            引擎名称:django.db.backends.mysql

2    mysql驱动程序

  •    MySQLdb(mysql python)
  •    mysqlclient
  •    MySQL
  •    PyMySQL(纯python的mysql驱动程序)

3     在django的项目中会默认使用sqlite数据库,在settings里有如下设置:

更改MySQL配置修改如下

DATABASES = {

    \'default\': {

        \'ENGINE\': \'django.db.backends.mysql\', 

        \'NAME\': \'books\',    #你的数据库名称

        \'USER\': \'root\',   #你的数据库用户名

        \'PASSWORD\': \'\', #你的数据库密码

        \'HOST\': \'\', #你的数据库主机,留空默认为localhost

        \'PORT\': \'3306\', #你的数据库端口

    }

}

注意:

NAME即数据库的名字,在mysql连接前该数据库必须已经创建,而上面的sqlite数据库下的db.sqlite3则是项目自动创建

USER和PASSWORD分别是数据库的用户名和密码。

设置完后,再启动我们的Django项目前,我们需要激活我们的mysql。

然后,启动项目,会报错:no module named MySQLdb

这是因为django默认你导入的驱动是MySQLdb,可是MySQLdb对于py3有很大问题,所以我们需要的驱动是PyMySQL

所以,我们只需要找到项目名文件下的__init__,在里面写入:

import pymysql
pymysql.install_as_MySQLdb()

九.ORM模型

模型之间的三种关系:一对一,一对多,多对多

  一对一:在主外键的关系基础上,给外键添加一个UNIQUE=True的属性

  一对多:就是主外键关系 foreign key

  多对多:(ManyToManyField)自动创建第三张表,也可以自己创建第三张表

9.1 ORM 增加表记录

from app01.models import *

    #create方式一:   Author.objects.create(name=\'Alvin\')

    #create方式二:   Author.objects.create(**{"name":"alex"})

    #save方式一:     author=Author(name="alvin")
                            author.save()

    #save方式二:     author=Author()
                            author.name="alvin"
                            author.save()

一对多(ForeignKey):

# 一对多的记录创建方式
    # 方法一
    # Book.objects.create(
    #     title="小白的帅气是如何炼成的",
    #     price=999.99,
    #     publish_id=1
    #
    # )
    # 方法二
    # publish_obj=Publish.objects.get(id=2)
    # Book.objects.create(
    #     title="小白的英俊是如何炼成的",
    #     price=999.99,
    #     publish=publish_obj
    #
    # )

多对多 (ManyToManyField)

author1=Author.objects.get(id=1)
    author2=Author.objects.filter(name=\'alvin\')[0]
    book=Book.objects.get(id=1)
    book.authors.add(author1,author2)
    #等同于:
    book.authors.add(*[author1,author2])
    book.authors.remove(*[author1,author2])
    #-------------------
    book=models.Book.objects.filter(id__gt=1)
    authors=models.Author.objects.filter(id=1)[0]
    authors.book_set.add(*book)
    authors.book_set.remove(*book)
    #-------------------
    book.authors.add(1)
    book.authors.remove(1)
    authors.book_set.add(1)
    authors.book_set.remove(1)

#注意: 如果第三张表是通过models.ManyToManyField()自动创建的,那么绑定关系只有上面一种方式
#     如果第三张表是自己创建的:
class Book2Author(models.Model):
      author=models.ForeignKey("Author")
      Book=  models.ForeignKey("Book")
#     那么就还有一种方式:
            author_obj=models.Author.objects.filter(id=2).first()
            book_obj  =models.Book.objects.filter(id=3).first()

            s=models.Book2Author.objects.create(author_id=1,Book_id=2)
            s.save()
            s=models.Book2Author(author=author_obj,Book_id=1)
            s.save()

9.2 ORM 删除表记录

Book.objects.filter(id=1).delete()

9.3 ORM修改表记录

 Book.objects.filter(id=3).update(title="php")

#--------------- save方法会将所有属性重新设定一遍,效率低-----------
    obj=Book.objects.filter(id=3)[0]
    obj.title="Python"
    obj.save()

想要显示对应的SQL语句,需要在settings加上日志记录配置

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

9.4 ORM查询表记录

# 查询相关API:

#  <1>filter(**kwargs):      它包含了与所给筛选条件相匹配的对象

#  <2>all():                 查询所有结果

#  <3>get(**kwargs):         返回与所给筛选条件相匹配的对象,返回结果有且只有一个,如果符合筛选条件的对象超过一个或者没有都会抛出错误。

#-----------下面的方法都是对查询的结果再进行处理:比如 objects.filter.values()--------

#  <4>values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet,运行后得到的并不是一系列 model的实例化对象,而是一个可迭代的字典序列
                                     
#  <5>exclude(**kwargs):     它包含了与所给筛选条件不匹配的对象

#  <6>order_by(*field):      对查询结果排序

#  <7>reverse():             对查询结果反向排序

#  <8>distinct():            从返回结果中剔除重复纪录

#  <9>values_list(*field):   它与values()非常相似,它返回的是一个元组序列,values返回的是一个字典序列

#  <10>count():              返回数据库中匹配查询(QuerySet)的对象数量。

#  <11>first():               返回第一条记录

#  <12>last():                返回最后一条记录

#  <13>exists():             如果QuerySet包含数据,就返回True,否则返回False


# ret=Book.objects.values("title") #<QuerySet [{\'title\': \'小白的帅气是如何炼成的\'}, {\'title\': \'小白的英俊是如何炼成的\'}]>
# print(ret)
# ret=Book.objects.values_list("title","price") #<QuerySet [(\'小白的帅气是如何炼成的\', Decimal(\'999.99\')), (\'小白的英俊是如何炼成的\', Decimal(\'999.99\'))]>
# print(ret)
# ret=Book.objects.exclude(id=1)
# print(ret)

# book_list=Book.objects.all().iterator() #将查找对象转换为迭代器,节省资源
# for book in book_lis
 
单表 的 表记录查询

#    models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值
#
#    models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、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,
View Code

 9.5 单表正向查询和反向查询

# 正向查找
    # book_obj=Book.objects.filter(id=1).first()
    # print(book_obj.publish.name) #人民出版社

    # book_obj=Book.objects.filter(id=2).first()
    # author_list=book_obj.authors.all()
    # for author in author_list:
    #     print(author.name)

    # 反向查找
    # pub=Publish.objects.get(name="人民出版社")
    # ret=pub.book_set.all().values("title")
    # print(ret)
View Code

 9.6 多表条件关联正向和反向查询

#正向查找
#一对多
ret=Book.objects.filter(title="python").values.("publish__addr")
##[{\'publish__addr\': \'北京\'}]
#查询书名python的出版社地址
#多对多
ret=Book.objects.filter(title="python").values("author__name")
ret=Book.objects.filter(author__name="xiaobai").values("title")
#查询书名为python的作者名字

#反向查找
ret=Author.objects.filter(book__title="python").values("name")
View Code

十.聚合查询和分组查询

10.1 aggregate

通过对QuerySet进行计算,返回一个聚合值的字典。aggregate()中每一个参数都指定一个包含在字典中的返回值。即在查询集上生成集合

from django.db.models import Avg,Min,Sum,Max

Book.objects.all().aggregate(Avg("price"))
#查询所有图书的平均价格

aggregate()是QuerySet的一个终止子句,意思是说,它返回一个包含一些键值对的字典。键的名称是聚合值得标识符,值是计算而来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果想要指定一个名称,可以向聚合子句提供:
Book.objects.aggregate(average_price=Avg("price")

10.2 annotate

通过计算查询结果中每一个对象所关联的对象集合,从而计算出总值,即为查询集的每一项生成聚合