小蜜蜂

小蜜蜂

关注
发信
关注(|-)粉丝(-|)

Python之Django框架的使用

1、安装Django

pip install django

2、创建Django项目

django-admin startproject 项目名称

3、在setting文件中配置数据库

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': '',
        'USER':'root',
        'PASSWORD':'',
        'HOST':'',
        'PORT':'',
    }
}

4、创建应用

python manage.py startapp 应用名称

5、定义模型类models.py,一个类对应数据库的一个表，一个属性，对应数据表中的一个字段

from django.db import models

class 类名(models.Model):
  xxxx=models.CharField(max_length=20)
  。。。

6、生成数据表

  • 激活模型：编辑settings.py文件，将应用加入到installed_apps中
  • 生成迁移文件：根据模型类生成sql语句
    python manage.py makemigrations
  • 执行迁移：执行sql语句生成数据表
    python manage.py migrate

7、运行Django项目，默认端口8000

python manage.py runserver ip:port

8、使用Django的管理

  • 创建一个管理员用户
python manage.py createsuperuser，按提示输入用户名、邮箱、密码
  • 启动服务器，通过“127.0.0.1:8000/admin”访问，输入上面创建的用户名、密码完成登录
  • 进入管理站点，默认可以对groups、users进行管理

9、管理界面本地化

  • 编辑settings.py文件，设置编码、时区
LANGUAGE_CODE = 'zh-Hans'
TIME_ZONE = 'Asia/Shanghai'

10、向admin注册应用的模型

  • 打开admin.py文件，注册模型

    from django.contrib import admin
    from models import xxx
    admin.site.register(xxx)

11、视图

  • 在django中，视图对WEB请求进行回应
  • 视图接收reqeust对象作为第一个参数，包含了请求的信息
  • 视图就是一个Python函数，被定义在views.py中
#coding:utf-8
from django.http import HttpResponse

def index(request):
    return HttpResponse("index")
  • 定义完成视图后，需要配置urlconf，否则无法处理请求

12、模板

  • 模板是html页面，可以根据视图中传递的数据填充值
  • 修改settings.py文件，设置TEMPLATES的DIRS值
'DIRS': [os.path.join(BASE_DIR, 'templates')],
  • 在模板中访问视图传递的数据
{{输出值，可以是变量，也可以是对象.属性}}
{%执行代码段%}

<!DOCTYPE html>
<html>
<head>
  <title></title>
</head>
<body>

    {{xxx}}

</body>
</html>

13、使用模板

  • 编辑views.py文件，在方法中调用模板
from django.http import HttpResponse
from django.template import RequestContext, loader
from models import xxx

def index(request):
    booklist = BookInfo.objects.all()
    template = loader.get_template('xxx.html')
    context = RequestContext(request, {'xxx': xxx})
    return HttpResponse(template.render(context))

def detail(reqeust, id):
    xxx = BookInfo.objects.get(pk=id)
    template = loader.get_template(xxx.html')
    context = RequestContext(reqeust, {'xxx': xxx})
    return HttpResponse(template.render(context))

14、Render

  • Django提供了函数Render()简化视图调用模板、构造上下文
from django.shortcuts import render
from models import xxx

def index(reqeust):
    xxx = xxx.objects.all()
    return render(reqeust, 'xxxx.html', {'xxx': xxx})


def detail(reqeust, id):
    xxx = xxx.objects.get(pk=id)
    return render(reqeust, 'xxx.html', {'xxx': xxx})

15、ORM简介

  • MVC框架中包括一个重要的部分，就是ORM，它实现了数据模型与数据库的解耦，即数据模型的设计不需要依赖于特定的数据库，通过简单的配置就可以轻松更换数据库
  • ORM是“对象-关系-映射”的简称，主要任务是：
  • 根据对象的类型生成表结构
  • 将对象、列表的操作，转换为sql语句
  • 将sql查询到的结果转换为对象、列表
  • 这极大的减轻了开发人员的工作量，不需要面对因数据库变更而导致的无效劳动
  • Django中的模型包含存储数据的字段和约束，对应着数据库中唯一的表
    Python之Django框架的使用-LMLPHP
    16、使用MySql数据库
  • 安装mysql包
pip install mysql-python
  • 在mysql中创建数据库
create databases 数据库名字 charset=utf8
  • 打开settings.py文件，修改DATABASES项
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'xxx',
        'USER': '用户名',
        'PASSWORD': '密码',
        'HOST': '数据库服务器ip，本地可以使用localhost',
        'PORT': '端口，默认为3306',
    }
}

