Python面向对象
创建类
使用class语句来创建一个新的类，class之后为类的名字并且以冒号结束
class ClassName:
'类的帮助信息' # 类文档帮助字符串
class_suite # 类体以下是一个简单的实例
class Employee:
"""所有的员工的基类"""
# 构造器
def __init__(self, name, age):
print("构造函数被调用！")
self.name = name
self.age = age
pass
# 属性
name = ""
age = 0
# 方法
def show(self):
print("我叫%s,我今年%d" % (self.name, self.age))
pass
def __del__(self):
print("析构函数被调用！")
pass
def main():
xiaoming = Employee("小米", 21)
xiaoming.show()
pass
if __name__ == "__main__":
main()在该实例中出现了两个特殊函数：
def __init__():构造器，用于初始化对象def __del__():析构器，在销毁对象之前调用
self参数：
- 在python的面向对象方法中，第一个参数永远是self，指向该对象自己本身，类似与C++中的this指针
- self代表类的实例，而非类本身
- 如果要让self指向类本身，则需要写：
self.__class__ - self不是关键字，可以随便换成其他的字，照样执行
def __init__(this, name, age):
print("构造函数被调用！")
print(this.__class__)
this.name = name
this.age = age
pass类的实例化
Python的实例化中没有new关键字，而是类似于函数的调用
以下实例化方法中使用Employee来实例化，并且通过__init__方法来接收参数
'''创建Employee的第一个对象'''
emp1 = Employee("Zaya",2000)
emp2 = Employee("Mari",1000)访问属性
可以使用’.’来访问对象的属性
emp1.diplay()如果为public则可以直接修改，如果为private则需要定义一个接口
Python内置类属性
__dict__类的属性（包含一个字典，由类的数据属性组成）__doc__类的文档字符串__name__类名__module__类定义所在的模块__bases__类的所有父类构成的元素
Python的对象销毁（垃圾回收）
Python 使用了引用计数这一简单技术来跟踪和回收垃圾。
在 Python 内部记录着所有使用中的对象各有多少引用。
一个内部跟踪变量，称为一个引用计数器。
当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。但是回收不是”立即”的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收。
垃圾回收机制不仅针对引用计数为0的对象，同样也可以处理循环引用的情况。循环引用指的是，两个对象相互引用，但是没有其他变量引用他们。这种情况下，仅使用引用计数是不够的。Python 的垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器。作为引用计数的补充， 垃圾收集器也会留心被分配的总量很大（即未通过引用计数销毁的那些）的对象。 在这种情况下， 解释器会暂停下来， 试图清理所有未引用的循环。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
class Point:
def __init__(self, x=0, y=0):
self.x = x
self.y = y
def __del__(self):
class_name = self.__class__.__name__
print(class_name, "销毁")
pt1 = Point()
pt2 = pt1
pt3 = pt1
print
id(pt1), id(pt2), id(pt3) # 打印对象的id
del pt1
del pt2
del pt32256516188960 2256516188960 2256516188960
Point 销毁
类的继承
继承语法如下：
class 派生类名字(基类名字)在Python中继承的一些特点
- 如果在子类中需要父类的构造方法就需要显式的调用父类的构造方法，或者不重写父类的构造方法。
2）在调用基类的方法时，需要加上基类的类名前缀，且需要带上 self 参数变量。区别在于类中调用普通函数时并不需要带上 self 参数。
3）Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找。
比如下面这个例子
class Parent:
def __init__(self):
print("调用了父类的构造器")
def __del__(self):
print("调用了父类的析构器")
class Child(Parent):
def __init__(self):
print("调用了子类的构造器")
def __del__(self):
print("调用了子类的析构器")
c = Child()调用了子类的构造器
调用了子类的析构器
上述例子中，重写了父类的构造器，因此Python不会进入父类进行构造，也就不会触发父类的构造器。这种机制似乎对于析构器也会生效。
class Parent:
def __init__(self):
print("调用了父类的构造器")
def __del__(self):
print("调用了父类的析构器")
class Child(Parent):
pass
# def __init__(self):
# print("调用了子类的构造器")
def __del__(self):
print("调用了子类的析构器")
c = Child()调用了父类的构造器
调用了子类的析构器
Python支持多继承
class SubClassName(ParentName1,ParentName2,......)方法重写（重载）
如果对父类的方法不满意，那么就可以执行重载操作，这时候Python会优先调用子类的方法
class Parent:
def show(self):
print("我是父")
class Child(Parent):
def show(self):
print("我是子")
child = Child()
child.show()基础重载方法
下标列出了一些基础的重载方法
| 序号 | 方法、描述&简单的应用 |
|---|---|
| 1 | __init__(args) 构造函数: obj=className(args) |
| 2 | __del__(self) 析构函数: del obj |
| 3 | __repr__(self) 转化为供解释器读取的形式: repr(obj) |
| 4 | __str__(self) 转化为适用于人阅读的形式: str(obj) |
| 5 | __cmp__(self,x) 对象间的比较: cmp(obj,x) |
运算符重载
Python同样支持运算符重载，实现方法如下
#!/usr/bin/python
class Vector:
def __init__(self, a, b):
self.a = a
self.b = b
def __str__(self):
return 'Vector (%d, %d)' % (self.a, self.b)
def __add__(self, other):
return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2, 10)
v2 = Vector(5, -2)
print(v1 + v2)Vector(7,8)
类的属性和方法
这个即访问控制符
私有属性
- 使用双下滑线进行声明，指示这个属性为私有，不能在类的外部被使用或者直接访问，只能在类的内部进行访问。
__private_attrsclass People: self.__age = None # 通过这个双下划线，指明了这个__age属性是私有的。
类的方法
- 在类的内部，使用def关键字可以为类定义一个方法，和一般的函数定义不同，类方法必须包含参数self，且为第一个参数永远都是self。
class People: def __init__(self): self.name = "Xiaoming" # 定义一个show()方法 def show(self): print("My name's " + self.name)
类的私有方法
- 两个下划线开头，声明该方法为私有方法，不能在类的外部进行调用，在类的内部进行调用
__private_method
访问控制
Python的访问控制非常有意思
- 无下划线开头
foo一般为public属性 - 单下划线开头
_foo一般为protected属性 - 双下划线开头
__foo一般为private属性 - 双头双尾
__foo__一般为系统定义的名字，如__init__
