Polars使用指南（二）

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

在上一篇文章中，我们介绍了Polars的优势和Polars.Series的常用API，本篇文章我们继续介绍Polars.Series的扩展API。

对于一些特殊的数据类型，如 pl.Array、list、str 等，Polars.Series 提供了基于属性的直接操作API，如果可以使用下述API实现的功能，应尽量避免使用 map_elements，因为效率更高。

1. Series.arr

Series中的元素可能不是简单数据类型，而是等长的数组，此时则可以直接使用polars内置的arr属性方法。

需要注意使用Series.arr的前提是Series的元素类型必须是pl.Array，而pl.Array需要指定长度，所以该系列的Series每个元素的长度都是固定的，如果Array不能满足需求，则可以使用第2节的Series.list。

import polars as pl

s = pl.Series("a", [[1, 2], [4, 3]], dtype=pl.Array(pl.Int64, 2))
s.arr.max()
# 结果
[
    2
    4
]
s.arr.min()
s.arr.sum()
# 把array转为list
s.arr.to_list()
# 去重，maintain_order 表示是否保持原始顺序，True 一般会降低性能
Series.arr.unique(*, maintain_order: bool = False) → Series
# 与和或
s.arr.all()
s.arr.any()

2. Series.list

list是比arr更灵活的结构，尤其是不再受限于固定长度。

import polars as pl

s = pl.Series(
    [[True, True], [False, True], [False, False], [None], [], None],
    dtype=pl.List(pl.Boolean),
)
s.list.all()
# 结果
[
    true
    false
    false
    true
    true
    null
]
s.list.any()
# 删除所有list中的空值，注意不是删除整个list元素，只删除每个list中的空值
s.list.drop_nulls()
# 每个list的最大/最小值
s.list.max()
s.list.min()
# 每个list的最大/最小值索引
s.list.arg_max()
s.list.arg_min()
# 每个list的和/均值
Series.list.sum() → Series
Series.list.mean() → Series
# 每个list元素个数，null也计算在内
Series.list.len() → Series
# 每个list合并其他list或者其他Series对应数据
Series.list.concat(other: list[Series] | Series | list[Any])
# 每个list第一个/最后一个值
Series.list.first() → Series
Series.list.last() → Series
# 每个list前/后n个值
Series.list.head(n: int | Expr = 5) → Series
Series.list.tail(n: int | Expr = 5) → Series
# 按索引取每个list中值
Series.list.get(index: int | Series | list[int]) → Series
# 按索引取每个list中值
Series.list.gather(
	indices: Series | list[int] | list[list[int]],
	*,
	null_on_oob: bool = False,
) → Series

# 压扁
s = pl.Series("a", [[1, 2, 3], [4, 5, 6]])
s.list.explode()  # 结果[1 2 3 4 5 6]
# 每个list内的偏差，null_behavior：{‘ignore’, ‘drop’}
Series.list.diff(n: int = 1, null_behavior: NullBehavior = 'ignore') 
# 每个list内元素值的频率
Series.list.count_matches(
	element: float | str | bool | int | date | datetime | time | Expr,
)
# 每个list是否包含给定值
Series.list.contains(item: float | str | bool | int | date | datetime)
# 翻转每个list
Series.list.reverse() → Series
# 每个list中元素听过分隔符拼接为一个值（每行只有一个str值），list中元素必须为字符串
Series.list.join(separator: IntoExpr) → Series
# 每个list去重
Series.list.unique(*, maintain_order: bool = False) → Series
# 每个list排序
Series.list.sort(*, descending: bool = False) → Series
# 每个list做切片，offset：起始位置，length：长度
Series.list.slice(offset: int | Expr, length: int | Expr | None = None) → Series
# 每个list平移
Series.list.shift(n: int | IntoExprColumn = 1) → Series

# 两个list类型Series每行的并集
Series.list.set_union(other: Series) → Series
# 两个list类型Series每行的交集
Series.list.set_intersection(other: Series) → Series
# 两个list类型Series每行的差集
Series.list.set_difference(other: Series) → Series

