Python变量和赋值机制、可变对象和不可变对象、深拷贝和浅拷贝

最新推荐文章于 2024-05-30 18:05:01 发布
最新推荐文章于 2024-05-30 18:05:01 发布
阅读量539 收藏 6
点赞数 5
分类专栏： Python 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36429555/article/details/118579332
版权

变量和赋值机制

组成部分

  • 变量是由三部分组成

    # 变量名 赋值符号 变量值
name = "Tom"

Python变量与C++的不同

  • 在C++中，我们对变量的认识应该相当于一个标识符，创建一个变量，即开辟一块内存然后给这块内存起个名字，那么这个名字就是“变量”，当然，这个变量的含义和内存地址以及指针都是不相同的。
  • 在Python中，变量就是一个指针。
    • 首先，python中的变量是没有类型的，有类型的是“对象”，而不是变量。变量没有类型，那么就意味着它可以随意指向任何对象。在强类型语言中，变量其实都是有具体的类型来限制的，规定一个类型的变量只能被赋值与该类型相同或兼容的值。但是在python中，显然变量的自由度更大。
    • 其次，之前学过体系结构的同学都应该了解，指针的内存空间大小是与类型无关的，其内存空间只是保存了所指向数据的内存地址。之所以说指针也有类型，是因为在计算偏移量的时候，确实需要类型相关的信息。所以，从深层次的含以上来理解，python中的变量与强类型语言中的指针非常相似。
  • C++通过操作内存地址而间接操作数据，数据处于被动地位；Python则是直接操控数据，数据处于主动地位，变量只是作为一种引用的关系存在，而不再拥有存储的功能

什么是对象

  • 对象=确定内存空间+存储在这块内存空间中的值。
  • 这一点其实和java有些相似。Java中，对象是分配在堆上的，存储真正的数据，而引用是在堆栈中开辟的内存空间用于引用某一个对象。
  • Python中，对象才有类型，不同的对象可以拥有不同类型的数据。
  • 在Python中，任何东西都是对象，Python使用对象模型来储存数据，任何类型的值都是一个对象。
  • 所有的python对象都有3个特征：身份、类型和值
    • 身份：每一个对象都有自己的唯一的标识，可以使用内建函数id()来得到它。这个值可以被认为是该对象的内存地址
    • 类型：对象的类型决定了该对象可以保存的什么类型的值，可以进行什么操作，以及遵循什么样的规则。type()函数来查看python 对象的类型。
    • 值：对象表示的数据项。

什么是引用

  • 在 Python 程序中，每个对象都会在内存中申请开辟一块空间来保存该对象，该对象在内存中所在位置的地址被称为引用。
  • 引用在Python中的语义应该是一种关系，即变量和对象之间的关系，就是指针指向某一块内存空间的关系。
  • 对于一个对象来说，和不同的变量可能存在着多个“引用”关系。因为变量是无类型的，他想关联谁就可以指向谁。
  • 在开发程序时，所定义的变量名实际就对象的地址引用。

变量的比较

  • “==” 比较的是对象所存储的数据的值是否相等
  • “is” 比较的是两个变量是否都引用了同一个对象

关于变量的总结

重要原则

  1. python中，万物皆对象，不存在所谓的传值调用，一切传递的都是对象的引用，也可以认为是传址。

  2. python中的一切数据都是存储在对象中

  3. python中的一切变量都是对对象的引用

  4. 对象不能被覆盖，也不能被直接销毁（python中有垃圾回收机制来回收不用地对象，比如引用计数机制）

  5. 变量采用地址引用的方式，变量存储的内容只是一个变量值所在的内存地址，而不是变量值(数据)本身

    在这里插入图片描述

赋值机制

  • Python的赋值机制("=")是将一个变量存储的其变量值对象的地址赋给一个变量
    在这里插入图片描述

  • a = 3
b = a # 将变量a对应的数据对象3的地址赋给变量b

可变对象和不可变对象

