Django&DRF重点内容大盘点

Django&DRF重点内容大盘点

本文只是将学习过程中需要深刻记忆,在工作中常用的一些命令或者知识点进行一个罗列并阐释,不会全面的将所有内容进行讲解。大家可以在了解了Django框架和DRF框架之后再来看这篇文章。否则会有点不知所云。

1.Django

1.1创建Django项目

这一命令必须熟记于心:

django-admin startproject 项目名

1.2 创建子应用

1.在工作中我们要开发很多项目,肯定需要很多模块,创建子应用肯定也需要掌握:

python manage.py startapp 子应用名

注意:此命令需要在项目的目录下进行输入。

2.创建完子应用中之后,千万不要忘记去INSTALLED_APPS中进行注册,这个参数在setting文件中。

1.3一个程序注意的点

1.3.1视图函数的定义

1)定义视图函数之后,要有一个request形参接收请求对象。

2)返回的时候用到了 HttpResponse这一命令返回响应对象

1.3.2url地址的配置

1.在子应用中的urls.py文件中设置当前子应用中url地址和视图对应关系

urlpatterns = [
    url(r'^url正则表达式$',views.视图函数名)
]

2.在项目总的urls.py文件中包含子应用中的urls.py文件

urlpatterns = [
    url(r'^',include('users.urls'))
]

1.4url配置

在子应用中进行url地址的配置时,建议严格匹配开头和结尾,避免在地址匹配时候出错。

1.5项目配置项

1.BASE_DIR指的是Django项目根目录

2.语言和时区本地化:

LANGUAGE_CODE = 'zh-Hans' # 中文语言
TIME_ZONE = 'Asia/Shanghai' # 中国时间

1.6客户端向服务器传递参数途径

1.6.1通过URL地址传递参数

在我们的url地址中的参数,我们如果想要获取可以在子应用中的urls文件中进行设置 还可以像 (?P<city>\w+)这样给分组起名字,在传参的时候就可以不用按照顺序了

/weather/城市/年份
url(r'weather/(\w+)/(\d{4})/$',views.weather)

1.6.2通过查询字符串传递参数

# /qs/?a=1&b=2&a=3
def qs(request):
    a = request.GET.get('a')
    b = request.GET.get('b')
    alist = request.GET.getlist('a')
    print(a)  # 3
    print(b)  # 2
    print(alist)  # ['1', '3']
    return HttpResponse('OK')

重要:查询字符串不区分请求方式,即假使客户端进行POST方式的请求,依然可以通过request.GET获取请求中的查询字符串数据。

1.6.3通过请求体传递数据

1)post表单提交的数据

/form/
def form_data(request):
    name = request.POST.get('name')
    age = request.POST.get('age')
    return HttpResponse('OK')

2)json数据

/json/
def json_data(request):
    req_data = request.body
    json_str = req_data.decode()
    req_dict = json.loads(json_str)
    name = req_dict.get('name')
    age = req_dict.get('age')
    return HttpResponse('OK')

1.6.4通过请求头传递数据(了解即可)

1.6.5request对象的属性

request请求对象的属性

说明

GET

查询字符串参数

POST

请求体重的表单数据

body

请求体中原始的bytes数据

method

请求方式

path

请求的url路径

META

请求头

COOKIES

客户端发送的cookie信息

FILES

客户端上传的文件

1.7相应对象构造

1.7.1响应时返回json数据

def get_json(request):
    res_dict = {
        'name':'xiaoyan',
        'age':'18'
    }
    return JsonResponse(res_dict)

1.7.2响应时进行页面重定向

def redirect_test(request):
    # 第一个参数是namespace,第二个参数是name
    req_url = reverse('users:index')
    return redirect(req_url)

1.8状态保持之session

1)将session信息保存到redis中

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/1",
        "OPTIONS": {
            "CLIENT_CLASS": "django_redis.client.DefaultClient",
        }
    }
}
SESSION_ENGINE = "django.contrib.sessions.backends.cache"
SESSION_CACHE_ALIAS = "default"

2)设置session

request.session['<key>'] = '<value>'

3)获取session

request.session.get('<key>')

