<p>JQuery 的 CSS 操作没有排队，但是您可以通过以下方法在“ fx”队列中执行:</p> <pre><code>$('#div').delay(1000).queue('fx', function() { $(this).removeClass('error'); }); </code></pre> 从数据框中删除所有值为 NA 的列

退还这个; };

现在你可以做这样的事情-等待1秒钟，添加 .error，等待3秒钟，删除 .error:

试试这个简单的箭头函数:

$('#div').delay(1000).queueAddClass('error').delay(2000).queueRemoveClass('error');

157866 次浏览
小开
最佳答案
T; error”) ; } ，1000) ;
小开

另一种方法是使用 apply()函数。

如果你有数据帧

df <- data.frame (var1 = c(1:7,NA),
var2 = c(1,2,1,3,4,NA,NA,9),
var3 = c(NA)
)

我不太明白在现实生活中我该怎么用反变。

到目前为止，我看到的唯一示例是同一个旧的数组示例。

object[] objectArray = new string[] { "string 1", "string 2" };

然后您可以使用 apply()来查看哪些列满足您的条件，因此您可以简单地使用 apply方法进行与 Musa 的答案相同的子设置。

> !apply (is.na(df), 2, all)
var1  var2  var3
TRUE  TRUE FALSE


> df[, !apply(is.na(df), 2, all)]
var1 var2
1    1    1
2    2    2
3    3    1
4    4    3
5    5    4
6    6   NA
7    7   NA
8   NA    9
小开 
class A {}
class B : A {}


public void SomeFunction()
{
var someListOfB = new List<B>();
someListOfB.Add(new B());
someListOfB.Add(new B());
someListOfB.Add(new B());
SomeFunctionThatTakesA(someListOfB);
}


public void SomeFunctionThatTakesA(IEnumerable<A> input)
{
// Before C# 4, you couldn't pass in List<B>:
// cannot convert from
// 'System.Collections.Generic.List<ConsoleApplication1.B>' to
// 'System.Collections.Generic.IEnumerable<ConsoleApplication1.A>'
}

以及一种使用 data.table 的方法(针对一般时间和内存效率)

library(data.table)
DT <- as.data.table(df)
DT[,which(unlist(lapply(DT, function(x)!all(is.na(x))))),with=F]

基本上，只要有一个函数接受一种类型的枚举数，就不能传入派生类型的枚举数而不显式强制转换它。

使用大数据的示例(30列，1e6行)

big_data <- replicate(10, data.frame(rep(NA, 1e6), sample(c(1:8,NA),1e6,T), sample(250,1e6,T)),simplify=F)
bd <- do.call(data.frame,big_data)
names(bd) <- paste0('X',seq_len(30))
DT <- as.data.table(bd)


system.time({df1 <- bd[,colSums(is.na(bd) < nrow(bd))]})
# error -- can't allocate vector of size ...
system.time({df2 <- bd[, !apply(is.na(bd), 2, all)]})
# error -- can't allocate vector of size ...
system.time({df3 <- Filter(function(x)!all(is.na(x)), bd)})
## user  system elapsed
## 0.26    0.03    0.29
system.time({DT1 <- DT[,which(unlist(lapply(DT, function(x)!all(is.na(x))))),with=F]})
## user  system elapsed
## 0.14    0.03    0.18
小开

下面是一个使用继承层次结构的简单示例。

//当 T 仅用作“ in”(参数)时 反变量 < in T > (T 参数) ;

考虑到简单的类层次结构:

enter image description here

//困惑

代码是:

public abstract class LifeForm  { }
public abstract class Animal : LifeForm { }
public class Giraffe : Animal { }
public class Zebra : Animal { }
委托 T 协变量两者均 < out T > (T 参数) ; //困惑

不变性(即用 in或 out关键字修饰的泛型类型参数 不 )

看起来，像这样的方法

public static void PrintLifeForms(IList<LifeForm> lifeForms)
{
foreach (var lifeForm in lifeForms)
{
Console.WriteLine(lifeForm.GetType().ToString());
}
}
委托 T 逆变项均 < in T > (T 参数) ;

... 应该接受一个不同的集合: (它做到了)

var myAnimals = new List<LifeForm>
{
new Giraffe(),
new Zebra()
};
PrintLifeForms(myAnimals); // Giraffe, Zebra
//来自.NET Framework: 行动 < in T > (T obj) ;

但是，传递 派生出来的类型的集合失败！

var myGiraffes = new List<Giraffe>
{
new Giraffe(), // "Jerry"
new Giraffe() // "Melman"
};
PrintLifeForms(myGiraffes); // Compile Error!

cannot convert from 'System.Collections.Generic.List<Giraffe>' to 'System.Collections.Generic.IList<LifeForm>'