概念

  • 可变对象与不可变对象的区别在于对象本身是否可变。
  • 可变对象是指，一个对象在不改变其所指向的地址的前提下，可以修改其所指向的地址中的值；
  • 不可变对象是指，一个对象所指向的地址上值是不能修改的，如果你修改了这个对象的值，那么它指向的地址就改变了，相当于你把这个对象指向的值复制出来一份，然后做了修改后存到另一个地址上了，本质上并没有对对象的值进行修改，而是重新创建了一个新的对象。但是可变对象就不会做这样的动作，而是直接在对象所指的地址上把值给改变了，而这个对象依然指向这个地址。

Python内置的对象类型的分类

  • 可变对象：list、dict、set、自定义的类对象、Pytorch中的tensor对象
  • 不可变对象：tuple、string、int、float、bool

代码示例

# 可变对象
>>> a = [1, 2, 3]
>>> a[1] = 4
>>> a
[1, 4, 3]

# 不可变对象
>>> b = (1, 2, 3)
>>> b[1] = 4
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

可变对象和不可变对象的地址问题

可变对象由于其本身可变，所以当修改可变对象时，该对象的地址是没有改变的

>>> a = [1, 2, 3]
>>> id(a)
2139167175368
>>> a[1] = 4
>>> id(a)
2139167175368

如果变量对应的是可变对象时

# 修改变量a对应的列表则b也跟着变，因为他们始终指向同一个地址
>>> a = [1, 2, 3]
>>> id(a)
139683460043584
>>> b = a
>>> id(b)
139683460043584
>>> a[1] = 4
>>> a
[1, 4, 3]
>>> b
[1, 4, 3]
>>> id(a)
139683460043584
>>> id(b)
139683460043584


# 如果是重新将新的列表的地址赋给变量b,则变量a和变量b则对应不同的地址,相互不影响
>>> b = [4, 5, 6]
>>> id(b)
139683460117696
>>> id(a)
139683460043584
>>> b
[4, 5, 6]
>>> a
[1, 4, 3]

如果变量对应的是不可变对象

# 因为不可变对象不可以修改,所以当值不同时即是在内存空间中新建了一块区域用以存放新值
# a改变后，它的地址也发生了变化，而b则维持原来的地址，原来地址中的内容也没有发生变化
>>> a = (1, 2, 3)
>>> id(a)
2139167074776
>>> b = a
>>> a = (4, 5, 6)
>>> a
(4, 5, 6)
>>> b
(1, 2, 3)
>>> id(a)
2139167075928
>>> id(b)
2139167074776

作为函数参数时

可变对象

>>> def myfunc(l):
...     l.append(1)
...     print(l)
...
>>> l = [1, 2, 3]
>>> myfunc(l)
[1, 2, 3, 1]
>>> l
[1, 2, 3, 1]
  • 可变对象作为参数传入时，在函数中对其本身进行修改，是会影响到全局中的这个变量值的，因为函数直接对该地址的值进行了修改

不可变对象

>>> def myfunc(a):
...     a += 1
...     print(a)
...
>>> a = 2
>>> myfunc(a)
3
>>> a
2

  • 对于不可变对象来说，虽然函数中的a值变了，但是全局中的a值没变，因为函数中的a值已经对应了另外一个地址，而全局中的a值指向的原来地址的值是没有变的

  • 关于函数的参数传递：

    python的函数传递其实就是将实参对应的对象地址赋值给形参，即形参和实参都具有相同的对象地址，指向相同的内存区域，且形参的作用域只是在函数内部

总结

  • python中向函数传递参数只能是传对象引用，表示把它的地址都传进去了，这才会带来上面的现象
  • 有的编程语言允许值传递，即只是把值传进去，在里面另外找一个地址来放，这样就不会影响全局中的变量

可变对象在类中使用

class Myclass:
    def __init__(self, a):
        self.a = a
    def printa(self):
        print(self.a)

aa = [1, 2]
my = Myclass(aa)
my.printa()
aa.append(3)
print(aa)
my.printa()

(bbn) jyzhang@admin2-X10DAi:~/test$ python net.py
[1, 2]
[1, 2, 3]
[1, 2, 3]
  • 类中的变量和全局变量地址依然是共用的，无论在哪里修改都会影响对方

创建可变对象和不可变对象时的内存机制

不可变对象

代码块
  • 一个模块，一个函数，一个文件，一个类都是一个代码块
  • 在交互模式下，每一行是一个代码块
