oop - 方法和函数有什么区别？

Question

有人可以在 OOP 上下文中提供方法与函数的简单解释吗？

Answer 1

函数是一段按名称调用的代码。它可以传递数据进行操作（即参数），也可以选择返回数据（返回值）。传递给函数的所有数据都是显式传递的。

方法是一段由与对象关联的名称调用的代码。在大多数方面，它与函数相同，除了两个关键区别：

1. 方法被隐式传递给调用它的对象。
2. 方法能够对包含在类中的数据进行操作（请记住，对象是类的实例——类是定义，对象是该数据的实例）。

（这是一个简化的解释，忽略了范围等问题。）

Answer 2

方法在对象上或在类中是静态的。
函数独立于任何对象（并且在任何类之外）。

对于 Java 和 C#，只有方法。
对于 C，只有函数。

对于 C++ 和 Python，这取决于你是否在课堂上。
但在基础英语中：

• 功能：独立的特性或功能。
• 方法：做某事的一种方式，它有不同的方法或方法，但与同一方面（又名类）相关。

Answer 3

'method'是'function'的面向对象的词。这几乎就是它的全部内容（即，没有真正的区别）。

不幸的是，我认为这里的很多答案都在延续或推进存在一些复杂、有意义的差异的想法。

真的 - 没有那么多，只是对同一件事有不同的说法。

[后期补充]

---

事实上，正如Brian Neal在对这个问题的评论中指出的那样，C++ 标准在提及成员函数时从不使用术语“方法”。有些人可能会认为这表明 C++ 并不是真正的面向对象语言。但是，我更愿意将其视为一个非常聪明的群体认为没有特别充分的理由使用不同术语的迹象。

Answer 4

一般来说：方法是属于一个类的函数，函数可以在代码的任何其他范围内，因此您可以声明所有方法都是函数，但并非所有函数都是方法：

以以下 python 示例为例：

class Door:
  def open(self):
    print 'hello stranger'

def knock_door:
  a_door = Door()
  Door.open(a_door)

knock_door()

给出的示例向您展示了一个名为“Door”的类，它有一个名为“open”的方法或动作，它被称为方法，因为它是在一个类中声明的。代码的另一部分“def”就在下面，它定义了一个函数，它是一个函数，因为它没有在类中声明，这个函数调用我们在类中定义的方法，如你所见，最后这个函数被自己调用。

如您所见，您可以在任何地方调用函数，但是如果要调用方法，则必须传递与声明该方法的类相同类型的新对象（Class.method（object）），或者必须调用对象内部的方法（object.Method()），至少在python中。

将方法视为只有一个实体可以做的事情，所以如果你有一个 Dog 类，那么只在该类内部有一个 bark 函数是有意义的，这将是一个方法，如果你还有一个 Person 类，它可能是有意义的为它写一个不属于任何类的函数“feed”，因为人类和狗都可以被喂食，你可以称它为一个函数，因为它不属于任何特定的类。

Answer 5

简单的记忆方法：

• 功能→免费（免费意味着它可以在任何地方，无需在对象或类中）
• 方法 → M ember（对象或类的成员）

Answer 6

Function和Method之间主要区别的一个非常笼统的定义：

函数是在类之外定义的，而方法是在类内部和类的一部分中定义的。

Answer 7

如果您想在这里阅读“我的 OO 方法介绍”

面向对象范式背后的想法是“威胁”软件由......以及“对象”组成。现实世界中的对象具有属性，例如，如果您有一个员工，该员工有一个姓名、一个员工 ID、一个职位、他属于一个部门等等。

对象也知道如何处理它的属性并对它们执行一些操作。假设我们想知道员工现在在做什么，我们会问他。

employe whatAreYouDoing.

“whatAreYouDoing”是发送给对象的“消息”。对象知道如何回答这些问题，据说它有解决问题的“方法”。

因此，对象必须公开其行为的方式称为方法。因此，方法是工件对象必须“做”某事。

其他可能的方法是

employee whatIsYourName
employee whatIsYourDepartmentsName

等等

另一方面，函数是编程语言必须计算某些数据的方式，例如，您可能拥有返回 16 的函数 addValues( 8 , 8 )

// pseudo-code
function addValues( int x, int y )  return x + y 
// call it 
result = addValues( 8,8 )
print result // output is 16...

由于第一个流行的编程语言（例如 fortran、c、pascal）没有涵盖 OO 范式，它们只调用这些工件“函数”。

