DRF之解析器元件及序列化元件

引入

Django RestFramework幫助我們實現了處理application/json協議請求的資料，另外，我們也提到，如果不使用DRF，直接從request.body裡面拿到原始的客戶端請求的位元組資料，經過decode，然後json反序列化之後，也可以得到一個Python字典型別的資料。

但是，這種方式並不被推薦，因為已經有了非常優秀的第三方工具，那就是Django RestFramework的解析器元件，這是我們今天要學習的第一個非常重要的知識點，咱們今天要學習的另一個也是至關重要的知識點叫做序列化元件。

序列化在上一節課中也已經提到了，幫助我們快速的進行符合規範的介面開發，也就是增刪改查介面，包含錯誤資訊定義，成功之後的返回資訊定義等等。

接下來，咱們就開始學習DRF的這兩個重要元件。

今日概要

解析器元件的使用及原始碼剖析
序列化元件的使用及RESTful介面設計

知識點複習回顧

昨日回顧
三元運算
列表推導式
getattr
Django settings檔案查詢順序
動態import
Django原生serializer

知識點複習回顧一：三元運算

三元運算能夠簡化我們的程式碼，請看如下程式碼：

# 定義兩個變數
a = 1
b = 2
# 判斷a的真假值，如果為True，則將判斷表示式的前面的值賦給c，否則將判斷表示式後面的值賦給c
c = a if a else b

print(c) # 1 # 因為a的真假值判斷為True，所以c為1
# 定義兩個變數
a = 0
b = 2
# 判斷a的真假值，如果為True，則將判斷表示式的前面的值賦給c，否則將判斷表示式後面的值賦給c
c = a if a else b

print(c) # 2 # 因為a的真假值判斷為False，所以c為2

知識點複習回顧二：列表推導式

列表推導式的返回結果仍然是一個列表，假設有列表li = [1, 2, 3, 4], 請同學們思考，如果將li列表裡面的每一個元素乘以2得到一個新的列表，請看下面的程式碼：

li = [1, 2, 3, 4]
# 方式一：使用普通for迴圈
new_list = list()
for item in li:
 new_list.append(item * 2)

# 方式二：使用列表推導式
li = [ x * 2 for x in li]

可見，列表推導式能夠大大簡化程式碼，再看下面的程式碼：

class JsonParser(object):
 pass


class FormParser(object):
 pass


class Parser(object):
 parser_classes = [JsonParser, FormParser]

 def _get_parse(self):
 parser_list = [parser() for parser in self.parser_classes]
 return parser_list


parser = Parser()
parser_list = parser._get_parse()
print(parser_list) # [<__main__.JsonParser object at 0x103f07048>, <__main__.FormParser object at 0x103f072e8>]

可以看到，parser_list是parser_classes中每個類的例項化物件列表。以上就是關於列表推導式的回顧。

知識點複習回顧三：getattr

在學習面向物件時，我們知道可以通過物件加點號獲取該物件的屬性，也可以通過物件的dict訪問屬性，請看下面的程式碼：

class Father(object):
 country = "china"


class Person(Father):
 def __init__(self, name, age):
 self.name = name
 self.age = age


p = Person("pizza", 18)
print(p.__dict__) # {'name': 'pizza', 'age': 18}
print(Person.__dict__) # {'__module__': '__main__', '__init__': <function Person.__init__ at 0x103f132f0>, '__doc__': None}
print(p.name) # pizza
print(p.age) # 18
print(p.country) # china 如果物件不存在這個屬性，則會到其父類中查詢這個屬性
print(p.hobby) # 如果在父類中也找不到這個屬性，則會報錯：AttributeError: 'Person' object has no attribute 'hobby'

物件的屬性查詢首先會在該物件的一個名為dict的字典中查詢這個屬性，如果找不到，則會到其父類中查詢這個屬性，如果在父類中都也找不到對應的屬性，這會丟擲異常AttributeError，我們可以通過在類中定義一個getattr來重定向未查詢到屬性後的行為，請看下面的程式碼：

class Father(object):
 country = "china"


class Person(Father):
 def __init__(self, name, age):
 self.name = name
 self.age = age

 def __getattr__(self, value):
 raise ValueError("屬性%s不存在" % value)


p = Person("pizza", 18)
print(p.hobby) # ValueError: 屬性hobby不存在

