Python- classes and objects (classes, methods, attributes, the object instance initialization function, inheritance) detailed analysis

Copyright: Without permission, please do not reprint without permission! ! ! https://blog.csdn.net/weixin_44755148/article/details/90409177

Before introducing detailed methodology, we have enclosed the call syntax in various ways

class

Class is a function of the package, you may receive a plurality of functions

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
猫看见的评级是：良

To the class method parameter passing mode

#外部参数
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

Add / modify class attributes

#从外部修改类属性
变量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(类.变量)                  #调用属性并打印出来

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

Examples of object classes

Examples of attributes and class attributes

#实例属性与类属性完全相同
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

Examples of new properties, can not directly use the class instance attribute retrieval, because the increase does not affect the class instance attributes

Examples of methods and class methods

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

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

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

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

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

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

Initialization function

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

Inherited class (parent class, subclass)

Hundred percent of the parent class method inherited

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

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

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

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

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

New method on the basis of inheritance

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

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

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

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

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

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

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

The method of covering the parent

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

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

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

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

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

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

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

Multiple Inheritance

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

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