【Python】Speedup

原创 已于 2024-11-18 11:14:58 修改 · 398 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #加速 #speedup

于 2021-07-19 10:15:25 首次发布
本文介绍了11种优化Python代码速度的方法，包括避免全局变量、减少函数属性访问、消除类内属性访问、避免不必要的抽象、避免数据复制、高效交换值、使用join替代字符串拼接、利用if短路特性、循环优化和使用numba库。通过这些技巧，可以显著提高代码执行效率。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

在这里插入图片描述

文章目录

1、Python 优化提速的 8 个小技巧

学习摘抄来自 Python 优化提速的 8 个小技巧

1.1、代码优化原则

不要过早优化——让正确的程序更快要比让快速的程序正确容易得多

权衡优化的代价——时间换空间或空间换时间、开发代价

不要优化那些无关紧要的部分——首先要找到代码运行慢的位置，通常是内部循环，专注于运行慢的地方进行优化

1.2、避免全局变量

通过将脚本语句放入到函数中，通常可带来 15% - 30% 的速度提升。

由于全局变量和局部变量实现方式不同，定义在全局范围内的代码运行速度会比定义在函数中的慢不

【全局】

import time
import math
s = time.time()

size = 10000

for x in range(size):
    for y in range(size):
        z = math.sqrt(x) + math.sqrt(y)

t = time.time() - s
print(t)  # 28.321624994277954

【局部】

import time
import math
s = time.time()

def main():
    size = 10000

    for x in range(size):
        for y in range(size):
            z = math.sqrt(x) + math.sqrt(y)

main()
t = time.time() - s
print(t)  # 24.015749216079712

1.2、避免函数属性访问

每次使用 .（属性访问操作符时）会触发特定的方法，如__getattribute__()和__getattr__()，这些方法会进行字典操作，因此会带来额外的时间开销。通过 from import 语句，可以消除属性访问。

【baseline】

import time
import math
s = time.time()


def compute_sqrt(size):
    result = []
    for i in range(size):
        result.append(math.sqrt(i))
    return result


def main():
    size = 10000
    for _ in range(size):
        result = compute_sqrt(size)


main()
t = time.time() - s
print(t)  # 15.633185386657715

【消除 sqrt 的属性访问】

import time
from math import sqrt
s = time.time()


def compute_sqrt(size):
    result = []
    for i in range(size):
        result.append(sqrt(i))  # changed
    return result


def main():
    size = 10000
    for _ in range(size):
        result = compute_sqrt(size)


main()
t = time.time() - s
print(t)  # 13.318369150161743

【局部变量的查找会比全局变量更快】

import time
import math
s = time.time()


def compute_sqrt(size):
    sqrt = math.sqrt  # changed
    result = []
    for i in range(size):
        result.append(sqrt(i))  # changed
    return result


def main():
    size = 10000
    for _ in range(size):
        result = compute_sqrt(size)


main()
t = time.time() - s
print(t)  # 12.782810926437378

【list.append 也涉及到了属性访问，消除掉】

import time
import math
s = time.time()


def compute_sqrt(size):
    result = []
    sqrt = math.sqrt  # changed
    append = result.append  # changed
    for i in range(size):
        append(sqrt(i))  # changed
    return result


def main():
    size = 10000
    for _ in range(size):
        result = compute_sqrt(size)


main()
t = time.time() - s
print(t)  # 11.429441690444946

1.3、避免类内属性访问

访问 self._value 的速度会比访问一个局部变量更慢一些。通过将需要频繁访问的类内属性赋值给一个局部变量，可以提升代码运行速度

import time
import math


class DemoClass:
    def __init__(self, value):
        self._value = value

    def computesqrt(self, size):
        result = []
        append = result.append
        sqrt = math.sqrt
        for _ in range(size):
            append(sqrt(self._value))
        return result


def main():
    size = 10000
    for _ in range(size):
        demo = DemoClass(size)
        result = demo.computesqrt(size)


s = time.time()
main()
t = time.time() - s
print(t)  # 13.051112174987793

import time
import math


