1. 为什么要做前后端分离？

    - 前后端交给不同的人来编写，职责划分明确。

    - API        (IOS,安卓,PC,微信小程序...)

    - vue.js等框架编写前端时，会比之前写jQuery更简单快捷。

2. 简述http协议？

    - 基于socket

    - 数据格式：

        "GET /index?name=123&age=19 http1.1\r\nhost:www.luffyciti.com\r\ncontent-type:application/json...\r\n\r\n"

        "POST /index http1.1\r\nhost:www.luffyciti.com\r\ncontent-type:application/json...\r\n\r\n{name:'alex',age:18}"

        "POST /index http1.1\r\nhost:www.luffyciti.com\r\ncontent-type:application/enform.....\r\n\r\nname=alex&age=18&xx=19"

    - 无状态短链接

        一次请求一次响应之后断开连接

3. 简述restful 规范？

    https://www.luffycity.com/api/v1/courses/?sub_category=0

    https://www.luffycity.com/api/v1/courses/?sub_category=0

    看上面一段url，可以说出5个

    1. 使用https代替http  2.在URL中体现自己写的是API 3. 在URL中体现版本  4. 使用名词 5.参数要合理

    之后，请求方式，响应信息。可以说后面5个

    6. 根据请求方式不同,处理不同的操作 7.返回状态码 8.返回错误信息 9. 返回code 10.hyper link(超链接)

4. django rest framework组件的作用？

    - 快速实现符合restful 规范的api

5. 列举django rest framework组件（10个）？

    - 版本

    - 权限

    - 认证

    - 节流

    - 分页

    - 解析器

    - 序列化

    - 视图

    - 路由

    - 渲染器

6. 路飞的表结构

    a. 课程分类

        - 课程大类

        - 课程子类

    b. 学位课

        - 学位课

        - 奖学金

        - 老师

    c. 专题课 or 学位课模块

        - 专题课 or 学位课模块

        - 课程详细

        - 课程大纲

        - 常见问题

        - 章节

        - 课时

        - 作业

    d. 价格

        - 价格策略

7. django contenttypes组件的作用？

    为了解决一张表和多个表做外键关联

from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation

from django.contrib.contenttypes.models import ContentType

from django.db.models import Q

from django.utils.safestring import mark_safe

from django.db import models

import hashlib

# ######################## 课程相关 ########################

class CourseCategory(models.Model):

    """课程大类, e.g 前端  后端..."""

    name = models.CharField(max_length=64, unique=True)

    def __str__(self):

        return "%s" % self.name

    class Meta:

        verbose_name_plural = "01.课程大类"

class CourseSubCategory(models.Model):

    """课程子类, e.g python linux """

    category = models.ForeignKey("CourseCategory")

    name = models.CharField(max_length=64, unique=True)

    def __str__(self):

        return "%s" % self.name

    class Meta:

        verbose_name_plural = "02.课程子类"

class DegreeCourse(models.Model):

    """学位课程"""

    name = models.CharField(max_length=128, unique=True)

    course_img = models.CharField(max_length=255, verbose_name="缩略图")

    brief = models.TextField(verbose_name="学位课程简介", )

    total_scholarship = models.PositiveIntegerField(verbose_name="总奖学金(贝里)", default=40000)  # 2000 2000

    mentor_compensation_bonus = models.PositiveIntegerField(verbose_name="本课程的导师辅导费用(贝里)", default=15000)

    period = models.PositiveIntegerField(verbose_name="建议学习周期(days)", default=150)  # 为了计算学位奖学金

    prerequisite = models.TextField(verbose_name="课程先修要求", max_length=1024)

    teachers = models.ManyToManyField("Teacher", verbose_name="课程讲师")

    # 用于GenericForeignKey反向查询， 不会生成表字段，切勿删除

    # coupon = GenericRelation("Coupon")

    # 用于GenericForeignKey反向查询，不会生成表字段，切勿删除

    degreecourse_price_policy = GenericRelation("PricePolicy")

    def __str__(self):

        return self.name

    class Meta:

        verbose_name_plural = "03.学位课"

class Teacher(models.Model):

    """讲师、导师表"""

    name = models.CharField(max_length=32)

    role_choices = ((0, '讲师'), (1, '导师'))

    role = models.SmallIntegerField(choices=role_choices, default=0)

    title = models.CharField(max_length=64, verbose_name="职位、职称")

    signature = models.CharField(max_length=255, help_text="导师签名", blank=True, null=True)

    image = models.CharField(max_length=128)

    brief = models.TextField(max_length=1024)

    def __str__(self):

        return self.name

    class Meta:

        verbose_name_plural = "04.导师或讲师"

class Scholarship(models.Model):

    """学位课程奖学金"""

    degree_course = models.ForeignKey("DegreeCourse")

    time_percent = models.PositiveSmallIntegerField(verbose_name="奖励档位(时间百分比)", help_text="只填百分值，如80,代表80%")

    value = models.PositiveIntegerField(verbose_name="奖学金数额")

    def __str__(self):

        return "%s:%s" % (self.degree_course, self.value)

    class Meta:

        verbose_name_plural = "05.学位课奖学金"

class Course(models.Model):

    """专题课/学位课模块表"""

    name = models.CharField(max_length=128, unique=True)

    course_img = models.CharField(max_length=255)

    sub_category = models.ForeignKey("CourseSubCategory")

    course_type_choices = ((0, '付费'), (1, 'VIP专享'), (2, '学位课程'))

    course_type = models.SmallIntegerField(choices=course_type_choices)

    # 不为空；学位课的某个模块

    # 为空；专题课

    degree_course = models.ForeignKey("DegreeCourse", blank=True, null=True, help_text="若是学位课程，此处关联学位表")

    brief = models.TextField(verbose_name="课程概述", max_length=2048)

    level_choices = ((0, '初级'), (1, '中级'), (2, '高级'))

    level = models.SmallIntegerField(choices=level_choices, default=1)

    pub_date = models.DateField(verbose_name="发布日期", blank=True, null=True)

    period = models.PositiveIntegerField(verbose_name="建议学习周期(days)", default=7)  #

    order = models.IntegerField("课程顺序", help_text="从上一个课程数字往后排")

    attachment_path = models.CharField(max_length=128, verbose_name="课件路径", blank=True, null=True)

    status_choices = ((0, '上线'), (1, '下线'), (2, '预上线'))

    status = models.SmallIntegerField(choices=status_choices, default=0)

    template_id = models.SmallIntegerField("前端模板id", default=1)

    # coupon = GenericRelation("Coupon")

    # 用于GenericForeignKey反向查询，不会生成表字段，切勿删除

    price_policy = GenericRelation("PricePolicy")

    asked_question = GenericRelation("OftenAskedQuestion")

    def __str__(self):

        return "%s(%s)" % (self.name, self.get_course_type_display())

    def save(self, *args, **kwargs):

        if self.course_type == 2:

            if not self.degree_course:

                raise ValueError("学位课程必须关联对应的学位表")

        super(Course, self).save(*args, **kwargs)

    class Meta:

        verbose_name_plural = "06.专题课或学位课模块"