17、开发流程

  • 在models.py中定义模型类，要求继承自models.Model
  • 把应用加入settings.py文件的installed_app项
  • 生成迁移文件
  • 执行迁移生成表
  • 使用模型类进行crud操作

18、使用数据库生成模型类

python manage.py inspectdb > xxx/models.py

19、定义模型

  • 在模型中定义属性，会生成表中的字段
  • django会为表增加自动增长的主键列，每个模型只能有一个主键列，如果使用选项设置某属性为主键列后，则django不会再生成默认的主键列
  • 属性命名限制
    & 不能是python的保留关键字
    & 由于django的查询方式，不允许使用连续的下划线

20、定义属性
对于重要数据都做逻辑删除，不做物理删除，实现方法是定义isDelete属性，类型为BooleanField，默认值为False

21、元选项

  • 在模型类中定义类Meta，用于设置元信息
  • 元信息db_table：定义数据表名称，推荐使用小写字母，数据表的默认名称
  • ordering：对象的默认排序字段，获取对象的列表时使用，接收属性构成的列表
   class BookInfo(models.Model):
            ...
            class Meta():
                ordering = ['id']
  • 字符串前加-表示倒序，不加-表示正序
class BookInfo(models.Model):
    ...
    class Meta():
        ordering = ['-id']
  • 排序会增加数据库的开销

22、管理器Manager

  • 用于与数据库进行交互
  • 当定义模型类时没有指定管理器，则Django会为模型类提供一个名为objects的管理器
  • 支持明确指定模型类的管理器
  • 当为模型类指定管理器后，django不再为模型类生成名为objects的默认管理器
  • 管理器是Django的模型进行数据库的查询操作的接口，Django应用的每个模型都拥有至少一个管理器
  • 自定义管理器类主要用于两种情况
  • 情况一：向管理器类中添加额外的方法
  • 情况二：修改管理器返回的原始查询集：重写get_queryset()方法
class BookInfoManager(models.Manager):
    def get_queryset(self):
        return super(BookInfoManager, self).get_queryset().filter(isDelete=False)
class BookInfo(models.Model):
    ...
    books = BookInfoManager()

23 、创建对象

  • 说明： _init _方法已经在基类models.Model中使用，在自定义模型中无法使用，
  • 方式一：在模型类中增加一个类方法
class BookInfo(models.Model):
    ...
    @classmethod
    def create(cls, title, pub_date):
        book = cls(btitle=title, bpub_date=pub_date)
        book.isDelete = False
        return book
引入时间包：from datetime import *
调用：book=BookInfo.create("hello",datetime(1980,10,11));
保存：book.save()
  • 方式二：在自定义管理器中添加一个方法
  • 在管理器的方法中，可以通过self.model来得到它所属的模型类
class BookInfoManager(models.Manager):
    def create_book(self, title, pub_date):
        book = self.model()
        book.btitle = title
        book.bpub_date = pub_date
        book.isDelete = False
        return book

class BookInfo(models.Model):
    ...
    books = BookInfoManager()
调用：book=BookInfo.books.create_book("abc",datetime(1980,1,1))
保存：book.save()

24、实例的属性

  • DoesNotExist：在进行单个查询时，模型的对象不存在时会引发此异常，结合try/except使用

25、实例的方法

  • str (self)：重写object方法，此方法在将对象转换成字符串时会被调用
  • save()：将模型对象保存到数据表中
  • delete()：将模型对象从数据表中删除

26、查询集

  • 在管理器上调用过滤器方法会返回查询集
  • 查询集经过过滤器筛选后返回新的查询集，因此可以写成链式过滤
  • 惰性执行：创建查询集不会带来任何数据库的访问，直到调用数据时，才会访问数据库
  • 何时对查询集求值：迭代，序列化，与if合用
  • 返回查询集的方法，称为过滤器
    all()
    filter()
    exclude()
    order_by()
    values()：一个对象构成一个字典，然后构成一个列表返回
  • 写法：
