python中级11面向对象中

1 特殊方法

●在类中可以定义一些特殊方法也称为魔术方法
●特殊方法都是形如__xxx__( )这种形式（注意是两个_ 下划线）
●特殊方法不需要我们调用，特殊方方法会在特定时候自动调用

问题:#目前来说对于我们的程序name是必须的，并且name又是不同的，
#手动添加name属性 容易遗忘 然后就报错class Person():# name='葫芦娃' 因为实例的属性时不同的 我们不能把属性定义在类中def speak(self):print('大家好呀,我是%s'%self.name)p1=Person()
#手动添加属性值
p1.name='钢铁侠'
p2=Person()
p1.name='绿巨人'
p3=Person()
p3.speak()  #得手动添加name属性 容易遗忘 然后就报错AttributeError: 'Person' object has no attribute 'name'
# AttributeError:“Person”对象没有属性“name”

如何解决以上（不用手动一个一个添加属性要求每个实例的属性不同）的问题就要用到 特殊方法

class Person():#在类中可以可以定义一些特殊方法#特殊方法都是形如__开头__(  )这种形式#特殊方法不需要我们自己调用  特殊方方法会在特定时候自动调用def __init__(self):passdef speak(self):print('大家好呀,我是%s'%self.name)p1=Person()
p1.__init__()#当然很明显什么效果都没有

我们在def __init __(self): 语句中加入print(‘hello’)
__init __()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法

class Person():#在类中可以可以定义一些特殊方法#特殊方法都是形如__开头__(  )这种形式#特殊方法不需要我们自己调用  特殊方方法会在特定时候自动调用def __init__(self):print('hello')def speak(self):print('大家好呀,我是%s'%self.name)p1=Person()
p1.__init__()     #我们调用了__init__()了一次 控制台却打印了两次结果hello
hello

class Person():def __init__(self):print('hello')def speak(self):print('大家好呀,我是%s'%self.name)p1=Person()
# p1.__init__()hello    #特殊方法不需要我们自己调用  特殊方方法会在特定时候自动调用

class Person():# 在类中可以可以定义一些特殊方法# 特殊方法都是形如__开头__(  )这种形式# 特殊方法不需要我们自己调用  特殊方方法会在特定时候自动调用def __init__(self):print('hello')def speak(self):print('大家好呀,我是%s'%self.name)p1=Person()
p2=Person()
p3=Person()
p4=Person()hello
hello
hello       #说明我们只要创建一个对象 他就会调用一次__init__  方法
hello

上面说明我们只要创建一个对象他就会调用一次__init__ 方法

init 方法

我们只要创建一个对象他就会调用一次__init__ 方法

例1

class Person():print('类中的代码....')# 在类中可以可以定义一些特殊方法# 特殊方法都是形如__开头__(  )这种形式# 特殊方法不需要我们自己调用  特殊方方法会在特定时候自动调用def __init__(self):print('hello')def speak(self):print('大家好呀,我是%s'%self.name)p1=Person()
p2=Person()
p3=Person()
p4=Person()类中的代码....
hello
hello
hello
hello

例2

class Person():# 在类中可以可以定义一些特殊方法# 特殊方法都是形如__开头__(  )这种形式# 特殊方法不需要我们自己调用  特殊方方法会在特定时候自动调用def __init__(self):print('hello')print('类中的代码....')def speak(self):print('大家好呀,我是%s'%self.name)p1=Person()
p2=Person()
p3=Person()
p4=Person()类中的代码....
hello
hello
hello
hello

由上两例我们可以发现是 pycharm 先执行类中的代码再执行__init__ 方法中的代码块

