9月14日课后笔记
继承的简介
# 继承是面向对象的三大特性之一
# 通过继承我们可以使一个类获取其他类的属性和方法
# object是所有类的父类
# class Animal(object):
#
# def run(self):
# print('动物跑起来啦....')
#
# def sleep(self):
# print('动物睡觉.....')
#
# a = Animal()
# issubclass() # 检查一个类是不是另一个类的子类
# a.run()
# 需求 定义一个狗类
# 1.直接修改Animal这个类,在这个类中添加我们需要的功能
# 这种方式比较麻烦,并且会违反ocp原则
# 2.直接创建一个新的类
# 创建一个新类是比较麻烦的。并且需要大量的复制粘贴,会出现大量的重复代码
# class Dog:
#
# def run(self):
# print('狗跑起来啦....')
#
# def sleep(self):
# print('狗睡觉.....')
#
# def speak(self):
# print('旺旺旺....')
# 3.直接从Animal类中继承它的属性和方法
# 在定义类的时候,可以在类名的后面加上一个括号,这个括号中可以指定当前类的父类(超类、基类)
class Animal(object):
def run(self):
print('动物跑起来啦....')
def sleep(self):
print('动物睡觉.....')
a = Animal()
class Dog(Animal):
def speak(self):
print('旺旺旺....')
def run(self):
print('狗在跑....')
d = Dog()
print(d)
d.run()
d.sleep()
d.speak()
r = isinstance(d,Dog)
r = isinstance(d,Animal)
print(r)
print(issubclass(Dog,Animal))
print(issubclass(Animal,object))
print(issubclass(Dog,object))
"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/104.py"
<__main__.Dog object at 0x0062A0A0>
狗在跑....
动物睡觉.....
旺旺旺....
True
True
True
class Animal:
def run(self):
print('动物在跑......')
def sleep(self):
print('动物睡觉......')
class Dog(Animal):
def run(self):
print('狗在跑...')
d = Dog()
print(issubclass(Dog,Animal))
print(issubclass(Dog,object))
r = isinstance(d,Animal)
print(r)
s = isinstance(d,object)
print(s)
print(issubclass(Animal,object))
# isinstance()和issubclass()都是判断一个类是否是另一个类的子类,注意二者的用法,issubclass()要方便的多
"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/114.py"
True
True
True
True
True
方法的重写
# 重写/覆盖(override)
#如果在子类中有和父类同名的方法,则通过子类实例去调用方法时,会调用子类的方法而不是父类的方法,这个特点我们称之为方法的重写(覆盖)。当我们调用一个对象的方法时:会优先去当前对象中寻找是否具有该方法,如果有则直接调用,如果没有,则去当前对象的父类中寻找,如果父类中有则直接调用父类中的方法。如果没有,则去爷爷类中寻找,以此类推,直到找到object,如果依然没有找到就报错了
class A(object):
def test(self):
print('A......')
class B(A):
def test(self):
print('B......')
class C(B):
pass
c = C()
c.test()
"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/方法的重写.py"
B......
super()
super()可以获取当前类的父类,并且通过super()返回对象调用父类的方法时,不需要传递self
# 父类中所有的方法都会被子继承,包括特殊的方法
class Animal(object):
def __init__(self,name,sex):
self._name = name
self._sex = sex
@property
def sex(self):
return self._sex
@sex.setter
def sex(self):
self._sex = sex
@property
def name(self):
return self._name
# @name.setter
# def name(self,name):
# self._name = name
def run(self):
print('动物跑起来...')
def sleep(self):
print('动物睡觉...')
class Dog(Animal):
def __init__(self,name,age,sex):
# self._name = name
self._age = age
# self._sex = sex
# super()可以获取当前的父类
# Animal.__init__(self,name,sex)
super().__init__(name,sex)
def speak(self):
print('汪汪汪...')
def run(self):
print('狗在跑...')
@property
def age(self):
return self._age
@age.setter
def age(self,age):
self._age = age
d = Dog('二哈',5,'公')
print(d.name)
print(d.age)
print(d.sex)
"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/116.py"
二哈
5
公
多重继承
# 在Python中是支持多重继承的。也就是我们可以为一个类同时制定多个父类,可以在类名的()里面添加多个类,来实现多重继承。
# 多重继承,会使子类同时拥有多个父类,并且会获取到所有父类中的方法。在开发中没有特殊情况,应该尽量避免使用多重继承。因为多重继承会让我们的代码更加复杂
# 如果多个父类中有同名的方法,则会先在第一个父类中寻找,然后找第二个,找第三个...前面会覆盖后面的
# 类名.__bases__ 这个属性可以用来获取当前类的父类
class A(object):
def test(self):
print('A......')
class B(object):
def test(self):
print('B......')
# 可以在类名的()里面添加多个类,来实现多重继承
class C(B,A):
pass
c = C()
# print(C.__bases__)
c.test()
"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/多重继承.py"
(<class '__main__.B'>, <class '__main__.A'>)
B......
多态
# 多态是面向对象的三大特性之一。从字面理解就是多种形态,一个对象可以以不同形态去呈现。面向对象三大特性
# 封装 确保对象中数据的安全
# 继承 保证了对象的扩展性
# 多态 保证了程序的灵活性
class A:
def __init__(self,name):
self._name = name
@property
def name(self):
return self._name
@name.setter
def name(self,name):
self._name = name
class B:
def __init__(self, name):
self._name = name
def __len__(self):
return 10
@property
def name(self):
return self._name
@name.setter
def name(self, name):
self._name = name
class C:
pass
a = A('张同学')
b = B('彭同学')
c = C()
# 定义一个函数 这种形式就是一个多态
def speak(obj):
print('你好%s'%obj.name)
speak(b)
# 这种形式就违反了一个多态的原则
def speak2(obj):
# 类型检查
if isinstance(obj,A):
print('你好%s'%obj.name)
speak2(a)
# __len__
# lst = [1,2,3]
# s = 'python'
# print(len(lst))
# print(len(b))
# 面向对象的三大特性
# 1.封装 确保对象中数据的安全
# 2.继承 保证了对象的可扩展性
# 3.多态 保证了程序的灵活性
# 多态 中国人 老外 非洲人
"F:\python exerciese\venv\Scripts\python.exe" "F:/python exerciese/多态.py"
你好彭同学
你好张同学
属性和方法
class A:
# 类属性,直接在类中定义的属性就是类属性
# 类属性可以通过类对象和实例对象来访问
# 类属性只能通过类对象来修改,不能通过实例对象来修改
count = 0
def __init__(self):
# 实例属性,通过实例对象添加的属性是实例属性
# 实例属性只能通过实例对象来访问和修改,类对象无法访问和修改
self.name = '张同学' # name是实例属性
# 实例方法
def test(self):
print('这个是test方法')
# 类方法
# 在类的内部使用@classmethod修饰的方法属于类方法
# 类方法的第一个参数是cls,也会自动传递,cls表示就是当前的类对象
@classmethod
def test2(cls):
print('这个是test2方法',cls)
print(cls.count)
# 静态方法
# 在类中被@staticmethod来修饰的方法属于静态方法
@staticmethod
def test3():
print('这个是test3方法')
# test3(self)中的self变灰色,是不可用状态,所以小括号中为空,如果小括号中有灰色的self,就会报错
a = A()
# 实例属性,通过实例对象添加的属性是实例属性
# a.count = 10
# A.count = 10
# print('A',A.count)
# print('a',a.count)
# print('a',a.name)
# print('A',A.name)
# a.test()
# A.test(a)
# a.test()等价于A.test(a)
# A.test2()
# a.test2()
# A.test2()等价于a.test2()
# A.test3()
# a.test3()
# 类属性
# 实例属性
# 实例方法
# 类方法
# 静态方法