jinYwuM

Python 面向对象

文章目录

前言
一、面向对象中的几点概念
- 1.1 什么是类？
- 1.2 什么是实例？
- 1.3 什么是属性？
- 1.4 什么是方法？
二、Python 使用面向对象编程
- 2.1 定义一个类
- 2.2 类的基本属性和方法
- - 类中的属性（两种）：
  - 类中的方法（三种）：
- 2.3 类的私有属性和私有方法
- - 2.3.1 类的私有属性
  - 2.3.2 类的私有方法
三、使用封装、继承、多态
- 3.1 封装（重要属性封装起来，防止被查看）
- - 3.1.1 常见封装
  - 3.1.2 装饰器封装
- 3.2 继承（访问扩展性）
- - 3.2.1 继承中非私有方法调用
  - 3.2.2 继承中初始化方法__init__()方法调用
- 3.3 多态（程序的灵活性）
4 特殊方法
- 4.1 类中的特殊成员
- 4.2 重写内置函数

前言

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

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

1.1 什么是类？

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

1.2 什么是实例？

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

1.3 什么是属性？

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

1.4 什么是方法？

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

二、Python 使用面向对象编程

创建对象流程：

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

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__.student，访问类变量
print(f"{stu1.name} 今年 {stu1.getAge()} 岁,是名{stu1.__class__.id}")

小结：

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

类中的方法（三种）：

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

class A(object):

    count = 0  # 类属性

    def __init__(self):
        self.name = 'swk'  # 实例属性

    def test(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 内部，双下划线实际上是把属性换了一个更复杂的方式表示，比 hidden_属性更复杂，它其实是把 __xxx 替换成了 _类名_属性名表示

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'
print(stu2.__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使用的注意事项:

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

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())