Python Django

本章内容：

django安装
django实例
django app 实例
django HttpRequest对象
django HttpResponse对象
django JsonResponse对象
django QueryDict对象
Render的前世
project添加一个目录并且可以识别
django路由系统URL
django Views
django Template
django simple_tag/filter
django cookie
django session
django链接数据库
类的写法
session 与 cookie的区别
django流程介绍
django数据库orm
django shell 操作/自带方法
django 分页功能
django csrf
django 中间件(待)
django缓存
django + uwsgi + nginx 启动
小练习
应用练习

参考文档

　　环境搭建及基础配置

　　URL设置

　　Django快速Web开发——模型（基础)

　　Django快速Web开发——模型（高级）

　　Django快速Web开发——管理后台

　　Django中文文档

　　Django 1.11.6 文档

Django 安装

参考文档

Django的安装会涉及一下多个软件，部署的参考文档会有很多，遇到的报错也会很多，百度、goole 可解决

系统字符集：

#echo $LANG
en_us.UTF-8

yum源设置：

mirrors.aliyun.com/help/centos
or   wget -O /etc/yum.repos.d/CentOs-Base.repo http://mirrors.aliyun.com/repo/Centos-6.repo

时区设置：　　

ntpdate time.windows.com

python 相关包安装：　　

依赖的包：

　　yum -y install openssl-devel readline-devel　gcc  gcc-c++　

　　pypi setuptools 包,注意回退一个版本比较稳定
　　　　Wget -S https://pypi.python.org/packages/dc/8c/7c9869454bdc53e72fb87ace63eac39336879eef6f2bf96e946edbf03e90/setuptools-33.1.1.zip#md5=7963d41d97b94e450e3f8a217be06ffe

　　　　unzip setuptools-33.1.1.zip
　　　　cd setuptools-33.1.1
　　　　/usr/local/python27/bin/python setup.py install

　　python-2.7.13 版本
　　　　wget -S https://www.python.org/ftp/python/2.7.13/Python-2.7.13.tgz

　　　　./configure --prefix=/usr/locl/python27
　　　　make && make intall

　　pip 安装
　　　　/usr/local/python27/bin/easy_install pip

　　　　vim /etc/pip.conf
　　　　　　[global]
　　　　　　trusted-host = pypi.douban.com
　　　　　　index-url = http://pypi.douban.com/simple
　　　　　　[list]
　　　　　　format=colums

virtualenv 环境安装

/usr/local/python27/bin/pip install virtualenv
cd data/
/usr/local/python27/bin/virtualenv ./python27env
source /data/python27/env/bin/activate
pip install ipython
pip install mysql-python
#deactiveate ,退出虚拟环境

django 安装：

pip install "django>=1.8,<1.9"    #安装1.8版本
ipython 中
    django.get_version()          #查看版本

mysql 安装

5.6版本比较稳定

rpm -ivh https://dev.mysql.com/get/mysql-community-release-el6-5.noarch.rpm

sudo yum -y install mysql mysql-server mysql-devel zlib-devel

django 实例

django-admin startproject opsweb        #生成opswed项目

　　项目目录结构：

　　运行第一个小实例：

　　需要提前在settings.py里修改这一行： ALLOWED_HOSTS = ["*"]　　

python manage.py runserver 0.0.0.0:33333

　　这里运行的时候遇到一个报错：

　　ImportError: No module named security

　　这个是由于我在virtualenv环境下创建的这个项目，执行的时候却退出了，需要进入后再执行。

django app 实例　

python manage.py startapp dashboard

生成的目录结构：　　

目录文件说明：

配置app

　　把app的名字写入：

　　　　opsweb/settings.py

　　再对url进行配置：

　　　　添加到opsweb/urls.py中

　　　　可以理解为处理dashboard目录，交给后面的函数来处理

　　配置视图：

　　配置dashboard中的url:

梳理下流程：

　　如：发起url请求：http://59.110.12.72:33333/dashboard/hello/

　　首先匹配到dashboard 这个app,然后又在python27env/reboot/opsweb/opsweb/urls.py中匹配到了 url(r'^dashboard/', include("dashboard.urls"))，然后就会去dashboard中查找urls.py. 在其中发现url(r'hello/$',views.hello), 然后就会执行views视图中的hello函数。

django HttpRequest 对象

视图函数中的request是由Django创建的

def index(request):
      pass

request属性

HttpRequest.scheme
HttpRequest.body
HttpRequest.path
HttpRequest.path_info
HttpRequest.method
HttpRequest.encoding
HttpRequest.GET
HttpRequest.POST
HttpRequest.META
HttpRequest.user

request方法

HttpRequest.get_host()
HttpRequest.get_full_path()
HttpRequest.build_absoulute_uri(location)
HttpRequest.get_signed_cookie()
HttpRequest.is_secure()
HttpRequest.is_ajax()

django HttpResponse对象

　　传递一个字符串作为页面的内容到HttpResponse构造函数

from django.http import HttpResponse

return HttpResponse('Here is the text of hte web page')

return HttpResponse('Test',content_type="text/plain")

reponse属性

HttpResponse.content 
HttpResponse.charset 
HttpResponse.status_code 
HttpResponse.reason_phrase

reponse方法

HttpResponse.__init__(content=”, content_type=None, status=200, reason=None, charset=None)

　　如何用呢？待了解

　　django 中 return HttpResponse('内容')，这个内容只能是string格式的，所以需要 json.dumps(res) 下这个res结果

　　加入这个res是字典，后端已经序列化了，传递给前端后，需要把这个字符串转化为对象， var obj = JSON.parse(data)

