1、 配置文件：
media：
avatar = models.FileField(upload_to='avatar') sessiongs MEDIA_ROOT=os.path.join(BASE_DIR,"blog","media","uploads") 文件上传：BASE_DIR/"blog"/"media"/"uploads"/avatar/a.png urls
# media 配置
MEDIA_URL="/media/"
url(r'^media/(?P<path>.*)$', serve, {'document_root': settings.MEDIA_ROOT}), <img src="/media/avatar/a.png">
2、url配置：
url(r'^articles/([0-9]{4})/$', views.year_archive), # year_archive(request,1990) 无名分组
url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive), # year_archive(request,year=1990) 有名分组
3、反向解析：
in urls:
url(r'^articles/([0-9]{4})/$', views.year_archive, name='news-year-archive'),
url(r'^index/$', views.index, name='Index'),
方式一
in template(模板反向解析): <a href="articles/2012/">2012 Archive</a>
<a href="{% url 'news-year-archive' 2012 %}">2012 Archive</a>
方式二
in views（视图函数反向解析）:
from django.core.urlresolvers import reverse
from django.http import HttpResponseRedirect #return redirect("/index/") # hard code
return HttpResponseRedirect(reverse('Index'))
4、视图函数：
请求对象---request：
1、HttpRequest.body： 请求元数据 2、HttpRequest.path：一个字符串，表示请求的路径组件（不含域名）
3、HttpRequest.method 5、HttpRequest.GET
6、HttpRequest.POST 7、HttpRequest.FILES 8、HttpRequest.user ： 一个 AUTH_USER_MODEL 类型的对象
响应对象：
return HttpResponse("") # 返回字符串实例
return render(request,"template",{"":""}) # 返回字符串实例 （**********）
return redirect("/index/") # 重定向 （**********）
5、模板语言：
views：
def foo():
name="yuan"
l=[111,222,333]
d={"info":[obj1,obj2]}
return render(request,"index.html",locals())
1、变量：{{name}}
---深度查询 句点符 {{l.0}} {{d.info.0.name}}
----过滤器：{{name|date:"Y-m-d"}}
2、标签
{%for i in l%}
{{ i }}
{%empty%}
<p>没有符合条件的书籍</p>
{%endfor%}
--------
{%if name == "yuan"%}
<p>真帅</p>
{%elif ...%}
{%endif%}
3、继承模板：
(1) base.html : {%block con%}{%end block con%}
(2) index.html:
{% extends "base.html"%} 继承
{%block con%}
{{block.super}} 模板盒子中内容
{%end block con%} 覆盖
6、models（模型） -----ORM
映射关系：
sql中表名--------------python的类名
sql中表的字段----------python的类属性
sql中表的记录----------python的类对象 class Article(models.Model):
nid = models.BigAutoField(primary_key=True)
title = models.CharField(max_length=50, verbose_name='文章标题')
read_count = models.IntegerField(default=0)
单表操作：
添加操作
views：
#方法1：
article_obj=models.Article.objects.create(nid=1,title="yuan",read_count=12) # create方法返回的是当前创建的文章对象 #方法2：
article_obj=models.Article(nid=1,title="yuan",read_count=12)
article_obj.save()
删除：
models.Article.objects.filter(title="python").delete() # 默认级联删除
修改：
models.Article.objects.filter(title="python").update(read_count=F("read_count")+10) 查询API：
<1> all(): 查询所有结果 #QuerySet <2> filter(**kwargs): 它包含了与所给筛选条件相匹配的对象 #QuerySet <3> get(**kwargs): 返回与所给筛选条件相匹配的对象，返回结果有且只有一个，
如果符合筛选条件的对象超过一个或者没有都会抛出错误。# model对象 <5> exclude(**kwargs): 它包含了与所给筛选条件不匹配的对象 #QuerySet <4> values(*field): 返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列
model的实例化对象，而是一个可迭代的字典序列 #QuerySet <9> values_list(*field): 它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列 #QuerySet <6> order_by(*field): 对查询结果排序 #QuerySet <7> reverse(): 对查询结果反向排序 #QuerySet <8> distinct(): 从返回结果中剔除重复纪录 #QuerySet <10> count(): 返回数据库中匹配查询(QuerySet)的对象数量。 # int <11> first(): 返回第一条记录 # model对象 <12> last(): 返回最后一条记录 # model对象 <13> exists(): 如果QuerySet包含数据，就返回True，否则返回False
querySet支持链式操作：
models.Article.objects.all().filter().values().distinct().count()
QuerySet数据类型：
1、可切片，可迭代 [obj,....]
2、惰性查询：
articles_list=models.Article.objects.all()
使用articles_list，比如if articles_list，这时转换sql语句 3、缓存机制
articles_list=models.Article.objects.all()
for i in articles_list：
print(i.title) # hit the database for i in articles_list：
print(i.title) # not hit the database ==============================================
for i in models.Article.objects.all()：
print(i.title) # hit the database for i in models.Article.objects.all()：
print(i.title) # hit the database
4、优化查询
articles_list=models.Article.objects.all().iterator()
for i in articles_list：
print(i.title) # hit the database for i in articles_list：
print(i.title) # 无结果
连表操作：
表关系：
class UserInfo(AbstractUser): # settings: AUTH_USER_MODEL = "blog.UserInfo"
"""
用户信息
"""
nid = models.BigAutoField(primary_key=True)
nickname = models.CharField(verbose_name='昵称', max_length=32,null=True)
telephone = models.CharField(max_length=11, blank=True, null=True, unique=True, verbose_name='手机号码')
avatar = models.FileField(verbose_name='头像', upload_to='avatar', default="avatar/default.png")
create_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True) class Blog(models.Model):
"""
站点信息
"""
nid = models.BigAutoField(primary_key=True)
title = models.CharField(verbose_name='个人博客标题', max_length=64)
site = models.CharField(verbose_name='个人博客后缀', max_length=32, unique=True)
theme = models.CharField(verbose_name='博客主题', max_length=32) user = models.OneToOneField(to='UserInfo', to_field='nid') class Category(models.Model): nid = models.AutoField(primary_key=True)
title = models.CharField(verbose_name='分类标题', max_length=32)
blog = models.ForeignKey(verbose_name='所属博客', to='Blog', to_field='nid') class Article(models.Model):
nid = models.BigAutoField(primary_key=True)
title = models.CharField(max_length=50, verbose_name='文章标题')
desc = models.CharField(max_length=255, verbose_name='文章描述') # category字段： 与Article对象关联的category对象
category = models.ForeignKey(verbose_name='文章类型', to='Category', to_field='nid', null=True) # user字段：与Article对象关联的user字段
user = models.ForeignKey(verbose_name='所属用户', to='UserInfo', to_field='nid') # tags字段： 与Article对象关联的所有的标签对象集合 tags = models.ManyToManyField(
to="Tag",
through='Article2Tag',
through_fields=('article', 'tag'),
) class ArticleDetail(models.Model): nid = models.AutoField(primary_key=True)
content = models.TextField(verbose_name='文章内容', ) article = models.OneToOneField(verbose_name='所属文章', to='Article', to_field='nid') class Article2Tag(models.Model): # 中介模型
nid = models.AutoField(primary_key=True)
article = models.ForeignKey(verbose_name='文章', to="Article", to_field='nid')
tag = models.ForeignKey(verbose_name='标签', to="Tag", to_field='nid') class Tag(models.Model):
nid = models.AutoField(primary_key=True)
title = models.CharField(verbose_name='标签名称', max_length=32)
blog = models.ForeignKey(verbose_name='所属博客', to='Blog', to_field='nid')
关联表的添加记录操作：
1、创建一篇文章对象：
user_obj=models.UserInfo.objects.get(nid=1)
category_obj=models.Category.objects.get(nid=2) #################一对多关系绑定#########################
# 方式1：
article_obj=models.Article.objects.create(nid=5,title="招呼亚星"....,user=user_obj,category=category_obj) # 方式2：
article_obj=models.Article.objects.create(nid=5,title="招呼亚星"....,user_id=1,category_id=2)
'''
Article:
nid title user_id category_id
5 招呼亚星 1 2 '''
############################多对多关系绑定#########################
if 没有中介模型：
tags = models.ManyToManyField("Tag")
'''
ORM创建的第三张表：
Article2tags: nid article_id tag_id
1 5 1
2 5 2 ''' 实例：给article_obj绑定kw1,kw2的标签
tag1=Tag.objects.filter(title=kw1).first()
tag2=Tag.objects.filter(title=kw2).first() article_obj.tags.add(tag1,tag2) #
article_obj.tags.add(*[tag1,tag2])
article_obj.tags.add(1,2)
article_obj.tags.add(*[1,2]) 解除关系：
article_obj.tags.remove(tag1,tag2)
article_obj.tags.clear() 重置关系：
article_obj.tags.clear()
article_obj.tags.add(tag1,tag2)
=====
article_obj.tags.set(tag1,tag2) if 有中介模型：
tags = models.ManyToManyField(
to="Tag",
through='Article2Tag',
through_fields=('article', 'tag'),
) class Article2Tag(models.Model): # 中介模型
nid = models.AutoField(primary_key=True)
article = models.ForeignKey(verbose_name='文章', to="Article", to_field='nid')
tag = models.ForeignKey(verbose_name='标签', to="Tag", to_field='nid') 绑定多对多的关系，有中介模型，不能再使用article_obj.tags.add(),remove()等方法；
只能用Article2Tag表进行实例对象。 实例：给article_obj绑定kw1,kw2的标签： models.Article2Tag.objects.create(tag_id=1,article_id=5)
models.Article2Tag.objects.create(tag_id=2,article_id=5)
关联表的查询操作
基于对象查询(子查询)：
一对多的查询：
实例1：查询主键为4的文章的分类名称(正向查询，按字段)
article_obj=models.Article.objects.get(nid=4)
print(article_obj.category.title)
SELECT * FROM "blog_article" WHERE "blog_article"."nid" = 4; // category_id=2
SELECT * FROM "blog_category" WHERE "blog_category"."nid" = 2;
实例2：查询用户yuan发表过的所有的文章(反向查询，表名_set)
yuan=models.UserInfo.objects.get(username="yuan")
book_list=yuan.article_set.all() # QuerySet
多对多的查询：
实例3：查询主键为4的文章的标签名称（正向查询，按字段）
article_obj=models.Article.objects.get(nid=4)
tag_list=article_obj.tags.all() # 是通过Article2Tag找到tag表中关联的tag记录
for i in tag_list:
print(i.title)
实例4：查询web开发的这个标签对应的所有的文章（反向查询，按表名_set）
tag_obj=models.Tag.objects.get(title="web开发")
article_list=tag_obj.article_set.all()
for i in article_list:
print(i.title)
实例5：查询web开发的这个标签对应的所有的文章对应的作者名字
tag_obj=models.Tag.objects.get(title="web开发")
article_list=tag_obj.article_set.all()
for article in article_list:
print(article.user.username)
基于QuerySet跨表查询 正向查询，按字段 ;反向查询，按表名(join查询)
一对多的查询：
实例1：查询主键为4的文章的分类名称
models.Article.objects.filter(nid=4).values("category__title")
models.Category.objects.filter(article__nid=4).values("title")
实例2：查询用户yuan发表过的所有的文章
models.UserInfo.objects.filter(username="yuan").values(article__title)
models.Article.objects.filter(user__username="yuan").values("title")
多对多的查询：
实例3：查询主键为4的文章的标签名称（正向查询，按字段）
models.Article.objects.filter(nid=4).values("tags__title")
models.Tag.objects.filter(article__nid=4).values("title")
实例4：查询web开发的这个标签对应的所有的文章（反向查询，按表名_set）
models.Article.objects.filter(tags__title="web开发").values("title")
models.Tag.objects.filter(title="web开发").values("article__title")
实例5：查询web开发的这个标签对应的所有的文章对应的作者名字
models.Tag.objects.filter(title="web开发").values("article__user__username")
models.UserInfo.objects.filter(article__tags__title="web开发").values("username")
聚合查询与分组查询：
聚合查询：
# 查询所有书籍的平均价格
Book.objects.all().aggregate(Avg('price'))
分组查询：
#查询每一个出版社出版过的名字以及出版书籍个数
sql： select publish.name,Count(book.name) from Book inner join publish on book.pub_id=publish.id group by publish.name