python面向对象编程代码_8.python面向对象编程

基本概念

Class 类

一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型。在类中定义了这些对象的都具备的属性(variables(data))、共同的方法

Object 对象

一个对象即是一个类的实例化后实例，一个类必须经过实例化后方可在程序中调用，一个类可以实例化多个对象，每个对象亦可以有不同的属性，就像人类是指所有人，每个人是指具体的对象，人与人之前有共性，亦有不同

Encapsulation 封装

在类中对数据的赋值、内部调用对外部用户是透明的，这使类变成了一个胶囊或容器，里面包含着类的数据和方法

Inheritance 继承

一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承

Polymorphism 多态

一个接口，多种实现

类的创建

classCar(object):def __init__(self,type,price):

self.type=type

self.price=pricedefcarinfo(self):print("type:%s,price:%d"%(self.type,self.price))

tesla= Car('tesla',2000)

jeep= Car('jeep',1000)

tesla.carinfo()

jeep.carinfo()

View Code

对象之间的交互

classGaren:

camp= 'Demacia'

def __init__(self,name,aggressivity = 58,life_value = 455): #初始攻击力和生命值

self.name =name

self.aggressivity=aggressivity

self.life_value=life_valuedef attack(self,enemy): #普通攻击技能，攻击敌人

enemy.life_value -= self.aggressivity #根据攻击力，减掉敌人生命值

classRiven:

camp= 'Noxus'

def __init__(self,name,aggressivity = 54,life_value = 4514):

self.name=name

self.aggressivity=aggressivity

self.life_value=life_valuedefattack(self,enemy):

enemy.life_value-=self.aggressivity

g1= Garen('盖伦')

r1= Riven("瑞文")print(g1.life_value)

r1.attack(g1)#交互

print(g1.life_value

继承

继承指的是类与类之间的关系，是一种什么是什么的关系，功能之一就是用来解决代码重用问题

继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类

classPeople(object):def __init__(self,name,age):

self.name=name

self.age=agedefeat(self):print("%s is eating..." %self.name)deftalk(self):print("%s is talking..." %self.name)defsleep(self):print("%s is sleeping..." %self.name)classMan(People):def __init__(self,name,age,money):

super(Man,self).__init__(name,age)

self.money=moneyprint("%s 一出生就有%s money" %(self.name,self.money))defsleep(self):print("man is sleeping")classWoman(People):defget_birth(self):print("%s is born a baby...." %self.name)

m1= Man("jack",22,10000)

m1.sleep()

w1= Woman("alex",26)

w1.get_birth()

View Code

组合

组合与继承都是有效地利用已有类的资源的重要方式。但是二者的概念和使用场景皆不同，

1.继承的方式

通过继承建立了派生类与基类之间的关系，它是一种'是'的关系，比如白马是马，人是动物。

当类之间有很多相同的功能，提取这些共同的功能做成基类，用继承比较好，比如老师是人，学生是人

2.组合的方式

用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python和linux课程，教授有学生s1、s2、s3...

classEquip():deffile(self):print('release fire skill')classRiven():

camp= 'Noxus'

def __init__(self,name):

self.name=name

self.equip= Equip() #用Equip类产生一个装备,赋值给实例的equip属性

r1= Riven('瑞文')

r1.equip.file()#可以使用组合的类产生的对象所持有的方法

结果：

release fire skill

View Code

继承与组合例子：

classPeople(object):def __init__(self,name,age,sex):

self.name=name

self.age=age

self.sex=sexclassCourse(object):def __init__(self,name,period,price):

self.name=name

self.period=period

self.price=pricedeftell_info(self):print('%s %s %s'%(self.name,self.period,self.price))classTeacher(People):def __init__(self,name,age,sex,job):

super(Teacher, self).__init__(name,age,sex)

self.job=job

self.course=[]

self.students=[]classStudent(People):def __init__(self,name,age,sex):

super(Student, self).__init__(name,age,sex)

self.course=[]#老师和学生对象

jack = Teacher('jack',18,'male','c++')

s1= Student('derek',12,'female')#课程

python = Course('python','3mons',3000)

linux= Course('linux','4mons',5000)#为老师和学生添加课程

jack.course.append(python)

jack.course.append(linux)

s1.course.append(linux)#为老师添加学生

jack.students.append(s1)#使用

for obj injack.course:

obj.tell_info()

View Code

3.私有属性

方法

1.静态方法  (@staticmethod)

静态方法是不可以访问实例变量或类变量的，一个不能访问实例变量和类变量的方法，其实相当于跟类本身已经没什么关系了

classDog(object):def __init__(self,name):

self.name=name

@staticmethoddefeat():print('is eating')

d= Dog('xiaohei')

d.eat()

View Code

2.类方法(@classmethod)

classDog(object):def __init__(self,name):

self.name=name

@classmethoddefeat(cls):print('is eating')

d= Dog('xiaohei')

d.eat()

View Code

3.属性方法(@property)

classDog(object):def __init__(self,name):

self.name=name

@propertydefeat(self):print('is eating')

d= Dog('xiaohei')

d.eat

View Code

把一个方法变成一个静态属性，因为eat此时已经变成一个静态属性了， 不是方法了， 想调用已经不需要加()号了，直接d.eat就可以了

多态

所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态

classF1(object):defshow(self):print 'F1.show'

classS1(F1):defshow(self):print 'S1.show'

classS2(F1):defshow(self):print 'S2.show'

defFunc(obj):printobj.show()

s1_obj=S1()

Func(s1_obj)#在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.show

s2_obj=S2()

Func(s2_obj)#在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show

类的特殊方法

1.__doc__

表示类的描述信息

classFunc():"""这里显示的是描述信息"""

deffunc(self):pass

print(Func.__doc__)

结果：

这里显示的是描述信息

View Code

2.__str__

如果一个类中定义了__str__方法，那么在打印 对象 时，默认输出该方法的返回值。

1 classFoo:2 def __str__(self):3 return 'alex li'

4 obj =Foo()5 print(obj)6

7

8 结果：9 alex li

View Code

3.反射

hasattr：判断一个对象是否有对应字符串方法

getattr:获取方法

setattr:添加方法

delattr：删除方法

def bulk(self): #添加的方法

print("%s is yelling...." %self.name)classDog(object):def __init__(self,name):

self.name=namedefeat(self,food):print("%s is eating..."%self.name,food)

d= Dog("NiuHanYang")

choice= input(">>:").strip()if hasattr(d,choice): #输入的字符串，判断是否有对应字符串的方法

func1 =getattr(d,choice)

func1('')else:

setattr(d,choice,bulk)#d.talk = bulk #通过setattr在类外部添加方法

func2 =getattr(d, choice)

func2(d)#if hasattr(d.choice): #删除#delattr(d.choice)

View Code

4.__del__

创建对象后，python解释器默认调用__init__()方法；

当删除一个对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法