　　前端对象转换为字符串：

　那为题来了，ajax 请求中只能 return HttpResponse 吗？最好是这样，但可以用 render，不过这个返回的是一个渲染好的html页面，处理是个问题，redirect这个是不能用的！

django JsonResponse对象

　　支持传递list,dict

　　return JsonResponse([1,2,3], safe = False)

django QueryDict对象

In [1]: from django.http import QueryDict
In [2]: Get = QueryDict('a=1&b=2&c=3')

　　QueryDict的方法：　

QueryDict.get(key, default=None) 
QueryDict.setdefault(key, default=None)[source] 
QueryDict.update(other_dict)
QueryDict.items()
QueryDict.values()
QueryDict.copy()
QueryDict.getlist(key, default=None) 
QueryDict.setlist(key, list_)[source] 
QueryDict.appendlist(key, item) 
QueryDict.setlistdefault(key, default_list=None) 
QueryDict.lists()
QueryDict.pop(key)
QueryDict.popitem()
QueryDict.dict()
QueryDict.urlencode(safe=None)

Render 的前世

　　这种方法相比render较不适用，建议使用render，学习一下

　　与flask相似，需要建立一个templates文件夹，把html文件放到这里，然后再渲染

　　视图中添加：

　　urls中添加：

　　html文件：

后端验证登录

　　request.GET

　　request.POST

　　request.FILES　　　　#上传文件

　　request.getlist() #checkbox 等多选的内容

 1 def login(request):
 2     print request
 3     if request.method == "GET":
 4         print 'username from get -->',request.GET.get('username')
 5         print 'password  from get-->',request.GET.get('password')
 6         template = loader.get_template('login.html')
 7         context = Context({"title":"reboot 运维平台"})
 8         return HttpResponse(template.render(context))
 9 
10     elif request.method == 'POST':
11         print 'username from get -->',request.POST.get('username')
12         print 'password  from get-->',request.POST.get('password')
13         username = request.POST.get('username')
14         password = request.POST.get('password')
15         return HttpResponse('login ok!')

views 函数

 <html>
     <head>
         <title>
             {{title}}
         </title>
         <script src="https://cdn.bootcss.com/jquery/1.12.4/jquery.min.js"></script>
     </head>
     <body>
         <h1>用户登录</h1>
         <ul>
             <form action="/dashboard/login/" method="post">
                 <li><input type="text" name="username" id="username" /></li>
                 <li><input type="text" name="password" id="password" /></li>
                 <li><input type="submit" value="login" id="form_submit" /></li>
             </form>
         </ul>
 
         <script>
             $(function(){
                $('#form_submit').click(function(){
                     var username = $('#username').val();
                     var password = $('#password').val();
                     $.post("/dashboard/login/",{username:username,password:password},function(res){
                         alert(res)   
                     })
                     return false;  #如果不return false的话，就会按照默认的请求走了
                }) 
             })
         </script>
     </body>
 </html>

Ajax 异步登录

project 添加一个目录并且可识别

　　又名静态文件配置

　　添加static目录，需要添加setting里面的

STATIC_URL = '/static/' 
STATICFILES_DIRS = (
    os.path.join(BASE_DIR, "static"),
 )

　　这样，就可以在templates目录下的html文件中引用这个url了

django 路由系统URL

　　项目下的urls.py的配置

　　　　1、/index/

　　　　2、/index/(\d+)

　　　　3、/index/(?P<nid>\d+)

　　　　　　正则(?P<year>[0-9]{4})用法

　　　　　　相当于定义了一个year变量，在后边匹配到条件，就把取到值复制给year

　　　　4、/index/(?P<nid>\d+) name='root'

　　　　　　reverse()

　　　　　　{% url 'root' 1 %}

　　　　5、include

　　　　　　当有N个app时，url的编写都在项目的usls.py下就会有点乱，可以把这个文件转移到各个app下的urls.py下，需要在项目urls.py下做如下操作

　　　　　　from django.conf.urls import url, include

　　　　　　urlpatterns = [

　　　　　　　　url(r'^cmdb/', include('app01.urls'))

　　　　　　　　url(r'^monitor/', include('app02.urls'))

　　　　　　]

　　　　6、默认值(传递参数)

　　　　　　/index/ {'web':'root'}

　　　　　　def func(request, web):

　　　　　　　　return ......

　　　　　　例子：

　　　　　　　　url(r'^index/', views.index, {'name':'root'})

　　　　　　　　def index(request, name):

　　　　　　　　　　print(name)

　　　　　　　　　　return HttpResponse('ok')

　　　　　　这时候回多传递后面的字典给后端，而浏览器的格式不变。这个字典的变量可以是动态的，如，动态获取了客户的信息，然后传递给后端。这是后再view中定义的函数，也需要传递这个字典的key，不然会报确实参数的错。

　　　　7、name

　　　　　　对URL路由关系进行命名， ==> 以后可以根据此名称生成自己想要的URL　　　　

url(r'abcdefg', views.index,  name='i1')
url(r'bbbbbb/(\d+)/(\d+)', views.index,  name='i2')
url(r'dddddd/(?P<pid>\d+)/(?P<nid>\d+)/', views.index,  name='i3')

url.py

def func(request, *args,  **kwargs):
    from  django.urls  import reverse
　 url1  =  reverse('i1')                         #生成的url       abcdefg
    url2  =  reverse('i2', args = (1,2,))      #bbbbbb/1/2/
    url3   =  reverse('i3' , kwargs = {'pid':1, "nid":9})      #dddddd/1/9

view.py