class CourseDetail(models.Model):

    """课程详情页内容"""

    course = models.OneToOneField("Course")

    hours = models.IntegerField("课时")

    course_slogan = models.CharField(max_length=125, blank=True, null=True)

    video_brief_link = models.CharField(verbose_name='课程介绍', max_length=255, blank=True, null=True)

    why_study = models.TextField(verbose_name="为什么学习这门课程")

    what_to_study_brief = models.TextField(verbose_name="我将学到哪些内容")

    career_improvement = models.TextField(verbose_name="此项目如何有助于我的职业生涯")

    prerequisite = models.TextField(verbose_name="课程先修要求", max_length=1024)

    recommend_courses = models.ManyToManyField("Course", related_name="recommend_by", blank=True)

    teachers = models.ManyToManyField("Teacher", verbose_name="课程讲师")

    def __str__(self):

        return "%s" % self.course

    class Meta:

        verbose_name_plural = "07.课程或学位模块详细"

class OftenAskedQuestion(models.Model):

    """常见问题"""

    content_type = models.ForeignKey(ContentType)  # 关联course or degree_course

    object_id = models.PositiveIntegerField()

    content_object = GenericForeignKey('content_type', 'object_id')

    question = models.CharField(max_length=255)

    answer = models.TextField(max_length=1024)

    def __str__(self):

        return "%s-%s" % (self.content_object, self.question)

    class Meta:

        unique_together = ('content_type', 'object_id', 'question')

        verbose_name_plural = "08. 常见问题"

class CourseOutline(models.Model):

    """课程大纲"""

    course_detail = models.ForeignKey("CourseDetail")

    title = models.CharField(max_length=128)

    # 前端显示顺序

    order = models.PositiveSmallIntegerField(default=1)

    content = models.TextField("内容", max_length=2048)

    def __str__(self):

        return "%s" % self.title

    class Meta:

        unique_together = ('course_detail', 'title')

        verbose_name_plural = "09. 课程大纲"

class CourseChapter(models.Model):

    """课程章节"""

    course = models.ForeignKey("Course")

    chapter = models.SmallIntegerField(verbose_name="第几章", default=1)

    name = models.CharField(max_length=128)

    summary = models.TextField(verbose_name="章节介绍", blank=True, null=True)

    pub_date = models.DateField(verbose_name="发布日期", auto_now_add=True)

    class Meta:

        unique_together = ("course", 'chapter')

        verbose_name_plural = "10. 课程章节"

    def __str__(self):

        return "%s:(第%s章)%s" % (self.course, self.chapter, self.name)

class CourseSection(models.Model):

    """课时目录"""

    chapter = models.ForeignKey("CourseChapter")

    name = models.CharField(max_length=128)

    order = models.PositiveSmallIntegerField(verbose_name="课时排序", help_text="建议每个课时之间空1至2个值，以备后续插入课时")

    section_type_choices = ((0, '文档'), (1, '练习'), (2, '视频'))

    section_type = models.SmallIntegerField(default=2, choices=section_type_choices)

    section_link = models.CharField(max_length=255, blank=True, null=True, help_text="若是video，填vid,若是文档，填link")

    video_time = models.CharField(verbose_name="视频时长", blank=True, null=True, max_length=32)  # 仅在前端展示使用

    pub_date = models.DateTimeField(verbose_name="发布时间", auto_now_add=True)

    free_trail = models.BooleanField("是否可试看", default=False)

    class Meta:

        unique_together = ('chapter', 'section_link')

        verbose_name_plural = "11. 课时"

    def __str__(self):

        return "%s-%s" % (self.chapter, self.name)

class Homework(models.Model):

    chapter = models.ForeignKey("CourseChapter")

    title = models.CharField(max_length=128, verbose_name="作业题目")

    order = models.PositiveSmallIntegerField("作业顺序", help_text="同一课程的每个作业之前的order值间隔1-2个数")

    homework_type_choices = ((0, '作业'), (1, '模块通关考核'))

    homework_type = models.SmallIntegerField(choices=homework_type_choices, default=0)

    requirement = models.TextField(max_length=1024, verbose_name="作业需求")

    threshold = models.TextField(max_length=1024, verbose_name="踩分点")

    recommend_period = models.PositiveSmallIntegerField("推荐完成周期(天)", default=7)

    scholarship_value = models.PositiveSmallIntegerField("为该作业分配的奖学金(贝里)")

    note = models.TextField(blank=True, null=True)

    enabled = models.BooleanField(default=True, help_text="本作业如果后期不需要了，不想让学员看到，可以设置为False")

    class Meta:

        unique_together = ("chapter", "title")

        verbose_name_plural = "12. 章节作业"

    def __str__(self):

        return "%s - %s" % (self.chapter, self.title)

# class CourseReview(models.Model):

#     """课程评价"""

#     enrolled_course = models.OneToOneField("EnrolledCourse")

#     about_teacher = models.FloatField(default=0, verbose_name="讲师讲解是否清晰")

#     about_video = models.FloatField(default=0, verbose_name="内容实用")

#     about_course = models.FloatField(default=0, verbose_name="课程内容通俗易懂")

#     review = models.TextField(max_length=1024, verbose_name="评价")

#     disagree_number = models.IntegerField(default=0, verbose_name="踩")

#     agree_number = models.IntegerField(default=0, verbose_name="赞同数")

#     tags = models.ManyToManyField("Tags", blank=True, verbose_name="标签")

#     date = models.DateTimeField(auto_now_add=True, verbose_name="评价日期")

#     is_recommend = models.BooleanField("热评推荐", default=False)

#     hide = models.BooleanField("不在前端页面显示此条评价", default=False)

#

#     def __str__(self):

#         return "%s-%s" % (self.enrolled_course.course, self.review)

#

#     class Meta:

#         verbose_name_plural = "13. 课程评价（购买课程后才能评价）"

#

#

# class DegreeCourseReview(models.Model):

#     """学位课程评价

#     为了以后可以定制单独的评价内容，所以不与普通课程的评价混在一起，单独建表

#     """

#     enrolled_course = models.ForeignKey("EnrolledDegreeCourse")

#     course = models.ForeignKey("Course", verbose_name="评价学位模块", blank=True, null=True,

#                                help_text="不填写即代表评价整个学位课程", limit_choices_to={'course_type': 2})

#     about_teacher = models.FloatField(default=0, verbose_name="讲师讲解是否清晰")

#     about_video = models.FloatField(default=0, verbose_name="视频质量")

#     about_course = models.FloatField(default=0, verbose_name="课程")

#     review = models.TextField(max_length=1024, verbose_name="评价")

#     disagree_number = models.IntegerField(default=0, verbose_name="踩")

#     agree_number = models.IntegerField(default=0, verbose_name="赞同数")

#     tags = models.ManyToManyField("Tags", blank=True, verbose_name="标签")

#     date = models.DateTimeField(auto_now_add=True, verbose_name="评价日期")

#     is_recommend = models.BooleanField("热评推荐", default=False)

