10 面向对象的编程

迷南。 2021-12-01 10:03 241阅读 0赞

本章内容：

1、编写类

2、显示对象

3、灵活的初始化

4、设置函数和获取函数

5、继承

6、多态

7、更深入的学习

\------------------------------------------

本章主要介绍，为什么Python是面向对象的编程语言（OOP）。所以，本章的内容主要围绕面向对象的编程语言的特点展开；

1、编写类

下面，先编写一个表示人的简单类：

# person.py
    class Person:
        """ Class to represent a person
        """
        def __init__(self):
            self.name = ''
            self.age = 0

\_\_init\_\_ 使用来进行数据初始化的标准函数。

![1576057-20190717225341626-1948049511.png][]

在这个函数中，我们只需要调用 Person() 对象，就可以使用 age 和 name 两个变量，但是这两个变量需要以句点表示的方式来指定数据；

另外一个难点就是 self 参数；在定义变量的时候，我们没有指定参数，而是通过 \_\_init\_\_函数调用了self参数，则是 person() 自己调用自己的意思；所以，self是一个指向对象本身的变量；

2、显示对象

方法是类中定义的函数；下面给上面Person类，添加一个方法，用于打印Person对象的内容：

# person.py
    class Person:
        """ Class to represent a person
        """
        def __init__(self0):
            self.name = ''
            self.age = 0
        def display(self):
            print("Person('%s',%d)" % (self.name, self.age))

方法display将person对象的内容适合程序眼阅读的方式打印到屏幕上

![1576057-20190717232849351-594033608.png][]

除了使用 display 的方法外，我们还可以使用其他的方式，来做的更好，让你能够定制对象以支持天衣无缝的打印。例如：特殊方法 \_\_str\_\_ 用于生成对象的字符串表示：

# person.py
    class Person():
        #为了节省篇幅，省略了 __init__
        def dsplay(self):
            print("Person('%s',%d)" % (self.name, self.age))
        def __str__(self):
            return ("Person('%s',%d)" % (self.name, self.age))

运行结果如下：

![1576057-20190717234539578-575139332.png][]

同样，还可以使用str来简化display：

# person.py
    class Person:
        # 为了节省篇幅，省略了 __init__
        def display(self):
            print(str(self))
        def __str__(self):
            return "Person('%s', %d)" % (self.name, self.age)

也可以定义特殊方法 \_\_repr\_\_ ，它返回对象的“官方”表示，例如Person对象的默认官方表示不太实用：

![1576057-20190718095845592-1219407427.png][]

通过添加方法 \_\_repr\_\_，我们可控制这里打印的字符串。在大多数类中，方法 \_\_repr\_\_ 都与方法 \_\_str\_\_ 相同：

# person.py
    class Person:
        # 为节省篇幅，省略了 __init__
        def display(self):
            print(str(self))
        def __str__(self):
            return "Person('%s', %d) % (self.name, self.age)
        def __repr__(self):
            return str(self)

3、灵活的初始化

当前，要创建具有特定姓名和年龄的Person对象，必须这样做：

![1576057-20190718101849658-1797923617.png][]

一种更加方便的方式，在构造对象时，将姓名和年龄传递给\_\_init\_\_。为此，需要重写\_\_init\_\_。

# person.py
    class Person:
        def __init__(self, name= '', age = 0):
            self.name = name
            self.age = age

这样的话，初始化Person对象将简单的多；

由于\_\_init\_\_的参数有默认值，你甚至可以创建“空的”Person对象：

![1576057-20190718230625424-820173571.png][]

注意方法 \_\_init\_\_，我们在其中使用了self.name和name（以及self.age和age）。变量name指向传入\_\_init\_\_的值，而self.name指向存储在对象中的值。使用self能够更加清晰的指出谁是谁；

4、设置函数和获取函数

当前，我们可以使用句点表示法来读写Person()对象的name以及age值，如下：

![1576057-20190718232746758-915032570.png][]

这种做法存在一个问题是，可能不小心将年纪设置成 -45 或者 509 等不符合逻辑的数字。对于常规Python变量，无法对付给他的值进行限制。但在对象中，可编写特殊设置函数（setter）和获取函数（getter），对存取值的方式进行控制。

首先，添加一个设置函数，它仅仅提供的值合理时才修改age:

def set_age(self, age):
        if 0 < age <= 150:
            self.age = age

此时，定义一个不再该范围内的数值，则不会修改；

![1576057-20190718234513890-634677805.png][]

对于这种设置函数，一种常见的抱怨是，输入p.set\_age(30)比输入p.age = 30更加繁琐。为了解决这个问题，我们可以使用**特性装饰器（property decorator）**。

特性装饰器：

