[toc]
把一些具有共同特征的对象的属性和行为（方法）抽取出来，将其抽象化，定义为类。
也就是说类是对象的模板，按照模板（类）实例化（具体化），这就是对象。
类是抽象的概念，而对象是具体的东西。
类的属性和方法都是一群对象的共同特征。
属性是那些对象的静态特征，在类中定义的变量。
方法是那些对象的动态特征（行为），在类中定义的函数。
这么说也不太准确，有些类中的有些方法和属性是关于类的，而与对象无关系。
通过定义类，实现了对数据和对数据的操作的封装。
# 作业
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)
zzzABC
========= After Update ===========
kkkABC
1
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)
Yjcps
1
Tom
2
2
1
0
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())
Can't creat a Triangle
perimeter: 12
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()
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())
Triangle
12
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())
12
25