小数据池
  • 小数据池，是Python对内存的一种优化
  • 它将-5到256的整数，以及一定规则的字符串，提前在内存中建了池，容器里固定放了这些数
  • 小数据池的应用数据类型：整型，字符串，bool
不可变对象的内存机制
  1. 在同一代码块中具有相同值的不可变对象具有相同的内存地址。初始化不可变对象时，会优先看是否之前在该代码块中创建过相同值的对象，若有，会复用该对象。
  2. 在不同代码块中满足小数据池条件的相同值的不可变对象具有相同的内存地址。
  3. 不同值的不可变对象具有不同的内存地址。

可变对象

  • 具有相同值的可变对象具有不同的内存地址，即每次初始化可变对象即要重新创建一个对象

深拷贝和浅拷贝

直接赋值

  • Bill = ["Gates", 50, ["Python", "C#", "JavaScript"]]
Jack = Bill
print(id(Bill))
print(Bill)
print([id(ele) for ele in Bill])
print(id(Jack))
print(Jack)
print([id(ele) for ele in Jack])
print(Jack is Bill)

    #output:
97597256
['Gates', 50, ['Python', 'C#', 'JavaScript']]
[97625072L, 34047944L, 97620808L]
97597256
['Gates', 50, ['Python', 'C#', 'JavaScript']]
[97625072L, 34047944L, 97620808L]
True

  • Bill[0] = "Mark"
Bill[2].append("Scala")
print(id(Bill))
print(Bill)
print([id(ele) for ele in Bill])
print(id(Jack))
print(Jack)
print([id(ele) for ele in Jack])

    #output:
97262024
['Mark', 50, ['Python', 'C#', 'JavaScript', 'Scala']]
[97615224L, 34047944L, 97596616L]
97262024
['Mark', 50, ['Python', 'C#', 'JavaScript', 'Scala']]
[97615224L, 34047944L, 97596616L]

  • 在这里插入图片描述

  • 这说明采用直接赋值的方式，变量Bill和Jack的地址完全相同，同时他们的内部元素的地址也完全相同，Bill的元素修改Jack上也成立。需要注意的是，str与int等原子类型是不可变类型，在不改变地址的前提下，无法改变值，所以Bill[0]的值发生了变换，且分配了一个新的地址。而list ,dict等容器类型式可变类型，在地址不变的前提下，可以更改值,所以Bill[2]的值发生了变化，但是地址不变

浅拷贝

  1. 浅拷贝

    import copy
 
Bill = ["Gates", 50, ["Python", "C#", "JavaScript"]]
Jack = copy.copy(Bill)
print(id(Bill))
print(Bill)
print([id(ele) for ele in Bill])
print(id(Jack))
print(Jack)
print([id(ele) for ele in Jack])
print(Jack is Bill)

#output:
97263496
['Gates', 50, ['Python', 'C#', 'JavaScript']]
[97625072L, 34047944L, 97262024L]
98156168
['Gates', 50, ['Python', 'C#', 'JavaScript']]
[97625072L, 34047944L, 97262024L]
False

  2. 修改值

    Bill[0] = "Mark"
Bill[2].append("Scala")
print(id(Bill))
print(Bill)
print([id(ele) for ele in Bill])
print(id(Jack))
print(Jack)
print([id(ele) for ele in Jack])

#output:
97263496
['Mark', 50, ['Python', 'C#', 'JavaScript', 'Scala']]
[97613904L, 34047944L, 97262024L]
98156168
['Gates', 50, ['Python', 'C#', 'JavaScript', 'Scala']]
[97625072L, 34047944L, 97262024L]

  3. 在这里插入图片描述

  4. 这说明,浅拷贝的变量Jack与Bill的地址不同，即 Jack is not Bill， 但是它俩的元素地址相同，即Jack[i] is Bill[i]。浅拷贝之后，对原变量元素进行赋值。Bill[0]与Bill[-1]都发生了变化，且由于Bill[0]是不可变类型，分配了新的地址，而浅拷贝对象Jack[0]还指向原地址，所以Jack[0]的值还是原来的值。而Bill[-1]是原地变化，所以Bill[-1]也进行了相应的变化。

