python16_day15【Django入门】

一、Django基本

1.什么是框架

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

基本框架

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

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

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

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

2.WSGI是什么鬼

　　step1:

 1 from wsgiref.simple_server import make_server
 2 
 3 
 4 def application(environ, start_response):
 5     start_response('200 OK', [('Content-Type', 'text/html')])
 6     return [b'<h1>Hello, web!</h1>']
 7 
 8 
 9 httpd = make_server('', 8080, application)
10 
11 print('Serving HTTP on port 8000...')
12 # 开始监听HTTP请求:
13 httpd.serve_forever()

View Code

 1 整个application()函数本身没有涉及到任何解析HTTP的部分，也就是说，底层代码不需要我们自己编写，
 2 我们只负责在更高层次上考虑如何响应请求就可以了。
 3 
 4 application()函数必须由WSGI服务器来调用。有很多符合WSGI规范的服务器，我们可以挑选一个来用。
 5 
 6 Python内置了一个WSGI服务器，这个模块叫wsgiref    
 7     
 8     
 9 application()函数就是符合WSGI标准的一个HTTP处理函数，它接收两个参数：
10 
11         //environ：一个包含所有HTTP请求信息的dict对象；
12         
13         //start_response：一个发送HTTP响应的函数。
14 
15 在application()函数中，调用：
16 
17 start_response('200 OK', [('Content-Type', 'text/html')])
18 
19 就发送了HTTP响应的Header，注意Header只能发送一次，也就是只能调用一次start_response()函数。
20 start_response()函数接收两个参数，一个是HTTP响应码，一个是一组list表示的HTTP Header，每
21 个Header用一个包含两个str的tuple表示。
22 
23 通常情况下，都应该把Content-Type头发送给浏览器。其他很多常用的HTTP Header也应该发送。
24 
25 然后，函数的返回值b'<h1>Hello, web!</h1>'将作为HTTP响应的Body发送给浏览器。
26 
27 有了WSGI，我们关心的就是如何从environ这个dict对象拿到HTTP请求信息，然后构造HTML，
28 通过start_response()发送Header，最后返回Body。

View Code

　　step2:

 1 print(environ['PATH_INFO'])
 2     path=environ['PATH_INFO']
 3     start_response('200 OK', [('Content-Type', 'text/html')])
 4     f1=open("index1.html","rb")
 5     data1=f1.read()
 6     f2=open("index2.html","rb")
 7     data2=f2.read()
 8 
 9     if path=="/yuan":
10         return [data1]
11     elif path=="/alex":
12         return [data2]
13     else:
14         return ["<h1>404</h1>".encode('utf8')]

View Code

　　step3:

 1 from wsgiref.simple_server import make_server
 2 
 3 def f1():
 4     f1=open("index1.html","rb")
 5     data1=f1.read()
 6     return [data1]
 7 
 8 def f2():
 9     f2=open("index2.html","rb")
10     data2=f2.read()
11     return [data2]
12 
13 def application(environ, start_response):
14 
15     print(environ['PATH_INFO'])
16     path=environ['PATH_INFO']
17     start_response('200 OK', [('Content-Type', 'text/html')])
18 
19 
20     if path=="/yuan":
21         return f1()
22 
23     elif path=="/alex":
24         return f2()
25 
26     else:
27         return ["<h1>404</h1>".encode("utf8")]
28 
29 
30 httpd = make_server('', 8502, application)
31 
32 print('Serving HTTP on port 8084...')
33 
34 # 开始监听HTTP请求:
35 httpd.serve_forever()

View Code

　　step4:

 1 from wsgiref.simple_server import make_server
 2 
 3 
 4 def f1(req):
 5     print(req)
 6     print(req["QUERY_STRING"])
 7 
 8     f1=open("index1.html","rb")
 9     data1=f1.read()
