django基础

Django基础(一)

一什么是web框架？

框架，即framework，特指为解决一个开放性问题而设计的具有一定约束性的支撑结构，使用框架可以帮你快速开发特定的系统，简单地说，就是你用别人搭建好的舞台来做表演。

对于所有的Web应用，本质上其实就是一个socket服务端，用户的浏览器其实就是一个socket客户端。

 1 import socket
 2 
 3 def handle_request(client):
 4 
 5     buf = client.recv(1024)
 6     client.send("HTTP/1.1 200 OK\r\n\r\n".encode("utf8"))
 7     client.send("<h1 style='color:red'>Hello, yuan</h1>".encode("utf8"))
 8 
 9 def main():
10 
11     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
12     sock.bind(('localhost',8001))
13     sock.listen(5)
14 
15     while True:
16         connection, address = sock.accept()
17         handle_request(connection)
18         connection.close()
19 
20 if __name__ == '__main__':
21 
22     main()

View Code

最简单的Web应用就是先把HTML用文件保存好，用一个现成的HTTP服务器软件，接收用户请求，从文件中读取HTML，返回。

如果要动态生成HTML，就需要把上述步骤自己来实现。不过，接受HTTP请求、解析HTTP请求、发送HTTP响应都是苦力活，如果我们自己来写这些底层代码，还没开始写动态HTML呢，就得花个把月去读HTTP规范。

正确的做法是底层代码由专门的服务器软件实现，我们用Python专注于生成HTML文档。因为我们不希望接触到TCP连接、HTTP原始请求和响应格式，所以，需要一个统一的接口，让我们专心用Python编写Web业务。

这个接口就是WSGI：Web Server Gateway Interface。

最简单的Web应用就是先把HTML用文件保存好，用一个现成的HTTP服务器软件，接收用户请求，从文件中读取HTML，返回。

这个接口就是WSGI：Web Server Gateway Interface。

二 MVC和MTV模式

Django的MTV模式本质是各组件之间为了保持松耦合关系,Django的MTV分别代表：

Model(模型)：负责业务对象与数据库的对象(ORM)

Template(模版)：负责如何把页面展示给用户

View(视图)：负责业务逻辑，并在适当的时候调用Model和Template

此外，Django还有一个url分发器，它的作用是将一个个URL的页面请求分发给不同的view处理，view再调用相应的Model和Template

三、Django基本命令

1、创建一个django project

django-admin.py startproject mysite

当前目录下会生成mysite的工程，目录结构如下：

manage.py ----- Django项目里面的工具，通过它可以调用django shell和数据库等。
settings.py ---- 包含了项目的默认设置，包括数据库信息，调试标志以及其他一些工作的变量。
urls.py ----- 负责把URL模式映射到应用程序。

2、在mysite目录下创建应用，比如blog:

1 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中新增了类时，运行它就可以自动在数据库中创建表了，不用手动创建。

7、Django 项目环境终端

python manage.py shell

这个命令和直接运行 python 进入 shell 的区别是：你可以在这个 shell 里面调用当前项目的 models.py 中的 API，对于操作数据的测试非常方便。

8、Django 项目环境终端

1 python manage.py dbshell

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

在这个终端可以执行数据库的SQL语句。如果您对SQL比较熟悉，可能喜欢这种方式。

9、更多命令

1 python manage.py

查看所有的命令，忘记子名称的时候特别有用。

四、路由配置系统（URLconf）

URL配置(URLconf)就像Django 所支撑网站的目录。它的本质是URL与要为该URL调用的视图函数之间的映射表；你就是以这种方式告诉Django，对于这个URL调用这段代码，对于那个URL调用那段代码。

    '''
    
    urlpatterns = [
         url(正则表达式, views视图函数，参数，别名),
]


参数说明：

    一个正则表达式字符串
    一个可调用对象，通常为一个视图函数或一个指定视图函数路径的字符串
    可选的要传递给视图函数的默认参数（字典形式）
    一个可选的name参数

    '''

