【三】DRF序列化进阶

最新推荐文章于 2024-09-17 23:15:58 发布
最新推荐文章于 2024-09-17 23:15:58 发布
阅读量914 收藏 7
点赞数 24
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58310590/article/details/138589159
版权

序列化器的定义与使用

多表关联序列化

【1】准备工作

# settings.py
DATABASES = {
    'default': {
        # 数据库引擎选择使用MySQL
        'ENGINE': 'django.db.backends.mysql',
        # 指定数据库名字，需提前创建
        'NAME': 'books',
        # 指定数据库用户名
        'USER': 'root',
        # 指定数据库用户密码
        'PASSWORD': '123123',
        # 指定数据库连接IP
        'HOST': '127.0.0.1',
        # 指定数据库端口
        'PORT': 3306,
        # 指定数据库默认编码集(可选)
        'CHARSET': 'utf8mb4',

    }
}

【2】定制返回格式之source

# models.py
from django.db import models

class Book(models.Model):
    name = models.CharField(max_length=64)
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8, decimal_places=2)
    publish_date = models.DateField()

    publish = models.ForeignKey(to='Publish', on_delete=models.SET_NULL, null=True)
    authors = models.ManyToManyField(to='Author')

    def __str__(self):
        return self.title


class Publish(models.Model):
    name = models.CharField(max_length=32,)
    addr = models.CharField(max_length=64)
    # 该字段不是给models看的，而是给校验行组件使用的
    email = models.EmailField()

    def __str__(self):
        return self.name


class Author(models.Model):
    name = models.CharField(max_length=32,null=True)
    age = models.IntegerField()

    def __str__(self):
        return self.name
  • 创建一个序列化serial.py文件
from rest_framework import serializers
from rest_framework.exceptions import ValidationError

def data_name(name):
    if name.startswith('shi'):
        raise ValidationError('不能用shi开头')
    else:
        return name

class TaskSerializer(serializers.Serializer):
    # required=False表明该字段在反序列化时必须输入，默认True
    # allow_null	表明该字段是否允许传入None，默认False
    # default	    反序列化时使用的默认值
    task_name = serializers.CharField(required=False,allow_null=True,default='默认字段',validators=[data_name])
    task_id = serializers.CharField(max_length=64,validators=[data_name])
    task_time = serializers.DateTimeField()


class BookSerializer(serializers.Serializer):
    #  source 定制返回字段名，跟name必须对应
    book_name = serializers.CharField(source='name')
    # 显示出版社名字-->字符串类型--》CharField  可以跨表查询
    book_publish = serializers.CharField(source='publish.name')
    # 所有字段都可以被转成CharField
    publish_id = serializers.IntegerField(source='publish.id')

    title = serializers.CharField()
    price = serializers.IntegerField()
    publish = serializers.CharField()
  • book_name: 这是书籍的名称字段，source='name' 表示它会从模型中的 name 字段获取数据。
  • book_publish: 这是书籍的出版社名称字段，source='publish.name' 表示它会从关联的出版社模型中的 name 字段获取数据。
  • publish_id: 这是书籍的出版社ID字段，source='publish.id' 表示它会从关联的出版社模型中的 id 字段获取数据。
  • title: 这是书籍的标题字段，直接从模型中的 title 字段获取数据。
  • price: 这是书籍的价格字段，直接从模型中的 price 字段获取数据。
  • publish: 这是书籍的出版社字段。然而，在代码中没有指定 source，这意味着它将尝试从模型中的 publish 字段获取数据。但是，publish 字段是一个 ForeignKey 字段，它应该是一个模型实例，而不是字符串，因此这里会出现问题。
# views.py
from rest_framework.views import APIView
from Api02.models import Book,Task2
from Api02.serial import BookSerializer
from rest_framework.response import Response