10     return [data1]
11 
12 def f2(req):
13 
14     f2=open("index2.html","rb")
15     data2=f2.read()
16     return [data2]
17 
18 import time
19 
20 def f3(req):        #模版以及数据库
21 
22     f3=open("index3.html","rb")
23     data3=f3.read()
24     times=time.strftime("%Y-%m-%d %X", time.localtime())
25     data3=str(data3,"utf8").replace("!time!",str(times))
26 
27 
28     return [data3.encode("utf8")]
29 
30 
31 def routers():
32 
33     urlpatterns = (
34         ('/yuan',f1),
35         ('/alex',f2),
36         ("/cur_time",f3)
37     )
38     return urlpatterns
39 
40 
41 def application(environ, start_response):
42 
43     print(environ['PATH_INFO'])
44     path=environ['PATH_INFO']
45     start_response('200 OK', [('Content-Type', 'text/html')])
46 
47 
48     urlpatterns = routers()
49     func = None
50     for item in urlpatterns:
51         if item[0] == path:
52             func = item[1]
53             break
54     if func:
55         return func(environ)
56     else:
57         return ["<h1>404</h1>".encode("utf8")]
58 
59 httpd = make_server('', 8518, application)
60 
61 print('Serving HTTP on port 8084...')
62 
63 # 开始监听HTTP请求:
64 
65 httpd.serve_forever()

View Code

伙计们，不知不觉我们自己已经写出一个web框架啦！

3.MTV and MVC

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

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

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

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

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

　　(1).创建一个django project:

django-admin.py startproject mysite

　　(2).在mysite目录下创建应用，比如blog:

python manage.py startapp blog

　　(3).启动django项目

python manage.py runserver 8080

　　(4).同步数据字段

    python manage.py syncdb
     
    注意：Django 1.7.1 及以上的版本需要用以下命令
    python manage.py makemigrations
    python manage.py migrate

　　(5).清空数据库

python manage.py flush

　　此命令会询问是 yes 还是 no, 选择 yes 会把数据全部清空掉，只留下空表。

　　(6).创建超级管理员

python manage.py createsuperuser
     
    # 按照提示输入用户名和对应的密码就好了邮箱可以留空，用户名和密码必填
     
    # 修改 用户密码可以用：
    python manage.py changepassword username

　　(7).项目环境终端　

python manage.py shell

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

　　(8).项目环境终端

python manage.py dbshell

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

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

4.路由配置系统

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

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

　　4.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 #设置项是否开启URL访问地址后面不为/跳转至带有/的路径
2 APPEND_SLASH=True

View Code

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

View Code

　　4.2.有名分组

 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 ]

　　4.3.URL参数

1 URLconf 在请求的URL 上查找，将它当做一个普通的Python 字符串。不包括GET和POST参数以及域名。
2 
3 例如，http://www.example.com/myapp/ 请求中，URLconf 将查找myapp/。
4 
5 在http://www.example.com/myapp/?page=3 请求中，URLconf 仍将查找myapp/。
6 
7 URLconf 不检查请求的方法。换句话讲，所有的请求方法 —— 同一个URL的POST、GET、HEAD等等 —— 都将路由到相同的函数。

　　4.4.捕获的参数都是字符串　

url(r'^articles/(?P<year>[0-9]{4})/?id=10$', views.year_archive),

　　以上year or id的值都为字符串

　　4.5.小技巧默认值

 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.6.IncludeURL

 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 ]

　　4.7.第三个参数

    url(r'^blog/(?P<year>[0-9]{4})/$', views.year_archive, {'foo': 'bar'}),
在这个例子中，对于/blog/2005/请求，Django 将调用views.year_archive(request, year='2005', foo='bar')。

　　4.8.NAME参数

　　-- URL变更不影响前端

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

5.视图

　　5.1.简单的视图

from django.http import HttpResponse
import datetime

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

1 http请求－响应过程中有两个核心对象：
2 
3         http请求对象：HttpRequest
4 
5         http响应响应：HttpResponse
6 
7 所在位置：django.http

　　5.2.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.3.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 #     又得重新登录.

posted @ 2017-05-09 18:13 willianflasky 阅读(135) 评论(0) 编辑收藏举报

刷新页面返回顶部

willian

python16_day15【Django入门】

公告

python16_day15【Django入门】