Python基础学习(13)—面向对象2(特殊方法，分装及装饰器)

面向对象(2)

1.1 特殊方法(魔术方法)

1 特殊方法例如__init__的都是以__开头__结尾的方法，

特殊方法会在特定的时候自动调用，init会在对象创建以后立即执行并且init会对新创建的对象初始化属性

2 ** self**
对于类中的方法来说，self 参数（第一个参数）代表该构造方法正在初始化的对象，换句话说，Python 会自动绑定类方法的第一个参数指向调用该方法的对象，且self参数是默认的。

打个比方，类就是一张汽车的图纸，创建的实例都是真正的汽车，一个图纸我们可以设计出成千上万个车，他们主人各不相同，self就是每个车的钥匙，他可以保证每个主人仅仅进入自己的车

3 学习特殊方法
1.特殊方法什么时候调用
2.特殊方法有什么作用
对于上节Person这个类name属性是必须，并且每一个实例对象的name属性是不一样的而且我们现在是将name属性手动添加，特别容易出错，使用了特殊方法可以避免这些问题

4 对象的创建流程
1.创建了一个变量
2.在内存中创建了一个新的对象
3.创建完对象后就会执行类中的代码块中的代码(只在类中执行一次)，__init__方法随即执行

5
例一：
__init__没有其他参数时

class Game:

    print('我要玩游戏')
    
    def __init__(self):

        # 通过self向新建的对象初始化属性
        print("开始了一局吃鸡")

        self.name = 'AWM'

    def give(self):

        print("给你个%s吧"%self.name)

    def obtain(self):

        print("不行，我要那个%s"%self.name)

p1 = Game() # 创建实例p1
print(p1.name) ##初始化对象pl的name属性的结果

p1.give() # 初始化的结果self.name为AWM

p1.name = 'AK' # 修改了p1属性中的name,然后传给obtain()方法的参数
p1.obtain() 

运行结果

我要玩游戏 # 创建完实例后执行了第一句语句

开始了一局吃鸡 # __init__函数随即执行
给你个AWM吧

AWM ##初始化的结果p1内self.name为AWM
不行，我要那个AK

例二：
__inti__带有参数时

class Game:
   print('我要玩游戏')

   def __init__(self,name):
     
       # 通过self向新建的对象初始化属性
       print("开始了一局吃鸡")

       self.name = name

   def give(self):
       print("给你个%s吧" % self.name)

   def obtain(self):
       print("不行，我要那个%s" % self.name)

#p1 = Game() 
#创建实例p1时self有参数，所以创建p1的时候要初始化参数name的值,否则会报错

p1 = Game('98k')  # 创建实例p1，初始化的结果p1内name的属性
print(p1.name)

p1.give()  # 将p1初始化的属性结果self.name传给give()方法

p1.name = 'AK'
#将p1修改后的属性结果name传给obtain()方法

p1.obtain()

运行结果

我要玩游戏

开始了一局吃鸡
98k  # 初始化p1中name属性为98k

给你个98k吧
不行，我要那个AK

总结：__init__方法有无参数的区别在于创建实例时需不需要传参，
共同点为第一个self参数不需要传实参，修改属性的格式都为 实例.属性名 = ，其他方法都有一个默认的self参数

类的基本结构
class 类名([父类]):
公共属性…
对象的初始化方法
def init(self,…)
…
其他的方法
def method(self,…)
…

1.2 封装

1 作用：
我们要增加数据的安全性
1.属性不能随意修改(我让你改你才能改，不让你改你就别改)
2.属性不能改为任意的值

2 封装
封装是面向对象的三大特性之一
封装指的是隐藏对象中一些不希望被外部访问到的属性或方法
实际上就是将属性的名字修改成就自己知道的，防止别人随意修改。

3 其实封装就两方面含义：把该隐藏的隐藏，该暴露的暴露出来

4.使用setter方法设置属性，可以增加数据的验证，确保数据的值是正确的

class Game:


    def __init__(self,name,beijin):


        self.hidden_name = name

        self.hidden_beijin = beijin


    def get_name(self):
        
        # 用于获取hidde_name属性
        return self.hidden_name

    def set_name(self,name):
		
	    # 用于修改hidde_name属性
        self.hidden_name = name

    def get_beijin(self):
		
		# 用于获取hidde_beijin属性
        return self.hidden_beijin

    def set_beijin(self,beijin):
		
		# 用于获取hidden_beijin属性
        if beijin >1: # 符合>1的条件才可以修改成功，数据的验证，确保数据的值是正确的

            self.hidden_beijin = beijin

    def give(self):

        print("给你个{0}倍{1}吧".format(self.hidden_beijin, self.hidden_name))

    def obtain(self):

        print(f"不行，我要那个{self.hidden_beijin}倍{self.hidden_name}")