class BookView(APIView):
    # 查询所有图书
    def get(self,request):
        print(request.data)
        # {'name': '去死', 'price': '222', 'publish': '人民日报'}
        res_list = Book.objects.all()
        print(res_list)
        # <QuerySet [<Book: 剑气长城>, <Book: 低头不见脚趾>, <Book: 恐怖如斯>, <Book: 大师>]>
        serializer = BookSerializer(instance=res_list,many=True)
        return Response(serializer.data)

image-20240413203820031

【3】定制返回字段模型类中书写方法

  • {name:书名,price:价格,publish:{name:出版社名,addr:地址},authors:[{},{}]}

返回详细信息

  • 先在models.py要实现表中添加
  • def publish_detail(self)这个函数跟我定义的serial.py中的字段要一致publish_detail。
class Book(models.Model):
    name = models.CharField(max_length=64)
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8, decimal_places=2)
    publish_date = models.DateField()

    publish = models.ForeignKey(to='Publish', on_delete=models.SET_NULL, null=True)
    authors = models.ManyToManyField(to='Author')

    def __str__(self):
        return self.name

    # 出版社对象
    @property
    def publish_detail(self):
        return {'name':self.publish.name,'addr':self.publish.addr}


    def authors_detail(self):
        list = []
        for author in self.authors.all():
            list.append({"name":author.name,'age':author.age})
        return list


# serial.py
class BookSerializer(serializers.Serializer):

    name = serializers.CharField()

    title = serializers.CharField()
    price = serializers.IntegerField()
    publish_date = serializers.DateField()

    # publish = serializers.CharField() # 如果这样写，会把publish对象，打印的样子返回给前端
    # def __str__(self):
    #     return self.name    你要在表中的publish写下这个
    # 出版社对象
    publish_detail = serializers.DictField()

    # 所有作者
    authors_detail = serializers.ListField()

image-20240413211150599

之前的更改名字也一样

就是serial.py里面的表的字段跟models.py文件中的函数一样就行def book_name(self):

class BookSerializer(serializers.Serializer):

    book_name = serializers.CharField()

class Book(models.Model):
    name = models.CharField(max_length=64)
    title = models.CharField(max_length=32)
    price = models.DecimalField(max_digits=8, decimal_places=2)
    publish_date = models.DateField()

    publish = models.ForeignKey(to='Publish', on_delete=models.SET_NULL, null=True)
    authors = models.ManyToManyField(to='Author')

    def __str__(self):
        return self.name
    
    #   def book_name(self):
    #    return self.name + 'xxxxxxx'

image-20240413214310992

【4】通过SerializerMethodField定制字段

  • serial.py

from rest_framework import serializers
from rest_framework.exceptions import ValidationError
class BookSerializer(serializers.Serializer):
    name = serializers.CharField()
    title = serializers.SerializerMethodField()

    def get_title(self, res):
        return res.title + '云开月明！！'

    price = serializers.IntegerField()
    publish_date = serializers.DateField()

    # publish = serializers.CharField() # 如果这样写，会把publish对象，打印的样子返回给前端
    # def __str__(self):
    #     return self.name    你要在表中的publish写下这个
    # 出版社对象
    publish_detail = serializers.SerializerMethodField()

    def get_publish_detail(self, res):
        # res(任何obj、bai) 就是当前序列化到的book对象
        return {'name': res.publish.name, 'addr': res.publish.addr, 'id': res.pk}

    # 作者对象
    authors_detail = serializers.SerializerMethodField()

    def get_authors_detail(self, obj):
        data_list = []
        for i in obj.authors.all():
            data_list.append({'name': i.name, 'age': i.age, 'id': i.id})

        return data_list

image-20240413221140392

image-20240413220921587

