python---类

面向过程
一个面向过程的程序是一步步执行程序的模块，代码，模块代码之间有很强的关联性

面向对象
 类，对象

类的特点：
 继承，封装，多态
对象：
类实例化后的对象

 多态：一种接口，多种形态

 把一个类变成一个具体的对象的过程叫实例化
 类变量的用途：
 实例公用的变量，节省内存

 类
    属性
        实例变量
        类变量
        私有属性
    方法
        构造方法，初始化实例化使用
        析构函数

    继承：
        单继承
        多继承
        组合（即在构造函数中一个类中直接调用另一个类）

 析构函数
 在实例释放、销毁的时候自动执行的，通常用于做一些收尾工作，如关闭一些数据库连接打开的临时文件

 私有方法、私有属性
 只有自己能够访问


 广度优先和深度优先
 广度优先是同一层次的优先处理
 深度优先是将第一个进行深度处理

python 2 中，经典类是按着深度优先来继承，新式类是按广度优先来继承的
python 3 中，经典类和新式类都是统一按广度优先来继承的

类的初步实现：

# -*- coding:utf-8 -*-
# LC


class Role:
    number = 123   #类变量
    test_list = []
    def __init__(self,name,role,weapon,life_value=100,money=15000):
        #构造函数
        #在实例化时做一些类的初始化工作
        self.name = name            #实例变量（静态属性），作用域就是实例本身
        self.role = role
        self.weapon = weapon
        self.__life_value = life_value      #私有属性
        self.money = money
    def show_status(self):
        print("%s life value is %s"%(self.name,self.__life_value))  #通过调用类的函数进行查看私有属性
    def __show(self):   #私有方法，加两个_
        pass

    def __del__(self):
        #析构函数
        print("%s is die!!!"%self.name)

    def shot(self):#类的方法、功能，（动态属性）
        print("%s shoting..."%self.name)

    def got_shot(self):
        print("%s got shoting"%self.name)

    def find_role(self):
        print("%s role is %s"%(self.name,self.role))

    def buy_gun(self,gun_name):
        print("%s is buying %s"%(self.name,gun_name))
#类实例化

r1 = Role("LC","Terrorist","AK47")          #实例化，生成一个角色，又叫做Role这个类的实例
r1.shot()
r1.buy_gun("M4A1")
r2 = Role("xm","good guy","m4a1")
#实例变量优先于类变量

r1.bullet_prove = True      #可新增实例变量
r1.name = "hell"            #修改实例变量
del r1.name                 #删除实例变量

r1.number = "改类变量"      #改变r1的类变量，只对r1有效

#私有属性查看方法
r1.show_status()

r1.test_list.append("from r1")
r2.test_list.append("from r2")


print(r1.name,r1.number)

类的继承

#class People:  经典类
#class People(object):  新式类

class People(object):

    def __init__(self,name,age,):
        self.name = name
        self.age = age

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

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

    def talk(self):
        print("%s is talking"%self.name)

class Relation(object):     #新式类
    def make_friends(self,obj):
        print("%s is trying to make friends with %s"%(self.name,obj.name))

class Man(People,Relation):      #继承父类,多继承
    def __init__(self,name,age,money):      #对构造函数进行重构
        People.__init__(self,name,age)      #继承父类的参数继承
        #super(Man,self).__init__(name,age)  继承父类的构造函数，与People.__init__(self,name,age)一样，新式类写法
        self.money = money
        print("%s born with %s money"%(self.name,self.money))

    def piao(self):
        print("%s is piaoing"%self.name)

    def sleep(self):            #更新，重构父类方法
        People.sleep(self)
        print("man sleeping ,update")

class Women(People,Relation):   #多继承，多继承在实例在实例化过程中，查找构造函数的时候，先从本类找，如果没有，再从父类找，多继承的话，从继承的父类按左至右找

    def get_birth(self):
        print("birth")

m1 = Man("LC",16,100)
m1.eat()

w1 = Women("Pxm",11)

m1.make_friends(w1)

类的多态

class Animal(object):
    def __init__(self,name):
        self.name = name
    @staticmethod           #使用装饰器配合实现
    def animal_talk(obj):  # 多态的实现方式，一种接口，多种形态
        obj.talk()

class Dog(Animal):
    def talk(self):
        print("%s is Wooling"%self.name)

class Cat(Animal):
    def talk(self):
        print("%s is Mewing"%self.name)

D1 = Dog("dog1")
C1 = Cat("cat1")

D1.talk()
C1.talk()

def animal_talk(obj):       #多态的实现方式，一种接口，多种形态
    obj.talk()

animal_talk(D1)
animal_talk(C1)

Animal.animal_talk(D1)
Animal.animal_talk(C1)