filter(键1=值1,键2=值2)
等价于
filter(键1=值1).filter(键2=值2)
  • 返回单个值的方法
    get()：返回单个满足条件的对象
    如果未找到会引发"模型类.DoesNotExist"异常
    如果多条被返回，会引发"模型类.MultipleObjectsReturned"异常
  • count()：返回当前查询的总条数
  • first()：返回第一个对象
  • last()：返回最后一个对象
  • exists()：判断查询集中是否有数据，如果有则返回True

26、限制查询集

  • 查询集返回列表，可以使用下标的方式进行限制，等同于sql中的limit和offset子句
  • 注意：不支持负数索引
  • 使用下标后返回一个新的查询集，不会立即执行查询
  • 如果获取一个对象，直接使用[0]，等同于[0:1].get()，但是如果没有数据，[0]引发IndexError异常，[0:1].get()引发DoesNotExist异常

27、查询集的缓存

  • 每个查询集都包含一个缓存来最小化对数据库的访问
  • 在新建的查询集中，缓存为空，首次对查询集求值时，会发生数据库查询，django会将查询的结果存在查询集的缓存中，并返回请求的结果，接下来对查询集求值将重用缓存的结果
  • 情况一：这构成了两个查询集，无法重用缓存，每次查询都会与数据库进行一次交互，增加了数据库的负载
print([e.title for e in Entry.objects.all()])
print([e.title for e in Entry.objects.all()])
  • 情况二：两次循环使用同一个查询集，第二次使用缓存中的数据
querylist=Entry.objects.all()
print([e.title for e in querylist])
print([e.title for e in querylist])
  • 何时查询集不会被缓存：当只对查询集的部分进行求值时会检查缓存，但是如果这部分不在缓存中，那么接下来查询返回的记录将不会被缓存，这意味着使用索引来限制查询集将不会填充缓存，如果这部分数据已经被缓存，则直接使用缓存中的数据

28、字段查询

  • 实现where子名，作为方法filter()、exclude()、get()的参数
  • 语法：属性名称__比较运算符=值
  • 表示两个下划线，左侧是属性名称，右侧是比较类型
  • 对于外键，使用“属性名_id”表示外键的原始值
  • 转义：like语句中使用了%与，匹配数据中的%与，在过滤器中直接写，例如：
  • filter(title__contains="%")=>where title like ‘%%%’，表示查找标题中包含%的
    比较运算符
  • exact：表示判等，大小写敏感；如果没有写“ 比较运算符”，表示判等
    filter(isDelete=False)
  • contains：是否包含，大小写敏感
    exclude(btitle__contains='传')
  • startswith、endswith：以value开头或结尾，大小写敏感
    exclude(btitle__endswith='传')
  • isnull、isnotnull：是否为null
    filter(btitle__isnull=False)
  • 在前面加个i表示不区分大小写，如iexact、icontains、istarswith、iendswith
  • in：是否包含在范围内
    filter(pk__in=[1, 2, 3, 4, 5])
  • gt、gte、lt、lte：大于、大于等于、小于、小于等于
    filter(id__gt=3)
  • year、month、day、week_day、hour、minute、second：对日期间类型的属性进行运算
    filter(bpub_date__year=1980)
    filter(bpub_date__gt=date(1980, 12, 31))
  • 跨关联关系的查询：处理join查询
    – 语法：模型类名 <属性名> <比较>
    – 注：可以没有__<比较>部分，表示等于，结果同inner join
    – 可返向使用，即在关联的两个模型中都可以使用
    filter(heroinfo_ _hcontent_ _contains='八')
  • 查询的快捷方式：pk，pk表示primary key，默认的主键是id
    filter(pk__lt=6)
    聚合函数
  • 使用aggregate()函数返回聚合函数的值
  • 函数：Avg，Count，Max，Min，Sum
from django.db.models import Max
maxDate = list.aggregate(Max('bpub_date'))
  • count的一般用法：
    count = list.count()
    F对象
  • 可以使用模型的字段A与字段B进行比较，如果A写在了等号的左边，则B出现在等号的右边，需要通过F对象构造
    list.filter(bread__gte=F('bcommet'))
  • django支持对F()对象使用算数运算
    list.filter(bread__gte=F('bcommet') * 2)
  • F()对象中还可以写作“模型类__列名”进行关联查询
    list.filter(isDelete=F('heroinfo__isDelete'))
  • 对于date/time字段，可与timedelta()进行运算
    list.filter(bpub_date__lt=F('bpub_date') + timedelta(days=1))
    Q对象
  • 过滤器的方法中关键字参数查询，会合并为And进行
  • 需要进行or查询，使用Q()对象
  • Q对象(django.db.models.Q)用于封装一组关键字参数，这些关键字参数与“比较运算符”中的相同
