面向对象 (二)

发表于 2019-12-06 更新于 2024-03-17 分类于 Python > Python教程 > Python基础本文字数： 6.6k 阅读时长 ≈ 11 分钟

内置方法 (一)

当对对象按照字典操作时，会自动触发相关方法

示例：

class Person:
    # 当对象按照字典设置键值对时，会自动触发该方法
    def __setitem__(self, key, value):
        # print(key, value)
        self.__dict__[key] = value

    # 当对象按照字典操作根据键获取值时，会自动触发该方法
    def __getitem__(self, item):
        print(item)
        return self.__dict__[item]

    # 当做字典操作，删除键值对时，会自动触发该方法
    def __delitem__(self, key):
        del self.__dict__[key]


p = Person()

p['name'] = 'xiaoming'
print(p.name)
# 通过字典方式添加的键值对，可以通过属性的方式获取
# print(p['name'])
# print(p.__dict__)

del p['name']
# print(p.name)

类的继承

相关概念：
- 继承：父类的属性和方法子类可以直接拥有
- 派生：子类在父类的基础上衍生出来的新的特征（属性和方法）
- 总结：其实他们是一回事，只是描述问题的角度侧重点不同（继承描述相同点，派生侧重不同点）

继承：

# class Animal(object):

# 当没有指定父类时，相当于默认父类为object
class Animal:
    def __init__(self, name):
        self.name = name

    def eat(self):
        print('小动物一天到晚吃个不停')


# 继承自Animal
class Dog(Animal):
    pass


d = Dog('旺财')
# 直接拥有父类的方法
d.eat()
# 直接拥有父类的属性
print(d.name)

派生：子类可以扩充属性和方法

class Animal:
    def run(self):
        print('小动物喜欢到处乱跑')


class Rabbit(Animal):
    # 添加方法
    def eat(self):
        print('爱吃萝卜和青菜')


xiaobai = Rabbit()
xiaobai.run()
xiaobai.eat()
# 添加属性
xiaobai.color = 'white'
print(xiaobai.color)

重写：

父类的方法完全不合适，子类需要全部的覆盖
父类的方法合适，但是需要完善

示例：

class Animal:
    def run(self):
        print('小动物喜欢到处乱跑')

    def eat(self):
        print('小动物也是一天三顿')


class Cat(Animal):
    # 当父类的方法完全不合适，可以覆盖重写
    def run(self):
        print('俺走的是猫步')

    # 父类的方法合适，但是子类需要添加内容完善功能
    def eat(self): 
        # 调用父类方法，不建议使用
        # Animal.eat(self)
        # super(Cat, self).eat()
        # 类名及self可以不传
        super().eat()
        print('不过俺喜欢吃鱼')


jiafei = Cat()
jiafei.run()
jiafei.eat()

多继承：

概念：一个类可以有多个父类

示例：

class A:
    def eat(self):
        print('eat func of A')


class B:
    def eat(self):
        print('eat func of B')


# 多继承，多个父类使用逗号隔开
class C(B, A):
    def eat(self):
        # print('eat func of C')
        # 当多个父类拥有相同方法时，会按照继承的先后顺序进行选择
        # super().eat()
        # 如果非要使用后面的类的方法时，可以明确指定进行调用
        A.eat(self)


c = C()
c.eat()

访问权限

权限：
- 公有的：类中的普通属性和方法，默认都是公有的，可以在类的内部、外部、子类中使用
- 私有的：定义时在前面加两个 _，只能在本类的内部使用，不能在外部及子类中使用

示例：

class Person:
    def __init__(self, name, age):
        self.name = name
        # 在属性的前面添加两个'_'，外部不能访问，系统内部的除外
        # 默认的属性名：__age => _Person__age
        self.__age = age

    def eat(self):
        print('民以食为天')

    # 在方法的前面添加两个'_'，外部不能访问，系统内部的除外
    # 默认的方法名：__inner() => _Person__inner()
    def __inner(self):
        print('私有方法，不想让外部调用')

    def test(self):
        # 在类的内部可以访问私有的属性和方法
        print(self.__age)
        self.__inner()


p = Person('老王', 50)
# 默认所有的属性和方法都是共有的，就是在类的外面可以直接使用
p.eat()
print(p.name)

# 以下两局会报错，提示没有相关的属性或方法
# p.__inner()
# print(p.__age)

print(p.__dict__)
# 可以通过系统修改的名称找到，但是强烈建议不要这样使用
print(p._Person__age)
p._Person__inner()
p.test()


class Man(Person):
    def test(self):
        # print(self.__age)
        # self.__inner()
        print('子类无法使用父类的私有属性和方法')


m = Man('木盖', 24)
m.test()

类属性

说明：定义时，写在类中，但是方法外的属性，通常放在类的开头位置

示例：

class Person:
    # 定义类属性
    nation = '中国'

    def __init__(self, name):
        self.name = name
        self.nation = 'china'


# 通过类名访问类属性
print(Person.nation)

# 通过对象也可以访问类属性，但是不建议
# 当对象有同名的成员属性时，使用的就是成员属性
p = Person('xiaoming')
print(p.nation)

# 也可以动态添加
Person.hello = 'hello'
print(Person.hello)

# 特殊的类属性
# 表示类名字符串
print(Person.__name__)

# 表示父类构成的元组
print(Person.__bases__)

# 存储类相关的信息
print(Person.__dict__)

类方法

说明：
- 定义时使用装饰器：classmethod
- 通过类名调用
作用：
- 可以创建对象或者简洁的创建对象
- 对外提供简单易用的接口

示例 1：语法

