Python 面向对象

---

前言

Python学习进度一直不高，在遇到概念性较强的部分，尤其是面向对象思想的理解，想着总结记录，方便随时翻看。

---

一、面向对象中的几点概念

1.1 什么是类？

类：用户定义的对象原型（prototype），该原型定义了一组可描述该类任何对象的属性，属性是数据成员（类变量 和 实例变量）和方法（类方法 和 成员方法 ），通过 “对象.变量 或 对象.方法()”的形式访问。其实类是一个模板，我们可以使用该模板生成不同的具体的对象，来完成我们想要的操作

1.2 什么是实例？

实例：某一个类的具体实现，例如我们定义了一个 Person 类，而具体的人，比如小明，小黄就是 Person 类的实例

1.3 什么是属性？

属性：描述该类具有的特征，比如人类具备的属性，身份证，姓名，性别，身高，体重等等都是属性

1.4 什么是方法？

方法：是该类对象的行为，例如这个男孩会打篮球，那个女孩会唱歌等等都是属于方法，常常通过方法改变一些类中的属性值

二、Python 使用面向对象编程

创建对象流程：

1. 加载类到内存
2. 开辟内存，系统自动调用__new__(cls)
3. 初始化对象，自动调用__init__(self)
4. 执行代码，访问具体实例

2.1 定义一个类

Python 中定义类是使用关键字 class，一个简单的实例代码（示例）：

class Student():
    pass

# 创建对象实例
stu = Student()
print(stu)
print(property(stu))
print(type(stu))

结果：

<__main__.Student object at 0x000001EA1DF21F88>
<property object at 0x000001EA1DF23638>
<class '__main__.Student'>

在定义一个类的时候，建议类名使用大驼峰命令，因为这是一种规范问题，打印对象的结果也可以看得到，我们创建的实例在计算机的内存地址。

2.2 类的基本属性和方法

类中的属性（两种）：

• 类属性(类变量)，通过 类型.类变量访问
• 对象属性(成员变量)，通过 对象.变量访问

class Student(object):

    # 类属性，定义在类中，方法外
    id = '学生'

    def __init__(self, name, age):
        self.name = name  # 成员属性
        self.__age = age  # 私有属性

    def setAge(self, age):
        self.__age = age

    def getAge(self):
        return self.__age


stu1 = Student('pureone', 29)

# 通过类型.类变量名，访问类变量
print(f"{stu1.name} 今年 {stu1.getAge()} 岁,是名{Student.id}")
# 通过对象.__class__.id，访问类变量
print(f"{stu1.name} 今年 {stu1.getAge()} 岁,是名{stu1.__class__.id}")
# 通过对象.id，访问类变量
print(f"{stu1.name} 今年 {stu1.getAge()} 岁,是名{stu1.id}")

小结：

• 在类中，方法外定义的属性就是类属性
• 类属性可以通过实例或类直接访问
• 类属性只能通过类对象修改，无法通过实例对象修改

绑定方法

• 绑定到对象 : 当对象去调用类中成员方法时,系统会默认把该对象当成参数传递给该方法
• 绑定到类 : 当对象或者类去调用类中成员方法时,系统会默认把该类当成参数传递给该方法

类中的三种方法类型

• 类方法
• 成员方法（实例方法）
• 静态方法

class A(object):

    count = 0  # 类属性

    def __init__(self):
        self.name = 'swk'  # 实例属性
	
	def demo():
		'''
		类中无参方法默认只能类来调用,对象无法调用
		'''
		print('类中无参方法')
	
    def test_1(self):
        '''
        以 self 为第一个参数的方法都是实例方法
        实例方法在调用时，Python 会默认将调用对象作为 self 传入
        实例方法可以通过实例和类去调用
            - 当通过实例调用时，会自动将当前调用对象作为 self 传入
            - 当通过类调用时，不会自动传递 self， 此时需要我们手动传递 self
        :return:
        '''
        print('hello World')

    @classmethod
    def test_2(cls):
        '''
        类方法
        在类内部使用 @classmethod 来修是的方法属于类方法
            类方法和实例方法的区别，实例方法第一个参数是 self， 而类方法第一个参数是 cls，可以访问类属性，不能访问实例属性
            类方法可以通过类调用，也可以通过实例调用，两者没有区别
        '''
        print('这是 test2 方法')

    @staticmethod
    def test_3():
        '''
        静态方法：通过类名.方法名()直接调用
        在类中使用 @staticmethod 来修饰的方法属于静态方法
        静态方法：基本是和当前类无关的方法，既不能访问类属性，也不能访问实例属性
        静态方法都是一些工具方法，它只是保存在当前类中的函数
        '''
        print('test_3 执行了')

2.3 类的私有属性和私有方法

