面向对象
面向过程：根据业务逻辑从上到 下写代码
面向对象（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
