面向对象
面向对象编程介绍类和对象类对象类和对象之间的关系区分类和对象类的构成定义类self创建对象创建多个对象保护对象的属性"魔法"方法打印id()定义__str__()方法应用:烤地瓜分析“烤地瓜”的属性和方法定义类，并且定义__init__()方法添加"烤地瓜"方法完整版代码测试cook方法是否好用定义addCondiments()方法和__str__()方法再次测试完整版应用:存放家具隐藏数据__init__()方法__del__()方法继承单继承多继承重写父类方法与调用父类方法1. 重写父类方法2. 调用父类的方法类属性、实例属性类属性实例属性(对象属性)通过实例(对象)去修改类属性多态静态方法和类方法1. 类方法2. 静态方法单例模式1. 单例是什么2. 创建单例-保证只有1个对象3. 创建单例时，只执行1次__init__方法面向对象编程介绍
A同学报道登记信息
B同学报道登记信息
C同学报道登记信息
A同学做自我介绍
B同学做自我介绍
C同学做自我介绍
stu_a = {"name":"A","age":21,"gender":1,"hometown":"河北"}stu_b = {"name":"B","age":22,"gender":0,"hometown":"山东"}stu_c = {"name":"C","age":20,"gender":1,"hometown":"安徽"}def stu_intro(stu):"""自我介绍"""for key, value in stu.items():print("key=%s, value=%d"%(key,value))stu_intro(stu_a)stu_intro(stu_b)stu_intro(stu_c)
考虑现实生活中，我们的思维方式是放在学生这个个人上，是学生做了自我介绍。而不是像我们刚刚写出的代码，先有了介绍的行为，再去看介绍了谁。
用我们的现实思维方式该怎么用程序表达呢？
stu_a = Student(个人信息)stu_b = Student(个人信息)stu_c = Student(个人信息)stu_a.intro()stu_a.intro()stu_a.intro()
面向过程：根据业务逻辑从上到下写代码
面向对象：将数据与函数绑定到一起，进行封装，这样能够更快速的开发程序，减少了重复代码的重写过程
面向过程编程最易被初学者接受，其往往用一长段代码来实现指定功能，开发过程的思路是将数据与函数按照执行的逻辑顺序组织在一起，数据与函数分开考虑。
def 发送邮件(内容)#发送邮件提醒连接邮箱服务器发送邮件关闭连接while True：if cpu利用率 > 90%:发送邮件('CPU报警')if 硬盘使用空间 > 90%:发送邮件('硬盘报警')if 内存占用 > 80%:发送邮件('内存报警')
面向对象(object-oriented ;简称: OO) 至今还没有统一的概念 我这里把它定义为: 按人们 认识客观世界的系统思维方式,采用基于对象(实体) 的概念建立模型,模拟客观世界分析、设 计、实现软件的办法。
面向对象编程(Object Oriented Programming-OOP) 是一种解决软件复用的设计和编程方法。 这种方法把软件系统中相近相似的操作逻辑和操作 应用数据、状态,以类的型式描述出来,以对象实例的形式在软件系统中复用,以达到提高软件开发效率的作用。
类和对象
面向对象编程的2个非常重要的概念：类和对象
对象是面向对象编程的核心，在使用对象的过程中，为了将具有共同特征和行为的一组对象抽象定义，提出了另外一个新的概念——类
类就相当于制造飞机时的图纸，用它来进行创建的飞机就相当于对象
类
人以类聚 物以群分。
具有相似内部状态和运动规律的实体的集合(或统称为抽象)。
具有相同属性和行为事物的统称
类是抽象的,在使用的时候通常会找到这个类的一个具体的存在,使用这个具体的存在。一个类可以找到多个对象
对象
某一个具体事物的存在 ,在现实世界中可以是看得见摸得着的。
可以是直接使用的
类和对象之间的关系
小总结：类就是创建对象的模板
区分类和对象
奔驰汽车 类
奔驰smart 类
张三的那辆奔驰smart 对象
狗 类
大黄狗 类
李四家那只大黄狗 对象
水果 类
苹果 类
红苹果 类 红富士苹果 类
我嘴里吃了一半的苹果 对象
类的构成
类(Class) 由3个部分构成
类的名称:类名
类的属性:一组数据
类的方法:允许对进行操作的方法 (行为)
举例：
人类设计,只关心3样东西:
事物名称(类名):人(Person)
属性:身高(height)、年龄(age)
方法(行为/功能):跑(run)、打架(fight)
狗类的设计
类名:狗(Dog
)属性:品种 、毛色、性别、名字、 腿儿的数量
方法(行为/功能):叫 、跑、咬人、吃、摇尾巴
类的抽象
拥有相同(或者类似)属性和行为的对象都可以抽像出一个类
定义类
定义一个类，格式如下：
class 类名:方法列表
定义一个Car类
# 定义类class Car:# 方法def getCarInfo(self):print('车轮子个数:%d, 颜色%s'%(self.wheelNum, self.color))def move(self):print("车正在移动...")
定义类时有2种：
新式类和经典类，上面的Car为经典类，如果是Car(object)则为新式类
类名 的命名规则按照"大驼峰"
self
理解self
# 定义一个类class Animal:# 方法def __init__(self, name):self.name = namedef printName(self):print('名字为:%s'%self.name)# 定义一个函数def myPrint(animal):animal.printName()dog1 = Animal('西')myPrint(dog1)dog2 = Animal('北')myPrint(dog2)
所谓的self，可以理解为自己
可以把self当做C++中类里面的this指针一样理解，就是对象自身的意思
某个对象调用其方法时，python解释器会把这个对象作为第一个参数传递给self，所以开发者只需要传递后面的参数即可
创建对象
通过上一节课程，定义了一个Car类；就好比有车一个张图纸，那么接下来就应该把图纸交给生成工人们去生成了
python中，可以根据已经定义的类去创建出一个个对象
创建对象的格式为:
对象名 = 类名()
创建对象:
# 定义类class Car:# 移动def move(self):print('车在奔跑...')# 鸣笛def toot(self):print("车在鸣笛...嘟嘟..")# 创建一个对象，并用变量BMW来保存它的引用BMW = Car()BMW.color = '黑色'BMW.wheelNum = 4 #轮子数量BMW.move()BMW.toot()print(BMW.color)print(BMW.wheelNum)
BMW = Car()，这样就产生了一个Car的实例对象，此时也可以通过实例对象BMW来访问属性或者方法
第一次使用BMW.color = '黑色’表示给BMW这个对象添加属性，如果后面再次出现BMW.color = xxx表示对属性进行修改
BMW是一个对象，它拥有属性（数据）和方法（函数）
当创建一个对象时，就是用一个模子，来制造一个实物
创建多个对象
创建一个Car类
创建出多个汽车对象，比如BMW、AUDI等
保护对象的属性
如果有一个对象，当需要对其进行修改属性时，有2种方法
对象名.属性名 = 数据 ---->直接修改
对象名.方法名() ---->间接修改
为了更好的保存属性安全，即不能随意修改，一般的处理方式为
将属性定义为私有属性
添加一个可以调用的方法，供调用
class People(object):def __init__(self, name):self.__name = namedef getName(self):return self.__namedef setName(self, newName):if len(newName) >= 5:self.__name = newNameelse:print("error:名字长度需要大于或者等于5")xiaoming = People("dongGe")print(xiaoming.__name)
class People(object):def __init__(self, name):self.__name = namedef getName(self):return self.__namedef setName(self, newName):if len(newName) >= 5:self.__name = newNameelse:print("error:名字长度需要大于或者等于5")xiaoming = People("dongGe")xiaoming.setName("wanger")print(xiaoming.getName())xiaoming.setName("lisi")print(xiaoming.getName())
Python中没有像C++中public和private这些关键字来区别公有属性和私有属性
它是以属性命名方式来区分，如果在属性名前面加了2个下划线’__’，则表明该属性是私有属性，否则为公有属性（方法也是一样，方法名前面加了2个下划线的话表示该方法是私有的，否则为公有的）。
"魔法"方法
打印id()
如果把BMW使用print进行输出的话，会看到如下的信息
即看到的是创建出来的BMW对象在内存中的地址
定义__str__()方法
class Car:def __init__(self, newWheelNum, newColor):self.wheelNum = newWheelNumself.color = newColordef __str__(self):msg = "嘿。。。我的颜色是" + self.color + "我有" + int(self.wheelNum) + "个轮胎..."return msgdef move(self):print('车在跑，目标:夏威夷')BMW = Car(4, "白色")print(BMW)
在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法
当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据
应用:烤地瓜
为了更好的理解面向对象编程，下面以“烤地瓜”为案例，进行分析
分析“烤地瓜”的属性和方法
示例属性如下:
cookedLevel : 这是数字；0~3表示还是生的，超过3表示半生不熟，超过5表示已经烤好了，超过8表示已经烤成木炭了！我们的地瓜开始时时生的
cookedString : 这是字符串；描述地瓜的生熟程度
condiments : 这是地瓜的配料列表，比如番茄酱、芥末酱等
示例方法如下:
cook() : 把地瓜烤一段时间
addCondiments() : 给地瓜添加配料
init() : 设置默认的属性
str() : 让print的结果看起来更好一些
定义类，并且定义__init__()方法
#定义`地瓜`类class SweetPotato:'这是烤地瓜的类'#定义初始化方法def __init__(self):self.cookedLevel = 0self.cookedString = "生的"self.condiments = []
添加"烤地瓜"方法
#烤地瓜方法def cook(self, time):self.cookedLevel += timeif self.cookedLevel > 8:self.cookedString = "烤成灰了"elif self.cookedLevel > 5:self.cookedString = "烤好了" elif self.cookedLevel > 3:self.cookedString = "半生不熟"else:self.cookedString = "生的"
完整版代码
把上面2块代码合并为一个程序后，在代码的下面添加以下代码进行测试
mySweetPotato = SweetPotato()print(mySweetPotato.cookedLevel)print(mySweetPotato.cookedString)print(mySweetPotato.condiments)
完整的代码为:
class SweetPotato:'这是烤地瓜的类'#定义初始化方法def __init__(self):self.cookedLevel = 0self.cookedString = "生的"self.condiments = []#烤地瓜方法def cook(self, time):self.cookedLevel += timeif self.cookedLevel > 8:self.cookedString = "烤成灰了"elif self.cookedLevel > 5:self.cookedString = "烤好了" elif self.cookedLevel > 3:self.cookedString = "半生不熟"else:self.cookedString = "生的"# 用来进行测试mySweetPotato = SweetPotato()print(mySweetPotato.cookedLevel)print(mySweetPotato.cookedString)print(mySweetPotato.condiments)
测试cook方法是否好用
在上面的代码最后面添加如下代码:
print("------接下来要进行烤地瓜了-----")mySweetPotato.cook(4) #烤4分钟print(mySweetPotato.cookedLevel)print(mySweetPotato.cookedString)
定义addCondiments()方法和__str__()方法
def __str__(self):msg = self.cookedString + " 地瓜"if len(self.condiments) > 0:msg = msg + "("for temp in self.condiments:msg = msg + temp + ", "msg = msg.strip(", ")msg = msg + ")"return msgdef addCondiments(self, condiments):self.condiments.append(condiments)
再次测试完整版
完整的代码如下:
class SweetPotato:"这是烤地瓜的类"#定义初始化方法def __init__(self):self.cookedLevel = 0self.cookedString = "生的"self.condiments = []#定制print时的显示内容def __str__(self):msg = self.cookedString + " 地瓜"if len(self.condiments) > 0:msg = msg + "("for temp in self.condiments:msg = msg + temp + ", "msg = msg.strip(", ")msg = msg + ")"return msg#烤地瓜方法def cook(self, time):self.cookedLevel += timeif self.cookedLevel > 8:self.cookedString = "烤成灰了"elif self.cookedLevel > 5:self.cookedString = "烤好了" elif self.cookedLevel > 3:self.cookedString = "半生不熟"else:self.cookedString = "生的"#添加配料def addCondiments(self, condiments):self.condiments.append(condiments)# 用来进行测试mySweetPotato = SweetPotato()print("------有了一个地瓜，还没有烤-----")print(mySweetPotato.cookedLevel)print(mySweetPotato.cookedString)print(mySweetPotato.condiments)print("------接下来要进行烤地瓜了-----")print("------地瓜经烤了4分钟-----")mySweetPotato.cook(4) #烤4分钟print(mySweetPotato)print("------地瓜又经烤了3分钟-----")mySweetPotato.cook(3) #又烤了3分钟print(mySweetPotato)print("------接下来要添加配料-番茄酱------")mySweetPotato.addCondiments("番茄酱")print(mySweetPotato)print("------地瓜又经烤了5分钟-----")mySweetPotato.cook(5) #又烤了5分钟print(mySweetPotato)print("------接下来要添加配料-芥末酱------")mySweetPotato.addCondiments("芥末酱")print(mySweetPotato)
应用:存放家具
#定义一个home类class Home:def __init__(self, area):self.area = area #房间剩余的可用面积#self.light = 'on' #灯默认是亮的self.containsItem = []def __str__(self):msg = "当前房间可用面积为:" + str(self.area)if len(self.containsItem) > 0:msg = msg + " 容纳的物品有: "for temp in self.containsItem:msg = msg + temp.getName() + ", "msg = msg.strip(", ")return msg#容纳物品def accommodateItem(self,item):#如果可用面积大于物品的占用面积needArea = item.getUsedArea()if self.area > needArea:self.containsItem.append(item)self.area -= needAreaprint("ok:已经存放到房间中")else:print("err:房间可用面积为:%d,但是当前要存放的物品需要的面积为%d"%(self.area, needArea))#定义bed类class Bed:def __init__(self,area,name = '床'):self.name = nameself.area = areadef __str__(self):msg = '床的面积为:' + str(self.area)return msg#获取床的占用面积def getUsedArea(self):return self.areadef getName(self):return self.name#创建一个新家对象newHome = Home(100)#100平米print(newHome)#创建一个床对象newBed = Bed(20)print(newBed)#把床安放到家里newHome.accommodateItem(newBed)print(newHome)#创建一个床对象newBed2 = Bed(30,'席梦思')print(newBed2)#把床安放到家里newHome.accommodateItem(newBed2)print(newHome)
如果一个对象与另外一个对象有一定的关系，那么一个对象可用是另外一个对象的属性
隐藏数据
可能你已经意识到，查看过着修改对象的属性（数据），有2种方法
1.直接通过对象名修改
SweetPotato.cookedLevel = 5
2.通过方法间接修改
SweetPotato.cook(5)
至少有2个原因：
如果直接修改属性，烤地瓜至少需要修改2部分，即修改cookedLevel和cookedString。而使用方法来修改时，只需要调用一次即可完成
如果直接访问属性，可能会出现一些数据设置错误的情况产生例如cookedLevel = -3。这会使地瓜比以前还生，当然了这也没有任何意义，通过使用方法来进行修改，就可以在方法中进行数据合法性的检查
init()方法
1.使用方式
def 类名:#初始化函数，用来完成一些默认的设定def __init__():pass
2.init()方法的调用
# 定义汽车类class Car:def __init__(self):self.wheelNum = 4self.color = '蓝色'def move(self):print('车在跑，目标:夏威夷')# 创建对象BMW = Car()print('车的颜色为:%s'%BMW.color)print('车轮胎数量为:%d'%BMW.wheelNum)
当创建Car对象后，在没有调用__init__()方法的前提下，BMW就默认拥有了2个属性wheelNum和color，原因是__init__()方法是在创建对象后，就立刻被默认调用了
init()方法，在创建一个对象时默认被调用，不需要手动调用
init(self)中，默认有1个参数名字为self，如果在创建对象时传递了2个实参，那么__init__(self)中出了self作为第一个形参外还需要2个形参，例如__init__(self,x,y)
init(self)中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递进去
del()方法
创建对象后，python解释器默认调用__init__()方法；
当删除一个对象时，python解释器也会默认调用一个方法，这个方法为__del__()方法
import timeclass Animal(object):# 初始化方法# 创建完对象后会自动被调用def __init__(self, name):print('__init__方法被调用')self.__name = name# 析构方法# 当对象被删除时，会自动被调用def __del__(self):print("__del__方法被调用")print("%s对象马上被干掉了..."%self.__name)# 创建对象dog = Animal("哈皮狗")# 删除对象del dogcat = Animal("波斯猫")cat2 = catcat3 = catprint("---马上 删除cat对象")del catprint("---马上 删除cat2对象")del cat2print("---马上 删除cat3对象")del cat3print("程序2秒钟后结束")time.sleep(2)
当有1个变量保存了对象的引用时，此对象的引用计数就会加1
当使用del删除变量指向的对象时，如果对象的引用计数不会1，比如3，那么此时只会让这个引用计数减1，即变为2，当再次调用del时，变为1，如果再调用1次del，此时会真的把对象进行删除
继承
单继承
# 定义一个父类，如下:class Cat(object):def __init__(self, name, color="白色"):self.name = nameself.color = colordef run(self):print("%s--在跑"%self.name)# 定义一个子类，继承Cat类如下:class Bosi(Cat):def setNewName(self, newName):self.name = newNamedef eat(self):print("%s--在吃"%self.name)bs = Bosi("印度猫")print('bs的名字为:%s'%bs.name)print('bs的颜色为:%s'%bs.color)bs.eat()bs.setNewName('波斯')bs.run()
虽然子类没有定义__init__方法，但是父类有，所以在子类继承父类的时候这个方法就被继承了，所以只要创建Bosi的对象，就默认执行了那个继承过来的__init__方法
总结：
子类在继承的时候，在定义类时，小括号()中为父类的名字
父类的属性、方法，会被继承给子类
注意点
class Animal(object):def __init__(self, name='动物', color='白色'):self.__name = nameself.color = colordef __test(self):print(self.__name)print(self.color)def test(self):print(self.__name)print(self.color)class Dog(Animal):def dogTest1(self):#print(self.__name) #不能访问到父类的私有属性print(self.color)def dogTest2(self):#self.__test() #不能访问父类中的私有方法self.test()A = Animal()#print(A.__name) #程序出现异常，不能访问私有属性print(A.color)#A.__test() #程序出现异常，不能访问私有方法A.test()print("------分割线-----")D = Dog(name = "小花狗", color = "黄色")D.dogTest1()D.dogTest2()
私有的属性，不能通过对象直接访问，但是可以通过方法访问
私有的方法，不能通过对象直接访问
私有的属性、方法，不会被子类继承，也不能被访问
一般情况下，私有的属性、方法都是不对外公布的，往往用来做内部的事情，起到安全的作用
多继承
Python中多继承的格式如下:
# 定义一个父类class A:def printA(self):print('----A----')# 定义一个父类class B:def printB(self):print('----B----')# 定义一个子类，继承自A、Bclass C(A,B):def printC(self):print('----C----')obj_C = C()obj_C.printA()obj_C.printB()
python中是可以多继承的
父类中的方法、属性，子类会继承
#coding=utf-8class base(object):def test(self):print('----base test----')class A(base):def test(self):print('----A test----')# 定义一个父类class B(base):def test(self):print('----B test----')# 定义一个子类，继承自A、Bclass C(A,B):passobj_C = C()obj_C.test()print(C.__mro__) #可以查看C类的对象搜索方法时的先后顺序
重写父类方法与调用父类方法
1. 重写父类方法
所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法
#coding=utf-8class Cat(object):def sayHello(self):print("halou-----1")class Bosi(Cat):def sayHello(self):print("halou-----2")bosi = Bosi()bosi.sayHello()
2. 调用父类的方法
#coding=utf-8class Cat(object):def __init__(self,name):self.name = nameself.color = 'yellow'class Bosi(Cat):def __init__(self,name):# 调用父类的__init__方法1(python2)#Cat.__init__(self,name)# 调用父类的__init__方法2#super(Bosi,self).__init__(name)# 调用父类的__init__方法3super().__init__(name)def getName(self):return self.namebosi = Bosi('xiaohua')print(bosi.name)print(bosi.color)
类属性、实例属性
在前面的例子中我们接触到的就是实例属性（对象属性），顾名思义，类属性就是类对象所拥有的属性，它被所有类对象的实例对象所共有，在内存中只存在一个副本，这个和C++中类的静态成员变量有点类似。对于公有的类属性，在类外可以通过类对象和实例对象访问
类属性
class People(object):name = 'Tom' #公有的类属性__age = 12#私有的类属性p = People()print(p.name) #正确print(People.name)#正确print(p.__age) #错误，不能在类外通过实例对象访问私有的类属性print(People.__age) #错误，不能在类外通过类对象访问私有的类属性
实例属性(对象属性)
class People(object):address = '山东' #类属性def __init__(self):self.name = 'xiaowang' #实例属性self.age = 20 #实例属性p = People()p.age =12 #实例属性print(p.address) #正确print(p.name) #正确print(p.age)#正确print(People.address) #正确print(People.name) #错误print(People.age)#错误
通过实例(对象)去修改类属性
class People(object):country = 'china' #类属性print(People.country)p = People()print(p.country)p.country = 'japan' print(p.country)#实例属性会屏蔽掉同名的类属性print(People.country)del p.country #删除实例属性print(p.country)
如果需要在类外修改类属性，必须通过类对象去引用然后进行修改。如果通过实例对象去引用，会产生一个同名的实例属性，这种方式修改的是实例属性，不会影响到类属性，并且之后如果通过实例对象去引用该名称的属性，实例属性会强制屏蔽掉类属性，即引用的是实例属性，除非删除了该实例属性。
多态
多态的概念是应用于Java和C#这一类强类型语言中，而Python崇尚“鸭子类型”。
所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态
Python伪代码实现Java或C#的多态
class F1(object):def show(self):print 'F1.show'class S1(F1):def show(self):print 'S1.show'class S2(F1):def show(self):print 'S2.show'# 由于在Java或C#中定义函数参数时，必须指定参数的类型# 为了让Func函数既可以执行S1对象的show方法，又可以执行S2对象的show方法，所以，定义了一个S1和S2类的父类# 而实际传入的参数是：S1对象和S2对象def Func(F1 obj):"""Func函数需要接收一个F1类型或者F1子类的类型"""print obj.show()s1_obj = S1()Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法，结果：S1.shows2_obj = S2()Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法，结果：S2.show
Python “鸭子类型”
class F1(object):def show(self):print 'F1.show'class S1(F1):def show(self):print 'S1.show'class S2(F1):def show(self):print 'S2.show'def Func(obj):print obj.show()s1_obj = S1()Func(s1_obj) s2_obj = S2()Func(s2_obj)
静态方法和类方法
1. 类方法
是类对象所拥有的方法，需要用修饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数（当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以’cls’作为第一个参数的名字，就最好用’cls’了），能够通过实例对象和类对象去访问。
class People(object):country = 'china'#类方法，用classmethod来进行修饰@classmethoddef getCountry(cls):return cls.countryp = People()print p.getCountry() #可以用过实例对象引用print People.getCountry() #可以通过类对象引用
类方法还有一个用途就是可以对类属性进行修改：
class People(object):country = 'china'#类方法，用classmethod来进行修饰@classmethoddef getCountry(cls):return cls.country@classmethoddef setCountry(cls,country):cls.country = countryp = People()print p.getCountry() #可以用过实例对象引用print People.getCountry() #可以通过类对象引用p.setCountry('japan') print p.getCountry() print People.getCountry()
结果显示在用类方法对类属性修改之后，通过类对象和实例对象访问都发生了改变
2. 静态方法
需要通过修饰器@staticmethod来进行修饰，静态方法不需要多定义参数
class People(object):country = 'china'@staticmethod#静态方法def getCountry():return People.countryprint People.getCountry()
从类方法和实例方法以及静态方法的定义形式就可以看出来，类方法的第一个参数是类对象cls，那么通过cls引用的必定是类对象的属性和方法；而实例方法的第一个参数是实例对象self，那么通过self引用的可能是类属性、也有可能是实例属性（这个需要具体分析），不过在存在相同名称的类属性和实例属性的情况下，实例属性优先级更高。静态方法中不需要额外定义参数，因此在静态方法中引用类属性的话，必须通过类对象来引用
单例模式
1. 单例是什么
举个常见的单例模式例子，我们日常使用的电脑上都有一个回收站，在整个操作系统中，回收站只能有一个实例，整个系统都使用这个唯一的实例，而且回收站自行提供自己的实例。因此回收站是单例模式的应用。
确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类，单例模式是一种对象创建型模式。
2. 创建单例-保证只有1个对象
# 实例化一个单例class Singleton(object):__instance = Nonedef __new__(cls, age, name):#如果类属性__instance的值为None，#那么就创建一个对象，并且赋值为这个对象的引用，保证下次调用这个方法时#能够知道之前已经创建过对象了，这样就保证了只有1个对象if not cls.__instance:cls.__instance = object.__new__(cls)return cls.__instancea = Singleton(18, "dongGe")b = Singleton(8, "dongGe")print(id(a))print(id(b))a.age = 19 #给a指向的对象添加一个属性print(b.age)#获取b指向的对象的age属性'''运行结果：In [12]: class Singleton(object):...:__instance = None...: ...:def __new__(cls, age, name):...: if not cls.__instance:...: cls.__instance = object.__new__(cls)...: return cls.__instance...: ...: a = Singleton(18, "dongGe")...: b = Singleton(8, "dongGe")...: ...: print(id(a))...: print(id(b))...: ...: a.age = 19...: print(b.age)...: 4391023224439102322419'''
3. 创建单例时，只执行1次__init__方法
# 实例化一个单例class Singleton(object):__instance = None__first_init = Falsedef __new__(cls, age, name):if not cls.__instance:cls.__instance = object.__new__(cls)return cls.__instancedef __init__(self, age, name):if not self.__first_init:self.age = ageself.name = nameSingleton.__first_init = Truea = Singleton(18, "dongGe")b = Singleton(8, "dongGe")print(id(a))print(id(b))print(a.age)print(b.age)a.age = 19print(b.age)
运行结果:
如果觉得《Python中面向对象(类 对象 魔法 打印)》对你有帮助，请点赞、收藏，并留下你的观点哦！