4.1 URLconf的正则字符串参数

4.1.1 简单配置

 1 from django.conf.urls import url
 2 
 3 from . import views
 4 
 5 urlpatterns = [
 6     url(r'^articles/2003/$', views.special_case_2003),
 7     url(r'^articles/([0-9]{4})/$', views.year_archive),
 8     url(r'^articles/([0-9]{4})/([0-9]{2})/$', views.month_archive),
 9     url(r'^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail),
10 ]

 1 '''
 2     NOTE:
 3 一旦匹配成功则不再继续
 4 若要从URL 中捕获一个值，只需要在它周围放置一对圆括号。
 5 不需要添加一个前导的反斜杠，因为每个URL 都有。例如，应该是^articles 而不是 ^/articles。
 6 每个正则表达式前面的'r' 是可选的但是建议加上。
 7 
 8 一些请求的例子：
 9 
10     /articles/2005/3/ 不匹配任何URL 模式，因为列表中的第三个模式要求月份应该是两个数字。
11     /articles/2003/ 将匹配列表中的第一个模式不是第二个，因为模式按顺序匹配，第一个会首先测试是否匹配。
12     /articles/2005/03/ 请求将匹配列表中的第三个模式。Django 将调用函数
13                        views.month_archive(request, '2005', '03')。
14     '''

#设置项是否开启URL访问地址后面不为/跳转至带有/的路径
APPEND_SLASH=True

4.1.2 有名分组(named group)

上面的示例使用简单的、没有命名的正则表达式组（通过圆括号）来捕获URL 中的值并以位置参数传递给视图。在更高级的用法中，可以使用命名的正则表达式组来捕获URL 中的值并以关键字参数传递给视图。

在Python 正则表达式中，命名正则表达式组的语法是(?P<name>pattern)，其中name 是组的名称，pattern 是要匹配的模式。

下面是以上URLconf 使用命名组的重写：

 1 from django.conf.urls import url
 2 
 3 from . import views
 4 
 5 urlpatterns = [
 6     url(r'^articles/2003/$', views.special_case_2003),
 7     url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),
 8     url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$', views.month_archive),
 9     url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/(?P<day>[0-9]{2})/$', views.article_detail),
10 ]

这个实现与前面的示例完全相同，只有一个细微的差别：捕获的值作为关键字参数而不是位置参数传递给视图函数。例如：

1 /articles/2005/03/    
2     请求将调用views.month_archive(request, year='2005', month='03')函数
3     /articles/2003/03/03/ 
4     请求将调用函数views.article_detail(request, year='2003', month='03', day='03')。

在实际应用中，这意味你的URLconf 会更加明晰且不容易产生参数顺序问题的错误 —— 你可以在你的视图函数定义中重新安排参数的顺序。当然，这些好处是以简洁为代价；有些开发人员认为命名组语法丑陋而繁琐。

4.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等等 —— 都将路由到相同的函数。

4.1.4 捕获的参数永远是字符串

每个捕获的参数都作为一个普通的Python 字符串传递给视图，无论正则表达式使用的是什么匹配方式。例如，下面这行URLconf 中：

url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),
views.year_archive() 的year 参数将是一个字符串

4.1.5 指定视图参数的默认值

有一个方便的小技巧是指定视图参数的默认值。下面是一个URLconf 和视图的示例：

 1 # URLconf
 2 from django.conf.urls import url
 3 
 4 from . import views
 5 
 6 urlpatterns = [
 7     url(r'^blog/$', views.page),
 8     url(r'^blog/page(?P<num>[0-9]+)/$', views.page),
 9 ]
10 
11 # View (in blog/views.py)
12 def page(request, num="1"):
13 
14     ...

