Django基本操作
1、创建一个django项目
django-admin startproject 项目名
2、用cd进入到项目里面，创建一个django应用
python manage.py startapp 应用名
3、启动django项目
python manage.py runserver IP 或 端口；（或者只写端口，或者两者都写）
manage.py : 与django进行交互的命令脚本
project_name
settings： 配置文件
urls ： 路由分发，url中的path（路径）与视图函数的一一
映射关系
在urls.py 文件中导入视图函数文件，写上路由关系！
示例：
from app01 import views
url(r'^login/', views.login),
项目与应用：
一个项目有多个应用
一个应用可以被多个项目拥有
两条同步记录
python manage.py makemigrations
python manage.py migrate
————————————————————————————————————————————————————
两个框架：学好哪一个都行
Django :大而全
Flask：小而精
MTV C
M：model
T：template
V: views
C: Controller(路由分配系统)
一 路由分配系统
功能：客户端访问的url的路径（path）与视图函数一一映射关系
语法格式：
urlpatterns = [
url(正则表达式, views视图函数，参数，别名),
]
key: 通过路径分组传参数给视图函数
无名分组：url(r'^(\d{4})/$', year_query),
# year_query(request,2007)
有名分组：url(r'^(?P<year>\d{4})/(?P<month>\d{2})$', year_query),
# year_query(request,year=2010,month=12)
name参数： url(r'^regq/', reg,name="register"),
二 视图函数（views）
请求对象： request
响应对象： httpresponse("")
request.method : 请求方式----->>GET POST
request.GET : 存放 get请求数据
request.POST : 存放 post数据
Httpresponse("") ------>实例字符创对象
render ------>模板的渲染 render（request,"html"，{key：value}）
"html"：模板（template） {key：value}： Context
redirect ------>跳转
模板语言： 渲染变量 {{}} 渲染标签 {% %}
渲染可以渲染字符串、列表、字典、数字都行，且双大括号中只能填写
一个东西，不可用逗号作为分隔写多个值
目的： 将变量嵌入到html中
注意：
1 只要带有模板语法的html都成为模板
2 render方法渲染时 把后端变量嵌入到模板中
关于redirect与render的区别：
redirect走的是路径！！！！！----->>需要url里面设置
映射，需要views中设置def函数，利用函数
##重点redirect这个跳转，是跳转到一个路
径下面，然后在通过路径，进行返回相应的函数！！！！！！！！
render返回的是模板(页面)！！！！！
————————————————————————————————————————————————————
模板的深度查询----->>句点方法，就是用小数点，这种深度操作，只有这一种方法，记住了：
举例：在views中写这个
def index(request):
name='yuan'
i=17
l=[12,45,77]
d={'name':"egon","age":111}
然后运行，执行之后，显示出效果，如下
http://127.0.0.1:8000/index/
<h3>{{ i }}</h3> #17
<h3>{{ l }}</h3> #[12, 45, 77]
<h3>{{ d }}</h3> #{'name': 'egon', 'age': 111}
<hr>
<p>{{ l.0 }}</p> #12
<p>{{ l.1 }}</p> #45
<p>{{ l.2 }}</p> #77
取字典中的值,上面的标签随意用，可以用其他的，这里用p标签是为了换行用
用<p>{{ d.name }}</p>
<p>{{ d.age }}</p>
★★★★★
locals----->>区域变量 当地人 局部变量
locals表示本地变量，用这个的话，无论现在页面是什么变量，都在前端里面对应它的名
字，即可直接使用，
这样就可以少些很多变量了，直接代替上一行代码写的这么多大括号里面的东西，看下面
对比
#return render(request,"index.html",{"name":name,"i":i,"l":l})
#return render(request,"index.html",locals())
取值操作：
def index(request):
name='yuan'
i=17
l=[12,45,77]
d={'name':"egon","age":111}
class Person(object):
def __init__(self,name):
self.name=name
p1=Person('egon')
p2=Person('阿猫')
p3=Person('阿狗')
querySet=[p1,p2,p3]
return render(request,"index.html",locals())
第一种取值操作（不推荐使用）
{{ querySet.0.name }}#取到的是第一个实例对象的名字
第二种取值方式：
{% for person in querySet %} #也就是for 类 in （定义的）列表
<p>{{ person.name }}</p>
{% endfor %}
<hr>
{% if i > 100 %}
<p>100</p>
{% elif i > 50 %}
<p>大于50小于100</p>
{% else %}
<p>{{ i }}</p>
{% endif %}
重点说明：
注意for 和endfor； if elif 和endif，一定要首尾结合使用，否则报错；都是大括号和
百分号括起来，以及注意格式！
{% for 条件 %}
语句
{% endfor %}
若是有条件判断：
{% if 条件 %}
语句
{% else %}
语句
{% endif %}
导入静态（static）文件：
一般在应用下面放入bookstrap文件，一般设置名字为static，然后把dist文件名改成
bookstrap，这个里面放bookstrap放入static中
注意：
1、导入静态文件的时候，要在settings里面进行路径拼接，使其找到bookstrap
的绝对路径
2、在每个html文件的最顶端都加上 {% load staticfiles %} 这个，这个是
django使用静态文件用的，否则没法用静态文件
老师总结的：
引入静态文件
1 将所有静态文件放到一个static的文件夹
2 将static文件夹放到应用下
3 STATIC_URL = '/static/' # 别名
STATIC_ROOT=(
os.path.join(BASE_DIR,"appBook/static"),
)
4 在模板首行加上{% load staticfiles %}
5 引入文件： {% static 具体路径 %}
数据库与ORM
ORM 表示：对象关系映射
在ORM中，
表名----->>对应类名
字段----->>类属性----->>就是id、name、sex，age这些
表中的一条记录----->>类实例对象----->>就是名字，性别，
年龄是多少，等等
目的：通过python代码实现对数据库的增删改查
models
是跟数据库搞关系的，可直接调用models类
项目流程：
设计表关系：
create table book（
id int primary key,
name varchar(20),
price double(5,2),
）
python manage.py makemigrations
python manage.py migrate
一对多的添加关系：
方式1：
Book.objects.create(
title="python",
price=100.00,
publish_id=2
)
方式2：
book_obj=Book.objects.get(id=1)
book_obj.publish :book_obj 关联的出版社对象（一定是一个对象）
Book.objects.create(
title="python",
price=100.00,
publish=
)
查询API：
表.objects.all() 得到是QuerySet集合对象------ [obj1,obj2,]
表.objects.filter(id=2) 得到是QuerySet集合对象-------[obj1,]
表.objects.get(id=2) 得到是Model对象 obj
万能的__
级联
oncascade
————————————————————————————————————————————————————
模板：
加载标签库:自定义filter和simple_tag
下面的abcde是步骤顺序
a、在app中创建templatetags模块(必须的)
b、创建任意 .py 文件，如：my_tags.py
复制代码
from django import template
from django.utils.safestring import mark_safe
register = template.Library() #register的名字是固定的,不可改变
@register.filter
def filter_multi(v1,v2):
return v1 * v2
@register.simple_tag
def simple_tag_multi(v1,v2):
return v1 * v2
@register.simple_tag
def my_input(id,arg):
result = "<input type='text' id='%s' class='%s' />" %(id,arg,)
return mark_safe(result)
复制代码
c、在使用自定义simple_tag和filter的html文件中导入之前创建的 my_tags.py ：{% load
my_tags %}
d、使用simple_tag和filter（如何调用）
-------------------------------.html
{% load xxx %} #首行
# num=12
{{ num|filter_multi:2 }} #24
{{ num|filter_multi:"[22,333,4444]" }}
{% simple_tag_multi 2 5 %} 参数不限,但不能放在if for语句中
{% simple_tag_multi num 5 %}
复制代码
e、在settings中的INSTALLED_APPS配置当前app，不然django无法找到自定义的simple_tag.
注意：
filter可以用在if等语句后，simple_tag不可以
{% if num|filter_multi:30 > 100 %}
{{ num|filter_multi:30 }}
{% endif %}
模板的继承
步骤如下：
母版
1、创建base.html文件，在这个文件的某个内容区中写上
{{% block XXX %}}
{{% endblock %}}
2、子板(html文件)继承母版的时候，需要在最顶端或者内容上面写上{{%extends "base.html" %}}
然后写{{% block XXX %}} 这两个要和母版中的一样
{{% endblock %}}
这样就完成步骤了！
母版的补充：
<1>如果在模板中使用 {% extends %} ，必须保证其为模板中的第一个模板标记。 否则，
模板继承将不起作用。
<2>一般来说，基础模板中的 {% block %} 标签越多越好。 记住，子模板不必定义父模板中所有
的代码块，因此
你可以用合理的缺省值对一些代码块进行填充，然后只对子模板所需的代码块进行（重）定义
。
<3>如果发觉自己在多个模板之间拷贝代码，你应该考虑将该代码段放置到父模板的某个 {% block
%} 中。
如果你需要访问父模板中的块的内容，使用 {{ block.super }}这个标签吧，这一个魔法变量
将会表现出父模
板中的内容。 如果只想在上级代码块基础上添加内容，而不是全部重载，该变量就显得非常有
用了。
<4>不允许在同一个模板中定义多个同名的 {% block %} 。 存在这样的限制是因为block 标签的
工作方式是双向的。
也就是说，block 标签不仅挖了一个要填的坑，也定义了在父模板中这个坑所填充的内容。如
果模板中出现了两个
相同名称的 {% block %} 标签，父模板将无从得知要使用哪个块的内容。
————————————————————————————————————————————————————
django跟mysql共同使用进行步骤总结：
设置mysql
1、需要先创建数据库，创建数据库的时候，干脆直接设置成utf8的格式
2、下一步，在settings里面进行下面databases的修改，把系统默认的直接注释掉
3、记得在settings看看有木有自己的django应用名
4、编写models，在里面创建表，也就是相当于创建类，因为表跟类是一一对应的
5、记得在项目下面的__init__.py文件件里面导入pymsql，以及写上这个
pymysql.install_as_MySQLdb()
6、做好这些之后，输入两条命令，进行迁移（同步）
7、若需要安装数据库，那么记得在数据库上写上自己的django项目名，以及数据库的用户
名和密码，点击添加应用即可
————————————————————————————————————————————————————
ORM之查（filter,value)
查询API：
# 查询相关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
---------------了不起的双下划线(__)之单表条件查询----------------
# 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,
QuerySet与惰性机制
所谓惰性机制：Publisher.objects.all()或者.filter()等都只是返回了一个QuerySet（查询结果集对象），它并不会马上执行sql，而是当调用QuerySet的时候才执行。
QuerySet特点：
<1> 可迭代的
<2> 可切片
#objs=models.Book.objects.all()#[obj1,obj2,ob3...]
#QuerySet: 可迭代
# for obj in objs:#每一obj就是一个行对象
# print("obj:",obj)
# QuerySet: 可切片
# print(objs[1])
# print(objs[1:4])
# print(objs[::-1])
QuerySet的高效使用：
<1>Django的queryset是惰性的
Django的queryset对应于数据库的若干记录（row），通过可选的查询来过滤。例如，下面的代码会得
到数据库中名字为‘Dave’的所有的人:person_set = Person.objects.filter(first_name="Dave")
上面的代码并没有运行任何的数据库查询。你可以使用person_set，给它加上一些过滤条件，或者将它传给某个函数，
这些操作都不会发送给数据库。这是对的，因为数据库查询是显著影响web应用性能的因素之一。
<2>要真正从数据库获得数据，你可以遍历queryset或者使用if queryset,总之你用到数据时就会执行sql.
为了验证这些,需要在settings里加入 LOGGING(验证方式)
obj=models.Book.objects.filter(id=3)
# for i in obj:
# print(i)
# if obj:
# print("ok")
<3>queryset是具有cache的
当你遍历queryset时，所有匹配的记录会从数据库获取，然后转换成Django的model。这被称为执行
（evaluation）.这些model会保存在queryset内置的cache中，这样如果你再次遍历这个queryset，
你不需要重复运行通用的查询。
obj=models.Book.objects.filter(id=3)
# for i in obj:
# print(i)
## models.Book.objects.filter(id=3).update(title="GO")
## obj_new=models.Book.objects.filter(id=3)
# for i in obj:
# print(i) #LOGGING只会打印一次
<4>
简单的使用if语句进行判断也会完全执行整个queryset并且把数据放入cache，虽然你并不需要这些
数据！为了避免这个，可以用exists()方法来检查是否有数据：
obj = Book.objects.filter(id=4)
# exists()的检查可以避免数据放入queryset的cache。
if obj.exists():
print("hello world!")
<5>当queryset非常巨大时，cache会成为问题
处理成千上万的记录时，将它们一次装入内存是很浪费的。更糟糕的是，巨大的queryset可能会锁住系统
进程，让你的程序濒临崩溃。要避免在遍历数据的同时产生queryset cache，可以使用iterator()方法
来获取数据，处理完数据就将其丢弃。
objs = Book.objects.all().iterator()
# iterator()可以一次只从数据库获取少量数据，这样可以节省内存
for obj in objs:
print(obj.name)
#BUT,再次遍历没有打印,因为迭代器已经在上一次遍历(next)到最后一次了,没得遍历了
for obj in objs:
print(obj.name)
#当然，使用iterator()方法来防止生成cache，意味着遍历同一个queryset时会重复执行查询。所以使
#用iterator()的时候要当心，确保你的代码在操作一个大的queryset时没有重复执行查询
总结:
queryset的cache是用于减少程序对数据库的查询，在通常的使用下会保证只有在需要的时候才会查询数据库。
使用exists()和iterator()方法可以优化程序对内存的使用。不过，由于它们并不会生成queryset cache，可能
会造成额外的数据库查询。
对象查询，单表条件查询，多表条件关联查询
#--------------------对象形式的查找--------------------------
# 正向查找
ret1=models.Book.objects.first()
print(ret1.title)
print(ret1.price)
print(ret1.publisher)
print(ret1.publisher.name) #因为一对多的关系所以ret1.publisher是一个对象,而不是一个queryset集合
# 反向查找
ret2=models.Publish.objects.last()
print(ret2.name)
print(ret2.city)
#如何拿到与它绑定的Book对象呢?----->>book_set,这个是django自己给我们设置的，一定要记住！
print(ret2.book_set.all()) #ret2.book_set是一个queryset集合
#---------------了不起的双下划线(__)之单表条件查询----------------
# 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,
#----------------了不起的双下划线(__)之多表条件关联查询---------------
# 正向查找(条件)
# ret3=models.Book.objects.filter(title='Python').values('id')
# print(ret3)#[{'id': 1}]
#正向查找(条件)之一对多
ret4=models.Book.objects.filter(title='Python').values('publisher__city')
print(ret4) #[{'publisher__city': '北京'}]
#正向查找(条件)之多对多
ret5=models.Book.objects.filter(title='Python').values('author__name')
print(ret5)
ret6=models.Book.objects.filter(author__name="alex").values('title')
print(ret6)
#注意
#正向查找的publisher__city或者author__name中的publisher,author是book表中绑定的字段
#一对多和多对多在这里用法没区别
# 反向查找(条件)
#反向查找之一对多:
ret8=models.Publisher.objects.filter(book__title='Python').values('name')
print(ret8)#[{'name': '人大出版社'}] 注意,book__title中的book就是Publisher的关联表名
ret9=models.Publisher.objects.filter(book__title='Python').values('book__authors')
print(ret9)#[{'book__authors': 1}, {'book__authors': 2}]
#反向查找之多对多:
ret10=models.Author.objects.filter(book__title='Python').values('name')
print(ret10)#[{'name': 'alex'}, {'name': 'alvin'}]
#注意
#正向查找的book__title中的book是表名Book
#一对多和多对多在这里用法没区别
注意：条件查询即与对象查询对应，是指在filter，values等方法中的通过__来明确查询条件。
ORM 1 添加方法 表.objects.create() obj=类(title="") obj.save() 外键字段添加方式（一对多） Book.objects.create(title="",price="",publish_id=) # publish_id对应的Publish表中的主键id Book.objects.create(title="",price="",publish=pub_obj) # publish_id对应的Publish表中的主键id book_obj.publish : 与这本书相关联的出版社对象（一个） 创建一对多用：ForeignKey
eg:
publish=models.ForeignKey("Publish", default=1)
外键字段添加方式（多对多） authors=models.ManyToManyFields("Author") book_obj.authors : 与这本书相关的所有的作者集合（querySet） book_obj.authors.add(obj1,obj2) book_obj.authors.add(*[]) book_obj.authors.remove(obj) book_obj.authors.clear() 2 查询方法 表.objects.all() -----------QuerySet [obj,obj] 表.objects.filter(id__gt=3,id__lt=6) -----------QuerySet [obj,obj] 表.objects.get() -----------model对象 QuerSet.first() -----------model对象 QuerSet.last() -----------model对象 eg: 表.objects.all().first() 表.objects.values(字段) --------- 存放字典的集合对象 <QuerySet [{'price': Decimal('45.00'), 'title': 'linux'}, {'price': Decimal('100.00'), 'title': '老男孩历险记'}, {'price': Decimal('12.00'), 'title': '老男孩感情史'}]> QuerySet: 1 可切片 2 可迭代 3 惰性机制 iterator exits 连表查询 class Book_authors(): book_id=... author_id=.... class Author(): name=..... #books=models.ManyToManyFields("Book") class Publish(): name=.... class BOOK(): title=... publish=... authors=..... 1 基于对象 正向查询： # 查询某本书的出版社或者作者信息 book_obj=BOOK.objects.get(id=4) book_obj.publish # 与这本书相关联的出版社 book_obj.authors # 与这本书关联的作者对象集合 反向查询： # 查询某个出版社出版过的书 # 查询某个作者出版社过的书 author_obj=Author.objects.get(id=2) author_obj.关联表名__set author_obj.book__set # 与这个作者关联的所有书籍对象的集合 2 基于 filter values __ 表.objects.filter().values() # 查询python这本书的出版社名字 BOOK.objects.filter(title="python").values(publish__name) Publish.objects.filter(book__title="python").values("name") 聚合与分组 在sql： select max() group by 字段 having select Avg(score) from stu aggreagte: Book.objects.all().aggregate(AvgPrice=Avg("price")) annotate: # 每一个作者出版过的书中的最高价 ： 按作者名字分组 ret4=Book.objects.values("authors__name").annotate(Max("price")) print(ret4) F Q F: Book.objects.all().update(price=F("price")+20) Q: Book.objects.filter(Q(price__gt=200) | Q(id__gt=5) ,title__startswith="老") 3 修改方法 Book.objects.filter(id=5).update(price=1000) 4 删除 Book.objects.filter(id=5).delete() # 级联删除
F查询和Q查询
仅仅靠单一的关键字参数查询已经很难满足查询要求。此时Django为我们提供了F和Q查询：
# F 使用查询条件的值,专门取对象中某列值的操作
# from django.db.models import F
# models.Tb1.objects.update(num=F('num')+1)
# Q 构建搜索条件
from django.db.models import Q
#1 Q对象(django.db.models.Q)可以对关键字参数进行封装，从而更好地应用多个查询
q1=models.Book.objects.filter(Q(title__startswith='P')).all()
print(q1)#[<Book: Python>, <Book: Perl>]
# 2、可以组合使用&,|操作符，当一个操作符是用于两个Q的对象,它产生一个新的Q对象。
Q(title__startswith='P') | Q(title__startswith='J')
# 3、Q对象可以用~操作符放在前面表示否定，也可允许否定与不否定形式的组合
Q(title__startswith='P') | ~Q(pub_date__year=2005)
# 4、应用范围：
# Each lookup function that takes keyword-arguments (e.g. filter(),
# exclude(), get()) can also be passed one or more Q objects as
# positional (not-named) arguments. If you provide multiple Q object
# arguments to a lookup function, the arguments will be “AND”ed
# together. For example:
Book.objects.get(
Q(title__startswith='P'),
Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))
)
#sql:
# SELECT * from polls WHERE question LIKE 'P%'
# AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')
# import datetime
# e=datetime.date(2005,5,6) #2005-05-06
# 5、Q对象可以与关键字参数查询一起使用，不过一定要把Q对象放在关键字参数查询的前面。
# 正确：
Book.objects.get(
Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),
title__startswith='P')
# 错误：
Book.objects.get(
question__startswith='P',
Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))
增删改查 有待总结....未完待续.......
详细参考博客：http://www.cnblogs.com/yuanchenqi/articles/6811632.html