Python 笔记：全网最详细最小白的Class类和实例详解

面向对象最重要的概念就是类（class）和实例（instance），类是抽象，而实例（Instance）则是一个个具体的对象
面向对象三大特点：封装、继承和多态

class Animal(object):
    def __init__(self, name):
        self.name = name     # 初始化类变量
    def Dog(self):   # 创建类中的方法
        print(self.name)

一、基本概念

1.1 概念

类(Class):

• 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

类变量：

• 类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

数据成员：

• 类变量或者实例变量, 用于处理类及其实例对象的相关的数据。

方法重写：

• 如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

局部变量：

• 定义在方法中的变量，只作用于当前实例的类。

实例变量：

• 在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。

继承：

• 即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。

实例化：

• 创建一个类的实例，类的具体对象。

方法：

• 类中定义的函数。

对象：

• 通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

1.2 代码实例

# -*- coding: utf-8 -*-
"""
  1、全局变量：在模块内、在所有函数外面、在class外面，这就是全局变量。
  2、局部变量：在函数内、在class的方法内（未加self修饰的) ,这就是局部变量
  3、静态变量：在class内的，但不在class的方法内的，这就是静态变量
  4、实例变量：在class的方法内的，用self修饰的变量，这就是实例变量

"""

Global_Variable = "我是全局变量"


class ExampleClass(object):
    Class_static_variable = "我是类静态变量"  # 静态变量

    def __init__(self, Instance_Variable):  # 构造函数,sel代表对象，有Instance_Variable属性
        self.Instance_Variable = Instance_Variable  # 实例变量

    def study_example(self):
        Local_variable = "我是一个局部变量"  # 局部变量
        print(Local_variable)  # 输出局部变量
        print(self.Instance_Variable)  # 输出实例变量


class ChlidExample(ExampleClass):
    def __init__(self, Instance_Variable, Chlid_Variable):
        ExampleClass.__init__(self, Instance_Variable)  # 初始化父类实例变量
        self.Chlid_Variable = Chlid_Variable

    def test(self):
        print("学习 python的面向对象,了解变量是必须的，我是孩子变量 {}，我是继承变量：{}".format(self.Chlid_Variable, self.Instance_Variable))


Instance_Variable = "我是用来测试实例变量的"
Chlid_Variable = "我是用来测试局部变量的 "
study = ChlidExample(Instance_Variable, Chlid_Variable)  # 调用子类对象
study.study_example()  # 子类调用父类方法

study_child = ChlidExample(Instance_Variable, Chlid_Variable)  # 调用子类对象
study_child.test()  # 子类调用子类方法

二、面向对象三大特性解析

2.1 封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。
所以，在使用面向对象的封装特性时，需要：

• 将内容封装到某处
• 从某处调用被封装的内容

class Animal(object):
    def __init__(self, name):   # 初始化方法
        self.name = name     # 初始化类变量
    def Dog(self):   # 创建类中的方法
        print(self.name)

    def Cat(self):  # 创建类中的方法
        print(self.name)
info = Animal('dahuang')  # 封装到对象 info
print(info.name)  # 直接调用
info.Dog()  # self 间接调用

2.2 继承

继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。
对于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。

class Animal(object):
    def __init__(self, name):  # 初始化方法
        self.name = name  # 初始化类变量
    def eat(self):  # 创建类中的方法
        print("%s吃 "%self.name)
    def drink(self):  # 创建类中的方法
        print("%s喝"%self.name)

class Dog(Animal):  # 继承Animal的 Dog
    def __init__(self, name):
        self.name = name  #
    def cry(self):
        print("汪汪叫")
class Cat(Animal):  # 继承Animal的 Cat
    def __init__(self, name):
        self.name = name  #
    def cry(self):
        print("喵喵叫")

child = Dog('邻居家的猫')  # 封装到子类对象 info
child.drink()  # 子类调用父类的方法

2.3 多态

多态，字面理解为多种形态，没错，就是一个方法能表现出不同的形态。
同一操作（方法）作用于不同的对象，可以有不同的解释，产生不同的结果，而无须明确知道这个子类实际上是什么。将其上升到父类与子类的层面时，就是父类的引用指向了子类的对象。
前面所讲的封装和继承都是为多态服务的
然而， Python属于鸭子类型，大意是：当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。
python中的鸭子类型允许我们使用任何提供所需方法的对象，而不需要迫使它成为一个子类。

多态三大前提：

1. 要有继承；
2. 重写；
3. 父类引用指向子类对象。

class Animal(object):
    def __init__(self, name):  # 初始化方法
        self.name = name  # 初始化类变量

class Dog(Animal):  # 继承Animal的 Dog
    def __init__(self, name):
        self.name = name  #
    def cry(self):
        print("%s汪汪叫" % self.name)

class Cat(Animal):  # 继承Animal的 Cat
    def __init__(self, name):
        self.name = name
    def cry(self):
        print("%s喵喵叫" % self.name)

def DuoTai(child):
    print(child.cry())

child1 = Dog('邻居家的狗')  # 封装到子类对象 info
DuoTai(child1)  # 多态展示Cry方法，重写
child2 = Cat('邻居家的猫')  # 封装到子类对象 info
DuoTai(child2)  # 多态展示Cry方法， 重写

三、进阶

3.1 基础重载方法

3.2 下划线说明

foo:

• 定义的是特殊方法，一般是系统定义名字 ，类似 init() 之类的。

_foo:

• 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *

_ _ foo:

• 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。