#     hide = models.BooleanField("不在前端页面显示此条评价", default=False)

#

#     def __str__(self):

#         return "%s-%s" % (self.enrolled_course, self.review)

#

#     class Meta:

#         verbose_name_plural = "14. 学位课评价（购买课程后才能评价）"

class PricePolicy(models.Model):

    """价格与有课程效期表"""

    content_type = models.ForeignKey(ContentType)  # 关联course or degree_course

    object_id = models.PositiveIntegerField()

    content_object = GenericForeignKey('content_type', 'object_id')

    # course = models.ForeignKey("Course")

    valid_period_choices = ((1, '1天'), (3, '3天'),

                            (7, '1周'), (14, '2周'),

                            (30, '1个月'),

                            (60, '2个月'),

                            (90, '3个月'),

                            (180, '6个月'), (210, '12个月'),

                            (540, '18个月'), (720, '24个月'),

                            )

    valid_period = models.SmallIntegerField(choices=valid_period_choices)

    price = models.FloatField()

    class Meta:

        unique_together = ("content_type", 'object_id', "valid_period")

        verbose_name_plural = "15. 价格策略"

    def __str__(self):

        return "%s(%s)%s" % (self.content_object, self.get_valid_period_display(), self.price)

from django.conf.urls import url

from api import views

urlpatterns = [

    url(r'index/$', views.CheckView.as_view()),

]

from django.shortcuts import render,HttpResponse

from api import models

from django.views import View

# Create your views here.

class CheckView(View):

    """

    练习题相关

    """

    def get(self, request):

        # a.查看所有学位课并打印学位课名称以及授课老师

        degree_list = models.DegreeCourse.objects.all().values('name', 'teachers__name')

        print(degree_list)

        return HttpResponse('ok')

class CheckView(View):

    """

    练习题相关

    """

    def get(self, request):

        # a.查看所有学位课并打印学位课名称以及授课老师

        queryset = models.DegreeCourse.objects.all()

        for row in queryset:

            print(row.name,row.teachers.all())

        return HttpResponse('ok')

class CheckView(View):

    """

    练习题相关

    """

    def get(self, request):

        # b.查看所有学位课并打印学位课名称以及学位课的奖学金

        c_obj=models.DegreeCourse.objects.all()

        for i in c_obj:

            # 利用degreecourse_price_policy字段进行反向查询

            print(i.name,i.degreecourse_price_policy.all().values('price'))

        return HttpResponse('ok')

class CheckView(View):

    """

    练习题相关

    """

    def get(self, request):

        # b.查看所有学位课并打印学位课名称以及学位课的奖学金

        degree_list = models.DegreeCourse.objects.all()

        for row in degree_list:

            print(row.name)

            scholarships = row.scholarship_set.all()

            for item in scholarships:

                print('------>',item.time_percent,item.value)

class CheckView(View):

    """

    练习题相关

    """

    def get(self, request):

        # c. 展示所有的专题课

        c_obj = models.Course.objects.filter(degree_course__isnull=True)

        print(c_obj)

        return HttpResponse('ok')

class CheckView(View):

    """

    练习题相关

    """

    def get(self, request):

        # d. 查看id=1的学位课对应的所有模块名称

        obj = models.DegreeCourse.objects.filter(id=1).values('course__name')

        print(obj)

        return HttpResponse('ok')

class CheckView(View):

    """

    练习题相关

    """

    def get(self, request):

        # e. 获取id = 1的专题课，并打印：课程名、级别(中文)、why_study、what_to_study_brief、所有recommend_courses

        c_obj = models.Course.objects.filter(id=1)

        print(c_obj.values('name'))

        print(c_obj.first().get_level_display())

        print(c_obj.values('coursedetail__why_study'))

        print(c_obj.values('coursedetail__what_to_study_brief'))

        print(c_obj.values('coursedetail__recommend_courses'))

        return HttpResponse('ok')

<QuerySet [{'name': 'Python开发入门7天特训营'}]>

初级

<QuerySet [{'coursedetail__why_study': '适合零基础学编程的小白，语言简洁高效，为进入人工智能、数据分析和网站开发做好准备；如果你准备敲下你人生的第一行代码、写出你的第一个程序，路飞学城的入门特训营会是最好的选择'}]>

<QuerySet [{'coursedetail__what_to_study_brief': '1、Python如何才能掌握真正的要领；\r\n2、看完理论课程自己怎么开始动手写出代码；\r\n3、什么才是专业的代码；\r\n4、最流行Python编程工具使用技巧；\r\n5、如何系统且高效的学习Python，遇到问题该如何入手分析\r\n6、可以自主开发各种小程序（如分数打印、猜年龄、用户登录程序、三级菜单等）'}]>

<QuerySet [{'coursedetail__recommend_courses': 1}]>

Python开发入门7天特训营

适合零基础学编程的小白，语言简洁高效，为进入人工智能、数据分析和网站开发做好准备；如果你准备敲下你人生的第一行代码、写出你的第一个程序，路飞学城的入门特训营会是最好的选择

初级

7

适合零基础学编程的小白，语言简洁高效，为进入人工智能、数据分析和网站开发做好准备；如果你准备敲下你人生的第一行代码、写出你的第一个程序，路飞学城的入门特训营会是最好的选择

<QuerySet [<Course: Python开发入门7天特训营(付费)>]>

Python开发入门7天特训营

适合零基础学编程的小白，语言简洁高效，为进入人工智能、数据分析和网站开发做好准备；如果你准备敲下你人生的第一行代码、写出你的第一个程序，路飞学城的入门特训营会是最好的选择

初级

7

适合零基础学编程的小白，语言简洁高效，为进入人工智能、数据分析和网站开发做好准备；如果你准备敲下你人生的第一行代码、写出你的第一个程序，路飞学城的入门特训营会是最好的选择

<QuerySet [<Course: Python开发入门7天特训营(付费)>]>

class CheckView(View):

    """

    练习题相关

    """

    def get(self, request):

        # f. 获取id = 1的专题课，并打印该课程相关的所有常见问题

        c_obj = models.Course.objects.filter(id=1).first()

        # 利用asked_question字段进行反向查询

        print(c_obj.asked_question.all().values('question'))

        return HttpResponse('ok')

class CheckView(View):

    """

    练习题相关

    """

    def get(self, request):

        # f. 获取id = 1的专题课，并打印该课程相关的所有常见问题

        obj = models.Course.objects.get(id=1)

        ask_list = obj.asked_question.all()

        for item in ask_list:

            print(item.question)

        return HttpResponse('ok')

class CheckView(View):

    """

    练习题相关

    """

    def get(self, request):

        # g.获取id = 1的专题课，并打印该课程相关的课程大纲

        c_obj = models.Course.objects.filter(id=1)

        print(c_obj.values('coursedetail__courseoutline__title'))

        return HttpResponse('ok')

class CheckView(View):

    """

    练习题相关

    """

    def get(self, request):

        # g.获取id = 1的专题课，并打印该课程相关的课程大纲

        obj = models.Course.objects.get(id=1)

        outline_list = obj.coursedetail.courseoutline_set.all()

        for item in outline_list:

            print(item.title,item.content)

        return HttpResponse('ok')