# 执行任意表达式，用于实现复杂需求
Series.list.eval(expr: Expr, *, parallel: bool = False) → Series
df = pl.DataFrame({"a": [1, 8, 3], "b": [4, 5, 2]})
df.with_columns(
    pl.concat_list(["a", "b"]).list.eval(pl.element().rank()).alias("rank")
)
# 结果
┌─────┬─────┬────────────┐
│ a   ┆ b   ┆ rank       │
│ --- ┆ --- ┆ ---        │
│ i64 ┆ i64 ┆ list[f64]  │
╞═════╪═════╪════════════╡
│ 1   ┆ 4   ┆ [1.0, 2.0] │
│ 8   ┆ 5   ┆ [2.0, 1.0] │
│ 3   ┆ 2   ┆ [2.0, 1.0] │
└─────┴─────┴────────────┘

# list转arr，width：arr宽度，需保证每个list等长
Series.list.to_array(width: int) → Series

3. Series.str

str 类型数据也是最常用的数据操作类型。

# 把Series中的所有str类型元素通过delimiter拼接为一个值，返回值是只有一个元素的Series；strict 如果异常，是引发异常，还是返回空值
Series.str.concat(delimiter: str = '-', *, ignore_nulls: bool = True) → Series
# 是否包含指定正则表达式，返回布尔类型，literal：True表示按正则解析pattern，False表示按纯字符串解析pattern，
Series.str.contains(
	pattern: str | Expr,
	*,
	literal: bool = False,
	strict: bool = True,
) → Series
s = pl.Series("s", ["AAA", "aAa", "aaa"])
# 不区分大小写，(?iLmsuxU) 语法
s.str.contains("(?i)AA").to_list()

# 包含patterns中任一值则返回True
Series.str.contains_any(
	patterns: Series | list[str],
	*,
	ascii_case_insensitive: bool = False,
) → Series

# 是否以指定字符串开头
Series.str.starts_with(prefix: str | Expr) → Series
# 是否以指定字符串结尾
Series.str.ends_with(suffix: str | Expr) → Series

# 字符串压扁
Series.str.explode() → Series
s = pl.Series("a", ["foo", "bar"])
s.str.explode()  # 结果 ["f" "o" "o" "b" "a" "r"]

# 根据pattern正则提取要素
Series.str.extract(pattern: str, group_index: int = 1) → Series
# 根据pattern正则提取所有匹配到的要素，返回是list类型的Series
Series.str.extract_all(pattern: str | Series) → Series
# 根据pattern正则提取所有group
Series.str.extract_groups(pattern: str) → Series

# 按照json解析元素
Series.str.json_decode(
	dtype: PolarsDataType | None = None,
	infer_schema_length: int | None = 100,
) → Series
# 使用提供的JSONPath表达式提取json字符串的第一个匹配。如果遇到无效的json字符串，抛出错误。所有返回值将被强制转换为String，而不管原始值是什么。
Series.str.json_path_match(json_path: str) → Series
df = pl.DataFrame(
    {"json_val": ['{"a":"1"}', None, '{"a":2}', '{"a":2.1}', '{"a":true}']}
)
df.select(pl.col("json_val").str.json_path_match("$.a"))[:, 0]
# 结果
[
    "1"
    null
    "2"
    "2.1"
    "true"
]

# 每个str的字符长度
Series.str.len_chars() → Series
# 每个str的字节长度，性能比len_chars高
Series.str.len_bytes() → Series

# 根据给定字符从左边填充字符串到指定长度,长度等于或大于此值的字符串将按原样返回。
Series.str.pad_start(length: int, fill_char: str = ' ') → Series
# 根据给定字符从右边填充字符串到指定长度,长度等于或大于此值的字符串将按原样返回。
Series.str.pad_end(length: int, fill_char: str = ' ') → Series

# 字符串替换，literal默认False，表示按照正则解析pattern，此时n只能为；如果literal为True，则表示按纯字符串解析pattern，此时n可以大于1。n表示要替换的数量
Series.str.replace(
	pattern: str,
	value: str,
	*,
	literal: bool = False,
	n: int = 1,
) → Series
# 替换所有匹配的字符串
Series.str.replace_all(pattern: str, value: str, *, literal: bool = False) → Series
# 多对多替换，patterns和replace_with一一对应
Series.str.replace_many(
	patterns: Series | list[str],
	replace_with: Series | list[str] | str,
	*,
	ascii_case_insensitive: bool = False,
) → Series

