Python—基础语法：类和对象（类、方法、属性、实例对象、初始化函数、继承）详细解析

在介绍详细方法之前，先附上各种方式的调用语法

类

类是函数包，可以接纳多个函数

class 智能机器人():             #定义类
    身高 = 168
    体重 = 44                  #定义属性值
    智商 = 198
    def 打招呼():              #定义方法
        print('主人你好！')
    def 卖萌():
        print('主人，求抱抱！')
    def 生气():
        print('主人，我要报警了！')

print('把类的属性打印出来：')
print(智能机器人.身高)         #类调用不同的属性值
print(智能机器人.体重)
print(智能机器人.智商)

智能机器人.打招呼()
智能机器人.卖萌()            #类调用不同的方法
智能机器人.生气()

#结果展示
把类的属性打印出来：
168
44
198
主人你好！
主人，求抱抱！
主人，我要报警了！

#调用类属性
class 智能机器人():
    身高 = 168
    体重 = 44
    智商 = 198
    def 打招呼():
        print('主人你好！')
    def 卖萌():
        print('主人，求抱抱！')
    def 生气():
        print('主人，我要报警了！')

    @classmethod        #声明类方法，只有声明之后，才能使用“智能机器人”这个类中的方法
    def 自报信息(cls):   #一定要传入参数cls
        print('主人，我的基础信息有：')
        print('身高：',cls.身高)       #cls.身高 则是在调用类属性
        print('体重：',cls.体重)
        print('智商：',cls.智商)
        print('啦啦啦啦，有没有很喜欢我')
智能机器人.自报信息()
智能机器人.打招呼()       #智能机器人这个类再调用不同的方法
智能机器人.卖萌()
智能机器人.生气()

#结果展示
主人，我的基础信息有：
身高： 168
体重： 44
智商： 198
啦啦啦啦，有没有很喜欢我
主人你好！
主人，求抱抱！
主人，我要报警了！

#调用类方法
class 成绩单():       #定义类
    @classmethod     #声明类方法
    def 录入成绩单(cls):
        cls.学生姓名 = input('请输入学生姓名：')
        cls.语文_成绩 = int(input('请输入语文成绩：'))
        cls.数学_成绩 = int(input('请输入数学成绩：'))

    @classmethod
    def 计算平均分(cls):
        平均分 = (cls.语文_成绩 + cls.数学_成绩)/2
        return 平均分       #因为此方法我们需要调用，所以用return返回结果便于后面的调用

    @classmethod
    def 评级(cls):
        平均分 = cls.计算平均分()        #类方法调用其他的方法
        if 平均分>=90:
            print(cls.学生姓名 + '的评级是：优')
        elif 平均分>= 80 and 平均分<90 :
            print(cls.学生姓名 + '的评级是：良')
        elif 平均分>= 60 and 平均分<80 :
            print(cls.学生姓名 + '的评级是：中')
        else:
            print(cls.学生姓名 + '的评级是：差')

成绩单.录入成绩单()
成绩单.评级()

#结果展示
请输入学生姓名：猫看见
请输入语文成绩：85
请输入数学成绩：76
猫看见的评级是：良

给类方法传参的方式

#外部参数
class 加100类():
    def 加100函数(参数):
        总和 = 参数 + 100
        print('计算结果如下：')
        print(总和)
参数 = 1              #外部参数
加100类.加100函数(参数)

#结果展示
计算结果如下：
101

#内部参数
class 加100类():
    def 加100函数(参数):
        总和 = 参数 + 100
        print('计算结果如下：')
        print(总和)
    参数 = 1              #内部参数     
加100类.加100函数(参数)

#结果展示
计算结果如下：
101

#示例二
#内部参数
class 智能机器人():
    身高 = 168
    体重 = 44
    智商 = 198
    
    @classmethod
    def 自报信息(cls):
        print('主人，我的基础信息有：')
        print('身高：',cls.身高)      #内部参数
        print('体重：',cls.体重)
        print('智商：',cls.智商)
        print('啦啦啦啦，有没有很喜欢我')
智能机器人.自报信息()

#结果展示
主人，我的基础信息有：
身高： 168
体重： 44
智商： 198
啦啦啦啦，有没有很喜欢我

#同时传入内部和外部参数
class 加100类():
    变量 = 100       
    
    @classmethod
    def 加100函数(cls,参数):
        总和 = cls.变量 + 参数
        print('加100函数计算结果如下：')
        print(总和)

参数 = int(input('请输入一个整数：'))
加100类.加100函数(参数)

#结果展示
请输入一个整数：25
加100函数计算结果如下：
125

增加/修改类属性

#从外部修改类属性
变量1 = 15
变量2 = 'abc'

class 类A():
    变量1 = 100
    
变量1 = 类A.变量1
类A.变量2 = 变量2

print(类A.变量1)      
print(类A.变量2)

#结果展示
100
abc

#从内部修改/增加类属性
class 类():          #定义类
    @classmethod          #声明类方法
    def 增加类属性(cls):     
        cls.变量 = input('请随意输入字符串：')    #从内部增加属性   

类.增加类属性()                    #调用类方法

print('打印新增的类属性：')
print(类.变量)                  #调用属性并打印出来

#结果展示
请随意输入字符串：猫看见
打印新增的类属性：
猫看见

类的实例对象

实例属性和类属性

#实例属性与类属性完全相同
class 类():
    变量 = 100

实例1 = 类() # 实例化
实例2 = 类() # 实例化

print(类.变量)
print(实例1.变量)  
print(实例2.变量)

#结果展示
100
100
100

#修改或者新增类属性，实例属性也会跟着改变
class 类():
    变量 = 100

实例1 = 类() # 实例化
实例2 = 类() # 实例化
print(实例1.变量)
print(实例2.变量)