class CheckView(View):

    """

    练习题相关

    """

    def get(self, request):

        # h.获取id = 1的专题课，并打印该课程相关的所有章节

        c_obj = models.Course.objects.filter(id=1)

        print(c_obj.values('coursechapter__name'))

        return HttpResponse('ok')

class CheckView(View):

    """

    练习题相关

    """

    def get(self, request):

        # h.获取id = 1的专题课，并打印该课程相关的所有章节

        obj = models.Course.objects.get(id=1)

        chapter_list = obj.coursechapter_set.all() # 默认obj.表名_set.all()

        for item in chapter_list:

            print(item.name)

        return HttpResponse('ok')

class CheckView(View):

    """

    练习题相关

    """

    def get(self, request):

        # i.获取id = 1的专题课，并打印该课程相关的所有课时

        c_obj = models.Course.objects.filter(id=1)

        for i in c_obj.values('coursechapter__chapter','coursechapter__name'):

            print(i.get('coursechapter__chapter'),i.get('coursechapter__name'))

            a_obj=models.CourseChapter.objects.filter(name=i.get('coursechapter__name'))

            for j in a_obj.values('coursesection__name'):

                print('  ',j.get('coursesection__name'))

        return HttpResponse('ok')

class CheckView(View):

    """

    练习题相关

    """

    def get(self, request):

        # i.获取id = 1的专题课，并打印该课程相关的所有课时

        obj = models.Course.objects.get(id=1)

        chapter_list = obj.coursechapter_set.all()

        for chapter in chapter_list:

            print(chapter.name,chapter.coursesection_set.all())

        return HttpResponse('ok')

from django.shortcuts import render,HttpResponse

from api import models

from rest_framework.views import APIView

class CourseView(APIView):

    def get(self,request,*args,**kwargs):

        return HttpResponse('ok')

from django.conf.urls import url

from api.views import course

urlpatterns = [

    url(r'course/$', course.CourseView.as_view()),

]

REST_FRAMEWORK = {

    'DEFAULT_VERSION': 'v1',            # 默认版本

    'ALLOWED_VERSIONS': ['v1', 'v2'],   # 允许的版本

    'VERSION_PARAM': 'version'          # URL中获取值的key

}

from django.conf.urls import url

from api.views import course

urlpatterns = [

    url(r'course/$', course.CourseView.as_view(),name='test'),

]

from django.shortcuts import render,HttpResponse

from api import models

from rest_framework.views import APIView

from rest_framework.versioning import QueryParameterVersioning

from rest_framework.response import Response

class CourseView(APIView):

    # 开启版本支持功能

    versioning_class = QueryParameterVersioning

    def get(self, request, *args, **kwargs):

        # 获取版本

        print(request.version)

        # 获取版本管理的类

        print(request.versioning_scheme)

        # 反向生成URL

        reverse_url = request.versioning_scheme.reverse('test', request=request)

        print(reverse_url)

        return Response('GET请求，响应内容')

from django.conf.urls import url

from api.views import course

urlpatterns = [

    url(r'^(?P<version>[v1|v2]+)/course/$', course.CourseView.as_view(), name='test'),

]

from django.shortcuts import render,HttpResponse

from api import models

from rest_framework.views import APIView

from rest_framework.versioning import URLPathVersioning

from rest_framework.response import Response

class CourseView(APIView):

    # 开启版本支持功能

    versioning_class = URLPathVersioning

    def get(self, request, *args, **kwargs):

        # 获取版本

        print(request.version)

        # 获取版本管理的类

        print(request.versioning_scheme)

        # 反向生成URL

        reverse_url = request.versioning_scheme.reverse('test', request=request)

        print(reverse_url)

        return Response('GET请求，响应内容')

from django.conf.urls import url

from api.views import course

urlpatterns = [

    url(r'^course/$', course.CourseView.as_view(), name='test'),

]

from django.shortcuts import render,HttpResponse

from api import models

from rest_framework.views import APIView

from rest_framework.versioning import AcceptHeaderVersioning

from rest_framework.response import Response

class CourseView(APIView):

    # 开启版本支持功能

    versioning_class = AcceptHeaderVersioning

    def get(self, request, *args, **kwargs):

        # 获取版本 HTTP_ACCEPT头

        print(request.version)

        # 获取版本管理的类

        print(request.versioning_scheme)

        # 反向生成URL

        reverse_url = request.versioning_scheme.reverse('test', request=request)

        print(reverse_url)

        return Response('GET请求，响应内容')

from django.shortcuts import render,HttpResponse

from api import models

from rest_framework.views import APIView

from rest_framework.versioning import HostNameVersioning

from rest_framework.response import Response

class CourseView(APIView):

    # 开启版本支持功能

    versioning_class = HostNameVersioning

    def get(self, request, *args, **kwargs):

        # 获取版本

        print(request.version)

        # 获取版本管理的类

        print(request.versioning_scheme)

        # 反向生成URL

        reverse_url = request.versioning_scheme.reverse('test', request=request)

        print(reverse_url)

        return Response('GET请求，响应内容')

from django.conf.urls import url

from api.views import course

urlpatterns = [

    url(r'^v1/', ([url(r'course/', course.CourseView.as_view(), name='test'), ], None, 'v1')),

    url(r'^v2/', ([url(r'course/', course.CourseView.as_view(), name='test'), ], None, 'v2')),

]

from django.shortcuts import render,HttpResponse

from api import models

from rest_framework.views import APIView

from rest_framework.versioning import NamespaceVersioning

from rest_framework.response import Response

class CourseView(APIView):

    # 开启版本支持功能

    versioning_class = NamespaceVersioning

    def get(self, request, *args, **kwargs):

        # 获取版本

        print(request.version)

        # 获取版本管理的类

        print(request.versioning_scheme)

        # 反向生成URL

        reverse_url = request.versioning_scheme.reverse('test', request=request)

        print(reverse_url)

        return Response('GET请求，响应内容')

REST_FRAMEWORK = {

    'DEFAULT_VERSIONING_CLASS':"rest_framework.versioning.URLPathVersioning",

    'DEFAULT_VERSION': 'v1',

    'ALLOWED_VERSIONS': ['v1', 'v2'],

    'VERSION_PARAM': 'version'

}

from django.conf.urls import url

from api.views import course

urlpatterns = [

    url(r'^course/', course.CourseView.as_view(), name='test'),

]

from django.shortcuts import render,HttpResponse

from api import models

from rest_framework.views import APIView

# from rest_framework.versioning import NamespaceVersioning

from rest_framework.response import Response

class CourseView(APIView):

    # 开启版本支持功能

    # versioning_class = NamespaceVersioning

    def get(self, request, *args, **kwargs):

        # 获取版本

        print(request.version)

        # 获取版本管理的类

        print(request.versioning_scheme)

        # # 反向生成URL

        # reverse_url = request.versioning_scheme.reverse('test', request=request)

        # print(reverse_url)

        return Response('GET请求，响应内容')