from django.db.models import Q
list.filter(Q(pk_ _lt=6))
  • Q对象可以使用&（and）、|（or）操作符组合起来
  • 当操作符应用在两个Q对象时，会产生一个新的Q对象
list.filter(pk_ _lt=6).filter(bcommet_ _gt=10)
list.filter(Q(pk_ _lt=6) | Q(bcommet_ _gt=10))
  • 使用~（not）操作符在Q对象前表示取反
    list.filter(~Q(pk__lt=6))
  • 可以使用&|~结合括号进行分组，构造做生意复杂的Q对象
  • 过滤器函数可以传递一个或多个Q对象作为位置参数，如果有多个Q对象，这些参数的逻辑为and
  • 过滤器函数可以混合使用Q对象和关键字参数，所有参数都将and在一起，Q对象必须位于关键字参数的前面

29、错误视图

  • Django原生自带几个默认视图用于处理HTTP错误
  • 404 (page not found) 视图
  • defaults.page_not_found(request, template_name=‘404.html’)
  • 默认的404视图将传递一个变量给模板：request_path，它是导致错误的URL
  • 如果Django在检测URLconf中的每个正则表达式后没有找到匹配的内容也将调用404视图
  • 如果在settings中DEBUG设置为True，那么将永远不会调用404视图，而是显示URLconf 并带有一些调试信息
  • 在templates中创建404.html
<!DOCTYPE html>
<html>
<head>
    <title></title>
</head>
<body>
找不到了
<hr/>
{{request_path}}
</body>
</html>
  • 在settings.py中修改调试
DEBUG = False
ALLOWED_HOSTS = ['*', ]

30、HttpReqeust对象

  • is_ajax()：如果请求是通过XMLHttpRequest发起的，则返回True

  • 31、QueryDict对象

  • 定义在django.http.QueryDict

  • request对象的属性GET、POST都是QueryDict类型的对象

  • 与python字典不同，QueryDict类型的对象用来处理同一个键带有多个值的情况

  • 方法get()：根据键获取值
    – 只能获取键的一个值

  • 如果一个键同时拥有多个值，获取最后一个值
    dict.get('键',default)
    或简写为
    dict['键']

  • 方法getlist()：根据键获取值
    – 将键的值以列表返回，可以获取一个键的多个值
    – dict.getlist(‘键’,default)

31、HttpResponse对象

  • 在django.http模块中定义了HttpResponse对象的API
  • HttpRequest对象由Django自动创建，HttpResponse对象由程序员创建
  • 不调用模板，直接返回数据
    – 调用模板
from django.http import HttpResponse
from django.template import RequestContext, loader

def index(request):
    t1 = loader.get_template('polls/index.html')
    context = RequestContext(request, {'h1': 'hello'})
    return HttpResponse(t1.render(context))

32、HttpResponseRedirect

  • 重定向，服务器端跳转
  • 构造函数的第一个参数用来指定重定向的地址

33、JsonResponse

  • 返回json数据，一般用于异步请求
  • _init _(data)
  • 帮助用户创建JSON编码的响应
  • 参数data是字典对象
  • sonResponse的默认Content-Type为application/json
from django.http import JsonResponse

def index2(requeset):
    return JsonResponse({'list': 'abc'})

34、启用session

  • 使用django-admin startproject创建的项目默认启用
  • 在settings.py文件中
项INSTALLED_APPS列表中添加：
'django.contrib.sessions',

项MIDDLEWARE_CLASSES列表中添加：
'django.contrib.sessions.middleware.SessionMiddleware',
  • 禁用会话：删除上面指定的两个值，禁用会话将节省一些性能消耗
  • 启用会话后，每个HttpRequest对象将具有一个session属性，它是一个类字典对象
  • get(key, default=None)：根据键获取会话的值
  • clear()：清除所有会话
  • flush()：删除当前的会话数据并删除会话的Cookie
  • del request.session[‘member_id’]：删除会话

