为什么python中的每个方法都需要相应的类函数？

我正在学习python中的OOP以及下面的和stackoverflow的答案

我理解类是如何工作的，方法是如何调用的，以及所有的事情，但我有一些疑问：

考虑以下代码片段：

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


    def distance(self):
         print (self.x)

    def bye(self):
        print(self.y)

a=Point(1,2)
a.distance()
a.bye()

正如我在教程中所读到的：

当我们调用带有一些参数的方法时，相应的类 函数是通过将方法的对象放在第一个 论点所以，像obj.meth（args）这样的东西变成Class.meth（obj， args）

当调用ObjectA.methodA（arg1，arg2）时，python会在内部进行转换 它为您提供以下服务：

类A.methodA（对象A、arg1、arg2）

现在我的困惑是为什么程序需要用每个方法调用类

类别.方法（对象，参数）

比如当我们称之为距离时，它就变成了点。距离（a）是“自我”的原因 当我们说“再见”时，它就成了“自我”的原因

当每个方法都需要点类时，如果我们不在每个方法中使用点类，会发生什么

为什么简单的meth（obj，args）不能起作用

我主要的疑问是，当我们用method的属性调用时，为什么它会用每个方法调用class.u方法。为什么每个人都需要它

#如果我理解正确，那么这是必要的，因为每个方法都可以访问其他方法的数据，如变量和内容？

关键是

python在内部为您转换它

从你的观点来看：

• meth（self，args）

  是用于定义成员函数的语法；及

• obj.meth（args）

  是用于调用成员函数的语法

meth（obj，args）

选项是过程语言的工作方式。这通常是实现的工作方式，但是将调用表示为

obj.meth（args）

可以保持对对象的关注，并更容易读取正在使用的数据值（对象实例）

编辑1如果我正确理解了您的问题，您会问为什么Python需要知道类，而它已经有了可用的实例，并且实例知道它们自己的类型。实际上，Python基于实例获取方法。我认为本教程的要点是，在Python中，类是定义函数的主要位置。这与一些面向对象的语言不同，在这些语言中，每个实例都有自己的方法，而且它们之间可能完全不同。因此，本教程对比了Python中常用的方法：

class Foo:
    def bar(self):
        pass

另一种选择（在Python中可能，但不典型）：

edit2Python方法通常存在于类中，而不是实例中。即使创建1000个

Point

对象，也只有一个

Point.distance

的实际指令字节副本。只要调用

.distance（）

，这些指令字节就会被执行。正确的是，

self

参数表示这些指令字节如何知道要处理哪个实例，以及该方法如何访问所传递实例中的其他数据

edit3

self

并不像本地和全局那样是一个名称空间。但是，可以公平地说，

self.foo

指的是一个

foo

，它确实可以被当前类的这个实例的所有方法访问。给定

a = Point(1,2)
b = Point(3,4)

在

点内。距离
呼叫，
self
指
a
或
b
，但不是两者都指。因此，当您调用
a.distance（）
时，
self.x
将是
a.x
，而不是
b.x
。但是
Point
的所有方法都可以访问
self.x
来获取当前点的
x
是什么

编辑4假设您没有使用对象，而是使用字典：

a = {'x':1, 'y':2}  # make a "point"
b = {'x':3, 'y':4}  # make another

def point_distance(point):
    print (point['x'])

然后你可以说：

point_distance(a)

起作用

print (a['x'])

类基本上做到了这一点，语法更清晰，并且有一些好处。但是正如
点
参数到
点距离（）
每次调用
点距离（）
时引用一个且仅一个类似点的字典一样，
self
参数到
点距离（）
每次调用
点距离（）时引用一个且仅一个
点
实例
类定义了它们的所有实例的共同点。通常这是包含其每个方法的代码。要将此代码应用于正确的实例对象，该语言将解释

instance.method(arg1, arg2, ...)

作为

因此，代码将应用于适当的类实例。
因为在不同的类中可以有相同的方法名，它需要调用适当的方法名。所以如果你有

class Class1:
    def meth():
        print "This is Class 1"

class Class2:
    def meth():
        print "This is Class 2"

c1 = Class1()
c2 = Class2()
c1.meth() # equivalent to Class1.meth(c1)
c2.meth() # equivalent to Class2.meth(c2)

如果它将
c1.meth（）
转换为
meth（c1）
，系统将无法知道要调用哪个
meth（）
函数。
“它将成为Point.a.distance（）”：它不会这样做。它变成了
Point.distance（a）
或
type（a）.distance（a）
我最初的问题是为什么python需要像这样进行内部转换？？我的意思是为什么有必要在每个类中附加“self”？所以如果我是正确的，那么我可以假设结论是“self”，将当前类的所有方法的局部名称空间更改为变量的全局名称空间。（只适用于当前课程，不适用于其他课程）先生，是的，现在我非常接近我真正想知道的，我想你知道的正是我想知道的，你的最后几行是我想要知道的，请更简要地解释你在最后几行写了什么，我需要什么，先生，请再解释一下。@Eleutetio试试看。此外，如果您还没有，请查看，以了解有关如何充分利用该网站的更多信息！
class_of_instance.method(instance, arg1, arg2, ...)

class Class1:
    def meth():
        print "This is Class 1"

class Class2:
    def meth():
        print "This is Class 2"

c1 = Class1()
c2 = Class2()
c1.meth() # equivalent to Class1.meth(c1)
c2.meth() # equivalent to Class2.meth(c2)