可以看到，我們能夠重新定義異常，也可以做其他任何事情，這就是getattr，一句話總結，通過物件查詢屬性，如果找不到屬性，且該物件有getattr方法，那麼getattr方法會被執行，至於執行什麼邏輯，我們可以自定義。

知識點複習回顧四：Django settings檔案查詢順序

同學們在使用Django的時候，應該是經常會用到它的settings檔案，通過在settings檔案裡面定義變數，我們可以在程式的任何地方使用這個變數，方便好用，比如，假設我在settings裡面定義了一個變數NAME=”Pizza”, 雖然可以在專案的任何地方使用：

1 2	>>> from drf_server import settings >>> print(settings.NAME) # Pizza

但是，這種方式並不是被推薦和建議的，因為除了專案本身的settings檔案之外，Django程式本身也有許多配置變數，都儲存在django/conf/global_setting.py模組裡面，包括快取、資料庫、祕鑰等，如果我們只是from drf_server import settings匯入了專案本身的配置資訊，當需要用到Django預設的配置資訊的時候，還需要再次匯入，from django.conf import settings，所以建議的使用方式是：

1 2	>>> from django.conf import settings >>> print(settings.NAME)

使用上面的方式，我們除了可以使用自定義的配置資訊(NAME)外，還可以使用global_settings中的配置資訊，不需要重複匯入，Django查詢變數的順序是先從使用者的settings裡面查詢，然後在global_settings中查詢，如果使用者的settings中找到了，則不會繼續查詢global_settings中的配置資訊，假設我在使用者的settings裡面定義了NAME=”Pizza”, 在global_settings中定義了NAME=”Alex”，請看下面的列印結果：

1 2	>>> from django.conf import settings >>> print(settings.NAME) # Pizza

可見，這種方式更加靈活高效，建議大家使用。

知識點複習回顧五：Django原生serializer

上一節課講到，我們可以自定義符合REST規範的介面，請看下面的程式碼：

from django.db import models

# Create your models here.


class Courses(models.Model):
 title = models.CharField(max_length=32)
 description = models.CharField(max_length=128)

class CoursesView(View):
 def get(self, request):
 courses = list()

 for item in Courses.objects.all():
 course = {
 "title": item.title,
 "description": item.description
 }

 courses.append(course)

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

通過上面的方式，我們定義出了符合規範的返回資料，加上符合規範的url，我們可以說，手動方式進行REST開發也是完全沒有問題的，但是，企業最注重的是開發效率，而不是程式設計師實現需求的方式，理論上來說，我們可以通過任何方式，但是我們應該儘可能的採用高效的、靈活的、強大的工具來幫助我們完成重複的事情，所以我們需要學習DRF，它提供了很多的功能，在講DRF的序列化之前，我們來了解另一個知識，那就是，Django框架原生的序列化功能，即Django原生serializer，它的使用方式如下：

from django.core.serializers import serialize

class StudentView(APIView):

 def get(self, request):
 
 origin_students = Student.objects.all()
 serialized_students = serialize("json", origin_students)

 return HttpResponse(serialized_students)

使用方式非常簡單，匯入模組之後，將需要的格式和queryset傳給serialize進行序列化，然後返回序列化後的資料。

如果你的專案僅僅只是需要序列化一部分資料，不需要用到諸如認證、許可權等等其他功能，可以使用Django原生serializer，否則建議使用DRF。

今日詳細

好了，接下來，鋪墊都做好了，剖析原始碼所需要的準備工作都已經做好了，接下來，我們就進入今天的新內容的學習，也就是解析器元件和序列化元件的使用及其原始碼剖析。

解析器元件

解析器元件的使用

首先，來看看解析器元件的使用，稍後我們一起剖析其原始碼：

from django.http import JsonResponse

from rest_framework.views import APIView
from rest_framework.parsers import JSONParser, FormParser
# Create your views here.


class LoginView(APIView):
 parser_classes = [FormParser]

 def get(self, request):
 return render(request, 'parserver/login.html')

 def post(self, request):
 # request是被drf封裝的新物件，基於django的request
 # request.data是一個property，用於對資料進行校驗
 # request.data最後會找到self.parser_classes中的解析器
 # 來實現對資料進行解析
 
 print(request.data) # {'username': 'alex', 'password': 123}

 return JsonResponse({"status_code": 200, "code": "OK"})

