【python自动化第六篇：面向对象】

知识点概览：

编程范式：面向对象，面向过程，函数式编程

• 面向过程：通过一组指令告诉机器去一步一做什么；一个过程包含一组要被进行计算的步骤，从头到尾的执行顺序；

三、面向对象编程

• 射击游戏模拟角色（深入类）

#!/usr/bin/env python
# -*- coding:utf-8 -*-

class Role(object):  #定义一个类
    m = 123  #定义类变量
    # 构造函数：在实例化时做一些类的初始化工作
    def __init__(self,name,role,weapon,life_value=100,money=12000):
        self.name = name #实例变量
        self.role = role
        self.weapon = weapon
        self.life_value = life_value
        self.money = money
    def shot(self): #类的方法（功能），也可以成为动态属性
        print("shot。。。。")
    def got_shot(self):
        print('i got shot....')
    def buy_gun(self,gun_name):
        print("%s buy gun %s" %(self.name,gun_name))
r1 = Role("wanghui",'police','kii')
r1.buy_gun('ssdsd')

• 类变量和实例变量（1）

#!/usr/bin/env python
# -*- coding:utf-8 -*-

class Role(object):
    n = 1234  # 类变量
    n_list = []
    name = "lei"
    def __init__(self, name, role, weapon, life_value=100, money=12000):
        self.name = name  # 实例变量
        self.weapon = weapon

r1 = Role('wanghui', 'police', "ak99")
r2 = Role("lijie", "jiji", 'kb132')
r1.name = 'gailei' # 修改实例变量
r1.bullet_prove = True  # 添加实例变量，而且只有r1有
r1.n = "change_value"
r1.n_list.append(124)
r2.n_list.append(2)
del r1.weapon  # 删除实例变量
print(r1.n, r2.n) #('change_value', 1234)
print(Role.n_list, r1.n_list, r2.n_list) #([124, 2], [124, 2], [124, 2])
#找的结果还是从实例变量里面去找，如果实例本身不存在找类变量 ('change_value', 'gailei', [124, 2], True)
print(r1.n, r1.name, r1.n_list, r1.bullet_prove)

• 三大特性：

私有属性：在属性前面加__
私有方法：在方法名前面加__

class Role(object):
    def __init__(self, name, role, weapon, life_value=100, money=12000):
        self.__life_value = life_value  # 属性私有化步骤（加__）
        self.money = money

    def __shot(self):  # 私有方法（还是前面加__）
        print("shoting!!!")

继承：减少重复代码

class People(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sleep(self):
        print("%s is sleeping!!" % self.name)


class Man(People):  # 继承父类People
    def drink(self):
        print("%s is drinking!!" % self.name)

    def sleep(self):  # 父类方法重构（子类和父类有同样的方法时就需要重构）
        People.sleep(self)  # 这样也能执行父类的方法
        print("man is sleeping！")

多态：目的是为了实现接口的重复利用，同样也能做到节省代码

class Animal(object):
    def __init__(self, name):
        self.name = name

    def talk(self):
        pass

    @staticmethod  # 静态方法
    def animal__talk(obj):  # 创建新函数
        obj.talk()

class Dog(Animal):
    def talk(self):
        print("wang wang!!")

d1 = Dog("hhhh")
Animal.animal__talk(d1)

四、其他概念

• 父类函数的重构问题：如果在继承的时候子类和父类的实例化参数有重复，则调用子类的实例化后的函数时，要注意父类函数的重构

class People(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age

class Man(People):
    # 重构了父类的构造函数，因此需要将父类的构造函数也要写上
    def __init__(self,name,age,money):
        super(Man,self).__init__(name,age)              #继承父类的构造方法
        self.money = money                                       #初始化自己的参数
        print("%s has %s money"%(self.name,self.money))

    def  drink(self):
        print("%s is drinking!!"%self.name)

m1 = Man("hehe",12,100)
m1.drink()

析构函数：

class Role(object):
    def __del__(self):  # 析构函数
        print("%s 彻底死了 ！！" % self.name)

    def __init__(self, name, role, weapon, life_value=100, money=12000):
        self.name = name  # 实例变量

r1 = Role('wanghui', 'police', "ak99")
del r1  # 这个实例被销毁了 ，那析构函数就开始执行了

　新式类和经典类的区别在于：（object）
在Python2.x的经典类中是按照深度优先来继承的，然而在其新式类中用的是广度优先来继承的
在Python3.x中无论是经典类还是新式类都是按照广度优先来继承的

• 多继承问题

class People(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.friends = []

    def eat(self):
        print("%s is eating" % self.name)

    def sleep(self):
        print("%s is sleeping!!" % self.name)

class Relation(object):
    def __init__(self):
        print(self.name)

    def make_friends(self, obj):
        # name是从w1里面传过来的
        print("%s make friends with %s" % (self.name, obj.name))
        self.friends.append(obj)

class Man(People, Relation):  # 多继承
    def drink(self):
        print("%s is drinking!!" % self.name)

    def sleep(self):  # 父类方法重构（子类和父类有同样的方法时就需要重构）
        People.sleep(self)  # 这样也能执行父类的方法
        print("man is sleeping！")

class Woman(People, Relation):  # 多继承
    def get_birth(self):
        print("%s is bon a baby" % self.name)

m1 = Man("wanghui", 24)
w1 = Woman("hehe", 22)
w1.name = "呵呵哒"  # 改名字
m1.make_friends(w1)  # 多继承调用
print(m1.friends[0].name)  # 打印列表内容