例如，C 中的前一个函数是：

int addValues( int x, int y ) 
{
   return x + y;
}

说一个对象具有执行某些操作的“函数”是不“自然的”，因为函数与数学内容更相关，而 Employee 几乎没有数学知识，但是您可以拥有与函数完全相同的方法，例如在 Java 中，这将是等效的 addValues 函数。

public static int addValues( int x, int y ) {
    return x + y;
}

看起来很熟悉？那是因为 Java 的根源在于 C++，而 C++ 源于 C。

最后只是一个概念，在实现中它们可能看起来相同，但在 OO 文档中这些被称为方法。

这是 Java 中以前的 Employee 对象的示例。

public class Employee {

    Department department;
    String name;

    public String whatsYourName(){
        return this.name;
    }
    public String whatsYourDeparmentsName(){
         return this.department.name();
    }
    public String whatAreYouDoing(){
        return "nothing";
    } 
    // Ignore the following, only set here for completness
    public Employee( String name ) {
        this.name = name;
    }

}

// Usage sample.
Employee employee = new Employee( "John" ); // Creates an employee called John

// If I want to display what is this employee doing I could use its methods.
// to know it.
String name = employee.whatIsYourName():
String doingWhat = employee.whatAreYouDoint();

// Print the info to the console.

 System.out.printf("Employee %s is doing: %s", name, doingWhat );

Output:
Employee John is doing nothing.

那么，区别在于应用它的“域”。

AppleScript 有“自然语言”matphor 的想法，在某些时候 OO 有。例如 Smalltalk。我希望在阅读本文后，您可以更容易地理解对象中的方法。

注意：代码不编译，仅作为示例。随意修改帖子并添加 Python 示例。

Answer 8

在 OO 世界中，这两者通常用于表示同一事物。

从纯数学和 CS 的角度来看，当使用相同的参数 ( f(x,y) = (x + y) ) 调用时，函数将始终返回相同的结果。另一方面，方法通常与类的实例相关联。尽管如此，大多数现代 OO 语言在大多数情况下不再使用术语“函数”。许多静态方法可能与函数非常相似，因为它们通常没有状态（并非总是如此）。

Answer 9

假设一个函数是一段代码（通常有自己的作用域，有时也有自己的闭包），它可以接收一些参数，也可以返回一个结果。

方法是一个对象拥有的函数（在一些面向对象的系统中，更正确的说法是它由一个类拥有）。被对象/类“拥有”意味着您通过对象/类引用方法；例如，在 Java 中，如果要调用对象“door”拥有的方法“open()”，则需要编写“door.open()”。

通常方法还会获得一些额外的属性来描述它们在对象/类中的行为，例如：可见性（与面向对象的封装概念相关），它定义了可以从哪些对象（或类）调用方法。

在许多面向对象的语言中，所有“函数”都属于某个对象（或类），因此在这些语言中没有不是方法的函数。

Answer 10

方法是类的函数。用普通的术语来说，人们到处交换方法和功能。基本上您可以将它们视为同一事物（不确定全局函数是否称为方法）。

http://en.wikipedia.org/wiki/Method_(computer_science)

Answer 11

函数是一个数学概念。例如：

f(x,y) = sin(x) + cos(y)

表示函数 f() 将返回第一个参数的 sin 添加到第二个参数的余弦。这只是数学。碰巧 sin() 和 cos() 也是函数。函数还有另一个属性：对具有相同参数的函数的所有调用都应该返回相同的结果。

另一方面，方法是与面向对象语言中的对象相关的函数。它有一个隐含的参数：被操作的对象（以及它的状态）。

因此，如果您有一个带有方法 g(x) 的对象 Z，您可能会看到以下内容：

Z.g(x) = sin(x) + cos(Z.y)

在这种情况下，参数 x 被传入，与前面的函数示例相同。但是，cos() 的参数是存在于对象 Z 内部的值。Z 和存在于其中的数据 (Zy) 是 Z 的 g() 方法的隐式参数。

Answer 12

从历史上看，“方法”是不返回值的东西，而“函数”是返回值的东西，这可能存在细微差别。每种语言都有自己的具有特殊含义的术语词典。

在“C”中，“函数”一词表示程序例程。

在Java中，术语“函数”没有任何特殊含义。而“方法”是指形成类实现的例程之一。

在C#中，这将翻译为：

public void DoSomething() {} // method
public int DoSomethingAndReturnMeANumber(){} // function

