Python 面向对象基础补充

类是模板，实例是根据类创建的对象

定义一个Square类

class Square:  # 定义一个正方形类
    angle = 90 # 类属性，正文形内角
    def __init__(self,length):
        self.length_value = length  # 实例属性， 边长
    def get_perimeter(self):   # 实例方法，周长
        p = self.length_value * 4
        return p
    def get_acreage(self): # 实例方法， 面积
        s = self.length_value ** 2
        return s

• angle 属于类属性，即所有正方形共有的特性；
• self.length_value 为实例属性，类实例化后归该实例所有，不同的实例这个 self.length_value 的值也不同（因为实例化Square类时，传入的length参数的值是不同的）；
• def get_perimeter(self)、def get_acreage(self) 两个方法都为实例方法，类实例化后可调用；

在类外部实现类属性的访问（即在类外部获取到 angle 的值）

class Square:  # 定义一个正方形类
    angle = 90 # 类属性，正文形内角
    def __init__(self,length):
        self.length_value = length  # 实例属性， 边长
    def get_perimeter(self):   # 实例方法，周长
        p = self.length_value * 4
        return p
    def get_acreage(self): # 实例方法， 面积
        s = self.length_value ** 2
        return s
# 方法一
angle_value_01 = Square.angle  # 在类的外部访问 angle 这个类属性，通过 类名.属性名 实现
print(angle_value_01)
# 方法二
small_square = Square(3)   # 在类外部首先实例化一个length=3的实例 small_square
angle_value_02 = small_square.angle # 通过 实例.属性名 实现访问
print(angle_value_02)

在类内部实例方法中实现类属性的访问（即在类内部实例方法中获取到 angle 的值）

class Square:  # 定义一个正方形类
    angle = 90 # 类属性，正文形内角
    def __init__(self,length):
        self.length_value = length  # 实例属性， 边长
    def get_perimeter(self):   # 实例方法，周长
        p = self.length_value * 4
        return p
    def get_acreage(self): # 实例方法， 面积
        s = self.length_value ** 2
        return s
    '''在类内部获取 类属性angle 的两种方法'''
    def get_twoAngle_sum01(self): # 实例方法，两个内角的和
        sum = self.angle * 2  # 在实例方法中访问类属性angle，可通过self.angle访问获取到值
        return sum
    def get_twoAngle_sum02(self): # 实例方法，两个内角的和
        sum = Square.angle * 2  # 在实例方法中访问类属性angle，还可通过 类名.angle访问获取到值
        return sum

在类外部实现实例属性的访问（即在类外部获取到 self.length_value 的值）

class Square:  # 定义一个正方形类
    angle = 90 # 类属性，正文形内角
    def __init__(self,length):
        self.length_value = length  # 实例属性， 边长
    def get_perimeter(self):   # 实例方法，周长
        p = self.length_value * 4
        return p
    def get_acreage(self): # 实例方法， 面积
        s = self.length_value ** 2
        return s
# 访问实例属性，必须实例化类后才能访问，不能通过类名直接访问
small_square = Square(3)   # 在类外部首先实例化一个length=3的实例 small_square
length_value01 = small_square.length_value # 通过 实例.属性名 实现访问
length_value02 = Square(3).length_value # 该方法与上面 small_square.length_value 等价
print(length_value01)
print(length_value02)

在类外部实现实例方法的调用（即在类外部调用 get_perimeter( )）

class Square:  # 定义一个正方形类
    angle = 90 # 类属性，正文形内角
    def __init__(self,length):
        self.length_value = length  # 实例属性， 边长
    def get_perimeter(self):   # 实例方法，周长
        p = self.length_value * 4
        return p
    def get_acreage(self): # 实例方法， 面积
        s = self.length_value ** 2
        return s
# 调用实例方法，必须实例化类后才能调用，不能通过类名直接调用
small_square = Square(3)   # 在类外部首先实例化一个length=3的实例 small_square
perimeter01 = small_square.get_perimeter() # 通过 实例.方法名 实现调用
perimeter02 = Square(3).get_perimeter() # 该方法与上面 small_square.get_perimeter() 等价
print(perimeter01)
print(perimeter02)

在类内部实例方法中对实例方法的调用（即在类内部的实例方法中调用 get_perimeter( )）