它融变量的简洁和函数的灵活于一身。装饰器指出函数或者方法有点特殊，这里使用他们来知识设置函数和获取函数；

获取函数返回变量的值，我们将使用@property装饰器来指出这一点：

@property
    def age(self)
        """ Returns this person's age.
        """
    
        return self.age

这里的age方法除必不可少的self外不接受任何参数。我们在它前面加上了 @property，指出这是一个获取函数。这个方法的名称将被用于设置变量。

我们还将底层变量self.age重命名为self.\_age。在对象变量前加上下划线是一种常见的做法，这里使用这种方式将这个变量与方法age区分开来。你需要将Person类中的每一个self.age替换为self.\_age。为保持一致性，最好也将self.name都替换为self.\_name。修改后的Person类类似于下面这样：

# person.py
    class Person:
        def __init__(self, name = '', age = 0):
            self._name = name
            self._age = age
    
        @property
        def age(self):
            return self._age
    
        def set_age(self, age):
            if 0 < age <= 150:
                self._age = age
    
        def display(self):
            print(self)
    
        def __str__(self):
            return "Person('%s', %d)" % (self._name, self._age)
        
        def __repr__(self):
            return str(self)

为了给age创建设置函数，我们将方法set\_age重命名为age，并使用@age.setter进行装饰：

@age.setter
    def age(self, age):
        if 0 < age <= 150:
            self._age = age

修改完以后这样输出：

![1576057-20190719141208439-579882375.png][]

由于给age提供了设置函数和获取函数，编写的代码就像直接使用变量age，但差别在于：遇到代码p.age = -4时，Python实际上将调用方法age(self, age)；同样，遇到代码p.age时，将调用方法age(self)。这提供了如下优点：1、赋值语句很简单了 2、同时可控制变量的设置和获取方式；

私有变量：

依然可以直接访问self.\_age:

![1576057-20190719142428616-1894321132.png][]

问题在于，直接修改 \_age 可能导致对象不一致，因此通常不希望直接修改的情况发生；

为了降低变量self.\_age被直接修改的可能性，一种方式是将其重新命名为self.\_age，即在变量名开头包含两个下划线。两个下划线表明age是私有变量，不应在Person类外直接访问它。要直接访问self.\_age，需要在前面加上\_Person，如下所示：

![1576057-20190719142757901-335387678.png][]

这虽然不能禁止你直接修改内部的变量，但是将无意间这样做的可能性几乎降到了零；

5、继承

继承是一种重用类的机制，让你能够这样创建全新的类：给基友类的副本添加变量方法；

假设我们要开发一款游戏，其中涉及人类玩家和计算机玩家，为此，可以创建一个player类，它包含所有玩家都由的东西，如得分和名称：

# players.py
    class Player:
        def __init__(self, name):
            self._name = name
            self._score = 0
        def reset_score(self):
            self._score = 0
        def incr_score(self):
            self._score = self._score + 1
        def get_name(self):
            return self._name
        def __str__(self):
            return "name = '%s', score = %d" % (self._name, self._score)
        def __repr__(self):
            return 'Player(%s)' % str(self)

我们可以像下面这样使用Player对象：

![1576057-20190719144219425-1552753982.png][]

咋们假设有两类玩家：人和计算机。主要差别在于，人通过键盘输入走法，而计算机使用函数生成走法。除此之外，这两类玩家相同，它们都由名称和得分；

下面来编写一个Human类，用于表示人类玩家。为此，一种办法是通过赋值并粘贴新建Player类的一个副本，再添加让玩家走棋的方法get\_move(self)。这种办法虽然可行，但更好的做法是使用继承。我们可以让Human类继承Player类的所有变量和方法，这样就不需要再次编辑它们了：

class Human(Player):
        pass

在Python中，pass语句表示“什么都不做”。对human类来说，这是一个完整而实用的定义，它继承player类的代码，然我们能够像下面一样定义变量：

![1576057-20190719145533202-53726213.png][]

重写方法：

一个小瑕疵是，h的字符串表示为player，但更准确的说法应该是human。为修复这种问题，可给Human定义方法\_\_repr\_\_;

class Human(Player):
        def __repr__(self):
            return 'Human(%s)' % str(self)

这样结果显示如下：

![1576057-20190719150011073-1349891165.png][]

这就是方法重写：Human中的方法\_\_repr\_\_重写了从Player那里继承的方法\_\_repr\_\_。这是定制派生类的常用方式；

class Computer(Player):
        def __repr__(self):
            return 'Computer(%s)' % str(self)

这三个类组成了一个小型的类层次结构。player为基类，而且他两个类都为派生类。

![1576057-20190719151627824-1225908611.png][]

