框架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())

七.模板继承

在网站中，为了减少共用页面区域的重复和冗余代码，如导航，底部，访问统计代码等，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;
            100%;
            position:fixed;
            top:0;
            left:0;

        }
        .left{
            position:fixed;
            top:48px;
            left:0;
            bottom:0;
            20%;
            background-color: palevioletred;
        }
        .right{
            overflow: scroll;
            position:fixed;
            top:48px;
            left:20%;
            bottom:0;
            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" %}

八.数据库

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',
        },
    }
}

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,

 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)

 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")

十.聚合查询和分组查询

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

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

Book.objects.filter(author__name="xiaobai").values("title")
#查询作为为xiaobai写的所有书
Book.objects.filter(authors__name="xiaobai").aggregate(Sum("price"))
#查询xiaobai所有书的价格

#查询每个作者所写书的总价格涉及到分组
Book.objects.values("author__name"").annotate(Sum("price"))

#查询各个出版社价格最低的书
Book.objects.vaues("publish__name").annotate(Min("price"))
#[{"publish__name":"北大出版社","price__min":Decimal("10.00")},
{"publish__name":"人民出版社","price__min":Decimal("20.00")},
{"publish__name":"河北出版社","price__min":Decimal("30.00")},
]

10.3 F查询和Q查询

from django.db.models import F,Q

#F使用查询条件的值，专门取对象中某列值的操作
Book.objects.all().update(price=F("price")+20)

#Q构建检索条件

Book.objects.filter(Q(price__gt=200) | Q(id__gt=5) , Q(title__startswith="小"))
以小开头的价格或者ID大于5的书

#Q可以对关键字参数进行封装，从而应用多个条件查询

# 可以组合使用&,|操作符，当一个操作符是用于两个Q的对象,它产生一个新的Q对象。
    Q(title__startswith='P') | Q(title__startswith='J')
 # Q对象可以用~操作符放在前面表示否定，也可允许否定与不否定形式的组合
    Q(title__startswith='P') | ~Q(pub_date__year=2005)