9月14日课后笔记

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()
# 类属性
# 实例属性
# 实例方法
# 类方法
# 静态方法