一、面向对象的概念
1、面向对象的两个基本概念
编程语言中，一般有两种编程思维，面向过程和面向对象。
面向过程，看重的是解决问题的过程。
这好比我们解决日常生活问题差不多，分析解决问题的步骤，然后一步一步的解决。
而面向对象是一种抽象，抽象是指用分类的眼光去看世界的一种方法。
Python 就是一门面向对象的语言,
如果你学过 Java ，就知道 Java 的编程思想就是：万事万物皆对象。Python 也不例外，在解决实际问题的过程中，可以把构成问题事务分解成各个对象。
面向对象都有两个基本的概念，分别是类和对象。
- 类
用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
- 对象
通过类定义的数据结构实例
2、面向对象的三大特性
面向对象的编程语言，也有三大特性，继承，多态和封装性。
- 继承
即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。
例如：一个 Dog 类型的对象派生自 Animal 类，这是模拟"是一个（is-a）"关系（例图，Dog 是一个 Animal ）。
- 多态
它是指对不同类型的变量进行相同的操作，它会根据对象（或类）类型的不同而表现出不同的行为。
- 封装性
“封装”就是将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体（即类）；封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员。
如果你是初次接触面向对象的编程语言，看到这里还一脸懵逼，不要紧，这是正常的。下面我们会通过大量的例子逐步了解 Python 的面向对象的知识。
二、类的定义和调用
1、怎么理解类？
类是什么？
个人认为理解类，最简单的方式就是：类是一个变量和函数的集合。
可以看下下面的这张图。
编辑
这张图很好的诠释了类，就是把变量和函数包装在一起。
当然我们包装也不是毫无目的的包装，我们会把同性质的包装在一个类里，这样就方便我们重复使用。
所以学到现在，你会发现很多编程的设计，都是为了我们能偷懒，重复使用。
2、怎么定义类
知道了类是什么样子的，我们接下来就要学习怎么去定义类了。
类定义语法格式如下：
class ClassName():
<statement-1>
.
.
.
<statement-N>
可以看到，我们是用 class 语句来自定义一个类的，其实这就好比我们是用 def 语句来定义一个函数一样。
竟然说类是变量和方法的集合包，那么我们来创建一个类。
class ClassA(): var1 = 100 var2 = 0.01 var3 = '两点水' def fun1(): print('我是 fun1') def fun2(): print('我是 fun1') def fun3(): print('我是 fun1')
你看，上面我们就定义了一个类，类名叫做 ClassA , 类里面的变量我们称之为属性，那么就是这个类里面有 3 个属性，分别是 var1 , var2 和 var3 。除此之外，类里面还有 3 个类方法 fun1() , fun2() 和 fun3() 。
3、怎么调用类属性和类方法
我们定义了类之后，那么我们怎么调用类里面的属性和方法呢？
直接看下图：
编辑
这里就不文字解释了（注：做图也不容易啊，只有写过技术文章才知道，这系列文章，多耗时）
好了，知道怎么调用之后，我们尝试一下：
class ClassA(): var1 = 100 var2 = 0.01 var3 = '程序员Johnny' def fun1(): print('我是 fun1') def fun2(): print('我是 fun2') def fun3(): print('我是 fun3') print(ClassA.var1) print(ClassA.var2) print(ClassA.var3) ClassA.fun1() ClassA.fun2() ClassA.fun3()
运行结果：
100
0.01
程序员Johnny
我是 fun1
我是 fun2
我是 fun3
三、类方法
1、类方法如何调用类属性
通过上面我们已经会定义类了，那么这里讲一下在同一个类里，类方法如何调用类属性的。
直接看个例子吧：
class ClassA(): var1 = '程序员Johnny' @classmethod def fun1(cls): print('我是fun1' + cls.var1) ClassA.fun1()
运行结果：
我是fun1程序员Johnny
注意看，在类方法上面多了个 @classmethod 用于声明下面的函数是类函数
如果我们删除掉@classmethod，是会报错的。
class ClassA(): var1 = '程序员Johnny' def fun1(cls): print('我是fun1' + cls.var1) ClassA.fun1()
运行结果：
编辑
如果没有声明是类方法，方法参数中就没有 cls , 就没法通过 cls 获取到类属性。
因此类方法，想要调用类属性，需要以下步骤：
- 在方法上面，用
@classmethod声明该方法是类方法。只有声明了是类方法，才能使用类属性 - 类方法想要使用类属性，在第一个参数中，需要写上
cls, cls 是 class 的缩写，其实意思就是把这个类作为参数，传给自己，这样就可以使用类属性了。 - 类属性的使用方式就是
cls.变量名
记住喔，无论是 @classmethod 还是 cls ,都是不能省去的。
省了都会报错。
2、类方法传参
上面我们学习了类方法如何调用类属性，那么类方法如何传参呢？
其实很简单，跟普通的函数一样，直接增加参数就好了。
这个就直接上例子了：
class ClassA(): var1 = '程序员Johnny' @classmethod def fun1(cls, age): print('我是fun1' + cls.var1) print('年龄' + str(age)) ClassA.fun1(18)
运行结果：
我是fun1程序员Johnny
年龄18
四、修改和增加类属性
1、从内部增加和修改类属性
来，我们先来温习一下类的结构。
看着这个结构，提一个问题，如何修改类属性，也就是类里面的变量？
从类结构来看，我们可以猜测，从类方法来修改，也就是从类内部来修改和增加类属性。
看下具体的实例：
class ClassA(): var1 = '程序员Johnny' @classmethod def fun1(cls): print('原来的 var1 值为: ' + cls.var1) cls.var1 = input('请输入修改 var1 的值: ') print('修改后 var1 值为: ' + cls.var1) cls.var2 = input('新增类型属性 var2, 请为它赋值为: ') print('修改后 var2 值为: ' + cls.var2) ClassA.fun1()
运行结果：
编辑
这里还是强调一下，例子还是要自己多写，不要只看，自己运行， 看效果。多想。
2、从外部增加和修改类属性
我们刚刚看了通过类方法来修改类的属性，这时我们看下从外部如何修改和增加类属性。
例子如下：
class ClassA(): var1 = '程序员Johnny' @classmethod def fun1(cls): print('var1 值为: ' + cls.var1) ClassA.fun1() ClassA.var1 = input('请输入修改 var1 的值: ') ClassA.fun1() ClassA.var2 = input('请输入新增类型属性 var2 的值: ') print(ClassA.var2)
运行结果：
编辑
五、类和对象
1、类和对象之间的关系
这部分内容主要讲类和对象，我们先来说说类和对象之间的关系。
类是对象的模板
我们得先有了类，才能制作出对象。
类就相对于工厂里面的模具，对象就是根据模具制造出来的产品。
从模具变成产品的过程，我们就称为类的实例化。
类实例化之后，就变成对象了。也就是相当于例子中的产品。
2、类的实例化
这里强调一下，类的实例化和直接使用类的格式是不一样的。
之前我们就学过，直接使用类格式是这样的：
class ClassA(): var1 = '程序员Johnny' @classmethod def fun1(cls): print('var1 值为：' + cls.var1) ClassA.fun1()
而类的实例化是怎样的呢？
是这样的，可以仔细对比一下，类的实例化和直接使用类的格式有什么不同？
编辑
主要的不同点有：
- 类方法里面没有了
@classmethod声明了，不用声明他是类方法 - 类方法里面的参数
cls改为self - 类的使用，变成了先通过
实例名 = 类()的方式实例化对象，为类创建一个实例，然后再使用实例名.函数()的方式调用对应的方法 ，使用实例名.变量名的方法调用类的属性
这里说明一下，类方法的参数为什么 cls 改为 self ？
其实这并不是说一定要写这个，你改为什么字母，什么名字都可以。
不妨试一下：
编辑
你看，把 self 改为 aaaaaaaa 还是可以一样运行的。
只不过使用 cls 和 self 是我们的编程习惯，这也是我们的编程规范。
因为 cls 是 class 的缩写，代表这类 ， 而 self 代表这对象的意思。
所以啊，这里我们实例化对象的时候，就使用 self 。
而且 self 是所有类方法位于首位、默认的特殊参数。
除此之外，在这里，还要强调一个概念，当你把类实例化之后，里面的属性和方法，就不叫类属性和类方法了，改为叫实例属性和实例方法，也可以叫对象属性和对象方法。
为什么要这样强调呢？
因为一个类是可以创造出多个实例对象出来的。
你看下面的例子：
编辑
我不仅能用这个类创建 a 对象，还能创建 b 对象
3、实例属性和类属性
一个类可以实例化多个对象出来。
编辑
根据这个图，我们探究一下实例对象的属性和类属性之间有什么关系呢？
先提出第一个问题，如果类属性改变了，实例属性会不会跟着改变呢？
还是跟以前一样，提出了问题，我们直接用程序来验证就好。
看程序：
编辑
从程序运行的结果来看，类属性改变了，实例属性会跟着改变。
这很好理解，因为我们的实例对象就是根据类来复制出来的，类属性改变了，实例对象的属性也会跟着改变。
那么相反，如果实例属性改变了，类属性会改变吗？
答案当然是不能啦。因为每个实例都是单独的个体，不能影响到类的。
具体我们做下实验：
编辑
可以看到，不管实例对象怎么修改属性值，对类的属性还是没有影响的。
4、实例方法和类方法
那这里跟上面一样，还是提出同样的问题。
如果类方法改变了，实例方法会不会跟着改变呢？
看下下面的例子：
编辑
这里建议我的例子，各位都要仔细看一下，自己重新敲一遍。相信为什么要这么做，这么证明。
还是那句话多想，多敲。
回归正题，从运行的结果来看，类方法改变了，实例方法也是会跟着改变的。
在这个例子中，我们需要改变类方法，就用到了类的重写。
我们使用了 类.原始函数 = 新函数 就完了类的重写了。
要注意的是，这里的赋值是在替换方法，并不是调用函数。所以是不能加上括号的，也就是 类.原始函数() = 新函数() 这个写法是不对的。
那么如果实例方法改变了，类方法会改变吗？
如果这个问题我们需要验证的话，是不是要重写实例的方法，然后观察结果，看看类方法有没有改变，这样就能得出结果了。
可是我们是不能重写实例方法。
你看，会直接报错。
编辑
六、初始化函数
1、什么是初始化函数
初始化函数的意思是，当你创建一个实例的时候，这个函数就会被调用。
比如：
编辑
当代码在执行 a = ClassA() 的语句时，就自动调用了 __init__(self) 函数。
而这个 __init__(self) 函数就是初始化函数，也叫构造函数。
初始化函数的写法是固定的格式：中间是 init，意思是初始化，然后前后都要有【两个下划线】，然后 __init__() 的括号中，第一个参数一定要写上 self，不然会报错。
构造函数（初始化函数）格式如下：
def __init__(self,[...):
初始化函数一样可以传递参数的，例如：
编辑
2、析构函数
竟然一个在创建的时候，会调用构造函数，那么理所当然，这个当一个类销毁的时候，就会调用析构函数。
析构函数语法如下：
def __del__(self,[...):
看下具体的示例：
编辑
3、Python 定义类的历史遗留问题
Python 在版本的迭代中，有一个关于类的历史遗留问题，就是新式类和旧式类的问题，具体先看以下的代码：
# 旧式类 class OldClass: pass # 新式类 class NewClass(object): pass
可以看到，这里使用了两者中不同的方式定义类，可以看到最大的不同就是，新式类继承了object 类，在 Python2 中，我们定义类的时候最好定义新式类，当然在 Python3 中不存在这个问题了，因为 Python3 中所有类都是新式类。
那么新式类和旧式类有什么区别呢？
运行下下面的那段代码：
# 旧式类 class OldClass: def __init__(self, account, name): self.account = account self.name = name # 新式类 class NewClass(object): def __init__(self, account, name): self.account = account self.name = name if __name__ == '__main__': old_class = OldClass(111111, 'OldClass') print(old_class) print(type(old_class)) print(dir(old_class)) print('\n') new_class = NewClass(222222, 'NewClass') print(new_class) print(type(new_class)) print(dir(new_class))
这是 python 2.7 运行的结果：
/Users/twowater/dev/python/test/venv/bin/python /Users/twowater/dev/python/test/com/twowater/test.py <__main__.OldClass instance at 0x109a50560> <type 'instance'> ['__doc__', '__init__', '__module__', 'account', 'name'] <__main__.NewClass object at 0x109a4b150> <class '__main__.NewClass'> ['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'account', 'name'] Process finished with exit code 0
这是 Python 3.6 运行的结果：
/usr/local/bin/python3.6 /Users/twowater/dev/python/test/com/twowater/test.py <__main__.OldClass object at 0x1038ba630> <class '__main__.OldClass'> ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'account', 'name'] <__main__.NewClass object at 0x103e3c9e8> <class '__main__.NewClass'> ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'account', 'name'] Process finished with exit code 0
仔细观察输出的结果，对比一下，就能观察出来，注意喔，Pyhton3 中输出的结果是一模一样的，因为Python3 中没有新式类旧式类的问题。
七、类的继承
1、定义类的继承
说到继承，你一定会联想到继承你老爸的家产之类的。
类的继承也是一样。
比如有一个旧类，是可以算平均数的。然后这时候有一个新类，也要用到算平均数，那么这时候我们就可以使用继承的方式。新类继承旧类，这样子新类也就有这个功能了。
通常情况下，我们叫旧类为父类，新类为子类。
首先我们来看下类的继承的基本语法：
class ClassName(BaseClassName):
<statement-1>
.
.
.
<statement-N>
在定义类的时候，可以在括号里写继承的类，如果不用继承类的时候，也要写继承 object 类，因为在 Python 中 object 类是一切类的父类。
当然上面的是单继承，Python 也是支持多继承的，具体的语法如下：
class ClassName(Base1,Base2,Base3):
<statement-1>
.
.
.
<statement-N>
多继承有一点需要注意的：若是父类中有相同的方法名，而在子类使用时未指定，python 在圆括号中父类的顺序，从左至右搜索 ， 即方法在子类中未找到时，从左到右查找父类中是否包含方法。
那么继承的子类可以干什么呢？
继承的子类的好处：
- 会继承父类的属性和方法
- 可以自己定义，覆盖父类的属性和方法
2、调用父类的方法
一个类继承了父类后，可以直接调用父类的方法的，比如下面的例子，UserInfo2 继承自父类 UserInfo ，可以直接调用父类的 get_account 方法。
class UserInfo(object): lv = 5 def __init__(self, name, age, account): self.name = name self._age = age self.__account = account def get_account(self): return self.__account class UserInfo2(UserInfo): pass if __name__ == '__main__': userInfo2 = UserInfo2('两点水', 23, 347073565); print(userInfo2.get_account())
3、父类方法的重写
当然，也可以重写父类的方法。
示例：
class UserInfo(object): lv = 5 def __init__(self, name, age, account): self.name = name self._age = age self.__account = account def get_account(self): return self.__account @classmethod def get_name(cls): return cls.lv @property def get_age(self): return self._age class UserInfo2(UserInfo): def __init__(self, name, age, account, sex): super(UserInfo2, self).__init__(name, age, account) self.sex = sex; if __name__ == '__main__': userInfo2 = UserInfo2('两点水', 23, 347073565, '男'); # 打印所有属性 print(dir(userInfo2)) # 打印构造函数中的属性 print(userInfo2.__dict__) print(UserInfo2.get_name())
最后打印的结果：
编辑
这里就是重写了父类的构造函数。
4、子类的类型判断
对于 class 的继承关系来说，有些时候我们需要判断 class 的类型，该怎么办呢？
可以使用 isinstance() 函数,
一个例子就能看懂 isinstance() 函数的用法了。
class User1(object): pass class User2(User1): pass class User3(User2): pass if __name__ == '__main__': user1 = User1() user2 = User2() user3 = User3() # isinstance()就可以告诉我们，一个对象是否是某种类型 print(isinstance(user3, User2)) print(isinstance(user3, User1)) print(isinstance(user3, User3)) # 基本类型也可以用isinstance()判断 print(isinstance('两点水', str)) print(isinstance(347073565, int)) print(isinstance(347073565, str))
输出的结果如下：
True
True
True
True
True
False
可以看到 isinstance() 不仅可以告诉我们，一个对象是否是某种类型，也可以用于基本类型的判断。
八、类的多态
多态的概念其实不难理解，它是指对不同类型的变量进行相同的操作，它会根据对象（或类）类型的不同而表现出不同的行为。
事实上，我们经常用到多态的性质，比如：
>>> 1 + 2 3 >>> 'a' + 'b' 'ab'
可以看到，我们对两个整数进行 + 操作，会返回它们的和，对两个字符进行相同的 + 操作，会返回拼接后的字符串。
也就是说，不同类型的对象对同一消息会作出不同的响应。
看下面的实例，来了解多态：
class User(object): def __init__(self, name): self.name = name def printUser(self): print('Hello !' + self.name) class UserVip(User): def printUser(self): print('Hello ! 尊敬的Vip用户：' + self.name) class UserGeneral(User): def printUser(self): print('Hello ! 尊敬的用户：' + self.name) def printUserInfo(user): user.printUser() if __name__ == '__main__': userVip = UserVip('两点水') printUserInfo(userVip) userGeneral = UserGeneral('水水水') printUserInfo(userGeneral)
输出的结果:
Hello ! 尊敬的Vip用户：两点水
Hello ! 尊敬的用户：水水水
可以看到，userVip 和 userGeneral 是两个不同的对象，对它们调用 printUserInfo 方法，它们会自动调用实际类型的 printUser 方法，作出不同的响应。这就是多态的魅力。
要注意喔，有了继承，才有了多态，也会有不同类的对象对同一消息会作出不同的相应。
九、类的访问控制
1、类属性的访问控制
在 Java 中，有 public （公共）属性 和 private （私有）属性，这可以对属性进行访问控制。
那么在 Python 中有没有属性的访问控制呢？
一般情况下，我们会使用 __private_attrs 两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
为什么只能说一般情况下呢？
因为实际上， Python 中是没有提供私有属性等功能的。
但是 Python 对属性的访问控制是靠程序员自觉的。为什么这么说呢？
看看下面的示例：
编辑
仔细看图片，为什么说双下划线不是真正的私有属性呢？我们看下下面的例子，用下面的例子来验证：
class UserInfo(object): def __init__(self, name, age, account): self.name = name self._age = age self.__account = account def get_account(self): return self.__account if __name__ == '__main__': userInfo = UserInfo('两点水', 23, 347073565); # 打印所有属性 print(dir(userInfo)) # 打印构造函数中的属性 print(userInfo.__dict__) print(userInfo.get_account()) # 用于验证双下划线是否是真正的私有属性 print(userInfo._UserInfo__account)
输出的结果如下图：
编辑
2、类专有的方法
一个类创建的时候，就会包含一些方法，主要有以下方法：
类的专有方法：
| 方法 | 说明 |
__init__ |
构造函数，在生成对象时调用 |
__del__ |
析构函数，释放对象时使用 |
__repr__ |
打印，转换 |
__setitem__ |
按照索引赋值 |
__getitem__ |
按照索引获取值 |
__len__ |
获得长度 |
__cmp__ |
比较运算 |
__call__ |
函数调用 |
__add__ |
加运算 |
__sub__ |
减运算 |
__mul__ |
乘运算 |
__div__ |
除运算 |
__mod__ |
求余运算 |
__pow__ |
乘方 |
当然有些时候我们需要获取类的相关信息，我们可以使用如下的方法：
type(obj)：来获取对象的相应类型；isinstance(obj, type)：判断对象是否为指定的 type 类型的实例；hasattr(obj, attr)：判断对象是否具有指定属性/方法；getattr(obj, attr[, default])获取属性/方法的值, 要是没有对应的属性则返回 default 值（前提是设置了 default），否则会抛出 AttributeError 异常；setattr(obj, attr, value)：设定该属性/方法的值，类似于 obj.attr=value；dir(obj)：可以获取相应对象的所有属性和方法名的列表：
3、方法的访问控制
其实我们也可以把方法看成是类的属性的，那么方法的访问控制也是跟属性是一样的，也是没有实质上的私有方法。一切都是靠程序员自觉遵守 Python 的编程规范。
示例如下，具体规则也是跟属性一样的，
class User(object): def upgrade(self): pass def _buy_equipment(self): pass def __pk(self): pass
下一章：Python教程第7章 | 元类
