一.课程安排

• 面向对象

二.课堂笔记

1.面向对象简介

• Python是一门面向对象的编程语言。

• 面向对象的编程语言，关注的是对象而不注重过程。

• 面向对象的编程思想，将所有功能/操作统一保存到对应的对象中，要使用某个功能，直接找到对应对象即可，一切皆对象。

• 这种编程方式比较容易阅读，并且易于维护，容易复用。但是编写的过程不太符合常规思维，编写相对麻烦

• 对象是内存中用来存储指定数据的一块区域，每个对象保存三种数据：id（标识）,type（类型）,value（值）

  • 在Cpython中，id就是内存地址
  • type用来标识当前对象所属的类型，类型就决定了对象有什么功能
  • value就是对象中存储的具体数据

• 对象分为：可变对象和不可变对象。不可变对象值不能改变，可变对象值可以改变。

• 面向过程

  • 面向过程是指将我们的程序分解为一个一个步骤，通过对每个步骤的抽象来完成程序
  • 这种编程方式往往只适用于一个功能，如果要实现别的功能，往往复用性比较低
  • 这种编程方式符合人类的思维，编写起来比较容易

2.类

• 我们目前学习的都是Python的内置对象，但是内置对象并不都能满足我们的需求，所以我们在开发中经常要自定义一些对象
• 类，简单理解它就是一个图纸，在程序中我们需要根据类来创建对象
• 类就是对象的图纸
• 我们也称对象是类的实例（instance）
• 如果多个对象是通过一个类创建的，我们称这些对象是一类对象

# 语法
class 类名（[父类]）:
pass

• 类的名字要使用大写字母开头，使用大驼峰命名法
• 类也是一个对象，是用来创建对象的对象

• 我们可以通过isinstance() 来检查一个对象是否是另一个类的实例

• 可以向对象（类）中添加变量，对象（类）中的变量称之为属性，语法：对象.属性=属性值
• 类是Type类型的对象，定义类实际上就是定义了一个type类型的对象

• 我们可以通过issubclass()检查一个类是否是另一个类的子类

• 我们可以通过bases 可以获取当前类所有的父类

  • 用法 类名.bases

例如：print(C.bases)

• 可以通过hasattr(对象，方法)来判断对象中是否含有某种方法

2.1 类的定义

• 类和对象都是对现实生活中事物的抽象
• 事物包含两部分：
  • 1.数据（属性）
  • 2.行为（方法）
• 调用方法：对象.方法()
• 方法调用和函数调用的区别：如果是函数调用，调用时有几个形参，就会传递几个实参。如果是方法调用，默认传递一个参数，所以方法中至少得有一个形参
• 在类代码块中，我们可以定义变量和函数
  • 变量会成为该类实例的公共属性，所有该实例都可以通过 对象.属性名 的形式访问
  • 函数会成为该类实例的公共方法，所有该实例都可以通过 对象.方法名 的形式访问

2.2 参数self

2.2.1 属性和方法

• 类中定义的属性和方法都是公共的，任何实例都可以访问
• 属性和方法的查找流程
  • 当我们调用一个对象的属性时，解析器会在当前的对象中寻找是否有该属性，如果有，则直接返回当前的对象的属性值。如果没有，则去当前对象的类对象中去寻找，如果有则返回类对象的属性值。如果没有就报错
• 类对象和实例对象中都可以保存属性（方法）
  • 如果这个属性（方法）是所有实例共享，则应该将其保存在类对象中
  • 如果这个属性（方法）是某个实例独有的，则应该保存到实例对象中
  • 一般情况下，属性保存到实例对象，方法保存到类对象

2.2.2 self

• 由来：
  • 方法每次被调用时,解析器都会自动传递一个参数
  • 这个参数,就是调用方法的本身
  • 如果是p1调用 第一个参数就是p1对象
  • 如果是p2调用 第一个参数就是p2对象
  • 一般习惯把这个参数命名为self