action = {% url "i1" %}
{% url "i3"  1 2 %}
{% url  'i3' pid=1  nid = 9%}

html

django Views

　　视图获取用户相关请求信息，以及请求头。

　　print(tpye(request)) #查看类类型

　　from django.core.handlers.wsgi import WAGIRequest #可以查看到所有的请求头都是包含在environ 方法中的

　　print（request.environ）

　　for k,v in request.environ.items(): #去查看请求头过来的所有信息　　

def login_view(request):
    if request.method == "GET":
        return render(request, "public/login.html")
    else:
        username = request.POST.get("username", "")
        userpass = request.POST.get("password", "")
        user = authenticate(username=username, password=userpass)
        ret = {"status":0, "errmsg":""}
        if user:
            login(request, user)
            ret['next_url'] = request.GET.get("next") if request.GET.get("next", None) else "/"
        else:
            ret['status'] = 1
            ret['errmsg'] = "用户名或密码错误，请联系管理员"
        return JsonResponse(ret)

View中三元运算写法

django Template

　　模板继承：有时候许多页面有许多相似之处，为了书写简单就可以用到末班继承，

　　被继承文件 layer.html ,写好公共的内容， {% block content %} {% endblock %} 这个里面是继承的页面中需要自己书写的东西

　　继承的文件 a.html {% extends 'layer.hmlt' %} #说明下这个内容是从哪里继承的

　　　　　　　　　　　　{% block content %} 书写自己的代码 {% endblock %} ,当然可以写多块内容

　　模板导入：别人写好的代码块，咱这个页面上面需要导入，比如淘宝上面的每个产品的块

　　　　　　 a.html b.html 这些都是一个个小的产品，这时候需要在主页面导入

　　　　　　{% include “a.html” %}

　　　　　　　 {% include "b.html" %}

django Simple_tag/filter

Simple_tag写法

　　1、首先要在app的目录下创建一个templatetags(名字不能变)目录，app需要添加到setting里面就不必多说了

　　2、穿件一个任意名称的python文件，如xxoo.py

　　3、xxoo.py 代码

from django import template

register = template.Library()       #register名字不能变

@register.simplt_tag
def  zidingyi(a,b):
    #可以添加参数
    return a + b

　　4、配置html文件

{% load xxoo %}        //首先需要在html文件的顶部load这个python文件


{% zidingyi  2  5  %}     //然后下面可以引用这个函数了

　　优点：可以传递多个参数

　　缺点：不能作为if条件

　　Filter

　　用法基本相同

from django import template

register = template.Library()       #register名字不能变

@register.filter
def  zidingyi(a,b):
    #可以添加参数,最多只允许两个参数
    return a + b

　　html文件

{% load xxoo %}        //首先需要在html文件的顶部load这个python文件


{% ‘第一个参数’|zidingyi：“第二个参数”  %}     //注意中间不能有空格

django cookie

　　cookie:以键对的方式存储在客户端

　　django设置cookie: rep.set_cookie(key,value,参数)

def login(request):
    user_info = {
        'dachengzi':{'pwd':'123'},
        'kangbazi':{'pwd':'123'}
    }

    if request.method == 'GET':
        print('I am here')
        return render(request, 'login.html')

    elif request.method == 'POST':
        username = request.POST.get('username')
        password = request.POST.get('password')
        print(username,password)
        res = user_info.get(username)
        if not res:
            return render(request, 'login.html')

        if res['pwd'] == password:
            print('I am coming to denglu')
            res = redirect('/denglu/')                          #可以这种写法
            res.set_cookie('username111',username)

            return res
        else:
            return  render(request,'login.html')



def denglu(request):
    v = request.COOKIES.get('username111')    #提取登录的username
    if not v:
        return redirect('/login/')
    return render(request, 'denglu.html', {'current_user':v})    #在前端显示登录的user

举例说明

参数：

key, 键

value='', 值

max_age=None, 超时时间

expires=None, 超时时间(IE requires expires, so set it if hasn't been already.)

path='/', Cookie生效的路径，/ 表示根路径，特殊的：跟路径的cookie可以被任何url的页面访问

domain=None, Cookie生效的域名

secure=False, https传输

httponly=False 只能http协议传输，无法被JavaScript获取（不是绝对，底层抓包可以获取到也可以被覆盖）

　　例：

　　　　current_date = datetime.datetime.utcnow()

current_date = current_date + datetime.timedelta(seconds=5)

response.set_cookie('username111', u, expires=current_data)

　　　　httponly=False 这只后只有http能获取到cookie，js获取不到

<select onchange="changePageSize()">
    <option value="10">10</option>
    <option value="30">30</option>
    <option value="50">50</option>
    <option value="100">100</option>
</select>


<script src="jquery.js"></script>
<script src="jquery.cookie.js"></script>       //cookie是基于juery的,对cookie进行操作

<script>
    function changePageSize(ths){
        var v = $(ths).val()
        $.cookie('per_page_count', v)
    }
</script>

cookie,分页

　　cookie 加salt

　　obj = HttpResponse('s')

　　obj.set_signed_cookie('username', "kangbazi", salt='abcdefg') #加盐加密

　　request.get_signed_cookie('username', salt='abcdefg') #用盐解密　　

django session

　　django实现session功能十分简单，在视图函数中添加如下，

　　　　request.session['username'] = username

　　看似简单，其实django帮我们做了许多事情

1、生成随机字符串

　　　　2、写到浏览器的cookie中，(sessionid的形式)

　　　　3、保存在服务器端的session中，(保存在了数据库中django_session表中)

　　　　4、当然这个服务器端存session的字典中也可以保存一些其他的客户的信息，来更好的识别客户

　　待session设置完毕后需要

　　　　python manage.py makemigrations

　　　　python manage.py migrate

　　来使之生效

　　django的session的缓存时间默认是2周，可以人为设置

　　　　request.session.set_expiry(10s) 设置10s过期

　　还可以在setting里添加一些默认的设置

    SESSION_ENGINE = 'django.contrib.sessions.backends.db'   # 引擎（默认）
     
    SESSION_COOKIE_NAME ＝ "sessionid"                       # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认）
    SESSION_COOKIE_PATH ＝ "/"                               # Session的cookie保存的路径（默认）
    SESSION_COOKIE_DOMAIN = None                             # Session的cookie保存的域名（默认）
    SESSION_COOKIE_SECURE = False                            # 是否Https传输cookie（默认）
    SESSION_COOKIE_HTTPONLY = True                           # 是否Session的cookie只支持http传输（默认）
    SESSION_COOKIE_AGE = 1209600                             # Session的cookie失效日期（2周）（默认）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                  # 是否关闭浏览器使得Session过期（默认）
    SESSION_SAVE_EVERY_REQUEST = False                       # 是否每次请求都保存Session，默认修改之后才保存（默认）

django 链接数据库

　　setting的配置中

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'wang.....',
        'USER':'#####',
        'PASSWORD':'123456',
        'HOST':'59.110.12.72',
        'PORT':3306
    }
}