# p1 = Game()
# 创建实例p1时self有参数，所以创建p1的时候要初始化参数name的值,否则会报错
p1 = Game('98k',2)  # 创建实例p1，初始化的结果p1内self.name为98k

p1.give()

print(p1.get_name(),p1.get_beijin())

p1.name  = 'M416' # 通过p1.name不能修改，实际上是给对象p1添加了name这个属性

p1.hidden_beijin = 6
p1.hidden_name = 'M416'
# 实际上我们是知道属性的名字叫什么才可以修改的，其他人不知道，修改也是徒劳
p1.obtain()

p1.set_name('AWM') #将p1的hidden_name属性修改为AWM

p1.set_beijin(-1) # 将p1的 didden_beijin属性改为-1
print(p1.get_beijin())

p1.set_beijin(8) # 将p1的 didden_beijin属性改为8
p1.give()

运行结果

给你个2倍98k吧
98k 2

不行，我要那个6倍M416

6 # 修改失败
给你个8倍AWM吧

3 我们一直在用“类对象.属性”的方式访问类中定义的属性，其实这种做法是欠妥的，因为它破坏了类的封装原则。换句话说，正常情况下的类，它包含的属性应该是隐藏的，只允许通过类提供的方法来间接实现对类属性的访问和操作。

因此，在不破坏类封装原则的基础上，为了能够有效操作类中的属性，类中应包含读（或写）类属性的多个 getter（或 setter）方法，这样就可以通过“类对象.方法(参数)”的方式操作属性，使用封装，确实增长了类定义复杂度，但是它确保了数据的安全性
如果希望属性是只读的，则可以直接去掉setter方法
如果希望属性不能被外界访问，则可以 直接渠道getter方法

4.使用setter方法设置属性，可以增加数据的验证，确保数据的值是正确的

1.3 封装的常用方法

可以为对象的属性使用双下划线开头,__xxx
双下划线开头的属性是对象的隐藏属性，隐藏属性只能在类的内部访问，无法通过外部访问
隐藏属性是python自动为属性改了一个名字
实际改的名字是: _类名_属性名 __name -> _Person__name，就像上一个hidden_name等

class Game:


    def __init__(self,name,beijin):


        self.__name = name

        self.__beijin = beijin


    def get_name(self):

        return self.__name

    def set_name(self,name):

        self.__name = name

    def get_beijin(self):

        return self.__beijin

    def set_beijin(self,beijin):

        if beijin >1:

            self.__beijin = beijin

    def give(self):

        print('我给你个{0}倍{1}'.format(self.__beijin,self.__name))

    def obtain(self):

        print(f"不行，我要那个{self.__beijin}倍{self.__name}")


p1 = Game('98k',2)  # 创建实例p1，初始化的结果p1内self.name为98k

p1.give()

p1._Game__name = 'QBZ'
p1._Game__beijin = "3" 

# print(p1.__name,p1.__beijin) # 因为p1对象里__name,__beijin真正的名字不是这个,所以打印时报错

p1.obtain()

运行结果

我给你个2倍98k
不行，我要那个3倍QBZ

1.4 @property

1 用来将一个get方法 转换为对象的属性
添加property装饰器以后，我们就可以像调用属性一样调用方法
2 用法：把get方法变为属性只需要加上@property装饰器即可
此时@property本身又会创建另外一个装饰器@score.setter,负责把set方法变成给属性赋值,这么做完后,我们调用起来既可控又方便

class Deal:

    def __init__(self,name):

        self._name = name

    @property
    def name(self):
        print('妈妈，我想吃',self._name)
        return self._name

p1 = Deal('烤山药')
p1.name # 我们就可以像调用name属性一样调用方法name
p1.name = ‘大嘴巴子’ # AttributeError: can't set attribute，修改会报错

运行结果
要是想修改name,调用@name.setter，修改的同时运行了name方法
,也可使用像调用属性一样调用方法

class Deal:

    def __init__(self,name):

        self._name = name

    @property
    def name(self):
        print('妈妈，我想吃',self._name)
        return self._name
    @name.setter
    def name(self,name):

        self._name = name
p1 = Deal('烤山药')
p1.name
p1.name = '大嘴巴子' # 修改的同时运行了name方法
print(p1.name)

运行结果

妈妈，我想吃 烤山药
妈妈，我想吃 大嘴巴子
大嘴巴子

要是想修改name,没有调用@name.setter，也可以修改，不能在修改的同时运行name方法,不能像调用属性一样调用方法,也不能调用方法

class Deal:

    def __init__(self,name):

        self._name = name

    @property
    def name(self):
        print('妈妈，我想吃',self._name)
        return self._name
    # @name.setter
    def name(self,name):

        self._name = name
p1 = Deal('烤山药')
p1.name
p1.name = '大嘴巴子' # 也可以修改
p1.name

运行结果

大嘴巴子