python进阶学习笔记：6 面向对象编程（二）

self和__init__解释：https://blog.csdn.net/cnds123/article/details/130506922

方法

声明格式：

def 方法名(self,[形参列表])：
     函数体

调用格式：

对象.方法名([实参列表])

【例1】实例方法示例。定义类Person4，创建其对象，并调用对象函数

class Person4:  # 定义类Person4
    def __init__(self):
        self.name = None

    def say_hi(self, name):  # 定义方法say_hi
        self.name = name  # 把参数name赋值给self.name，即成员变量name（域）
        print('您好, 我叫', self.name)


p4 = Person4()  # 创建对象实例
p4.say_hi('Alice')  # 调用对象实例的方法

__init__方法

      __init__方法：构造函数（构造方法），用于执行类的实例的初始化工作。创建完对象后调用，初始化当前对象的实例，无返回值        
【例1】__init__方法示例1（Person5.py）

class Person5:  # 定义类Person5
    def __init__(self, name):  # __init__方法
        self.name = name  # 把参数name赋值给self.name，即成员变量name（域）

    def say_hi(self):  # 定义类Person的方法say_hi
        print('您好, 我叫', self.name)


p5 = Person5('Helen')  # 创建对象
p5.say_hi()  # 调用对象的方法

__new__方法

__new__方法是一个类方法，创建对象时调用，返回当前对象的一个实例，一般无需重载该方法

__del__方法

        如果创建的类实例化对象后续不再使用，需手动销毁释放其占用的内存空间（整个过程称为垃圾回收（简称GC））。

【例】：

class Demo:
    def __init__(self):
        print("调用 __init__() 方法构造对象")

    def __del__(self):
        print("调用__del__() 销毁对象，释放其空间")


demo = Demo()
del demo

但是，读者千万不要误认为，只要为该实例对象调用 __del__() 方法，该对象所占用的内存空间就会被释放。举个例子：

class Demo:
    def __init__(self):
        print("调用 __init__() 方法构造对象")

    def __del__(self):
        print("调用__del__() 销毁对象，释放其空间")


demo = Demo()
# 添加一个引用demo对象的实例对象
d = demo
del demo
print("***********")

注意，最后一行输出信息，是程序执行即将结束时调用 __del__() 方法输出的。

可以看到，当程序中有其它变量（比如这里的 d）引用该实例对象时，即便手动调用 __del__() 方法，该方法也不会立即执行。这和 Python 的垃圾回收机制的实现有关。

私有方法和公有方法

• 类似“__name()”形式的方法是私有的（private），其他为公共的（public）
• 类似“__name__()”属性称为特殊方法。不能直接访问私有方法，但可以在其他方法中访问

class Book:  # 定义类Book
    def __init__(self, name, author, price):
        self.name = name  # 把参数name赋值给self.name，即成员变量name（域）
        self.author = author
        self.price = price

    def __check_name(self):  # 定义私有方法，判断name是否为空
        if self.name == '':
            return False
        else:
            return True

    def get_name(self):  # 定义类Book的方法get_name
        if self.__check_name():
            print(self.name, self.author)
        # 调用私有方法
        else:
            print('No value')


b = Book('Python程序设计教程', '江红', 59.0)  # 创建对象
b.get_name()  # 调用对象的方法
b.__check_name()  # 直接调用私有方法，非法

方法重载

• 可以定义多个重名的方法，只要保证方法签名是唯一的
• 方法签名包括三个部分：方法名、参数数量和参数类型
• 【例1】方法重载示例1（PersonOverload.py）

class Person:  # 定义类Person   
    def __init__(self):
        self.name = None

    def say_hi(self, name=None):  # 定义类方法say_hi       
        self.name = name  # 把参数name赋值给self.name，即成员变量name（域）       
        if name is None:
            print('您好! ')
        else:
            print('您好, 我叫', self.name)


p21 = Person()  # 创建对象
p21.say_hi()  # 调用对象的方法，无参数
p21.say_hi('威尔逊')  # 调用对象的方法，带参数

静态方法

       静态方法是一类特殊的方法，有时可能需要写一个属于这个类的方法，但是这些代码完全不会使用到实例对象本身，例如：

class Student(object):
    @staticmethod
    def aver_age(x, y):
        return x + y

    def year(self):
        return self.aver_age(self.month, self.day)


print(Student().year is Student().year)
print(Student().aver_age is Student().aver_age)
print(Student().aver_age is Student.aver_age)

        这个例子中，如果把aver_age作为非静态方法同样可以运行，但是它要提供self参数，而这个参数在方法中根本不会被使用到。这里的@staticmethod装饰器可以给我们带来一些好处，Python不再需要为Student对象实例初始化一个绑定方法，绑定方法同样是对象，但是创建需要成本，而静态方法可以避免这些。

      可读性更好的代码，看到@staticmethod我们就知道这个方法并不需要依赖对象本身的状态。
       可以在子类中被覆盖，如果是把aver_age作为模块的顶层函数，那么继承自Student的子类就没法改变Student的aver_age了如果不覆盖year的话。

类方法

        什么是类方法？类方法不是绑定到对象上，而是绑定在类上的方法。

class Student(object):
    score = 100

    @classmethod
    def get_score(cls):
        return cls.score