在上面的例子中，两个URL模式指向同一个视图views.page —— 但是第一个模式不会从URL 中捕获任何值。如果第一个模式匹配，page() 函数将使用num参数的默认值"1"。如果第二个模式匹配，page() 将使用正则表达式捕获的num 值。

4.1.6 Including other URLconfs

 1 #At any point, your urlpatterns can “include” other URLconf modules. This
 2 #essentially “roots” a set of URLs below other ones.
 3 
 4 #For example, here’s an excerpt of the URLconf for the Django website itself.
 5 #It includes a number of other URLconfs:
 6 
 7 
 8 from django.conf.urls import include, url
 9 
10 urlpatterns = [
11    url(r'^admin/', admin.site.urls),
12    url(r'^blog/', include('blog.urls')),
13 ]

2.2 传递额外的选项给视图函数(了解)

URLconfs 具有一个钩子，让你传递一个Python 字典作为额外的参数传递给视图函数。

django.conf.urls.url() 函数可以接收一个可选的第三个参数，它是一个字典，表示想要传递给视图函数的额外关键字参数。

例如：

1 from django.conf.urls import url
2 from . import views
3 
4 urlpatterns = [
5     url(r'^blog/(?P<year>[0-9]{4})/$', views.year_archive, {'foo': 'bar'}),
6 ]

在这个例子中，对于/blog/2005/请求，Django 将调用views.year_archive(request, year='2005', foo='bar')。

这个技术在Syndication 框架中使用，来传递元数据和选项给视图。

2.3 name参数

 1 '''
 2 
 3 urlpatterns = [
 4     url(r'^index',views.index,name='INDEX'),
 5 
 6 ]
 7 ###################
 8 
 9 def index(req):
10     if req.method=='POST':
11         username=req.POST.get('username')
12         password=req.POST.get('password')
13         if username=='alex' and password=='123':
14             return HttpResponse("登陆成功")
15 
16     return render(req,'index.html')
17 
18 #####################
19 
20 <!DOCTYPE html>
21 <html lang="en">
22 <head>
23     <meta charset="UTF-8">
24     <title>Title</title>
25 </head>
26 <body>
27 {#     <form action="/index/" method="post">#}
28      <form action="{% url 'INDEX' %}" method="post">
29          用户名:<input type="text" name="username">
30          密码:<input type="password" name="password">
31          <input type="submit" value="submit">
32      </form>
33 </body>
34 </html>
35 
36 
37 #######################
38 
39 '''

五、编写视图

一个视图函数，或者简短来说叫做视图，是一个简单的Python函数，它接受web请求，并且返回web响应。响应可以是一张网页的HTML内容，一个重定向，一个404错误，一个XML文档，或者一张图片. . . 是任何东西都可以。无论视图本身包含什么逻辑，都要返回响应。代码写在哪里也无所谓，只要它在你的Python目录下面。除此之外没有更多的要求了——可以说“没有什么神奇的地方”。为了能够把代码放在某个地方，惯例是把视图放在叫做views.py的文件中，然后把它放到你的项目或者应用目录里。

5.1 一个简单的视图

下面是一个返回当前日期和时间作为HTML文档的视图：

1 from django.http import HttpResponse
2 import datetime
3 
4 def current_datetime(request):
5     now = datetime.datetime.now()
6     html = "<html><body>It is now %s.</body></html>" % now
7     return HttpResponse(html)

让我们逐行阅读上面的代码：

首先，我们从 django.http模块导入了HttpResponse类，以及Python的datetime库。
接着，我们定义了current_datetime函数。它是一个视图函数。每个视图函数都应接收HttpRequest对象作为第一个参数，一般叫做request。
注意视图函数的名称并不重要；不需要用一个统一的命名方式来命名，以便让Django识别它。我们将其命名为current_datetime，是因为这个名称能够精确地反映出它的功能。
这个视图会返回一个HttpResponse对象，其中包含生成的响应。每个视图函数都要返回HttpResponse对象


