当前位置：首页 > news >正文

Python语法进阶篇 --- 封装、继承、多态、静态方法、类方法

news 2025/6/6 5:51:00

Python语法进阶篇 --- 封装、继承、多态、静态方法、类方法

封装
继承
多态
静态方法
类方法

🐹🐹🐹🐹🐹一只正在努力学习计算机技术的小仓鼠🐹🐹🐹🐹🐹

面向对象的三大特征：封装、继承、多态

封装

概念：封装指将对象中的属性和方法包起来，这些属性和方法只能在对象内部处理，即隐藏对象中不希望被外部访问的属性或方法。封装有助于保证数据的安全性和代码的可维护性。
属性分类：
- xxx：普通属性/方法。在类中，该属性/方法允许在任何地方使用。
- _xxx：私有属性/方法。在类中，该属性/方法允许外部使用，允许子类继承，但是在另一个.py文件通过from xxx import *无法导入私有属性。一般为了避免与Python关键字冲突而命名的方法。
- __xxx：隐藏属性/方法。在类中，该属性/方法不允许外部直接访问，不允许子类继承，且在另一个.py文件通过from xxx import *也无法导入隐藏属性。

class Human:hand = 2foot = 2_habit = '吃喝玩乐'__feature = '高等动物'# 普通方法def introduce(self):# 在实例方法中访问隐藏属性Human.__feature = '会学习、会思考的高等动物'print(f'Human is {self.__feature}')# 私有方法def _creature(self):print('Human is in the top of food chain')# 隐藏方法def __disposition(self):print('Human is kindness when they were born')# 直接从实例中调用隐藏方法def getDisposition(self):self.__disposition()
human = Human()
# 访问对象里的普通属性
print(f'Human has {human.hand} hands')
# 访问对象里的私有属性
print(f'Human like {human._habit}')
# 访问对象里的隐藏属性
human.introduce()
# 访问对象里的私有方法
human._creature()
# 访问对象里的隐藏方法
human.getDisposition()

继承

概念：类和类之间形成父子关系，子类默认继承父类的所有属性和方法（__init__除外）。

单继承

class Person:
behaviour = ['eat', 'drink', 'think']
def create(self):print('Person created')# Person类的子类Girl
class Girl(Person):def gender(self):print('this is Girl')
girl = Girl()
print(girl.behaviour)
girl.gender()

多重继承

继承的传递性：子类拥有父类及父类的父类中的属性和方法。
A|B(A)|C(B) → C继承B，B继承A → C类同时拥有A类和B类的属性和方法。

class Grandfather():identify = '爷爷'def identity(self):print(f'{self.identify}')
class Father(Grandfather):identify = '爸爸'def eat(self):print('I can eat')
class Son(Father):identify = '儿子'def drink(self):print('I can drink')
son = Son()
son.identity()

方法重写

概念：如果从父类继承的方法不能满足子类的需求，可以在子类中重写父类的方法，这个过程称为方法重写。

覆盖父类方法

class Person:def money(self):money = 100print(f'{money}需要继承')
class Man(Person):def money(self):money = 1000print(f'可以继承{int(money*0.8)}元')
man = Man()
man.money()

扩展父类方法

第一种方式（推荐）：super().方法名()
第二种方式：super(子类名,self).方法名()
第三种方式：父类名.方法名()

class Father:def money(self):money = 10000print(f'继承款：{money}')
class Man(Father):def money(self):super().money()my_money = 20000print(f'存款：{my_money}')
man = Man()
man.money()

新式类
- 概念：继承object类或者该类的子类都是新式类。object类是所有对象的基类，提供了一些内置的属性和方法，可以使用dir查看。在python3中，如果一个类没有继承任何类，则默认继承object类。
```
class A(object):pass
print(dir(object))
```

多继承

概念：子类可以拥有多个父类，并且具有所有父类的属性和方法。开发时应避免不同的父亲具有同名方法

class Father(object):def money(self):print('拥有一百万可以继承')
class Mother(object):def appearance(self):print('绝世容颜可以继承')def money(self):print('拥有一亿财产')
class Son(Father, Mother):pass
son = Son()
son.appearance()
# 多个父类中存在方法同名的情况时，调用第一个父类中的实例方法
son.money()
# python中内置的属性__mro__可以查看方法的搜索顺序
print(Son.__mro__)

弊端
- 容易引起冲突
- 代码设计复杂度增加

多态

概念：一个对象具有多种形态，在不同的使用环境中以不同的形态展示其功能，那我们就称该对象具有多态性。
前提条件：继承、重写
特点
1. 不关注对象的类型，关注对象具有的行为，也就是对象的实例方法是否同名。
2. 多态的好处可以增加代码的外部调用灵活度，让代码更加通用，兼容性比较强。
3. 不同的子类对象，调用相同的父类方法，会产生不同的执行结果。

class Animal(object):def shout(self):print('动物会叫')
class Cat(Animal):def shout(self):print('喵喵喵')
class Dog(Animal):def shout(self):print('汪汪汪')
cat = Cat()
dog = Dog()
cat.shout()
dog.shout()# 定义一个统一的接口，实现一种调用方式得到不同的执行结果
class Animal(object):def eat(self):print('我会干饭')
class Pig(Animal):def eat(self):print('我吃西瓜')
class Dog(Pig):def eat(self):print('我吃狗粮')
# test函数充当接口，以对象为变量，执行不同对象的eat方法
def test(obj):obj.eat()
animal = Animal()
test(animal)
pig = Pig()
test(pig)

静态方法

概念：静态方法内部没有实例属性和类属性。使用装饰器@staticmethod来标识静态方法，静态方法与类无关，即可以转换成函数使用。

格式

# 定义
class 类名:@staticmethoddef 方法名(形参):方法体
# 调用
类名.方法名(实参)
对象名.方法名(实参)

class Person(object):@staticmethoddef study(name):print(f'{name}会学习')
# 类访问
Person.study('bingbing')
# 对象访问
person = Person()
person.study('bingbing')

类方法

概念：类方法内部可以访问类属性，或者调用其他方法。使用装饰器@classmethod来标识类方法，类方法的第一个参数必须是类对象，一般以cls作为第一个参数。

class Person(object):hand = 2foot = 2_habit = '吃喝玩乐'# 类方法一般配合类属性使用@classmethoddef sleep(cls):# cls即类对象本身---Personprint(cls)# 当方法中使用类对象（如访问私有类属性）时，定义类方法。print('人类最喜欢%s' % cls._habit)
person = Person()
person.sleep()