深拷贝

  1. 深拷贝

    import copy
 
Bill = ["Gates", 50, ["Python", "C#", "JavaScript"]]
Jack = copy.deepcopy(Bill)
print(id(Bill))
print(Bill)
print([id(ele) for ele in Bill])
print(id(Jack))
print(Jack)
print([id(ele) for ele in Jack])
print(Jack is Bill)

#output:
97262024
['Gates', 50, ['Python', 'C#', 'JavaScript']]
[97625072L, 34047944L, 97598216L]
97263496
['Gates', 50, ['Python', 'C#', 'JavaScript']]
[97625072L, 34047944L, 97596872L]
False

  2. 修改值

    Bill[1] = 38
Bill[2].append("Scala")
print(id(Bill))
print(Bill)
print([id(ele) for ele in Bill])
print(id(Jack))
print(Jack)
print([id(ele) for ele in Jack])

#output:
97262024
['Gates', 38, ['Python', 'C#', 'JavaScript', 'Scala']]
[97625072L, 34048232L, 97598216L]
97263496
['Gates', 50, ['Python', 'C#', 'JavaScript']]
[97625072L, 34047944L, 97596872L]

  3. 在这里插入图片描述

  4. 结论

    • 可以看到，Jack是Bill的深拷贝对象，Jack is not Bill，and Jack[i] is not Bill[i]，从而实现效果上，两个变量的彻底剥离。
    • 在初始化的时候，由于前两个元素都是不可变类型，在同一个代码块中Jack与Bill的这两个元素的地址相同。重点是对于可变类型元素，两个变量的地址是不同的，因此，不论元素类型是否可变，原对象的变化都不影响拷贝对象。

总结

= ，copy，deepcopy的区别如下：
考虑对象A的变化对拷贝对象B的影响，应该这么考虑：

  1. A与B是否指向同一个地址(=)，若是则A在当前地址的任何变化都会导致B的变化，(若A被重新赋值至一个新的对象除外)。
  2. A与B指向的地址不同，若B的元素与A的元素指向地址相同(浅拷贝)，且A的元素有可变类型，那么A的可变类型元素的变化会导致B的相应元素的变化。
  3. A与B指向的地址不同，且A与B的元素指向的地址也不同(深拷贝，不可变类型元素地址相同，不影响)，那么A的任何类型元素的变化都不会导致B的元素变化。

（注：这里的变化均是指在当前地址的操作引起的变化）

