本节内容
一、什么是web框架
二、MVC和MTV视图
三、Django基本命令
四、路由配置系统
五、编写视图
六、Template
七、ORM
| 一、什么是web框架 |
对于所有的web应用，本质上其实就是一个socket服务端，用户的浏览器就是一个socket客户端
#!/usr/bin/env python
#coding:utf-8
import socket
def handle_request(client):
buf = client.recv(1024)
client.send("HTTP/1.1 200 OK\r\n\r\n")
client.send("Hello, world!")
def main():
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('localhost',8080))
sock.listen(5)
while True:
connection, address = sock.accept()
handle_request(connection)
connection.close()
if __name__ == '__main__':
main()
上述通过socket来实现了其本质，而对于真实开发中的python web程序来说，一般会分为两部分：服务器程序(如Apache,Nginx等)和应用程序
服务器程序负责对socket服务器进行封装，并在请求到来时，对请求的各种数据进行整理。应用程序则负责具体的逻辑处理
为了方便应用程序的开发，就出现了众多的Web框架，例如：Django、Flask、web.py 等。
不同的框架有不同的开发方式，但是无论如何，开发出的应用程序都要和服务器程序配合，才能为用户提供服务。
这样，服务器程序就需要为不同的框架提供不同的支持。这样混乱的局面无论对于服务器还是框架，都是不好的。
对服务器来说，需要支持各种不同框架，对框架来说，只有支持它的服务器才能被开发出的应用使用。
这时候，标准化就变得尤为重要。我们可以设立一个标准，只要服务器程序支持这个标准，框架也支持这个标准，那么他们就可以配合使用。
一旦标准确定，双方各自实现。这样，服务器可以支持更多支持标准的框架，框架也可以使用更多支持标准的服务器。
WSGI(Web Server Gateway Interface)是一种规范，它定义了使用python编写的web app与web server之间接口格式，
实现web app与web server间的解耦。Python标准库提供的独立WSGI服务器称为wsgiref
from wsgiref.simple_server import make_server
def RunServer(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
return [bytes('Hello, web!
', encoding='utf-8'), ]
if __name__ == '__main__':
httpd = make_server('', 8000, RunServer)
print("Serving HTTP on port 8000...")
httpd.serve_forever()
| 二、MVC和MTV模式 |
MVC模式众所周知的模式，即：将应用程序分解成三个组成部分model(模型)，view(视图)和controller(控制器)，其中：
M 管理应用程序的状态(通常存储到数据库中)，并约束改变状态的行为(或者叫做“业务规则”)
C 接收外部用户的操作，根据操作访问模型获取数据，并调用“视图”显示这些数据，控制器就是将“模型”和“视图”隔离，并成为两者之间的联系纽带
V 负责把数据格式化呈现给用户
Django也是一个MVC框架，但是在Django中，控制器接收用户输入的部分由框架自行处理，
所以Django里更关注的是模型(Model)、模板(Template)和视图(View)，称为MTV模式
Model(模型)：负责业务对象和数据库对象(ORM)
Template(模板)：负责如何把页面展示给用户
View(视图)：负责业务逻辑，并在适当的时候调用Model和Template
此外Django还有一个URL分发器，负责将一个个URL的页面请求分发给不同的view处理
| 三、Django基本命令 |
1. 创建一个django project
django-admin.py startproject mysite当前目录下会生成mysite的工程，目录结构如下：
-
manage.py ----- Django项目里面的工具，通过它可以调用django shell和数据库等。
-
settings.py ---- 包含了项目的默认设置，包括数据库信息，调试标志以及其他一些工作的变量。
-
urls.py ----- 负责把URL模式映射到应用程序
注：若没有成功，Windows下尝试 django-admin startproject mysite
2. 在mysite目录下创建应用，比如blog:
python manage.py startapp blog
3. 启动django项目
python manage.py runserver 8080
这样我们的django就启动起来了！当我们访问：http://127.0.0.1:8080/时就可以看到：
4、同步更改数据库表或字段
'''
python manage.py syncdb
注意：Django 1.7.1 及以上的版本需要用以下命令
python manage.py makemigrations
python manage.py migrate
'''
这种方法可以创建表，当你在models.py中新增了类时，运行它就可以自动在数据库中创建表了，不用手动创建
class Host(models.Model):
host = models.CharField(max_length=64)
port = models.IntegerField()
memo = models.CharField(max_length=256, null=True)
create_name = models.CharField(max_length=64)
create_date = models.DateField()5. 清空数据库
python manage.py flush
此命令会询问是 yes 还是 no, 选择 yes 会把数据全部清空掉，只留下空表
6. 创建超级管理员
'''
python manage.py createsuperuser
# 按照提示输入用户名和对应的密码就好了邮箱可以留空，用户名和密码必填
# 修改 用户密码可以用：
python manage.py changepassword username
'''
7. Django 项目环境终端
python manage.py shell这个命令和 直接运行 python 进入 shell 的区别是：你可以在这个 shell 里面调用当前项目的 models.py 中的 API，对于操作数据的测试非常方便。
8. Django 项目环境终端
python manage.py dbshellDjango 会自动进入在settings.py中设置的数据库，如果是 MySQL 或 postgreSQL,会要求输入数据库用户密码。
在这个终端可以执行数据库的SQL语句。如果您对SQL比较熟悉，可能喜欢这种方式。
9. 更多命令
python manage.py
查看所有的命令，忘记子名称的时候特别有用
| 四、路由配置系统(URLconf) |
URL配置本质是URL与视图函数之间的映射表
urlpatterns = [
url(正则表达式，view视图函数，参数，别名)，
url(正则表达式，view视图函数，参数，别名)，
......
]
参数说明：
参数一：正则表达式字符串
参数二：一个可调用对象，通常为一个视图函数或一个指定视图函数路径的字符串
参数三：可选项，要传递给视图函数的默认参数(字典形式)，如locals()
参数四：可选项，别名
1、URLconf的正则字符串参数
1.1 简单示例
from django.conf.urls import url
from django.contrib import admin
from host import views
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^articles/2003/$', views.special_case_2003), # 严格匹配 articles/2003/
url(r'^articles/[0-9]{4}/$', views.year_archive), # 严格匹配 articles/4位数字/
url(r'^articles/[0-9]{4}/[0-9]{2}/$', views.month_archive), # 严格匹配 articles/4位数字/2位数字/
# 严格匹配 articles/4位数字/,并将该4位数字作为view函数的参数
url(r'^articles/([0-9]{4})/$', views.year_archive_para),
]''' NOTE: 1 一旦匹配成功则不再继续 2 若要从URL 中捕获一个值，只需要在它周围放置一对圆括号。 3 不需要添加一个前导的反斜杠，因为每个URL 都有。例如，应该是^articles 而不是 ^/articles。 4 每个正则表达式前面的'r' 是可选的但是建议加上。 '''
#设置项是否开启URL访问地址后面不为/跳转至带有/的路径 APPEND_SLASH=True
1.2 有名分组(name group)
上面的示例使用简单的、没有命名的正则表达式组（通过圆括号）来捕获URL 中的值并以位置参数传递给视图
在更高级的用法中，可以使用命名的正则表达式组来捕获URL 中的值并以关键字 参数传递给视图
在Python 正则表达式中，命名正则表达式组的语法是(?P
from django.conf.urls import url
from django.contrib import admin
from host import views
urlpatterns = [
url(r'^admin/', admin.site.urls),
# 严格匹配 articles/4位数字/2位数字/任意数字/,分为3组，year=xxxx，month=xx,day=xxxxxx
url(r'^articles/(?P[0-9]{4})/(?P[0-9]{2})/(?P[0-9]+)/$', views.article_detail),
]
这个实现与前面的示例完全相同，只有一个细微的差别：捕获的值作为关键字参数而不是位置参数传递给视图函数。例如：
/articles/2005/03/ 请求将调用views.month_archive(request, year='2005', month='03')函数 /articles/2003/03/03/ 请求将调用函数views.article_detail(request, year='2003', month='03', day='03')。
在实际应用中，这意味你的URLconf 会更加明晰且不容易产生参数顺序问题的错误 —— 你可以在你的视图函数定义中重新安排参数的顺序
当然，这些好处是以简洁为代价；有些开发人员认为命名组语法丑陋而繁琐。
1.3 URLconf在什么上查找
URLconf 在请求的URL 上查找，将它当做一个普通的Python 字符串。不包括GET和POST参数以及域名。
例如，http://www.example.com/myapp/ 请求中，URLconf 将查找myapp/。
在http://www.example.com/myapp/?page=3 请求中，URLconf 仍将查找myapp/。
URLconf 不检查请求的方法。换句话讲，所有的请求方法 —— 同一个URL的POST、GET、HEAD等等 —— 都将路由到相同的函数
1.4 捕获的参数永远是字符串
每个捕获的参数都作为一个普通的Python 字符串传递给视图，无论正则表达式使用的是什么匹配方式。例如，下面这行URLconf 中：
url(r'^articles/(?P[0-9]{4})/$', views.year_archive),
views.year_archive() 的year 参数将是一个字符串
1.5 指定视图参数的默认值
# URLConf
from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^blog/$', views.page),
url(r'^blog/page(?P[0-9]+)/$', views.page),
]
# View (in blog/views.py)
def page(request, num="1"):
...
在上面的例子中，两个URL模式指向同一个视图views.page —— 但是第一个模式不会从URL 中捕获任何值。
如果第一个模式匹配，page() 函数将使用num参数的默认值"1"。如果第二个模式匹配，page() 将使用正则表达式捕获的num 值
1.6 其他 URL配置
from django.conf.urls import include, url
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^host/', include('host.urls')),
]注： include访问url地址时，需要拼接host，如http://127.0.0.1/host/xxxx
2. 传递额外选项给视图参数(了解)
URLconfs 具有一个钩子，让你传递一个Python 字典作为额外的参数传递给视图函数。
django.conf.urls.url() 函数可以接收一个可选的第三个参数，它是一个字典，表示想要传递给视图函数的额外关键字参数。
例如：
from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^blog/(?P[0-9]{4})/$', views.year_archive, {'foo': 'bar'}),
] 在这个例子中，对于/blog/2005/请求，Django 将调用views.year_archive(request, year='2005', foo='bar')。
这个技术在Syndication 框架中使用，来传递元数据和选项给视图
3. 别名参数
''' urlpatterns = [ url(r'^index',views.index,name='INDEX'), ] ################### def index(req): if req.method=='POST': username=req.POST.get('username') password=req.POST.get('password') if username=='alex' and password=='123': return HttpResponse("登陆成功") return render(req,'index.html') #####################Title {# ####################### '''
| 五、编写视图 |
一个视图函数，或者简短来说叫做视图，是一个简单的Python函数，它接受web请求，并且返回web响应
响应可以是一张网页的HTML内容，一个重定向，一个404错误，一个XML文档，或者一张图片. . . 是任何东西都可以
无论视图本身包含什么逻辑，都要返回响应
代码写在哪里也无所谓，只要它在你的Python目录下面。除此之外没有更多的要求了——可以说“没有什么神奇的地方”。
为了能够把代码放在某个地方，惯例是把视图放在叫做views.py的文件中，然后把它放到你的项目或者应用目录里
1. 一个简单的视图
下面是一个返回当前日期和时间作为HTML文档的视图：
from django.http import HttpResponse
import datetime
def current_datetime(request):
now = datetime.datetime.now()
html = "It is now %s." % now
return HttpResponse(html)
让我们逐行阅读上面的代码：
首先，我们从 django.http模块导入了HttpResponse类，以及Python的datetime库
接着，我们定义了current_datetime函数。它是一个视图函数。每个视图函数都应接收HttpRequest对象作为第一个参数，一般叫做request。
注意视图函数的名称并不重要；不需要用一个统一的命名方式来命名，以便让Django识别它，
我们将其命名为current_datetime，是因为这个名称能够精确地反映出它的功能。
这个视图会返回一个HttpResponse对象，其中包含生成的响应。每个视图函数都要返回HttpResponse对象
'''
http请求－响应过程中有两个核心对象：
http请求对象：HttpRequest
http响应响应：HttpResponse
所在位置：django.http
'''
2. 快捷函数
2.1 render函数
－－－－－－－－－－－－－－－render(request, template_name[, context]）
结合一个给定的模板和一个给定的上下文字典，并返回一个渲染后的 HttpResponse 对象。
参数：
request： 用于生成响应的请求对象。
template_name：要使用的模板的完整名称，可选的参数
context：添加到模板上下文的一个字典。默认是一个空字典。如果字典中的某个值是可调用的，视图将在渲染模板之前调用它。
content_type：生成的文档要使用的MIME类型。默认为DEFAULT_CONTENT_TYPE 设置的值。
status：响应的状态码。默认为200。2.2 redirect函数
页面重定向，参数为RUL相对地址
| 六、Template |
1. 模板系统介绍
HTML被直接硬编码在 Python代码之中，如下所示
def current_datetime(request):
now = datetime.datetime.now()
html = "It is now %s." % now
return HttpResponse(html)尽管这种技术便于解释视图是如何工作的，但直接将HTML硬编码到你的视图里却并不是一个好主意。 让我们来看一下为什么：
(1) 对页面设计进行的任何改变都必须对 Python 代码进行相应的修改。 站点设计的修改往往比底层 Python 代码的修改要频繁得多，
因此如果可以在不进行 Python 代码修改的情况下变更设计，那将会方便得多
(2) Python 代码编写和 HTML 设计是两项不同的工作，大多数专业的网站开发环境都将他们分配给不同的人员(甚至不同部门)来完成。
设计者和HTML/CSS的编码人员不应该被要求去编辑Python的代码来完成他们的工作
(3) 程序员编写 Python代码和设计人员制作模板两项工作同时进行的效率是最高的，
远胜于让一个人等待另一个人完成对某个既包含 Python又包含 HTML 的文件的编辑工作
基于这些原因，将页面的设计和Python的代码分离开会更干净简洁更容易维护， Django的模板系统 (Template System)实现这种模式
Python的模板：HTML代码＋逻辑控制代码
2. 模板支持的语法
2.1 变量(使用双大括号来引用变量)
语法格式：{ { var_name }}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－Template和Context对象
>>> python manange.py shell (进入该django项目的环境)
>>> from django.template import Context, Template
>>> t = Template('My name is {
{ name }}.')
>>> c = Context({'name': 'Stephane'})
>>> t.render(c)
'My name is Stephane.'
# 同一模板，多个上下文，一旦有了模板对象，你就可以通过它渲染多个context，无论何时我们都可以
# 像这样使用同一模板源渲染多个context，只进行 一次模板创建然后多次调用render()方法渲染会
# 更为高效：
# Low
for name in ('John', 'Julie', 'Pat'):
t = Template('Hello, {
{ name }}')
print t.render(Context({'name': name}))
# Good
t = Template('Hello, {
{ name }}')
for name in ('John', 'Julie', 'Pat'):
print t.render(Context({'name': name}))
Django 模板解析非常快捷。 大部分的解析工作都是在后台通过对简短正则表达式一次性调用来完成。
这和基于 XML 的模板引擎形成鲜明对比，那些引擎承担了 XML 解析器的开销，且往往比 Django 模板渲染引擎要慢上几个数量级
from django.shortcuts import render,HttpResponse from django.template.loader import get_template #记得导入 # Create your views here. import datetime from django.template import Template,Context # def current_time(req): #原始的视图函数 # now=datetime.datetime.now() # html="现在时刻：%s.
" %now # return HttpResponse(html) # def current_time(req): #django模板修改的视图函数 # now=datetime.datetime.now() # t=Template('现在时刻是:{ {current_date}}
') #t=get_template('current_datetime.html') # c=Context({'current_date':now}) # html=t.render(c) # return HttpResponse(html) #另一种写法(推荐) def current_time(req): now=datetime.datetime.now() return render(req, 'current_datetime.html', { 'current_date':now})
2.2 深度变量的查找(万能的句点号)
在到目前为止的例子中，我们通过 context 传递的简单参数值主要是字符串，然而，
模板系统能够非常简洁地处理更加复杂的数据结构，例如list、dictionary和自定义的对象。在 Django 模板中遍历复杂数据结构的关键是句点字符 (.)
#最好是用几个例子来说明一下。
# 首先，句点可用于访问列表索引，例如：
>>> from django.template import Template, Context
>>> t = Template('Item 2 is {
{ items.2 }}.')
>>> c = Context({'items': ['apples', 'bananas', 'carrots']})
>>> t.render(c)
'Item 2 is carrots.'
#假设你要向模板传递一个 Python 字典。 要通过字典键访问该字典的值，可使用一个句点：
>>> from django.template import Template, Context
>>> person = {'name': 'Sally', 'age': '43'}
>>> t = Template('{
{ person.name }} is {
{ person.age }} years old.')
>>> c = Context({'person': person})
>>> t.render(c)
'Sally is 43 years old.'
#同样，也可以通过句点来访问对象的属性。 比方说， Python 的 datetime.date 对象有
#year 、 month 和 day 几个属性，你同样可以在模板中使用句点来访问这些属性：
>>> from django.template import Template, Context
>>> import datetime
>>> d = datetime.date(1993, 5, 2)
>>> d.year
>>> d.month
>>> d.day
>>> t = Template('The month is {
{ date.month }} and the year is {
{ date.year }}.')
>>> c = Context({'date': d})
>>> t.render(c)
'The month is 5 and the year is 1993.'
# 这个例子使用了一个自定义的类，演示了通过实例变量加一点(dots)来访问它的属性，这个方法适
# 用于任意的对象。
>>> from django.template import Template, Context
>>> class Person(object):
... def __init__(self, first_name, last_name):
... self.first_name, self.last_name = first_name, last_name
>>> t = Template('Hello, {
{ person.first_name }} {
{ person.last_name }}.')
>>> c = Context({'person': Person('John', 'Smith')})
>>> t.render(c)
'Hello, John Smith.'
# 点语法也可以用来引用对象的方法。 例如，每个 Python 字符串都有 upper() 和 isdigit()
# 方法，你在模板中可以使用同样的句点语法来调用它们：
>>> from django.template import Template, Context
>>> t = Template('{
{ var }} -- {
{ var.upper }} -- {
{ var.isdigit }}')
>>> t.render(Context({'var': 'hello'}))
'hello -- HELLO -- False'
>>> t.render(Context({'var': '123'}))
'123 -- 123 -- True'
# 注意这里调用方法时并* 没有* 使用圆括号 而且也无法给该方法传递参数；你只能调用不需参数的
# 方法。2.3 变量的过滤器(filter)的使用
语法格式： { {obj|filter:param}}
# 1 add ： 给变量加上相应的值 # # 2 addslashes : 给变量中的引号前加上斜线 # # 3 capfirst : 首字母大写 # # 4 cut ： 从字符串中移除指定的字符 # # 5 date ： 格式化日期字符串 # # 6 default ： 如果值是False,就替换成设置的默认值，否则就是用本来的值 # # 7 default_if_none: 如果值是None，就替换成设置的默认值，否则就使用本来的值 #实例: #value1="aBcDe" { { value1|upper }}
#value2=5 { { value2|add:3 }}
#value3='he llo wo r ld' { { value3|cut:' ' }}
#import datetime #value4=datetime.datetime.now() { { value4|date:'Y-m-d' }}
#value5=[] { { value5|default:'空的' }}
#value6='跳转' { { value6 }} { % autoescape off %} { { value6 }} { % endautoescape %} { { value6|safe }}
{ { value6|striptags }} #value7='1234' { { value7|filesizeformat }}
{ { value7|first }}
{ { value7|length }}
{ { value7|slice:":-1" }}
#value8='http://www.baidu.com/?a=1&b=3' { { value8|urlencode }}
value9='hello I am yuan'
2.4 标签(tag)的使用(使用大括号和百分比的组合来使用tag)
语法格式: {% tags %}
{% if %}的使用
{% if %}标签计算一个变量值，如果是“true”，即它存在、不为空并且不是false的boolean值,系统则会显示{% if %}和{% endif %}间的所有内容
{% if num >= 100 and 8 %}
{% if num > 200 %}
num大于200
{% else %}
num大于100小于200
{% endif %}
{% elif num < 100%}
num小于100
{% else %}
num等于100
{% endif %}
{% if %} 标签接受and，or或者not来测试多个变量值或者否定一个给定的变量
{% if %} 标签不允许同一标签里同时出现and和or，否则逻辑容易产生歧义，例如下面的标签是不合法的：
{% if obj1 and obj2 or obj3 %}{% for %}的使用
{% for %}标签允许你按顺序遍历一个序列中的各个元素,每次循环模板系统都会渲染{% for %}和{% endfor %}之间的所有内容
{% for obj in list %}
- {
{ obj.name }}
{% endfor %}
#在标签里添加reversed来反序循环列表：
{% for obj in list reversed %}
...
{% endfor %}
#{% for %}标签可以嵌套：
{% for country in countries %}
{
{ country.name }}
{% for city in country.city_list %}
- {
{ city }}
{% endfor %}
{% endfor %}
#系统不支持中断循环，系统也不支持continue语句，{% for %}标签内置了一个forloop模板变量，
#这个变量含有一些属性可以提供给你一些关于循环的信息
1，forloop.counter表示循环的次数，它从1开始计数，第一次循环设为1:
{% for item in todo_list %}
{
{ forloop.counter }}: {
{ item }}
{% 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 %}{% else %} {% endif %}
{
{ object }}
{% endfor %}
# 富有魔力的forloop变量只能在循环中得到，当模板解析器到达{% endfor %}时forloop就消失了
# 如果你的模板context已经包含一个叫forloop的变量，Django会用{% for %}标签替代它
# Django会在for标签的块中覆盖你定义的forloop变量的值
# 在其他非循环的地方，你的forloop变量仍然可用
#{% empty %}
{
{li }}
{% for i in li %}
{
{ forloop.counter0 }}----{
{ i }}
{% empty %}
this is empty!
{% endfor %}
# [11, 22, 33, 44, 55]
# 0----11
# 1----22
# 2----33
# 3----44
# 4----55
| 七、ORM |
表(模型)的创建：
实例：我们来假定下面这些概念，字段和关系
作者模型：一个作者有姓名。
作者详细模型：把作者的详情放到详情表，包含性别，email地址和出生日期，
作者详情模型和作者模型之间是一对一的关系（one－to－one）（类似于每个人和他的身份证之间的关系），
在大多数情况下我们没有必要将他们拆分成两张表，这里只是引出一对一的概念。
出版商模型：出版商有名称，地址，所在城市，省，国家和网站。
书籍模型：书籍有书名和出版日期，一本书可能会有多个作者，一个作者也可以写多本书，
所以作者和书籍的关系就是多对多的关联关系（many－to－many），一本书只应该由一个出版商出版，
所以出版商和书籍是一对多关联关系（one－to－many），也被称作外键。
1 from django.db import models
2 class Publisher(models.Model): 3 name = models.CharField(max_length=30, verbose_name="名称") 4 address = models.CharField("地址", max_length=50) 5 city = models.CharField('城市',max_length=60) 6 state_province = models.CharField(max_length=30) 7 country = models.CharField(max_length=50) 8 website = models.URLField() 9 10 class Meta: 11 verbose_name = '出版商' 12 verbose_name_plural = verbose_name 13 14 def __str__(self): 15 return self.name 16 17 class Author(models.Model): 18 name = models.CharField(max_length=30) 19 def __str__(self): 20 return self.name 21 22 class AuthorDetail(models.Model): 23 sex = models.BooleanField(max_length=1, choices=((0, '男'),(1, '女'),)) 24 email = models.EmailField() 25 address = models.CharField(max_length=50) 26 birthday = models.DateField() 27 author = models.OneToOneField(Author) 28 29 class Book(models.Model): 30 title = models.CharField(max_length=100) 31 authors = models.ManyToManyField(Author) 32 publisher = models.ForeignKey(Publisher) 33 publication_date = models.DateField() 34 price=models.DecimalField(max_digits=5,decimal_places=2,default=10) 35 def __str__(self): 36 return self.title
-------------------------------------增(create , save) -------------------------------
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()
-----------------------------------------删（delete） ---------------------------------------------
>>> Book.objects.filter(id=1).delete()
(3, {'app01.Book_authors': 2, 'app01.Book': 1})
我们表面上删除了一条信息，实际却删除了三条，因为我们删除的这本书在Book_authors表中有两条相关信息，
这种删除方式就是django默认的级联删除
-----------------------------------------改（update和save） ----------------------------------------
实例：
注意：
<1> 第二种方式修改不能用get的原因是：update是QuerySet对象的方法，get返回的是一个model对象，它没有update方法，
而filter返回的是一个QuerySet对象(filter里面的条件可能有多个条件符合，比如name＝'alvin',可能有两个name＝'alvin'的行数据)。
<2>在“插入和更新数据”小节中，我们有提到模型的save()方法，这个方法会更新一行里的所有列。 而某些情况下，我们只需要更新行里的某几列。
---------------------------------------查（filter，value等) -------------------------------------
# 查询相关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,