类.变量 = 'abc'   # 修改类属性
print(实例1.变量)   # 实例属性同步变化
print(实例2.变量)   # 实例属性同步变化

#结果展示
100
100
abc
abc

#实例属性的修改并不会影响到类属性
class 类():
    变量 = 100

实例1 = 类() # 实例化
实例2 = 类() # 实例化

print('原先的类属性：')
print(类.变量)
print('原先的实例1属性：')
print(实例1.变量)
print('原先的实例2属性：')
print(实例2.变量)

实例1.变量 = 'abc'
print('--------修改实例1的属性后----------') 

print('现在的类属性：')
print(类.变量)
print('现在的实例1属性：')
print(实例1.变量)
print('现在的实例2属性：')
print(实例2.变量)

#结果展示
原先的类属性：
100
原先的实例1属性：
100
原先的实例2属性：
100
--------修改实例1的属性后----------
现在的类属性：
100
现在的实例1属性：
abc
现在的实例2属性：
100

新增实例属性，不能直接用类调取实例属性，因为增加实例属性不影响类

实例方法和类方法

#“重写类方法”分成两个步骤：第一个步骤是在类的外部写一个函数，第二个步骤是把这个新函数的名字赋值给类.原始函数
class 类():
    def 原始函数(self):
        print('我是原始函数！')

def 新函数(self):         #定义新方法
    print('我是重写后的新函数!')

a = 类()  # 实例化
a.原始函数()

# 用新函数代替原始函数，也就是【重写类方法】
类.原始函数 = 新函数

# 现在原始函数已经被替换了
a.原始函数()

#结果展示
我是原始函数！
我是重写后的新函数!

初始化函数

class 类():
    def __init__(self):        #写法是固定的
        print('实例化成功！')

实例 = 类()

#可以接受参数传递
class 成绩单():
    def __init__(self,学生姓名,语文_成绩,数学_成绩):       #定义初始化函数
        self.学生姓名 = 学生姓名
        self.语文_成绩 = 语文_成绩
        self.数学_成绩 = 数学_成绩

    def 打印成绩单(self):
        print(self.学生姓名 + '的成绩单如下：')
        print('语文成绩：'+ str(self.语文_成绩))
        print('数学成绩：'+ str(self.数学_成绩))
        
成绩单1 = 成绩单('张三',99,88)
成绩单2 = 成绩单('李四',64,73)       #传入参数
成绩单3 = 成绩单('王五',33,22)

成绩单1.打印成绩单()
成绩单2.打印成绩单()       #实例对象调用方法
成绩单3.打印成绩单()

#结果展示
张三的成绩单如下：
语文成绩：99
数学成绩：88
李四的成绩单如下：
语文成绩：64
数学成绩：73
王五的成绩单如下：
语文成绩：33
数学成绩：22

类的继承（父类，子类）

百分百继承父类的方法

class 父类():
    def __init__(self,参数):
        self.变量 = 参数

    def 打印属性(self):
        print('变量的值是：')
        print(self.变量)

class 子类(父类):     #继承
    pass  # pass语句代表“什么都不做”

子类实例 = 子类(2)
子类实例.打印属性()
print('---------此处是分界线----------')
父类实例 = 父类(3)
父类实例.打印属性()

#结果展示
变量的值是：
2
---------此处是分界线----------
变量的值是：
3

在继承的基础上新增方法

class 基础机器人():
    def __init__(self,参数):
        self.姓名 = 参数

    def 自报姓名(self):
        print('我是' + self.姓名 + '！')     

    def 卖萌(self):
        print('主人，求抱抱！')

class 高级机器人(基础机器人):       #继承
    def 高级卖萌(self):          #新增方法
        print('主人，每次想到怎么欺负你的时候，就感觉自己全身biubiubiu散发着智慧的光芒！')

安迪 = 高级机器人('安迪')

安迪.自报姓名()
安迪.卖萌()
安迪.高级卖萌()

#结果展示
我是安迪！
主人，求抱抱！
主人，每次想到怎么欺负你的时候，就感觉自己全身biubiubiu散发着智慧的光芒！

覆盖父类方法

class 基础机器人():
    def __init__(self,参数):
        self.姓名 = 参数

    def 自报姓名(self):
        print('我是' + self.姓名 + '！')     

    def 卖萌(self):
        print('主人，求抱抱！')

class 高级机器人(基础机器人):
    def 自报姓名(self):         #覆盖父类的方法
        print('我是高级机器人' + self.姓名 + '!')

    def 卖萌(self):
        print('主人，每次想到怎么欺负你的时候，就感觉自己全身biubiubiu散发着智慧的光芒！')

安迪 = 高级机器人('安迪')
安迪.自报姓名()
安迪.卖萌()

#结果展示
我是高级机器人安迪!
主人，每次想到怎么欺负你的时候，就感觉自己全身biubiubiu散发着智慧的光芒！

多重继承

class 基础机器人():
    def 卖萌(self):
        print('主人，求抱抱！')
 # 注：因为多重继承要求父类是平等的关系，所以这里的“高级机器人”没有继承“基础机器人”
class 高级机器人(): 
    def 高级卖萌(self): 
        print('主人，每次想到怎么欺负你的时候，就感觉自己全身biubiubiu散发着智慧的光芒！')
class 超级机器人(基础机器人,高级机器人):     #多重继承
    def 超级卖萌(self): 
        print('pika, qiu!')
      
皮卡 = 超级机器人()
皮卡.卖萌()
皮卡.高级卖萌()
皮卡.超级卖萌()

#结果展示
主人，求抱抱！
主人，每次想到怎么欺负你的时候，就感觉自己全身biubiubiu散发着智慧的光芒！
pika, qiu!