class Person():# 在类中可以可以定义一些特殊方法# 特殊方法都是形如__开头__(  )这种形式# 特殊方法不需要我们自己调用  特殊方方法会在特定时候自动调用def __init__(self):print(self)def speak(self):print('大家好呀,我是%s'%self.name)p1=Person()
p2=Person()
p3=Person()
p4=Person()<__main__.Person object at 0x00000000020A3520>
<__main__.Person object at 0x00000000020B5A00>
<__main__.Person object at 0x0000000002086730>
<__main__.Person object at 0x0000000002086190>
# 打印了4个对象

那么__init__能解决最上面我们的问题吗

class Person():# 在类中可以可以定义一些特殊方法# 特殊方法都是形如__开头__(  )这种形式# 特殊方法不需要我们自己调用  特殊方方法会在特定时候自动调用def __init__(self):self.name='葫芦娃'def speak(self):print('大家好呀,我是%s'%self.name)p1=Person()
p2=Person()
p3=Person()
p1.speak()  # 若换成p1.speak() 结果还是不会变的大家好呀,我是葫芦娃

关键例

class Person():# 在类中可以可以定义一些特殊方法# 特殊方法都是形如__开头__(  )这种形式# 特殊方法不需要我们自己调用  特殊方方法会在特定时候自动调用def __init__(self,name):self.name='name'        #此处关键def speak(self):print('大家好呀,我是%s'%self.name)p1=Person()
p2=Person()
p3=Person()
p2.speak()TypeError: __init__() missing 1 required positional argument: 'name'#TypeError:“name”缺少1个必需的位置参数

class Person():# 在类中可以可以定义一些特殊方法# 特殊方法都是形如__开头__(  )这种形式# 特殊方法不需要我们自己调用  特殊方方法会在特定时候自动调用def __init__(self,name):self.name=namedef speak(self):print('大家好呀,我是%s'%self.name)p1=Person()
p2=Person('绿巨人')
p3=Person()
p2.speak()TypeError: __init__() missing 1 required positional argument: 'name'#我们把未传参的实例注释一下

我们把未传参的实例注释一下

class Person():# 在类中可以可以定义一些特殊方法# 特殊方法都是形如__开头__(  )这种形式# 特殊方法不需要我们自己调用  特殊方方法会在特定时候自动调用def __init__(self,name):self.name=namedef speak(self):print('大家好呀,我是%s'%self.name)# p1=Person()
p2=Person('绿巨人')
# p3=Person()
p2.speak()大家好呀,我是绿巨人

class Person():# 在类中可以可以定义一些特殊方法# 特殊方法都是形如__开头__(  )这种形式# 特殊方法不需要我们自己调用  特殊方方法会在特定时候自动调用def __init__(self,name):self.name=namedef speak(self):print('大家好呀,我是%s'%self.name)p1=Person('钢铁聚龙')
p2=Person('绿巨人')
# p3=Person()
p1.speak()大家好呀,我是钢铁聚龙

这样就很好的就解决了问题
#类的基本结构 (当然父类还没没有讲到)
‘’’
class 类名([父类]):

公共属性...
#对象的初始化方法
def__init__(self,....)pass#其他的方法
def method1(self):pass
def method2(self):pass...

‘’’

2 封装的引入及封装

●出现封装的原因：我们需要一种方式来增强数据的安全性
–1. 属性不能随意修改
–2. 属性不能改为任意的值
●封装是面向对象的三大特性之一
●封装是指隐藏对象中一些不希望被外部所访问到的属性或方法
●我们也可以提供给一个getter()和setter()方法是外部可以访问到属性
—getter() 获取对象中指定的属性
—setter() 用来设置对象指定的属性
●使用封装，确实增加了类的定义的复杂程度，但是它也确保了数据的安全
–1. 隐藏属性名，使调用者无法随意的修改对象中的属性
–2. 增加了getter()和setter()方法，很好控制属性是否是只读的
–3. 使用setter()设置属性，可以增加数据的验证，确保数据是正确的
–4. 使用getter()方法获取属性，使用setter()方法设置属性可以在读取属
性和修改属性的同时做一些其他的处理
●可以为对象的属性使用双下划线开头 __xxx。双下划线开头的属性，是对象的隐藏属性，隐藏属性只能在类的内部访问，无法通过对象访问
●其实隐藏属性只不过是Python自动为属性改了一个名字 --> _类名__属性
名例如 __name -> _Person__name
●这种方式实际上依然可以在外部访问，所以这种方式我们一般不用。一般我们会将一些私有属性以_开头
●一般情况下,使用_开头的属性都是私有属性，没有特殊情况下不要修改私有属性


