按照老师这个写出来，发现每次运行结果都会变化，这是什么原因？

还有，self.items[index] = s，那么数组里存放的是二元组么？

class Array():
    def __init__(self, size=4):
        self.size = size  # 记录容器大小
        self.item = [None]*size  # 分配空间
        self.length = 0

    def setitem(self, key, value):
        self.item[key] = value
        self.length += 1

    def getitem(self, key):
        return self.item[key]

    def len(self):
        return self.length

    def iter(self):
        for value in self.item:
            yield value


class Slot():
    def __init__(self, key=None, value=None):
        self.key = key
        self.value = value

    def str(self):
        return 'key: {} value: {}'.format(self.key, self.value)


class HashTable():
    def __init__(self):
        self.size = 4
        self.items = Array(self.size)

    def get_index(self, key):
        return hash(key) % self.size

    def put(self, key, value):
        s = Slot(key, value)
        index = self.get_index(key)
        self.items[index] = s

    def get(self, key):
        index = self.get_index(key)  # 获得key对应的索引
        return self.items[index]


if __name__ == '__main__':
    h = HashTable()
    h.put('name', '卢布')
    h.put('sex', '男')
    print(h.get('name'))
    print(h.get('sex'))

问题：

老师我的为什么出现这个问题

class Node():
    def __init__(self, value = None, next = None):
        self.value = value
        self.next = next

    def __str__(self):
        return 'Node:{}'.format(self.value)


class LinkedList():
    def __init__(self):
        self.root = Node()
        self.next = None
        self.size = 0

    def append_end(self, value):  # 链表的后边加数据
        node = Node(value)
        if not self.root.next:
            self.root.next = node
        else:
            self.next.next = node
        self.next = node
        self.size += 1

    def append_first(self, value):
        node = Node(value)
        if not self.root.next:
            self.root.next = node
        else:
            temp = self.root.next
            self.root.next = node
            node.next = temp
        self.size += 1

    def __iter__(self):
        current = self.root.next
        while current is not self.next:
            yield current
            current = current.next
        yield current


if __name__ == '__main__':
    link = LinkedList()
    link.append_end('悟空')
    link.append_end('八戒')
    link.append_first('师傅')
    for i in link:
        print(i)

老师请问，视频中对框红线的位置之前加了个if判断，我感觉没有必要加，运行结果也是好的，不知道我的理解有没有问题。

class Node():
    def __init__(self, value=None, next=None):
        self.value = value
        self.next = next

    def __str__(self):
        return 'Node:{}'.format(self.value)


class LinkedList():
    def __init__(self):
        self.root = Node()
        self.next = None
        self.size = 0

    def append_end(self, value):  # 链表的后边加数据
        node = Node(value)
        if not self.root.next:
            self.root.next = node
        else:
            self.next.next = node
        self.next = node
        self.size += 1

    def append_first(self, value):
        node = Node(value)
        if not self.root.next:
            self.root.next = node
        else:
            temp = self.root.next
            self.root.next = node
            node.next = temp
        self.size += 1

    def __iter__(self):
        current = self.root.next
        while current is not self.next:
            yield current.value
            current = current.next
        yield current.value

    def find(self, value):
        for n in self.__iter__():
            if n == value:
                return n


if __name__ == '__main__':
    link = LinkedList()
    link.append_end('悟空')
    link.append_end('八戒')
    link.append_first('师傅')
    for i in link:
        print(i)
    print(Node('悟空'))
    print(link.find('悟空'))

老师请问，代码中将n改为n.value就会报错，但是原视频中不会报错，我这个代码中报错的原因是啥，n代表的是Node还是Node的value

老师 为啥你这个地方要写成 == 而并非= ？

老师这个我按照你视频上的代码操作了一遍，你最后打印的长度为2，为啥我打印的长度为4

老师请问，图中标出的地方为什么不是判断self.value呢，self.value才能判断当前这个链表里边有没有数据

为啥移了两位是2的平方？

老师好，python不是也有垃圾回收机制么，还用del 吗？

老师，这个溢出了怎么办，head一直加？元素覆盖了呢？

老师，size干啥用的，下面并没有用到，size和length之间有啥限制关系吗

老师，如果hashtable放满了，index会一直循环，计算位置

get时候没找到也会一直循环的，找不到位置

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None

class solution:
    def reversePrint(self, head: ListNode):
        stack = []
        while head:
            stack.append(head.val)
            head = head.next
        return stack[::-1]
if __name__ == '__main__':
    head = [1, 22, 3, 5, 6, 9]
    rev = solution.reversePrint()
    print(rev(head))

老师，请问我这个问题出现在哪里了？