我的小钱

在Person类中，我们用self定义了init方法，这里需要注意的有趣的事情是self和实例变量p的内存位置是相同的<__main__。位于0x106a78fd0>的Person对象

class Person:

    def __init__(self, name, age):
        self.name = name 
        self.age = age 

    def say_hi(self):
        print("the self is at:", self)
        print((f"hey there, my name is {self.name} and I am {self.age} years old"))

    def say_bye(self):
        print("the self is at:", self)
        print(f"good to see you {self.name}")

p = Person("john", 78)
print("the p is at",p)
p.say_hi()  
p.say_bye() 

如上所述，self和实例变量都是同一个对象。

当对象实例化时，对象本身被传递到self参数中。

因此，对象的数据被绑定到对象上。下面是一个示例，说明您可能希望如何可视化每个对象的数据。注意“self”是如何被对象名称替换的。我并不是说下面这个示例图是完全准确的，但希望它能在可视化self的使用方面起到一定的作用。

对象被传递到self参数中，这样对象就可以保存自己的数据。

Although this may not be wholly accurate, think of the process of instantiating an object like this: When an object is made it uses the class as a template for its own data and methods. Without passing it's own name into the self parameter, the attributes and methods in the class would remain as a general template and would not be referenced to (belong to) the object. So by passing the object's name into the self parameter it means that if 100 objects are instantiated from the one class, they can all keep track of their own data and methods.

如下图所示:

“self”这个词指的是一个类的实例

class foo:
      def __init__(self, num1, num2):
             self.n1 = num1 #now in this it will make the perimeter num1 and num2 access across the whole class
             self.n2 = num2
      def add(self):
             return self.n1 + self.n2 # if we had not written self then if would throw an error that n1 and n2 is not defined and we have to include self in the function's perimeter to access it's variables

我很惊讶居然没人提起Lua。Lua也使用“self”变量，但是可以省略，但仍然使用。c++对'this'做了同样的处理。我不认为有任何理由必须在每个函数中声明“self”，但你仍然可以像使用lua和c++一样使用它。对于一门以简洁为傲的语言来说，它要求你声明self变量是很奇怪的。

从医生那里，

方法的特殊之处在于实例对象是作为函数的第一个参数传递的。在我们的例子中，调用x.f()完全等价于MyClass.f(x)。一般来说，调用带有n个参数列表的方法相当于调用带有参数列表的相应函数，该参数列表是通过在第一个参数之前插入方法的实例对象创建的。

在此之前的相关片段，

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

x = 我的类（）

我将用不使用类的代码演示:

def state_init(state):
    state['field'] = 'init'

def state_add(state, x):
    state['field'] += x

def state_mult(state, x):
    state['field'] *= x

def state_getField(state):
    return state['field']

myself = {}
state_init(myself)
state_add(myself, 'added')
state_mult(myself, 2)

print( state_getField(myself) )
#--> 'initaddedinitadded'

类只是一种避免始终传递这种“状态”的方法(以及其他一些不错的事情，如初始化、类组合、很少需要的元类，以及支持自定义方法来覆盖操作符)。

现在让我们使用内置的python类机制来演示上面的代码，以展示它们基本上是相同的东西。

class State(object):
    def __init__(self):
        self.field = 'init'
    def add(self, x):
        self.field += x
    def mult(self, x):
        self.field *= x

s = State()
s.add('added')    # self is implicitly passed in
s.mult(2)         # self is implicitly passed in
print( s.field )

[把我的答案从重复的封闭式问题中迁移过来]