目录
前言：
前面我们学了Python中的属性和方法的定义，但是这些属性和方法都是公有的，也就是说我定义单个或者多个实例对象，这些实例对象都共有这个类的属性和方法，同时还可以去访问这些属性和方法。（上一期链接Python进阶-----面向对象1.0（对象和类的介绍、定义）_Python欧尼酱的博客-CSDN博客）下面给个例子：
class People:
ty='人类'
def __init__(self,name,age,gander):
self.name=name
self.age=age
self.gander=gander
def fun(self):
print('电话号码****')
print(f'我的年龄{self.age}')
a=People('Jack',15,'male')
print(a.ty)
print(a.name,a.age,a.gander)
a.fun()
#输出结果：人类
# Jack 15 male
# 电话号码****
# 我的年龄15这里可以看出，这个实例对象的所有属性和方法都可以被访问到，这个类的属性和方法都是公开的，并不是特有的。
1.添加特有属性/方法
当我们建立了一个实例化对象之后，我们可以去手动添加在对象的属性和方法，这个添加之后的方法或者属性都是这个对象特有的，如果我们去建立另外一个对象，这个对象是不能访问上一个对象的特有属性或者方法。
示例1：添加特有属性
class People:
def __init__(self, name, age, gander):
self.name = name
self.age = age
self.gander = gander
def fun(self):
print('电话号码****')
print(f'我的年龄{self.age}')
a = People('Jack', 15, 'male')
b= People('Amy',16,'fmale')
a.father='Tom'
print(a.__dict__)
print(b.__dict__)
print(b.father)#报错:'People' object has no attribute 'father'
#输出结果：{'name': 'Jack', 'age': 15, 'gander': 'male', 'father': 'Tom'}
# {'name': 'Amy', 'age': 16, 'gander': 'fmale'}这里可以看到，我给对象a添加了father属性，然后通过__dict__方法去查看这些属性，对比与对象b发现多了一个father属性，那么这个属性就是对象a特有的属性，那么如果我去用对象b查询b.father 那么结果就会报错
示例2：添加特有方法
class People:
def __init__(self, name, age, gander):
self.name = name
self.age = age
self.gander = gander
def fun(self):
print('电话号码****')
print(f'我的年龄{self.age}')
def specific():
print('this is a specific function')
a = People('Jack', 15, 'male')
b= People('Amy',16,'fmale')
b.specific=specific
b.specific()
#a.specific() #报错：'People' object has no attribute 'specific'
#输出结果：this is a specific function
#可以通过以下的方法，查询到对象a和对象b支持的功能和方法，很显然就可以看出specific()方法是谁特有的
# print(dir(b))
# print(dir(a))这里可以看出我给对象b添加了特有的方法specific()，所以对象b是可以去调用这个方法的，而对象a是不可以去调用的，否则就会报错
2.私有属性/方法
所谓的私有，也就是在所有数据中，特别设置了某一些数据不可查询，也就是加密的意思。在现实生活中，相关部门，例如医院，他们获取了我们个人信息，名字，性别，年龄，手机号，身份证号码等等，但是这些部门在一些平台的展示的时候不会吧全部信息给展示出来（例如年龄，身份证号码等等），而是说张某，李某等，这就是一种加密私有的过程。在Python类中把一些属性或者方法给加密（私有）化，让建立的实例对象无法访问这些属性或者方法，这就是一个私有化的过程。
Python中私有化的定义：
实例对象__属性名/方法名
(也就是在属性名字或者方法名字的前面加上两个_（下划线）
作用功能：
前面以医院的例子说了，可以把一些信息加密私有化，起到保护作用，在Python也是一样的，都是起保护作用，不公开一些比较重要的信息
（1）私有化示例
示例1：属性私有化
class People:
def __init__(self, name, age, gander):
self.name = name
self.__age = age #这里把年龄信息给加密私有化
self.gander = gander
def __user_info(self): #这里吧方法给加密私有化
print('电话号码****')
print(f'我的年龄{self.age}')
def fun(self):
print('the user')
user=People('Jack',20,'male')
print(user.name) #输出结果：Jack
print(user.gander) #输出结果：male
print(user.__age) #报错： 'People' object has no attribute '__age'这里我给age进行私有化，但是我输出照样按照__age 去输出，结果报错说这个属性不存在，这也说明这个属性是无法查询的
示例2：方法私有化
class People:
def __init__(self, name, age, gander):
self.name = name
self.__age = age #这里把年龄信息给加密私有化
self.gander = gander
def __user_info(self): #这里吧方法给加密私有化
print('电话号码****')
print(f'我的年龄{self.age}')
def fun(self):
print('the user')
user=People('Jack',20,'male')
user.fun() #输出结果：the user
user.__user_info() #报错：'People' object has no attribute '__user_info'这里可以看出，__user_info() 私有化后是无法调用的，这样写的好处就是到时候我们学到面对对象的封装时，就可以把相关的信息进行私有化封装，避免重要信息泄露，提高保护性
（2） 私有化属性/方法可以在类的内部使用
在定义类的过程中，一些私有化属性或者方法可以在类的内部进行调用，而在外部的实例对象是不可以去访问调用的（例子在上面）。
示例：
class People:
def __init__(self, name, age, gander):
self.name = name
self.__age = age #这里把年龄信息给加密私有化
self.gander = gander
def __user_info(self): #这里吧方法给加密私有化
print('电话号码****')
print(f'我的年龄{self.__age}')
def __fun(self):
print('the user')
def using(self):#在类的内部定义一个方法去调用私有化方法/属性
self.__fun()
self.__user_info()
a=People('John',22,'male') #外部的实例对象是无法调用私有化属性/方法的
a.using()
#输出结果：
# the user
# 电话号码****
# 我的年龄22（3）强制访问私有化属性/方法
私有化了相关属性/方法之后，难道就无法访问了吗？那当然不是了，如果真的无法访问那与其去私有化，那还干脆不如不写，其实Python中是可以通过一些方法去强制访问私有化属性或者方法的。那这样做其实是比较考验程序员的道德水平的哈，一般情况下我们虽然可以通过一些渠道去访问一些信息，但是真的没这个必要，这对其他人不好，所以在以后工作和生活的时候很不建议去强制访问相关重要信息。回归话题，现在是在学习Python嘛，哪有什么重要信息嘛，所以这些方法还是要学习的
通过dir()可以去查询到一个对象可以支持的方法，这里可以看出这里前面两个有_People__的方法，其实我们就可以去通过这个方法来查询使用一些私有化数据或者方法。
格式：
实例对象_类名__属性/方法
实例：
class People:
def __init__(self, name, age, gander):
self.name = name
self.__age = age #这里把年龄信息给加密私有化
self.gander = gander
def __user_info(self): #这里吧方法给加密私有化
print('电话号码****')
print(f'我的年龄{self.__age}')
def fun(self):
print('the user')
user=People('Tom',20,'male')
print(user._People__age) #强制访问属性
user._People__user_info() #强制访问方法
#输出结果：20
# 电话号码****
# 我的年龄20（4）@property装饰器去操作私有属性/方法
@property装饰器可以去实现将一个方法变成属性，这个属性但是又不完全是属性，这个转换之后的属性是具有方法的效果。这样可以提供操作效率，可以让操作者明显感觉得到正在操作的不是一个方法而是一个属性。
用法：
Python中提供了@property 获取方法的返回值属性，@方法名.setter 设置方法返回的属性值，@方法名.deleter 删除方法中的返回值
示例：
class Test:
def __init__(self,score):
self.__score=score
@property #装饰器把下面这个方法转换为一个具有方法效果的属性
def getscore(self): #定义一个方法
if self.__score>=60:
return f'及格，分数为{self.__score}'
return '不及格'
Tom=Test(50)
print(Tom.getscore)这里的初始化score是50分，然后返回的是不及格，但是如果我们想去修改或者删除这个分数的话，我们就要用到@getscore.setter和@getscore.deleter装饰器方法
class Test:
def __init__(self,score):
self.__score=score
@property #装饰器把下面这个方法转换为一个具有方法效果的属性
def getscore(self): #定义一个方法
if self.__score>=60:
return f'及格，分数为{self.__score}'
return '不及格'
@getscore.setter
def setscore(self,newscore):
print('分数已修改')
self.__score=newscore
@getscore.deleter
def delscore(self):
print('分数已删除')
del self.__score
Tom=Test(50)
#触发property装饰器，查询结果
print(Tom.getscore)
#触发setter装饰器
Tom.setscore=66
print(Tom.getscore)
#触发deleter装饰器
del Tom.delscore
print(Tom.getscore) #这里分数已经被删除了就会报错，'Test' object has no attribute '_Test__score'其实@property装饰器的功能还有很多很多，我这里也就是用property装饰器去实现类中的方法转换为具有方法效果的属性功能，其他的我就不多说了，如果想了解更多关于property装饰器的可以去看看这个链接http://t.csdn.cn/4Ey3m
总结：
属性和方法是面向对象重要组成部分，其分为共有、特有、私有。
共有：所有同一个类的实例对象都可以访问
特有：虽然同一个类的实例对象，但是有些属性是某一个实例对象特有的，其他实例对象是无法访问的
私有：私有是在类中定义的，把相关属性/方法设置为不允许访问，同一个类的实例对象都具有它们的私有属性，但是不允许访问
好了，这一期就到这里了，下课！
分享一张壁纸~