'''
http请求－响应过程中有两个核心对象：

        http请求对象：HttpRequest

        http响应响应：HttpResponse

所在位置：django.http

'''

5.2 快捷函数

5.2.1 render函数

 1 －－－－－－－－－－－－－－－render(request, template_name[, context]）
 2 
 3 结合一个给定的模板和一个给定的上下文字典，并返回一个渲染后的 HttpResponse 对象。
 4 
 5 参数：
 6      request： 用于生成响应的请求对象。
 7 
 8      template_name：要使用的模板的完整名称，可选的参数
 9 
10      context：添加到模板上下文的一个字典。默认是一个空字典。如果字典中的某个值是可调用的，视图将在渲染模板之前调用它。
11 
12      content_type：生成的文档要使用的MIME类型。默认为DEFAULT_CONTENT_TYPE 设置的值。
13 
14      status：响应的状态码。默认为200。

5.2.2 redirect函数

 1 -----------------------------------url.py
 2 
 3  url(r"login",   views.login),
 4  url(r"yuan_back",   views.yuan_back),
 5 
 6 -----------------------------------views.py
 7 def login(req):
 8     if req.method=="POST":
 9         if 1:
10             # return redirect("/yuan_back/")
11             name="yuanhao"
12 
13             return render(req,"my backend.html",locals())
14 
15     return render(req,"login.html",locals())
16 
17 
18 def yuan_back(req):
19 
20     name="苑昊"
21 
22     return render(req,"my backend.html",locals())
23 
24 -----------------------------------login.html
25 
26 <form action="/login/" method="post">
27     <p>姓名<input type="text" name="username"></p>
28     <p>性别<input type="text" name="sex"></p>
29     <p>邮箱<input type="text" name="email"></p>
30     <p><input type="submit" value="submit"></p>
31 </form>
32 -----------------------------------my backend.html
33 <h1>用户{{ name }}你好</h1>
34 
35 #总结: render和redirect的区别:
36 #   1 if render的页面需要模板语言渲染,需要的将数据库的数据加载到html,那么所有的这一部分
37 #     除了写在yuan_back的视图函数中,必须还要写在login中,代码重复,没有解耦.
38 
39 #   2 the most important: url没有跳转到/yuan_back/,而是还在/login/,所以当刷新后
40 #     又得重新登录.

六、Template

6.1 模板系统的介绍

你可能已经注意到我们在例子视图中返回文本的方式有点特别。也就是说，HTML被直接硬编码在 Python代码之中。

1 def current_datetime(request):
2     now = datetime.datetime.now()
3     html = "<html><body>It is now %s.</body></html>" % now
4     return HttpResponse(html)

尽管这种技术便于解释视图是如何工作的，但直接将HTML硬编码到你的视图里却并不是一个好主意。让我们来看一下为什么：

对页面设计进行的任何改变都必须对 Python 代码进行相应的修改。站点设计的修改往往比底层 Python 代码的修改要频繁得多，因此如果可以在不进行 Python 代码修改的情况下变更设计，那将会方便得多。

Python 代码编写和 HTML 设计是两项不同的工作，大多数专业的网站开发环境都将他们分配给不同的人员（甚至不同部门）来完成。设计者和HTML/CSS的编码人员不应该被要求去编辑Python的代码来完成他们的工作。

程序员编写 Python代码和设计人员制作模板两项工作同时进行的效率是最高的，远胜于让一个人等待另一个人完成对某个既包含 Python又包含 HTML 的文件的编辑工作。

基于这些原因，将页面的设计和Python的代码分离开会更干净简洁更容易维护。我们可以使用 Django的 模板系统 (Template System)来实现这种模式，这就是本章要具体讨论的问题。

python的模板：HTML代码＋逻辑控制代码

6.2 模板支持的语法

6.2.1 变量（使用双大括号来引用变量）

1 语法格式：       {{var_name}}

 1 －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－Template和Context对象 
 2 >>> python manange.py shell  (进入该django项目的环境)
 3 >>> from django.template import Context, Template
 4 >>> t = Template('My name is {{ name }}.')
 5 >>> c = Context({'name': 'Stephane'})
 6 >>> t.render(c)
 7 'My name is Stephane.'
 8 
 9 
10 # 同一模板，多个上下文，一旦有了模板对象，你就可以通过它渲染多个context，无论何时我们都可以
11 # 像这样使用同一模板源渲染多个context，只进行 一次模板创建然后多次调用render()方法渲染会
12 # 更为高效：
13 # Low
14 for name in ('John', 'Julie', 'Pat'):
15     t = Template('Hello, {{ name }}')
16     print t.render(Context({'name': name}))
17 
18 # Good
19 t = Template('Hello, {{ name }}')
20 for name in ('John', 'Julie', 'Pat'):
21     print t.render(Context({'name': name}))

Django 模板解析非常快捷。大部分的解析工作都是在后台通过对简短正则表达式一次性调用来完成。这和基于 XML 的模板引擎形成鲜明对比，那些引擎承担了 XML 解析器的开销，且往往比 Django 模板渲染引擎要慢上几个数量级。

 1 from django.shortcuts import render,HttpResponse
 2 from django.template.loader import get_template #记得导入
 3 # Create your views here.
 4 
 5 
 6 import datetime
 7 from django.template import Template,Context
 8 
 9 # def current_time(req):
10     #原始的视图函数
11     # now=datetime.datetime.now()
12     # html="<html><body>现在时刻：<h1>%s.</h1></body></html>" %now
13     # return HttpResponse(html)
14 
15 
16 
17 # def current_time(req):
18 
19       #django模板修改的视图函数
20 #     now=datetime.datetime.now()
21 #     t=Template('<html><body>现在时刻是:<h1 style="color:red">{{current_date}}</h1></body></html>')
22       #t=get_template('current_datetime.html')
23 #     c=Context({'current_date':now})
24 #     html=t.render(c)
25 #     return HttpResponse(html)
26 
27 #另一种写法(推荐)
28 
29 def current_time(req):
30 
31     now=datetime.datetime.now()
32 
33     return render(req, 'current_datetime.html', {'current_date':now})

View Code

6.2.2 深度变量的查找（万能的句点号）

在到目前为止的例子中，我们通过 context 传递的简单参数值主要是字符串，然而，模板系统能够非常简洁地处理更加复杂的数据结构，例如list、dictionary和自定义的对象。在 Django 模板中遍历复杂数据结构的关键是句点字符 (.)。

 1 #最好是用几个例子来说明一下。
 2 # 首先，句点可用于访问列表索引，例如：
 3 
 4 >>> from django.template import Template, Context
 5 >>> t = Template('Item 2 is {{ items.2 }}.')
 6 >>> c = Context({'items': ['apples', 'bananas', 'carrots']})
 7 >>> t.render(c)
 8 'Item 2 is carrots.'
 9 
10 #假设你要向模板传递一个 Python 字典。 要通过字典键访问该字典的值，可使用一个句点：
11 >>> from django.template import Template, Context
12 >>> person = {'name': 'Sally', 'age': '43'}
13 >>> t = Template('{{ person.name }} is {{ person.age }} years old.')
14 >>> c = Context({'person': person})
15 >>> t.render(c)
16 'Sally is 43 years old.'
17 
18 #同样，也可以通过句点来访问对象的属性。 比方说， Python 的 datetime.date 对象有
19 #year 、 month 和 day 几个属性，你同样可以在模板中使用句点来访问这些属性：
20 
21 >>> from django.template import Template, Context
22 >>> import datetime
23 >>> d = datetime.date(1993, 5, 2)
24 >>> d.year
25 >>> d.month
26 >>> d.day
27 >>> t = Template('The month is {{ date.month }} and the year is {{ date.year }}.')
28 >>> c = Context({'date': d})
29 >>> t.render(c)
30 'The month is 5 and the year is 1993.'
31 
32 # 这个例子使用了一个自定义的类，演示了通过实例变量加一点(dots)来访问它的属性，这个方法适
33 # 用于任意的对象。
34 >>> from django.template import Template, Context
35 >>> class Person(object):
36 ...     def __init__(self, first_name, last_name):
37 ...         self.first_name, self.last_name = first_name, last_name
38 >>> t = Template('Hello, {{ person.first_name }} {{ person.last_name }}.')
39 >>> c = Context({'person': Person('John', 'Smith')})
40 >>> t.render(c)
41 'Hello, John Smith.'
42 
43 # 点语法也可以用来引用对象的方法。 例如，每个 Python 字符串都有 upper() 和 isdigit()
44 # 方法，你在模板中可以使用同样的句点语法来调用它们：
45 >>> from django.template import Template, Context
46 >>> t = Template('{{ var }} -- {{ var.upper }} -- {{ var.isdigit }}')
47 >>> t.render(Context({'var': 'hello'}))
48 'hello -- HELLO -- False'
49 >>> t.render(Context({'var': '123'}))
50 '123 -- 123 -- True'
51 
52 # 注意这里调用方法时并* 没有* 使用圆括号 而且也无法给该方法传递参数；你只能调用不需参数的
53 # 方法。

6.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 }}<br>