　　测试链接数据是否成功：

　　　　python manage.py syncdb

　　需要注意的是，Django默认使用的是MySQLdb模块链接MYSQL，python3中需要修改为pymysql，在project 同名文件夹下的__init__文件中添加如下代码即可：

　　import pymysql

　　pymysql.install_as_MYSQLdb()

　　链接数据库创建普通用户：

　　　　python manage.py shell

　　　　from django.contrib.auth.models import User

　　　　user = User.objects.create_user('rock','rock@51reboot.com','123456')

　　创建管理员用户，命令行模式下：

　　　　python manage.py createsuperuser --username=reboot --email=reboot@51reboot.com

　　修改密码：

　　　　python manage.py shell

　　　　from django.contrib.auth.models import User

　　　　user = User.objects.get(username='rock')

　　　　user.set_password('rock')

　　　　user.save()

　　用户登录和退出验证：　

from django.contrib.auth import authenticate,login,logout

def login_view(request):
    print request
    if request.method == "GET":
        template = loader.get_template('login.html')
        context = Context({"title":"reboot 运维平台"})
        return HttpResponse(template.render(context))

    elif request.method == 'POST':
        print 'username from get -->',request.POST.get('username')
        print 'password  from get-->',request.POST.get('password')
        username = request.POST.get('username')
        password = request.POST.get('password')
        user = authenticate(username=username,password=password)
        if user:
            login(request,user)
            return HttpResponse('login ok!')
        else:
            return HttpResponse('login fail')
    

def logout_view(request):
    logout(request)
    return HttpResponse('logout success!!')

类方法的写法

from django.views import view

class Home(view):       #继承view方法 
    '''
    执行get、post方法之前都会先执行dispatch方法
    '''
    def dispatch(self, request, *args, **kwargs):
        #代用父类中的dispatch
        print('before')
        
        result = super(Home, self).dispatch(request, *args, **kwargs)
        print('after')
        
    def get(self, request):
        print(request.method)
        return render(request, 'home.html')
    
    def post(self, request):
        print(request.method, 'POST')
        return render(request, 'home.html')

session 与 cookie的区别

　　1，session 在服务器端，cookie 在客户端（浏览器）
　　2，session 默认被存在在服务器的一个文件里（不是内存）
　　3，session 的运行依赖 session id，而 session id 是存在 cookie 中的，也就是说，如果浏览器禁用了 cookie ，同时 session 也会失效（但是可以通过其它方式　实现，比如在 url 中传递 session_id）
　　4，session 可以放在文件、数据库、或内存中都可以。
　　5，用户验证这种场合一般会用 session

django流程介绍

　　两种架构：

　　MVC

　　　　即将程序分为三个组成部分， model(模型)、view(视图)、controller(控制器)

　　　　M 管理应用程序的状态，

　　　　C 接受外部用户的操作，根据操作访问模型获取数据

　　　　V 负责把数据格式化后呈献给用户

　　django 也是MVC的框架，但是在Django中，控制器接受用户输入的部分由框架自行处理，所以Django里更关注的是模型(Model),模块(Template)和视图(Views)，成为MTV模式：

　　　　M 代表模型(Model) ，即数据存取层，该层处理与数据相关的所有事物：如何存取、如何验证有效性、包含哪些行为以及数据之间的关系等。

　　　　T 代表模板(Template), 即表现层，该层处理与表现相关的决定：如何在页面或者其他类型文档中进行显示

　　　　V 代表视图(View), 即业务逻辑层，盖层包含存取模型及调取恰当模块的相关逻辑，你可以把它看做模型与模块之间的桥梁。　

Djiango 数据库 ORM

　　小例，通过django orm 添加表，然后admin展示：

　　首先在dashboard这个app下的models.py添加表

from django.db import models

# Create your models here.

class Publisher(models.Model):
    name = models.CharField(max_length=30)
    address = models.CharField(max_length=50)
    city = models.CharField(max_length=60)
    state_province = models.CharField(max_length=30)
    country = models.CharField(max_length=50)
    website = models.URLField()
    def __unicode__(self):             #这两行是为了在后台中以名字展现，不然不会显示创建的名称
        return "<%s>"%(self.name)

