1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 作业
class Person(object):
    def __init__(self, _name, _height, _weight, _gender):
        self.name = _name
        self.height = _height
        self.weight = _weight
        self.gender = _gender
        self.count_update = 0

    def get_bmi(self):
        bmi = sel.weight / (self.height**2)
        return bmi

    def rename(self, _name):
        if self.name == _name:
            pass
        else:
            self.name = _name
            self.count_update += 1


me = Person('zzzABC', 1.75, 65, 'Male')
print(me.name)
me.rename('zzzABC')
me.rename('kkkABC')
print('========= After Update ===========')
print(me.name)
print(me.count_update)

1
2
3
4

zzzABC
========= After Update ===========
kkkABC
1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

class People(object):
    # 定义类属性count_people，与所有对象共享
    count_people = 0

    # 创建对象时的初始化操作
    def __init__(self, _name):
        # 定义对象属性name
        self.name = _name
        People.count_people += 1

    # 删除对象时的操作
    def __del__(self):
        People.count_people -= 1


me = People('Yjcps')
print(me.name)
print(me.count_people)
print()

friend = People('Tom')
print(friend.name)
print(friend.count_people)
print(me.count_people)
print()

del friend
print(me.count_people)
print()

del me
print(People.count_people)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

Yjcps
1

Tom
2
2

1

0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

class Triangle(object):
    def __init__(self, a, b, c):
        self._a = a
        self._b = b
        self._c = c

    # 静态方法，通过装饰器@staticmethod定义，静态方法属于类方法
    @staticmethod
    def is_valid(a, b, c):
        return a + b > c and b + c > a and a + c > b

    # 类方法使用装器@classmethod定义，cls 表示类本身
    @classmethod
    def create_by_default(cls):
        a = 3
        b = 4
        c = 5
        return cls(a, b, c)

    # 对象的方法，self表示对象本身
    def perimeter(self):
        return self._a + self._b + self._c


# 检查是否可以构成三角形
if Triangle.is_valid(1, 2, 3):
    t1 = Triangle(1, 2, 3)
else:
    print("Can't creat a Triangle")

# 通过类方法创建默认的三角形
t2 = Triangle.create_by_default()

# 通过对象的方法计算三角形的周长
print('perimeter:', t2.perimeter())

1
2

Can't creat a Triangle
perimeter: 12

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

import abc


class Shape(object):
    def __init__(self, _name):
        self.name = _name

    # 定义没有（可能无法）实现的方法，需要在子类中改写此方法
    @abc.abstractmethod
    def perimeter(self):
        '''Method should be rewrited'''


t1 = Shape('Shape')
t1.perimeter()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

import abc


# 定义父类（基类）
class Shape(object):
    def __init__(self, _name):
        self.name = _name

    # 定义没有（可能无法）实现的方法，需要在子类中改写此方法
    @abc.abstractmethod
    def perimeter(self):
        '''Method should be rewrited'''


# 定义子类 继承Shape类
class Triangle(Shape):
    def __init__(self, a, b, c):
        # 调用父类的初始化方法
        Shape.__init__(self, 'Triangle')

        self._a = a
        self._b = b
        self._c = c

    # 在子类中改写perimeter方法
    def perimeter(self):
        return self._a + self._b + self._c


t1 = Triangle(3, 4, 5)
print(t1.name)
print(t1.perimeter())

1
2

Triangle
12

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class Square(Shape):
    def __init__(self, a):
        # 调用父类的初始化方法
        Shape.__init__(self, 'Square')
        self._a = a

    # 在子类中改写perimeter方法

    def perimeter(self):
        return self._a**2


t1 = Triangle(3, 4, 5)
s1 = Square(5)

# 不同的类可以有相同名字的方法，它们的行为可以不同，这就是多态。
print(t1.perimeter())
print(s1.perimeter())

1
2

12
25