【基类常被称为父类，而派生类则被称为子类】

6、多态

为了演示OOP的威力，咋们来创建一个名为Undercut的简单游戏。在这个游戏中，两个玩家同时选择一个1-10的整数，如果一个玩家选择的整数比对方选择整数的小1，则该玩家获胜，否则算打平。例如，如果Thomas和Bonnie一起玩游戏Undercur，且他们选择的数字分别为9和10，则Thomas获胜；如果他们分别选择4和7，则打成平手；

下面是一个玩Undercut游戏的函数:

def play_undercut(p1, p2):
        p1.reset_score()
        p2.reset_score()
        m1 = p1.get_move()
        m2 = p2.get_move()
        print("%s move: %d" % (p1.get_name(), m1))
        print("%s move: %d" % (p2.get_name(), m2))
        if m1 == m2 -1:
            p1.incr_score()
            return p1, p2, '%s wins!' % p1.get_name()
        elif m2 == m1 -1:
            p2.incr_score()
            return p1, p2, '%s wins!' % p2.get_name()
        else：
            return p1, p2, 'draw: no winner'

其中，p1.get\_move() 和 p2.get\_move() 我们还没有实现这些函数，因为他们随有些而异。下面就来实现这些函数；

实现get\_move函数：

虽然在游戏Undercut中，走法不过是选择1-10的数字，但任何计算机选择数字的方式截然不同。人类玩家通过键盘输入一个1-10的数字，而计算机玩家使用函数来选择数字。因此，Human和Commputer类需要专用的get\_move(self)方法。

下面时候Human类的方法get\_move():

class Human(Plays):
        def __repr__(self):
            return 'Human(%s)' % str(self)
    
        def get_move(self):
            while True:
                try:
                    n = int(input('%s move (1 - 10): ' % self.get_name()))
                    if 1 <= n <= 10:
                        return n
                    else:
                        print('Oops!')
                except:
                    print('Oops!')

上述代码不断要求用户输入一个1-10的整数，知道用户按要求做。try/except 机构用于铺货用户输入的不是整数（如two）时函数int引发的异常。

对于计算机玩家，我们让它返回一个1-10的随机数（如果需要，以后可改进计算机采取的策略）：

import random
    
    class Computer(Player):
        def __repr__(self):
            return 'Computer(%s)' % str(self)
    
        def get_move(self):
            return random.randint(1,10)

再关联上述代码，则可以执行该游戏；

7、更深入的学习

这里，我们主要了解**面向对象设计模式**。推荐《设计模式：可复用面向对象软件的基础》

转载于:https://www.cnblogs.com/BurnovBlog/p/11205040.html

[1576057-20190717225341626-1948049511.png]: /images/20211201/19c4e4dc3480492a9e18ae5a23a0cb8c.png
[1576057-20190717232849351-594033608.png]: /images/20211201/7efc8712552e43f7b5765d80af1fecd9.png
[1576057-20190717234539578-575139332.png]: /images/20211201/93cab7f54b1a4052beee2933b6205a5b.png
[1576057-20190718095845592-1219407427.png]: /images/20211201/56254bac3fb34dbeab01bd2205fddc19.png
[1576057-20190718101849658-1797923617.png]: /images/20211201/c8ba667094734e368b81ad70edc7b5ed.png
[1576057-20190718230625424-820173571.png]: /images/20211201/1cd953bcd9b84e758a99c9cce7a634ec.png
[1576057-20190718232746758-915032570.png]: /images/20211201/ca63fcbacb0a41538ca3a7ee21b286f0.png
[1576057-20190718234513890-634677805.png]: /images/20211201/ac553975afff430296a991f9fb064955.png
[1576057-20190719141208439-579882375.png]: /images/20211201/5c03a8d5ab104d268faf90c3329d7ce1.png
[1576057-20190719142428616-1894321132.png]: /images/20211201/b7366fcb2dc643109b8380df2b1c6de1.png
[1576057-20190719142757901-335387678.png]: https://img2018.cnblogs.com/blog/1576057/201907/1576057-20190719142757901-335387678.png
[1576057-20190719144219425-1552753982.png]: https://img2018.cnblogs.com/blog/1576057/201907/1576057-20190719144219425-1552753982.png
[1576057-20190719145533202-53726213.png]: https://img2018.cnblogs.com/blog/1576057/201907/1576057-20190719145533202-53726213.png
[1576057-20190719150011073-1349891165.png]: https://img2018.cnblogs.com/blog/1576057/201907/1576057-20190719150011073-1349891165.png
[1576057-20190719151627824-1225908611.png]: https://img2018.cnblogs.com/blog/1576057/201907/1576057-20190719151627824-1225908611.png