但实际上，我重申这两个概念确实没有区别。如果您在有关 Java 的非正式讨论中使用术语“函数”，人们会认为您的意思是“方法”并继续。不要在有关 Java 的适当文档或演示文稿中使用它，否则你会看起来很傻。

Answer 13

函数或方法是一段命名的可调用代码，它执行一些操作并可选地返回一个值。

在C语言中，使用术语函数。Java和C#人们会说它是一种方法（在这种情况下，函数是在类/对象中定义的）。

C ++程序员可能将其称为函数或有时方法（取决于他们是否正在编写过程风格的 C++ 代码或正在执行 C++ 的面向对象方式，只有 C/C++ 的程序员也可能将其称为函数，因为术语“方法”是在 C/C++ 文献中较少使用）。

您只需调用函数的名称即可使用函数，

result = mySum(num1, num2);

您可以通过首先引用其对象来调用方法，例如，

result = MyCalc.mySum(num1,num2);

Answer 14

函数是一组可用于操作数据的逻辑。

而Method是用于操作其所属对象的数据的函数。所以从技术上讲，如果你有一个与你的类不完全相关但在类中声明的函数，它不是方法；这被称为糟糕的设计。

Answer 15

在诸如 Object Pascal 或 C++ 之类的 OO 语言中，“方法”是与对象关联的函数。因此，例如，“Dog”对象可能具有“bark”功能，这将被视为“Method”。相反，“StrLen”函数是独立的（它提供作为参数提供的字符串的长度）。因此它只是一个“功能”。Javascript 在技术上也是面向对象的，但与 C++、C# 或 Pascal 等成熟语言相比，它面临许多限制。尽管如此，这种区别应该仍然存在。

一些额外的事实：C# 完全面向对象，因此您不能创建独立的“函数”。在 C# 中，每个函数都绑定到一个对象，因此从技术上讲，它是一个“方法”。关键是 C# 中很少有人将它们称为“方法”——他们只是使用术语“函数”，因为没有任何真正的区别。

最后——所以任何 Pascal 大师都不会在这里跳到我身上——Pascal 还区分了“函数”（返回值）和“过程”，后者没有。尽管您当然可以选择是否返回值，但 C# 并没有明确地做出这种区分。

Answer 16

类上的方法作用于类的实例，称为对象。

class Example
{
   public int data = 0; // Each instance of Example holds its internal data. This is a "field", or "member variable".

   public void UpdateData() // .. and manipulates it (This is a method by the way)
   {
      data = data + 1;
   }

   public void PrintData() // This is also a method
   {
      Console.WriteLine(data);
   }
}

class Program
{
   public static void Main()
   {
       Example exampleObject1 = new Example();
       Example exampleObject2 = new Example();

       exampleObject1.UpdateData();
       exampleObject1.UpdateData();

       exampleObject2.UpdateData();

       exampleObject1.PrintData(); // Prints "2"
       exampleObject2.PrintData(); // Prints "1"
   }
}

Answer 17

既然您提到了 Python，以下可能是大多数现代面向对象语言中方法和对象之间关系的有用说明。简而言之，他们所谓的“方法”只是一个传递额外参数的函数（正如其他答案所指出的那样），但 Python 比大多数语言更明确。

# perfectly normal function
def hello(greetee):
  print "Hello", greetee

# generalise a bit (still a function though)
def greet(greeting, greetee):
  print greeting, greetee

# hide the greeting behind a layer of abstraction (still a function!)
def greet_with_greeter(greeter, greetee):
  print greeter.greeting, greetee

# very simple class we can pass to greet_with_greeter
class Greeter(object):
  def __init__(self, greeting):
    self.greeting = greeting

  # while we're at it, here's a method that uses self.greeting...
  def greet(self, greetee):
    print self.greeting, greetee

# save an object of class Greeter for later
hello_greeter = Greeter("Hello")

# now all of the following print the same message
hello("World")
greet("Hello", "World")
greet_with_greeter(hello_greeter, "World")
hello_greeter.greet("World")

现在比较函数greet_with_greeter和方法greet：唯一的区别是第一个参数的名称（在函数中我称之为“greeter”，在方法中我称之为“self”）。所以我可以以greet与使用函数完全相同的方式使用该greet_with_greeter方法（使用“点”语法来获取它，因为我在一个类中定义了它）：

Greeter.greet(hello_greeter, "World")

