Python3 面向对象编程

小案例：

#!/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)

　　运行结果：

金毛正在叫:汪汪汪...
波斯猫正在叫:喵喵喵...

　　

转载于:https://www.cnblogs.com/bert227/p/9347405.html