Jiyang@UESTC
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python怎样给对象赋值_Python对象赋值、浅拷贝和深拷贝
weixin_39598135的博客
01-29 1636
总结：1、copy.copy 浅拷贝 只拷贝父对象，不会拷贝对象的内部的子对象2、copy.deepcopy 深拷贝 拷贝对象及其子对象1、对象赋值will = ["Will", 28, ["Python", "C#", "JavaScript"]]wilber = will #对象赋值(对象引用)print id(will)print willprint [id(ele) for ele i...
python列表是可变对象吗_Python可变对象和不可变对象
weixin_39675728的博客
12-06 3578
Python中一切皆对象，每个对象都有其唯一的id，对应的类型和值，其中id指的是对象在内存中的位置。根据对象的值是否可修改分为可变对象和不可变对象。其中，不可对象包括：数字，字符串，tuple可变对象包括：list，dict，setPython中的变量可以指向任意对象，可以将变量都看成是指针，保存了所指向对象的内存地址(对象的引用)。不可变对象对于不可变对象，如果要更新变量引用的不可变对象的值，...
《Python》：深拷贝、浅拷贝、赋值之间的关系（附可变与不可变）【用图文讲清楚！】
热门推荐
一个深技大小学生的博客
12-22 1万+
不可变具体怎么体现呢，以整形为例：python中所有的整形都已经有自己的地址了，我们将整形赋值给变量的过程其实是变量的地址指向整形的地址a = 1# a的id地址和1是一样的c = 1# c也指向了1的地址，所以a和c的地址是一样的同样的，如果将a的值修改为2，那么a的地址就会指向2的id地址。a = 1# a的id地址和1是一样的a = 2所以，其实可变和不可变是对于id来说的一个id地址只能指向一个值的数据类型，就是不可变数据类型（换句话就是值变了，地址也变了）直接上代码！
记录遇到的Python陷阱和注意点
weixin_33781606的博客
09-09 161
来源：http://www.cnblogs.com/wilber2013/p/5178620.html 最近使用Python的过程中遇到了一些坑，例如用datetime.datetime.now()这个可变对象作为函数的默认参数，模块循环依赖等等。 在此记录一下，方便以后查询和补充。 避免可变对象作为默认参数 在使用函数的过程中，经常会涉及默认参数。...
『Python学习笔记』Python中的浅拷贝和深拷贝&可变与不可变类型
AI新视界
03-05 834
浅拷贝，是指重新分配一块内存，创建一个新的对象，里面的元素是原对象中子对象的引用。 所谓深度拷贝，是指重新分配一块内存，创建一个新的对象，并且将原对象中的元素，以递归的方式，通过创建新的子对象拷贝到新对象中。因此，新对象和原对象没有任何关联。
Python的变量赋值，可变对象与不可变对象，浅复制（copy）与深复制（deepcopy）
fate252的博客
05-26 334
python 可变对象，不可变对象 可变对象 该对象所指定的内存地址上面的值可以被改变，变量被改变后，其所指向的内存地址上面的值，直接被改变，没有发生复制行为，也没有发生开辟新的内存地址行为。 python可变对象有，列表，字典，set集合 例如： a=['1','2','3'] print(id(a)) 2275736586376 a.append('1') print(a) ['1', ...
Python可变对象与不可变对象的浅拷贝与深拷贝
renwu
03-06 605
本文主要介绍了python中容易面临的考试点和犯错点，即浅拷贝与深拷贝我们可以发现，赋值、浅拷贝和深拷贝后的变量的值是一样的，但他们的“内部”真的一样吗？本文就是回答这个问题的。
彻底理解Python中浅拷贝和深拷贝的区别
专注自动化、性能测试、测试架构学习交流
12-09 9690
Python浅拷贝只复制某个对象的引用，而不复制对象本身，新旧对象还是共享同一块内存。Python深拷贝会创造一个一摸一样的对象，新对象和原对象不共享内存，修改新对象不会改变原对对象。
python赋值浅拷贝和深拷贝的区别_python赋值、浅拷贝、深拷贝区别
weixin_42601134的博客
01-12 756
在写Python过程中，经常会遇到对象的拷贝，如果不理解浅拷贝和深拷贝的概念，你的代码就可能出现一些问题。所以，在这里按个人的理解谈谈它们之间的区别。一、赋值(assignment)在《Python FAQ1》一文中，对赋值已经讲的很清楚了，关键要理解变量与对象的关系。>>> a = [1, 2, 3]>>> b = a>>> print(id...
解惑 python3 可变类型与不可变类型 ， is 与 == 区别 ， 变量赋值、深拷贝与浅拷贝
01-21
注意：这里的可变不可变指的是内存中的那块内容（value）是否可以被改变。如果是不可变类型的话，在对对象本身操作的时候，必须在内存中新申请一块区域（因为老区域不可变）。如果是可变类型，在对对象操作的时候，...
详解Python直接赋值,深拷贝和浅拷贝
01-19
对于可变对象和不可变对象,将一个变量直接赋值给另外一个变量,两者 id 值一致,其实本质上是将变量量绑定到对象的过程. >>> a=1 >>> b=a >>> id(a) == id(b) True >>> c=string >>> d=c >>> id(c) == id(d) True >>>...
python变量赋值方法(可变与不可变)
01-20
Python在heap中分配的对象分成两类：可变对象和不可变对象。所谓可变对象是指，对象的内容可变，而不可变对象是指对象内容不可变。 不可变（immutable）：int、字符串(string)、float、（数值型number）、元组...
如何mysql数据导入到mongdb
codemami的博客
05-30 1237
由于MySQL和MongoDB的数据模型不同（例如，MySQL使用关系模型，而MongoDB使用文档模型），你可能需要转换数据的格式。使用MongoDB驱动程序：你也可以使用MongoDB的官方驱动程序（如Python的pymongo）来编写脚本，将数据直接插入到MongoDB中。注意：如果你的JSON文件包含多个文档，并且它们不是作为数组的一部分（即每个文档都在其自己的行上），则需要使用--jsonArray选项。手动转换：对于小型数据集，你可以手动编辑SQL或CSV文件，将其转换为JSON格式。
在linux服务器上使用tensorboard，错误记录
wwwwzm的博客
05-30 984
1. 使用tensorboard命令时，不是从虚拟环境中找tensorboard，而是从（全局路径）中找（/home/ljx/.local/lib/python3.9/site-packages/tensorboard）是一个在 Unix-like 系统（包括 Linux 和 macOS）的命令行界面（如 Bash shell）中使用的命令。2.使用which命令， 查看使用的tensorboard的路径，发现使用的是全局路径，不是虚拟环境路径。是一个特殊的变量，它定义了操作系统搜索可执行文件的目录。
基于NANO 9K 开发板加载PICORV32软核，并建立交叉编译环境
最新发布
pocean2012的博客
05-30 1069
ISP的实现逻辑是出厂“芯片”（我们这里是软核）自带了BootLoader程序，即出厂引导程序，通过BootLoader可以将程序从串口（上位机）下载到Flash中，实际的时序是通过RST来区分正常启动还是烧录状态，然后上位机的烧录脚本来控制串口时序， 用户程序实际上是通过串口最终下载到了FLASH中，然后程序从flash启动。NANO 9K低成本体验FPGA开发，还是挺香的，官方例子有加载PICORV32软核的例子，可以建立简单的ISP编程环境，通过串口就可以加载程序，很方便。
Pandas03
Bianca427的博客
05-27 1607
聚合计算时新增一列计算最大值与平均值的差值df.groupby('district').agg(最低工资=('salary', 'min'), 最高工资=('salary', 'max'), 平均工资=('salary', 'mean'), 最大值与均值差值=('salary', myfunc)).rename_axis(["行政区"])
深入理解Python中None和““的区别
m0_54701273的博客
05-27 1035
在Python的世界里，None和空字符串""经常被用作默认值或用于表示缺省值的情况。尽管它们在某些语境下似乎可互换，但实际上None和""在Python中有着根本的区别。
使用Quartznet和Pytorch实现语音文字转换（speech-to-text）
摸鱼人
05-30 529
QuartzNet是Nvidia推出的一个轻量级的端到端语音识别模型，即使在5x15版本上仅包含18.9M个参数，在LibriSpeech-dev其他数据集上也能有超过95%的准确率。因此，凭借高吞吐量和高精度，QuartzNet可以提供帧级语音到文本推理，相比于大多数GB级别的ASR模型，QuartzNet适用于存储和计算能力有限的边缘设备上使用。
生命在于学习——Python人工智能原理（2.1）
易水哲的博客
05-27 1644
机器学习是指从有限的观测数据中学习出具有一般性的规律。
python 变量和对象在内存中
12-08
Python 变量和对象在内存中有着密切的关系。在Python中，变量是对对象的引用，而对象是存储在内存中的一段数据。 当我们创建一个变量并将其赋值为某个对象时，实际上是在内存中创建了一个对象，并将变量指向该对象的内存地址。这意味着变量并不直接存储对象的值，而是存储对象的引用。 当我们对变量进行操作时，实际上是在操作对象而不是变量本身。例如，当我们对一个整数变量进行加法操作时，实际上是在对整数对象进行加法运算。 在Python中，对象可以分为可变对象和不可变对象。可变对象是指在创建之后可以改变其值的对象，例如列表和字典；而不可变对象是指创建之后其值不可变的对象，例如整数和字符串。变量指向的对象可以是可变对象也可以是不可变对象。 当一个对象没有被任何变量引用时，Python的垃圾回收机制会将其从内存中清除，释放内存空间。这意味着我们不需要手动管理内存，而是由Python自动处理对象的创建和销毁。 总之，Python中的变量和对象在内存中是通过引用的方式关联在一起的，我们通过变量来操作对象，而对象的创建和销毫不可变对象消除则由Python自动管理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值