Distributor经销商跟CarModel表车型是多对多关系
class DistributorSerializer(serializers.ModelSerializer):
    car_models = serializers.SlugRelatedField(
        '''
many=True 表示这是一个多对多关系，即一个经销商可能销售多个车型。
read_only=True 表示该字段是只读的，不能用于创建或更新对象。
slug_field='name' 指定了作为标识的字段名，在这里是 CarModel 表中的 name 字段。这意味着在序列化时，将使用 CarModel 对象的 name 字段来表示关联的车型。
        '''
        many=True,
        read_only=True,
        slug_field='name'
    )

    class Meta:
        model = Distributor
        fields = '__all__'

image-20240424095356579

# models.py
# 车厂
class CarFactory(models.Model):
    name = models.CharField(max_length=100)
    address = models.CharField(max_length=200)
    phone = models.CharField(max_length=20)

    def __str__(self):
        return self.name

# 车型
class CarModel(models.Model):
    name = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    # 一对多
    factory = models.ForeignKey(CarFactory, on_delete=models.CASCADE, related_name='models')

    def __str__(self):
        return self.name
    
# serilaer.py    
# 一对多关系
class CarFactorySerializer(serializers.ModelSerializer):
    models = serializers.SerializerMethodField()

    def get_models(self, obj):
        # 获取与当前车厂相关联的所有车型
        models = obj.models.all()
        # 序列化车型数据
        serializer = CarModelSerializer(models, many=True)
        return serializer.data

    class Meta:
        model = CarFactory
        fields = ('id', 'name', 'address', 'phone', 'models')

    def get_models(self, obj):
        # 获取与当前车厂相关联的所有车型
        car_models = obj.models.all()
        # 序列化车型数据
        serialized_models = []
        for car_model in car_models:
            serialized_model = {
                'name': car_model.name,
                'price': car_model.price,
                'id': car_model.pk,
                'factory': obj.pk  # 车厂的主键作为车型的工厂信息
            }
            serialized_models.append(serialized_model)
        return serialized_models

    class Meta:
        model = CarFactory
        fields = ('id', 'name', 'address', 'phone', 'models')

image-20240424100439927

image-20240424101250833

多表关联反序列化

【5】定制返回之子序列化

​ 这个的重点就是要定义一个字序列化的类PublishSerializer里面的字段名是要表中的有的字段名（列名）

当使用子序列化器时，有几个要注意的重点：

  1. 字段名和源字段的匹配： 确保在子序列化器中使用的 source 参数与模型中的字段名匹配。这样才能正确地将父对象的属性传递给子序列化器进行序列化。
  2. 多对多关系处理： 如果处理的是多对多关系，确保在子序列化器中设置 many=True 参数，以表示这是一个多个对象的集合。
  3. 数据验证： 子序列化器也可以执行数据验证。确保在子序列化器中定义了适当的验证规则，以确保父对象和子对象的数据都被正确验证。
# 子序列化

class PublishSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField()
    addr = serializers.CharField()
    email = serializers.EmailField()


class AuthorSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField()
    age = serializers.IntegerField()

class BookSerializer(serializers.Serializer):

    name = serializers.CharField()
    title = serializers.CharField()
    price = serializers.IntegerField()
    publish_date = serializers.DateField()

    # 如果这样写，会把publish对象，打印的样子返回给前端
    # publish = PublishSerializer()
    # 修改字段的名字"publish_res"
    # 一对多关系
    publish_res = PublishSerializer(source='publish')
	# # 修改字段的名字"authors_list"
    # 多对多关系
    authors_list = AuthorSerializer(source='authors',many=True)

image-20240413223603552

【6】反序化的保存

【1】删除

  • views.py

class BookDetailView(APIView):
    def delete(self, request, pk):
        instance = Book.objects.filter(pk=pk).first()
        if not instance:
            return Response({'code': 404, 'msg': 'Book not found'}, status=status.HTTP_404_NOT_FOUND)

        instance.delete()
        return Response({'code': 200, 'msg': 'Book deleted successfully'}, status=status.HTTP_200_OK)

  • urls.py

