python面向对象特性

python的面向对象与Java是由很大区别的。

OOP术语概述：

• 类: 用户定义的原型对象，它定义了一套描述类的任何对象的属性。属性是数据成员(类变量和实例变量)和方法，通过点符号访问。
• 类变量：这是一个类的所有实例共享的变量。类变量在类中，但在所有类的方法外定义。类变量不被用作经常作为实例变量。
• 类方法：类中定义的方法向外提供给API。
• 数据成员：保存与类和对象关联的数据的类变量或实例变量。
• 函数重载：一个以上的行为特定功能的分配。执行的操作所涉及的对象(自变量)的类型不同而不同。
• 实例变量：定义在初始化方法内，只属于一个类的当前实例的变量。
• 继承：类的特点，即都是由它派生其他类的转移。
• 实例：某一类的一个单独对象。属于类Circle一个obj对象，例如，是类Circle的一个实例。
• 实例化：创建一个类的实例。
• Method : 一种特殊的函数，函数在类定义中定义。
• 对象：这是由它的类中定义的数据结构的唯一实例。一个对象包括两个数据成员(类变量和实例变量)和方法。
• 运算符重载：一个以上的函数功能，特定的操作符分配。

python面向对象的核心围绕self展开。贯穿于类的成员和方法。

创建类
创建类使用关键字class

class Student:
	# options

类变量

class Student:
	name = None
	age = None

类方法

class Student:
	name =None
	age = None
	def setNmae(self,name):
		self.name = name
	def getName(self):
		return self.name
	
	# setter & getter

类方法必须有self，这是类方法的特有表示，对类的操作也离不开self。这个可以随便命名，只要作为函数的第一个参数即可。

类的第一个方法__init__()是一种特殊的方法，这是类的构造函数，当创建该类的一个新实例Python调用的初始化方法。在改方法中定义的变量为实例变量。

class Student:
	name =None
	age = None
	def __init__(self,name,age):
		self.name = name
		self.age = age
	def setNmae(self,name):
		self.name = name
	def getName(self):
		return self.name

创建实例对象
对类的引用是类名，对类的实例化时类的引用：

# 引用类
student = Student

# 实例化类
student = Student()

# 实例化并用构造函数初始化类
student = Student("lihua",22)

# 除了构造方法实例化外，setter方法也可初始化
student = Student()
student.setName("lihua")

实例化类一定要有括号才是第类的引用。初始化函数直接传递实参，形参在构造函数__init__中定义了。

访问属性
对于类属性可以用类名.属性访问，因为类属性时所有实例共享的属性，也可编写setter和getter方法对外暴露接口访问。对于实例变量，时每个实例特有的只能通过gettet和setter方法访问。

class Student:
	name =None
	def __init__(self):
		# options
	def setNmae(self,name):
		self.name = name
	def getName(self):
		return self.name


# 两种访问方式
student = Student("lihua")
# student = Student() student.setName("lihua")
student.name
student.getNmae()

class Student:
	def __init__(self,name):
		self.name = name
	def setNmae(self,name):
		self.name = name
	def getName(self):
		return self.name

# 实例变量只能构造方法初始化，和方法访问或修改
student = Student("lihua")
student.getName()
# 修改
student.setNmae("zhansna")

内置函数
除了使用.来操作类的成员外，类还提供了内置函数：
getattr(obj, name[default]): 访问对象的属性，返回值为属性值。
hasattr(obj,name):检查一个属性是否存在。
setattr(obj,name,value):设置一个属性。如果属性不存在，那么它将被创建。
delattr(obj, name): 要删除一个属性。

obj是实例对象，后面的擦书都是str类型。

hasattr(student,"name")   # 返回值为bool
getattr(student,"name")
setattr(student,"age","20")
delattr(student,"age")

内置的类属性
每个Python类会继续并带有内置属性，他们可以使用点运算符像任何其他属性一样来访问：
__dict__: 将类的实例变量转化为字典类型。
__doc__: 类的文档字符串，或None如果没有定义。
__module__: 在类中定义的模块名称。此属性是在交互模式其值为“__main__”。

print(
        student.__dict__ ,
        student.__doc__ ,
        student.__module__ ,
    )
# {'name': 'lihua'} None __main__