# 翻转字符串
Series.str.reverse() → Series
# 字符串切片，offset为负表示最后n位
Series.str.slice(offset: int, length: int | None = None) → Series
# 分隔字符串
Series.str.split(by: IntoExpr, *, inclusive: bool = False) → Series
# 删除开头和结尾的指定字符集，默认是删除空格
Series.str.strip_chars(characters: IntoExprColumn | None = None) → Series
# 删除开头的指定字符集，默认是删除空格
Series.str.strip_chars_start(characters: IntoExprColumn | None = None) → Series
# 删除结尾的指定字符集，默认是删除空格
Series.str.strip_chars_end(characters: IntoExprColumn | None = None) → Series
# 删除指定字符串前缀，同strip_chars_start
Series.str.strip_prefix(prefix: IntoExpr) → Series
# 删除指定字符串后缀，同strip_chars_end
Series.str.strip_suffix(suffix: IntoExpr) → Series

# 字符串转为日期，dtype要转换的类型 Date、 Datetime、 or Time；format如果没指定，则程序自己尝试解析（不建议）；
# strict：如果转换失败，是否引发异常；
# ambiguous，如果程序解析发现结果不确定（二义性等），应该如何处理，{'raise' (default): 引发异常，'earliest': 使用最早的日期时间，'latest'：使用最晚的日期时间}
Series.str.strptime(
	dtype: PolarsTemporalType,
	format: str | None = None,
	*,
	strict: bool = True,
	exact: bool = True,
	cache: bool = True,
	ambiguous: Ambiguous | Series = 'raise',
) → Series
# to_date
Series.str.to_date(
	format: str | None = None,
	*,
	strict: bool = True,
	exact: bool = True,
	cache: bool = True,
) → Series
# to_datetime，time_unit：{None, 'us', 'ns', 'ms'}
Series.str.to_datetime(
	format: str | None = None,
	*,
	time_unit: TimeUnit | None = None,
	time_zone: str | None = None,
	strict: bool = True,
	exact: bool = True,
	cache: bool = True,
	ambiguous: Ambiguous | Series = 'raise',
) → Series
s = pl.Series(["2020-01-01 01:00Z", "2020-01-01 02:00Z"])
s.str.to_datetime("%Y-%m-%d %H:%M%#z")
# to_time
Series.str.to_time(
	format: str | None = None,
	*,
	strict: bool = True,
	cache: bool = True,
) → Series

# 根据指定进制转换为整型
Series.str.to_integer(*, base: int = 10, strict: bool = True) → Series
s = pl.Series("bin", ["110", "101", "010", "invalid"])
s.str.to_integer(base=2, strict=False)
# 转换为decimal，inference_length 确定精度和有效位数
Series.str.to_decimal(inference_length: int = 100) → Series
s = pl.Series(
    ["40.12", "3420.13", "120134.19", "3212.98", "12.90", "143.09", "143.9"]
)
s.str.to_decimal()
# 结果
[
    40.12
    3420.13
    120134.19
    3212.98
    12.90
    143.09
    143.90
]
# 转小写
Series.str.to_lowercase() → Series
# 转大写
Series.str.to_uppercase() → Series
# 将句子每个单词首字母改为大写，其它字母小写
Series.str.to_titlecase() → Series
# 对数字类型字符串前面填充0到指定长度，如果前缀是-（负数），则在-后填充。使用时，需要先把数值类型转为str，然后调用
Series.str.zfill(length: int) → Series
s = pl.Series([-1, 123, 999999, None])
s.cast(pl.String).str.zfill(4)

4. Series.dt

时间类型Series API。除下面列出API外，Series.dt 也支持分桶、时区转换等操作，具体可参考官方文档。

# 组合两个日期，如果s有时间字段，则使用time替换s的时间字段；若s无时间字段（date类型），则把time添加为时间属性
Series.dt.combine(time: dt.time | Series, time_unit: TimeUnit = 'us') → Expr