class Preson:
    def eat(self):
        print('麻辣是我的最爱')

    @classmethod
    def test(cls):
        print('类方法 test')
        # cls 表示当前类
        print(cls)

    @classmethod
    def create(cls):
        p = cls()
        # 进行特定的初始化设置
        p.age = 1
        return p


Preson.test()
print(Preson)
# 可以创建对象或者简洁的创建对象
p = Preson.create()
print(p)

示例 2：设计一个数字类，有两个属性，能够进行加减乘除运算，要求：计算两个数的平方和

class Number:
    def __init__(self, num1, num2):
        self.num1 = num1
        self.num2 = num2

    def add(self):
        return self.num1 + self.num2

    def sub(self):
        return self.num1 - self.num2

    def mul(self):
        return self.num1 * self.num2

    def div(self):
        if self.num2 == 0:
            return 0
        return self.num1 / self.num2

    @classmethod
    def pingfanghe(cls, num1, num2):
        # 第一个数
        n1 = Number(num1, num1)
        # 求平方
        n12 = n1.mul()

        # 第二个数
        n2 = Number(num2, num2)
        # 求平方
        n22 = n2.mul()

        # 第三个数
        n3 = Number(n12, n22)
        # 求和
        return n3.add()


print(Number.pingfanghe(3, 4))

静态方法

说明：
- 使用装饰器：staticmethod 进行修饰
- 定义的方法没有第一个表示当前类的参数

示例：

class Person:
    @staticmethod
    def test():
        print('static method test')

    @staticmethod
    def create():
        # 也可以创建对象
        p = Person()
        return p


Person.test()

p = Person.create()

与类方法相比：

1 2	1. 除了装饰器不同，其他的基本一样，做与对象创建无关的任务时可以使用静态方法 2. 所有静态方法能够完成的功能都可以使用类方法完成

多态特性

定义：不同的对象，调用相同的方法有不同的响应
体现：多态性，不同的对象接收相同的消息会有不同的响应

示例：

class Animal:
    def run(self):
        pass


class Dog(Animal):
    def run(self):
        print('狗奔跑的时候一般是s型')


class Cat(Animal):
    def run(self):
        print('猫平时走猫步，偶尔会突然加速')


# 参数必须有run方法
def func(obj):
    obj.run()


func(Dog())
func(Cat())

属性函数

说明：
- 使用装饰器：property 进行修饰
- 将方法当做属性一样使用
作用：保护特定属性，处理属性

示例：

class User:
    def __init__(self, username, password):
        self.username = username
        self.__password = password

    # 使用property修饰的方法，可以当做属性访问
    # 可以保护特定的属性
    @property
    def password(self):
        print('有人想直接获取密码')
        return '哈哈，想偷看，没门'
        # return self.__password

    # 当设置password属性时，会自动调用该方法
    @password.setter
    def password(self, password):
        print('注意了，有人想修改密码', password)
        # 可以对密码进行特定处理，然后保存
        self.__password = 'xxx' + password + 'yyy'


u = User('xiaoming', '123456')
print(u.username)
# 直接访问密码是不需要的，也是不安全的
# 直接访问password属性，自动调用使用property装饰器修饰后的password方法
print(u.password)
u.password = '654321'

内置方法 (二)

说明：
- 把对象当做函数一样调用时，系统会自动触发__call__方法
- 若想支持这样的操作，需要在类中提供__call__方法

示例：

class Person:
    # 把对象当做函数一样调用时，系统会自动触发该方法
    def __call__(self, *args, **kwargs):
        # 如计算和
        return sum(args)


p = Person()
# 将对象当做函数使用，需要提供__call__方法
ret = p(1, 2, 3, 4, name='xiaoming')
print(ret)

函数判断

问题：如何判断一个对象是否可以像函数一样调用

示例：

class A:
    def __call__(self, *args, **kwargs):
        print('xxx')


def test():
    pass


# 不能使用isinstance方法判断一个对象是否是函数
# print(isinstance(test(), function))
# 打印时仍然是function类型
# print(type(test))

# 判断一个对象是否可以像函数一样调用
print(callable(test))
test()

a = A()
print(callable(a))
# a()


# 判断对象是否拥有__call__属性
print(hasattr(test, '__call__'))
print(hasattr(a, '__call__'))

# 判断是否是函数
from inspect import isfunction

print(isfunction(test))
print(isfunction(a))

数据持久化存储

方法：普通文件、数据库、序列化

示例：

import pickle


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


# 存储：对象 => 文件
# xiaoming = Person('小明', 18)
# fp = open('test.txt', 'wb')
# pickle.dump(xiaoming, fp)
# print('对象数据已存储完毕')

# 读取：文件 => 对象
fp = open('test.txt', 'rb')
xiaoming = pickle.load(fp)

print(xiaoming.name)
print(xiaoming.age)

fp.close()

内置方法 (一)

类的继承

相关概念：

继承：

派生：子类可以扩充属性和方法

重写：

多继承：

访问权限

权限：

示例：

类属性

说明：定义时，写在类中，但是方法外的属性，通常放在类的开头位置

示例：

类方法

说明：

作用：

示例 1：语法

示例 2：设计一个数字类，有两个属性，能够进行加减乘除运算，要求：计算两个数的平方和

静态方法

说明：

示例：

与类方法相比：

多态特性

定义：不同的对象，调用相同的方法有不同的响应

体现：多态性，不同的对象接收相同的消息会有不同的响应

示例：

属性函数

说明：

作用：保护特定属性，处理属性

示例：

内置方法 (二)

说明：

示例：

函数判断

问题：如何判断一个对象是否可以像函数一样调用

示例：

数据持久化存储

方法：普通文件、数据库、序列化

示例：