#value2=5
{{ value2|add:3 }}<br>

#value3='he  llo wo r ld'
{{ value3|cut:' ' }}<br>

#import datetime
#value4=datetime.datetime.now()
{{ value4|date:'Y-m-d' }}<br>

#value5=[]
{{ value5|default:'空的' }}<br>

#value6='<a href="#">跳转</a>'

{{ value6 }}

{% autoescape off %}
  {{ value6 }}
{% endautoescape %}

{{ value6|safe }}<br>

{{ value6|striptags }}

#value7='1234'
{{ value7|filesizeformat }}<br>
{{ value7|first }}<br>
{{ value7|length }}<br>
{{ value7|slice:":-1" }}<br>

#value8='http://www.baidu.com/?a=1&b=3'
{{ value8|urlencode }}<br>
    value9='hello I am yuan'

View Code

6.2.4 标签(tag)的使用（使用大括号和百分比的组合来表示使用tag）

语法格式:    {% tags %}

{% if %} 的使用

{% if %}标签计算一个变量值，如果是“true”，即它存在、不为空并且不是false的boolean值,系统则会显示{% if %}和{% endif %}间的所有内容

 1 {% if num >= 100 and 8 %}
 2 
 3     {% if num > 200 %}
 4         <p>num大于200</p>
 5     {% else %}
 6         <p>num大于100小于200</p>
 7     {% endif %}
 8 
 9 {% elif num < 100%}
