小案例：
#!/usr/bin/env python
# _*_ coding:utf-8 _*_
# Author:Bert
import sys
class Role(object):
n="Role_n" #这是类变量
list= []
def __init__(self,name,role, weapon, life_value=100, money=15000):
"""
构造函数；在实例化时做一些类的初始化的工作
self 相当于传role 对象
"""
self.name=name #role1.name=name实例变量(静态属性),作用域就是实例本身
self.role=role
self.weapon=weapon
self.__life_value=life_value #在变量前面加 __ 变成私有属性，只有class里面才可以访问
self.money=money
def show_life_value(self):
print("通过class内部方法调用私有属性：%s的血量%s" %(self.name,self.__life_value))
def __private(self):
print("私有方法只有class内部的方法可以调用，必须用self")
def shot(self):
""" 类的方法 (动态属性) """
sys.stdout.write("%s通过class内shot方法调用私有方法__private：")
self.__private()
def buy_gun(self, gun_name):
print("%s购买%s" % (self.name, gun_name))
def __del__(self):
"""在实例释放、销毁的时候自动执行的，通常用于做一些收尾工作， 如关闭一些数据库连接，关闭打开的临时文件"""
print("析构函数，%s自动销毁"%(self.name))
role1 = Role("Jack","98K","terrorist")
role1.buy_gun("M416自动步枪")
role1.n = "Jack_n" #相当于给role1 这个实例 新增一个实例变量n
role1.list.append("Jack_list") #实例对象修改类里面的字典、列表等复杂的数据类型，其实就是修改类里面的
del role1.weapon #删除实例属性 用 del
role1.show_life_value()# 通过调用class的方法调用私有属性
role1.shot() #通过内部方法调用私有方法
print(role1.n,",",role1.list)
role2 = Role("Jone","AK47","police")
role2.n = "Jone_n"
role2.list.append("Jone_list")
print(role2.n,",",role2.list)
print(Role.n,",",Role.list)
运行结果：
Jack购买M416自动步枪 通过class内部方法调用私有属性：Jack的血量100 %s通过class内shot方法调用私有方法__private：私有方法只有class内部的方法可以调用，必须用self Jack_n , ['Jack_list'] Jone_n , ['Jack_list', 'Jone_list'] Role_n , ['Jack_list', 'Jone_list'] 析构函数，Jack自动销毁 析构函数，Jone自动销毁
面向对象的三大特性之一继承
#!/usr/bin/env python
# _*_ coding:utf-8 _*_
# Author:Bert
#class Person: #经典类
class Person(object): #新式类
""" 新式类与经典类 主要体现在多继承的顺序方面 Python3 广度优先 Python2 经典类 深度优先，新式类 广度优先"""
""" 定义一个父类 """
def __init__(self,name,age):
self.name=name
self.age=age
self.friends=[]
def eat(self):
print("%s 正在吃饭......"%(self.name))
def talk(self):
print("%s正在说话....."%(self.name))
class Relation(object):
def makfriends(self,obj):
print("%s和%s在交朋友...."%(self.name,obj.name))
self.friends.append(obj)
class Man(Person,Relation):
"""子类继承父类Person
多继承，中间用逗号隔开
"""
def __init__(self,name,age,job):
""" 父类构造方法的重构 """
super(Man, self).__init__(name, age)
""" 利用super()重构可以提高代码可修改行 另一种写法 Person.__init__(self,name,age) """
self.job=job
def play_game(self):
""" Man 的方法"""
print("%s 正在玩游戏......"%(self.name))
def talk(self):
""" 子类重写父类的方法 """
print("%s已经重写了父类的talk方法"%(self.name))
class Woman(Person):
"""子类继承父类Person"""
def huazhuang(self):
""" Woman 的方法"""
print("%s 正在化妆......"%(self.name))
def talk(self):
""" 重写父类方法，但保留父类方法的内容，添加新功能 """
super(Woman, self).talk()
"""另一种 Person.talk(self)"""
print("%s给父类talk方法添加了新功能...."%self.name)
man = Man("Jack",25,"Python") #实例化一个Man
woman = Woman("Like",24) ##实例化一个Woman
man.eat() #man 调用父类方法
man.play_game() #man 调用自己独有的方法
man.talk() #man 调用改写后的父类方法
man.makfriends(woman)
print("man的朋友：",man.friends[0])
woman.eat() #woman 调用父类方法
woman.huazhuang() #woman 调用自己独有的方法
woman.talk() #woman 调用改写后的父类方法
运行结果：
Jack 正在吃饭...... Jack 正在玩游戏...... Jack已经重写了父类的talk方法 Jack和Like在交朋友.... man的朋友： <__main__.Woman object at 0x0000029232431780> Like 正在吃饭...... Like 正在化妆...... Like正在说话..... Like给父类talk方法添加了新功能....
深度优先与广度优先的图解
广度优先的顺序为：A-B-C-D-E-F-G-H-I
深度优先的顺序为：A-B-D-E-I-C-F-G-H
面向对象的三大特性之一多态
#!/usr/bin/env python
# _*_ coding:utf-8 _*_
# Author:CarsonLi
class Animal(object):
def __init__(self,name):
self.name = name
def talk(self):
print("..................")
@staticmethod
def animal_talk(obj):
obj.talk()
class Dog(Animal):
def talk(self):
print("%s正在叫:汪汪汪..." % (self.name))
class Cat(Animal):
def talk(self):
print("%s正在叫:喵喵喵..." % (self.name))
dog = Dog("金毛")
cat = Cat("波斯猫")
""" 一个接口的多种实现 """
Animal.animal_talk(dog)
Animal.animal_talk(cat)
运行结果：
金毛正在叫:汪汪汪... 波斯猫正在叫:喵喵喵...