• self在定义时需要定义，在调用时会自动传入
• self的名字并不是规定死的，最好按照约定是用self
• self总是指调用时的实例对象

2.3 特殊方法

• 在类中可以定义一些特殊方法也称为魔术方法

• 特殊方法：_xxx_()

• 特定方法不需要我们调用，在特定时候自动调用

• 特殊方法会在特殊时刻自己调用

• _init_在实例对象创建以后执行

• 类中的代码块在init之前执行，并且不管实例化多少次，只执行一次

• 学习其它特殊方法

  • 1.特殊方法什么时候调用
  • 2.特殊方法有什么作用

• 实例对象的创建流程： p1 = Person()

  • 1.创建一个变量
  • 2.在内存中创建一个新的对象
  • 3.执行类中的代码块(只执行一次)
  • 4.init(self)方法执行了

# 类的基本结构:

class 类名([父类]):

    # 类属性
    a = 1
    b = 2
    # 实例方法
    def __init__(self,x,y,....):
        实例属性
        self.x=x
        self.y=y
        ......
    
    # 类方法
    def m1(self,....):
       
       代码块
       
    .......

2.4 封装

• 出现封装的原因：我们需要一种方式来增强数据的安全性
  • 属性不能随意修改(让你改你才能改)
  • 属性不能改为任意的值
• 封装是面向对象的三大特性之一
• 封装是指隐藏对象中一些不希望被外部所访问到的属性和方法
• 我们也可以提供一个getter()和setter()方法是外部可以访问到属性
  • getter()用来获取对象中指定的属性
  • setter()用来设置对象指定的属性
• 使用封装，增加了类定义的复杂程度，但是它也确保了数据的安全
  • 1. 隐藏属性名，使调用者无法随意的修改对象中的属性
  • 2. 增加了getter()和setter()，很好控制属性是否是只读的
  • 3. 使用setter()设置属性，可以增加数据的验证，确保数据的正确性
  • 4.使用getter()方法获取属性，使用setter()方法设置属性可以在读取属性和修改属性的同时做一些其他的处理
• 高级封装
  • 可以为对象的属性使用双下划线开头__xx。双下划线开头的属性，是对象的隐藏属性，隐藏属性只能在类的内部访问，无法通过对象访问
  • 其实隐藏 属性只不过是Python自动为属性改了一个名字-->类名_属性名 例如：__name-->_Person__name
  • 这种方式实际上依然可以在外部访问，所以这种方式我们一般不用。一般我们会将一些私有属性以_开头。
  • 一般情况下，使用以_开头的属性都是私有属性，没有特殊情况下，不要修改私有属性

2.5 Property装饰器

• 我们可以使用@property装饰器来创建只读属性，@property装饰器会将方法转换为相同名称的只读属性,可以与所定义的属性配合使用，这样可以防止属性被修改

3.继承

• 继承是面向对象三大特性之一
• 通过继承我们可以使用一个类获取到其他类中的属性和方法
• 在定义一个类时，可以在类名后面的括号中指定当前类的父类（超类，基类
• 继承提高了类的复用性。让类与类之间产生了关系。有了这个关系，才有了多态的特性
• 在创建类时，如果省略了父类，则默认父类为object
• object是所有类的父类，所有类都继承自object
• 所有的对象都是object的实例

4.方法重写

• 如果在子类中有和父类同名的方法，则通过子类实例去调该方法时，会调用子类的方法而不是父类的方法，这个特点我们称之为方法的重写(覆盖)
• 当我们调用一个对象方法时：
  • 会优先去当前对象中寻找是否具有该方法，如果有则直接调用
  • 如果没有，则去当前对象的父类中寻找，如果父类中有则直接调用父类中的方法
  • 如果没有，则去父类中的父类寻找，以此类推，直到找到object，如果依然没有找到就报错了

5.super()

• super()可以获取当前类的父类
• 并且通过super()返回对象调用父类方法时，不需要传递self