10     <p>num小于100</p>
11 
12 {% else %}
13     <p>num等于100</p>
14 
15 {% endif %}
16 
17 
18 
19 {% if %} 标签接受and，or或者not来测试多个变量值或者否定一个给定的变量
20 {% if %} 标签不允许同一标签里同时出现and和or，否则逻辑容易产生歧义，例如下面的标签是不合法的：
21 
22 {% if obj1 and obj2 or obj3 %}

{% for %}的使用

 1 <ul>
 2 {% for obj in list %}
 3     <li>{{ obj.name }}</li>
 4 {% endfor %}
 5 </ul>
 6 
 7 
 8 #在标签里添加reversed来反序循环列表：
 9 
10     {% for obj in list reversed %}
11     ...
12     {% endfor %}
13 
14 #{% for %}标签可以嵌套：
15 
16     {% for country in countries %}
17         <h1>{{ country.name }}</h1>
18         <ul>
19          {% for city in country.city_list %}
20             <li>{{ city }}</li>
21          {% endfor %}
22         </ul>
23     {% endfor %}
24 
25 
26 #系统不支持中断循环，系统也不支持continue语句，{% for %}标签内置了一个forloop模板变量，
27 #这个变量含有一些属性可以提供给你一些关于循环的信息
28 
29 1，forloop.counter表示循环的次数，它从1开始计数，第一次循环设为1:
30 
31     {% for item in todo_list %}
32         <p>{{ forloop.counter }}: {{ item }}</p>
33     {% endfor %}
34 2，forloop.counter0 类似于forloop.counter，但它是从0开始计数，第一次循环设为0
35 3，forloop.revcounter
36 4，forloop.revcounter0
37 5，forloop.first当第一次循环时值为True，在特别情况下很有用：
38 
39     
40     {% for object in objects %}   
41          {% if forloop.first %}<li class="first">{% else %}<li>{% endif %}   
42          {{ object }}   
43         </li>  
44     {% endfor %}  
45     
46 # 富有魔力的forloop变量只能在循环中得到，当模板解析器到达{% endfor %}时forloop就消失了
47 # 如果你的模板context已经包含一个叫forloop的变量，Django会用{% for %}标签替代它
48 # Django会在for标签的块中覆盖你定义的forloop变量的值
49 # 在其他非循环的地方，你的forloop变量仍然可用
50 
51 
52 #{% empty %}
53 
54 {{li }}
55       {%  for i in li %}
56           <li>{{ forloop.counter0 }}----{{ i }}</li>
57       {% empty %}
58           <li>this is empty!</li>
59       {% endfor %}
60 
61 #         [11, 22, 33, 44, 55]
62 #            0----11
63 #            1----22
64 #            2----33
65 #            3----44
66 #            4----55