class DemoClass:
    def __init__(self, value):
        self._value = value

    def computesqrt(self, size):
        result = []
        append = result.append
        sqrt = math.sqrt
        value = self._value  # changed
        for _ in range(size):
            append(sqrt(value))
        return result


def main():
    size = 10000
    for _ in range(size):
        demo = DemoClass(size)
        result = demo.computesqrt(size)


s = time.time()
main()
t = time.time() - s
print(t)  # 11.46233320236206

1.4、避免不必要的抽象

任何时候当你使用额外的处理层（比如装饰器、属性访问、描述器）去包装代码时，都会让代码变慢。大部分情况下，需要重新进行审视使用属性访问器的定义是否有必要，使用getter/setter函数对属性进行访问通常是 C/C++ 程序员遗留下来的代码风格。如果真的没有必要，就使用简单属性

import time
import math

class DemoClass:
    def __init__(self, value):
        self.value = value

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, x):
        self._value = x

def main():
    size = 1000000
    for i in range(size):
        demo = DemoClass(size)
        value = demo.value
        demo.value = i

s = time.time()
main()
t = time.time() - s
print(t)  # 0.4996964931488037

import time

class DemoClass:
    def __init__(self, value):
        self.value = value

def main():
    size = 1000000
    for i in range(size):
        demo = DemoClass(size)
        value = demo.value
        demo.value = i

s = time.time()
main()
t = time.time() - s
print(t)  # 0.2712728977203369

1.5、避免数据复制

import time

def main():
    size = 10000
    for _ in range(size):
        value = range(size)
        value_list = [x for x in value]
        square_list = [x**2 for x in value_list]

s = time.time()
main()
t = time.time() - s
print(t)  # 21.94828724861145

import time

def main():
    size = 10000
    for _ in range(size):
        value = range(size)
        square_list = [x**2 for x in value]

s = time.time()
main()
t = time.time() - s
print(t)  # 19.546735286712646

1.6、交换值时不使用中间变量

import time

def main():
    size = 1000000
    for _ in range(size):
        a = 3
        b = 5
        temp = a
        a = b
        b = temp

s = time.time()
main()
t = time.time() - s
print(t)  # 0.04886913299560547

import time


def main():
    size = 1000000
    for _ in range(size):
        a = 3
        b = 5
        a,b = b,a

s = time.time()
main()
t = time.time() - s
print(t)  # 0.044878244400024414

1.7、字符串拼接用 join 而不是+

import time
import string

def concatstring(string_list):
    result = ""
    for str_i in string_list:
        result += str_i
    return result

def main():
    string_list = list(string.ascii_letters * 100)
    #print(string.ascii_letters)  # abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
    #print(len(string.ascii_letters))  # 52
    for _ in range(10000):
        result = concatstring(string_list)

s = time.time()
main()
t = time.time() - s
print(t)  # 9.094638586044312

import time
import string

def concatstring(string_list):
    return "".join(string_list)

def main():
    string_list = list(string.ascii_letters * 100)
    #print(string.ascii_letters)  # abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
    #print(len(string.ascii_letters))  # 52
    for _ in range(10000):
        result = concatstring(string_list)

s = time.time()
main()
t = time.time() - s
print(t)  # 0.2922179698944092

当使用 a + b 拼接字符串时，由于 Python 中字符串是不可变对象，其会申请一块内存空间，将 a 和 b 分别复制到该新申请的内存空间中。因此，如果要拼接 n 个字符串，会产生 n-1 个中间结果，每产生一个中间结果都需要申请和复制一次内存，严重影响运行效率。而使用 join() 拼接字符串时，会首先计算出需要申请的总的内存空间，然后一次性地申请所需内存，并将每个字符串元素复制到该内存中去

1.8、利用 if 条件的短路特性

if 条件的短路特性是指对 if a and b 这样的语句， 当 a 为 False 时将直接返回，不再计算 b；对于 if a or b 这样的语句，当 a 为True时将直接返回，不再计算b 。因此， 为了节约运行时间，对于 or 语句，应该将值为 True 可能性比较高的变量写在 or 前，而 and 应该推后。

1.9、循环优化

用 for 循环代替 while 循环

import time

