在 rpy2 中正确定义和调用 R 函数：避免 NoneType 陷阱

f <- function(match_out) {
    result <- summary(match_out)$sum.all
    result <- as.data.frame(result)
    return(result)
}

from rpy2 import robjects

get_balance = robjects.r('''f <- function(match_out) {
        result <- summary(match_out)$sum.all
        result <- as.data.frame(result)
        return(result)
    }
    ''')
# 此时 get_balance 将是 NoneType
print(type(get_balance)) # 输出 <class 'rpy2.rinterface_lib.sexp.NULLType'> 或 NoneType

from rpy2 import robjects
from rpy2.robjects.packages import importr

# 假设 MatchIt 包已安装并需要使用
base = importr('base')
stats = importr('stats')
matchit = importr('MatchIt')

# 示例：创建一个 dummy 的 match_out 对象，实际应用中会由 matchit.matchit() 生成
# 这里仅为演示函数调用，不涉及真实的匹配过程
# 假设 match_out 是一个包含 summary 方法的 R 对象
# 在真实场景中，match_out 会是 matchit.matchit() 的结果
# 例如：
# data = base.data_frame(x=base.c(1,2,3,4,5), treat=base.c(0,1,0,1,0))
# match_out = matchit.matchit(base.formula('treat ~ x'), data=data)

# 模拟一个具有 summary 方法的 R 对象，以便函数可以执行
# 这是一个简化的模拟，实际 match_out 会更复杂
class MockMatchOut:
    def __init__(self):
        self.summary_data = robjects.DataFrame({'Mean Diff': robjects.FloatVector([0.1, 0.2]),
                                                'Std. Mean Diff': robjects.FloatVector([0.05, 0.1])})
        self.summary_data.rownames = robjects.StrVector(['covariate1', 'covariate2'])

    def summary(self):
        # 模拟 summary(match_out) 的行为，返回一个包含 $sum.all 的列表或S3对象
        class MockSummaryResult:
            def __init__(self, data):
                self.sum_all = data

            # 允许通过属性访问 $sum.all
            @property
            def sum_all(self):
                return self._sum_all

            @sum_all.setter
            def sum_all(self, value):
                self._sum_all = value

        return MockSummaryResult(self.summary_data)

# 将 Python 对象转换为 R 对象，以便 R 函数可以处理
# 实际的 match_out 应该是 rpy2 包装的 R 对象
mock_match_out_r = robjects.conversion.py2rpy(MockMatchOut())

# 解决方案一：直接定义匿名函数
get_balance_anon = robjects.r('''
    function(match_out) {
        # 确保 match_out 能够被 summary 函数处理
        # 实际使用时，match_out 是 matchit.matchit() 的结果
        # 这里为了演示，我们假设它有一个 $sum.all 属性
        result <- summary(match_out)$sum.all
        result <- as.data.frame(result)
        return(result)
    }
''')

# 此时 get_balance_anon 是一个可调用的 R 函数对象
print(type(get_balance_anon)) # 输出 <class 'rpy2.robjects.functions.Function'>

# 调用函数并获取结果
balance_anon = get_balance_anon(mock_match_out_r)
print(balance_anon)

from rpy2 import robjects
from rpy2.robjects.packages import importr

base = importr('base')
stats = importr('stats')
matchit = importr('MatchIt')

# 模拟一个具有 summary 方法的 R 对象，以便函数可以执行
class MockMatchOut:
    def __init__(self):
        self.summary_data = robjects.DataFrame({'Mean Diff': robjects.FloatVector([0.1, 0.2]),
                                                'Std. Mean Diff': robjects.FloatVector([0.05, 0.1])})
        self.summary_data.rownames = robjects.StrVector(['covariate1', 'covariate2'])

    def summary(self):
        class MockSummaryResult:
            def __init__(self, data):
                self._sum_all = data

            @property
            def sum_all(self):
                return self._sum_all

            @sum_all.setter
            def sum_all(self, value):
                self._sum_all = value
        return MockSummaryResult(self.summary_data)

mock_match_out_r = robjects.conversion.py2rpy(MockMatchOut())

# 解决方案二：显式返回命名函数对象
get_balance_named = robjects.r('''
    f <- function(match_out) {
        result <- summary(match_out)$sum.all
        result <- as.data.frame(result)
        return(result)
    }
    f # 将函数名称作为最后一个表达式返回
''')

# 此时 get_balance_named 也是一个可调用的 R 函数对象
print(type(get_balance_named)) # 输出 <class 'rpy2.robjects.functions.Function'>

# 调用函数并获取结果
balance_named = get_balance_named(mock_match_out_r)
print(balance_named)