面向对象最重要的概念就是类(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中的鸭子类型允许我们使用任何提供所需方法的对象，而不需要迫使它成为一个子类。

多态三大前提：

要有继承；

重写；

父类引用指向子类对象。

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)的变量, 只能是允许这个类本身进行访问了。