公众代表 TResult Func < in T，out TResult > (T arg) ; }//类

为什么? 因为泛型参数 IList<LifeForm>不是协变的- > IList<T>是不变的，因此 IList<LifeForm>只接受参数化类型 T必须是 LifeForm的集合(实现 IList)。

协方差广泛用于不可变集合(即不能从集合中添加或删除新元素)

如果 PrintLifeForms的方法实现是恶意的(但具有相同的方法签名) ，那么编译器阻止传递 List<Giraffe>的原因就显而易见了:

 public static void PrintLifeForms(IList<LifeForm> lifeForms)
{
lifeForms.Add(new Zebra());
}

上述问题的解决方案——即将一个更派生类型 collection<Giraffe>的集合传递给一个接受一个接受 collection<LifeForm>的 不那么来源超类的集合的函数——是确保使用协变通用集合类型，例如 IEnumerable(定义为 IEnumerable<out T>)。IEnumerable没有改变集合的方法，并且作为 out协方差的结果，任何具有 LifeForm子类型的集合现在都可以传递给该方法:

public static void PrintLifeForms(IEnumerable<LifeForm> lifeForms)
{
foreach (var lifeForm in lifeForms)
{
Console.WriteLine(lifeForm.GetType().ToString());
}
}

由于 IList允许添加或删除元素，因此 LifeForm的任何子类都可以添加到参数 lifeForms中，并且会违反传递给该方法的任何派生类型集合的类型。(在这里，恶意方法将尝试向 var myGiraffes添加 Zebra)。幸运的是，编译器保护我们免受这种危险。

PrintLifeForms现在可以用 Zebras、 Giraffes和 LifeForm的任何子类的任何 IEnumerable<>来调用。

var myGiraffes = new List<Giraffe>
{
new Giraffe(), // "Jerry"
new Giraffe() // "Melman"
};
PrintLifeForms(myGiraffes); // All good!

协方差(使用 out修饰的参数化类型的泛型)

逆变(用 in修饰的参数化类型的泛型)

协方差广泛用于不可变集合(即不能从集合中添加或删除新元素)

上述问题的解决方案——即将一个更派生类型 collection<Giraffe>的集合传递给一个接受一个接受 collection<LifeForm>的 不那么来源超类的集合的函数——是确保使用协变通用集合类型，例如 IEnumerable(定义为 IEnumerable<out T>)。IEnumerable没有改变集合的方法，并且作为 out协方差的结果，任何具有 LifeForm子类型的集合现在都可以传递给该方法:

public static void PrintLifeForms(IEnumerable<LifeForm> lifeForms)
{
foreach (var lifeForm in lifeForms)
{
Console.WriteLine(lifeForm.GetType().ToString());
}
}

当函数作为参数传递时，经常使用逆变。

PrintLifeForms现在可以用 Zebras、 Giraffes和 LifeForm的任何子类的任何 IEnumerable<>来调用。

var myGiraffes = new List<Giraffe>
{
new Giraffe(), // "Jerry"
new Giraffe() // "Melman"
};
PrintLifeForms(myGiraffes); // All good!

逆变(用 in修饰的参数化类型的泛型)

下面是一个函数的例子，它接受一个 Action<Zebra>作为参数，并在一个已知的 Zebra 实例上调用它:

public void PerformZebraAction(Action<Zebra> zebraAction)
{
var zebra = new Zebra();
zebraAction(zebra);
}

当函数作为参数传递时，经常使用逆变。

下面是一个函数的例子，它接受一个 Action<Zebra>作为参数，并在一个已知的 Zebra 实例上调用它:

public void PerformZebraAction(Action<Zebra> zebraAction)
{
var zebra = new Zebra();
zebraAction(zebra);
}

正如预期的那样，这种做法效果不错:

var myAction = new Action<Zebra>(z => Console.WriteLine("I'm a zebra"));
PerformZebraAction(myAction); // I'm a zebra

直觉上，这种做法将会失败:

var myAction = new Action<Giraffe>(g => Console.WriteLine("I'm a giraffe"));
PerformZebraAction(myAction);

正如预期的那样，这种做法效果不错:

var myAction = new Action<Zebra>(z => Console.WriteLine("I'm a zebra"));
PerformZebraAction(myAction); // I'm a zebra

cannot convert from 'System.Action<Giraffe>' to 'System.Action<Zebra>'

直觉上，这种做法将会失败:

var myAction = new Action<Giraffe>(g => Console.WriteLine("I'm a giraffe"));
PerformZebraAction(myAction);

cannot convert from 'System.Action<Giraffe>' to 'System.Action<Zebra>'

然而，这成功了吗

var myAction = new Action<Animal>(a => Console.WriteLine("I'm an animal"));
PerformZebraAction(myAction); // I'm an animal

