这是一个函数，它属于一个类：

class C:
    def my_method(self):
        print("I am a C")

c = C()
c.my_method()  # Prints("I am a C")

就这么简单！
（也有一些方法可以让你控制类和函数之间的关系，但我猜你问的不是这个，而是基本的。）

一个方法是一个函数，它将一个类示例作为它的第一个参数。方法是类的成员。

class C:
    def method(self, possibly, other, arguments):
        pass # do something here

正如你想知道它在Python中的具体含义，我们可以区分绑定和未绑定方法。在Python中，所有函数（同样也包括方法）都是可以传递和“玩弄”的对象。因此，未绑定和绑定方法的区别是：
1)绑定方法

# Create an instance of C and call method()
instance = C()

print instance.method # prints '<bound method C.method of <__main__.C instance at 0x00FC50F8>>'
instance.method(1, 2, 3) # normal method call

f = instance.method
f(1, 2, 3) # method call without using the variable 'instance' explicitly

绑定方法是属于类的示例的方法。在这个例子中，instance.method绑定到名为instance的示例。每次调用绑定方法时，该示例都会作为第一个参数自动传递--按照惯例称为self。
2)未绑定方法

print C.method # prints '<unbound method C.method>'
instance = C()
C.method(instance, 1, 2, 3) # this call is the same as...
f = C.method
f(instance, 1, 2, 3) # ..this one...

instance.method(1, 2, 3) # and the same as calling the bound method as you would usually do

当你访问C.method（类中的方法，而不是示例中的方法）时，你会得到一个未绑定的方法。如果你想调用它，你必须把示例作为第一个参数传递，因为这个方法 * 没有 * 绑定到任何示例。
了解了这个区别，你就可以把函数/方法作为对象来使用，比如传递方法。作为一个例子，想象一个API，它允许你定义一个回调函数，但是你想提供一个方法作为回调函数。没问题，只要传递self.myCallbackMethod作为回调函数，它就会自动被调用，示例作为第一个参数。（或只以奸计）。
希望你明白了）我认为这就是你应该知道的所有关于方法的基础知识。你还可以阅读更多关于classmethod和staticmethod装饰器的内容，但那是另一个主题。

在Python中，方法是一个函数，因为对象的类型而对给定的对象可用。
例如，如果创建my_list = [1, 2, 3]，则append方法可以应用于my_list，因为它是一个Python列表：my_list.append(4)。所有列表都有一个append方法，因为它们是列表。
再举一个例子，如果你创建了my_string = 'some lowercase text'，那么upper方法可以应用于my_string，因为它是一个Python字符串：my_string.upper() .
列表没有upper方法，字符串也没有append方法，为什么呢？因为方法只存在于一个特定的对象中，如果它们已经为该类型的对象显式地定义了，而Python的开发人员（到目前为止）已经决定，那些特定的方法对于那些特定的对象来说是不需要的。
要调用一个方法，格式为object_name.method_name()，方法的所有参数都列在括号中。方法隐式作用于被命名的对象，因此有些方法没有任何声明的参数，因为对象本身是唯一必需的参数。例如，my_string.upper()没有任何列出的参数，因为唯一必需的参数是对象本身。my_string .
以下是一个常见的混淆点：

import math
math.sqrt(81)

sqrt是math对象的方法吗？不是。这是从math模块调用sqrt函数的方式。使用的格式是module_name.function_name()，而不是object_name.method_name()。通常，区分这两种格式的唯一方法（视觉上）是查看代码的其余部分，看看句点之前的部分（math，my_list，my_string）是否定义为对象或模块。

抱歉，但是--在我看来--RichieHinder说那个方法是完全正确的...
这是一个函数，它是一个类的成员。
下面是一个函数成为类成员的例子。从那时起，它就像类的一个方法。让我们从 empty 类和带一个参数的普通函数开始：

>>> class C:
...     pass
...
>>> def func(self):
...     print 'func called'
...
>>> func('whatever')
func called

现在我们向C类添加一个成员，它是对函数的引用。之后，我们可以创建类的示例并调用其方法，就像它是在类内部定义的一样：

>>> C.func = func
>>> o = C()
>>> o.func()
func called

我们也可以使用另一种方法调用该方法：

>>> C.func(o)
func called

o.func甚至以与类方法相同的方式体现：

>>> o.func
<bound method C.func of <__main__.C instance at 0x000000000229ACC8>>

我们可以尝试相反的方法，定义一个类，并将它的方法作为一个函数：

>>> class A:
...     def func(self):
...         print 'aaa'
...
>>> a = A()
>>> a.func
<bound method A.func of <__main__.A instance at 0x000000000229AD08>>
>>> a.func()
aaa

