F#奇妙游（31）：数据缺失的处理

已于 2023-09-11 09:30:00 修改
阅读量305 收藏
点赞数
文章标签： F# 函数式编程 .NET 开发语言 算法
于 2023-09-09 17:11:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/withstand/article/details/132779805
版权

option

在处理数据时，缺失数据和无效数据是一个常见的问题。在Python中，通常使用None来表示缺失数据。

在F#中，我们可以使用FSharpOption来表示缺失数据。FSharpOption是一个泛型类型，它有两个值：Some和None。Some表示一个值，而None表示一个缺失的值。FSharpOption的定义如下：

type FSharpOption<T> =
    | None
    | Some of T

从ADT的组合数来分析，这个和类型的组合数是 1 + C T 1+C_T 1+CT​ 。在通常的情况下，我们在F#中都把这个写作option<T>，或者T option。而构造一个option<T>的值，我们可以使用Some和None这两个构造器，例如：

let x = Some 1
let y = None

一般的，我们可以使用match表达式来处理option<T>的值，例如：

let z = 
    match x with
    | Some x -> x
    | None -> 0

如果是定义输入参数是option<T>类型的函数，还有一个语法糖：

let f (x: int option) =
    match x with
    | Some x -> x
    | None -> 0

可以写成：

let f = 
    function
    | Some x -> x
    | None -> 0

后面这个情况非常适用于配合|>操作符使用，例如：

let x = Some 1
x |> (function Some x -> x | None -> 0)

在对一个T option的集合类型时，我们就可以很方便的用上面的语法糖来构造一些小的判定函数。

FSharp.Core.Option

而在实际的工作中，上面的这些都是不需要的，因为F#已经提供了FSharp.Core.Option模块来处理option<T>类型的值。下表按照ADT分析的结果，列出了FSharp.Core.Option模块中的函数：