class Animal:

    def __init__(self,name):

        self._name = name

    def run(self):

        print('动物跑.....')

    def sleep(self):

        print('动物睡觉....')
    @property
    def name(self):

        return self._name
    @name.setter
    def name(self,name):
        self._name = name

# 父类中所有的方法都会被子类继承，包括特殊方法

class Dog(Animal):
        # 希望可以直接调用父类的__init__
        # Animal.__init__(self,name)       
    def __init__(self,name,age):  
        
        # 我希望有一种动态的方式来获取类的父类        
        # 通过super()可以直接获取当前类的父类
        super().__init__(name)
        # self._name = name
        self._age = age
    @property
    def age(self):

        return self._age
    @age.setter
    def age(self,age):
        self._age = age

    def run(self):

        print('狗跑.....')


    def speak(self):

        print('旺旺.....')


d = Dog('二哈',8) # __init__() missing 1 required positional argument: 'name'
d.name = '德牧'

print(d.name)
print(d.age)

6.多重继承

• 在Python中是支持多重继承。也就是我们可以为一个类同时制定多个父类
• 可以在类名的()后边添加多个类，来实现多重继承
• 多重继承，会使子类同时拥有多个父类，并且会获取到所有父类中的方法
• 在开发中没有特殊情况，应该尽量避免使用多重继承。因为多重继承会让我们的代码更加复杂
• 如果多个父类中有同名的方法，则会先在第一个父类中寻找，然后找第二个，找第三个...前面会覆盖后面的

7.多态

• 多态是面向对象的三大特性之一。从字面理解就是多种形态
• 一个对象可以以不同形态去呈现
• 经典例子：

# len() 获取长度 是因为这个对象中有一个特殊方法__len__
# 只要对象中有__len__特殊方法，就可以通过len()这个函数获取长度
class B:

    def __init__(self,name):

        self._name = name
    def __len__(self):
        return 100


    @property
    def name(self):

        return self._name
    @name.setter
    def name(self,name):

        self._name = name
b=B('钢铁侠')
# lst = [1,2,3]
# s = 'python'
# print(len(lst))
# print(len(s))
print(len(b)) # TypeError: object of type 'B' has no len()

# 如果在类B中增加了方法：def __len__(self): 
# 那么，我们就可以使用len()函数了
print(len(b)) 
>>>100

7.1 总结

• 面向对象三大特性：
  • 封装 确保对象中数据的安全
  • 继承 保证了对象的扩展性
  • 多态 保证了程序的灵活性

8.属性和方法

8.1 属性

• 属性分为类属性和实例属性
  • 类属性：直接在类中定义的属性
  • 类属性通过类或类的实例访问到。通过类对象来修改，无法通过实例对象修改
  • 实例属性： 通过实例对象添加的属性属于实例属性
  • 实例属性通过实例对象来访问和修改，类对象无法访问修改

8.2 方法

• 方法分为类方法和实例方法
  • 实例方法：在类中定义，以self为第一个参数的方法都是实例方法。实例方法在调用时,Python会将调用对象以self传入
  • 实例方法可以通过类对象和类实例去调用
  • 当通过实例调用时，会自动将当前调用对象作为self传入
  • 当通过类调用时，不会自动传递self，我们必须手动传递self
  • 类方法以@classmethod 来修饰的方法属于类方法
  • 类方法第一个参数是cls 也会自动被传递。cls就是当前的类对象
  • 类方法和实例方法的区别，实例方法的第一个参数是self，类方法的第一个参数是cls
  • 类方法可以通过类对象去调用，也可以通过实例对象去调用

8.3 静态方法

• 在类中用@staticmethod来修饰的方法属于静态方法
• 静态方法不需要指定任何的默认参数，静态方法可以通过类对象和实例对象调用
• 静态方法，基本上是一个和当前类无关的方法，它只是一个保存到当前类中的函数
• 静态方法一般都是些工具方法，和当前类无关

三.作业