python学习笔记(十二)面向对象2

最新推荐文章于 2024-08-01 19:45:58 发布

鱼天天

最新推荐文章于 2024-08-01 19:45:58 发布

阅读量153

点赞数 1

分类专栏： python学习文章标签： python

本文链接：https://blog.csdn.net/qq_40433141/article/details/105256495

版权

python学习专栏收录该内容

21 篇文章 0 订阅

订阅专栏

面向对象

文章目录

- 面向对象

面向对象三大特点

封装：既是对数据封装，又是对处理数据的方法的封装
继承：强调的是父子类之间的关系
多态：不同的对象调用相同的方法，有不同的响应。

类的继承

继承语法

# class Animal:
# 当没有写父类时，默认继承自object
# 定义一个动物类
class Animal(object):
    def __init__(self, name):
        self.name = name

    def run(self):
        print('小动物们一天到晚到处乱跑')
# 狗 继承自 动物  狗也是动物     
class Dog(Animal):
 	def eat(self):
      	print('小狗喜欢啃骨头')   
    
# 创建一个狗  对象
d = Dog('旺财')

# 继承的属性
print(d.name)
# 继承的方法
d.run()

# 添加新的属性
d.age = 2
# 添加的方法
d.eat()

方法重写

当对于父类的方法不满意的时候可以进行重写
重写之后父类的方法就会失效自己重写的方法生效

class Aniaml:
    def eat(self):
        print('小动物都喜欢吃东西')

    def run(self):
        print('小动物喜欢跑个不停')
        
class Cat(Aniaml):
    # 完全不合适，覆盖重写
    def run(self):
        print('猫喜欢走猫步')

	# 不完全合适，需要修改完善
    def eat(self):
        # 调用父类的方法
        # Aniaml.eat(self)        # 不建议使用
        # super(Cat, self).eat()      # 老的写法
        super().eat()               # 新的写法，推荐
        print('猫喜欢吃鱼') 
        
c = Cat()
c.eat()
c.run()

多继承

一个类可以有多个父类，即可以拥有多个类的特征

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

class B:
    def run(self):
        print('run func in class B')

	def eat(self):
		print('eat func in class B')
        
class C(A, B):
    def eat(self):
        # 这样写会按照默认顺序查找父类的方法
        # super().eat()
        # 可以明确指定调用哪个父类的方法
        B.eat(self)    
 
c = C()
c.eat()
c.run()

继承链

class A(object):
    def foo(self):
        print('A foo')
            
class B(object):
    def foo(self):
        print('B foo')

    def bar(self):
        print('B bar')
    
class C1(A, B):
    pass

class C2(A, B):
    def bar(self):
        print('C2-bar')

class D(C1, C2):
    pass

d = D()

d.foo()
d.bar()

# __mro__类属性，记录了继承链的查找顺序
# 一旦找到，立即停止并返回
# 按照广度优先的原则进行查找
for i in D.__mro__:
    print(i)

访问权限

class Person:
    def __init__(self, name, age):
        self.name = name
        # 定义私有属性
        self.__age = age
        
p = Person('王大花', 18)

# 公有属性：可以在类外使用
print(p.name)
# 私有属性：不能再类外使用
# print(p.__age)

# 实现原理：私有属性默认会在前面加 '_类名' 前缀
# 可以通过下面的方式访问私有属性，但是强烈不建议
# print(p._Person__age)
print(p.__dict__)

class Man(Person):
    def introduce(self):
        # 可以在子类中使用
        print(self.name)
        # 也不能在子类中使用
        # print(self.__age)    
 
m = Man('二狗', 20)
m.introduce()

总结
公有属性：在类的内部、外部、子类中都可以使用
私有属性：只能在类的内部使用，类外及子类中都不能使用
实现原理：默认在’_'开头的属性前添加’类名’的前缀

类属性

class Person:
    # 类属性
    nation = 'china'

    # 限制对象可以使用的属性，可以提升访问效率
    # 只可以使用这么多
    __slots__ = ('name', 'age')

    def __init__(self, name):
        # 成员属性
        self.name = name
        
xiaoming = Person('小明')
xiaohong = Person('小红')
print(xiaoming.name)
print(xiaohong.name)
        
# 查看对象的类名
print(xiaoming.__class__)

# 通过类名进行访问
print(Person.nation)

# 查看类的名字
print(Person.__name__)

# 查看父类元组
print(Person.__bases__)

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

# 查看继承链顺序
print(Person.__mro__)

xiaoming.age = 20
# 不能添加，因为没有在Person.slots类属性中
# xiaoming.height = 180

# 显示对象能够使用的属性
print(Person.__slots__)

类方法

class Person:
    # 成员方法：通过对象调用
    def eat(self):
        print('能吃是福')

    # 类方法：通过类名调用
    @classmethod
    def test(cls):
        # cls：表示当前类
        print(cls)

    # 可以创建对象 或 简单的创建对象
    @classmethod
    def create(cls):
        p = cls()
        p.age = 1
        return p
    
p = Person()
p.eat()

Person.test()

p2 = Person.create()
print(p2)    
p2.eat()

作用：

可以创建对象或简洁的创建对象
可以对外提供简单易用的接口

静态方法

class Person:
    # 定义静态方法：也是通过类名调用，但是没有第一个表示当前类的参数
    @staticmethod
    def test():
        print('静态方法 test')

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

class Man(Person):
    @staticmethod
    def test():
        # 无法使用super调用父类方法
        # 只能通过类名调用
        Person.test()
        
Person.test()

p = Person.create()
print(p)

Man.test()

总结
方式可以静态方法解决的问题都可以使用类方法进行解决
静态方法中无法使用super
静态方法中没有cls参数

多态特性

说明：不同的对象调用相同的方法，有不同的响应

示例：

class Animal:
    def run(self):
        print('小动物走路姿势各不相同')
        
class Dog(Animal):
	def run(self):
      	print('狗喜欢撒欢疯跑')

class Cat(Animal):
	def run(self):
      	print('猫走的是猫步')
      	
def func(obj):
	# 判断某个对象是否拥有某个属性
    if hasattr(obj, 'run'):
    	obj.run()
    else:
    	print('类型有误')
    	
func(Dog())
func(Cat())

对象支持字典操作

说明：将对象当做字典操作时，会自动触发相关的魔术方法

示例：

class Person:
    # 当做字典操作：设置属性时
    def __setitem__(self, key, value):
        # print(key, value)
        self.__dict__[key] = value

    # 当做字典操作：获取属性时
    def __getitem__(self, item):
        # print(item)
        return self.__dict__.get(item)

    # 当做字典操作：删除属性时
    def __delitem__(self, key):
        # print(key)
        self.__dict__.pop(key)
        # del self.__dict__[key]
        
p = Person()

# p.name = '大花'
p['name'] = '大花'

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

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