def computesum(size):
    sum_ = 0
    i = 0
    while i < size:
        sum_ += i
        i += 1
    return sum_

def main():
    size = 10000
    for _ in range(size):
        result = computesum(size)

s = time.time()
main()
t = time.time() - s
print(t)  # 9.779865980148315

import time


def computesum(size):
    sum_ = 0
    for i in range(size):
        sum_ += i
    return sum_


def main():
    size = 10000
    for _ in range(size):
        result = computesum(size)


s = time.time()
main()
t = time.time() - s
print(t)  # 4.808104038238525

python 的 for 循环比 while 循环快不少

使用隐式 for 循环代替显式 for 循环

承接上面的例子

import time

def computesum(size):
    return sum(range(size)) # 隐式 for 循环代替显式 for 循环
 
def main():
    size = 10000
    for _ in range(size):
        result = computesum(size)

s = time.time()
main()
t = time.time() - s
print(t)  # 1.5418744087219238

减少内层 for 循环的计算

1 避免全局变量 的代码中 sqrt(x) 位于内侧 for 循环， 每次训练过程中都会重新计算一次，增加了时间开销

import time
import math


def main():
    size = 10000
    sqrt = math.sqrt
    for x in range(size):
        for y in range(size):
            z = sqrt(x) + sqrt(y)

s = time.time()
main()
t = time.time() - s
print(t)  # 17.86617159843445

import time
import math

def main():
    size = 10000
    sqrt = math.sqrt
    for x in range(size):
        sqrt_x = sqrt(x)
        for y in range(size):
            z = sqrt_x + sqrt(y)

s = time.time()
main()
t = time.time() - s
print(t)  # 10.21863317489624

10、使用 numba.jit

numba 可以将 Python 函数 JIT 编译为机器码执行，大大提高代码运行速度。关于 numba 的更多信息见下面的主页：http://numba.pydata.org/numba.pydata.org

import time


def computesum(size):
    sum_ = 0
    for i in range(size):
        sum_ += i
    return sum_


def main():
    size = 10000
    for _ in range(size):
        result = computesum(size)


s = time.time()
main()
t = time.time() - s
print(t)  # 4.808104038238525

import time
import numba


@numba.jit
def computesum(size):
    sum_ = 0
    for i in range(size):
        sum_ += i
    return sum_


def main():
    size = 10000
    for _ in range(size):
        result = computesum(size)


s = time.time()
main()
t = time.time() - s
print(t)  # 1.409585952758789

11、选择合适的数据结构

Python 内置的数据结构如 str, tuple, list, set, dict 底层都是 C 实现的，速度非常快，自己实现新的数据结构想在性能上达到内置的速度几乎是不可能的。

list 类似于 C++ 中的 std::vector，是一种动态数组。其会预分配一定内存空间，当预分配的内存空间用完，又继续向其中添加元素时，会申请一块更大的内存空间，然后将原有的所有元素都复制过去，之后销毁之前的内存空间，再插入新元素。

删除元素时操作类似，当已使用内存空间比预分配内存空间的一半还少时，会另外申请一块小内存，做一次元素复制，之后销毁原有大内存空间。

因此，如果有频繁的新增、删除操作，新增、删除的元素数量又很多时，list 的效率不高。此时，应该考虑使用collections.deque。collections.deque 是双端队列，同时具备栈和队列的特性，能够在两端进行 O(1) 复杂度的插入和删除操作。

list 的查找操作也非常耗时。当需要在 list 频繁查找某些元素，或频繁有序访问这些元素时，可以使用 bisect 维护 list 对象有序并在其中进行二分查找，提升查找的效率。

另外一个常见需求是查找极小值或极大值，此时可以使用 heapq 模块将 list 转化为一个堆，使得获取最小值的时间复杂度是 O(1)。

下面的网页给出了常用的 Python 数据结构的各项操作的时间复杂度：https://wiki.python.org/moin/TimeComplexity

2、Lazy evaluation

惰性计算（Lazy evaluation），也被译为延迟计算或惰性求值，是计算机编程中的一个重要概念。

一、定义与原理

  • 惰性计算指的是，在计算过程中，表达式不在它被绑定到变量之后就立即求值，而是在该值被实际取用的时候才进行计算。这种策略旨在最小化计算机所需执行的工作，从而提升性能。