双下划线"__"的作用：
在 Python 中，双下换线是作为私有属性而存在，但它其实还是可以访问到，在 Python 内部，双下划线实际上是把 __xxx 替换成了 _类名__xxx表示，可以通过类名.__dict__查看

2.3.1 类的私有属性

在学习 java 的过程中，我们知道 java 拥有 public > default > protected > private 的四大访问修饰符。而在 Python 中修改一个属性值，可以直接通过 “对象.属性” 直接修改，这样是有问题的，比如我们把一个人的年龄设置为 200，正常人都知道，一个人的最长寿命也不会超过 150 岁，所以为了防止这种情况的出现，我们可以把人的年龄设置为私有变量，这样年龄属性就无法在外面直接访问得到了。因此我们只需要把 age字段前面加上 ‘__’ 即可，这样在外面，我们就无法使用 对象.age 或 对象.__age 访问到年龄了

class Student():

    # student 是类属性，可以他通过 对象.__class__.student 访问
    student = "大学生"
    # init 是类的构造方法，在对象被创建的时候，就会自动调用这个方法
    def __init__(self,name,age):
        # 定义两个对象属性，这个属性在不同的对象中是不一样的
        self.name = name
        if age>150:
            raise ValueError("人的年龄无法达到 150 岁以上")
        self.__age = age

    def sing(self):
        print(f"{self.name} 会唱歌")

    def basketbal(self):
        print(f"{self.name} 会打篮球")

stu1 = Student("小红",18)
stu2 = Student("小黄",19)

print(stu1.age)
# AttributeError: 'Student' object has no attribute 'age'

这样 age 属性就无法被直接访问，因此需要创建两个方法，和 java 中的 setter 和 getter 方法的作用类似，分别设置和获取变量

• 用来提供设置属性的值
• 用来提供访问属性的值

2.3.2 类的私有方法

class Student():

    student = "大学生"

    def __init__(self, name, age):
        self.name = name
        if age > 150:
            raise ValueError("人的年龄无法达到 150 岁以上")
        self.__age = age

    def getAge(self):
        # 调用私有方法
        self.__showAge()
        return self.__age

    def setAge(self, age):
        if age > 150:
            raise ValueError("人的年龄无法达到150岁")
        self.__age = age

    # 定义私有方法，只能在本类中被调用
    def __showAge(self):
        # 私有方法，可以访问成员属性或者私有属性
        print("今年 %d 岁了" % self.__age)


stu1 = Student("小红", 18)
stu2 = Student("小黄", 19)
stu1.setAge(20)

print(stu1.getAge())

三、使用封装、继承、多态

3.1 封装（重要属性封装起来，防止被查看）

封装的核心：隐藏对象中一些不希望被外部访问到的属性或方法
在学习 Java 的过程中，我们进行封装操作的时候，设置属性的访问权限为 private（只在当前类可以访问），所以我们会使用 getter 和 setter 方法来修改属性的值。在 Python 中我们也可以使用 同样的 getter 和 setter 方法

3.1.1 常见封装

class Retangle():

    # 内部访问，使用 hidden 任然可以被访问
    # 使用 __作为私有属性，是外部不可以被访问
    def __init__(self,width, height):
        self.__width = width
        self.__height = height

    def setWidth(self,width):
        self.__width = width

    def getWidth(self):
        return self.__width

    def setHeight(self,height):
        self.__height = height

    def getHeight(self):
        return self.__height

3.1.2 装饰器封装

class Person():
    '''
        __xxxx 成为私有属性，实际是__name -> _Person__name
        使用 _xxx 作为私有属性，没有特殊需求，不要修改私有属性
        类一般使用属性或方法不可见可以使用单下划线
    '''

    # 构造函数，初始化对象属性
    def __init__(self, name):
        self.__name = name

    @property
    def name(self):
        '''
        setter、getter 方法更好的使用
        @property，将一个 get 方法，转换为对象属性
        @属性名.setter 将一个 set 方法，转换为对象属性
        两者缺一不可
        '''
        return self.__name

    # setter 方法的的装饰器： @属性名.setter
    @name.setter
    def name(self, name):
        self.__name = name


p = Person('猴赛雷')
p.name = 'aaa'  # 使用属性的方式 调用 setter 和 getter
print(p.name)

@property使用的注意事项:

1. 方法上要写@property
2. 方法形参只能是self
3. 调用时不需要写括号，直接当成属性变量用，即 对象.变量
4. 只能取值，不能设置值

3.2 继承（访问扩展性）

分别编写 pipi 类 和 dandan 类，它们都继承了 Dog 类，因此他们都具备 Dog 类的非私有属性和方法，而且还可以定义其特有的方法，示例代码如下

class Dog():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    # 定义公共方法
    def bark(self):
        print(f"{self.name} can bark")


class pipi(Dog):
    def play(self):
        print(f"{self.name} 会打滚")


class dandan(Dog):
    def other(self):
        print(f"{self.name} 会杂技")