# 提取date属性（结果是polars.Date类型的Series）
Series.dt.date() → Series
# 提取datetime属性（结果是polars.Datetime类型的Series）
Series.dt.datetime() → Series
# 提取time属性（结果是polars.Time类型的Series）
Series.dt.time() → Series
# 提取年属性
Series.dt.year() → Series
# 提取季节属性
Series.dt.quarter() → Series
# 提取month属性
Series.dt.month() → Series
# 提取week属性，一年中的第几周
Series.dt.week() → Series
# 提取weekday属性，一周第几天，范围1~7，星期一为1，星期天为7
Series.dt.weekday() → Series
# 提取day属性（结果是polars.Int8类型的Series）
Series.dt.day() → Series
# 提取hour属性
Series.dt.hour() → Series
# 提取minute属性
Series.dt.minute() → Series
# 提取second属性，如果fractional为True，则返回小数（包含秒、毫秒等）
Series.dt.second(*, fractional: bool = False) → Series
# 提取毫秒属性
Series.dt.millisecond() → Series
# 提取微秒属性
Series.dt.microsecond() → Series
# 提取纳秒属性
Series.dt.nanosecond() → Series
# 返回给定时间的时间戳，time_unit 表示时间戳单位
Series.dt.timestamp(time_unit: TimeUnit = 'us') → Series
# 判断年份是否为闰年
Series.dt.is_leap_year() → Series

# Series的最大时间，返回一个标量
Series.dt.max() → dt.date | dt.datetime | dt.timedelta | None
# Series的最小时间，返回一个标量
Series.dt.min() → dt.date | dt.datetime | dt.timedelta | None
# 平均时间
Series.dt.mean() → dt.date | dt.datetime | None
# 中位数时间
Series.dt.mean() → dt.date | dt.datetime | None

# 重置日期到每月的第一天（其他不变）
Series.dt.month_start() → Series
# 重置日期到每月的最后一天（其他不变）
Series.dt.month_end() → Series

# 对时间加减，by形式参考注1
Series.dt.offset_by(by: str | Expr) → Series

# 格式化时间
Series.dt.strftime(format: str) → Series
Series.dt.to_string(format: str) → Series

# 从 Duration 类型中解析总天数
Series.dt.total_days() → Series

from datetime import datetime
date = pl.datetime_range(
    datetime(2020, 3, 1), datetime(2020, 5, 1), "1mo", eager=True
).alias("datetime")
date.diff().dt.total_days()
# 下面同上
Series.dt.total_hours() → Series
Series.dt.total_microseconds() → Series
Series.dt.total_milliseconds() → Series
Series.dt.total_minutes() → Series
Series.dt.total_nanoseconds() → Series
Series.dt.total_seconds() → Series

注1：Series.dt.offset_by，by参数形式，以下格式字符串

  • 1ns (1 nanosecond)
  • 1us (1 microsecond)
  • 1ms (1 millisecond)
  • 1s (1 second)
  • 1m (1 minute)
  • 1h (1 hour)
  • 1d (1 calendar day)
  • 1w (1 calendar week)
  • 1mo (1 calendar month)
  • 1q (1 calendar quarter)
  • 1y (1 calendar year)
  • 1i (1 index count)