七、ORM

表(模型)的创建：

实例：我们来假定下面这些概念，字段和关系

作者模型：一个作者有姓名。

作者详细模型：把作者的详情放到详情表，包含性别，email地址和出生日期，作者详情模型和作者模型之间是一对一的关系（one－to－one）（类似于每个人和他的身份证之间的关系），在大多数情况下我们没有必要将他们拆分成两张表，这里只是引出一对一的概念。

出版商模型：出版商有名称，地址，所在城市，省，国家和网站。

书籍模型：书籍有书名和出版日期，一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的关系就是多对多的关联关系（many－to－many），一本书只应该由一个出版商出版，所以出版商和书籍是一对多关联关系（one－to－many），也被称作外键。

 1 from django.db import models<br>
 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

View Code

-------------------------------------增(create , save) -------------------------------

 1 from app01.models import *
 2 
 3     #create方式一:   Author.objects.create(name='Alvin')
 4 
 5     #create方式二:   Author.objects.create(**{"name":"alex"})
 6 
 7     #save方式一:     author=Author(name="alvin")
 8                             author.save()
 9 
10     #save方式二:     author=Author()
11                             author.name="alvin"
12                             author.save()

-----------------------------------------删（delete） ---------------------------------------------

1 >>> Book.objects.filter(id=1).delete()
2 (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()方法，这个方法会更新一行里的所有列。而某些情况下，我们只需要更新行里的某几列。

#---------------- update方法直接设定对应属性----------------
    models.Book.objects.filter(id=3).update(title="PHP")
    ##sql:
    ##UPDATE "app01_book" SET "title" = 'PHP' WHERE "app01_book"."id" = 3; args=('PHP', 3)


#--------------- save方法会将所有属性重新设定一遍,效率低-----------
    obj=models.Book.objects.filter(id=3)[0]
    obj.title="Python"
    obj.save()
# SELECT "app01_book"."id", "app01_book"."title", "app01_book"."price", 
# "app01_book"."color", "app01_book"."page_num", 
# "app01_book"."publisher_id" FROM "app01_book" WHERE "app01_book"."id" = 3 LIMIT 1; 
# 
# UPDATE "app01_book" SET "title" = 'Python', "price" = 3333, "color" = 'red', "page_num" = 556,
# "publisher_id" = 1 WHERE "app01_book"."id" = 3;

View Code

此外，update()方法对于任何结果集（QuerySet）均有效，这意味着你可以同时更新多条记录update()方法会返回一个整型数值，表示受影响的记录条数。

注意，这里因为update返回的是一个整形，所以没法用query属性；对于每次创建一个对象，想显示对应的raw sql，需要在settings加上日志记录部分：

 1 LOGGING = {
 2     'version': 1,
 3     'disable_existing_loggers': False,
 4     'handlers': {
 5         'console':{
 6             'level':'DEBUG',
 7             'class':'logging.StreamHandler',
 8         },
 9     },
10     'loggers': {
11         'django.db.backends': {
12             'handlers': ['console'],
13             'propagate': True,
14             'level':'DEBUG',
15         },
16     }
17 }

View Code

---------------------------------------查（filter，value等) -------------------------------------

 1 # 查询相关API：
 2 
 3 #  <1>filter(**kwargs):      它包含了与所给筛选条件相匹配的对象
 4 
 5 #  <2>all():                 查询所有结果
 6 
 7 #  <3>get(**kwargs):         返回与所给筛选条件相匹配的对象，返回结果有且只有一个，如果符合筛选条件的对象超过一个或者没有都会抛出错误。
 8 
 9 #-----------下面的方法都是对查询的结果再进行处理:比如 objects.filter.values()--------