1.9类视图

1.9.1类视图的使用

1)定义类视图

/register/
class RegisterView(View):
    def get(self,request):
        return HttpResponse('返回注册页面')
    def post(self,request):
        return HttpResponse('进行注册处理...')
    def put(self,request):
        return HttpResponse('put方法被调用')

2)进行url配置

url(r'^register/$',views.RegisterView.as_view())

1.9.2类视图添加装饰器

使用Django框架提供method_decorator将针对函数视图装饰器添加到类视图的方法上面

# 为全部请求方法添加装饰器
@method_decorator(my_decorator, name='dispatch')
class DemoView(View):
    def get(self, request):
        print('get方法')
        return HttpResponse('ok')

    def post(self, request):
        print('post方法')
        return HttpResponse('ok')


# 为特定请求方法添加装饰器
@method_decorator(my_decorator, name='get')
class DemoView(View):
    def get(self, request):
        print('get方法')
        return HttpResponse('ok')

    def post(self, request):
        print('post方法')
        return HttpResponse('ok')

1.10中间件

1.10.1定义中间件

def simple_middleware(get_response):
    # 此处编写的代码仅在Django第一次配置和初始化的时候执行一次。

    def middleware(request):
        # 此处编写的代码会在每个请求处理视图前被调用。

        response = get_response(request)

        # 此处编写的代码会在每个请求处理视图之后被调用。

        return response

    return middleware

1.10.2 在 MIDDLEWARE中注册中间

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    # 'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
    'users.middleware.my_middleware',  # 添加中间件
]

1.10.3注意:中间件是全局的

1.11使用模板的详细步骤

1.加载模板:指定使用模板文件,获取模板对象

from django.template import loader
temp = loader.get_template('模板文件名')

2.模板渲染:给模板文件传递变量,将模板文件中的变量进行替换,获取替换之后的html内容

res_html = temp.render(字典)

3.创建响应对象

return HttpResponse(res_html)

1.12数据库

1.12.1数据库链接配置

1.在settings.py进行配置

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'HOST': '127.0.0.1',  # 数据库主机
        'PORT': 3306,  # 数据库端口
        'USER': 'root',  # 数据库用户名
        'PASSWORD': 'mysql',  # 数据库用户密码
        'NAME': 'django_demo'  # 数据库名字
    }
}

2.首次启动时需要在项目同名的目录init.py添加

pip install pymysql
import pymysql
pymysql.install_as_MySQLdb()

1.12.2定义模型类

class 模型类名(models.Model):
    # 字段名 = models.字段类型(选项参数)
    # ...

    class Meta:
        db_table = '<表名>'

定义外键属性

hbook = models.ForeignKey(BookInfo, on_delete=models.CASCADE, verbose_name='图书')  # 外键

cascade是级联,删除主表数据时连同外键表中数据一起删除

1.12.3迁移生成表

1)生成迁移文件

python manage.py makemigrations

2)同步到数据库中

python manage.py migrate

1.12.4通过模型类和对象进行数据库操作(增删改查)

新增

  1. 创建模型类对象-->对象.save()
  2. 模型类.objects.create(...)

注意:添加HeroInfo时,可以给hbook赋值,也可以直接表中hbook_id赋值

HeroInfo是定义的英雄模型类,与图书BookInfo对应。

修改

1. 查询对象->修改对象属性->对象.save()
 2. 模型类.objects.filter(...).update(...)

删除

  1. 查询对象->对象.delete()
  2. 模型类.objects.filter(...).delete()

查询

基本查询
    模型类.objects.查询函数
条件查询
    对应get, filter, exclude参数中可以写查询条件
    格式: 属性名__条件名=值
    注意:可以写多个查询条件,默认是且的关系
F对象
    用于查询时字段之间的比较
    from django.db.models import F
Q对象
    用于查询时条件之间的逻辑关系
    from django.db.models import Q
    &(与) |(或) ~(非)
聚合
    聚合类: from django.db.models import Count, Sum, Avg, Max, Min
aggregate
排序
    排序默认是升序,降序在排序字段前加-
    order_by