使用方式非常簡單，分為如下兩步：

from rest_framework.views import APIView
繼承APIView
直接使用request.data就可以獲取Json資料

如果你只需要解析Json資料，不允許任何其他型別的資料請求，可以這樣做：

from rest_framework.parsers import JsonParser
給檢視類定義一個parser_classes變數，值為列表型別[JsonParser]
如果parser_classes = [], 那就不處理任何資料型別的請求了

問題來了，這麼神奇的功能，DRF是如何做的？因為昨天講到Django原生無法處理application/json協議的請求，所以拿json解析來舉例，請同學們思考一個問題，如果是你，你會在什麼地方加入新的Json解析功能？

首先，需要明確一點，我們肯定需要在request物件上做文章，為什麼呢？因為只有有了使用者請求，我們的解析才有意義，沒有請求，就沒有解析，更沒有處理請求的邏輯，所以，我們需要弄明白，在整個流程中，request物件是什麼時候才出現的，是在繫結url和處理檢視之間的對映關係的時候嗎？我們來看看原始碼：

@classonlymethod
def as_view(cls, **initkwargs):
 """Main entry point for a request-response process."""
 for key in initkwargs:
 if key in cls.http_method_names:
 raise TypeError("You tried to pass in the %s method name as a "
 "keyword argument to %s(). Don't do that."
 % (key, cls.__name__))
 if not hasattr(cls, key):
 raise TypeError("%s() received an invalid keyword %r. as_view "
 "only accepts arguments that are already "
 "attributes of the class." % (cls.__name__, key))

def view(request, *args, **kwargs):
 self = cls(**initkwargs)
 if hasattr(self, 'get') and not hasattr(self, 'head'):
 self.head = self.get
 self.request = request
 self.args = args
 self.kwargs = kwargs
 return self.dispatch(request, *args, **kwargs)
 view.view_class = cls
 view.view_initkwargs = initkwargs

 # take name and docstring from class
 update_wrapper(view, cls, updated=())

 # and possible attributes set by decorators
 # like csrf_exempt from dispatch
 update_wrapper(view, cls.dispatch, assigned=())
 return view

看到了嗎？在執行view函式的時候，那麼什麼時候執行view函式呢？當然是請求到來，根據url查詢對映表，找到檢視函式，然後執行view函式並傳入request物件，所以，如果是我，我可以在這個檢視函式裡面加入處理application/json的功能：

@classonlymethod
def as_view(cls, **initkwargs):
 """Main entry point for a request-response process."""
 for key in initkwargs:
 if key in cls.http_method_names:
 raise TypeError("You tried to pass in the %s method name as a "
 "keyword argument to %s(). Don't do that."
 % (key, cls.__name__))
 if not hasattr(cls, key):
 raise TypeError("%s() received an invalid keyword %r. as_view "
 "only accepts arguments that are already "
 "attributes of the class." % (cls.__name__, key))

def view(request, *args, **kwargs):
 if request.content_type == "application/json":
 import json
 return HttpResponse(json.dumps({"error": "Unsupport content type!"}))

 self = cls(**initkwargs)
 if hasattr(self, 'get') and not hasattr(self, 'head'):
 self.head = self.get
 self.request = request
 self.args = args
 self.kwargs = kwargs
 return self.dispatch(request, *args, **kwargs)
 view.view_class = cls
 view.view_initkwargs = initkwargs

 # take name and docstring from class
 update_wrapper(view, cls, updated=())

 # and possible attributes set by decorators
 # like csrf_exempt from dispatch
 update_wrapper(view, cls.dispatch, assigned=())
 return view

看到了吧，然後我們試試傳送json請求，看看返回結果如何？是不是非常神奇？事實上，你可以在這裡，也可以在這之後的任何地方進行功能的新增。

那麼，DRF是如何做的呢？我們在使用的時候只是繼承了APIView，然後直接使用request.data，所以，我斗膽猜測，功能肯定是在APIView中定義的，廢話，具體在哪個地方呢？接下來，我們一起來分析一下DRF解析器原始碼，看看DRF在什麼地方加入了這個功能，上節課，我們通過面向物件的方式，給類的某個方法新增了功能，呼叫重寫的方法，就實現了功能擴充套件，但是上面除了request.data，我們沒有呼叫任何新的方法，所以，問題就在這個request.data上，它絕不僅僅是一個普通的物件屬性。