class Author(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=40)
    email = models.EmailField()
    def __unicode__(self):
        return "<%s,%s>"%(self.first_name,self.last_name)
 
class Book(models.Model):
    title = models.CharField(max_length=100)
    authors = models.ManyToManyField(Author)
    publisher = models.ForeignKey(Publisher)
    publication_date = models.DateField()
    def __unicode__(self):
        return "<%s>"%(self.title)

　　表格创建完毕后需要在数据苦衷生成了

　　　　python manage.py makemigrations

　　　　python manage.py migrate

　　这样数据库中就会生成对应的表：

　　表创建完毕了，就需要在app下的admin.py中导入表的信息　　　

from django.contrib import admin

# Register your models here.
import models

admin.site.register(models.Author)
admin.site.register(models.Book)
admin.site.register(models.Publisher)

　　python manay.py createsuperuser ,创建可登录admin后台的超级管理员用户　

　这样在访问http://59.110.12.72:33333/admin/ ，就可以在里面做一些对标的增、删、改、查了

　　Django 数据库支持的字段类型：

　　　　详见：https://docs.djangoproject.com/en/1.9/ref/models/fields/

　　Django 中如果想要表格可以输入为空：

　　　　null = True 控制的是数据库可以为空

　　　　blank = True 告诉Django表格可以为空

　　　　然后再发布配置：

　　使标题显示中文

　　ORM对数据库进行操作

　　　　表中插入数据

　　　　python manage.py shell

　　　　>>> from dashboard.models import Publisher

　　　　>>> p1 = Publisher(name='Apress',address='USA',city='MHD',state_province='..',country='USA',website='www.baidu.com')

　　　　>>> p1.save() #这种方法，需要save()后才会添加到数据库

　　　　　　　　　　　　 #下面这种方法，可以直接在添加到数据库

　　　　>>> p1 = Publisher.objects.create(name='laoboy',address='USA',city='MHD',state_province='..',country='USA',website='www.baidu.com')

　　　　这套命令对应这数据库操作的 insert

　　如果要改变其中某个字段的值，需要怎么操作呢？

　　　　p1.name = 'balabala'

　　　　p1.save()

　　这里保存的时候，是又重新把整个表保存了一遍。

　　查找对象 　　

　　　　>>> Publisher.objects.all()

　　　　[<Publisher: <快网出版社>>, <Publisher: <Apress>>, <Publisher: <oldboy>>]

　　　　注意到Django在选择所有数据时并没有使用 SELECT* ，而是显式列出了所有字段。设计的时候就是这样：SELECT* 会更慢

　　　　>>> Publisher.objects.filter(name='oldboy')

　　　　[<Publisher: <oldboy>>]

　　　　同样，也支持，多条件过滤

　　　　>>> Publisher.objects.filter(name='oldboy',country='USA')

　　　　[<Publisher: <oldboy>>]

　　　　模糊查询

　　　　>>> Publisher.objects.filter(name__contains="boy") #中间是双横杠

　　　　[<Publisher: <oldboy>>]

　　　　获取单个对象并对齐修改

　　　　>>> Publisher.objects.get(name='oldboy')

　　　　<Publisher: <oldboy>>
　　　　>>> a = Publisher.objects.get(name='oldboy')
　　　　>>> a.name = 'oldboy2'
　　　　>>> a.save()
　　　　获取对象后进行排序

　　　　>>> Publisher.objects.order_by("name") #按照name来排序

　　　　>>> Publisher.objects.order_by("state_province", "address") #第一项一样的，按照第二项来排序

　　　　>>> Publisher.objects.order_by("-name") #倒叙

　　　　排来排去有点麻烦，可以用meta来进行全局的排序

　　　　连锁查询

　　　　>>> Publisher.objects.filter(country="U.S.A.").order_by("-name")