class Square:  # 定义一个正方形类
    angle = 90 # 类属性，正文形内角
    def __init__(self,length):
        self.length_value = length  # 实例属性， 边长
    def get_perimeter(self):   # 实例方法，周长
        p = self.length_value * 4
        return p
    def get_acreage(self): # 实例方法， 面积
        s = self.length_value ** 2
        return s
    '''该方法实现获取两倍周长，通过调用实例方法self.get_perimeter()来计算处理'''
    def get_double_perimeter(self): # 实例方法，获取2倍的周长
        double_p = self.get_perimeter()*2
        return double_p

类方法：在类内部，由@classmethod装饰，第一个参数是cls的方法

class Square:  # 定义一个正方形类
    angle = 90 # 类属性，正方形内角
    def __init__(self,length):
        self.length_value = length  # 实例属性， 边长
    def get_perimeter(self):   # 实例方法，周长
        p = self.length_value * 4
        return p
    def get_acreage(self): # 实例方法， 面积
        s = self.length_value ** 2
        return s
    '''在类内部，用@classmethod装饰，第一个参数为cls的方法为类方法'''
    @classmethod
    def get_twoAngle_sum01(cls): # 类方法，两个内角的和
        sum = cls.angle * 2  # 在类方法中访问类属性angle，可通过 cls.angle访问获取到值
        return sum
    @classmethod
    def get_twoAngle_sum02(cls): # 类方法，两个内角的和
        sum = Square.angle * 2  # 在类方法中访问类属性angle，也可通过 Square.angle访问获取到值
        return sum

在类外部调用类方法
1、通过实例调用类方法， 实例.类方法；
2、通过类名调用类方法， 类名.类方法；

class Square:  # 定义一个正方形类
    angle = 90  # 类属性，正方形内角
    def __init__(self, length):
        self.length_value = length  # 实例属性， 边长
    def get_perimeter(self):  # 实例方法，周长
        p = self.length_value * 4
        return p
    def get_acreage(self):  # 实例方法， 面积
        s = self.length_value ** 2
        return s
    @classmethod
    def get_twoAngle_sum01(cls):  # 类方法，两个内角的和
        sum = cls.angle * 2  # 在类方法中访问类属性angle，可通过 cls.angle访问获取到值
        return sum
    @classmethod
    def get_twoAngle_sum02(cls):  # 类方法，两个内角的和
        sum = Square.angle * 2  # 在类方法中访问类属性angle，也可通过 Square.angle访问获取到值
        return sum
s1 = Square(3)
sum_01 = s1.get_twoAngle_sum01()   # 通过实例调用类方法， 实例.类方法
sum_02 = Square.get_twoAngle_sum01() # 通过类名调用类方法， 类名.类方法
print(sum_01)
print(sum_02)

试一下：sum_03 = Square（3）.get_twoAngle_sum01() 是否也能实现调用类方法？
在类内部调用类方法
通过类名调用类方法， 类名.类方法

class Square:  # 定义一个正方形类

    angle = 90  # 类属性，正方形内角

    def __init__(self, length):
        self.length_value = length  # 实例属性， 边长

    def get_perimeter(self):  # 实例方法，周长
        p = self.length_value * 4
        return p

    def get_acreage(self):  # 实例方法， 面积
        s = self.length_value ** 2
        sum02 = Square.get_twoAngle_sum02()
        return s,sum02

    @classmethod
    def get_twoAngle_sum01(cls):  # 类方法，两个内角的和
        sum = cls.angle * 2  # 在类方法中访问类属性angle，可通过 cls.angle访问获取到值
        sum02 = Square.get_twoAngle_sum02()
        return sum,sum02

    @classmethod
    def get_twoAngle_sum02(cls):  # 类方法，两个内角的和
        sum = Square.angle * 2  # 在类方法中访问类属性angle，也可通过 Square.angle访问获取到值
        return sum

静态方法：在类内部，用@staticmethod装饰，第一个参数无要求