特殊函数
__setattr__（key,value）：函数是用来设置对象的属性，通过object中的__setattr__函数来为对象设置新的属性，类中也可以重写改方法将其作为setter使用。
__getattr__(item)：是类的特殊函数，用于查询属性。
__delattr__(*args, **kwargs)函数用来删除对象的属性，通过object中的__delattr__函数来删除对象的属性。
__call__(key)特殊函数用于函数自身调用。
__getattribute__(item)：实例方法，获取实例的属性值，相当于getter。

用法：
__setattr__（key,value）就相当于setter的扩展，自己写setter要为每个对象各写一个setter，使用__setattr__只需要一个就可以动态为每个属性动态赋值。同时还可以为实例对象新增属性。

# 新建类对象，重写__setattr__方法
class Person(object):
    name = None

    def __setattr__(self, key, value):
        return  object.__setattr__(self,key,value)
'''
通过object的__setattr__方法为属性动态赋值，形参为str类型
'''

# 实例化类调用重写方法
if __name__ == "__main__":
    person = Person()
    # 获取属性值
    a = person.__getattribute__("name")
    print(a)
	# 为属性动态赋值
	person.__setattr__("name", "zhansan")  # 只需要传入属性名和值就可以为不同属性赋值,看下面。
    b= person.__getattribute__("name")
    print(b)

	# 为实例对象添加新属性
	person.__setattr__("age",22)   # age属性在类中并未定义
    e=person.__getattribute__("age")
    print(e)
	
 
#### 结果：
None
zhangsan
22

__setattr__方法为不同的属性赋值，不需要写任何逻辑，只要传入对应的属性和值即可：

class Person(object):
    name = None
    age = None
    address = None

    def __setattr__(self, key, value):
        return object.__setattr__(self,key, value)

    def to_str(self):
        return "Person({0},{1},{2})".format(self.name,self.age,self.address)


if __name__ == "__main__":
    person = Person()
    person.__setattr__("name", "lihua")
    person.__setattr__("age", 22)
    person.__setattr__("address", "beijin")
    print(person.to_str())

##### 结果
Person(lihua,22,beijin)

__getattr__方法用于动态获取属性值，并对属性值进行处理，但需要编写判断逻辑。

class Person(object):
    name = None
    age = None
    address = None

    def __setattr__(self, key, value):
        return object.__setattr__(self,key, value)

    def __getattr__(self, item):
        if item == "name":
            return self.name
        if item == "age":
            return self.age
        if item == "address":
            return self.address


if __name__ == "__main__":
    person = Person()
    person.__setattr__("name","lihua")
    a=person.__getattr__("name")
    print(a)

#### 结果
lihua

上面的__getattr__方法值是单纯的获取属性值，没有对值进行任何处理，如果需要对值进行计算，加密等需要编写逻辑。如果只是要获取值可以使用__getattribute__(item)方法。

__delattr__(*args, **kwargs)方法用于删除属性，同样调用object的__delattr__方法:

class A(object):
    def __delattr__(self, *args, **kwargs): 
        return object.__delattr__(self, *args, **kwargs) 

https://www.jb51.net/article/61826.htm

销毁对象（垃圾回收）
Python的删除不需要的对象（内建类型或类的实例），自动释放内存空间。由Python定期回收的内存块不再使用的过程被称为垃圾收集。

Python的垃圾回收器在程序执行过程中运行，当一个对象的引用计数为零时触发。一个对象的引用计数改变为指向它改变别名的数量。也可以使用 del+ 对象 直接实现回收内存。

del student
print(student)

# NameError: name 'student' is not defined

当垃圾回收器销毁孤立的实例，并回收其空间一般不会注意到。但是，一个类可以实现特殊方法__del__()，称为析构函数被调用时，该实例将被摧毁。这个方法可以用于清理所用的一个实例的任何非内存资源。

# 或调用类的特殊方法__del__
def __del__(self):
   class_name = self.__class__.__name__
   print class_name, "destroyed"

类继承
子类继承父类的属性，可以使用父类的这些属性，就好像它们是在子类中定义的一样。子类也可以覆盖父类的数据成员和方法。

任何类都直接或间接继承object类，继承通过()实现。

子类继承父类时，只需在定义子类时，将父类（可以是多个）放在子类之后的圆括号里即可。

class student(object):
	# 
# 没有括号默认继承object类

另外python支持多继承策略，多继承经常需要面临的问题是，多个父类中包含同名的类方法。对于这种情况，Python 的处置措施是：根据子类继承多个父类时这些父类的前后次序决定，即排在前面父类中的类方法会覆盖排在后面父类中的同名类方法。

https://www.jb51.net/article/66651.htm