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 使用面向对象编程

创建对象流程:

  1. 加载类到内存
  2. 开辟内存,系统自动调用__new__()
  3. 初始化对象,自动调用__init__()
  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__.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使用的注意事项:

  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

你可能感兴趣的:(Python,Perl,数组引用,零宽断言)