【python学习】Day1打卡-20210425

好奇以下内容，查资料得知以下结果

【python中内置函数与内置方法的区别】

1.作用域不同

内置函数的作用域：从函数调用开始至函数执行完成，返回给调用者后，在执行过程中开辟的空间会自动释放，也就是说函数执行完成后，函数体内部通过赋值等方式修改变量的值不会保留，会随着返回给调用者后，开辟的空间会自动释放。

内置方法的作用域：通过实例化的对象进行方法的调用，调用后开辟的空间不会释放，也就是说调用方法中对变量的修改值会一直保留。

2.调用方式不同

内置函数是通过“函数名（）”的方式进行调用；而内置方法是通过“对象.方法名”的方式进行调用。

 

 

【python中函数和方法的区别】

1、从分类的角度来分析。

（1）函数的分类：

• 内置函数：python内嵌的一些函数。
• 匿名函数：一行代码实现一个函数功能。
• 递归函数
• 自定义函数：根据自己的需求，来进行定义函数。

（2）方法的分类：

• 普通方法：直接用self调用的方法。
• 私有方法：__函数名，只能在类中被调用的方法。
• 属性方法：@property，将方法伪装成为属性，让代码看起来更合理。
• 特殊方法(双下划线方法)：以__init__为例，是用来封装实例化对象的属性，只要是实例化对象就一定会执行__init方法，如果对象子类中没有则会寻找父类（超类），如果父类（超类）也没有，则直接继承object（python 3.x）类，执行类中的__init__方法。
• 类方法：通过类名的调用去操作公共模板中的属性和方法。
• 静态方法：不用传入类空间、对象的方法， 作用是保证代码的一致性，规范性，可以完全独立类外的一个方法，但是为了代码的一致性统一的放到某个模块（py文件）中。

2、从作用域的角度来分析：

（1）函数作用域：从函数调用开始至函数执行完成，返回给调用者后，在执行过程中开辟的空间会自动释放，也就是说函数执行完成后，函数体内部通过赋值等方式修改变量的值不会保留，会随着返回给调用者后，开辟的空间会自动释放。

（2）方法作用域：通过实例化的对象进行方法的调用，调用后开辟的空间不会释放，也就是说调用方法中对变量的修改值会一直保留。

3、调用的方式不同。

（1）函数：通过“函数名（）”的方式进行调用。

（2）方法：通过“对象.方法名”的方式进行调用。

class Foo(object):

    def func(self):
        pass

#实例化
obj = Foo()

# 执行方式一:调用的func是方法
obj.func() #func 方法

# 执行方式二：调用的func是函数
Foo.func(123) # 函数

 

【Python中函数和方法区别】

首先摒弃错误认知:并不是类中的调用都叫方法.

函数

函数是封装了一些独立的功能，可以直接调用，能将一些数据（参数）传递进去进行处理，然后返回一些数据（返回值），也可以没有返回值。可以直接在模块中进行定义使用。所有传递给函数的数据都是显式传递的。

方法

方法和函数类似，同样封装了独立的功能，但是方法是只能依靠类或者对象来调用的，表示针对性的操作。
方法中的数据self和cls是隐式传递的，即方法的调用者；
方法可以操作类内部的数据

简单的说，函数在python中独立存在，可直接使用的，而方法是必须被别人调用才能实现的。
静态方法除外（与类和对象均无关，通过类名和对象名均可被调用，属函数）

先来一段代码：

def fun():
    pass
print(fun)

结果如下：

<function fun at 0x000002215AE5C268>

可以看出:

单独定义的function都属于函数，就比如上面的fun()函数。

但在类中定义的function，就需要分情况来看了。

再看一段代码：

class Apple:

    def fun1(self):
        return 'normal'

    @staticmethod
    def fun2():
        return 'staticmethod'

    @classmethod
    def fun3(cls):
        return 'classmethod'


print(Apple.fun1)
print(Apple.fun2)
print(Apple.fun3)

print("------------------------------------我是分割线-------------------------------------")

apple = Apple()
print(apple.fun1)
print(apple.fun2)
print(apple.fun3)

运行结果如下：

<function Apple.fun1 at 0x0000025520CCD048>    # 函数
<function Apple.fun2 at 0x0000025520FB8620>    # 函数
<bound method Apple.fun3 of <class '__main__.Apple'>>    # 方法
------------------------------------我是分割线-------------------------------------
<bound method Apple.fun1 of <__main__.Apple object at 0x0000025520FB3C18>>  # 方法
<function Apple.fun2 at 0x0000025520FB8620>    # 函数
<bound method Apple.fun3 of <class '__main__.Apple'>>    # 方法

由此可以得出：

在一个类中：

当类直接调用function时，
定义在@staticmethod下的func,如func2，和普通func，如func1属于`函数`，
定义在@classmethod下的func，如func3，属于`方法`(即称为类方法)。

当类实例化对象后，如`apple对象`，再调用function时，
普通func，如fun1，就被称为是`实例化方法`，
定义在@staticmethod下的func，与class和实例化对象无关，所以依然属于`函数`,
定义在@classmethod下的func，与class内部有关，属于类的方法。

即：

• @classmethod下定义的func属于方法，@staticmethod下定义的func属于函数。
• 而类class中定义的普通func要分是类调用还是类对象调用。
  1.类调用：函数
  2.类对象调用：方法

---

总结：

• 与类和实例无绑定关系的 func 都属于函数(function); ---> 如：静态函数和类调用的普通func()
• 与类和实例有绑定关系的 func 都属于方法(method). ---> 如：类方法和类对象调用的普通func()

二、区分函数和方法

class Lwd(object):
    age = 12
    def __init__(self):
        self.name="ydd"
    def func(self):
        print("名字：" + self.name)
    def func2(self):
        print("年龄：" + str(age))

lwd = Lwd()
lwd.func()    # ydd
# 类直接调用func，需要传入数据(参数）
# 否则报错: missing 1 required positional argument: self
Lwd.func(lwd)    # ydd

lwd.func2()      # 年龄：12
Lwd.func2(lwd)    # 年龄：12

另一段代码:

from types import FunctionType, MethodType
print(isinstance(lwd.func, FunctionType))  # False
print(isinstance(lwd.func, MethodType))   # True   #说明这是一个方法

print(isinstance(Lwd.func, FunctionType))  # True   #说明这是一个函数
print(isinstance(Lwd.func, MethodType))  # False

“不为失败找借口，只为成功找方法。”送给自己，也送给正在读文章的博友们～