在leetcode答案里写self代表什么？？？？？？？？？？？？？

比如一道题，leetcode一开始给了个def(self, n):之类的，
然后咱们在下面写答案。

如果我写self.n = n，这和我定义一个new_n = n有什么区别呢？

还有，比如定义个graph，和self.graph这俩有什么区别？

我知道如果咱们定义新函数，平行写，调用的时候需要用self。这里我问的是，咱们什么都不新定义，就在leetcode def下面写答案，
第一行我就写graph = ...和self.graph = ...有什么区别？

这问题是由1494 parallel courses ii引申的。代码如下。
from itertools import combinations # for picking k of n
class Solution:
    @lru_cache(None) # caching for faster lookups
    def recurse(self, mask, in_degrees):
        # if all the bits are 0, we have taken all the courses
        if not mask: return 0

        # all the nodes that *can* be taken now, following both the properties
        nodes = [i for i in range(self.n) if mask & 1 << i and in_degrees == 0]

        ans = float('inf')
        # enumerating all the possible combinations
        for k_nodes in combinations(nodes, min(self.k, len(nodes))):
            new_mask, new_in_degrees = mask, list(in_degrees)

            # updating what would happen to new_mask and new_in_degrees
            # if we considered the nodes in k_nodes
            for node in k_nodes:
                # since we know the bit is set, we un-set this bit, to mark it "considered"
                new_mask ^= 1 << node
                # updating each of the in-degrees, since the "parents" have been taken away
                for child in self.graph[node]:
                    new_in_degrees[child] -= 1

            # the heart of recursion
            # note the +1!
            ans = min(ans, 1+self.recurse(new_mask, tuple(new_in_degrees)))
        return ans

    def minNumberOfSemesters(self, n: int, relations: List[List[int]], k: int) -> int:
        # saving n and k for later use
        self.n = n
        self.k = k
        in_degrees = [0]*self.n
        # graph layout remains the same, although the in_degrees change.
        # This allows us to keep graph as self.graph
        # instead of passing it over and over.
        self.graph = defaultdict(list)
        for prev_course, next_course in relations:
            # remember, its 0-indexed now!
            in_degrees[next_course - 1] += 1
            self.graph[prev_course - 1].append(next_course - 1)

        # start with all the bits set
        return self.recurse((1 << self.n) - 1, tuple(in_degrees))


我个人习惯不喜欢平行写定义，我喜欢把定义写到leetcode定义里面。当我把第一个def写到第二个里面时，然后删除self，提示不能哈希的列表

建議先學好python再開始刷題...

我很惊讶能在破地里看到这种问题，小红书都不如了吗…

python基础，self是一个class的attribute，会存在instance中。你直接newn=n也没啥，就是name space不能跨越class的function

SnowCSWG 发表于 2021-12-24 22:04
python基础，self是一个class的attribute，会存在instance中。你直接newn=n也没啥，就是name space不能跨越 ...

问题中代码我什么都没变，就是把第一个函数写到第二个函数里面，删除所有self，然后报错
TypeError: unhashable type: 'list'
    ret = Solution().minNumberOfSemesters(param_1, param_2, param_3)
Line 96 in _driver (Solution.py)
    _driver()
Line 107 in <module> (Solution.py)

代码如下，不知道这里面哪个self是不是不能删？？？？

from itertools import combinations # for picking k of n
class Solution:
    @lru_cache(None) # caching for faster lookups
   
   
    def minNumberOfSemesters(self, n: int, relations: List[List[int]], k: int) -> int:
              
        # saving n and k for later use        
        in_degrees = [0]*n
        # graph layout remains the same, although the in_degrees change.
        # This allows us to keep graph as self.graph
        # instead of passing it over and over.
        graph = defaultdict(list)
        for prev_course, next_course in relations:
            # remember, its 0-indexed now!
            in_degrees[next_course - 1] += 1
            graph[prev_course - 1].append(next_course - 1)
        
        
        def recurse(mask, in_degrees):
            # if all the bits are 0, we have taken all the courses
            if not mask: return 0

            # all the nodes that *can* be taken now, following both the properties
            nodes = [i for i in range(n) if mask & 1 << i and in_degrees == 0]

            ans = float('inf')
            # enumerating all the possible combinations
            for k_nodes in combinations(nodes, min(k, len(nodes))):
                new_mask, new_in_degrees = mask, list(in_degrees)

                # updating what would happen to new_mask and new_in_degrees
                # if we considered the nodes in k_nodes
                for node in k_nodes:
                    # since we know the bit is set, we un-set this bit, to mark it "considered"
                    new_mask ^= 1 << node
                    # updating each of the in-degrees, since the "parents" have been taken away
                    for child in graph[node]:
                        new_in_degrees[child] -= 1

                # the heart of recursion
                # note the +1!
                ans = min(ans, 1+recurse(new_mask, tuple(new_in_degrees)))
            return ans
        
        # start with all the bits set
        return recurse((1 << n) - 1, tuple(in_degrees))

变量声明里没self好像会影响递归的调用。。ps你为啥一定要把那个self删了啊

lancevi96 发表于 2021-12-24 22:37
变量声明里没self好像会影响递归的调用。。ps你为啥一定要把那个self删了啊

我原来最开始接触dfs时写习惯了就把dfs一直写在leetcode大定义里面，慢慢就不想带着self了，除非极端迫不得已非得写self才写。比如两个函数平行写，我一般都写到一个里面。
受累再帮我看一下我上个回复，是没办法把第一个def写到第二个里面了么。
TypeError: unhashable type: 'list'
    ret = Solution().minNumberOfSemesters(param_1, param_2, param_3)
Line 96 in _driver (Solution.py)
    _driver()
Line 107 in <module> (Solution.py)

我想是本身class的聲明，你可以用self調用自身函數，members….emmmm

补充内容 (2021-12-25 06:38 +08:00):
把class封装起来，self不就有用了

这不单单是Python是OOP的概念吧，你把class当class，def是function，完了很多题例如BFS有上下左右（虽然Python能写外面），或者一些数据结构题有自带变量，然后想象成都是new出来跑test case的就很清楚了

我觉得你是没懂 python 里的 OOP/class 是怎么回事...

你说的 "不喜欢平行写定义", 你的意思是不喜欢平行列 def, 而是喜欢写进同一个里?
- 从代码功能上, 确实两种都能做同一件事情, 但是把每个部分写分离, 就是为了 maintenance 和 readability. 就算到 extreme, 你所有东西全都只在一个 def 里, class 也不要, 也能完成任何 OOP 能做的最终结果 (也就是被叫做 spaghetti code). 但是基本是维护的噩梦.
- 至于哪里用 self, 哪里不用, 为什么报错. 你可以好好再看看 python 的 class, scope 等内容. 比如你可以看看这些例子你在跑之前能不能知道为什么哪些会报错 https://trinket.io/python/0dcd51fa1d