from django.shortcuts import render,HttpResponse

from api import models

from rest_framework.views import APIView

from rest_framework.response import Response

import json

class CourseView(APIView):

    def get(self, request, *args, **kwargs):

        """

        获取所有专题课信息

        :param request:

        :param args:

        :param kwargs:

        :return:

        """

        # 方式一：

        course_list = list(models.Course.objects.all().values('id','name'))

        return HttpResponse(json.dumps(course_list,ensure_ascii=False))

from rest_framework import serializers

class CourseSerializer(serializers.Serializer):

    id = serializers.IntegerField()

    name = serializers.CharField()

from django.shortcuts import render,HttpResponse

from api import models

from rest_framework.views import APIView

from rest_framework.response import Response

from api.serializers.course import CourseSerializer

class CourseView(APIView):

    def get(self, request, *args, **kwargs):

        """

        获取所有专题课信息

        :param request:

        :param args:

        :param kwargs:

        :return:

        """

        # 方式二：

        course_list = models.Course.objects.all()

        ser = CourseSerializer(instance=course_list,many=True)

        return Response(ser.data)
       

from django.shortcuts import render,HttpResponse

from api import models

from rest_framework.views import APIView

from rest_framework.response import Response

from api.serializers.course import CourseSerializer

from rest_framework.pagination import PageNumberPagination

class CourseView(APIView):

    def get(self, request, *args, **kwargs):

        # 从数据库中获取数据

        queryset = models.Course.objects.all()

        # 分页

        page = PageNumberPagination()

        # paginate_queryset 接收3参数,分别是queryset对象,request,视图

        # 这里的self就是CourseView视图

        course_list = page.paginate_queryset(queryset,request,self)

        # 分页之后的结果执行序列化

        ser = CourseSerializer(instance=course_list,many=True)

        return Response(ser.data)

REST_FRAMEWORK = {

    'DEFAULT_VERSIONING_CLASS':"rest_framework.versioning.URLPathVersioning",

    'DEFAULT_VERSION': 'v1',

    'ALLOWED_VERSIONS': ['v1', 'v2'],

    'VERSION_PARAM': 'version',

    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',

    'PAGE_SIZE':1

}

class PageNumberPagination(BasePagination):

    """

    A simple page number based style that supports page numbers as

    query parameters. For example:

    http://api.example.org/accounts/?page=4

    http://api.example.org/accounts/?page=4&page_size=100

    """

    # The default page size.

    # Defaults to `None`, meaning pagination is disabled.

    page_size = api_settings.PAGE_SIZE

    django_paginator_class = DjangoPaginator

    # Client can control the page using this query parameter.

    page_query_param = 'page'

    page_query_description = _('A page number within the paginated result set.')

    # Client can control the page size using this query parameter.

    # Default is 'None'. Set to eg 'page_size' to enable usage.

    page_size_query_param = None

    page_size_query_description = _('Number of results to return per page.')

    # Set to an integer to limit the maximum page size the client may request.

    # Only relevant if 'page_size_query_param' has also been set.

    max_page_size = None

    last_page_strings = ('last',)

    template = 'rest_framework/pagination/numbers.html'

    invalid_page_message = _('Invalid page.')

from django.shortcuts import render,HttpResponse

from api import models

from rest_framework.views import APIView

from rest_framework.response import Response

from api.serializers.course import CourseSerializer

from rest_framework.pagination import PageNumberPagination

class CourseView(APIView):

    def get(self, request, *args, **kwargs):

        response = {'code':1000,'data':None,'error':None}

        try:

            # 从数据库中获取数据

            queryset = models.Course.objects.all()

            # 分页

            page = PageNumberPagination()

            # paginate_queryset 接收3参数,分别是queryset对象,request,视图

            # 这里的self就是CourseView视图

            course_list = page.paginate_queryset(queryset,request,self)

            # 分页之后的结果执行序列化

            ser = CourseSerializer(instance=course_list,many=True)

            response['data'] = ser.data

        except Exception as e:

            response['code'] = 500

            response['error'] = '获取数据失败'

        return Response(response)

from django.shortcuts import render,HttpResponse

from api import models

from rest_framework.views import APIView

from rest_framework.response import Response

from api.serializers.course import CourseSerializer

from rest_framework.pagination import PageNumberPagination

class CourseView(APIView):

    def get(self, request, *args, **kwargs):

        response = {'code':1000,'data':None,'error':None}

        try:

            # 从数据库中获取数据

            queryset = models.Course.objects.allxx()  # 模拟错误

            # 分页

            page = PageNumberPagination()

            # paginate_queryset 接收3参数,分别是queryset对象,request,视图

            # 这里的self就是CourseView视图

            course_list = page.paginate_queryset(queryset,request,self)

            # 分页之后的结果执行序列化

            ser = CourseSerializer(instance=course_list,many=True)

            response['data'] = ser.data

        except Exception as e:

            response['code'] = 500

            response['error'] = '获取数据失败'

        return Response(response)

class BaseResponse(object):

    def __init__(self):

        self.code = 1000

        self.data = None

        self.error = None

    @property  # 负责把一个方法变成属性调用

    def dict(self):

        return self.__dict__

from django.shortcuts import render,HttpResponse

from api import models

from rest_framework.views import APIView

from rest_framework.response import Response

from api.serializers.course import CourseSerializer

from rest_framework.pagination import PageNumberPagination

from api.utils.response import BaseResponse

class CourseView(APIView):

    def get(self, request, *args, **kwargs):

        # response = {'code':1000,'data':None,'error':None}

        ret = BaseResponse()

        try:

            # 从数据库中获取数据

            queryset = models.Course.objects.all()

            # 分页

            page = PageNumberPagination()

            # paginate_queryset 接收3参数,分别是queryset对象,request,视图

            # 这里的self就是CourseView视图

            course_list = page.paginate_queryset(queryset,request,self)

            # 分页之后的结果执行序列化

            ser = CourseSerializer(instance=course_list,many=True)

            ret.data = ser.data

        except Exception as e:

            ret.code = 500

            ret.error = '获取数据失败'

        return Response(ret.__dict__)

from rest_framework import serializers

from api import models

class CourseSerializer(serializers.ModelSerializer):

    # id = serializers.IntegerField()

    # name = serializers.CharField()

    class Meta:  # 配置项

        model = models.Course  # Course表

        fields = ['id','name']  # 指定序列化的字段

from rest_framework import serializers

from api import models

class CourseSerializer(serializers.ModelSerializer):

    # 显示choices里面的中文

    level_cn = serializers.CharField(source='get_level_display')

    class Meta:  # 配置项

        model = models.Course  # Course表

        fields = ['id','name','level_cn']  # 指定序列化的字段

from rest_framework import serializers

from api import models

class CourseSerializer(serializers.ModelSerializer):

    # 显示choices里面的中文

    level_cn = serializers.CharField(source='get_level_display')

    # 显示课时,对于一对一，使用表名.字段

    hours = serializers.CharField(source='coursedetail.hours')

    class Meta:  # 配置项

        model = models.Course  # Course表

        fields = ['id','name','level_cn','hours']  # 指定序列化的字段

