python学习7__面向对象2_python 定义一个外部函数,参数是两个human的对象,实现两个对象比年龄大小,并输出-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_42267191/article/details/104179484

本文深入讲解面向对象编程的三大特性：封装、继承和多态。详细解析继承关系、多继承、多层继承的概念及实现方式，同时介绍了成员方法、类方法、静态方法的区别，以及类属性和对象属性的特点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

# 查看继承关系图
s = Son()
# 通过类名
print(Son.__mro__)
# object所有类的父类
print(Son.__mro__)

class A(object):
    pass

面向对象三大特征

封装

继承

•继承指的是一个对象直接使用另一个对象的属性或方法

调用父类中重写的方式：

•第一种方式:通过: 父类名.方法名(self)

•第二种方式: super(当前类名,self).方法名()

•第三种方式: super().方法名() 只支持python3

class Father:
    def sayHello(self):
        print('同志好')

class Son(Father):
    def sayHello(self):
        # 执行父类中sayHllo这个方法
        super().sayHello()
        # 再执行自己的方法
        print('hello')

s = Son()
s.sayHello()

init和属性继承问题：

•继承之后,就默认继承了父类中公有的属性,子类中可以直接使用,也可以修改

•子类复写init方法之后,就不能再使用父类init中定义的成员属性了

•如果重写init方法后还要使用父类的成员属性,就需要在init方法中调用父类的init方法

class Father:
    def __init__(self,name,age):
        print('调用了Father的init方法')
        self.name = name
        self.age = age

class Son(Father):
    def __init__(self,name,age,phone):
        # 调用父类的init方法
        super(Son, self).__init__(name,age) #注意！这里父类属性是外部输入的，这里init之后要输入参数
        self.phone = phone

s = Son('张三',30,'1343534')

print(s.name)
print(s.age)
print(s.phone)

多继承：class 子类(父类1,父类2…)

多继承方法和属性总结：

1.多继承可以直接使用多个父类中的方法

2.多继承中,子类没有成员属性,如果多个父类都有成员属性,只能使用前一个父类的成员属性

3.多继承中,子类没有成员属性,如果只有一个父类有成员属性,不论继承的顺序,都能使用这个成员属性

4.如果需要使用所有父类的成员属性,需要重写init方法,调用多个父类的init方法

class Mother:
    def __init__(self):
        self.money = 100000
    def cook(self):
        print('会做饭')

class Father:
    def __init__(self):
        self.wage = 10000
        self.money = 1
    def makeMoney(self):
        print('会赚钱')
# 创建Son类
class Son(Father,Mother):
    def __init__(self):  #这里重新定义的属性，若不进行下面的引用，父类中的属性被覆盖
      
        # 继承链下一个类，这里不能用
        # super(Son, self).__init__()
        # 调用Father 的init  这里不能用
        # super().__init__()
        # 调用Mother 的init   这里不能用
        # super().__init__()
        Father.__init__(self)  #只能用这种方式，出现同名的方法用类似方式进行调用
        Mother.__init__(self)  #若出现同名属性，执行下一个继承链的名字属性
        self.email = ''
# 创建son对象
s = Son()
s.cook()
s.makeMoney()
print(Son.__mro__)
# 访问money
print(s.money)       #输出妈妈的100000而不是爸爸的1
print(s.wage)
'''
输出：
会做饭
会赚钱
(<class '__main__.Son'>, <class '__main__.Father'>, <class '__main__.Mother'>, <class 'object'>)
100000
10000
'''

多层继承：

•多层继承可以访问所有父类中公共的方法和属性

# 定义爷爷类
class GrandFather:
    def __init__(self):
        self.name = '爷爷'
        self.age = 80

    def smoke(self):
        print('爷爷抽烟')
    def drink(self):
        print('爷爷喝酒')
# 定义爸爸
class Father(GrandFather):
    def __init__(self):
        GrandFather.__init__(self)
        self.phone = '1324324'

    def smoke(self):
        print('爸爸抽烟')

    def drink(self):
        print('爸爸喝酒')

class Son(Father):
    def __init__(self):
        super(Son, self).__init__()
        self.email = '1232432@qq.com'

    def smoke(self):
        print('大头儿子抽烟')
s = Son()
print(s.name)
print(s.age)
print(s.phone)
print(s.email)
s.smoke()
s.drink()
'''
爷爷
80
1324324
1232432@qq.com
大头儿子抽烟
爸爸喝酒
'''

多态

作用：是一种思想

•不同的子类对象调用相同的父类方法，产生不同的执行结果，可以增加代码的外部调用灵活度

•多态以继承和重写父类方法为前提

•多态是调用方法的技巧，不会影响到类的内部设计

