python递归是按引用传递还是按值传递？

我正在leetcode上解决此问题：

Given a set of distinct integers, nums, return all possible subsets.
input =[1,2,3]
output =[[],[3],[2],[2,3],[1],[1,3],[1,2],[1,2,3]]

我有C++解决方案，它被接受，然后我完全编码了相同的Python解决方案。

class Solution(object):    
    def subsets(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        solutions = []
        self._get_subset(nums, 0, [], solutions)

        return solutions

    @staticmethod
    def _get_subset(nums, curr, path, solutions):
        if curr>= len(nums):
            solutions.append(path)
            return

        path.append(nums[curr])
        Solution._get_subset(nums, curr+1, path, solutions)

        path.pop()
        Solution._get_subset(nums, curr+1, path, solutions)

现在输出为： []、[]、[]、[]、[]、[]、[]、[]、[]、[]、[]]

似乎是Python的pass-by-reference/pass-by-value导致了这个问题，但我不知道如何解决。同样的C++代码工作正常：

class Solution {
public:
vector<vector<int>> subsets(vector<int>& nums) {
    vector<vector<int>> solutions;
    vector<int> path;

    _get_path(nums, 0, path, solutions);
    return solutions;
}

void _get_path(vector<int>& nums, 
               int curr,
               vector<int>& path,
               vector< vector<int> > &solutions)
{
    if(curr >= nums.size()){
        solutions.push_back(path);
        return; 
    }
    path.push_back(nums[curr]);
    _get_path(nums, curr+1, path, solutions);

    path.pop_back();
    _get_path(nums, curr+1, path, solutions);
}
};

类解决方案{
公众：
向量子集（向量和nums）{
向量解；
向量路径；
_获取路径（nums，0，路径，解决方案）；
返回解决方案；
}
void\u get\u路径（向量和nums，
国际货币，
向量与路径，
矢量<矢量>&解决方案）
{
如果（curr>=nums.size（））{
解决方案。推回（路径）；
返回；
}
路径。推回（nums[curr]）；
_获取路径（nums、curr+1、路径、解决方案）；
path.pop_back（）；
_获取路径（nums、curr+1、路径、解决方案）；
}
};

问题在于：

solutions.append(path)

< C++ >代码> vector：：PuxSuffBue//Copy>复制了<代码>路径>代码>（内部）。但在Python中，所有内容都是引用。因此，您将您的

解决方案

构建为一个列表，其中包含对同一

路径

的多个引用，这些引用最终会减少为零

您想要一份副本：

solutions.append(list(path))

或：

---

path

是通过引用传递的，因此您总是只操作同一个实例。传递路径[：]以传递可修改的副本

solutions.append(path[:])