35、会话过期时间

  • set_expiry(value)：设置会话的超时时间
  • 如果没有指定，则两个星期后过期
  • 如果value是一个整数，会话将在values秒没有活动后过期
  • 若果value是一个imedelta对象，会话将在当前时间加上这个指定的日期/时间过期
  • 如果value为0，那么用户会话的Cookie将在用户的浏览器关闭时过期
  • 如果value为None，那么会话永不过期
  • 修改视图中login_handle函数，查看效果
    存储session
  • 使用存储会话的方式，可以使用settings.py的SESSION_ENGINE项指定
  • 基于数据库的会话：这是django默认的会话存储方式，需要添加django.contrib.sessions到的INSTALLED_APPS设置中，运行manage.py migrate在数据库中安装会话表，可显示指定为
SESSION_ENGINE='django.contrib.sessions.backends.db'
  • 基于缓存的会话：只存在本地内在中，如果丢失则不能找回，比数据库的方式读写更快

SESSION_ENGINE='django.contrib.sessions.backends.cache'
  • 可以将缓存和数据库同时使用：优先从本地缓存中获取，如果没有则从数据库中获取

SESSION_ENGINE='django.contrib.sessions.backends.cached_db'

使用Redis缓存session

  • 会话还支持文件、纯cookie、Memcached、Redis等方式存储，下面演示使用redis存储
  • 安装包
pip install django-redis-sessions
  • 修改settings中的配置，增加如下项
SESSION_ENGINE = 'redis_sessions.session'
SESSION_REDIS_HOST = 'localhost'
SESSION_REDIS_PORT = 6379
SESSION_REDIS_DB = 0
SESSION_REDIS_PASSWORD = ''
SESSION_REDIS_PREFIX = 'session'
  • 管理redis的命令
启动：sudo redis-server /etc/redis/redis.conf
停止：sudo redis-server stop
重启：sudo redis-server restart
redis-cli：使用客户端连接服务器
keys *：查看所有的键
get name：获取指定键的值
del name：删除指定名称的键

36、模板

  • 定义模板路径
DIRS=[os.path.join(BASE_DIR,"templates")]
  • 模板处理
    • Django处理模板分为两个阶段
    • Step1 加载：根据给定的标识找到模板然后预处理，通常会将它编译好放在内存中
loader.get_template(template_name)，返回一个Template对象
  • Step2 渲染：使用Context数据对模板插值并返回生成的字符串
Template对象的render(RequestContext)方法，使用context渲染模板
  • 加载渲染完整代码：

from django.template import loader, RequestContext
from django.http import HttpResponse

def index(request):
    tem = loader.get_template('temtest/index.html')
    context = RequestContext(request, {})
    return HttpResponse(tem.render(context))

快捷函数

  • 为了减少加载模板、渲染模板的重复代码，django提供了快捷函数
  • render_to_string("")
  • render(request,‘模板’,context)

from django.shortcuts import render

def index(request):
    return render(request, 'temtest/index.html')
  • csrf_token：这个标签用于跨站请求伪造保护
{ % csrf_token %}

过滤器

  • 语法：{ { 变量|过滤器 }}，例如{ { name|lower }}，表示将变量name的值变为小写输出

37、HTML转义
关闭转义

  • 对于变量使用safe过滤器
{{ data|safe }}
  • 对于代码块使用autoescape标签
{ % autoescape off %}
{{ body }}
{ % endautoescape %}
  • 标签autoescape接受on或者off参数
  • 自动转义标签在base模板中关闭，在child模板中也是关闭的

38、csrf

  • 跨站请求伪造
  • 某些恶意网站上包含链接、表单按钮或者JavaScript，它们会利用登录过的用户在浏览器中的认证信息试图在你的网站上完成某些操作，这就是跨站攻击

防csrf的使用

  • 在django的模板中，提供了防止跨站攻击的方法，使用步骤如下：
  • step1：在settings.py中启用’django.middleware.csrf.CsrfViewMiddleware’中间件，此项在创建项目时，默认被启用
  • step2：在csrf1.html中添加标签
<form>
{% csrf_token %}
...
</form>

取消保护

  • 如果某些视图不需要保护，可以使用装饰器csrf_exempt，模板中也不需要写标签，修改csrf2的视图如下
from django.views.decorators.csrf import csrf_exempt

@csrf_exempt
def csrf2(request):
    uname=request.POST['uname']
    return render(request,'booktest/csrf2.html',{'uname':uname})