然而，这成功了吗

var myAction = new Action<Animal>(a => Console.WriteLine("I'm an animal"));
PerformZebraAction(myAction); // I'm an animal

甚至这也成功了:

var myAction = new Action<object>(a => Console.WriteLine("I'm an amoeba"));
PerformZebraAction(myAction); // I'm an amoeba

甚至这也成功了:

var myAction = new Action<object>(a => Console.WriteLine("I'm an amoeba"));
PerformZebraAction(myAction); // I'm an amoeba

为什么？因为 Action被定义为 Action<in T>，也就是说它是 contravariant，这意味着对于 Action<Zebra> myAction，myAction最多可以是一个 Action<Zebra>，但是一个具有 参数的 不那么来源超类的 Zebra也是可以接受的。

为什么？因为 Action被定义为 Action<in T>，也就是说它是 contravariant，这意味着对于 Action<Zebra> myAction，myAction最多可以是一个 Action<Zebra>，但是一个具有 参数的 不那么来源超类的 Zebra也是可以接受的。

虽然这在一开始可能是不直观的(例如，如何将 Action<object>作为需要 Action<Zebra>的参数传递?)如果您解压缩这些步骤，您将注意到被调用的函数(PerformZebraAction)本身负责将数据(在本例中是一个 Zebra实例)传递给函数-数据不来自调用代码。

虽然这在一开始可能是不直观的(例如，如何将 Action<object>作为需要 Action<Zebra>的参数传递?)如果您解压缩这些步骤，您将注意到被调用的函数(PerformZebraAction)本身负责将数据(在本例中是一个 Zebra实例)传递给函数-数据不来自调用代码。

由于以这种方式使用高阶函数的反向方法，在调用 Action时，针对 zebraAction函数(作为参数传递)调用的是派生程度更高的 Zebra实例，尽管函数本身使用派生程度较低的类型。

小开 
df[sapply(df, function(x) all(is.na(x)))] <- NULL
小开

转换器代表帮助我想象两个概念一起工作:

delegate TOutput Converter<in TInput, out TOutput>(TInput input);

现在可以将 select与 where选择助手一起使用。select_if已被取代，但在 dplyr 1.0.2时仍然有效。(感谢@mcstrother 提醒我们)。

library(dplyr)
temp <- data.frame(x = 1:5, y = c(1,2,NA,4, 5), z = rep(NA, 5))
not_all_na <- function(x) any(!is.na(x))
not_any_na <- function(x) all(!is.na(x))


> temp
x  y  z
1 1  1 NA
2 2  2 NA
3 3 NA NA
4 4  4 NA
5 5  5 NA


> temp %>% select(where(not_all_na))
x  y
1 1  1
2 2  2
3 3 NA
4 4  4
5 5  5


> temp %>% select(where(not_any_na))
x
1 1
2 2
3 3
4 4
5 5

老答案

dplyr现在有一个 select_if动词，可能在这里有所帮助:

> temp
x  y  z
1 1  1 NA
2 2  2 NA
3 3 NA NA
4 4  4 NA
5 5  5 NA


> temp %>% select_if(not_all_na)
x  y
1 1  1
2 2  2
3 3 NA
4 4  4
5 5  5


> temp %>% select_if(not_any_na)
x
1 1
2 2
3 3
4 4
5 5
小开

TOutput表示方法返回 更具体的类型的 协方差。

晚到的游戏，但你也可以使用 janitor包。这个函数将删除全部为 NA 的列，并且可以更改以删除全部为 NA 的行。

df <- janitor::remove_empty(df, which = "cols")

小开

purrr软件包的另一个选择:

library(dplyr)


df <- data.frame(a = NA,
b = seq(1:5),
c = c(rep(1, 4), NA))


df %>% purrr::discard(~all(is.na(.)))
df %>% purrr::keep(~!all(is.na(.)))
小开

一个方便的 base R选项可以是 colMeans():

df[, colMeans(is.na(df)) != 1]
小开

违规行为

您可以使用管理员软件包 remove_empty

library(janitor)


df %>%
remove_empty(c("rows", "cols")) #select either row or cols or both

另外，另一种 dplyr 方法

 library(dplyr)
df %>% select_if(~all(!is.na(.)))

在现实世界中，你总是可以使用动物庇护所而不是兔子庇护所，因为每次动物庇护所接待一只兔子，它就是一只动物。然而，如果你使用兔子收容所而不是动物收容所，它的工作人员可能会被老虎吃掉。

或者

df %>% select_if(colSums(!is.na(.)) == nrow(df))

如果希望只排除/保留具有一定数量缺失值的列，则这也很有用，例如。

 df %>% select_if(colSums(!is.na(.))>500)