10 
11 #  <4>values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列 model的实例化对象，而是一个可迭代的字典序列
12                                      
13 #  <5>exclude(**kwargs):     它包含了与所给筛选条件不匹配的对象
14 
15 #  <6>order_by(*field):      对查询结果排序
16 
17 #  <7>reverse():             对查询结果反向排序
18 
19 #  <8>distinct():            从返回结果中剔除重复纪录
20 
21 #  <9>values_list(*field):   它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列
22 
23 #  <10>count():              返回数据库中匹配查询(QuerySet)的对象数量。
24 
25 # <11>first():               返回第一条记录
26 
27 # <12>last():                返回最后一条记录
28 
29 #  <13>exists():             如果QuerySet包含数据，就返回True，否则返回False

 1 ---------------了不起的双下划线(__)之单表条件查询----------------
 2 
 3 #    models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值
 4 #
 5 #    models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
 6 #    models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
 7 #
 8 #    models.Tb1.objects.filter(name__contains="ven")
 9 #    models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
10 #
11 #    models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and
12 #
13 #    startswith，istartswith, endswith, iendswith,

bootstrap:

http://www.cnblogs.com/yuanchenqi/articles/6788872.html
http://www.cnblogs.com/yuanchenqi/articles/6811632.html

View Code

http://www.cnblogs.com/wupeiqi/articles/5237704.html

posted @ 2017-05-12 00:36 春野之火阅读(135) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

春野之火

django基础

Django基础(一)

一 什么是web框架？

二 MVC和MTV模式

4.1 URLconf的正则字符串参数

4.1.2 有名分组(named group)

4.1.3 URLconf 在什么上查找

4.1.4 捕获的参数永远是字符串

4.1.5 指定视图参数的默认值

4.1.6 Including other URLconfs

2.2 传递额外的选项给视图函数(了解)

2.3 name参数

五、编写视图

5.1 一个简单的视图

5.2 快捷函数

5.2.1 render函数

5.2.2 redirect函数

六、Template

6.1 模板系统的介绍

6.2 模板支持的语法

6.2.1 变量（使用双大括号来引用变量）

6.2.2 深度变量的查找（万能的句点号）

6.2.3 变量的过滤器(filter)的使用

6.2.4 标签(tag)的使用（使用大括号和百分比的组合来表示使用tag）

{% if %} 的使用

{% for %}的使用

七、ORM

表(模型)的创建：

公告

一什么是web框架？