dog1 = pipi("皮皮", 2)
dog2 = dandan("蛋蛋", 3)
dog1.play()
dog1.bark()  # 调用公共的方法
dog2.other()

子类继承父类的三点注意：

• 子类可以调用父类的公有成员
• 子类不能调用父类的私有成员
• 子类可以重写父类的同名公有方法

3.2.1 继承中非私有方法调用

当子类和父类方法同名时，子类方法会覆盖父类的方法。

class Dog():
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def bark(self):
        print(f"{self.name} can bark")

    def eat(self):
        print(f"{self.name} 喜欢吃鸡肉")


class pipi(Dog):
    def play(self):
        print(f"{self.name} 会打滚")

    def eat(self):
        print(f"{self.name} 喜欢吃火腿")


dog1 = pipi("皮皮", 2)
dog1.eat()

运行结果：

皮皮 喜欢吃火腿

3.2.2 继承中初始化方法__init__()方法调用

• 当子类没有 init 方法时，子类会直接继承 父类的 init 方法
• 当子类定义了 init 方法的时候，子类的init() 中调用父类的 init()方法，应先初始化父类，在初始化子类
• 子类定义了 init()，子类__init__() 中没有调用父类的方法，这时注意，父类的私有属性无法调用

class A(object):
    def __init__(self, name):
        self.name = name
        print("name:", self.name)

    def getName(self):
        return 'A ' + self.name


class B(A):
    def __init__(self, name):
        # super().__init__(name) 初始化父类的__init__()方法
        # super(子类名, self).__init__(name) 初始化父类的__init__()方法
        super(B, self).__init__(name)
        print("hi")
        self.name = name

    def getName(self):
        return 'B ' + self.name


if __name__ == '__main__':
    b = B('hello')
    print(b.getName())

运行结果：

name: hello
hi
B hello

3.3 多态（程序的灵活性）

多态：是指一个声明为 A类型的变量，可能是指 A类型的对象，也可以是 A类型的任何子类对象

class Dog():
    def __init__(self, name, age):
        self.name = name

        if age > 100:
            raise ValueError("狗狗的年龄不可能这么大")
        self.__age = age

    def getAge(self):
        return self.__age

    def setAge(self, age):
        if age > 100:
            raise ValueError("狗狗的年龄不可能这么大")
        self.__age = age

    # 定义公共方法
    def bark(self):
        print(f"{self.name} can bark")

    def eat(self):
        print(f"{self.name} 喜欢吃鸡肉")


class pipi(Dog):
    def play(self):
        print(f"{self.name} 会打滚")

    def eat(self):
        print(f"{self.name} 喜欢吃火腿")

    # 方法覆盖
    def bark(self):
        print(f"{self.name} 在叫,嘻嘻....")


class dandan(Dog):
    def other(self):
        print(f"{self.name} 会杂技")


def dog_bark(dog):
    if isinstance(dog, Dog):
        dog.bark()


d = Dog("阿拉斯加", 3)
dog_bark(d)

d1 = pipi("小皮", 2)
dog_bark(d1)

d2 = dandan("蛋蛋", 1)
dog_bark(d2)

以上代码中，我们定义一个 dog_bark() 方法，它可以接受父类的对象，也可以接受子类的对象。使用多态，我们并不需要给每个子类定义一个调用 bark() 的方法，pipi_bark(), dandan_bark()，只需要定义一个 dog_bark()，在调用的时候给它传递对应的子类对象即可。

4 特殊方法

4.1 类中的特殊成员

方法在特殊的场景的时候会被⾃动的执⾏

• 类名() 会自动执__init__()
• 对象() 会自动执__call__()
• 对象[key] 会自动执__getitem__()
• 对象[key] = value 会自动执行__setitem__()
• del 对象[key] 会自动执行 delitem()
• 对象+对象 会自动执行 add()
• with 对象 as 变量 会自动执行__enter__ 和__exit__
• 打印对象的时候 会自动执行 str
• 干掉可哈希 hash == None 对象就不可哈希

4.2 重写内置函数

在 Python 中大家应该都用过 len(), str() 等一些内置函数，这些方法都可以在定义类时重写。也成为魔术方法，它的使用也很简单，我们使用 __ 开始 以及结尾就可以使用了
特殊方法：

class Test():
    def __init__(self):
        print("我是初始化方法")

    def __len__(self):
        return 55

    def __str__(self):
        return "Hello World"


t = Test()

print(t)
print(len(t))
print(str(t))

以下特殊方法可以定义，成为魔术方法

• init 初始化方法
• str() str() 这个特殊方法会在尝试将对象转换为字符串的时候调用
• rpr() rpr()
• len() 获取长度 len()
• bool() 返回布尔值 bool()
• pow
• lshift()
• lt()
• add()
• and
• or
• eq
• sub