​ 在路由配置中，path('books/<int:pk>/', BookDetailView.as_view()) 表示处理单个书籍的操作，包括查找、更改和删除。而 path('books/', BookView.as_view()) 则表示处理多个书籍的操作，包括查找全部和添加。

from django.urls import path
# BookView、BookDetailView 这个就是我在views.py 定义的类
from Api02.views import BookView,BookDetailView  #

urlpatterns = [
    path('books/', BookView.as_view()),
    path('books/<int:pk>/', BookDetailView.as_view()),

]

  • 序列化组

第一种方法

class PublishSerializer(serializers.ModelSerializer):
    # id = serializers.IntegerField()
    # name = serializers.CharField()
    # addr = serializers.CharField()
    # email = serializers.EmailField()
    class Meta:
        model = Publish
        fields = ['id', 'name', 'addr', 'email']


class AuthorSerializer(serializers.ModelSerializer):
    # id = serializers.IntegerField()
    # name = serializers.CharField()
    # age = serializers.IntegerField()
    class Meta:
        model = Author
        fields = ['id', 'name', 'age']

class BookSerializer(serializers.ModelSerializer):

    # 如果这样写，会把publish对象，打印的样子返回给前端
    # publish = PublishSerializer()
    # 修改字段的名字"publish_res"
    publish_res = PublishSerializer(source='publish')


    authors_l = AuthorSerializer(source='authors', many=True)


    class Meta:
        model = Book
        fields = ['id','name', 'title', 'price', 'publish_date', 'publish_res', 'authors_l', 'delete']

第二种方法

class PublishSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField()
    name = serializers.CharField()
    addr = serializers.CharField()
    email = serializers.EmailField()
    # class Meta:
    #     model = Publish
    #     fields = ['id', 'name', 'addr', 'email']


class AuthorSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField()
    name = serializers.CharField()
    age = serializers.IntegerField()
    # class Meta:
    #     model = Author
    #     fields = ['id', 'name', 'age']

class BookSerializer(serializers.ModelSerializer):
    id = serializers.IntegerField()
    name = serializers.CharField()
    title = serializers.CharField()
    price = serializers.IntegerField()
    publish_date = serializers.DateField()
    # 如果这样写，会把publish对象，打印的样子返回给前端
    # publish = PublishSerializer()
    # 修改字段的名字"publish_res"
    publish_res = PublishSerializer(source='publish')


    authors_l = AuthorSerializer(source='authors', many=True)


    class Meta:
        model = Book
        fields = ['id','name', 'title', 'price', 'publish_date', 'publish_res', 'authors_l', 'delete']

image-20240414192226872

image-20240414192250051

【2】更新

  • views.py

class BookDetailView(APIView):
    def put(self, request, pk):
        # instance 就是序列化的  res_data就是反序列化的
        pk = Book.objects.filter(pk=pk).first()
        print(pk)
        res_data = BookSerializer(data=request.data, instance=pk)
        if res_data.is_valid():
            # 验证过后的数据
            print(res_data.validated_data)
            # 保存数据
            res_data.save()
            return Response({'code': 200, "msg": res_data.data})
        else:
            return Response({'code': 404, 'msg': res_data.errors})

  • urls.py

这个两个路由跟上述一样

from django.urls import path
# BookView、BookDetailView 这个就是我在views.py 定义的类
from Api02.views import BookView,BookDetailView  #

urlpatterns = [
    path('books/', BookView.as_view()),
    path('books/<int:pk>/', BookDetailView.as_view()),

]

  • 序列化组

ModelSerializer使用

​ ModelSerializer 是 Django REST Framework 提供的一个便捷的序列化器类，用于简化与数据库模型的交互。它可以自动根据模型字段生成对应的序列化字段，并提供默认的序列化和反序列化逻辑。

​ 在序列化组中，你可以使用 ModelSerializer 来快速地将数据库模型转换为 JSON 格式的数据，或者将 JSON 格式的数据反序列化为模型对象。

# ModelSerializer使用