好了，有了這個共同的認識，我們接下來驗證一下我們的看法。

解析器元件原始碼剖析

請看下圖：

上圖詳細描述了整個過程，最重要的就是重新定義的request物件，和parser_classes變數，也就是我們在上面使用的類變數。好了，通過分析原始碼，驗證了我們的猜測。

序列化元件

序列化元件的使用

定義幾個 model:

from django.db import models

# Create your models here.


class Publish(models.Model):
 nid = models.AutoField(primary_key=True)
 name = models.CharField(max_length=32)
 city = models.CharField(max_length=32)
 email = models.EmailField()

 def __str__(self):
 return self.name


class Author(models.Model):
 nid = models.AutoField(primary_key=True)
 name = models.CharField(max_length=32)
 age = models.IntegerField()

 def __str__(self):
 return self.name


class Book(models.Model):
 title = models.CharField(max_length=32)
 publishDate = models.DateField()
 price = models.DecimalField(max_digits=5, decimal_places=2)
 publish = models.ForeignKey(to="Publish", to_field="nid", on_delete=models.CASCADE)
 authors = models.ManyToManyField(to="Author")

 def __str__(self):
 return self.title

通過序列化元件進行GET介面設計

首先，設計url，本次我們只設計GET和POST兩種介面：

from django.urls import re_path

from serializers import views

urlpatterns = [
 re_path(r'books/$', views.BookView.as_view())
]

我們新建一個名為app_serializers.py的模組，將所有的序列化的使用集中在這個模組裡面，對程式進行解耦：

# -*- coding: utf-8 -*-
from rest_framework import serializers

from .models import Book


class BookSerializer(serializers.Serializer):
 title = serializers.CharField(max_length=128)
 publish_date = serializers.DateTimeField()
 price = serializers.DecimalField(max_digits=5, decimal_places=2)
 publish = serializers.CharField(max_length=32)
 authors = serializers.CharField(max_length=32)

接著，使用序列化元件，開始寫檢視類：

# -*- coding: utf-8 -*-
from rest_framework.views import APIView
from rest_framework.response import Response

# 當前app中的模組
from .models import Book
from .app_serializer import BookSerializer

# Create your views here.

class BookView(APIView):
 def get(self, request):
 origin_books = Book.objects.all()
 serialized_books = BookSerializer(origin_books, many=True)

 return Response(serialized_books.data)

如此簡單，我們就已經，通過序列化元件定義了一個符合標準的介面，定義好model和url後，使用序列化元件的步驟如下：

匯入序列化元件：from rest_framework import serializers
定義序列化類，繼承serializers.Serializer(建議單獨建立一個專用的模組用來存放所有的序列化類)：class BookSerializer(serializers.Serializer):pass
定義需要返回的欄位(欄位型別可以與model中的型別不一致，引數也可以調整)，欄位名稱必須與model中的一致
在GET介面邏輯中，獲取QuerySet
開始序列化：將QuerySet作業第一個引數傳給序列化類，many預設為False，如果返回的資料是一個列表巢狀字典的多個物件集合，需要改為many=True
返回：將序列化物件的data屬性返回即可

上面的介面邏輯中，我們使用了Response物件，它是DRF重新封裝的響應物件。該物件在返回響應資料時會判斷客戶端型別（瀏覽器或POSTMAN），如果是瀏覽器，它會以web頁面的形式返回，如果是POSTMAN這類工具，就直接返回Json型別的資料。

此外，序列化類中的欄位名也可以與model中的不一致，但是需要使用source引數來告訴元件原始的欄位名，如下：

class BookSerializer(serializers.Serializer):
 BookTitle = serializers.CharField(max_length=128, source="title")
 publishDate = serializers.DateTimeField()
 price = serializers.DecimalField(max_digits=5, decimal_places=2)
 # source也可以用於ForeignKey欄位
 publish = serializers.CharField(max_length=32, source="publish.name")
 authors = serializers.CharField(max_length=32)

下面是通過POSTMAN請求該介面後的返回資料，大家可以看到，除ManyToManyField欄位不是我們想要的外，其他的都沒有任何問題：

