面向对象

  • 面向对象编程介绍
  • 类和对象
    • 类
    • 对象
    • 类和对象之间的关系
    • 区分类和对象
    • 类的构成
  • 定义类
  • 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 time
class 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 = cat
cat3 = catprint("---马上 删除cat对象")
del cat
print("---马上 删除cat2对象")
del cat2
print("---马上 删除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、B
class C(A,B):def printC(self):print('----C----')obj_C = C()
obj_C.printA()
obj_C.printB()

python中是可以多继承的
父类中的方法、属性，子类会继承

#coding=utf-8
class 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、B
class C(A,B):passobj_C = C()
obj_C.test()print(C.__mro__) #可以查看C类的对象搜索方法时的先后顺序

重写父类方法与调用父类方法

1. 重写父类方法

所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法

#coding=utf-8
class Cat(object):def sayHello(self):print("halou-----1")class Bosi(Cat):def sayHello(self):print("halou-----2")bosi = Bosi()bosi.sayHello()

2. 调用父类的方法

#coding=utf-8
class 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)...:
4391023224
4391023224
19'''

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 = 19
print(b.age)

运行结果:

Python中面向对象(类，对象，魔法，打印)相关推荐

  1. python定义一个dog类 类属性有名字毛色体重_全面了解python中的类,对象,方法,属性...

    python中一切皆为对象,所谓对象:我自己就是一个对象,我玩的电脑就是对象,坐着的椅子就是对象,家里养的小狗也是一个对象...... 我们通过描述属性(特征)和行为来描述一个对象的.比如家里的小狗, ...

  2. 理解Python中的类对象、实例对象、属性、方法

    class Animal(object): # 类对象age = 0 # 公有类属性__like = None # 私有类属性def __init__(self): # 魔法方法self.name = ...

  3. python类定义中、对象字符串的特殊方法是_python中自定义类对象json字符串化的方法_python json转字符串、...

    python中自定义类对象json字符串化的方法 1. 用 json 或者simplejson 就可以 2.定义转换函数: def convert_to_builtin_type(obj): prin ...

  4. Python之面向对象类和对象

    Python之面向对象类和对象 定义一个类:class 定义类的语法: class Test(object):"""类里定义一类事物共同的技能.可以是变量,也可是函数.& ...

  5. Javascript基础与面向对象基础~第四讲 Javascript中的类对象

    今天来说JS中如何实现类(class),事实上本应该昨天晚上写的,可我失言了,在些说一声"抱歉"!JS中的类是JS面向对象的基础,也是我最拿手的东西,你写的代码能否提高一个层次,一 ...

  6. python中的类属性和类方法_python面向对象之类属性和类方法的使用和实例

    类属性和类方法 目标 类的结构类属性和实例属性类方法和静态方法 01. 类的结构 1.1 术语 -- 实例 1. 使用面相对象开发,第 1 步 是设计 类 2. 使用 类名() 创建对象,创建对象 的 ...

  7. Python中面向对象（学习笔记）

    文章目录 一.面向过程与面向对象 简述 面向过程编程 面向对象编程 二.类和对象 类 对象(实例) 类和对象的关系 三.类的定义 四.类中的成员 类属性 实例函数(对象函数,成员函数) 实例函数和普通 ...

  8. python中的类class及self详解

    转载:https://blog.csdn.net/CLHugh/article/details/75000104 在介绍Python的self用法之前,先来介绍下Python中的类和实例-- 我们知道 ...

  9. python中的类及self详解

    在介绍Python的self用法之前,先来介绍下Python中的类和实例-- 我们知道,面向对象最重要的概念就是类(class)和实例(instance),类是抽象的模板,比如学生这个抽象的事物,可以 ...

  10. Python中的类、模块和包究竟是什么?

    Python培训教程:Python中的类.模块和包究竟是什么?在Python和其他编程语言中,都有类似或相同的概念,如对象.类.模块.包,名称都是一样的,只不过会有细微的一些区别,正是因为有这些存在, ...

最新文章

  1. Swift 中枚举、结构体、类（enum、struct、class）
  2. jsp+servlet 导出Excel表格
  3. Stanford CoreNLP使用需要注意的一点
  4. 物料信息记录中几个常见的数据表
  5. 2020ICPC(小米邀请赛2) - Knapsack(贪心+dp)
  6. python初学者_面向初学者的20种重要的Python技巧
  7. 数据分析--使用Web API(应用编程接口)以自动请求GitHub网站的特定信息为例爬取数据，附完整的Python代码详解
  8. 这N张模板，做出了秒杀echarts和python的可视化大屏，老板很满意
  9. 昔日最有前途的 Java 最终还是败给了晚辈 Python
  10. 《AngularJS高级程序设计》——第2章 你的第一个AngularJS应用 2.1 准备项目
  11. c语言 内存清除函数,C语言内存初始化函数MEMSET的用法
  12. PHP中strtotime()的使用
  13. 解读审计领域国内外资质认证CISA、ISO27001 Auditor
  14. php怎么求阶乘_php递归函数求阶乘
  15. 企业信息系统战略规划
  16. 国外手机短信验证码接收神器(转自美国华人网FuninUSA)
  17. 魔兽世界提取CG最新教程
  18. 图片上传到阿里云OSS
  19. 分享三个网页访问(点击)统计脚本，展示访问来源地图分布
  20. 秉火429笔记之十一 Systick--滴答定时器

热门文章

  1. Resend messages one by one
  2. 怎么在地图上标注自己的店铺
  3. 如何查询手机屏幕尺寸、密度，分辨率
  4. 2022年手机CPU性能天梯图排行榜 手机处理器排行榜 2022
  5. DAOS整体设计分析 （一）
  6. Win10任务栏假死问题解决方案
  7. iOS自学-混合编程
  8. VMware Workstation Ubuntu 20.04 LTS无法连接网络问题
  9. 计算机图形学（第2版 于万波 于硕 编著）第45页的Bresenham算法有错误
  10. xy苹果助手未受信任_苹果ios企业签名后App无法安装？如何解决？