　　　　[<Publisher: O'Reilly>, <Publisher: Apress>]

　　　　　　过滤完数据在查询。

　　　　限制查询

　　　　>>> Publisher.objects.order_by('name')[0] #指向要帅选出来的第一条数据

　　　　<Publisher: Apress>

　　　　相当于mysql的

　　　　筛选到数据并修改：

　　　　删除对象

django shell 操作/自带方法

shell 中修改密码：

from django.contrib.auth.models import User

u = User.objects.get(username='admin')       #得到admin用户的对象

u.set_password('123')        #设置密码
u.password                        #查看的密码就是加密后的


#添加新用户
u2 = User()
u2.username = 'u2'
u2.set_password('123')
u2.save()

#设置is_staff后便可以登录后台系统了
u2.is_staff = True

#django user登录鉴权
from django.contrib.auth  import authenticate

test = authenticate(username='u2', password='123')
#如果有值则存在，None则不存在

　　用户验证登录的时候如果没有验证成功，django会有一个自己的rewritelogin的地址如果想要更改这个login的得知的话，则需要在settings配置文件中添加如下一行

LOGIN_URL = ‘/login’

　　django自带方法

　　1、login

from django.contrib.auth import login, authenticate

user = authenticate(username='u2', password='123')
login(request, user)     #登录

　　2、login_required

from django.contrib.auth.decorators import login_required


@login_required
def index(request):          #装饰到函数前面
    pass

django分页功能

　　xss: django为了安全机制，默认传递的都是字符串，比如来自浏览客户的评论，如果给写了个js脚本，抱歉那是不会执行的，只是按照字符串来对待

　　确定安全的情况下，那如何让其对这字符串做解释呢？

　　方法：

　　　　1、前端 {{ page_str |safe}} //对后端传递过来的字符串作解释

　　　　2、后端 from django.utils.safestring import mark_safe

page_str = mark_safe(page) #对html的字符串做mark_safe后，再传递

　　手写一个分页：

def user_list(request):
    current_page = request.GET.get('p',1)     #获取参数p,没有就默认为1
    start = (current_page-1) * 10
    end = current_page * 10
    data = LIST[start:end]        #LIST  想象为数据库获取的数据


    all_count = len(LIST)
    count, yushu = divmod(all_count, 10)
    if y:
        count += 1

    page_list = []
    for i in range(1, count+1):
        temp = '<a href="/user_list/?p=%s>%s</a>"' %(i,i)
        page_list.append(temp)

    page_str = "".join(page_list)

    page_str = mark_safe(page_str)

    return render(request, 'user_list.html' , {'li': data, 'page_str': page_str})

分页

django csrf

　　CSRF, Cross Site Request Forgery, 跨站点伪造请求。举例来讲，某个恶意的网站上有一个指向你的网站的链接，如果某个用户已经登录到你的网站上了，那么当这个用户点击这个恶意网站上的那个链接时，就会向你的网站发来一个请求，你的网站会以为这个请求是用户自己发来的，其实呢，这个请求是那个恶意网站伪造的。具体的细节及其危害见 wikipedia

　　机制：django 第一次响应来自某个客户端的请求时，会在服务器端随机生成一个 token，把这个 token 放在 cookie 里。然后每次 POST 请求都会带上这个 token，这样就能避免被 CSRF 攻击。

　　setting中开启csrf功能后，在没有做特殊处理的情况下会遇到下面的报错：

　　那如何解决这个问题呢？

　　1、form 表单提交的的时候需要添加上{% csrf_token %}

<form action="/cref/" method="post">
    {%  csrf_token %}
    <div>
        用户名：<input type="text" name="username">
    </div>
    <div>
        密码：<input type="text" name="password">
    </div>
    <div>
        <input type="submit" value="提交">
    </div>
</form>

csrf_token

　　2、如果是ajax请求呢？那就需要在请求的时候，在header中添加这么一行，headers:{'X-CSRFtoken':csrf_token},

    <script>
        $(function () {
            $('#btn').click(function () {
                var csrf_token = $.cookie('csrftoken')
                $.ajax({
                    url:'/cref/',
                    type:"POST",
                    headers:{'X-CSRFtoken':csrf_token},
                    data : {'username':'admin','password':'123'},
                    success:function(){

                    }
                })

            })
        })

    </script>

ajax

　　如果你的ajax很多，老是添加这么一行，那岂不是很麻烦呢？那只需要在开头添加一个ajaxSetup即可　

        $(function () {
            $.ajaxSetup({
                beforeSend:function (xhr,settings) {
                    xhr.setRequestHeader('X-CSRFtoken',$.cookie('csrftoken'))
                }
            });

            $('#btn').click(function () {
                var csrf_token = $.cookie('csrftoken')
                $.ajax({
                    url:'/cref/',
                    type:"POST",
                    //headers:{'X-CSRFtoken':csrf_token},
                    data : {'username':'admin','password':'123'},
                    success:function(){

                    }
                })

            })
        })

many_ajax

　　另外想一个问题，如果有100个views,只有其中两个需要加这个需求，另外的都不加，再如果有两个加，其他的都不加呢？这里就涉及到全局和局部使之生效的问题

　　全局：

　　　　中间件 django.middleware.csrfViewMiddleware

　　局部：

@csrf_protect, 为当前的幻术强制设置防跨站请求伪造功能，即便settings中没有设置全局中间件
@csrf_exempt,取消当前函数防跨站请求伪造功能，即便settings中设置了全局中间件

django + uwsgi + nginx 启动

　　使用runserver可以使我们的django项目很便捷的在本地运行起来，但这只能在局域网内访问，如果在生产环境部署django，就要多考虑一些问题了。比如静态文件处理，安全，效率等等，本篇文章总结归纳了一下基于uwsgi+Nginx下django项目生产环境的部署

　　准备知识：

　　　　Django：一个基于python的开源web框架

　　　　uwsgi：一个基于自由uwagi协议、wsgi协议和http服务协议的web网关

　　　　nginx:常用的高性能代理服务器

　　　　wsgi.py : django项目携带的一个wsgi接口文件

　　项目流程

　　　　1、首先客户端请求服务资源，

　　　　2、nginx作为直接对外的服务接口,接收到客户端发送过来的http请求,会解包、分析，

　　　　3、如果是静态文件请求就根据nginx配置的静态文件目录，返回请求的资源，

　　　　4、如果是动态的请求,nginx就通过配置文件,将请求传递给uWSGI；uWSGI 将接收到的包进行处理，并转发给wsgi，

　　　　5、wsgi根据请求调用django工程的某个文件或函数，处理完后django将返回值交给wsgi，

　　　　6、wsgi将返回值进行打包，转发给uWSGI， uWSGI接收后转发给nginx,nginx最终将返回值返回给客户端(如浏览器)。 *

　　　　注:不同的组件之间传递信息涉及到数据格式和协议的转换

　　软件安装：

　　　　1.yum -y install gcc openssl openssl-devel

　　　　2.install python3
                     ./configure --prefix=/usr/local --with-ssl
                      make && make install
　　　　3. istall pip3
   　　　　url:https://github.com/pypa/pip/archive/1.5.5.tar.gz
   　　　　python3 setup.py install
　　　　 /usr/local/python3/bin       pip 安装的命令都放到这个目录下

　　　　4.pip3 install uwsgi

5. install nginx

　　　　　tar 包安装的ngin,需要自己添加快速启动脚本到 /etc/init.d/下

 #!/bin/sh
 #
 # nginx - this script starts and stops the nginx daemon
 #
 # chkconfig: - 85 15
 # description: Nginx is an HTTP(S) server, HTTP(S) reverse \
 #   proxy and IMAP/POP3 proxy server
 # processname: nginx
 # config: /etc/nginx/nginx.conf
 # config: /etc/sysconfig/nginx
 # pidfile: /var/run/nginx.pid
 # Source function library.
 . /etc/rc.d/init.d/functions
 # Source networking configuration.
 . /etc/sysconfig/network
 # Check that networking is up.
 [ "$NETWORKING" = "no" ] && exit 0
     nginx="/usr/local/nginx/sbin/nginx"
     prog=$(basename $nginx)
     NGINX_CONF_FILE="/usr/local/nginx/conf/nginx.conf"
 [ -f /etc/sysconfig/nginx ] && . /etc/sysconfig/nginx
     lockfile=/var/lock/subsys/nginx

 start() {
     [ -x $nginx ] || exit 5
     [ -f $NGINX_CONF_FILE ] || exit 6
     echo -n $"Starting $prog: "
     daemon $nginx -c $NGINX_CONF_FILE
     retval=$?
     echo
 [ $retval -eq 0 ] && touch $lockfile
     return $retval
 }

 stop() {
     echo -n $"Stopping $prog: "
     killproc $prog -QUIT
     retval=$?
     echo
 [ $retval -eq 0 ] && rm -f $lockfile
     return $retval
     killall -9 nginx
 }

 restart() {
     configtest || return $?
     stop
     sleep 1
     start
 }

 reload() {
     configtest || return $?
     echo -n $"Reloading $prog: "
     killproc $nginx -HUP
     RETVAL=$?
     echo
 }

 force_reload() {
     restart
 }

 configtest() {
     $nginx -t -c $NGINX_CONF_FILE
 }

 rh_status() {
     status $prog
 }

 rh_status_q() {
     rh_status >/dev/null 2>&1
 }

 case "$1" in
     start)
         rh_status_q && exit 0
         $1
     ;;
     stop)
         rh_status_q || exit 0
         $1
     ;;
     restart|configtest)
         $1
     ;;
     reload)
         rh_status_q || exit 7
         $1
     ;;
     force-reload)
         force_reload
     ;;
     status)
         rh_status
     ;;
     condrestart|try-restart)
         rh_status_q || exit 0
     ;;
     *)
         echo $"Usage: $0 {start|stop|status|restart|condrestart|try-restart|reload|force-reload|configtest}"
         exit 2
 esac

