python学习日志--day6

python类与面向对象

一、面向对象编程（OOP）

1、程序=指令+数据

2、两种范型：

• 以指令为核心（围绕“正在发生什么”进行编写）
• 以数据为核心（围绕“将影响谁”进行编写）

3、核心概念：

• 机器模型（“解空间”或“方案空间”）-----问题模型（“问题空间”）
• 类型由状态集合（数据）和转换这些状态的操作的集合组成（类---抽象的，实例---具体的）

4、程序设计方法

• 所有东西都是对象
• 程序是一大堆对象的组合
• 对象有独立的存储空间，也可容纳其他对象（封装）
• 每个对象都属于某一类型
• 同一个类的所有对象都能接收相同的消息

5、对象的接口

on()      off()      brighten()

6、类

将同一种具体事物的共同特性抽象出来的表现

类=数据（变量、属性）+方法（函数）

7、类间关系

• 依赖（“uses-a”）:一个类的方法操纵另一个类的对象
• 继承（"is-a"）：描述特殊与一般关系
• 聚合（“has-a”）:类A的对象包含类B的对象

8、面向对象编程的原则

• 封装
• 继承

class People:

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

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

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

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


class Man(People):
    pass


class Woman(People):
    def get_birth(self):
        print("%s is born a baby..."%self.name)

m1 = Man("xiaoming",22)
m1.eat()
m1.talk()

m2 = Woman("xiaohong",21)
m2.get_birth()
m2.eat()

输出结果

• 多态：一个接口，多个方法

9、示例

示例1

class Dog():
    def __init__(self,name):
        self.name =name

    def bulk(self):
        print("%s:wang wang wang" % self.name)

a=Dog("xx")
b=Dog("zz")
c=Dog("ww")

a.bulk()
b.bulk()
c.bulk()

输出结果：

示例2

class Role:
    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 shot(self):
        print("shooting...")

    def got_shot(self):
        print("ah...,I got shot...")

    def buy_gun(self,gun_name):
        print("%s just bought %s" %(self.name,gun_name))

r1 = Role('yimi','police','AK47')
r2 = Role('Jack','terrorist','B22')

r1.got_shot()




输出结果



类变量&实例变量（类变量和实例变量同时存在，先找实例变量）
类变量：共用的属性，节省kaixiao

class Role:
    n = 123 #类变量
    n_list = []
    name = "我是类name"
    def __init__(self, name, role, weapon, life_value=100, money=15000):
        #构造函数
        #在实例化时做一些类的初始化的工作
        self.name = name #r1.name=name实例变量(静态属性),作用域就是实例本身
        self.role = role
        self.weapon = weapon
        self.__life_value = life_value
        self.money = money
    def __del__(self):
        pass #print("%s 彻底死了。。。。" %self.name)

    def show_status(self):
        print("name:%s weapon:%s life_val:%s" %(self.name,
                                                 self.weapon,
                                                self.__life_value))
    def __shot(self): # 类的方法，功能 （动态属性）
        print("shooting...")

    def got_shot(self):
        self.__life_value -=50
        print("%s:ah...,I got shot..."% self.name)

    def buy_gun(self, gun_name):
        print("%s just bought %s" % (self.name,gun_name) )



r1 = Role('Chenronghua', 'police',  'AK47') # Role(r1,'Alex', 'police',  'AK47')把一个类变成一个具体对象的过程叫 实例化(初始化一个类，造了一个对象)
r1.buy_gun("AK47")
r1.got_shot()
#r1.__shot()
print(r1.show_status())



r2 = Role('jack', 'terrorist', 'B22')  #生成一个角色
r2.got_shot()


输出结果







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








二、python类和实例
1、类的创建
使用class关键字

class ClassName(bases):
    data = value               #定义数据属性
    def method(self,...):      #定义方法属性
        self.method() = value

示例


class FirstClass():
    data = "hello"               #定义数据属性
    def printdata(self):      #定义方法属性
        print(self.data)