继承的概念：子类 自动拥有（继承） 父类 的所有 方法 和 属性 继承的语法
class 类名(父类名):
pass
- 子类继承自 父类，可以直接享受 父类中已经封装好的方法，不需要再次开发
- 子类中应该根据需求，封装子类特有的 属性和方法
- 当父类的方法实现不能满足子类需求时，可以对方法进行 重写(override)
class Person(object):
"""父类"""
def __init__(self, id, name=None):
self.id = id
self.name = name
def printInfo(self):
print(f'编号: {self.id} 姓名: {self.name}')
# 子类继承父类
class Student(Person):
pass
# 子类继承父类
class Teacher(Person):
pass
s1 = Student(111, "eric")
s1.printInfo()
父类和子类是一个相对概念
- 继承的好吹
不使用继承构造的Circle类和Rectangle类
import math
class Circle(object):
def __init__(self, color, r):
self.r = r
self.color = color
def area(self):
return math.pi * self.r * self.r
def show_color(self):
print(self.color)
class Rectangle(object):
def __init__(self, color, a, b):
self.color = color
self.a, self.b = a, b
def area(self):
return self.a * self.b
def show_color(self):
print(self.color)
circle = Circle('red', 3.0)
print(circle.area())
circle.show_color()
rectangle = Rectangle('blue', 2.0, 3.0)
print(rectangle.area())
rectangle.show_color()
- 重构鲁班打大龙
from random import randint
class Sprite():
def __init__(self, name, blood, strength):
self.name = name
self.blood = blood
self.strength = strength
def take_damage(self, sprite):
if isinstance(sprite, Hero):
print("Hero 类")
elif isinstance(sprite, Montser):
print("Montser 类")
damage = randint(sprite.strength - 5, sprite.strength + 5)
self.blood -= damage
print(f'{self.name} 你被 {sprite.name}攻击, 受到了{damage}点伤害!, 还剩{self.blood}滴血..')
if self.blood <= 0:
print(f'{self.name} 你被 {sprite.name}杀死了; 胜败乃兵家常事, 请重新来过!')
return True
else:
return False
class Hero(Sprite):
def __init__(self, name, blood, strength, skin = None):
super().__init__(name, blood, strength)
self.skin = skin
class Montser(Sprite):
pass
if __name__ == '__main__':
h1 = Hero("鲁班", 1000, 300)
m1 = Montser("大龙", 5000, 50)
while True:
is_moster_died = m1.take_damage(h1)
if is_moster_died:
break
is_hero_died = h1.take_damage(m1)
if is_hero_died:
break
类属性 类方法 静态方法
类对象：类名 实例对象：类创建的对象
类属性就是类对象所拥有的属性，它被所有类对象的实例对象所共有，在内存中只存在一个副本(只被初始化一次)，这个和C++、Java中类的静态成员变量有点类似。对于公有的类属性，在类外可以通过类对象(类名)和实例对象访问
class People(object):
nick_name = "Tom" #公有的类属性
__age = 19 #私有的类属性
id = 0
def __init__(self, name):
self.name = name
self.score = 0
self.score += 1
People.id += 1
p1 = People("张三")
p2 = People("李四")
print(p1.nick_name) # 实例对象访问类属性(不建议)
print(People.nick_name) # 类名访问类属性(建议)
print(People.id) # 2
print(p1.score) # 1
print(p2.score) #1
- 类方法
类对象所拥有的方法，需要用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数（当然可以用其他名称的变量作为其第一个参数，但是大部分人都习惯以’cls’作为第一个参数的名字），能够通过实例对象和类对象去访问。
class People(object):
nick_name = "Tom" #公有的类属性
__age = 19 #私有的类属性
id = 0
country = "china"
def __init__(self, name):
self.name = name
self.score = 0
self.score += 1
People.id += 1
@classmethod
def get_country(cls):
return cls.country
# 类方法一个用途就是可以对类属性进行修改：
@classmethod
def set_country(cls, country):
cls.country = country
def hello(self):
print("hello")
People.set_country('us')
print(People.get_country())
# print(People.hello()) 错误
- 静态方法
需要通过修饰器@staticmethod来进行修饰，静态方法不需要定义参数
class People(object):
nick_name = "Tom" #公有的类属性
__age = 19 #私有的类属性
id = 0
country = "china"
def __init__(self, name):
self.name = name
self.score = 0
self.score += 1
People.id += 1
# @classmethod
# def get_country(cls):
# return cls.country
# 错误 不需要参数
# @staticmethod
# def get_country(cls):
# return cls.country
@staticmethod
def get_country():
return People.country
# 类方法一个用途就是可以对类属性进行修改：
@classmethod
def set_country(cls, country):
cls.country = country
def hello(self):
print("hello")
People.set_country('us')
print(People.get_country())
# print(People.hello()) 错误
因为python中的列表不能完全代替数学中的向量运算, 我们自己实现一个线性代数的向量类
class Vector(object):
def __init__(self, lst):
self.__value = lst
def __str__(self):
# s = "("
# for i in range(len(self.__value)):
# if i== len(self.__value)-1:
# s += str(self.__value[i]) + ")"
# else:
# s += str(self.__value[i]) + ", "
# return "({})".format(", ".join([str(i) for i in self.__value]))
return f'({", ".join([str(i) for i in self.__value])})'
if __name__ == '__main__':
v1= Vector([i for i in range(1, 6)])
print(v1) # (1, 2, 3, 4, 5)