from django.shortcuts import render,HttpResponse

from api import models

from rest_framework.views import APIView

from rest_framework.response import Response

from api.serializers.course import CourseSerializer

from rest_framework.pagination import PageNumberPagination

from api.utils.response import BaseResponse

class CourseView(APIView):

    def get(self, request, *args, **kwargs):

        # response = {'code':1000,'data':None,'error':None}

        ret = BaseResponse()

        try:

            # 从数据库中获取数据

            queryset = models.Course.objects.all().order_by('pk')

            # 分页

            page = PageNumberPagination()

            # paginate_queryset 接收3参数,分别是queryset对象,request,视图

            # 这里的self就是CourseView视图

            course_list = page.paginate_queryset(queryset,request,self)

            # 分页之后的结果执行序列化

            ser = CourseSerializer(instance=course_list,many=True)

            ret.data = ser.data

        except Exception as e:

            ret.code = 500

            ret.error = '获取数据失败'

        return Response(ret.__dict__)

from rest_framework import serializers

from api import models

class CourseSerializer(serializers.ModelSerializer):

    # 显示choices里面的中文

    level_cn = serializers.CharField(source='get_level_display')

    # 显示课时,对于一对一，使用表名.字段

    hours = serializers.CharField(source='coursedetail.hours')

    recommend_courses = serializers.CharField(source='coursedetail.recommend_courses')

    class Meta:  # 配置项

        model = models.Course  # Course表

        fields = ['id','name','level_cn','hours','recommend_courses']  # 指定序列化的字段

from rest_framework import serializers

from api import models

class CourseSerializer(serializers.ModelSerializer):

    # 显示choices里面的中文

    level_cn = serializers.CharField(source='get_level_display')

    # 显示课时,对于一对一，使用表名.字段

    hours = serializers.CharField(source='coursedetail.hours')

    recommend_courses = serializers.CharField(source='coursedetail.recommend_courses.all')

    class Meta:  # 配置项

        model = models.Course  # Course表

        fields = ['id','name','level_cn','hours','recommend_courses']  # 指定序列化的字段

    def bind(self, field_name, parent):

        # In order to enforce a consistent style, we error if a redundant

        # 'method_name' argument has been used. For example:

        # my_field = serializer.SerializerMethodField(method_name='get_my_field')

        default_method_name = 'get_{field_name}'.format(field_name=field_name)

        assert self.method_name != default_method_name, (

            "It is redundant to specify `%s` on SerializerMethodField '%s' in "

            "serializer '%s', because it is the same as the default method name. "

            "Remove the `method_name` argument." %

            (self.method_name, field_name, parent.__class__.__name__)

        )

        # The method name should default to `get_{field_name}`.

        if self.method_name is None:

            self.method_name = default_method_name

        super(SerializerMethodField, self).bind(field_name, parent)

from rest_framework import serializers

from api import models

class CourseSerializer(serializers.ModelSerializer):

    # 显示choices里面的中文

    level_cn = serializers.CharField(source='get_level_display')

    # 显示课时,对于一对一，使用表名.字段

    hours = serializers.CharField(source='coursedetail.hours')

    # 显示推荐课程,对于多对多,使用def_字段名

    # SerializerMethodField表示序列化字段,使用方法获取

    recommend_courses = serializers.SerializerMethodField()

    class Meta:  # 配置项

        model = models.Course  # Course表

        fields = ['id','name','level_cn','hours','recommend_courses']  # 指定序列化的字段

    def get_recommend_courses(self,row):

        recommend_list = []  # 空列表

        # row表示一行数据,  .all()表示取所有关联的书籍

        for item in row.coursedetail.recommend_courses.all():

            recommend_list.append({'id':item.id,'name':item.name})

        return recommend_list

from rest_framework import serializers

from api import models

class CourseSerializer(serializers.ModelSerializer):

    # 显示choices里面的中文

    level_cn = serializers.CharField(source='get_level_display')

    # 显示课时,对于一对一，使用表名.字段

    hours = serializers.CharField(source='coursedetail.hours')

    # 显示推荐课程,对于多对多,使用def_字段名

    # SerializerMethodField表示序列化字段,使用方法获取

    recommend_courses = serializers.SerializerMethodField()

    class Meta:  # 配置项

        model = models.Course  # Course表

        fields = ['id','name','level_cn','hours','recommend_courses']  # 指定序列化的字段

    def get_recommend_courses(self,row):

        recommend_list = row.coursedetail.recommend_courses.all()

        return [{'id': item.id, 'name': item.name} for item in recommend_list]

from rest_framework import serializers

from api import models

class CourseSerializer(serializers.ModelSerializer):

    # 显示choices里面的中文

    level_cn = serializers.CharField(source='get_level_display')

    # 显示课时,对于一对一，使用表名.字段

    hours = serializers.CharField(source='coursedetail.hours')

    # 显示推荐课程,对于多对多,使用def_字段名

    # SerializerMethodField表示序列化字段,使用方法获取

    recommend_courses = serializers.SerializerMethodField()

    # 显示总奖学金,使用表名.字段

    total_scholarship = serializers.CharField(source='degree_course.total_scholarship')

    class Meta:  # 配置项

        model = models.Course  # Course表

        fields = ['id','name','level_cn','hours','recommend_courses','total_scholarship']  # 指定序列化的字段

    def get_recommend_courses(self,row):

        recommend_list = row.coursedetail.recommend_courses.all()

        return [{'id': item.id, 'name': item.name} for item in recommend_list]

from rest_framework import serializers

from api import models

class CourseSerializer(serializers.ModelSerializer):

    # 显示choices里面的中文

    level_cn = serializers.CharField(source='get_level_display')

    # 显示课时,对于一对一，使用表名.字段

    hours = serializers.CharField(source='coursedetail.hours')

    # 显示推荐课程,对于多对多,使用def_字段名

    # SerializerMethodField表示序列化字段,使用方法获取

    recommend_courses = serializers.SerializerMethodField()

    # 显示总奖学金,使用表名.字段

    total_scholarship = serializers.CharField(source='degree_course.total_scholarship')

    # 显示价格策略，contenttypes反向查询，使用def_字段名

    price_strategy = serializers.SerializerMethodField()

    class Meta:  # 配置项

        model = models.Course  # Course表

        fields = ['id','name','level_cn','hours','recommend_courses','total_scholarship','price_strategy']  # 指定序列化的字段

    def get_recommend_courses(self,row):

        recommend_list = row.coursedetail.recommend_courses.all()

        return [{'id': item.id, 'name': item.name} for item in recommend_list]

    def get_price_strategy(self,row):

        # .all 表示查询关联的价格策略

        price_list = row.price_policy.all()

        return [{'id': item.id, 'valid_period': item.valid_period,'price': item.price} for item in price_list]

# a.查看所有学位课并打印学位课名称以及授课老师

# b.查看所有学位课并打印学位课名称以及学位课的奖学金

# c.展示所有的专题课