# 尝试定义一个车类'''
属性: name color
方法: run() 喇叭()'''
class car():def __init__(self,name,color):self.color=colorself.name=namedef speak(self):print('我是',self.name,'之车，我的颜色是',self.color)def run(self):print('汽车开始跑了.....')def laba(self):print(self.color,self.name,'滴嘟滴嘟滴嘟滴嘟滴嘟滴嘟滴嘟滴嘟')c1=car('奔驰','黑色')
c1.speak()
c1.laba()我是 奔驰 之车，我的颜色是 黑色
黑色 奔驰 滴嘟滴嘟滴嘟滴嘟滴嘟滴嘟滴嘟滴嘟

class car():def __init__(self,name,color):self.color=colorself.name=namedef speak(self):print('我是',self.name,'之车，我的颜色是',self.color)def run(self):print('汽车开始跑了.....')def laba(self):print(self.color,self.name,'滴嘟滴嘟')c1=car('奔驰','黑色')
# c1.speak()
# c1.laba()
c1.name='大狼狗'
c1.laba()黑色 大狼狗 滴嘟滴嘟  #这个黑色的狼狗叫的好像有点另类

意思是目前我们可以通过对象.属性的方式来修改属性的值
这就导致我们对象的属性不是特别安全

● 现在我们需要一种方式来增强数据的安全性封装
—1 属性不能随意修改(我让你改你才可以改)
—2 属性不能改为任意的值

class Dog:def __init__(self,name):self.name=named1=Dog('秋田犬')d1.name='大柴狗'  print(d1.name)大柴狗

–封装是面向对象的三大特征之一
–封装就是指隐藏对象汇总的一些不希望被外部访问属性或方法
–将对象属性名修改为一个外部不知道的名字 hidden_name

# 封装 是面向对象的三大特征之一
# 封装就是指隐藏对象汇总的一些不希望被外部访问属性或方法
# 将对象属性名 修改为一个外部不知道的名字  hidden_name
class Dog:def __init__(self,name):self.hidden_name=namedef speak(self):print('大家好我是%s!!'%self.hidden_name)d1=Dog('大狼狗')d1.name='大柴狗'  # 因为我们的内部是hidden_named1.speak()大家好我是大狼狗!!

class Dog:def __init__(self,name):self.hidden_name=namedef speak(self):print('大家好我是%s!!'%self.hidden_name)d1=Dog('大狼狗')d1.hidd_name='大柴狗'd1.speak()大家好我是大柴狗!!

class Dog:def __init__(self,name):self.hidd_name=namedef speak(self):print('大家好我是%s!!'%self.hidd_name)# get_name() 用来获取对象的name的属性值def get_name(self):return self.hidd_named1=Dog('大狼狗')# d1.hidd_name='大柴狗'
#
# d1.speak()print(d1.get_name())大狼狗

class Dog:def __init__(self,name):self.hidd_name=namedef speak(self):print('大家好我是%s!!'%self.hidd_name)# get_name() 用来获取对象的name的属性值def get_name(self):return self.hidd_name# set_name() 用来修改对象的属性值def set_name(self,name):self.hidd_name=named1=Dog('大狼狗')# d1.hidd_name='大柴狗'
#
# d1.speak()print(d1.get_name())
d1.set_name('局黑背')
print(d1.get_name())大狼狗
局黑背

class Dog:def __init__(self,name):self.hidd_name=namedef speak(self):print('大家好我是%s!!'%self.hidd_name)# get_name() 用来获取对象的name的属性值(关键是return)def get_name(self):return self.hidd_name# set_name() 用来修改对象的属性值 (修改的关键是=)def set_name(self,name):self.hidd_name=named1=Dog('大狼狗')# d1.hidd_name='大柴狗'
#
# d1.speak()print(d1.get_name())
d1.set_name('局黑背')
print(d1.get_name())d1.speak()
大狼狗
局黑背
大家好我是局黑背!!

●使用封装，确实增加了类的定义的复杂程度，但是它也确保了数据的安全
–1. 隐藏属性名，使调用者无法随意的修改对象中的属性
–2. 增加了getter()和setter()方法，很好控制属性是否是只读的
–3. 使用setter()设置属性，可以增加数据的验证，确保数据是正确的
–4. 使用getter()方法获取属性，使用setter()方法设置属性可以在读取属
性和修改属性的同时做一些其他的处理

class Dog:def __init__(self,name,age):self.hidden_name=nameself.hidden_age=agedef speak(self):print('大家好我是%s!!'%self.hidden_name)# get_name() 用来获取对象的name的属性值 (关键是return)def get_name(self):return self.hidden_name# set_name() 用来修改对象的属性值 (修改的关键是=)def set_name(self,name):self.hidden_name=namedef get_age(self):return self.hidden_agedef set_age(self,age):self.hidden_age=aged1=Dog('大狼狗',5)
print(d1.get_age())5

class Dog:def __init__(self,name,age):self.hidden_name=nameself.hidden_age=agedef speak(self):print('大家好我是%s!!'%self.hidden_name)# get_name() 用来获取对象的name的属性值 (关键是return)def get_name(self):return self.hidden_name# set_name() 用来修改对象的属性值 (修改的关键是=)def set_name(self,name):self.hidden_name=namedef get_age(self):return self.hidden_agedef set_age(self,age):self.hidden_age=aged1=Dog('大狼狗',5)d1.set_age(-8)
print(d1.get_age())-8

这个年龄就不合法所以我们可以加上条件语句if age>0:

class Dog:def __init__(self,name,age):self.hidden_name=nameself.hidden_age=agedef speak(self):print('大家好我是%s!!'%self.hidden_name)# get_name() 用来获取对象的name的属性值 (关键是return)def get_name(self):return self.hidden_name# set_name() 用来修改对象的属性值 (修改的关键是=)def set_name(self,name):self.hidden_name=namedef get_age(self):return self.hidden_agedef set_age(self,age):if age>0:self.hidden_age=aged1=Dog('大狼狗',5)d1.set_age(-8)
print(d1.get_age())5

这样上面的操作就解释了–3. 使用setter()设置属性，可以增加数据的验证，确保数据是正确的

class Dog:def __init__(self,name,age):self.hidden_name=nameself.hidden_age=agedef speak(self):print('大家好我是%s!!'%self.hidden_name)# get_name() 用来获取对象的name的属性值 (关键是return)def get_name(self):return self.hidden_name# set_name() 用来修改对象的属性值 (修改的关键是=)def set_name(self,name):self.hidden_name=namedef get_age(self):print('用户读取了属性...')return self.hidden_agedef set_age(self,age):print('用户修改了属性...')if age>0:self.hidden_age=aged1=Dog('大狼狗',5)d1.set_age(8)
print(d1.get_age())用户修改了属性...
用户读取了属性...
8

当然这个仅仅是print 逻辑比较简单比如说打开一个网页用户打开一次我们就会记录一次这样我们就会获得一些用户的相应的一些习惯上的数据就比如淘宝的猜你喜欢
你会发现里面的东西都和你喜欢的差不多原因就是有可能你点击了某些地方它在方法里设置了获取用户的习惯行为动作
上面的就是第4点使用getter()方法获取属性，使用setter()方法设置属性可以在读取属性和修改属性的同时做一些其他的处理

封装二

隐藏属性就是一种伪封装
只不过就是在你想修改时设置了障碍


class Person:def __init__(self,name):self.hidden_name=namedef get_name(self):return self.hidden_namedef set_name(self,name):self.hidden_name=nameP=Person('葫芦娃')
P.set_name('航巨人')
print(P.get_name())航巨人

还可以这么改
当然这种方法不推荐因为这样方法set_name( )不就白写了

class Person:def __init__(self,name):self.hidden_name=namedef get_name(self):return self.hidden_namedef set_name(self,name):self.hidden_name=nameP=Person('葫芦娃')
# P.set_name('航巨人')
P.hidden_name='超人'
print(P.get_name())超人

我们再改改.

class Person:# 可以为对象 的属性使用双下划线__的方式来封装 __xxxdef __init__(self,name):# self.hidden_name=nameself.__name=namedef get__name(self):return self.__namedef set_name(self,name):self.__name=nameP=Person('葫芦娃')
# P.set_name('航巨人')
# P.hidden_name='超人'
print(P.get__name())葫芦娃

试试 print(P.__name)这个方式

class Person:# 可以为对象 的属性使用双下划线__的方式来封装 __xxxdef __init__(self,name):# self.hidden_name=nameself.__name=namedef get__name(self):return self.__namedef set_name(self,name):self.__name=nameP=Person('葫芦娃')
# P.set_name('航巨人')
# P.hidden_name='超人'
# print(P.get__name())
print(P.__name)AttributeError: 'Person' object has no attribute '__name'
# AttributeError:“Person”对象没有属性“\u name”

这样也是不行的

class Person:# 可以为对象 的属性使用双下划线__的方式来封装 __xxxdef __init__(self,name):# self.hidden_name=nameself.__name=namedef get__name(self):return self.__namedef set_name(self,name):self.__name=nameP=Person('葫芦娃')
# P.set_name('航巨人')
P.hidden_name='超人'
# print(P.get__name())
P.__name='asojid'
print(P.get__name())葫芦娃

为什么呢
#可以为对象的属性使用双下划线__的方式来封装 __xxx
#双下划线的属性是对象的隐藏属性，隐藏属性只能在类的内部访问无法通过对象访问
#隐藏属性只不过是python 自动给属性起了另外一个名字
#这个名字叫做_类名__属性名，
也就是把 __name—>_Person__name
#使用__开头方式的属性，实际上我们依然是可以在外部访问的所以这种方式一般不用
#一般我们对属性进行封装都是以_开头的方式

class Person:#可以为对象 的属性使用双下划线__的方式来封装 __xxx#双下划线的属性是对象的隐藏属性，隐藏属性只能在类的内部访问 无法通过对象访问#隐藏属性只不过是python 自动给属性起了另外一个名字#这个名字叫做_类名__属性名    __name--->_Person__namedef __init__(self,name):# self.hidden_name=nameself.__name=namedef get__name(self):return self.__namedef set_name(self,name):self.__name=nameP=Person('葫芦娃')
# P.set_name('航巨人')
# P.hidden_name='超人'
# print(P.get__name())
# P.__name='asojid'
# print(P.get__name())print(P._Person__name)
P._Person__name='asojid'
print(P._Person__name)
print(P.get__name())葫芦娃
asojid
asojid

隐藏属性就是一种伪封装
只不过就是在你想修改时设置了障碍

所以一般呢我们是这样写的

class Person:#可以为对象 的属性使用双下划线__的方式来封装 __xxx#双下划线的属性是对象的隐藏属性，隐藏属性只能在类的内部访问 无法通过对象访问#隐藏属性只不过是python 自动给属性起了另外一个名字#这个名字叫做_类名__属性名    __name--->_Person__name#使用__开头方式的属性，实际上我们依然是可以在外部访问的 所以这种方式一般不用#一般我们对属性进行封装 都是以_开头的方式def __init__(self,name):# self.hidden_name=nameself._name=namedef get_name(self):return self._namedef set_name(self,name):self._name=nameP=Person('葫芦娃')
# P.set_name('航巨人')
# P.hidden_name='超人'
# print(P.get__name())
# P.__name='asojid'
# print(P.get__name())# print(P._Person__name)
# P._Person__name='asojid'
# print(P._Person__name)
# print(P.get__name())
print(P._name)
print(P.get_name())葫芦娃
葫芦娃

这种写法的好处是
1 一个下划线要比两个下划线书写
2 也是一种封装的方式
3 我们希望你修改不了属性

3 property装饰器

我们可以使用@property装饰器来创建只读属性，@property装饰器会将方
法转换为相同名称的只读属性,可以与所定义的属性配合使用，这样可以防止
属性被修改

class Person():def __init__(self,name):self._name=name# getter方法def name(self):print('get方法执行了...')return self._nameP=Person('葫芦娃娃')
print(P.name())get方法执行了...
葫芦娃娃

class Person():def __init__(self,name):self._name=name# getter方法def name(self):print('get方法执行了...')return self._nameP=Person('葫芦娃娃')
P._name='dsa'
print(P.name()) #get方法执行了...
dsa

当然通过 P.name( )获得 dsa 会是有点怪怪的

class Person():def __init__(self,name):self._name=name# getter方法@propertydef name(self):print('get方法执行了...')return self._nameP=Person('葫芦娃娃')
P._name='dsa'
print(P.name())TypeError: 'str' object is not callable
#TypeError:“str”对象不可调用

class Person():def __init__(self,name):self._name=name# getter方法@propertydef name(self):print('get方法执行了...')return self._nameP=Person('葫芦娃娃')print(P.name)  #这样写看似你P.name 是一个属性  其实你调用的是一个方法 这样写就好多了#因为你想要一个值 或者变量   调用方法 会有点怪  我们使用P.方法或变量  # 比如在name前加上@property就很好解决了  这样方便你看 但是你自己知道其实#是调用了一个方法  这个方法前加有@propertyget方法执行了...
葫芦娃娃

也就是
我们可以使用@property装饰器来创建只读属性，@property装饰器会将方
法转换为相同名称的只读属性,可以与所定义的属性配合使用，这样可以防止
属性被修改

class Person():def __init__(self,name):self._name=name# getter方法@propertydef name(self):print('get方法执行了...')return self._nameP=Person('葫芦娃娃')
P.name='蝙蝠侠'  #加了@property 装饰器这样也能修改 当然修改属性 还是建议用下面@name.setter 的方法
print(P.name)

我们再试试setter 方法

#
class Person():def __init__(self,name):self._name=name# getter方法@propertydef name(self):print('get方法执行了...')return self._name# setter方法@name.setterdef name(self, name):self._name = nameP = Person('葫芦娃娃')
P.name = '蝙蝠侠'
print(P.name)get方法执行了...
蝙蝠侠

class Person():def __init__(self,name):self._name=name# getter方法@propertydef name(self):print('get方法执行了...')return self._name# setter方法
#     @name.setterdef name(self, name):self._name = nameP = Person('葫芦娃娃')
P.name = '蝙蝠侠'   # 当然此时的P.name = '蝙蝠侠' 也就单纯的是一个赋值 跟我们的程序毫无关系
print(P.name)蝙蝠侠

当然上面的setter 和 geteer 的方法名字是一样的我们应该这么写

class Person():def __init__(self,name):self._name=name# getter方法@propertydef get_name(self):print('get方法执行了...')return self._name# setter方法@get_name.setterdef set_name(self, name):self._name = namep=Person('葫a娃')
p.set_name = 's侠'
print(p.get_name)get方法执行了...
s侠

复习环节