[
    {
        "title": "Python入門",
 "publishDate": null,
 "price": "119.00",
 "publish": "浙江大學出版社",
 "authors": "serializers.Author.None"
 },
 {
 "title": "Python進階",
 "publishDate": null,
 "price": "128.00",
 "publish": "清華大學出版社",
 "authors": "serializers.Author.None"
 }
]

那麼，多對多欄位如何處理呢？如果將source引數定義為”authors.all”，那麼取出來的結果將是一個QuerySet，對於前端來說，這樣的資料並不是特別友好，我們可以使用如下方式：

class BookSerializer(serializers.Serializer):
 title = serializers.CharField(max_length=32)
 price = serializers.DecimalField(max_digits=5, decimal_places=2)
 publishDate = serializers.DateField()
 publish = serializers.CharField()
 publish_name = serializers.CharField(max_length=32, read_only=True, source='publish.name')
 publish_email = serializers.CharField(max_length=32, read_only=True, source='publish.email')
 # authors = serializers.CharField(max_length=32, source='authors.all')
 authors_list = serializers.SerializerMethodField()

 def get_authors_list(self, authors_obj):
 authors = list()
 for author in authors_obj.authors.all():
 authors.append(author.name)

 return authors

請注意，get_必須與欄位名稱一致，否則會報錯。

通過序列化元件進行POST介面設計

接下來，我們設計POST介面，根據介面規範，我們不需要新增url，只需要在檢視類中定義一個POST方法即可，序列化類不需要修改，如下：

# -*- coding: utf-8 -*-
from rest_framework.views import APIView
from rest_framework.response import Response

# 當前app中的模組
from .models import Book
from .app_serializer import BookSerializer

# Create your views here.


class BookView(APIView):
 def get(self, request):
 origin_books = Book.objects.all()
 serialized_books = BookSerializer(origin_books, many=True)

 return Response(serialized_books.data)

 def post(self, request):
 verified_data = BookSerializer(data=request.data)

 if verified_data.is_valid():
 book = verified_data.save()
 # 可寫欄位通過序列化新增成功之後需要手動新增只讀欄位
 authors = Author.objects.filter(nid__in=request.data['authors'])
 book.authors.add(*authors)

 return Response(verified_data.data)
 else:
 return Response(verified_data.errors)

POST介面的實現方式，如下：

url定義：需要為post新增url，因為根據規範，url定位資源，http請求方式定義使用者行為
定義post方法：在檢視類中定義post方法
開始序列化：通過我們上面定義的序列化類，建立一個序列化物件，傳入引數data=request.data（application/json）資料
校驗資料：通過例項物件的is_valid()方法，對請求資料的合法性進行校驗
儲存資料：呼叫save()方法，將資料插入資料庫
插入資料到多對多關係表：如果有多對多欄位，手動插入資料到多對多關係表
返回：將插入的物件返回

請注意，因為多對多關係欄位是我們自定義的，而且必須這樣定義，返回的資料才有意義，而使用者插入資料的時候，serializers.Serializer沒有實現create，我們必須手動插入資料，就像這樣：

# 第二步， 建立一個序列化類，欄位型別不一定要跟models的欄位一致
class BookSerializer(serializers.Serializer):
 # nid = serializers.CharField(max_length=32)
 title = serializers.CharField(max_length=128)
 price = serializers.DecimalField(max_digits=5, decimal_places=2)
 publish = serializers.CharField()
 # 外來鍵欄位, 顯示__str__方法的返回值
 publish_name = serializers.CharField(max_length=32, read_only=True, source='publish.name')
 publish_city = serializers.CharField(max_length=32, read_only=True, source='publish.city')
 # authors = serializers.CharField(max_length=32) # book_obj.authors.all()

 # 多對多欄位需要自己手動獲取資料，SerializerMethodField()
 authors_list = serializers.SerializerMethodField()

 def get_authors_list(self, book_obj):
 author_list = list()

 for author in book_obj.authors.all():
 author_list.append(author.name)

 return author_list

 def create(self, validated_data):
 # {'title': 'Python666', 'price': Decimal('66.00'), 'publish': '2'}
 validated_data['publish_id'] = validated_data.pop('publish')
 book = Book.objects.create(**validated_data)

 return book

 def update(self, instance, validated_data):
 # 更新資料會呼叫該方法
 instance.title = validated_data.get('title', instance.title)
 instance.publishDate = validated_data.get('publishDate', instance.publishDate)
 instance.price = validated_data.get('price', instance.price)
 instance.publish_id = validated_data.get('publish', instance.publish.nid)

 instance.save()

 return instance

