1、类的特殊方法（魔术方法）
目前，对于Person类来说，name属性是必须的，并且每一个对象中的name属性都是不同的
class Person():
name = ‘葫芦娃’
def speak(self):
print(‘大家好我是%s’%self.name)
p1 = Person()
p2 = Person()
p1.speak()
p2.speak()
p1,p2返回值都是 葫芦娃
class Person():
#name = ‘葫芦娃’
def speak(self):
print(‘大家好我是%s’%self.name)
p1 = Person()
p2 = Person()
因为每个对象的name不同，所以注释了公共属性，手动添加对象的name属性
p1.name = ‘葫芦娃’
p2.name = ‘钢铁侠’
p1.speak()
p2.speak()
返回值：
p1葫芦娃
p2钢铁侠
在类中我们可以定义一些特殊的方法（魔术方法）
这些特殊方法的格式 例如：以__开头__结尾的方法
特殊的方法不需要我们自己调用
学习特殊方法
1）特殊方法什么时候调用？
2）特殊方法有什么作用？
创建对象的流程
p1 = person()
1）创建一个变量
2）在内存中创建一个新的对象
3）执行代码块中的代码（只在类定义的时候执行一次）
4）init(self)方法执行
定义一个类的基本结构
class 类名([父类]):
公共属性
#对象的初始化方法
def init(self):
…
def method1(self,…):
…
def method2(self,…):
…
class Person():
#name = ‘葫芦娃’
#特殊方法不需要调用
#特殊方法会在特殊的时候自己调用（一般就是解析器调用）
def init(self):
print(‘init方法执行了’)
def speak(self):
print(‘大家好我是%s’%self.name)
p1 = Person()
返回值：init方法执行了
class Person():
#name = ‘葫芦娃’
#特殊方法不需要调用
#特殊方法会在特殊的时候自己调用（一般就是解释器调用）
def init(self,name):
#print(self)
#通过self向新创建的对象中初始化属性
self.name = name
def speak(self):
print(‘大家好我是%s’%self.name)
p1 = Person()
返回值：init方法执行了
class Person():
def init(self,name):
self.name = name
def speak(self):
print(‘大家好我是%s’%self.name)
print(‘person代码块中的代码’)
p1 = Person(‘葫芦娃’)
print(p1.name)
p1.speak()
返回值：
person代码块中的代码
葫芦娃
大家好我是葫芦娃
定义一个表示车的类(car)
车的属性：name,color
车的方法：run(),laba()
class car():
def init(self,name,color):
self.name = name
self.color = color
def run(self):
print(‘汽车开始跑了’)
def laba(self):
print(’%s汽车鸣笛’%self.name)
目前我们是可以通过 对象.属性 的方法修改属性的值，这种方式就可以导致对象中的属性可以随意修改
c = car(‘大奔’,‘白色’)
c.name = ‘丰田’
print(c.name,c.color)
c.run()
c.laba()
返回值：
丰田 白色
汽车开始跑了
丰田 汽车鸣笛
我们想要增加数据的安全性那么我们要做到两点
1）属性不能随意修改
2）属性不能改为任意值
2、封装
封装是面向对象的三大特征之一
封装是指隐藏对象中不希望被外部访问到的属性和方法
如何隐藏对象中的属性
将对象的属性名修改成外部不知道的名字
如何获取（修改）对象当中的属性
需要提供getter和setter方法使外部可以访问到属性
封装
class dog():
def init(self,name,age):
self.hidden_name = name
self.hidden_age = age
def speak(self):
print(‘大家好，我是%s，我今年%s岁了’%(self.hidden_name,self.hidden_age))
get_name(self) 获取对象中指定的属性（get_属性名）
def get_name(self):
#get_name(self)用来获取对象的name属性
return self.hidden_name
set_name(self,name) 用来设置对象中指定的属性值（set_属性名）
def set_name(self,name):
self.hidden_name = name
def get_age(self):
return self.hidden_age
#对岁数进行判断只有大于0才是合法数据
def set_age(self,age):
if age > 0:
self.hidden_age = age
d = dog(‘二哈’,5)
#print(d.get_name())
d.set_name(‘德牧’)
d.set_age(-4)
print(d.get_age())
d.speak()
使用封装确实增加了类定义的复杂程度，但是它也确保了我们数据的安全性
1）隐藏了属性名，使用者无法随意的修改对象的属性
2）增加了getter和setter方法之后，很好的控制了属性是否是只读的
如果你希望属性是只读的，则可以直接去掉setter方法
如果希望属性不能被外部访问，则可以去掉getter方法
3）使用setter方法设置属性，可以增加数据的验证
4）使用getter方法获取属性，使用setter方法设置属性
我们可以在读取属性和修改属性的时候
5)setter 和 getter方法也可以表示一些计算的属性
3、练习
练习一
class Rect():
def init(self,width,height):
self.hidden_width = width
self.hidden_height = height
def get_width(self):
return self.hidden_width
def get_height(self):
return self.hidden_height
def set_width(self,width):
self.hidden_width = width
def set_height(self,height):
self.hidden_height = height
def get_area(self):
return self.hidden_width * self.hidden_height
r = Rect(2,3)
print(r.get_area())
返回值：6
r.set_width(5)
r.set_height(10)
print(r.get_area())
返回值：50
练习二
如果我希望封装的更加彻底，外部访问不到
我们可以为对象使用双下划线 __***
__双下划线开头的属性 是对象的隐藏属性，隐藏属性只能在类的内部访问，无法通过对象来访问
__name -> _Person__name 实际上将名字改为 类名__属性名
一般我们会将一些私有属性（不希望外部访问的属性）以**开头
class Person():
def init(self,name):
self._name = name
def get_name(self):
return self._name
def set_name(self,name):
self._name = name
p = Person(‘葫芦娃’)
####p = Person(‘钢铁侠’)
##p._Person__name = ‘蜘蛛侠’
print(p._name)
4、property()装饰器，
#property()用来将get方法转换为一个属性
class Person():
def init(self,name):
self._name = name
@property
def name(self):
print(‘get方法执行了’)
return self._name
#设置setter方法的装饰器 @属性名.setter
@name.setter
def name(self,name):
print(‘set方法执行了’)
self._name = name
p = Person(‘葫芦娃’)
print(p.name)
返回值：
get方法执行了
葫芦娃
p = Person(‘葫芦娃’)
p.name = ‘钢铁侠’
print(p.name)
返回值：
set方法执行了
get方法执行了
钢铁侠
#@property、@name_setter的设置，使得通过属性可以方便的访问getter和setter方法