print(Student.get_score)
print(Student().get_score)
print(Student().get_score is Student.get_score)
print(Student.get_score())

无论用哪种方式访问这个方法，它总是绑定到了这个类身上，它的第一个参数是这个类本身（类也是对象）

系统内置方法

        以下是针对python3.8源代码进行每个内置方法说明

class object:
 """ The most base type """
 
 # del obj.xxx或delattr(obj,'xxx')时被调用，删除对象中的一个属性
 def __delattr__(self, *args, **kwargs): # real signature unknown
 """ Implement delattr(self, name). """
 pass
 
 # 对应dir(obj)，返回一个列表，其中包含所有属性和方法名（包含特殊方法）
 def __dir__(self, *args, **kwargs): # real signature unknown
 """ Default dir() implementation. """
 pass
 
 # 判断是否相等 equal ，在obj==other时调用。如果重写了__eq__方法，则会将__hash__方法置为None
 def __eq__(self, *args, **kwargs): # real signature unknown
 """ Return self==value. """
 pass
 
 # format(obj)是调用，实现如何格式化obj对象为字符串
 def __format__(self, *args, **kwargs): # real signature unknown
 """ Default object formatter. """
 pass
 
 # getattr(obj,'xxx')、obj.xxx时都会被调用，当属性存在时，返回值，不存在时报错（除非重写__getattr__方法来处理）。
 # 另外，hasattr(obj,'xxx')时也会被调用（估计内部执行了getattr方法）
 def __getattribute__(self, *args, **kwargs): # real signature unknown
 """ Return getattr(self, name). """
 pass
 
 # 判断是否大于等于 greater than or equal，在obj>=other时调用
 def __ge__(self, *args, **kwargs): # real signature unknown
 """ Return self>=value. """
 pass
 
 # 判断是否大于 greater than，在obj>other时调用
 def __gt__(self, *args, **kwargs): # real signature unknown
 """ Return self>value. """
 pass
 
 # 调用hash(obj)获取对象的hash值时调用
 def __hash__(self, *args, **kwargs): # real signature unknown
 """ Return hash(self). """
 pass
 
 def __init_subclass__(self, *args, **kwargs): # real signature unknown
 """
 This method is called when a class is subclassed.
 
 The default implementation does nothing. It may be
 overridden to extend subclasses.
 """
 pass
 
 # object构造函数，当子类没有构造函数时，会调用object的__init__构造函数
 def __init__(self): # known special case of object.__init__
 """ Initialize self. See help(type(self)) for accurate signature. """
 pass
 
 # 判断是否小于等于 less than or equal，在obj<=other时调用
 def __le__(self, *args, **kwargs): # real signature unknown
 """ Return self<=value. """
 pass
 
 # 判断是否小于 less than，在obj<other时调用
 def __lt__(self, *args, **kwargs): # real signature unknown
 """ Return self<value. """
 pass
 
 # 创建一个cls类的对象，并返回
 @staticmethod # known case of __new__
 def __new__(cls, *more): # known special case of object.__new__
 """ Create and return a new object. See help(type) for accurate signature. """
 pass
 
 # 判断是否不等于 not equal,在obj!=other时调用
 def __ne__(self, *args, **kwargs): # real signature unknown
 """ Return self!=value. """
 pass
 
 def __reduce_ex__(self, *args, **kwargs): # real signature unknown
 """ Helper for pickle. """
 pass
 
 def __reduce__(self, *args, **kwargs): # real signature unknown
 """ Helper for pickle. """
 pass
 
 # 如果不重写__str__，则__repr__负责print(obj)和交互式命令行中输出obj的信息
 # 如果重写了__str__，则__repr__只负责交互式命令行中输出obj的信息
 def __repr__(self, *args, **kwargs): # real signature unknown
 """ Return repr(self). """
 pass
 
 # 使用setattr(obj,'xxx',value)、obj.xxx=value是被调用（注意，构造函数初始化属性也要调用）
 def __setattr__(self, *args, **kwargs): # real signature unknown
 """ Implement setattr(self, name, value). """
 pass
 
 # 获取对象内存大小
 def __sizeof__(self, *args, **kwargs): # real signature unknown
 """ Size of object in memory, in bytes. """
 pass
 
 # 设置print(obj)打印的信息，默认是对象的内存地址等信息
 def __str__(self, *args, **kwargs): # real signature unknown
 """ Return str(self). """
 pass
 
 @classmethod # known case
 def __subclasshook__(cls, subclass): # known special case of object.__subclasshook__
 """
 Abstract classes can override this to customize issubclass().
 
 This is invoked early on by abc.ABCMeta.__subclasscheck__().
 It should return True, False or NotImplemented. If it returns
 NotImplemented, the normal algorithm is used. Otherwise, it
 overrides the normal algorithm (and the outcome is cached).
 """
 pass
 # 某个对象是由什么类创建的，如果是object，则是type类<class 'type'>
 __class__ = None
 # 将对象中所有的属性放入一个字典，例如{'name':'Leo','age':32}
 __dict__ = {}
 # 类的doc信息
 __doc__ = ''
 # 类属于的模块,如果是在当前运行模块，则是__main__，如果是被导入，则是模块名（即py文件名去掉.py）
 __module__ = ''