class Human:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    # 行为
    def eat(self):
        print('用树枝吃饭')
# 中国人
class ZhHuman(Human):
    def eat(self):
        print('用筷子吃饭')
# 美国人
class USAHuman(Human):
    def eat(self):
        print('用刀叉吃饭')
# 非洲人
class AfricaHuman(Human):
    def eat(self):
        print('用手吃饭')
#多态思想，一个函数，输入不同的对象会执行出不同的结果
def translate(human):
    '''传递一个具有吃饭功能的huamn'''
    human.eat()

# 创建四个对象
human = Human('元始天尊',1000)
zhHuman = ZhHuman('张三',30)
usaHuman = USAHuman('bill',40)
arHuman = AfricaHuman('tom',50)
###注意和下一部分区别，这个是不同对象调用的自己类里的eat函数
human.eat()
zhHuman.eat()
usaHuman.eat()
arHuman.eat()
###两部分执行结果一样
translate(human)
translate(zhHuman)
translate(usaHuman)
translate(arHuman)

类属性和对象属性

对象属性： •实例属性,通过对象名.属性名定义

•成员属性,通过self.属性名定义

访问只能通过对象或self.属性名，与类属性最容易搞混的差别

类属性：

class 类名:

类属性名=属性值

类属性注意：

1.如果有同名对象属性,实例对象会优先访问对象属性

2.类属性只能通过类修改,不能通过实例对象修改

总结：

在这里插入图片描述

'''总结:
类属性:可以通过对象访问  也可以通过类名访问
类属性只能通过类名.属性名修改
'''
class Dog:
    # 类属性
    type = '狗'
    def __init__(self,name):
        self.name = name
        self.type = '猫'


dog1 = Dog('旺财')
print(dog1.type)
print(Dog.type)
# 修改type
# 定义了一个实例属性
dog1.type = '中华田园犬'
print(dog1.type)

Dog.type = '中华田园犬'
print(Dog.type)
print(Dog.name)  #报错！！成员属性不可以用类名访问
'''
猫
狗
中华田园犬
中华田园犬
'''

成员方法，类方法和静态方法

成员方法：•在类中定义的普通方法就是成员方法,成员方法必须要通过对象实例来调用

类方法定义格式：

@classmethod

def 方法名(cls):

成员方法与类方法区别：

定义方式；访问方式：成员方法只能通过对象实例访问，类方法可以通过对象和类访问；方法参数：类方法参数是类cls，成员方法参数是成员self；访问属性：成员方法可以访问成员属性和类属性，类方法只能访问类属性

静态方法：

•需要通过@staticmethod来进行修饰，静态方法既不需要传递类对象也不需要传递实例对象（形参没有self/cls）

•静态方法也能够通过实例对象和类对象去访问

•静态方法可以访问类属性,不能访问对象属性

'''
1.定义工具类
2.工具类中checkName  checkPwd
  name:全是字母   长度3=20
  pwd:全是数字  3-20
'''
class Utils:
    @staticmethod
    def checkName(name):
        return name.isalpha() and (len(name)>=3 and len(name)<=20)
      
    @staticmethod
    def checkPwd(pwd):
        return pwd.isdecimal() and (len(pwd)>=3 and len(pwd)<=20)

print(Utils.checkName('wrewer'))   #TURE
print(Utils.checkPwd('1231243234'))  #TURE

枚举

引用

•引用就是变量指向数据存储空间的现象

•使用id(数据/变量)操作获取数据存储的内存空间引用地址

数字字符串布尔和元组的引用时的应用地址方式类似：

 b=2
 print(id(b))
 a = 2
 c=3
 print(id(a))  #a，b打印的引用地址相同,c不同。

列表，集合，字典的引用相似：

c = {1, 2, 3}
print(id(c))
d = {1, 2, 3}
c = {2, 3}
print(id(c))
print(id(d))  # 三次打印结果都不一样

可变类型和不可变类型

•所谓可变类型与不可变类型是指：数据能否直接进行修改，如果能直接修改那么就是可变，否则是不可变

在这里插入图片描述

默认参数不要使用可变类型

def func(a=[]):
    a.append(2)
    print(a)

func() #[2]
func()  #[2, 2]
func()  #[2, 2, 2]

is和==

•Python中对象包含的三个基本要素，分别是：id(身份标识)、type(数据类型)和value(值)

•==是python标准操作符中的比较操作符，用来比较判断两个对象的value(值)是否相等

•is也被叫做同一性运算符，这个运算符比较判断的是对象间的唯一身份标识，也就是id是否相同

isinstance()

语法格式:

isinstance(object,classinfo)

isinstance(对象,类) 用来判断对象是否属于这个类，返回bool值，一般用在if语句中