关联查询
    1. 查询和指定对象关联的数据
    由1查多
        一对象.多类名小写_set.all()
        例:book.heroinfo_set.all()
    由多查1
        多对象.外键属性
        例:hero.hbook
    2. 通过模型类进行关联查询
    查图书(一)
        一类.objects.get|filter(多类名__字段__条件=值)
        例:books = BookInfo.objects.filter(heroinfo__hcomment__contains='八')
    查英雄(多)
        多类.objects.filter(外键属性__字段__条件=值)
        例:heros = HeroInfo.objects.filter(hbook__bread__gt=30)

1.13admin站点

上传图片Django自带文件存储系统,可以直接通过Admin站点进行图片的上传,默认上传的文件保存在服务器本地。

使用

1)在配置文件中设置配置项MEDIA_ROOT='上传文件的保存目录'

2)定义模型类时,图片字段的类型使用 ImageField

3)迁移生成表并在admin.py注册模型类,直接登录Admin站点就可以进行图片上传

2.DRF框架

2.1目的

利用DRF框架快速的实现RestAPI接口的设计

2.2RestfulAPI接口设计风格

关键点

1)url地址尽量使用名词,不要使用动词 2)请求url地址采用不同的请求方式执行不同的操作 GET(获取) POST(新增) PUT(修改) DELETE(删除) 3)过滤参数可以放在查询字符串中 4)响应数据返回&响应状态码

状态码

说明

200

获取或修改成功

201

新增成功

204

删除成功

404

资源不存在

400

客户请求有误

500

服务器错误

5)响应数据的格式:json

2.3django自定义RestAPI接口

RestAPI接口核心工作 1.将数据库数据序列化为前端所需要的格式,并返回 2.将前端发送的数据反序列化为模型类对象,并保存到数据库中

2.4DRF框架

2.4.1作用:大大提高RestAPI接口开发效率

2.5序列化器Serializer

2.5.1功能

进行数据的序列化和反序列化

2.5.2序列化器的定义

继承自serializers.Serializer

from rest_framework import serializers

# serializers.Serializer:DRF框架中所有序列化器的父类,定义序列化器类时,可以直接继承此类
# serializers.ModelSerializer:Serializer类的子类,在父类的基础上,添加一些功能

class 序列化器类名(serializers.Serializer):
    # 字段名 = serializers.字段名(选项参数)

序列化器对象创建:

序列化器类(instance=<实例对象>,data=<数据>,**kwargs)

2.5.3序列化功能

说白了就是将实例对象转换为字典数据

1)序列化单个对象

book = BookInfo.objects.get(id=1)
serializer = BookInfoSerializer(book)
res = json.dumps(serializer.data,ensure_ascii=False,indent=4)

2)序列化多个对象,其实就是添加了一个many参数

books = BookInfo.objects.all()
serializer = BookInfoSerializer(books,many=True)
res = json.dumps(serializer.data,ensure_ascii=False,indent=4)

3)关联对象的嵌套序列化

1.将关联对象序列化为关联对象的主键

hbook = serializers.PrimaryKeyRelatedField(label='图书',read_only=True)

2.采用指定的序列化器将关联对象进行序列化

hbook = BookInfoSerializer(label='图书')

3.将关联对象序列化为关联对象模型类_str_方法的返回值

hbook = serializers.StringRelatedField(label='图书')

注意:和对象关联的对象如果有多个,在序列化器中定义嵌套序列化字段时,需要添加many=True。

2.5.4反序列化功能

反序列化-数据校验

data = {'btitle':'python','bpub_date':'1980-1-1'}
serializer = BookInfoSerializer(data)
serializer.is_valid()
serializer.errors
serialiser.validated_data

当系统提供的校验不能满足我们的需求的时候,我们可以补充额外的验证:

1)指定特定字段的 validators参数进行补充验证

btitle = serializers.CharField(label='标题',max_length=20,validators=[about_django])

注意:此处的 about_django为我们自定义的校验函数

2)在序列化器类中定义特定方法 validate_<fieldname>针对特定字段进行补充验证

def validate_btitle(self,value):
    if 'django' not in value.lower():
        raise serializers.validationError('图书不是关于Django的')
    return value

