python-面向对象

面向对象

面向过程：根据业务逻辑从上到 下写代码
面向对象（OO）：将数据与函数绑定到一起，进行封装，这样能够更快速的开发过程，减少重复代码

类和对象

类的构成：
1、类的名称
2、类的属性
3、类的方法
类里的方法，self做为形参可以不传，也可以自己传参，也可以用其他变量代替self，但是为了程序的可读性，一般用 self

#encoding:utf-8
class Cat:
    #属性
    #方法
#python解析器会自动的调用init方法，一般用于设置默认值
    def __init__(self):
        print("我是猫")
    def eat(self):
        print("猫在吃鱼....")
    def drink(self):
        print("猫在喝水....")
    def introduce(self):
            print("%s的年龄是：%d"%(self.name,self.age))

#创建一个对象
tom = Cat()
#调用tom指向对象的方法
tom.drink()
tom.eat()
#给tom添加属性
tom.name = "汤姆"
tom.age = 55
tom.introduce()

lanmao = Cat()
lanmao.name = "蓝猫"
lanmao.age = 33
lanmao.introduce()

通过魔法方法传参数，初始化对象

#encoding:utf-8
class Cat:
    #属性
    #方法
    def __init__(self,new_name,new_age):
        self.name = new_name
        self.age = new_name
    def introduce(self):
            print("%s的年龄是：%s"%(self.name,self.age))
#创建一个对象
tom = Cat("Tom",40)
tom.introduce()
lanmao = Cat("蓝猫",10)
lanmao.introduce()

获取对象的描述信息时，用str方法，就可以直接打印对象。如下：

#encoding:utf-8
class Cat:
    #属性
    #方法
    def __init__(self,new_name,new_age):
        self.name = new_name
        self.age = new_name
    def __str__(self):
        return "%s的年龄是：%s"%(self.name,self.age)
#创建一个对象
tom = Cat("Tom",40)
lanmao = Cat("蓝猫",10)

print(tom)
print(lanmao)

面向对象的应用

烤地瓜例子：

#encoding:utf-8
class SweetPotato:
    def __init__(self):
        self.cookedstring = "生的"
        self.cookedLevel = 0
        self.condiments = []
    def __str__(self):
        return "地瓜 状态：%s(%d) 佐料：%s"%(self.cookedstring, self.cookedLevel, str(self.condiments))
    def cook(self,cooked_time):
        self.cookedLevel +=cooked_time
        if cooked_time>=0 and cooked_time<3:
            self.cookedstring = "生的"
        elif cooked_time >=3 and cooked_time <5:
            self.cookedstring = "半生不熟"
        elif cooked_time>=5 and cooked_time<8:
            self.cookedstring = "熟了"
        elif cooked_time>8:
            self.cookedstring = "糊了"
    def addCondiments(self, item):
        self.condiments.append(item)
digua = SweetPotato()
digua.cook(2)
digua.addCondiments("孜然")
print(digua)
digua.cook(4)
digua.addCondiments("大蒜")
print(digua)
运行结果：
地瓜 状态：生的(2) 佐料：['孜然']
地瓜 状态：半生不熟(6) 佐料：['孜然', '大蒜']

面向对象应用2

存放家具例子：

#encoding:utf-8
class Home:
    def __init__(self,new_area,new_info,new_addr):
        self.area = new_area
        self.info = new_info
        self.addr = new_addr
        self.leftarea = new_area
        self.contain_items = []
    def __str__(self):
        msg = "房子的总面积是：%d，可用面积是：%d,户型是：%s,地址是：%s"%(self.area, self.leftarea, self.info, self.addr)
        msg+= "当前房子的家具有：%s"%(str(self.contain_items))
        return msg
    def add_item(self,item):
        self.leftarea -= item.area
        self.contain_items.append(item.name)
class Bed:
    def __init__(self,new_name,new_area):
        self.name = new_name
        self.area = new_area
    def __str__(self):
        return "%s占地的面积是：%d"%(self.name,self.area)
fangzi = Home(129,"三室两厅","北京朝阳")
print(fangzi)
bed1  = Bed("席梦思",4)
#print(bed1)
fangzi.add_item(bed1)
print(fangzi)
bed2 = Bed("儿童床",3)
fangzi.add_item(bed2)
print(fangzi)
运行结果：
房子的总面积是：129，可用面积是：129,户型是：三室两厅,地址是：北京朝阳当前房子的家具有：[]
房子的总面积是：129，可用面积是：125,户型是：三室两厅,地址是：北京朝阳当前房子的家具有：['席梦思']
房子的总面积是：129，可用面积是：122,户型是：三室两厅,地址是：北京朝阳当前房子的家具有：['席梦思', '儿童床']

私有属性和私有方法

set和get方法

#encoding:utf-8
class Dog:
    def set_age(self,new_age):
        if new_age >0 and new_age<100:
            self.age = new_age
        else:
            self.age = 0  
    def get_age(self):
        return self.age
dog = Dog()
dog.set_age(10)
age = dog.get_age()
#dog.age = 3
#dog.name = "小白"
print(dog.age)

私有方法加一个__,不能用对象直接调用

#encoding:utf-8
class Dog:
    #私有方法
    def __test1(self):
        print("--正在发送短信--")
    #公有方法
    def test2(self,new_monney):
        if new_monney >10000:
            self.__test1()
        else:
            print("余额不足，请充值")
dog = Dog()
#dog.__test1()
dog.test2(1000000)

del()方法

#encoding:utf-8
class Dog:
    def __del__(self):
        print("正在销毁")
dog1 = Dog()
dog2 = dog1
del dog2
del dog1
print("---------------------------")
运行结果：
正在销毁
---------------------------

#encoding:utf-8
class Dog:
    def __del__(self):
        print("正在销毁")
dog1 = Dog()
dog2 = dog1
del dog1
print("---------------------------")
运行结果：
---------------------------
正在销毁

从以上两个代码片可以看出，当一个对象的所有引用都被删除后才会自动调用del方法，并且，此方法系统自动调用，无需手动调用。即引用计数器为0时才会自动销毁

获取引用计数器的方法

>>> import sys
>>> class T:
...     pass
... 
>>> t = T()
>>> sys.getrefcount(t)
2
>>> tt = t
>>> sys.getrefcount(t)
3