# d. 查看id=1的学位课对应的所有模块名称

# e.获取id = 1的专题课，并打印：课程名、级别(中文)、why_study、what_to_study_brief、所有recommend_courses

# f.获取id = 1的专题课，并打印该课程相关的所有常见问题

# g.获取id = 1的专题课，并打印该课程相关的课程大纲

# h.获取id = 1的专题课，并打印该课程相关的所有章节

from django.conf.urls import url

from api.views import course,degreecourse

urlpatterns = [

    url(r'courses/$',course.CoursesView.as_view()),

    url(r'courses/(?P<pk>\d+)/$',course.CourseDetailView.as_view()),

    url(r'courses/thematic/$',course.CourseThematicView.as_view()),

    url(r'courses/module/(?P<pk>\d+)/$',course.CourseModuleView.as_view()),

    url(r'courses/faq/(?P<pk>\d+)/$',course.CourseFAQView.as_view()),

    url(r'courses/outline/(?P<pk>\d+)/$',course.CourseOutlineView.as_view()),

    url(r'courses/chapter/(?P<pk>\d+)/$',course.CourseChapterView.as_view()),

    url(r'degreecourse/$',degreecourse.DegreeCourseView.as_view()),

    url(r'degreecourse/teachers/$',degreecourse.DegreeCourseTeachersView.as_view()),

    url(r'degreecourse/scholarship/$',degreecourse.DegreeCourseScholarshipView.as_view()),

]

from rest_framework import serializers

from api import models

class CourseModelSerializer(serializers.ModelSerializer):  # 所有课程

    level_name = serializers.CharField(source='get_level_display')

    hours = serializers.CharField(source='coursedetail.hours')

    course_slogan = serializers.CharField(source='coursedetail.course_slogan')

    recommend_courses = serializers.SerializerMethodField()

    class Meta:

        model = models.Course

        fields = ['id','name','level_name','hours','course_slogan','recommend_courses']

    def get_recommend_courses(self,row):

        recommend_list = row.coursedetail.recommend_courses.all()

        return [ {'id':item.id,'name':item.name} for item in recommend_list]

class CourseThematicModelSerializer(serializers.ModelSerializer):  # 所有的专题课

    level_name = serializers.CharField(source='get_level_display')

    course_type = serializers.CharField(source='get_course_type_display')

    status = serializers.CharField(source='get_status_display')

    degree_course = serializers.CharField(source='degree_course.total_scholarship')

    class Meta:

        model = models.Course

        fields = '__all__'

class CourseModuleModelSerializer(serializers.ModelSerializer):  # 所有的专题课

    degree_course = serializers.CharField(source='degree_course.name')

    class Meta:

        model = models.Course

        fields = ['id','degree_course']

class CourseDetailModelSerializer(serializers.ModelSerializer):  # 具体id的学位课对应的所有模块名称

    level_name = serializers.CharField(source='get_level_display')

    why_study = serializers.CharField(source='coursedetail.why_study')

    what_to_study_brief = serializers.CharField(source='coursedetail.what_to_study_brief')

    recommend_courses = serializers.SerializerMethodField()

    price_strategy = serializers.SerializerMethodField()

    class Meta:

        model = models.Course

        fields = ['id','name','level_name','why_study','what_to_study_brief','recommend_courses','price_strategy']

    def get_recommend_courses(self,row):

        recommend_list = row.coursedetail.recommend_courses.all()

        return [ {'id':item.id,'name':item.name} for item in recommend_list]

    def get_price_strategy(self,row):

        price_list = row.price_policy.all()

        return [{'id': item.id, 'valid_period': item.valid_period,'price': item.price} for item in price_list]

class CourseFAQModelSerializer(serializers.ModelSerializer):  # 具体id专题课程相关的所有常见问题

    asked_question = serializers.SerializerMethodField()

    class Meta:

        model = models.Course

        fields = ['id','name', 'asked_question']

    def get_asked_question(self, row):

        faq_list = row.asked_question.all()

        return [{'id': item.id, 'question': item.question, 'answer': item.answer} for item in faq_list]

class CourseOutlineModelSerializer(serializers.ModelSerializer):  # 具体id课程相关的课程大纲

    asked_question = serializers.SerializerMethodField()

    class Meta:

        model = models.Course

        fields = ['id', 'name', 'asked_question']

    def get_asked_question(self, row):

        outline_list = row.coursedetail.courseoutline_set.all()

        return [{'id': item.id, 'title': item.title, 'content': item.content} for item in outline_list]

class CourseChapterModelSerializer(serializers.ModelSerializer):  # 具体id课程相关的所有章节

    chapter = serializers.SerializerMethodField()

    class Meta:

        model = models.Course

        fields = ['id', 'name', 'chapter']

    def get_chapter(self, row):

        chapter_list = row.coursechapter_set.all()

        return [{'id': item.id, 'name': item.name} for item in chapter_list]

from rest_framework import serializers

from api import models

class DegreeCourseModelSerializer(serializers.ModelSerializer):  # 学位课所有信息

    class Meta:

        model = models.DegreeCourse

        fields = '__all__'

class DegreeCourseTeachersModelSerializer(serializers.ModelSerializer):  # 学位课的老师

    teachers = serializers.SerializerMethodField()

    class Meta:

        model = models.DegreeCourse

        fields = ['name','teachers']

    def get_teachers(self,row):

        teachers_list = row.teachers.all()

        return [ {'id':item.id,'name':item.name} for item in teachers_list]

class DegreeCourseScholarshipModelSerializer(serializers.ModelSerializer):  # 学位课的奖学金

    degreecourse_price_policy = serializers.SerializerMethodField()

    class Meta:

        model = models.DegreeCourse

        fields = ['name','degreecourse_price_policy']

    def get_degreecourse_price_policy(self,row):

        scholarships = row.scholarship_set.all()

        return [ {'id':item.id,'time_percent':item.time_percent,'value':item.value} for item in scholarships]

from api.utils.response import BaseResponse

from rest_framework.pagination import PageNumberPagination

class SerializedData(object):  # 序列化通用格式数据

    def __init__(self,request,queryset,serializer_class):

        self.request = request

        self.queryset = queryset

        self.serializer_class = serializer_class

    def get_data(self):

        ret = BaseResponse()

        try:

            # 从数据库获取数据

            queryset = self.queryset.order_by('id')

            # 分页

            page = PageNumberPagination()

            course_list = page.paginate_queryset(queryset, self.request, self)

            # 分页之后的结果执行序列化

            ser = self.serializer_class(instance=course_list, many=True)

            ret.data = ser.data

        except Exception as e:

            print(e)

            ret.code = 500

            ret.error = '获取数据失败'

        return ret.dict

from rest_framework.views import APIView

from rest_framework.response import Response

from rest_framework.versioning import URLPathVersioning

from rest_framework.pagination import PageNumberPagination

from api import models

from api.serializers.course import CourseModelSerializer, CourseThematicModelSerializer, CourseModuleModelSerializer, \

    CourseDetailModelSerializer,CourseFAQModelSerializer,CourseOutlineModelSerializer,CourseChapterModelSerializer