這樣就會非常複雜化程式，如果我希望序列化類自動插入資料呢？

這是問題一：如何讓序列化類自動插入資料？

另外問題二：如果欄位很多，那麼顯然，寫序列化類也會變成一種負擔，有沒有更加簡單的方式呢？

答案是肯定的，我們可以這樣做：

class BookSerializer(serializers.ModelSerializer):
 class Meta:
 model = Book

 fields = ('title',
 'price',
 'publish',
 'authors',
 'author_list',
 'publish_name',
 'publish_city'
 )
 extra_kwargs = {
 'publish': {'write_only': True},
 'authors': {'write_only': True}
 }

 publish_name = serializers.CharField(max_length=32, read_only=True, source='publish.name')
 publish_city = serializers.CharField(max_length=
              
           
              
              
            
            相關推薦
			   
            
            
            
 

    

    
    DRF之解析器元件及序列化元件
      引入 
Django RestFramework幫助我們實現了處理application/json協議請求的資料，另外，我們也提到，如果不使用DRF，直接從request.body裡面拿到原始的客戶端請求的位元組資料，經過decode，然後json反序列化之後，也可以得到一個Python字典型別的資料。 
但 

  
 

    

    
    DRF之解析器組件及序列化組件
      除了   queryset   服務器   字段   color   stat   需求   使用方式   更新   　　通過上一篇博客的學習，我們已經有了一個共識，Django無法處理application/json協議請求的數據，即，如果用戶通過application/json協議發送請求數據到達Djan 

  
 

    

    
    Serializers 序列化元件 Serializers 序列化元件
      Serializers 序列化元件 

  
 
 
  
  為什麼要用序列化元件 
  當我們做前後端分離的專案~~我們前後端互動一般都選擇JSON資料格式，JSON是一個輕量級的資料互動格式。 
  那麼我們給前端資料的時候都要轉成json格式，那就需要對我們從資料庫拿到的資料進行序列化。 
 

  
 

    

    
    drf-序列化元件 rest-framework之序列化元件
       
 rest-framework之序列化元件 
  
   
    
     
     一 Django自帶序列化元件 
     二 rest-framework序列化之Serializer 
     三 rest-framework序列化之ModelSerializer 
     四 生成hy 

  
 

    

    
    drf序列化元件之檢視家族
      一、檢視家族的分類
1.匯入分類
from rest_framewok import views, generics, mixins, viewsets
views：檢視類
 兩大檢視類：APIView、GenericAPIView
from rest_framework.views import APIV 

  
 

    

    
    DRF框架之Serializer序列化器的反序列化操作
      昨天，我們完成了Serializer序列化器的反序列化操作，那麼今天我們就來學習Serializer序列化器的最後一點知識，反序列化操作。
首先，我們定要明確什麼是反序列化操作？
反序列化操作：JOSN資料 --> 字典資料 -->驗證通過的字典資料 --> 模型資料
我們在進行反序列化操作 

  
 

    

    
    Django-Rest-Framework的序列化之serializers 序列化元件
       
 Django-Rest-Framework的序列化之serializers 序列化元件 
 
  
  
正常的序列化 
from django.http import HttpResponse, JsonResponse
from django.views import View 

  
 

    

    
    DRF-->1 序列化元件的使用和介面設計---get
      定義序列化器（本質就是一個類），一般包括模型類的欄位，有自己的欄位型別規則。實現了序列化器後，就可以建立序列化物件以及查詢集進行序列化操作，通過序列化物件.data來獲取資料（不用自己構造字典，再返回Json資料） 
廢話不多說，直接上程式碼！！！ 
DRF序列化可以理解這幾句 
 
             

  
 

    

    
    DAY97 - Rest Framework(二）- 序列化元件之Serializer和ModelSerializer
      一、序列化元件之Serializer 
from django.http import JsonResponse
from rest_framework.views import APIView
from rest_framework.request import Request
from rest_fram 

  
 

    

    
    DRF解析組件以及序列化組件
      插入數據   繼承   foreign   部分   price   t對象   就會   註意   技術分享   一.知識點回顧:
1.三元運算:
三元運算能夠簡化我們的代碼,請看如下代碼:

# 定義兩個變量
a = 1
b = 2
# 判斷a的真假值，如果為True，則將判斷表達式的前面的 

  
 

    

    
    rest_framwork之序列化元件
      1 序列化元件（1）原生序列化    1)匯入      from django.core.serializers import serializer    2)使用    &nb 

  
 

    

    
    DAY98 - Rest Framework(三）- 序列化元件之HyperlinkedIdentityField和初識認證元件
      一、序列化元件之HyperlinkedIdentityField 
HyperlinkedIdentityField可以通過反向解析向前臺返回一個連結 
url(r'^Books/(?P<id>\d+)', views.BooksDetail.as_view(),name='test'), 
#  

  
 

    

    
    【DRF框架】序列化元件——欄位驗證
      單個欄位的驗證 
1.在序列化器裡定義校驗欄位的鉤子方法   validate_欄位 
2.獲取欄位的資料 
3.驗證不通過，丟擲異常  raise serializers.ValidationError("校驗不通過的說明") 
4.驗證通過，直接返回欄位資料 
 
 

  
 

    

    
    【DRF框架】利用序列化元件操作
      使用序列化元件進行操作 
不帶引數：查+增 
帶引數：查、改、刪 
  
不帶引數的操作 
 
 # url路由
url(r'^book_list/$',Search_book.as_view()), 
 
 
 # views.py
from utils.serializers import Bo 

  
 

    

    
    DRF Django REST framework  之  解析器（二）
      引入
Django Rest framework幫助我們實現了處理application/json協議請求的資料，如果不使用DRF，直接從 request.body 裡面拿到原始的客戶端請求的位元組資料，經過 decode ，然後 json 反序列化 

  
 

    

    
    19.DjangoRestFramework學習二之序列化元件、檢視元件
      一 序列化元件
　　首先按照restful規範咱們建立一些api介面，按照下面這些形式寫吧：
　　　　Courses --- GET ---> 檢視資料----->返回所有資料列表[{},{},]
　　　　Courses--- POST --->新增資料 -----> 返回新增的資料{ 

  
 

    

    
    python學習day4之路文件的序列化和反序列化
      data   多次   文件交互   由於   mps   logs   json   tro   之路   json和pickle序列化和反序列化
　　json是用來實現不同程序之間的文件交互，由於不同程序之間需要進行文件信息交互，由於用python寫的代碼可能要與其他語言寫的代碼進行數據傳輸，json支持 

  
 

    

    
    Android開發之漫漫長途 X——Android序列化
      view   編寫   person   android中   做了   知識   序列化對象   數據庫   讀者   該文章是一個系列文章，是本人在Android開發的漫漫長途上的一點感想和記錄，我會盡量按照先易後難的順序進行編寫該系列。該系列引用了《Android開發藝術探索》以及《深入理解Androi 

  
 

    

    
    Flink1.4.0中反序列化及序列化類變化
      繼承   tde   post   變化   flink   ted   標記   api   col      Flink1.4.0中，反序列化及序列化時繼承的類，有一些被標記為了“@deprecated”，路徑上也有變化：
1.AbstractDeserializationSchema
以前路徑

org 

  
 

    

    
    rest_framework之解析器、路由控制、分頁
      控制   img   其他   http   只需要   api   參數   字符   route   解析器
我們都知道，網絡傳輸數據只能傳輸字符串格式的，如果是列表、字典等數據類型，需要轉換之後才能使用
但是我們之前的rest_framework例子都沒有轉換就直接可以使用了，這是因為rest_fr 

  

            

          
        
      
    
    
  
    搜尋
    
        
      
      
    
  
 
  
  
    基礎教學
     
    Mysql入門  
     Sql入門 
      Android入門 
       Docker入門 
        Go語言入門 
         Ruby程式入門 
          Python入門 
           Python進階 
            Django入門 
             Python爬蟲入門 
             
      
      
  
   
  
    最近訪問
    
  	      
  
      
    
  

 

 


  
    
      
        
          首頁
前端設計
程式設計
免費資源
實用技巧
資料庫
資訊
字典
        
          Copyright © 2002-2020  程式人生 796T.COM All rights reserved.