到目前为止，它看起来是一样的。现在函数窃取：

>>> afunc = A.func
>>> afunc(a)
aaa

事实是，该方法不接受“whatever”参数：

>>> afunc('whatever')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unbound method func() must be called with A instance as first 
  argument (got str instance instead)

IMHO，这不是反对 * 方法是一个函数，是一个类的成员 * 的参数。

后来发现的Alex Martelli's answer，基本上说的是一样的。抱歉，如果你认为它重复：）

http://docs.python.org/2/tutorial/classes.html#method-objects
通常，方法在绑定后立即被调用：

x.f()

在MyClass示例中，这将返回字符串'hello world'。但是，不必立即调用方法：x. f是一个方法对象，可以存储起来，以后再调用。例如：

xf = x.f
while True:
    print xf()

将继续打印你好世界直到时间的尽头。
当一个方法被调用时，究竟发生了什么？你可能已经注意到，x. f（）被调用时没有使用上述参数，尽管f（）的函数定义指定了一个参数。参数发生了什么？当一个需要参数的函数被调用时，Python肯定会引发一个异常--即使该参数实际上并没有被使用......
其实，你可能已经猜到了答案：方法的特殊之处在于对象是作为函数的第一个参数传递的。在我们的例子中，调用x. f（）完全等价于MyClass. f（x）。一般来说，调用一个包含n个参数的方法等价于调用一个包含一个参数列表的函数，该参数列表是通过在第一个参数之前插入该方法的对象而创建的。
如果你仍然不明白方法是如何工作的，看一下实现也许可以澄清问题。当引用一个示例属性而不是数据属性时，它的类被搜索。如果名称表示一个有效的类属性是一个函数对象，则通过将示例对象和函数对象打包（指针指向）到一个抽象对象中来创建一个方法对象：这是方法对象。2当方法对象被一个参数列表调用时，一个新的参数列表将从示例对象和参数列表中构造出来，函数对象将被这个新的参数列表调用。

如果你认为对象类似于名词，那么方法就类似于动词。在对象（如字符串或列表）之后使用方法，可以将方法的操作应用于对象。

要理解方法，首先必须考虑面向对象编程：让我们把一辆车作为一个类。所有的车都有共同的东西，也有使它们独特的东西，例如，所有的车都有4个轮子，车门，方向盘......但你的个人车（让我们称之为，my_toyota）是红色的，在5. 6秒内从0 - 60进一步车目前位于我家，门是锁着的，后备箱是空的...所有这些都是my_toyota示例的属性。your_honda可能在路上，后备箱装满了杂货...
但是你可以用汽车做一些事情，你可以开它，你可以开门，你可以装载它，你可以用汽车做的这些事情是汽车的方法，它们改变了特定示例的属性.
作为伪代码，您可以：

my_toyota.drive(shop)

将地点从我家更改为商店，或

my_toyota.load([milk, butter, bread]

这样，箱子里就装满了[牛奶、黄油、面包]。
这样的方法实际上是充当对象一部分的函数：

class Car(vehicle)
    n_wheels = 4

    load(self, stuff):
    '''this is a method, to load stuff into the trunk of the car'''
        self.open_trunk
        self.trunk.append(stuff)
        self.close_trunk

则代码将为：

my_toyota = Car(red)
my_shopping = [milk, butter, bread]
my_toyota.load(my_shopping)

方法是“属于"对象并具有特定名称的函数：

obj.methodname

其中obj是某个对象（可能是表达式），methodname是由该对象的类型定义的方法的名称。
值得注意的是：我们像调用其他函数一样调用方法。2更多信息可以在python教程中找到。

• • python文档解释了一个方法**，如下所示：

......方法是"属于"对象的函数。（在Python中，术语"方法"并不是类示例所独有的：其他对象类型也可以有方法。例如，列表对象有方法，称为append，insert，remove，sort等等。
并且，python doc还解释了关于一个函数的说明，如下所示：
一系列的语句，它向调用程序返回某个值，也可以给它传递零个或多个参数，这些参数在语句体的执行过程中可能会用到。
而且，python文档还解释了对象，如下所示：
对象是Python对数据的抽象。Python程序中的所有数据都由对象或对象之间的关系表示。（在某种意义上，与冯·诺依曼的"存储程序计算机"模型一致，代码也由对象表示。）
每个对象都有一个标识、一个类型和一个值。你可以把它看作是对象在内存中的地址。"is"操作符比较两个对象的标识;函数的作用是：返回一个整数。