所以我有效地将一个方法变成了一个函数。我可以把一个函数变成一个方法吗？好吧，因为 Python 让你在定义类之后搞乱它们，让我们试试：

Greeter.greet2 = greet_with_greeter
hello_greeter.greet2("World")

是的，该函数greet_with_greeter现在也称为方法greet2。这显示了方法和函数之间唯一真正的区别：当您通过调用“在”对象上调用方法时object.method(args)，语言会神奇地将其转换为method(object, args).

（OO 纯粹主义者可能会争辩说方法与函数不同，如果您进入高级 Python 或 Ruby - 或 Smalltalk！ - 您将开始明白他们的观点。此外，有些语言为方法提供对对象的位的特殊访问。但是主要的概念差异仍然是隐藏的额外参数。）

Answer 18

对我来说：如果我同意，方法和函数的功能是相同的：

• 一个函数可以返回一个值
• 可能期望参数

就像任何一段代码一样，你可能有你放入的对象，你可能有一个对象作为结果。在这样做的过程中，他们可能会改变对象的状态，但这不会改变他们对我的基本功能。

在调用对象或其他代码的函数时可能存在定义差异。但这不就是语言上的区别，这就是人们交换它们的原因吗？我会小心提到的计算示例。因为我雇了员工来做我的计算：

new Employer().calculateSum( 8, 8 );

通过这样做，我可以依靠负责计算的雇主。如果他想要更多的钱，我会释放他，让碳素收集器处理闲置员工的功能来完成剩下的工作，并聘请一名新员工。

即使争论一个方法是一个对象函数而一个函数是非连接计算也无济于事。函数描述符本身以及理想情况下函数的文档将告诉我它需要什么以及它可能返回什么。其余的，比如操纵某个对象的状态对我来说并不是真正透明的。我确实希望函数和方法都能交付和操纵他们声称的内容，而无需详细了解他们是如何做到的。即使是纯计算函数也可能会更改控制台的状态或附加到日志文件。

Answer 19

让我们不要把应该是一个非常简单的答案复杂化。方法和函数是一回事。当函数在类外部时，您将其称为函数，而在将函数编写在类内部时，将其称为方法。

Answer 20

据我了解，方法是可以对类执行的任何操作。它是编程中使用的通用术语。

在许多语言中，方法由函数和子例程表示。大多数语言用于这些的主要区别是函数可能会将值返回给调用者，而子例程可能不会。然而，许多现代语言只有函数，但这些函数可以选择不返回任何值。

例如，假设您想描述一只猫，并且希望它能够打哈欠。您将创建一个带有 Yawn 方法的 Cat 类，它很可能是一个没有任何返回值的函数。

Answer 21

对于一阶近似，方法（在 C++ 风格的 OO 中）是成员函数的另一个词，即作为类的一部分的函数。

在像 C/C++ 这样的语言中，你可以拥有不是类成员的函数；您不会将与类无关的函数称为方法。

Answer 22

恕我直言，当人们想要引用对象内部的函数时，他们只是想发明一个新词来简化程序员之间的交流。

如果您说的是方法，那么您的意思是类中的函数。如果您说的是函数，那么您的意思只是类外的函数。

事实上，这两个词都是用来描述功能的。即使您错误地使用它，也不会发生任何错误。这两个词都很好地描述了您希望在代码中实现的目标。

函数是必须发挥作用（函数）做某事的代码。方法是解决问题的方法。

它做同样的事情。这是同样的事情。如果您想要超级精确并遵守约定，您可以将方法称为对象内部的函数。

Answer 23

函数是主要属于面向过程的编程的概念，其中函数是可以处理数据并返回值的实体

方法是面向对象编程的概念，其中方法是类的成员，主要对类成员进行处理。

Answer 24

我不是专家，但这是我所知道的：

1. 函数是C语言术语，它指的是一段代码，函数名将是使用该函数的标识符。

2. 方法是面向对象的术语，通常它在函数参数中有一个 this 指针。你不能像C那样调用这段代码，你需要使用对象来调用它。

3. 调用方法也不同。这里调用意思就是找到这段代码的地址。C/C++，链接的时候会使用函数符号来定位。

4. Objective-C 是不同的。调用意思是一个 C 函数使用数据结构来查找地址。这意味着在运行时一切都是已知的。

Answer 25

我知道很多其他人已经回答了，但我发现以下是一个简单但有效的单行答案。虽然它看起来并不比这里的其他答案好很多，但如果你仔细阅读它，它会包含你需要了解的关于方法与功能的一切。

