anndata.concat

anndata.concat#

anndata.concat(adatas, *, axis='obs', join='inner', merge=None, uns_merge=None, label=None, keys=None, index_unique=None, fill_value=None, pairwise=False)[source]#

沿着一个轴连接AnnData对象。

请参阅文档中的串联部分以获取更详细的描述。

Parameters:

adatas Union[Collection[AnnData], Mapping[str, AnnData]]

要连接的对象。如果传递的是映射，则键用于keys参数，值被连接。

axis Literal['obs', 0, 'var', 1] (default: 'obs')

沿哪个轴进行连接。

join Literal['inner', 'outer'] (default: 'inner')

在连接时如何对齐值。如果是“outer”，则取其他轴的并集。如果是“inner”，则取交集。有关更多信息，请参见concatenation。

merge Union[Literal['same', 'unique', 'first', 'only'], Callable, None] (default: None)

如何选择未与正在连接的轴对齐的元素。当前实施的策略包括：

None: 不保留任何元素。
"same": 每个对象中相同的元素。
"unique": 只有一个可能值的元素。
"first": 每个位置上看到的第一个元素。
"only": 仅在一个对象中出现的元素。

uns_merge Union[Literal['same', 'unique', 'first', 'only'], Callable, None] (default: None)

如何选择 .uns 的元素。使用与 merge 参数相同的一组策略，只是递归应用。

label str | None (default: None)

轴注释中的列（即 .obs 或 .var）用于放置批次信息。如果为 None，则不添加任何列。

keys Collection | None (default: None)

为每个被添加对象的名称。这些值用于label的列值，或者如果index_unique不是None，则附加到索引上。默认为递增的整数标签。

index_unique str | None (default: None)

是否通过使用键使索引唯一。如果提供，这是“{orig_idx}{index_unique}{key}”之间的分隔符。当 None 时，原始索引将被保留。

fill_value Any | None (default: None)

当 join="outer" 时，这个值将用于填充引入的索引。默认情况下，稀疏数组用零填充，而密集数组和 DataFrames 用缺失值填充。

pairwise bool (default: False)

是否应该包含沿着连接维度的成对元素。默认情况下为False，因为结果数组通常没有意义。

Return type:

AnnData

注意事项

警告

如果你使用 join='outer'，当批次中缺少变量时，这将为稀疏数据填充0。请谨慎使用。密集数据则填充 NaN。

示例

准备示例对象

>>> import anndata as ad, pandas as pd, numpy as np
>>> from scipy import sparse
>>> a = ad.AnnData(
...     X=sparse.csr_matrix(np.array([[0, 1], [2, 3]])),
...     obs=pd.DataFrame({"group": ["a", "b"]}, index=["s1", "s2"]),
...     var=pd.DataFrame(index=["var1", "var2"]),
...     varm={
...         "ones": np.ones((2, 5)),
...         "rand": np.random.randn(2, 3),
...         "zeros": np.zeros((2, 5)),
...     },
...     uns={"a": 1, "b": 2, "c": {"c.a": 3, "c.b": 4}},
... )
>>> b = ad.AnnData(
...     X=sparse.csr_matrix(np.array([[4, 5, 6], [7, 8, 9]])),
...     obs=pd.DataFrame(
...         {"group": ["b", "c"], "measure": [1.2, 4.3]}, index=["s3", "s4"]
...     ),
...     var=pd.DataFrame(index=["var1", "var2", "var3"]),
...     varm={"ones": np.ones((3, 5)), "rand": np.random.randn(3, 5)},
...     uns={"a": 1, "b": 3, "c": {"c.b": 4}},
... )
>>> c = ad.AnnData(
...     X=sparse.csr_matrix(np.array([[10, 11], [12, 13]])),
...     obs=pd.DataFrame({"group": ["a", "b"]}, index=["s1", "s2"]),
...     var=pd.DataFrame(index=["var3", "var4"]),
...     uns={"a": 1, "b": 4, "c": {"c.a": 3, "c.b": 4, "c.c": 5}},
... )

沿不同轴连接

>>> ad.concat([a, b]).to_df()
    var1  var2
s1     0     1
s2     2     3
s3     4     5
s4     7     8
>>> ad.concat([a, c], axis="var").to_df()
    var1  var2  var3  var4
s1     0     1    10    11
s2     2     3    12    13

内部连接和外部连接

>>> inner = ad.concat([a, b])  # Joining on intersection of variables
>>> inner
AnnData object with n_obs × n_vars = 4 × 2
    obs: 'group'
>>> (inner.obs_names, inner.var_names)  
(Index(['s1', 's2', 's3', 's4'], dtype='object'),
Index(['var1', 'var2'], dtype='object'))
>>> outer = ad.concat([a, b], join="outer")  # Joining on union of variables
>>> outer
AnnData object with n_obs × n_vars = 4 × 3
    obs: 'group', 'measure'
>>> outer.var_names
Index(['var1', 'var2', 'var3'], dtype='object')
>>> outer.to_df()  # Sparse arrays are padded with zeroes by default
    var1  var2  var3
s1     0     1     0
s2     2     3     0
s3     4     5     6
s4     7     8     9

使用轴的索引而不是其名称

>>> ad.concat([a, b], axis=0).to_df()  # Equivalent to axis="obs"
    var1  var2
s1     0     1
s2     2     3
s3     4     5
s4     7     8
>>> ad.concat([a, c], axis=1).to_df()  # Equivalent to axis="var"
    var1  var2  var3  var4
s1     0     1    10    11
s2     2     3    12    13

跟踪源对象

>>> ad.concat({"a": a, "b": b}, label="batch").obs
   group batch
s1     a     a
s2     b     a
s3     b     b
s4     c     b
>>> ad.concat([a, b], label="batch", keys=["a", "b"]).obs  # Equivalent to previous
   group batch
s1     a     a
s2     b     a
s3     b     b
s4     c     b
>>> ad.concat({"a": a, "b": b}, index_unique="-").obs
     group
s1-a     a
s2-a     b
s3-b     b
s4-b     c

组合值未对齐到连接轴

>>> ad.concat([a, b], merge="same")
AnnData object with n_obs × n_vars = 4 × 2
    obs: 'group'
    varm: 'ones'
>>> ad.concat([a, b], merge="unique")
AnnData object with n_obs × n_vars = 4 × 2
    obs: 'group'
    varm: 'ones', 'zeros'
>>> ad.concat([a, b], merge="first")
AnnData object with n_obs × n_vars = 4 × 2
    obs: 'group'
    varm: 'ones', 'rand', 'zeros'
>>> ad.concat([a, b], merge="only")
AnnData object with n_obs × n_vars = 4 × 2
    obs: 'group'
    varm: 'zeros'

相同的合并策略可以用于 .uns 中的元素。

>>> dict(ad.concat([a, b, c], uns_merge="same").uns)
{'a': 1, 'c': {'c.b': 4}}
>>> dict(ad.concat([a, b, c], uns_merge="unique").uns)
{'a': 1, 'c': {'c.a': 3, 'c.b': 4, 'c.c': 5}}
>>> dict(ad.concat([a, b, c], uns_merge="only").uns)
{'c': {'c.c': 5}}
>>> dict(ad.concat([a, b, c], uns_merge="first").uns)
{'a': 1, 'b': 2, 'c': {'c.a': 3, 'c.b': 4, 'c.c': 5}}

anndata.concat

目录

anndata.concat#