from api.utils.response import BaseResponse

from api.utils.serialization_general import SerializedData

class CoursesView(APIView):  # 所有课程,分页展示,每页1个

    def get(self, request, *args, **kwargs):

        # response = {'code':1000,'data':None,'error':None}

        queryset = models.Course.objects.all()

        serializer_class = CourseModelSerializer

        data = SerializedData(request,queryset,serializer_class).get_data()

        return Response(data)

class CourseDetailView(APIView):  # 课程详情

    def get(self, request, pk, *args, **kwargs):

        queryset = models.Course.objects.filter(id=pk)

        serializer_class = CourseDetailModelSerializer

        data = SerializedData(request, queryset, serializer_class).get_data()

        return Response(data)

class CourseThematicView(APIView):  # 所有的专题课

    def get(self, request, *args, **kwargs):

        queryset = models.Course.objects.all()

        serializer_class = CourseThematicModelSerializer

        data = SerializedData(request, queryset, serializer_class).get_data()

        return Response(data)

class CourseModuleView(APIView):  # 具体id的学位课对应的所有模块名称

    def get(self, request, pk, *args, **kwargs):

        queryset = models.Course.objects.filter(degree_course_id=pk)

        serializer_class = CourseModuleModelSerializer

        data = SerializedData(request, queryset, serializer_class).get_data()

        return Response(data)

class CourseFAQView(APIView):  # 具体id的课程相关的所有常见问题

    def get(self, request, pk, *args, **kwargs):

        queryset = models.Course.objects.filter(id=pk)

        serializer_class = CourseFAQModelSerializer

        data = SerializedData(request, queryset, serializer_class).get_data()

        return Response(data)

class CourseOutlineView(APIView):  # 具体id课程相关的课程大纲

    def get(self, request, pk, *args, **kwargs):

        queryset = models.Course.objects.filter(id=pk)

        serializer_class = CourseOutlineModelSerializer

        data = SerializedData(request, queryset, serializer_class).get_data()

        return Response(data)

class CourseChapterView(APIView):  # 具体id课程相关的所有章节

    def get(self, request, pk, *args, **kwargs):

        queryset = models.Course.objects.filter(id=pk)

        serializer_class = CourseChapterModelSerializer

        data = SerializedData(request, queryset, serializer_class).get_data()

        return Response(data)

from rest_framework.views import APIView

from rest_framework.response import Response

from rest_framework.versioning import URLPathVersioning

from rest_framework.pagination import PageNumberPagination

from api import models

from api.serializers.degreecourse import DegreeCourseModelSerializer,DegreeCourseTeachersModelSerializer

from api.serializers.degreecourse import DegreeCourseScholarshipModelSerializer

from api.utils.response import BaseResponse

class DegreeCourseView(APIView):  # 所有学位课

    def get(self,request,*args,**kwargs):

        # response = {'code':1000,'data':None,'error':None}

        ret = BaseResponse()

        try:

            # 从数据库获取数据

            queryset = models.DegreeCourse.objects.all()

            # 分页

            page = PageNumberPagination()

            course_list = page.paginate_queryset(queryset,request,self)

            # 分页之后的结果执行序列化

            ser = DegreeCourseModelSerializer(instance=course_list,many=True)

            ret.data = ser.data

        except Exception as e:

            ret.code = 500

            ret.error = '获取数据失败'

        return Response(ret.dict)

class DegreeCourseTeachersView(APIView):  # 学位课对应的老师

    def get(self, request, *args, **kwargs):

        ret = BaseResponse()

        try:

            # 从数据库获取数据

            # 防止出现UnorderedObjectListWarning: Pagination may yield...

            queryset = models.DegreeCourse.objects.get_queryset().order_by('id')

            print(queryset)

            # 分页

            page = PageNumberPagination()

            course_list = page.paginate_queryset(queryset, request, self)

            # 分页之后的结果执行序列化

            ser = DegreeCourseTeachersModelSerializer(instance=course_list, many=True)

            print(ser.data)

            ret.data = ser.data

        except Exception as e:

            print(e)

            ret.code = 500

            ret.error = '获取数据失败'

        return Response(ret.dict)

class DegreeCourseScholarshipView(APIView):  # 学位课对应的老师

    def get(self, request, *args, **kwargs):

        ret = BaseResponse()

        try:

            # 从数据库获取数据

            # 防止出现UnorderedObjectListWarning: Pagination may yield...

            queryset = models.DegreeCourse.objects.get_queryset().order_by('id')

            print(queryset)

            # 分页

            page = PageNumberPagination()

            course_list = page.paginate_queryset(queryset, request, self)

            # 分页之后的结果执行序列化

            ser = DegreeCourseScholarshipModelSerializer(instance=course_list, many=True)

            print(ser.data)

            ret.data = ser.data

        except Exception as e:

            print(e)

            ret.code = 500

            ret.error = '获取数据失败'

        return Response(ret.dict)

<template>

  <div id="app">

    <router-view/>

  </div>

</template>

<script>

export default {

  name: 'App'

}

</script>

<style>

</style>

<template>

  <div class="hello">

    <h1>{{ msg }}</h1>

  </div>

</template>

<script>

export default {

  name: 'HelloWorld',

  data () {

    return {

      msg: '欢迎使用路飞学城'

    }

  }

}

</script>

<!-- Add "scoped" attribute to limit CSS to this component only -->

<style scoped>

h1, h2 {

  font-weight: normal;

}

ul {

  list-style-type: none;

  padding: 0;

}

li {

  display: inline-block;

  margin: 0 10px;

}

a {

  color: #42b983;

}

</style>

// The Vue build version to load with the `import` command

// (runtime-only or standalone) has been set in webpack.base.conf with an alias.

import Vue from 'vue'

import App from './App'

import router from './router'

import axios from 'axios'  //导入axios

Vue.prototype.$axios = axios  //声明全局变量

Vue.config.productionTip = false

/* eslint-disable no-new */

new Vue({

  el: '#app',

  router,

  components: { App },

  template: '<App/>'

})

<template>

  <div class="hello">

    <h1>{{ msg }}</h1>

  </div>

</template>

<script>

export default {

  name: 'HelloWorld',

  data () {

    return {

      msg: '欢迎使用路飞学城'

    }

  },

  mounted(){  //页面加载完成后

    this.initCourse();  //执行此方法

  },

  methods:{

    initCourse:function () {

      //向后台发送ajax请求

      this.$axios.request({

        url:'http://127.0.0.1:8000/api/v1/courses/',

        method:'GET',

        responseType:'json',

      }).then(function (arg) {

        //成功之后

        console.log(arg);

      }).catch(function (err) {

        //发生错误

        console.log(err);

      })

    }

  },

}

</script>

<!-- Add "scoped" attribute to limit CSS to this component only -->

<style scoped>

h1, h2 {

  font-weight: normal;

}

ul {

  list-style-type: none;

  padding: 0;

}

li {

  display: inline-block;

  margin: 0 10px;

}

a {

  color: #42b983;

}

</style>