nginx_restat.sh

　　下面配置uwsgi.ini 文件

# hello_uwsgi.ini file
[uwsgi]

# Django-related settings

socket = :9999                   #这里需要配置的socket，如果是http的话，会有错误
#http = :9999

# the base directory (full path)
chdir           = /home/right/cache_check

# Django s wsgi file
module          = cache_check.wsgi

# process-related settings
# master
master          = true

# maximum number of worker processes
processes       = 4


#logto = /var/log/uwsgi/%n.log
daemonize   = /var/log/uwsgi/dango_uwsgi.log

# ... with appropriate permissions - may be needed
# chmod-socket    = 664
# clear environment on exit
vacuum          = true

plugin         = python
#harakiri    = 12

　　添加uwsgi快速启动脚本

#!/bin/sh
NAME="dango"
if [ ! -n "$NAME" ];then
    echo "no arguments"
    exit;
fi

echo $NAME
ID=`ps -ef | grep "$NAME" | grep -v "$0" | grep -v "grep" | awk '{print $2}'`
echo $ID
echo "################################################"
for id in $ID
do
kill -9 $id
echo "kill $id"
done
echo  "################################################"
uwsgi --ini /home/right/cache_check/dango_uwsgi.ini

　　添加nginx的配置

        location / {
            include uwsgi_params;
            uwsgi_pass 127.0.0.1:9999;
               uwsgi_send_timeout 1600;        # 指定连接到后端uWSGI的超时时间。
            uwsgi_connect_timeout 1600;   # 指定向uWSGI传送请求的超时时间，完成握手后向uWSGI传送请求的超时时间。
            uwsgi_read_timeout 1600;        # 指定接收uWSGI应答的超时时间，完成握手后接收uWSGI应答的超时时间。

            #root   html;
            #index  index.html index.htm;
            #uwsgi_param SCRIPT_NAME;
        }

　　到这里配置完毕，可以运行了

针对以上的内容做一个小练习：

　　可以添加新书，并显示

 1 from django.db import models
 2 
 3 # Create your models here.
 4 
 5 class Publisher(models.Model):
 6     name = models.CharField(max_length=30)
 7     address = models.CharField(max_length=50)
 8     city = models.CharField(max_length=60)
 9     state_province = models.CharField(max_length=30)
10     country = models.CharField(max_length=50,null=True)
11     website = models.URLField()
12     def __unicode__(self):
13         return "<%s>"%(self.name)
14 
15 class Author(models.Model):
16     first_name = models.CharField(max_length=30)
17     last_name = models.CharField(max_length=40)
18     email = models.EmailField()
19     def __unicode__(self):
20         return "<%s,%s>"%(self.first_name,self.last_name)
21  
22 class Book(models.Model):
23     title = models.CharField(max_length=100)
24     authors = models.ManyToManyField(Author)
25     publisher = models.ForeignKey(Publisher)
26     publication_date = models.DateField()
27     def __unicode__(self):
28         return "<%s>"%(self.title)

models.py

#!/usr/bin/python
#coding:utf-8

