F#奇妙游(31):数据缺失的处理

这篇具有很好参考价值的文章主要介绍了F#奇妙游(31):数据缺失的处理。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

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>的值,我们可以使用SomeNone这两个构造器,例如:

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 value ADT Description
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>的集合类型使用mapfilter等函数,例如:

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

便于写出非常简洁的代码。文章来源地址https://www.toymoban.com/news/detail-702716.html

结论

  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

到了这里,关于F#奇妙游(31):数据缺失的处理的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • VB.net:VB.net编程语言学习之ADO.net基本名称空间与类的简介、案例应用(实现与SQL数据库编程案例)之详细攻略

    VB.net:VB.net编程语言学习之ADO.net基本名称空间与类的简介、案例应用(实现与SQL数据库编程案例)之详细攻略 目录 ADO.net基本名称空间与类 1、ADO.net六个基础名称空间 2、ADO.net类

    2024年02月06日
    浏览(47)
  • 数据操作——缺失值处理

    缺失值的处理思路 如果想探究如何处理无效值, 首先要知道无效值从哪来, 从而分析可能产生的无效值有哪些类型, 在分别去看如何处理无效值 什么是缺失值 一个值本身的含义是这个值不存在则称之为缺失值, 也就是说这个值本身代表着缺失, 或者这个值本身无意义, 比如说

    2024年01月22日
    浏览(48)
  • 【数据分析】缺失值处理

    1. 均值填充: 对于 数值型 的特征,采用该特征在已有数据中的 平均值或中位数 来填充缺失值。 2. 众数填充: 对于 类别型 的特征,采用该特征在已有数据中 出现频率最高的类别 来填充缺失值。 3. 插值法: 通过已有的数据,推算出缺失值,常用的插值方法包括线性插值、

    2024年02月11日
    浏览(43)
  • pandas数据清洗——缺失值处理

    使用DataFrame对象的info()方法 原始数据 ​​ 注:NaN为空缺值   查看是否有缺失值    Non-Null Count列显示的是每个索引中不是空缺的个数 使用DataFrame的isnull()方法和notnull()方法 1. isnull()方法——判断是否为空,输出结果为True和False,不为NaN时返回False,为NaN时返回True。     2.

    2024年02月12日
    浏览(55)
  • 数据缺失值的4种处理方法

    缺失值的产生的原因多种多样,主要分为机械原因和人为原因。机械原因是由于机械原因导致的数据收集或保存的失败造成的数据缺失,比如数据存储的失败,存储器损坏,机械故障导致某段时间数据未能收集(对于定时数据采集而言)。 人为原因是由于人的主观失误、历史

    2024年02月04日
    浏览(36)
  • 【机器学习】数据清洗之处理缺失点

    🎈个人主页:甜美的江 🎉欢迎 👍点赞✍评论⭐收藏 🤗收录专栏:机器学习 🤝希望本文对您有所裨益,如有不足之处,欢迎在评论区提出指正,让我们共同学习、交流进步! 引言: 在机器学习领域,数据被广泛认为是驱动模型性能的关键。然而,在真实世界的数据中,缺

    2024年02月20日
    浏览(43)
  • 【数据挖掘 | 数据预处理】缺失值处理 & 重复值处理 & 文本处理 确定不来看看?

    🤵‍♂️ 个人主页: @AI_magician 📡主页地址: 作者简介:CSDN内容合伙人,全栈领域优质创作者。 👨‍💻景愿:旨在于能和更多的热爱计算机的伙伴一起成长!!🐱‍🏍 🙋‍♂️声明:本人目前大学就读于大二,研究兴趣方向人工智能硬件(虽然硬件还没开始玩,但一直

    2024年02月07日
    浏览(72)
  • 缺失数据(missing data)的处理(理论)

    expectation maximization 期望最大化 maximum likelihood 最大似然 case substitution prior knowledge 先验知识 图片来源:https://github.com/dataprofessor/infographic 对原始数据进行缺失值检查。 若无缺失数据,则继续进行其他数据预处理步骤,进而进行机器学习模型的建立。 若有缺失数据,按照数据

    2024年02月06日
    浏览(39)
  • SparkSQL-对数据缺失和异常值进行处理

    缺失数据 准备数据  处理方式 丢弃规则 填充规则 异常数据  方法1:丢弃处理  方法2:替换处理 准备数据  处理方式 1、丢弃/过滤:DataFrame.na.drop() 2、填充:DataFrame.na.fill() 3、替换:DataFrame.na.replace() 丢弃规则 1、any 一行中有任何一个是NaN/null就丢弃 2、all 只有一行中所有

    2024年02月05日
    浏览(59)
  • Hlang--用Python写个编程语言-函数与基本数据结构实现

    okey,经过一段时间的努力,接下来要实现的是函数。当然还有对应的基本数据结构,那么之后的话,我们的工作就开始进一步转换了。 那么在这块我们要实现的有: 函数的定义 String类型的实现 列表类型的实现 实话实话,这个的实现是相当简陋的。不过作为一个小模型,应该

    2024年02月12日
    浏览(58)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包