在这里，这个家伙写得很好，很简单:https://www.jeffknupp.com/blog/2014/06/18/improve-your-python-python-classes-and-object-oriented-programming/

阅读上面的链接作为参考:

self? So what's with that self parameter to all of the Customer methods? What is it? Why, it's the instance, of course! Put another way, a method like withdraw defines the instructions for withdrawing money from some abstract customer's account. Calling jeff.withdraw(100.0) puts those instructions to use on the jeff instance. So when we say def withdraw(self, amount):, we're saying, "here's how you withdraw money from a Customer object (which we'll call self) and a dollar figure (which we'll call amount). self is the instance of the Customer that withdraw is being called on. That's not me making analogies, either. jeff.withdraw(100.0) is just shorthand for Customer.withdraw(jeff, 100.0), which is perfectly valid (if not often seen) code. init self may make sense for other methods, but what about init? When we call init, we're in the process of creating an object, so how can there already be a self? Python allows us to extend the self pattern to when objects are constructed as well, even though it doesn't exactly fit. Just imagine that jeff = Customer('Jeff Knupp', 1000.0) is the same as calling jeff = Customer(jeff, 'Jeff Knupp', 1000.0); the jeff that's passed in is also made the result. This is why when we call init, we initialize objects by saying things like self.name = name. Remember, since self is the instance, this is equivalent to saying jeff.name = name, which is the same as jeff.name = 'Jeff Knupp. Similarly, self.balance = balance is the same as jeff.balance = 1000.0. After these two lines, we consider the Customer object "initialized" and ready for use. Be careful what you __init__ After init has finished, the caller can rightly assume that the object is ready to use. That is, after jeff = Customer('Jeff Knupp', 1000.0), we can start making deposit and withdraw calls on jeff; jeff is a fully-initialized object.

一个简单的说明性例子

希望它能有所帮助，这里有一个简单的例子，我用它来理解在类中声明的变量和在__init__函数中声明的变量之间的区别:

class MyClass(object):
    i = 123
    def __init__(self):
        self.i = 345
     
a = MyClass()
print(a.i)
print(MyClass.i)

输出:

345
123

是的，你是对的，这些是oop结构。

__init__是类的构造函数。self形参引用对象的实例(在c++中就像这样)。

class Point:
    def __init__(self, x, y):
        self._x = x
        self._y = y

__init__方法在对象的内存被分配后被调用:

x = Point(1,2)

如果你想在对象中持久化这个值，在对象的方法中使用self参数是很重要的。例如，如果你像这样实现__init__方法:

class Point:
    def __init__(self, x, y):
        _x = x
        _y = y

您的x和y参数将存储在堆栈上的变量中，当init方法超出作用域时将被丢弃。将这些变量设置为self。_x和self。_y将这些变量设置为Point对象的成员(在对象的生命周期内都可以访问)。

注意:对这个回答中“构造者”一词的使用做了一些澄清。从技术上讲，在Python中，“构造函数”的职责被划分为两个方法。这些方法是__new__(负责分配内存)和__init__(如本文所述，负责初始化新创建的实例)。

类对象支持两种操作:属性引用和实例化

属性引用使用Python中所有属性引用使用的标准语法:obj.name。有效属性名是创建类对象时类名称空间中的所有名称。所以，如果类定义是这样的:

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

    def f(self):
        return 'hello world'

然后MyClass。i和MyClass。F是有效的属性引用，分别返回一个整数和一个函数对象。类属性也可以被赋值，所以你可以改变MyClass的值。我被指派。__doc__也是一个有效的属性，返回属于类的文档字符串:" a simple example class"。

类实例化使用函数表示法。假设类对象是一个返回类的新实例的无参数函数。例如:

x = MyClass()

实例化操作(“调用”类对象)创建一个空对象。许多类喜欢用自定义为特定初始状态的实例创建对象。因此，类可以定义一个名为__init__()的特殊方法，如下所示:

def __init__(self):
    self.data = []

当类定义__init__()方法时，类实例化会自动为新创建的类实例调用__init__()。所以在这个例子中，一个新的，初始化的实例可以通过:

x = MyClass()

当然，__init__()方法可能有参数以获得更大的灵活性。在这种情况下，给类实例化操作符的参数被传递给__init__()。例如,

class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart

x = Complex(3.0, -4.5)
x.r, x.i

这是从官方文件中截取的，最终对我帮助最大。

这是我的例子

class Bill():
    def __init__(self,apples,figs,dates):
        self.apples = apples
        self.figs = figs
        self.dates = dates
        self.bill = apples + figs + dates
        print ("Buy",self.apples,"apples", self.figs,"figs 
                and",self.dates,"dates. 
                Total fruitty bill is",self.bill," pieces of fruit :)")

创建类Bill的实例时:

purchase = Bill(5,6,7)

你会得到:

> Buy 5 apples 6 figs and 7 dates. Total fruitty bill is 18  pieces of
> fruit :)

self是类实例的引用

class foo:
    def bar(self):
            print "hi"

现在我们可以创建一个foo实例并调用它的方法，self参数在本例中由Python添加:

f = foo()
f.bar()

但是如果方法调用不在类实例的上下文中，它也可以被传入，下面的代码做同样的事情

f = foo()
foo.bar(f)

有趣的是，变量名“self”只是一种约定。下面的定义将工作完全相同..说了这么多，这是一种非常强烈的惯例，应该一直遵循，但它确实说明了语言的灵活性

class foo:
    def bar(s):
            print "hi"

在这段代码中:

class A(object):
    def __init__(self):
        self.x = 'Hello'

    def method_a(self, foo):
        print self.x + ' ' + foo

．.． self变量表示对象本身的实例。大多数面向对象语言将此作为一个隐藏参数传递给对象上定义的方法;Python则不然。你必须显式地声明它。当你创建一个A类的实例并调用它的方法时，它将被自动传递，就像在…

a = A()               # We do not pass any argument to the __init__ method
a.method_a('Sailor!') # We only pass a single argument

__init__方法大致代表Python中的构造函数。当你调用A()时，Python为你创建一个对象，并将其作为第一个参数传递给__init__方法。任何额外的参数(例如，A(24， 'Hello'))也会作为参数传递——在这种情况下会引发异常，因为构造函数并不期望它们。