class PublishSerializer(serializers.ModelSerializer):
    class Meta:
        model = Publish
        fields = ['id', 'name', 'addr', 'email']


class AuthorSerializer(serializers.ModelSerializer):
    class Meta:
        model = Author
        fields = ['id', 'name', 'age']

class BookSerializer(serializers.ModelSerializer):
    class Meta:
        model = Book
        fields = '__all__'
        # fields=['id','name','publish_detail','authors_list']

        extra_kwargs = {
            'name': {'max_length': 8},  # 限制name不能超过8
            'publish': {'write_only': True},
            'authors': {'write_only': True},
        }

    # 自己再重写的字段
    # 这个字段用来做序列化
    publish_detail = PublishSerializer(source='publish',read_only=True)
    # 这个字段用来做序列化
    authors_list = AuthorSerializer(source='authors', many=True,read_only=True)

这样要注意如果没有加上子序列化这种方法

class PublishSerializer(serializers.ModelSerializer):
    class Meta:
        model = Publish
        fields = ['id', 'name', 'addr', 'email']


class AuthorSerializer(serializers.ModelSerializer):
    class Meta:
        model = Author
        fields = ['id', 'name', 'age']
        
# views.py就必须在加上 pk = Book.objects.filter(pk=pk).first()否则就会报错
    def put(self, request, pk):
        pk = Book.objects.filter(pk=pk).first()
        print(pk)
        res_data = BookSerializer(data=request.data, instance=pk)
        if res_data.is_valid():
            # 验证过后的数据
            print(res_data.validated_data)
            # 保存数据
            res_data.save()
            return Response({'code': 200, "msg": res_data.data})
        else:
            return Response({'code': 404, 'msg': res_data.errors})

第二种

这里要注意在输入的时候ID这个就是必填字段了

class BookSerializer(serializers.Serializer):
    id = serializers.IntegerField()
    name = serializers.CharField()
    title = serializers.CharField()
    price = serializers.IntegerField()
    publish_date = serializers.DateField()


    # 反序列化保持最要多表关联
    publish_save = serializers.IntegerField(source='publish',write_only=True)
    authors = serializers.ListField(write_only=True)
    # 更新
    def update(self, instance, validated_data):
        publish_id = validated_data.pop('publish')
        authors = validated_data.pop('authors')
        # 使用instance.pk获取主键值
        book_qs = Book.objects.filter(pk=instance.pk)
        # 使用update更新实例
        book_qs.update(**validated_data, publish_id=publish_id)
        # 获取更新后的实例
        instance = book_qs.first()

image-20240414194802347

image-20240414194850210

【3】添加

  • views.py

class BookView(APIView):
    def post(self, request):
        res_data = BookSerializer(data=request.data)
        print(res_data)
        if res_data.is_valid():
            # 验证过后的数据
            print(res_data.validated_data)
            # 保存数据
            res_data.save()
            return Response(res_data.data, status=status.HTTP_201_CREATED)
        else:
            return Response({'code': 404, 'msg': res_data.errors})

  • 序列化组

# 反序列化的保存
class BookSerializer(serializers.Serializer):
    name = serializers.CharField()
    title = serializers.CharField()
    price = serializers.IntegerField()
    publish_date = serializers.DateField()


    # 反序列化保持最要多表关联
    publish_save = serializers.IntegerField(source='publish',write_only=True)
    authors = serializers.ListField(write_only=True)
#
#     # 添加
    def create(self, validated_data):
        publish_id = validated_data.pop('publish')
        authors = validated_data.pop('authors')
        book = Book.objects.create(**validated_data, publish_id=publish_id)
        book.authors.add(*authors)
        return book

!在这里插入图片描述

image-20240414195306665