方法是具有定义接收器的函数，在 OOP 术语中，方法是对象实例上的函数。

Answer 26

类是一些数据和函数的集合，可以选择使用构造函数。

当您创建该特定类的实例（复制、复制）时，构造函数会初始化该类并返回一个对象。

现在类成为对象（没有构造函数）&函数在对象上下文中被称为方法。

所以基本上

类<==新==>对象

函数<==新==>方法

在java中，通常被告知构造函数名称与类名称相同，但实际上构造函数类似于实例块和静态块，但具有用户定义的返回类型（即类类型）

而类可以有一个静态块，实例块，构造函数，函数对象通常只有数据和方法。

Answer 27

函数 - 独立代码段中的函数，其中包含一些逻辑，必须独立调用 并在类之外定义。

方法 - 方法是一段独立的代码，它在引用某个对象时被调用，并在类中定义。

Answer 28

TL;博士

函数是一段要运行的代码。
方法是对象内部的函数。

函数示例：

function sum(){
  console.log("sum")l
}

方法示例：

const obj = {
a:1,
b:2,
sum(){
  }
}

所以这就是为什么我们说函数中的“this”关键字不是很有用，除非我们将它与调用、应用或绑定一起使用。因为调用、应用、绑定将调用该函数作为对象内部的方法 ==> 基本上它将函数转换为方法

Answer 29

在 C++ 中，有时使用方法来反映类的成员函数的概念。但是，最近我在《C++ 编程语言第 4 版》一书中的第 586 页“派生类”中找到了一条语句

虚函数有时也称为方法。

这有点令人困惑，但他有时会说，所以大致有道理，C++ 创建者倾向于将方法视为可以在对象上调用的函数，并且可以表现出多态性。

Answer 30

以下是使用 JavaScript 示例对方法与函数的一些解释：

test(20, 50);是函数定义并用于运行一些步骤或返回可以在某处存储/使用的东西。

您可以重用代码：定义一次代码并多次使用它。

您可以使用不同的参数多次使用相同的代码，以产生不同的结果。

var x = myFunction(4, 3);   // Function is called, return value will end up in x

function myFunction(a, b) {
    return a * b;          // Function returns the product of a and b
}

var test = something.test();这里 test() 可以是某个对象的方法，也可以是为内置对象自定义的原型，这里有更多解释：

JavaScript 方法是可以对对象执行的操作。

JavaScript 方法是包含函数定义的属性。

javascript中字符串的内置属性/方法：

var message = "Hello world!";
var x = message.toUpperCase();
//Output: HELLO WORLD!

自定义示例：

function person(firstName, lastName, age, eyeColor) {
    this.firstName = firstName;  
    this.lastName = lastName;
    this.age = age;
    this.eyeColor = eyeColor;
    this.changeName = function (name) {
        this.lastName = name;
    };
}

something.changeName("SomeName"); //This will change 'something' objject's name to 'SomeName'

您也可以为字符串、数组等定义属性，例如

String.prototype.distance = function (char) {
    var index = this.indexOf(char);

    if (index === -1) {
        console.log(char + " does not appear in " + this);
    } else {
        console.log(char + " is " + (this.length - index) + " characters from the end of the string!");
    }
};

var something = "ThisIsSomeString"

// now use distance like this, run and check console log

something.distance("m");

一些参考资料：Javascript Object Method , Functions , More info on prototype

Answer 31

方法和函数之间的区别

通过阅读Microsoft 上的此文档

包含可执行代码的成员统称为类的函数成员。上一节描述了方法，它们是主要的函数成员。本节介绍 C# 支持的其他类型的函数成员：构造函数、属性、索引器、事件、运算符和终结器。

所以方法是函数的子集。每个方法都是函数，但不是每个函数都是方法，例如，aconstructor不能说是方法，但它是函数。

Answer 32

简而言之：非静态（“instance”）方法采用隐藏指针指向“this”（作为它们的第一个参数），这是您调用该方法的对象。

这是与常规独立函数的唯一区别，尽管动态调度。

如果您有兴趣，请阅读下面的详细信息。

我将尽量简短，并以 C++ 为例，尽管我所说的几乎可以应用于所有语言。

• 对于您的 CPU，函数和方法都只是一段代码。时期。
• 因此，当调用函数/方法时，它们可以带参数

好吧，我说没有实际区别。让我们深入一点：