二、特点与优势

  • 延迟求值：惰性计算的核心在于延迟表达式的求值过程，直到该值被真正需要时才进行计算。这有助于避免不必要的计算，从而提升程序的执行效率。
  • 性能提升：通过减少不必要的计算，惰性计算可以显著提升程序的运行性能。特别是在处理大规模数据或复杂计算时，这种优势尤为明显。
  • 构造无限数据结构：惰性计算允许程序员构造无限的数据结构，如无限列表或无限流，而不会导致程序陷入无限循环或内存溢出。这是因为只有在需要时才会计算数据的值。
  • 节省空间：由于惰性计算避免了不必要的计算，因此可以节省大量的内存空间。这对于资源受限的环境或需要处理大量数据的场景尤为重要。

三、应用场景

  • 函数式编程：惰性计算特别适用于函数式编程语言，如Haskell、Miranda等。这些语言通常默认支持惰性计算，使得程序员可以更加灵活地处理数据。
  • 条件表达式：在Python等语言中，惰性计算可以用于优化条件表达式的执行。例如，在 “if x and y” 表达式中，如果x为false，则不会计算y的值，从而避免了不必要的计算。
  • 迭代器与生成器：在JavaScript等语言中，迭代器与生成器是实现惰性计算的重要工具。它们允许程序员创建可以按需生成值的序列，从而节省内存和计算资源。

四、实现方式

  • 默认支持：某些编程语言（如Miranda和Haskell）默认支持惰性计算。在这些语言中，程序员无需进行额外的配置或编写特殊的代码即可享受惰性计算带来的优势。
  • 函数或特殊语法：另一些语言（如Scheme）提供函数或特殊语法来支持惰性计算。例如，Scheme提供了delay和force函数来延迟表达式的求值和强制求值。
  • 库或框架：对于不支持惰性计算的语言，程序员可以通过引入第三方库或框架来实现这一功能。这些库或框架通常提供了类似的接口和语法来支持惰性计算。

五、注意事项

  • 避免无限循环：虽然惰性计算允许构造无限的数据结构，但程序员需要确保不会意外地创建导致无限循环的表达式。这通常需要通过仔细设计算法和逻辑来实现。
  • 性能权衡：虽然惰性计算可以提升性能，但在某些情况下（如需要立即获取结果时），它可能会增加延迟*。因此，程序员需要根据具体的应用场景和需求来权衡使用惰性计算的利弊。

综上所述，惰性计算是一种强大的编程策略，它可以帮助程序员优化程序的执行效率、节省内存空间，并构造无限的数据结构。然而，在使用惰性计算时，程序员也需要注意避免无限循环和性能权衡等问题。

3、taichi

胡渊鸣：import一个“太极”库，让Python代码提速100倍！

提速前

import time
def is_prime(n):
    result = True
    for k in range(2, int(n ** 0.5) + 1):
        if n % k == 0:
            result = False
            break
    return result

def count_primes(n):
    count = 0
    for k in range(2, n):
        if is_prime(k):
            count += 1
    return count

star = time.time()
count_primes(100_0000)
end = time.time()
print(end-star)

output

4.871095180511475

引入 tachi 提速后

import time
import taichi as ti
ti.init(arch=ti.cpu)

@ti.func
def is_prime(n:int) -> int:
    result = True
    for k in range(2, int(n ** 0.5) + 1):
        if n % k == 0:
            result = False
            break
    return result

@ti.kernel
def count_primes(n:int) -> int:
    count = 0
    for k in range(2, n):
        if is_prime(k):
            count += 1
    return count

star = time.time()
count_primes(100_0000)
end = time.time()
print(end-star)

注意，一定要指定好函数形参的类型，不然会报错

0.24001169204711914

速度真的提升了很多