39、验证码
验证码视图

  • 新建viewsUtil.py，定义函数verifycode
  • 此段代码用到了PIL中的Image、ImageDraw、ImageFont模块，需要先安装Pillow（3.4.1）包
  • Image表示画布对象
  • ImageDraw表示画笔对象
  • ImageFont表示字体对象，ubuntu的字体路径为“/usr/share/fonts/truetype/freefont”
  • 代码如下：
from django.http import HttpResponse
def verifycode(request):
    #引入绘图模块
    from PIL import Image, ImageDraw, ImageFont
    #引入随机函数模块
    import random
    #定义变量，用于画面的背景色、宽、高
    bgcolor = (random.randrange(20, 100), random.randrange(
        20, 100), 255)
    width = 100
    height = 25
    #创建画面对象
    im = Image.new('RGB', (width, height), bgcolor)
    #创建画笔对象
    draw = ImageDraw.Draw(im)
    #调用画笔的point()函数绘制噪点
    for i in range(0, 100):
        xy = (random.randrange(0, width), random.randrange(0, height))
        fill = (random.randrange(0, 255), 255, random.randrange(0, 255))
        draw.point(xy, fill=fill)
    #定义验证码的备选值
    str1 = 'ABCD123EFGHIJK456LMNOPQRS789TUVWXYZ0'
    #随机选取4个值作为验证码
    rand_str = ''
    for i in range(0, 4):
        rand_str += str1[random.randrange(0, len(str1))]
    #构造字体对象
    font = ImageFont.truetype('FreeMono.ttf', 23)
    #构造字体颜色
    fontcolor = (255, random.randrange(0, 255), random.randrange(0, 255))
    #绘制4个字
    draw.text((5, 2), rand_str[0], font=font, fill=fontcolor)
    draw.text((25, 2), rand_str[1], font=font, fill=fontcolor)
    draw.text((50, 2), rand_str[2], font=font, fill=fontcolor)
    draw.text((75, 2), rand_str[3], font=font, fill=fontcolor)
    #释放画笔
    del draw
    #存入session，用于做进一步验证
    request.session['verifycode'] = rand_str
    #内存文件操作
    import cStringIO
    buf = cStringIO.StringIO()
    #将图片保存在内存中，文件类型为png
    im.save(buf, 'png')
    #将内存中的图片数据返回给客户端，MIME类型为图片png
    return HttpResponse(buf.getvalue(), 'image/png')

配置url

  • 在urls.py中定义请求验证码视图的url
from . import viewsUtil

urlpatterns = [
    url(r'^verifycode/$', viewsUtil.verifycode),
]

显示验证码

  • 在模板中使用img标签，src指向验证码视图
<img id='verifycode' src="/verifycode/" alt="CheckCode"/>

40、管理静态文件
配置静态文件

  • 在settings 文件中定义静态内容
STATIC_URL = '/static/'
STATICFILES_DIRS = [
    os.path.join(BASE_DIR, 'static'),
]
  • 在项目根目录下创建static目录，再创建当前应用名称的目录
  • 在模板中可以使用硬编码
/static/xxx/xxxx.jpg
  • 在模板中可以使用static编码
{ % load static from staticfiles %}
<img src="{ % static "my_app/myexample.jpg" %}" alt="My image"/>

41、中间件

  • 是一个轻量级、底层的插件系统，可以介入Django的请求和响应处理过程，修改Django的输入或输出
  • 激活：添加到Django配置文件中的MIDDLEWARE_CLASSES元组中
  • 每个中间件组件是一个独立的Python类，可以定义下面方法中的一个或多个
    • _init _：无需任何参数，服务器响应第一个请求的时候调用一次，用于确定是否启用当前中间件
    • process_request(request)：执行视图之前被调用，在每个请求上调用，返回None或HttpResponse对象
    • process_view(request, view_func, view_args, view_kwargs)：调用视图之前被调用，在每个请求上调用，返回None或HttpResponse对象
    • process_template_response(request, response)：在视图刚好执行完毕之后被调用，在每个请求上调用，返回实现了render方法的响应对象
    • process_response(request, response)：所有响应返回浏览器之前被调用，在每个请求上调用，返回HttpResponse对象
    • process_exception(request,response,exception)：当视图抛出异常时调用，在每个请求上调用，返回一个HttpResponse对象
  • 使用中间件，可以干扰整个处理过程，每次请求中都会执行中间件的这个方法
  • 示例：自定义异常处理
  • 与settings.py同级目录下创建myexception.py文件，定义类MyException，实现process_exception方法