from django.shortcuts import render
from django.http import HttpResponse
from django.template import Context,loader
from django.contrib.auth import authenticate,login,logout

import models
# Create your views here.

def booklist(request):
    if request.method == 'POST':
        book_name = request.POST.get('name')
        publisher_id = request.POST.get('publisher_id')
        author_ids = request.POST.get('author_ids')
        print 'books`s name from post -->',request.POST.get('name')
        print 'publisher_id  from post-->',request.POST.get('publisher_id')
        print 'author_ids from post-->',request.POST.get('author_ids')

        new_book = models.Book(
            title = book_name,
            publisher_id = publisher_id,
            publication_date = '2016-05-22'
        )
        new_book.save()
        new_book.authors.add(*author_ids)   #表中多对多，需要另外插入
        
    books = models.Book.objects.all()
    publisherlist = models.Publisher.objects.all()
    authorlist = models.Author.objects.all()

    return render(request, 'books.html',{'books':books,'publisher':publisherlist,'authorlist':authorlist} )

views.py

 1 <!DOCTYPE html>
 2 <html lang="en" xmlns="http://www.w3.org/1999/html">
 3 <head>
 4     <meta charset="UTF-8">
 5     <title>booklist</title>
 6     <style books_name></style>
 7     <link rel="stylesheet" href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css" >
 8     <style>
 9         .book_form{margin-top:10px;}
10     </style>
11 </head>
12 <body>
13     <div class="container">
14         </br>
15         <ul>
16             {% for book in books %}
17                 <li>{{book.title}}</li>
18 
19             {% endfor%}
20         </ul>
21 
22         </br>
23         <form method='post' action='/dashboard/books/'>
24             <div class="col-xs-4">
25                 输入书名<input type="text" class=" input-sm form-control" name='name' >
26             </div>
27             </br>
28             <div class="col-xs-2">
29                 <select class="input-sm form-control" name="publisher_id">
30                     <option >请选择出版社</option>
31                     {% for banshe in publisher%}
32                         <option value='{{banshe.id}}'>{{banshe.name}}</option>
33                     {% endfor%}
34 
35                 </select>
36 
37             </div>
38             <div class="col-xs-4">
39                <select multiple class="form-control" name='author_ids'>
40                   {% for auth in authorlist%}
41                   <option value='{{auth.id}}'>{{auth.first_name}}</option>
42                   {% endfor %}
43                 </select> 
44             </div>
45 
46             <input type="submit" value="创建新书">
47         </form>
48     </div>
49 </body>
50 </html>

前端html

应用练习

总结一

　　用户登录，前端用户ajax请求登录，后端验证，翻过json给前端，前端通过状态码来判断做什么操作

　　涉及的内容：django login, authenticate, login_required ， ajax请求， from表单

from django.http import HttpResponse, JsonResponse
from django.http.response import JsonResponse
from django.shortcuts import render, redirect
from django.contrib.auth import authenticate, login
from django.contrib.auth.decorators import login_required


@login_required
def index(request):
    return render(request, 'index.html')

def mylogin(request):
    user_info = {
        'dachengzi':{'pwd':'123'},
        'kangbazi':{'pwd':'123'}
    }

    if request.method == 'GET':
        print('I am here')
        return render(request, 'pages/examples/login.html')

    elif request.method == 'POST':
        print('I am post request!')
        username = request.POST.get('username')
        password = request.POST.get('password')
        print(username,password)
        res = authenticate(username=username, password=password)
        res_json = {}
        if res is not None:
            login(request,res)
            res_json['status'] = 0
        else:
            res_json['status'] = 1

    return JsonResponse(res_json)

views.py

<form action="#" >         //防止from自动get请求，这里填入#
      <div class="form-group has-feedback">
        <input id="username" class="form-control" placeholder="Email">
        <span class="glyphicon glyphicon-envelope form-control-feedback"></span>
      </div>
      <div class="form-group has-feedback">
        <input id="password" type="password" class="form-control" placeholder="Password">
        <span class="glyphicon glyphicon-lock form-control-feedback"></span>
      </div>
      <div class="row">
        <div class="col-xs-8">
          <div class="checkbox icheck">
            <label>
              <input type="checkbox"> Remember Me
            </label>
          </div>
        </div>
        <!-- /.col -->
        <div class="col-xs-4">
          <button id="submit" type="submit" class="btn btn-primary btn-block btn-flat">Sign In</button>
        </div>
        <!-- /.col -->
      </div>
    </form>



<script>

    $('#submit').click(function () {
        username = $('#username').val()
        password = $('#password').val()

        $.ajax({
            type:"POST",
            url:"/login/",
            data:{username:username, password:password},
            dataTpye:"json",
            success:function (data1) {
                status = data1.status
                if(status ==0){
                    location.href='/'
                }else{
                    console.log('error')
                }
            }
        })

    })

</script>

html

posted @ 2017-08-14 11:39 IT小工Joey 阅读(682) 评论(0) 编辑收藏举报

刷新页面返回顶部

IT小工

Python Django

参考文档

Django 安装

django 实例

django app 实例

django HttpRequest 对象

django HttpResponse对象

django JsonResponse对象

django QueryDict对象

Render 的前世

project 添加一个目录并且可识别

django 路由系统URL

django Views

django Template

django Simple_tag/filter

django cookie

django session

django 链接数据库

类方法的写法

session 与 cookie的区别

django流程介绍

Djiango 数据库 ORM

django shell 操作/自带方法

django分页功能

django csrf

django + uwsgi + nginx 启动

针对以上的内容做一个小练习：

应用练习

公告

django app 实例　