class Square:  # 定义一个正方形类

    angle = 90  # 类属性，正方形内角

    def __init__(self, length):
        self.length_value = length  # 实例属性， 边长

    def get_perimeter(self):  # 实例方法，周长
        p = self.length_value * 4
        return p

    def get_acreage(self):  # 实例方法， 面积
        s = self.length_value ** 2
        sum02 = Square.get_twoAngle_sum02()
        return s,sum02

    @classmethod
    def get_twoAngle_sum01(cls):  # 类方法，两个内角的和
        sum = cls.angle * 2  # 在类方法中访问类属性angle，可通过 cls.angle访问获取到值
        sum02 = Square.get_twoAngle_sum02()
        return sum,sum02

    @classmethod
    def get_twoAngle_sum02(cls):  # 类方法，两个内角的和
        sum = Square.angle * 2  # 在类方法中访问类属性angle，也可通过 Square.angle访问获取到值
        return sum
    '''通过@staticmethod装饰的方法，为静态方法'''
    @staticmethod
    def get_total_angle(): # 类静态方法， 返回内角总和
        total_angle = Square.angle * 4 # 在类静态方法中访问类属性angle, 可通过 Square.angle 访问获取到值
        return total_angle

在类外部，调用静态方法
跟类方法调用方法一致
1、通过实例调用类方法， 实例.类方法；
2、通过类名调用类方法， 类名.类方法；

class Square:  # 定义一个正方形类

    angle = 90  # 类属性，正方形内角

    def __init__(self, length):
        self.length_value = length  # 实例属性， 边长

    def get_perimeter(self):  # 实例方法，周长
        p = self.length_value * 4
        return p

    def get_acreage(self):  # 实例方法， 面积
        s = self.length_value ** 2
        sum02 = Square.get_twoAngle_sum02()
        return s,sum02

    @classmethod
    def get_twoAngle_sum01(cls):  # 类方法，两个内角的和
        sum = cls.angle * 2  # 在类方法中访问类属性angle，可通过 cls.angle访问获取到值
        sum02 = Square.get_twoAngle_sum02()
        return sum,sum02

    @classmethod
    def get_twoAngle_sum02(cls):  # 类方法，两个内角的和
        sum = Square.angle * 2  # 在类方法中访问类属性angle，也可通过 Square.angle访问获取到值
        return sum
    '''通过@staticmethod装饰的方法，为静态方法'''
    @staticmethod
    def get_total_angle(): # 类静态方法， 返回内角总和
        total_angle = Square.angle * 4 # 在类静态方法中访问类属性angle, 可通过 Square.angle 访问获取到值
        return total_angle


s1 = Square(5)   # 实例化一个边长为5的正方形
total_angle_01 = s1.get_total_angle()  # 通过实例调用静态方法， 实例.静态方法
total_angle_02 = Square.get_total_angle() # 通过类名调用静态方法， 类名.静态方法
print(total_angle_01)
print(total_angle_02)

在类内部，调用静态方法
通过类名调用静态方法， 类名.静态方法

class Square:  # 定义一个正方形类

    angle = 90  # 类属性，正方形内角

    def __init__(self, length):
        self.length_value = length  # 实例属性， 边长

    def get_perimeter(self):  # 实例方法，周长
        p = self.length_value * 4
        sum02 = Square.get_twoAngle_sum02()
        return p, sum02

    def get_acreage(self):  # 实例方法， 面积
        s = self.length_value ** 2
        sum02 = Square.get_twoAngle_sum02()
        total_angle = Square.get_total_angle() # 通过 类名.静态方法 进行调用
        return s,sum02, total_angle

    @classmethod
    def get_twoAngle_sum01(cls):  # 类方法，两个内角的和
        sum = cls.angle * 2  # 在类方法中访问类属性angle，可通过 cls.angle访问获取到值
        sum02 = Square.get_twoAngle_sum02()
        total_angle = Square.get_total_angle() # 通过 类名.静态方法 进行调用
        return sum,sum02, total_angle

    @classmethod
    def get_twoAngle_sum02(cls):  # 类方法，两个内角的和
        sum = Square.angle * 2  # 在类方法中访问类属性angle，也可通过 Square.angle访问获取到值
        return sum
    '''通过@staticmethod装饰的方法，为静态方法'''
    @staticmethod
    def get_total_angle(): # 类静态方法， 返回内角总和
        total_angle = Square.angle * 4 # 在类静态方法中访问类属性angle, 可通过 Square.angle 访问获取到值
        return total_angle