在代码中，这意味着如果你有一个 IShelter<Animal> animals，你可以简单地编写 IShelter<Rabbit> rabbits = animals 如果，你承诺在 IShelter<T>中只使用 T作为方法参数，如下所示:

public class Contravariance
{
public class Animal { }
public class Rabbit : Animal { }


public interface IShelter<in T>
{
void Host(T thing);
}


public void NoCompileErrors()
{
IShelter<Animal> animals = null;
IShelter<Rabbit> rabbits = null;


rabbits = animals;
}
}
像这样:

public class Contravariance
{
public class Animal { }
public class Rabbit : Animal { }


public interface IShelter<in T>
{
void Host(T thing);
}


public void NoCompileErrors()
{
IShelter<Animal> animals = null;
IShelter<Rabbit> rabbits = null;


rabbits = animals;
}
}

并用一个更通用的项替换一个项，即减少方差或引入 瓦解保全方差。

并用一个更通用的项替换一个项，即减少方差或引入 瓦解保全方差。

协方差

协方差

在现实世界中，你总是可以使用兔子供应商而不是动物供应商，因为每次兔子供应商给你一只兔子，它就是一只动物。然而，如果你使用动物供应商而不是兔子供应商，你可能会被老虎吃掉。

在现实世界中，你总是可以使用兔子供应商而不是动物供应商，因为每次兔子供应商给你一只兔子，它就是一只动物。然而，如果你使用动物供应商而不是兔子供应商，你可能会被老虎吃掉。

在代码中，这意味着如果你有一个 ISupply<Rabbit> rabbits，你可以简单地编写 ISupply<Animal> animals = rabbits 如果，你承诺在 ISupply<T>中只使用 T作为方法返回值，如下所示:

public class Covariance
{
public class Animal { }
public class Rabbit : Animal { }


public interface ISupply<out T>
{
T Get();
}


public void NoCompileErrors()
{
ISupply<Animal> animals = null;
ISupply<Rabbit> rabbits = null;


animals = rabbits;
}
}

在代码中，这意味着如果你有一个 ISupply<Rabbit> rabbits，你可以简单地编写 ISupply<Animal> animals = rabbits 如果，你承诺在 ISupply<T>中只使用 T作为方法返回值，如下所示:

public class Covariance
{
public class Animal { }
public class Rabbit : Animal { }


public interface ISupply<out T>
{
T Get();
}


public void NoCompileErrors()
{
ISupply<Animal> animals = null;
ISupply<Rabbit> rabbits = null;


animals = rabbits;
}
}

并用一个更派生的项替换一个项，即增加方差或引入 合作伙伴方差。

并用一个更派生的项替换一个项，即增加方差或引入 合作伙伴方差。

总而言之，这只是你的一个 编译时可检查承诺，你会以某种方式对待一个通用类型，以保持类型安全，不会让任何人吃掉。

总而言之，这只是你的一个 编译时可检查承诺，你会以某种方式对待一个通用类型，以保持类型安全，不会让任何人吃掉。

你可能需要给 这个一个读数，让你的头脑重新思考这个问题。

小开

试试 -i标志(或者 --ignore-errors)。顺便说一下，文件似乎提供了一种更有力的方法来实现这一点:

重点是“非”符号需要在通用量词的外面。也就是说，select_if操作符作用于列。在这种情况下，它只选择那些 不要满足条件的

每个元素都等于 NA

小开

若要忽略命令行中的错误，请在该行文本的开头(在初始选项卡之后)写入一个 -。在将命令传递给 shell 执行之前，将丢弃 -。

Remove _ Constant ()可以很好地完成这项工作。

小开

比如说,

clean:
-rm -f *.o

这会导致 rm继续运行，即使它无法删除文件。

这是一个老问题，但我认为我们可以用一个更简单的 data.table 解决方案来更新@mnel 的好答案:

DT[, .SD, .SDcols = \(x) !all(is.na(x))]

所有示例都使用 rm，但适用于需要忽略来自(即 mkdir)的错误的任何其他命令。

(我使用的是 R > = 4.1中提供的新的 \(x) lambda 函数语法，但实际上关键是通过 .SDcols传递逻辑子集。

62.247762 a

速度是等价的。

microbenchmark::microbenchmark(
which_unlist = DT[, which(unlist(lapply(DT, \(x) !all(is.na(x))))), with=FALSE],
sdcols       = DT[, .SD, .SDcols = \(x) !all(is.na(x))],
times = 2
)
#> Unit: milliseconds
#>          expr      min       lq     mean   median       uq      max neval cld
#>  which_unlist 51.32227 51.32227 56.78501 56.78501 62.24776 62.24776     2   a
#>        sdcols 43.14361 43.14361 49.33491 49.33491 55.52621 55.52621     2   a

提交答案