大白兔黑又黑
关注
  • 10
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
keys-request-key.rar_POLARIS
09-24
文件可能包含密钥的生成指南、密钥交换协议或者实际密钥的明文或密文形式。 综合以上分析，我们可以推测这个压缩包的内容是在为Polaris平台进行系统部署或更新时所需的组件。`board-polaris.c`用于确保设备的硬件...
Polars，详解DataFrame高性能处理工具~
机器学习算法与Python学习
01-03 389
点击机器学习算法与Python学习，选择加星标精彩内容不迷路Polars是一个用于操作结构化数据的高性能DataFrame库。其核心部分是用Rust编写的，但该库也提供了Python接口。它的主要特点包括：快速: Polars是从零开始编写的，紧密与机器结合，没有外部依赖。I/O: 对所有常见数据存储层提供一流支持：本地、云存储和数据库。易于使用: 以原始意图编写查询。Polars 在内部会使...
从Pandas快速切换到Polars ：数据的ETL和查询
deephub
04-20 5246
对于我们日常的数据清理、预处理和分析方面的大多数任务，Pandas已经绰绰有余。但是当数据量变得非常大时，它的性能开始下降。我们以前的两篇文章来测试Pandas 1.5.3、polar和Pandas 2.0.0之间的性能了，Polars 正好可以解决大数据量是处理的问题，所以本文将介绍如何将日常的数据ETL和查询过滤的Pandas转换成polars。Polars是一个用于Rust和Python的DataFrame库。Extract, Transform, and Load (ETL)的过程是怎样的:“提取、
polars学习-03 数据类型转换
最新发布
DataShare
05-13 452
polars学习系列文章，第3篇 数据类型转换。该系列文章会分享到github，大家可以去下载jupyter文件仓库地址：https://github.com/DataShare-duo/polars_learn。
比起 Pandas, 你更需要 Polars：详细指南
一览无遗
12-28 3849
在数据分析领域，Python 由于其多功能性和广泛的库生态系统而成为一种流行的语言。数据处理和分析在提取见解和做出明智决策方面发挥着至关重要的作用。然而，随着数据集的规模和复杂性不断增长，对高性能解决方案的需求变得至关重要。有效地处理大型数据集需要能够提供快速计算和优化操作的工具。这就是 Polars 出现的原因。Polars 是一个强大的开源库，专为 Python 中的高性能数据操作和分析而设计。
又一款数据分析神器：Polars 真的很强大
Python数据挖掘
04-23 6832
相信对于不少的数据分析从业者来说呢，用的比较多的是Pandas以及SQL这两种工具，Pandas不但能够对数据集进行清理与分析，并且还能够绘制各种各样的炫酷的图表，但是遇到数据集很大的时候要是还使用Pandas来处理显然有点力不从心。 今天我就来介绍另外一个数据处理与分析工具，叫做Polars，它在数据处理的速度上更快，当然里面还包括两种API，一种是Eager API，另一种则是Lazy API，其中Eager API和Pandas的使用类似，语法类似差不太多，立即执行就能产生结果。喜欢本文记得收藏、关注
Polars 速度极快的数据处理第三方模块
Python实用宝典网
01-04 1592
Polars 是一个速度极快的 DataFrames 库。它拥有以下特性：1.多线程2.强大的表达式API3.查询优化下面给大家简单介绍一下这个模块的使用方式。1.准备开始之前，你要确保Python和pip已经成功安装在电脑上，如果没有，可以访问这篇文章：超详细Python安装指南进行安装。(可选1)如果你用Python的目的是数据分析，可以直接安装Anaconda：Python数据分析与挖掘...
Python polars库：高性能数据操作的利器
涛哥聊Python
12-13 1182
在本文中，探讨了Python的polars库，从数据的创建与加载、基本操作、聚合统计到合并连接等多个方面展示了其强大功能。通过清晰的示例代码，全面了解polars在数据处理领域的应用。这个库不仅提供了简便的数据操作接口，而且在处理大规模数据时表现卓越，通过性能优化进一步提高了数据处理效率。介绍了polars的条件表达式与过滤、数据类型转换与处理，以及对时间序列数据的灵活支持。此外，通过可视化示例，展示了polars与其他数据可视化库结合的能力，使得数据分析结果更加生动直观。
xmljava系统源码-Polaris::spouting_whale:NepxionPolarisisanenterpriselevelcloudnativemicros
06-06
Polaris【北极星】企业级云原生微服务框架指南示例源码。请访问Gitee镜像获得最佳体验 Discovery【探索】微服务企业级解决方案 ① Discovery【探索】微服务企业级解决方案文档 ② Discovery【探索】微服务企业级解决...
Polaris UI工具包素材.zip
05-18
Polaris UI工具包中包含了大量的界面元素，如按钮、表单、导航栏、模态框等，这些预设的组件遵循一致的设计原则，易于理解和使用。设计师可以根据项目需求，快速选择合适的元素，减少从零开始设计的时间，同时保证了...
PyPI 官网下载 | polars-0.7.9-cp36-abi3-macosx_10_7_x86_64.whl
02-09
资源来自pypi官网，解压后可用。 资源全名：polars-0.7.9-cp36-abi3-macosx_10_7_x86_64.whl
Fairwinds Polaris:Kubernetes的配置验证和策略执行-开源
05-26
`README.md`文件则是项目的基本介绍和使用指南，通常包含安装步骤、示例用法和贡献指南等内容。`polaris`可能是Polaris的源代码或可执行文件，用户可以通过它来运行配置检查。 总而言之，Fairwinds Polaris是一款...
polaris_view_helpers:用于Shopify Polaris的Rails视图助手
05-11
Polaris是Shopify提供的一套设计系统，它包含了组件、样式和交互指南，帮助开发者构建一致、易于使用的 Shopify 应用。 **Rails视图助手**是Rails框架中的一个特性，它提供了一系列的方法，用于在视图模板中方便地...
Rust机器学习之Polars
略懂……略懂……
11-17 3235
本文将带领大家学习Polars的基础用法，通过数据加载 --> 数据探索 --> 数据清洗 --> 数据操作一整个完整数据处理闭环，让大家学会如何用Polars代替Pandas进行数据处理。
基于中文在线文档的Polars工具介绍
林景的博客
05-21 2394
Polars是一个能够提取（Extract）、转换（Transform）与加载（Load）大规模数据集的工具（快速多线程、单指令多数据流、延迟/即时执行、查询优化、混合流等）。根据官方开发人员的Benchmark结果，Polars版本号为0.8.8时，能够在143s左右导入维度在1,000,000,000*9左右，内存为50GB的数据集。与此同时，Pandas在1.2.2版本导入同样的数据集会出现out of memory的报错。
Polars库的常见用法总结
weixin_43837522的博客
10-19 1276
以上只是Polars库的一些基本用法，Polars还提供了更多的功能和操作，如窗口函数、数据透视表、数据合并等。您可以查阅Polars的官方文档以获取更详细的信息和示例。这只是Polars库的一些常见用法，Polars还提供了更多的功能和操作，如数据合并、数据透视表、窗口函数等。您可以查阅Polars的官方文档以获取更详细的信息和示例。Polars是一个基于Rust语言的数据操作和分析库，专为大型数据集和高性能计算而设计。它提供了类似于pandas的API，但在性能方面更加强大。
Polars
majiayu000的博客
04-07 426
Polars是基于Rust写的一个速度很快的DataFrame库。APIPolars拥有C、C++的性能，并且完全控制查询引擎的性能关键部分。PolarsPolars还可以控制IO，允许它保存冗余副本并将和predicates降低到扫描级别。Polars从头开始编写，旨在并行化DataFrame上的查询。Polars拥有lazy和semi-lazy模式。在lazy模式，我们能够对整个查询做优化，进一步提升性能和内存压力。
python中Polars库详解
m0_68678046的博客
04-22 3237
polars库详解
python PIL/cv2/base64相互转换
热门推荐
haveanybody的博客
01-16 1万+
       PIL和cv2是python中两个常用的图像处理库，PIL一般是anaconda自带的，cv2是opencv的python版本。base64在网络传输图片的时候经常用到。 ##PIL读取、保存图片方法 from PIL import Image img = Image.open(img_path) img.save(img_path2) ##cv2读取、保存图片方法 impo...
linux支持Polaris
06-09
是的，Linux系统支持Polaris架构的显卡。AMD在Linux上提供了一系列的驱动程序来支持他们的显卡产品。对于Polaris架构的显卡，AMDGPU和Radeon驱动都支持。 AMDGPU驱动是AMD官方推出的驱动程序，它是开源的，并且已经被纳入到Linux内核中。AMDGPU驱动支持所有AMD显卡，包括Polaris架构的显卡。AMDGPU驱动提供了OpenGL、Vulkan和OpenCL等API的支持。 Radeon驱动是Linux内核自带的驱动程序，同样支持Polaris架构的显卡。Radeon驱动提供了基本的2D/3D加速和视频解码功能，但在性能和功能方面不如AMDGPU驱动。 需要注意的是，如果您使用的是最新的Polaris架构的显卡，建议使用AMDGPU驱动，因为它提供了更好的性能和功能支持。如果您使用的是旧的Polaris架构的显卡，您可能需要使用Radeon驱动或者AMD官方提供的闭源驱动（如AMDGPU-PRO）。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值