Python面向对象

Python是一门面向对象的语言，在Python中创建一个类和对象是很容易的
1、面向对象技术：
类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
类变量：类变量在实例化的对象中是公用的，类变量定义在类中且在函数体之外，类变量通常不作为实例变量使用。
数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。
方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
实例变量：定义在方法中的变量，只作用于当前实例的类。
继承：即一个派生类（derived class）继承基类（base class）的字段和方法。
实例化：创建一个类的实例，类的实例是一个具体的对象。
方法：类中定义的函数。
对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。
2、类定义:
class Complex:
def __init__(self,real,imag):
self.r=real
self.i=imag
实例：
x=Complex(3.0,-4.5)
构造函数：类倾向于将对象创建为有初始状态。因此类可能会定义一个名为 init() 的特殊方法（构造方法）
def __init__(self):
self.data=[]
类定义了 init() 方法的话，类的实例化操作会自动调用 init() 方法。init() 方法可以有参数，参数通过 init() 传递到类的实例化操作。
self代表类的实例，代表当前对象的地址，而非类，self.class则指向类
类的方法第一个参数self
class Test:
def prt(self):
print(self)
print(self.__class__)

t=Test()
t.prt()
3、属性和方法
类的方法：
在类地内部，使用def定义方法，类方法必须包含参数self, 且为第一个参数。
class people:
name=""
age=0
__weight=0 #类的私有属性，在类外部无法直接进行访问
def __init__(self,n,a,w):
self.name=n
self.age=a
self.__weight=w
def speak(self):
print("%s 说：我%d 岁。"%(self.name,self.age))
print("%s 说：我体重%d 斤。"%(self.name,self.__weight))
p=people("runoob",10,30)
p.speak()
print(p.name,p.age) # 这里外面不能访问p.__weight
类的私有属性：两个下划线开头，声明为私有属性，不能再类外部使用，只能在类内部使用。
类的私有方法：两个下划线开头，声明为私有方法，只能在类的内部调用，不能在类地外部调用
4、类的继承与重载
派生类的定义：
class student(people): #派生自people类
grade=""
def __init__(self,n,a,w,g):
people.__init__(self,n,a,w) #调用父类构造函数
self.grade=g #覆写父类的方法
def speak(self):
print("%s 说：我%d 岁了，我在读%d年级。"%(self.name,self.age,self.grade))

s=student('chen',10,60,3)
s.speak()
Python支持多重继承
class speaker():
topic=''
name=''
def __init__(self,n,t):
self.name=n
self.topic=t
def speak(self):
print("我叫%s,我是一个演说家,我演讲的题目是%s"%(self.name,self.topic))
class sample(student,speaker): #多重继承
a=''
def __init__(self,n,a,w,g,t):
student.__init__(self,n,a,w,g) #调用第一个父类的构造函数
speaker.__init__(self,n,t) #调用第二个父类的构造函数
test=sample("Tim",25,80,4,'python')
test.speak() #两个父类都有speak函数，默认调用排在前面的父类的同名函数
方法重写：
class Parent:
def myMethod(self):
print('调用父类方法')
class Child(Parent):
def myMethod(self): #相同的方法在子类中重写了
print('调用子类方法')
c=Child()
c.myMethod() #子类调用的是重写了的方法

类的专有方法：
__init__: 构造函数，在生成对象时调用
__del__: 析构函数，释放对象时使用
__repr__: 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__div__: 除运算
__mod__: 求余运算
__pow__: 乘方

#运算符重载,对类的专有方法进行重载
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)