m0_58310590
关注
drf--序列化
冷小陌的博客
10-11 172
在子应用文件里建一个 serializer.py 文件 在这个文件里写入以下内容 __all__ : 将表中所有字段进行序列化 ['id','title','price','desc'] ： 只序列化需要的字段 from rest_framework import serializers from .models import * class CateSerializer(seriali...
DRF（5）- 序列化器之序列化
君莫笑
09-19 216
1, DRF魅力展示(了解) 目的: 了解drf的魅力,使用流程 操作流程: 1, 安装django-restframework, 注册 #安装 pip install djangorestframework #注册 INSTALLED_APPS = [ ... 'rest_framework', ] 2, 路由 from django.conf.u...
DRF多表关联的序列化和反序列化
AZURE060606的博客
04-13 1010
property@property相当于调用了book表中的方法，返回的是一个对象。
【DRF】序列化和反序列化操作（4）
python全栈
05-12 826
序列化是将后端响应数据转换成JSON数据给客户端（PC端、APP端） 一、获取单条数据（序列化） from app1.models import NewsChannel from app1.serializer import NewsChannelSerializer #获取模型对象 channel_obj=NewsChannel.objects.get(id=1) #创建序列化器对象 serializer=NewsChannelSerializer(instance=channel_obj) #获取模型
DRF 序列化器关联多表后提交数据
weixin_44121790的博客
03-06 1070
DRF 序列化器关联多表后提交数据 models.py class Doctor(models.Model): dname = models.CharField(max_length=18) service = models.CharField(max_length=10) class Patient(models.Model): pname = models.Char...
drf 自关联序列化
白小白的小白的博客
06-11 1205
自关联的表如何序列化： 表： class Category(BaseModel): """ 商品类别 """ CLASSIFY_CHOICES = ( (1, '面料'), (2, "款式"), ) name = models.CharField(max_length=20, verbose_name='名称') parent = models.ForeignKey('self', null=True, blank=Tr
DRF序列化中表的关联
weixin_45250558的博客
12-13 554
一对多的两个表 用户与地址 class UserSerializer(serializer.HyperLinkedModelSerializer): 关联关系在user查询中出现地址信息 1 信息显示 address=AdressSerializere(many=True)` 2 信息以地址的形式显示 address=HyperLinkedRelatedFIeld(read_...
DRF初始-序列化与反序列化
大雪纷斐的博客
09-06 196
drf1.0
python drf_Python正课134 —— DRF 进阶1
weixin_39575502的博客
12-22 271
restful就是一个接口开发的约定俗成的开发规范。不局限于django或者drf，即便我们不使用drf，其实也能实现符合restful规范的api接口。同时，drf框架不是restful作者开发出来的！！！一：序列化器-Serializer作用：1.序列化,序列化器会把模型对象转换成字典,将来提供给视图经过response以后变成json字符串2.反序列化,把客户端发送过来的数据,经过视图调用r...
如何使用DRF的序列化器之反序列化
二月的博客
12-11 1225
验证数据：使用序列化器进行反序列化时，需要对数据进行验证后，才能获取验证成功的数据或保存成模型类对象。 在获取反序列化的数据前，必须调用is_valid()方法进行验证，验证成功返回True，否则返回False。is_valid()方法还可以在验证失败时抛出异常serializers.ValidationError，可以通过传递raise_exception=True参数开启，REST fram...
DRF框架讲解(深入DRF机制和原理)
11-22
DRF 是 Django 生态系统中的重要组成部分，它简化了 API 的开发过程，提供了模型序列化、权限控制、格式化器、验证器和分页等功能。它的灵活性和可扩展性使得开发者能够快速地构建复杂的数据接口。 **二、序列化...
2019年python自动化运维进阶篇20期视频教程-百度网盘下载视频
09-02
│ 04三种场景下的反序列化操作.51reboot.mp4 │ 06父组件传值给子组件思路及实战.51reboot.mp4 │ 07子组件传值给父组件思路及案例.51reboot.mp4 │ ├─14.第十四天 │ 01vue一对多多对多显示.51reboot.mp4 │ 02...
Python世界：力扣29题两数相除算法实践
来知晓的博客
09-13 463
除法运算本质是减法，从理解原理到真正实现还是有距离，建议初步理解后，不参考任何代码，完全自己复现一遍，体会更深。注意提示：目的就是提醒越界问题：-2^31/-1=2&31，超过了整数表达范围。本问题来自于力扣29题，在做完大数相乘后，顺带也看下两数相除。将两数相除，要求不使用乘法、除法和 mod 运算符。给定两个整数，被除数。
[Python数据可视化]Plotly Express: 地图数据可视化的魅力
最新发布
William数据分析的博客
09-17 600
在数据分析和可视化的世界中，地图数据可视化是一个强大而直观的工具，它可以帮助我们更好地理解和解释地理数据。Python 的 Plotly Express 库提供了一个简单而强大的方式来创建各种地图。本文将通过一个简单的示例，展示如何使用 Plotly Express 来创建一个交互式的地图，并探讨其在地图数据可视化方面的应用。
Tcl lnit error: Can’t find a usable init.tcl in the following directories 问题解决
梦想闹钟
09-15 483
实际研究后发现，其实py2exe已经把打包需要的lib放在dist文件夹下了，但是打包后的程序运行后却没有去lib下找，而是去找系统自带的环境变量里找，所以找不到。这个问题出现在我用py2exe打包了一个包含tkinter的图形化界面，在当前电脑上运行无问题，在移动到新电脑上后提示报错、getcwd用于获取当前工作目录绝对路径，在设置环境的变量的时候它用的是绝对路径-所以也导致了在当前电脑上能用而移动后不能用。解决方法是在你的程序里重新设置下环境变量，而且是用相对路径的形式。
JUC从实战到源码：中断机制与API实现
qq_43843951的博客
09-12 1176
在Java中，线程中断是一种机制，用于通知线程应该停止当前正在执行的任务。中断通常用于协同线程之间的合作，以便让线程在适当的时候终止其工作，尤其是在长时间运行的任务或阻塞操作中。通过学了多线程以及synchronized的相关知识，接下来就到了学习线程中断知识。
opencv学习：calcHist 函数绘制图像直方图及代码实现
mohanyelong的博客
09-13 1504
opencv学习：calcHist 函数绘制图像直方图及代码实现
面试真题 | web自动化关闭浏览器，quit()和close()的区别
NHB234567的博客
09-13 415
关闭所有的浏览器窗口，销毁driver操作，则需要使用的是quit方法；当打开了多个窗口，只想要关闭非最后一个窗口的时候，使用的是close方法。这些资料，对于【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴上万个测试工程师们走过最艰难的路程，希望也能帮助到你！close():只关闭当前的浏览器标签页，如果当前浏览器标签页剩下最后一个，则所有标签页面退出。是否编写过对应浏览器退出的测试用例。quit():所有的浏览器窗口退出。关闭当前的标签页，其他窗口不退出。退出当前所有的窗口；
Python——俄罗斯方块
2302_81225694的博客
09-14 1628
这段代码使用了Pygame库来实现游戏的图形界面，通过键盘控制方块的移动和旋转。游戏循环不断更新方块的位置和网格状态，并绘制在屏幕上。在方块达到底部或无法继续移动时，判断是否有满行，并清除满行的方块。游戏会根据方块的状态和移动情况不断更新，直到无法继续下落为止，游戏结束。俄罗斯方块游戏是一款经典的益智游戏，通常使用编程语言Python来实现。请注意，这只是一个简单的示例，可能还有一些功能和优化方面的改进。您可以根据自己的需求进行修改和扩展。
drf 序列化 通过Response返回信息
03-23
可以使用以下代码将序列化后的数据通过 Response 返回： ```python from rest_framework.response import Response # 假设已经完成了序列化并得到了 data return Response(data) ``` 其中，`data` 是序列化后的数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值