3)定义 validate方法进行补充验证(结合多个字段内容验证)

def validate(self,attrs):
    """
    此处的attrs是一个字典,创建序列化器对象时,传入data数据
    """
    bread = attrs['bread']
    bcomment = attrs['bcomment']
    if bread<=bcomment:
        raise serializers.ValidationError('图书阅读量必须大于评论量')
    return attrs

2.5.5反序列化-数据保存(新增&更新)

校验通过之后,可以调用 serializer.save()进行数据保存

1)数据新增

def create(self,validated_data):
    """
    validated_data:字典,校验之后的数据
    """
    book = BookInfo.objects.create(**validated_data)
    return book

-----------------------------
data = {'btitle':'python','bpub_data':'1802-1-1','bread':30,'bcomment:20'}
serializer = BookInfoSerializer(data=data)
serializer.is_valid()
serializer.save()
serializer.data

2)数据更新

def update(self,instance,validated_data):
    """
    instance:创建序列化器对象时传入实例对象
    validated_data:是一个字典,校验之后的数据
    """
    btitle = validated_data.get('btitle')
    bpub_data_date = validated_data.get('bpub_date')

    instance.btitle = btitle
    instance.bpub_date = bpub_date
    instance.save()

    return instance

2.5.6使用序列化器改写RestAPI接口

我们举两个代表性的例子即可:

# /books/
class BookListView(View):
    def get(self, request):
        """
        获取所有的图书的信息:
        1. 查询所有的图书的数据
        2. 返回所有图书的json的数据
        """
        # 1. 查询所有的图书的数据
        books = BookInfo.objects.all() # QuerySet

        # 2. 返回所有图书的json的数据,状态码: 200
        books_li = []
        for book in books:
            # 将book对象转换成dict
            book_dict = {
                'id': book.id,
                'btitle': book.btitle,
                'bpub_date': book.bpub_date,
                'bread': book.bread,
                'bcomment': book.bcomment,
                'image': book.image.url if book.image else ''
            }

            books_li.append(book_dict)

        return JsonResponse(books_li, safe=False)

    def post(self, request):
        """
        新增一本图书的信息:
        1. 获取参数btitle和bpub_date并进行校验
        2. 创建图书信息并添加进数据表中
        3. 返回新增的图书的json数据,状态码: 201
        """
        # 需求: 前端需要传递新增图书的信息(btitle, bpub_date),通过json传递

        # 1. 获取参数btitle和bpub_date并进行校验
        # 获取json的原始数据
        req_data = request.body # bytes

        # 将bytes转换为str
        json_str = req_data.decode()

        # 将json字符串转换dict
        req_dict = json.loads(json_str)

        # 获取btitle和bpub_date
        btitle = req_dict.get('btitle')
        bpub_date = req_dict.get('bpub_date')

        # TODO: 省略参数校验过程...

        # 2. 创建图书信息并添加进数据表中
        book = BookInfo.objects.create(
            btitle=btitle,
            bpub_date=bpub_date
        )

        # 3. 返回新增的图书的json数据,状态码: 201
        # 将book对象转换成dict
        book_dict = {
            'id': book.id,
            'btitle': book.btitle,
            'bpub_date': book.bpub_date,
            'bread': book.bread,
            'bcomment': book.bcomment,
            'image': book.image.url if book.image else ''
        }

        return JsonResponse(book_dict, status=201)

修改之后:

class BookListView(View):
    def get(self, request):
        books = BookInfo.objects.all() # QuerySet
        serializer = BookInfoSerializer(books, many=True)
        return JsonResponse(serializer.data, safe=False)

    def post(self, request):
        req_data = request.body # bytes
        json_str = req_data.decode()
        req_dict = json.loads(json_str)

        serializer = BookInfoSerializer(data=req_dict)
        serializer.is_valid(raise_exception=True)

        # 反序列化-数据保存(新增) -> create
        serializer.save()
        return JsonResponse(serializer.data, status=201)

原文发布于微信公众号 - 小闫笔记(Pythonnote)

原文发表时间:2019-01-19

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

扫码关注云+社区

领取腾讯云代金券