• 有两种方法：静态和非静态
• 静态方法类似于常规函数，但在类中声明，其作用类似于命名空间
• 非静态（“实例”）方法采用指向“this”的隐藏指针。这是与常规独立功能的唯一区别。

抛开动态调度不谈，这意味着它就这么简单：

class User {
    public string name; // I made it public intentionally

    // Each instance method takes a hidden reference to "this"
    public void printName(/*User & this*/) {
        cout << this.name << endl;
    }
};

相当于

public getName(User & user) {
    // No syntactic sugar, passing a reference explicitly
    cout << user.name << endl;
}

所以，本质上，user->printName()它只是getName(user).

如果您不使用动态分派，仅此而已。如果它被使用，那么它会涉及更多，但编译器仍然会发出看起来像this作为第一个参数的函数的东西。

Answer 33

方法和功能之间有明显的区别：

函数是一段独立的代码，你可以在任何地方调用它，只要用给定的参数提到它的名字，就像在大多数过程语言中一样，例如 C++ 和 python。尽管

方法专门与对象相关联，这意味着您只能通过在它之前用点（。）表示法提及它的对象来调用方法，就像在专门的纯面向对象语言（如 C# 和 java）中一样。

Answer 34

一般答案是：

method具有对象上下文（this，或类实例引用），

function没有上下文（null、全局或静态）。

但问题的答案取决于您使用的语言术语。

1. 在 JavaScript (ES 6) 中，您可以根据需要自由自定义函数上下文 (this)，这通常必须链接到 (this) 对象实例上下文。

2. 在 Java 世界中，您总是听到“只有 OOP 类/对象，没有函数”，但如果您仔细观察static methodsJava，它们实际上是在全局/空上下文（或类的上下文，没有实例化）中，所以只有函数没有目的。Java 老师可以告诉你，functions were rudiment of C in C++ and dropped in Java但他们告诉你这是为了简化历史并避免新手提出不必要的问题。如果您在 Java 7 之后的版本中看到，您会发现许多纯函数编程元素（甚至不是来自 C，而是来自较旧的 1988 Lisp）用于简化并行计算，并且不是 OOP 类风格。

3. 在 C++ 和 D 世界中，事情变得更强大，并且您已经将函数和对象与方法和字段分开。但在实践中，您再次看到函数without this和方法whith this（带有对象上下文）。

4. 在 FreePascal/Lazarus 和 Borland Pascal/Delphi 中，函数和对象（变量和字段）的分离术语通常类似于 C++。

5. Objective-C 来自 C 世界，因此您必须使用方法插件将 C 函数和 Objective-C 对象分开。

6. C# 与 Java 非常相似，但具有许多 C++ 优点。

Answer 35

Amethod是任何对象或类的成员。Afunction是独立的。

但在 Javascript 的情况下，function是method可以互换的。

Answer 36

它们通常可以互换，但方法通常是指类内的子例程，而函数通常是指类外的子例程。例如，在 Ruby 中：

# function
def putSqr(a)
   puts a ** 2
end


class Math2
   # method
   def putSqr(a)
      puts a ** 2
   end
end

在 Java 中，所有东西（除了 package 和 import 语句）都必须在类中，人们几乎总是将它们称为“方法”。

Answer 37

函数和方法看起来非常相似。它们也有输入和返回输出。区别在于方法在类内部，而函数在类外部。

Answer 38

使用 C# 术语，函数和方法之间存在区别。术语函数成员不仅包括方法，还包括其他非数据成员，例如索引器、运算符、构造函数、析构函数和属性——所有包含可执行代码的成员。

参考 => Professional C# and .NET 2021 Edition - 由 Christina Nagel 编写

Answer 39

方法和函数有什么区别？

Python 的官方文档是这样定义的（在这里感谢@Kelly Bundy！）：

功能

一系列向调用者返回一些值的语句。它也可以传递零个或多个参数，这些参数可用于执行主体。另请参阅参数、方法和函数定义部分

方法

在类体内定义的函数。如果作为该类实例的属性调用，该方法将获取实例对象作为其第一个参数（通常称为self）。请参阅函数和嵌套范围。

---

正方形是长方形，但并非所有长方形都是正方形。我解释世界的方式是，方法是函数，但并非所有函数都是方法。一个方法的独特之处在于它是一种特殊类型的函数，它也与一个类相关联并且可以访问类成员变量。

也可以看看：

1. [我的答案] hasattr 被称为方法，但它看起来像一个函数