Function or valueADTDescription
isSome option('a option -> bool)返回 true， 如果对象不是None.
isNone option('a option -> bool)返回 true， 如果对象是None.
count option('a option -> int)count inp 展开成为 match inp with None -> 0 \| Some _ -> 1.
get option('a option -> 'a)得到option所包含的值.
toObj value('a option -> 'a)转换成一个对象.
toNullable option('a option -> System.Nullable<'a>)转换成Nullable值.
toArray option('a option -> 'a array)转换成一个数组，长度是0或者1.
toList option('a option -> 'a list)转换成一个列表，长度是0或者1.
ofObj value('a -> 'a option)转换成一个option，空值为None.
ofNullable value(System.Nullable<'a> -> 'a option)转换成一个option，null变为None.
flatten option('a option option -> 'a option)flatten inp 展开成为 match inp with None -> None\| Some x -> x
contains value option('a -> 'a option -> bool)如果option为Some value返回true否则返回false.
forall predicate option(('a -> bool) -> 'a option -> bool)forall p inp 展开成为 match inp with None -> true\| Some x -> p x.
exists predicate option(('a -> bool) -> 'a option -> bool)exists p inp 展开成为 match inp with None -> false\| Some x -> p x.
defaultValue value option('a -> 'a option -> 'a)如果对象Some value得到对应value, 否则返回默认值.
defaultWith defThunk option((unit -> 'a) -> 'a option -> 'a)如果对象Some value得到对应value, 否则求值defThunk并返回结果.
iter action option(('a -> unit) -> 'a option -> unit)iter f inp 展开成为 match inp with None -> ()\| Some x -> f x.
orElse ifNone option('a option -> 'a option -> 'a option)如果option为Some value直接返回, 否则返回ifNone.
bind binder option(('a -> 'b option) -> 'a option -> 'b option)bind f inp 展开成为 match inp with None -> None \| Some x -> f x
filter predicate option(('a -> bool) -> 'a option -> 'a option)filter f inp 展开成为 match inp with None -> None\| Some x -> if f x then Some x else None.
map mapping option(('a -> 'b) -> 'a option -> 'b option)map f inp 展开成为 match inp with None -> None\| Some x -> Some (f x).
orElseWith ifNoneThunk option((unit -> 'a option) -> 'a option -> 'a option)如果option为Some value直接返回, 否则求值ifNoneThunk并返回结果.
fold folder state option(('a -> 'b -> 'a) -> 'a -> 'b option -> 'a)fold f s inp 展开成为 match inp with None -> s\| Some x -> f s x.
foldBack folder option state(('a -> 'b -> 'b) -> 'a option -> 'b -> 'b)fold f inp s 展开成为 match inp with None -> s\| Some x -> f x s.
map2 mapping option1 option2(('a -> 'b -> 'c) -> 'a option -> 'b option -> 'c option)map f option1 option2 展开成为 match option1, option2 with Some x, Some y -> Some (f x y)\| _ -> None.
map3 mapping option1 option2 option3(('a -> 'b -> 'c -> 'd) -> 'a option -> 'b option -> 'c option -> 'd option)map f option1 option2 option3 展开成为 match option1, option2, option3 with Some x, Some y, Some z -> Some (f x y z) \| _ -> None.

其实这许多的功能，只需要略微看看源代码就知道，基本上就是替换为对应match表达式的代码。例如isSome的源代码如下：

let inline isSome option =
    match option with
    | None -> false
    | Some _ -> true

这样的好处是，可以对一个option<T>的集合类型使用map和filter等函数，例如：

let x = [Some 1; None; Some 2]
x |> List.filter Option.isSome

便于写出非常简洁的代码。

结论

  1. 在F#中，使用option<T>来表示缺失数据；
  2. 使用FSharp.Core.Option模块来处理option<T>类型的值；
  3. 使用|>操作符配合function语法糖来处理option<T>类型的值。

Option源代码

namespace Microsoft.FSharp.Core

open Microsoft.FSharp.Core.Operators

[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module Option =

    [<CompiledName("GetValue")>]
    let get option =
        match option with
        | None -> invalidArg "option" (SR.GetString(SR.optionValueWasNone))
        | Some x -> x

    [<CompiledName("IsSome")>]
    let inline isSome option =
        match option with
        | None -> false
        | Some _ -> true

    [<CompiledName("IsNone")>]
    let inline isNone option =
        match option with
        | None -> true
        | Some _ -> false

    [<CompiledName("DefaultValue")>]
    let inline defaultValue value option =
        match option with
        | None -> value
        | Some v -> v

    [<CompiledName("DefaultWith")>]
    let inline defaultWith ([<InlineIfLambda>] defThunk) option =
        match option with
        | None -> defThunk ()
        | Some v -> v

    [<CompiledName("OrElse")>]
    let inline orElse ifNone option =
        match option with
        | None -> ifNone
        | Some _ -> option

    [<CompiledName("OrElseWith")>]
    let inline orElseWith ([<InlineIfLambda>] ifNoneThunk) option =
        match option with
        | None -> ifNoneThunk ()
        | Some _ -> option

    [<CompiledName("Count")>]
    let inline count option =
        match option with
        | None -> 0
        | Some _ -> 1

    [<CompiledName("Fold")>]
    let inline fold<'T, 'State> ([<InlineIfLambda>] folder) (state: 'State) (option: 'T option) =
        match option with
        | None -> state
        | Some x -> folder state x

    [<CompiledName("FoldBack")>]
    let inline foldBack<'T, 'State> ([<InlineIfLambda>] folder) (option: option<'T>) (state: 'State) =
        match option with
        | None -> state
        | Some x -> folder x state

    [<CompiledName("Exists")>]
    let inline exists ([<InlineIfLambda>] predicate) option =
        match option with
        | None -> false
        | Some x -> predicate x

    [<CompiledName("ForAll")>]
    let inline forall ([<InlineIfLambda>] predicate) option =
        match option with
        | None -> true
        | Some x -> predicate x

    [<CompiledName("Contains")>]
    let inline contains value option =
        match option with
        | None -> false
        | Some v -> v = value

    [<CompiledName("Iterate")>]
    let inline iter ([<InlineIfLambda>] action) option =
        match option with
        | None -> ()
        | Some x -> action x

    [<CompiledName("Map")>]
    let inline map ([<InlineIfLambda>] mapping) option =
        match option with
        | None -> None
        | Some x -> Some(mapping x)

    [<CompiledName("Map2")>]
    let inline map2 ([<InlineIfLambda>] mapping) option1 option2 =
        match option1, option2 with
        | Some x, Some y -> Some(mapping x y)
        | _ -> None

    [<CompiledName("Map3")>]
    let inline map3 ([<InlineIfLambda>] mapping) option1 option2 option3 =
        match option1, option2, option3 with
        | Some x, Some y, Some z -> Some(mapping x y z)
        | _ -> None

    [<CompiledName("Bind")>]
    let inline bind ([<InlineIfLambda>] binder) option =
        match option with
        | None -> None
        | Some x -> binder x

    [<CompiledName("Flatten")>]
    let inline flatten option =
        match option with
        | None -> None
        | Some x -> x

    [<CompiledName("Filter")>]
    let inline filter ([<InlineIfLambda>] predicate) option =
        match option with
        | None -> None
        | Some x -> if predicate x then Some x else None

    [<CompiledName("ToArray")>]
    let inline toArray option =
        match option with
        | None -> [||]
        | Some x -> [| x |]

    [<CompiledName("ToList")>]
    let inline toList option =
        match option with
        | None -> []
        | Some x -> [ x ]

    [<CompiledName("ToNullable")>]
    let inline toNullable option =
        match option with
        | None -> System.Nullable()
        | Some v -> System.Nullable(v)

    [<CompiledName("OfNullable")>]
    let inline ofNullable (value: System.Nullable<'T>) =
        if value.HasValue then
            Some value.Value
        else
            None

    [<CompiledName("OfObj")>]
    let inline ofObj value =
        match value with
        | null -> None
        | _ -> Some value

    [<CompiledName("ToObj")>]
    let inline toObj value =
        match value with
        | None -> null
        | Some x -> x

module ValueOption =

    [<CompiledName("GetValue")>]
    let get voption =
        match voption with
        | ValueNone -> invalidArg "option" (SR.GetString(SR.optionValueWasNone))
        | ValueSome x -> x

    [<CompiledName("IsSome")>]
    let inline isSome voption =
        match voption with
        | ValueNone -> false
        | ValueSome _ -> true

    [<CompiledName("IsNone")>]
    let inline isNone voption =
        match voption with
        | ValueNone -> true
        | ValueSome _ -> false

    [<CompiledName("DefaultValue")>]
    let inline defaultValue value voption =
        match voption with
        | ValueNone -> value
        | ValueSome v -> v

    // We're deliberately not using InlineIfLambda, because benchmarked code ends up slightly slower at the time of writing (.NET 8 Preview)
    [<CompiledName("DefaultWith")>]
    let inline defaultWith defThunk voption =
        match voption with
        | ValueNone -> defThunk ()
        | ValueSome v -> v

    [<CompiledName("OrElse")>]
    let inline orElse ifNone voption =
        match voption with
        | ValueNone -> ifNone
        | ValueSome _ -> voption

    [<CompiledName("OrElseWith")>]
    let inline orElseWith ([<InlineIfLambda>] ifNoneThunk) voption =
        match voption with
        | ValueNone -> ifNoneThunk ()
        | ValueSome _ -> voption

    [<CompiledName("Count")>]
    let inline count voption =
        match voption with
        | ValueNone -> 0
        | ValueSome _ -> 1

    [<CompiledName("Fold")>]
    let inline fold<'T, 'State> ([<InlineIfLambda>] folder) (state: 'State) (voption: voption<'T>) =
        match voption with
        | ValueNone -> state
        | ValueSome x -> folder state x

    [<CompiledName("FoldBack")>]
    let inline foldBack<'T, 'State> ([<InlineIfLambda>] folder) (voption: voption<'T>) (state: 'State) =
        match voption with
        | ValueNone -> state
        | ValueSome x -> folder x state

    [<CompiledName("Exists")>]
    let inline exists ([<InlineIfLambda>] predicate) voption =
        match voption with
        | ValueNone -> false
        | ValueSome x -> predicate x

    [<CompiledName("ForAll")>]
    let inline forall ([<InlineIfLambda>] predicate) voption =
        match voption with
        | ValueNone -> true
        | ValueSome x -> predicate x

    [<CompiledName("Contains")>]
    let inline contains value voption =
        match voption with
        | ValueNone -> false
        | ValueSome v -> v = value

    [<CompiledName("Iterate")>]
    let inline iter ([<InlineIfLambda>] action) voption =
        match voption with
        | ValueNone -> ()
        | ValueSome x -> action x

    [<CompiledName("Map")>]
    let inline map ([<InlineIfLambda>] mapping) voption =
        match voption with
        | ValueNone -> ValueNone
        | ValueSome x -> ValueSome(mapping x)

    [<CompiledName("Map2")>]
    let inline map2 ([<InlineIfLambda>] mapping) voption1 voption2 =
        match voption1, voption2 with
        | ValueSome x, ValueSome y -> ValueSome(mapping x y)
        | _ -> ValueNone

    [<CompiledName("Map3")>]
    let inline map3 ([<InlineIfLambda>] mapping) voption1 voption2 voption3 =
        match voption1, voption2, voption3 with
        | ValueSome x, ValueSome y, ValueSome z -> ValueSome(mapping x y z)
        | _ -> ValueNone

    [<CompiledName("Bind")>]
    let inline bind ([<InlineIfLambda>] binder) voption =
        match voption with
        | ValueNone -> ValueNone
        | ValueSome x -> binder x

    [<CompiledName("Flatten")>]
    let inline flatten voption =
        match voption with
        | ValueNone -> ValueNone
        | ValueSome x -> x

    [<CompiledName("Filter")>]
    let inline filter ([<InlineIfLambda>] predicate) voption =
        match voption with
        | ValueNone -> ValueNone
        | ValueSome x ->
            if predicate x then
                ValueSome x
            else
                ValueNone

    [<CompiledName("ToArray")>]
    let inline toArray voption =
        match voption with
        | ValueNone -> [||]
        | ValueSome x -> [| x |]

    [<CompiledName("ToList")>]
    let inline toList voption =
        match voption with
        | ValueNone -> []
        | ValueSome x -> [ x ]

    [<CompiledName("ToNullable")>]
    let inline toNullable voption =
        match voption with
        | ValueNone -> System.Nullable()
        | ValueSome v -> System.Nullable(v)

    [<CompiledName("OfNullable")>]
    let inline ofNullable (value: System.Nullable<'T>) =
        if value.HasValue then
            ValueSome value.Value
        else
            ValueNone

    [<CompiledName("OfObj")>]
    let inline ofObj value =
        match value with
        | null -> ValueNone
        | _ -> ValueSome value

    [<CompiledName("ToObj")>]
    let inline toObj value =
        match value with
        | ValueNone -> null
        | ValueSome x -> x
大福是小强
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
利用数据集，用机器学习模型对股市预测，聊聊看！
**My Coding Family**
07-05 549
ok，以上就是我这期的Bug修复内容啦，如果还想查找更多解决方案，你可以看看我专门收集Bug及提供解决方案的专栏「Bug调优」，都是实战中碰到的Bug，希望对你有所帮助。到此，咱们下期拜拜。码字不易，如果这篇文章对你有所帮助，帮忙给bug菌来个，您的支持就是我坚持写作分享知识点传播技术的最大动力。「猿圈奇妙屋」；以第一手学习bug菌的首发干货，不仅能学习更多技术硬货，还可白嫖最新BAT大厂面试真题、4000G Pdf技术书籍、万份简历/PPT模板、技术文章Markdown文档等海量资料，你想要的我都有。
机器学习系列(3)_逻辑回归应用之Kaggle泰坦尼克之灾
热门推荐
寒小阳
11-12 42万+
f作者： 寒小阳 &&龙心尘 时间：2015年10月。 出处： 声明：版权所有，转载请注明出处，谢谢。手把手机器学习之逻辑回归应用——Kaggle泰坦尼克之灾1.引言先说一句，年末双十一什么的一来，真是非(mang)常(cheng)欢(gou)乐(le)！然后push自己抽出时间来写这篇blog的原因也非常简单： 写完前两篇逻辑回归的介绍和各个角度理解之后，小伙伴们纷纷表示『好像很高级的样纸，
F#奇妙游（32）：缺失数据集合的处理
withstand的博客
09-11 164
假设我们有一个类似于CSV的文件，每行的数据用’,'隔开。文件中有些数据是缺失的，也有些数据没有保存，采用字符串说明。我们省略文件读取的过程，仅仅把第一行数据拿来作为例子。这个数据的解析也挺麻烦的，因为碰到有引号的字符串，我们要把他当做一个单独的单元，考虑到引号内可能会有’,'。我们单独实现一个String的方法，来完成这个功能。这个函数里有两个相互调用的递归函数，定义的语法如下。这样定义才能保证在func1中递归调用func2。识别字符串中的数字可以使用。
《Pandas数据处理》（二）——数据清洗及特征处理
qq_41430142的博客
08-18 3734
【回顾&引言】前面一章的内容大家可以感觉到我们主要是对基础知识做一个梳理，让大家了解数据分析的一些操作，主要做了数据的各个角度的观察。那么在这里，我们主要是做数据分析的流程性学习，主要是包括了数据清洗以及数据的特征处理，数据重构以及数据可视化。这些内容是为数据分析最后的建模和模型评价做一个铺垫。 开始之前，导入numpy、pandas包和数据 #加载所需的库 import numpy as np import pandas as pd #加载数据train.csv data=pd.read_csv(
#第26篇分享：一个文本分类的数据挖掘（python语言：sklearn 朴素贝叶斯NB）（2）
weixin_46008828的博客
03-07 481
②.朴素贝叶斯算法：(朴素贝叶斯分类常用于文本分类，尤其是对于英文等语言来说，分类效果很好；它常用于垃圾文本过滤、情感预测、推荐系统等) ①算法概念：（小数据，以概率计算，假设特征之间独立）朴素贝叶斯（NB）属于生成式模型（即需要计算特征与类的联合概率分布），计算过程非常简单，只是做了一堆计数。NB有一个条件独立性假设，即在类已知的条件下，各个特征之间的分布是独立的。 ②.算法思路：NB 属于娱乐的概率是0，显然是不太好的，所以出现了拉普拉斯平滑系数，就是加上个系数，不让他的值是0：拉普拉斯平滑（模块内
使用python pandas处理excel表格数据
秀秀的奇妙旅行
04-06 5382
首先需要对表格数据进行一些处理，问题有 需要筛选不合格的数据 需要进行两组数据的合并（表头顺序以及内容不完全一致） 需要对总表进行拆分 python 二维数组切片 Python高级特性——多维数组切片（Slice） python中的切片 使用Pandas对Excel进行合并操作（concat、append、merge、join） Python3 pandas库(26) 一次读取多个excel文件并合并 python利用pandas读取Excel文件和筛选处理小案例 python-pandas实现简.
《Python 简易速速上手小册》第9章：数据科学和机器学习入门（2024 最新版）
江帅帅
01-27 797
欢迎来到机器学习的奇妙世界，这是一个充满了数据、算法和预测的地方！在这一节，我们将探索机器学习的基础，并使用 Python 中著名的机器学习库 Scikit-Learn 来进行实战演练。准备好揭开机器学习的神秘面纱了吗？让我们开始这段旅程！
智能决策的艺术：揭秘决策树的奇妙原理与实战应用
weixin_41859354的博客
07-03 1242
我们将使用著名的鸢尾花数据集（Iris Dataset），该数据集包含150个样本，每个样本有4个特征（花萼长度、花萼宽度、花瓣长度和花瓣宽度），目标是根据这些特征预测鸢尾花的种类（Setosa、Versicolor和Virginica）。本文详细介绍了决策树算法的原理，包括决策树的结构、划分标准、生成过程和剪枝方法。通过鸢尾花数据集案例，我们展示了如何使用Python和Scikit-learn构建、评估和可视化决策树模型。决策树是一种直观且易于解释的机器学习算法，适用于各种分类和回归任务。
LearningR-数据处理
weixin_33958366的博客
05-20 258
R自带函数 reshape2data restructuring dplyrdata aggregation tidyr待整理 字符串处理 1. R自带函数 1.1 转置 使用函数t()可对一个矩阵或数据框进行转置，对于数据框，行名将变成变量（列）名。 cars <- mtcars(1:5,1:4) cars t(cars) ...
FsPlot:F# 数据可视化库
07-03
FsPlot 关于 FsPlot 是一个使用 HTML5/JavaScript 的 F# 交互式数据可视化库。 文档 NuGet PM> Install-Package FsPlot 接触
DeepDives:F# 深潜
07-04
5. **序列和序列操作**：F#的序列（seq）类型支持延迟计算，允许处理大量数据而不会一次性加载全部内容，这对大数据处理非常有用。此外，F#还提供了一系列操作符（如`|>`、`map`、`filter`等）来处理序列。 6. **...
FXL:F# eXcel 有效
06-22
FXL，全称为“F# eXcel”，是一款基于F#编程语言的MVVM（Model-View-ViewModel）架构的WPF（Windows Presentation Foundation）应用，专门用于处理Excel数据的交换和操作。这个项目的核心目的是提供一个高效且灵活的...
Learning-fsharp:学习F＃书
05-18
＃学习F＃函数数据结构和算法### F＃入门，探索具有数据结构和算法的函数编程范例 阿德南·马苏德（Adnan Masood）博士。 F＃是一种多范式编程语言，它包含面向对象，命令式和功能性编程语言属性。 F＃功能编程...
php开发的在线客服系统，全开源无加密，支持微信客服对接
最新发布
jiyc2008的博客
08-01 2797
介绍： 在网络上找了一圈“客服系统源码”，配置测试了一下，发现所有的“客服系统源码”基本都不能正常的使用。 所以更新了这份新源码，亲测是可以正常使用的，因此顺便也给大家简单分享一下！好东西，可以直接使用，可以二开。 环境要求：apache/nginx + php>=5.6+mysql>=5.6（必须是php7.3以下的版本，不支持php7.4。在php7.4下部分功能异常，没法完整使用） 其它要求： 1、取消防跨站攻击(open_basedir前面不要打勾)，根目录绑定public，伪
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
执梗的博客
07-23 2141
蓝桥杯 2024 年第十五届省赛真题 —— 最大异或结点
2024秋招算法
weixin_43364551的博客
07-22 2360
根据代码随想录和力扣进行算法训练的笔记
嵌入式C++、ROS 、OpenCV、SLAM 算法和路径规划算法：自主导航的移动机器人流程设计（代码示例）
嵌入式极客小张
07-25 1521
在科技迅速发展的背景下，嵌入式自主移动机器人作为一个具有广泛应用前景的研究领域，吸引了众多开发者的关注。本文详细介绍了一个嵌入式自主移动机器人项目，重点阐述了其硬件与软件系统设计及代码实现。硬件部分采用ESP32、Raspberry Pi和Arduino作为嵌入式控制器，结合激光雷达、超声波传感器和摄像头等多种传感器，实现环境感知和数据采集。软件系统基于Raspberry Pi OS，主要使用Python进行高层逻辑控制，C/C++用于实时任务处理，并利用ROS框架支持机器人开发。
C语言100道基础拔高题（1）
2303_78660417的博客
07-23 3115
最后按最小值，中间值，最大值的顺序打印即可。解题思路：首先输出由这几个数字所组成的所有三位数，接着再设置条件，使其输出的三位数不重复，下面我们来看下源代码。值得注意的是：所以题目的代码都是作者自行编写，如有更好的思路或者代码的优化，还请指出更正。解题思路：首先找到能整除这个正整数的最小正数，接着重置循环初值，让它继续查找最小正数，最后将得到的所有正数放到一个数组里，最后设置好格式之后循环打印出来。解题思路：首先确定好区间，接着判断是否是素数，素数就是一个大于1的数，除了1和它本身之外，不能被其他数整除。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大福是小强

除非你钱多烧得慌……

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值