from django.http import HttpResponse
class MyException():
    def process_exception(request,response, exception):
        return HttpResponse(exception.message)
  • 将类MyException注册到settings.py中间件中
MIDDLEWARE_CLASSES = (
    'test1.myexception.MyException',
    ...
)
  • 定义视图，并发生一个异常信息，则会运行自定义的异常处理

42、上传图片

  • 当Django在处理文件上传的时候，文件数据被保存在request.FILES
  • FILES中的每个键为中的name
  • 注意：FILES只有在请求的方法为POST 且提交的带有enctype=“multipart/form-data” 的情况下才会包含数据。否则，FILES 将为一个空的类似于字典的对象
  • 使用模型处理上传文件：将属性定义成models.ImageField类型
pic=models.ImageField(upload_to='cars/')
  • 注意：如果属性类型为ImageField需要安装包Pilow
pip install Pillow==3.4.1
  • 图片存储路径
    • 在项目根目录下创建media文件夹
    • 图片上传后，会被保存到“/static/media/cars/图片文件”
    • 打开settings.py文件，增加media_root项
MEDIA_ROOT=os.path.join(BASE_DIR,"static/media")
  • 使用django后台管理，遇到ImageField类型的属性会出现一个file框，完成文件上传
  • 手动上传的模板代码
<html>
<head>
    <title>文件上传</title>
</head>
<body>
    <form method="post" action="upload/" enctype="multipart/form-data">
        <input type="text" name="title"><br>
        <input type="file" name="pic"/><br>
        <input type="submit" value="上传">
    </form>
</body>
</html>
  • 手动上传的视图代码
from django.conf import settings

def upload(request):
    if request.method == "POST":
        f1 = request.FILES['pic']
        fname = '%s/cars/%s' % (settings.MEDIA_ROOT,f1.name)
        with open(fname, 'w') as pic:
            for c in f1.chunks():
                pic.write(c)
        return HttpResponse("ok")
    else:
        return HttpResponse("error")

43、Admin站点

  • 通过使用startproject创建的项目模版中，默认Admin被启用
  • 1.创建管理员的用户名和密码
python manage.py createsuperuser
然后按提示填写用户名、邮箱、密码
  • 2.在应用内admin.py文件完成注册，就可以在后台管理中维护模型的数据
from django.contrib import admin
from models import *

admin.site.register(HeroInfo)
  • 查找admin文件：在INSTALLED_APPS项中加入django.contrib.admin，Django就会自动搜索每个应用的admin模块并将其导入

ModelAdmin对象

  • ModelAdmin类是模型在Admin界面中的表示形式
  • 定义：定义一个类，继承于admin.ModelAdmin，注册模型时使用这个类
class HeroAdmin(admin.ModelAdmin):
    ...
  • 通常定义在应用的admin.py文件里
  • 使用方式一：注册参数
admin.site.register(HeroInfo,HeroAdmin)
  • 使用方式二：注册装饰器
@admin.register(HeroInfo)
class HeroAdmin(admin.ModelAdmin):
  • 通过重写admin.ModelAdmin的属性规定显示效果，属性主要分为列表页、增加修改页两部分

列表页选项

“操作选项”的位置

  • actions_on_top、actions_on_bottom：默认显示在页面的顶部
class HeroAdmin(admin.ModelAdmin):
    actions_on_top = True
    actions_on_bottom = True

list_display

  • 出现列表中显示的字段
  • 列表类型
  • 在列表中，可以是字段名称，也可以是方法名称，但是方法名称默认不能排序
  • 在方法中可以使用format_html()输出html内容
在models.py文件中
from django.db import models
from tinymce.models import HTMLField
from django.utils.html import format_html

class HeroInfo(models.Model):
    hname = models.CharField(max_length=10)
    hcontent = HTMLField()
    isDelete = models.BooleanField()
    def hContent(self):
        return format_html(self.hcontent)

在admin.py文件中
class HeroAdmin(admin.ModelAdmin):
    list_display = ['hname', 'hContent']
  • 让方法排序，为方法指定admin_order_field属性
在models.py中HeroInfo类的代码改为如下：
    def hContent(self):
        return format_html(self.hcontent)
    hContent.admin_order_field = 'hname'
  • 标题栏名称：将字段封装成方法，为方法设置short_description属性
10-04 18:31
Powered by LMLPHP ©2024 小蜜蜂 0.063862