Python AsyncIO 模块的用法及其优势 Using Python‘s AsyncIO module to Speed Up Your Application
AI天才研究院
07-28 1190
在Python中，有一个模块叫做asyncio（另一种实现异步编程的方式是通过协程），它提供了一种便捷的创建并发执行任务的方法。对于IO密集型或网络通信等耗时比较长的程序来说，asyncio可以显著提升性能。本文将详细介绍一下AsyncIO模块的用法及其优势。
python实现网络测速
A soul tortured by desire
01-06 1394
Python网络测速
python将音频进行变速的操作方法
01-21
有的时候需要手里的音频文件变速听，或可能变慢或可能变快 这里使用的python进行操作，我的目标是将文件转成2倍速 首先需要安装插件 pip install ffmpeg 然后再执行： from ffmpeg import audio audio.a_speed(“D:\\1505.mp3”, “2”, “D:\\1505_2x.mp3”) 如果执行不出错，会返回一个true 运行结果 我可以看到这里的音频速度提升以后音频小了 这里我是将目标路径下的MP3音频转成了2倍速的，设立不局限于MP3。其他格式的音频文件也是可以进行处理的。 当然这里还可以进行批量操作 import os
Python性能优化的20条建议
u010808961的专栏
09-16 1007
Python性能优化的20条建议 优化算法时间复杂度 算法的时间复杂度对程序的执行效率影响最大，在Python中可以通过选择合适的数据结构来优化时间复杂度，如list和set查找某一个元素的时间复杂度分别是O(n)和O(1)。不同的场景有不同的优化方式，总得来说，一般有分治，分支界限，贪心，动态规划等思想。 减少冗余数据 如用上三角或下三角的方式去保存一个大
python加速运算_python 加速运算
weixin_39653622的博客
12-04 517
测试代码运行的时间import timetic = time.time()much_job = [x**2 for x in range(1, 1000000, 3)]toc = time.time()print('userd: {:.5f}s'.format(toc-tic))# userd: 0.06204s一、加速查找1. 用set而非listimport timedata = [i**2+...
python音频加速_python - 使用python减慢口头音频（不是来自mp3 / wav） - 堆栈内存溢出...
weixin_36487107的博客
01-13 726
如评论中所述，只需增加或减少采样频率/帧频，就可以加快音频的速度。 尽管如果您打算通过麦克风实时进行录制，则想法之一是以几秒钟的块进行录制，播放慢下来的音频，然后再次进行录制。这是一个使用sounddevice的示例，这基本上是我在这里回答的略微修改。 我们循环录制音频4秒钟，共3次，然后立即以帧频偏移量播放(大于1表示加速，小于1表示减速)。 在开始新块之前，音频播放完成需要增加1秒的延迟...
常用的python gpu加速方法
花生日记
05-10 6414
例如，如果我们需要对大量的数据进行分析和计算，并且需要对模型进行优化和训练，那么我们可以使用 Python提供的一些模块来加速这一过程： 在上面的代码中，我们使用了 Python内置的一个函数来对大量的数据进行分析和计算。但是，如果我们使用 gpu提供的其他功能，例如聚类、降维等，则可以避免这些问题。例如，在 Python中，我们可以使用以下语句来实现对数据的插入操作： 对于模型训练，我们可以使用以下语句来进行模型的训练和优化： 当然，在实际的开发中，我们还可以使用其他的内置函数来进行数据处理。
py-sample-speedup:我试图加快python的random.sample方法的速度
05-03
py-sample-speedup 我试图加快python的random.sample方法的速度。 我从cpythons git 获得的原始方法。 def improved_sample(population, k, shuffle=True): population和k使用方法与原始方法类似。 由于算法行为而...
orbitals_speedup
05-18
轨道数 轨道基于Jared Tarbell在其“ ”算法中实现的幼稚优化过程。 在开始与邻居结交朋友之前，节点是以某种或多或少结构化的方式创建的。 逐渐地，节点努力与他们的朋友变得更近，同时与他们尚未结交的节点保持...
python处理声音示例程序
08-26
audio = audio.speedup(2) # 将播放速度提高两倍 # 静音处理 mute_audio = audio.overlay(AudioSegment.silent(duration=audio.duration_seconds)) ``` 此外，Python还可以使用`wave`库来读取和分析WAV文件。例如...
【Python知识地图】音频处理：pydub库使用指南
最新发布
科技改变人类，技术成就未来
08-26 1141
Pydub 是一个用于音频处理的 Python 库，基于 ffmpeg 或 libav 提供的功能。它提供了简单的接口来加载、处理和保存音频文件。本文将详细介绍 Pydub 库的基本用法及其主要功能，并提供一些示例代码。
python 音频 音调
weixin_40435021的博客
07-06 315
Python相关视频讲解：python的or运算赋值用法用python编程Excel有没有用处？011_编程到底好玩在哪？查看python文件_输出py文件_cat_运行python文件_shelPython音频处理与音调调整 在音频处理领域，调整音频的音调是一项常见的技术。通过改变音频的音调，可以使音频更加动感或者...
Python实现基本数据结构---队列操作
爱橙子的OK绷的专栏
04-26 1547
#! /usr/bin/env python #coding=utf-8class Queue(object): def __init__(self,size): self.size=size self.head=-1 #初始化队头 self.tail=-1 #初始化队尾 self.queue=[] def EnQueue
pydub简单介绍
Debatrix的博客
03-01 2万+
pydub是python的高级一个音频处理库，可以让你以一种不那么蠢的方法处理音频。（开发者自己是这么说的，不过个人感觉有时候仍然很蠢。。。。）
python实现LRU
qq_35810838的博客
10-13 2200
参考： https://blog.youkuaiyun.com/yz764127031/article/details/79410571 https://blog.youkuaiyun.com/hjj414/article/details/38503419 https://www.cnblogs.com/break-python/p/5459169.html ''' 方法一 class LRUCache: ...
零基础小白Python入门必看：面向对象之典型魔术方法
python_miao的博客
10-10 187
魔术方法 查看类的魔术方法 class A: pass dir(A) # 可以得到类所有公有成员 复制代码 输出结果如下 ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__le__', '__lt...
声学模型学习笔记（四） dnn speedup
xmdxcsj的专栏
10-08 1777
trainingminibatch一般设为256-1024.太小会导致更新参数频繁，降低GPU的计算效率；太大会导致训练需要更多的训练迭代数。piplined bp将模型按层分割，然后分配到不同的GPU机器上面，实现训练的并行。例如下图 一帧数据依次经过三个GPU的前向计算，然后在依次进行后向传播。图中的时刻： - GPU1处理n的前向计算和n-5的bp计算 - GPU2处理n-1的前向计
最好用的python音频库之一：pydub的中文文档（含API）
热门推荐
一朵蘑菇的疯言疯语
01-29 4万+
pydub 中文文档（含API） 0x00 写在最前 Pydub lets you do stuff to audio in a way that isn’t stupid. pydub 提供了简洁的高层接口，极大的扩展了python处理音频文件的能力，pydub可能不是最强大的Python音频处理库，但绝对是Python最简洁易用的音频库只要，非要说有什么弊端，大概只有高度依赖ffmpeg，...
python面向对象【头歌】
roydon
11-18 7391
任务：给定了一个 Dog 类，类中有 foot、weight 和 height 三个属性。请在类的外部输出这三个属性的值。
how to speed up pandas compute
04-04
There are several ways to speed up pandas computations: 1. Use vectorized operations: Pandas is built on top of NumPy, which is a popular numerical computing library for Python. NumPy provides vectorized operations, which can be used to perform operations on arrays of data. Vectorized operations are faster than using loops to perform the same operations. 2. Use the correct data types: Using the correct data types for your data can significantly speed up computations. For example, using integers instead of floats can reduce the memory usage and speed up arithmetic operations. 3. Use the apply() method wisely: The apply() method can be slow for large datasets. Instead, use vectorized functions or methods wherever possible. 4. Use chunking: If you have a large dataset, you can speed up computations by processing the data in smaller chunks. This can reduce the memory usage and improve performance. 5. Use parallel processing: Pandas supports parallel processing, which can speed up computations on multi-core machines. You can use the Dask library to parallelize Pandas dataframes. 6. Use the right hardware: Using a solid-state drive (SSD) instead of a hard disk drive (HDD) can significantly speed up computations that involve reading and writing data. Similarly, using a computer with a high-end processor and more RAM can improve performance.
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值