Python是一种面向对象编程的语言，Python中几乎都是对象，简单数值类型，代码模块，可以说是万物皆对象。例如对于一个数值对象：

>>> type(1) <class 'int'> >>> dir(1) ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'as_integer_ratio', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']

目录

一、面向对象编程二、类和对象1.什么是类和对象2.自定义类：创建与调用3.属性、函数和方法4.类命名空间 三、继承1.继承2.继承查询3.多个超类 四、多态1.什么是多态2.开闭原则3.鸭子类型 五、封装1.私有变量2.读写方法

一、面向对象编程

面向对象编程的思想将对象作为程序的基本单元，对象=数据（属性）+一套访问和操作这些数据的方法。就像在引言中说的，Python中所有的数据类型都可以被视为对象我们也可以自定义对象，即面向对象中类的概念。 从面向过程的编程到面向对象的编程，从语句到函数到类，抽象程度不断变高，但是更符合我们日常中的概念。 以学生成绩表为例，语句表达：

std1 = { 'name': 'Michael', 'score': 98 } std2 = { 'name': 'Bob', 'score': 81 }

通过函数打印：

def print_score(std): print('%s: %s' % (std['name'], std['score']))

将对象数据：学生成绩，对数据处理的方法：打印，整合在一起就是一个类。

class Student(object): def __init__(self, name, score): self.name = name self.score = score def print_score(self): print('%s: %s' % (self.name, self.score))

给对象发消息实际上就是调用对象对应的关联函数，即对象的方法：

bart = Student('Bart Simpson', 59) lisa = Student('Lisa Simpson', 87) bart.print_score() lisa.print_score()

面向对象编程的好处主要有三个方面： 1）多态：可对不同类型的对象执行相同的操作。 2）封装：对外部隐藏有关对象工作原理的细节。 3）继承：可基于通用类创建出专用类。

二、类和对象

1.什么是类和对象

类是一种对象的统称，每个对象都属于特定的类，对象是类的实例，是Python中程序的基本单元，要创建对象，就首先要创建一个类。 通过赋值语句可以给对象赋予名称，名称可以有很多个但是id只有一个。

a = complex(1,1)

2.自定义类：创建与调用

1）class语句和类的初始化

class <类名>: def _init_(self,<参数表>): def <方法名>(self,<参数表>)：

_init_()是一个特殊的函数名，用于根据类的定义创建实例对象，第一个参数必须是self。 2）调用类和方法

obj = <类名>(<参数表>) obj.<方法>（）

类方法中的self就是obj对象实例本身

#在Python中约定，类名大写字母开头，函数小写字母开头 class Person: def set_name(self, name): self.name = name def get_name(self): return self.name def greet(self): print("Hello, world! I'm {}.".format(self.name)) >>> foo = Person() #先创建Person()，再将foo名称与之关联 >>> bar = Person() >>> foo.set_name('Luke Skywalker') >>> bar.set_name('Anakin Skywalker') >>> foo.greet() Hello, world! I'm Luke Skywalker. >>> bar.greet() Hello, world! I'm Anakin Skywalker.

3.属性、函数和方法

方法和函数的区别表现在参数self上，方法中的第一个参数关联到它所属的实例，调用的时候无需这个参数，可以在类的外部将方法关联到一个普通的函数，通过这种方法，也可以实现普通函数对类中self实例的访问。

>>> class Class: ... def method(self): ... print('I have a self!') ... >>> def function(): ... print("I don't...") ... >>> instance = Class() >>> instance.method() I have a self! >>> instance.method = function >>> instance.method() I don't... >>> class Bird: ... song = 'Squaawk!' ... def sing(self): ... print(self.song) ... >>> bird = Bird() >>> bird.sing() Squaawk! >>> birdsong = bird.sing >>> birdsong() Squaawk!

4.类命名空间

在class语句中定义的代码都是在一个特殊的命名空间（类的命名空间）内执行的，而类的所有成员都可访问这个命名空间，例如：

class MemberCounter: members = 0 def init(self): MemberCounter.members += 1 >>> m1 = MemberCounter() >>> m1.init() >>> MemberCounter.members 1 >>> m2 = MemberCounter() >>> m2.init() >>> MemberCounter.members 2

如果给实例中的属性members赋值，那么该值将被写入m1的一个属性中，这个属性遮住了类级变量。m1中的属性将被覆盖为定值（类似于外部传递进来的实参值覆盖类命名空间内的全局变量），类中的操作不在影响该变量，但m1中的方法仍会影响其他实例中的该属性（类级变量）。

>>> class MemberCounter: members = 0 def init(self): MemberCounter.members += 1 >>> m1 = MemberCounter() >>> m1.init() >>> m1.members 1 >>> m1.members=3 >>> m1.members 3 >>> m2= MemberCounter() >>> m2.init() >>> m2.members 2 >>> m1.init() >>> m1.members 3 >>> m2.members 3 >>> m2.init() >>> m2.members 4

三、继承

1.继承

1）定义一个class的时候，可以从某个现有的class继承，新的class称为子类（Subclass），而被继承的class称为基类、父类或超类（Base class、Super class）。 例如：Dog类和Cat类都继承自Animal类。

class Animal(object): def run(self): print('Animal is running...') class Dog(Animal): pass class Cat(Animal): pass

2）通过这种方法，子类可以获得父类全部的属性和方法，并可以新增，或者重写已有的方法。

class Filter: def init(self): self.blocked = [] def filter(self, sequence): return [x for x in sequence if x not in self.blocked] class SPAMFilter(Filter): # SPAMFilter是Filter的子类 def init(self): # 重写超类Filter的方法init self.blocked = ['SPAM'] >>> f = Filter() >>> f.init() >>> f.filter([1, 2, 3]) [1, 2, 3] >>> s = SPAMFilter() >>> s.init() >>> s.filter(['SPAM', 'SPAM', 'SPAM', 'SPAM', 'eggs', 'bacon', 'SPAM']) ['eggs', 'bacon']

2.继承查询

1）要确定一个类是否是另一个类的子类，可使用内置方法issubclass：

>>> issubclass(SPAMFilter, Filter) True >>> issubclass(Filter, SPAMFilter) False

2）查询基类，可访问其特殊属性 __bases__;查询对象属于哪个类，可使用属性__class__:

>>> SPAMFilter.__bases__ (<class __main__.Filter at 0x171e40>,) >>> Filter.__bases__ (<class 'object'>,)

3）确定对象是否是特定类的实例，可使用isinstance:

>>> s = SPAMFilter() >>> isinstance(s, SPAMFilter) True >>> isinstance(s, Filter) True

3.多个超类

1）多重继承，继承多个父类的属性和方法：

class Calculator: def calculate(self, expression): self.value = eval(expression) class Talker: def talk(self): print('Hi, my value is', self.value) class TalkingCalculator(Calculator, Talker): pass >>> tc = TalkingCalculator() >>> tc.calculate('1 + 2 * 3') >>> tc.talk() Hi, my value is 7

2）注意：如果多个超类以不同的方式实现了同一个方法（同名方法），必须在class语句中小心排列这些超类，因为位于前面的类的方法将覆盖位于后面的类的方法。因此，在前面的示例中，如果Calculator类包含方法talk，那么这个方法将覆盖Talker 类的方法talk（导致它不可访问）。

四、多态

1.什么是多态

我们首先要对数据类型再作一点说明。当我们定义一个class的时候，我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型，比如str、list、dict没什么两样，子类对象的数据类型是子类本身，同时也是父类的数据类型。 多态的用法例如，定义一个函数：

def run_twice(animal): animal.run() animal.run() >>> run_twice(Animal()) Animal is running... Animal is running... >>> run_twice(Dog()) Dog is running... Dog is running... >>> run_twice(Cat()) Cat is running... Cat is running..

2.开闭原则

多态的好处就是，由于Animal类型有run()方法，因此，传入的任意类型，只要是Animal类或者子类，就会自动调用实际类型的run()方法，这就是多态的意思。调用方只管调用，不管细节，而当我们新增一种Animal的子类时，只要确保run()方法编写正确，不用管原来的代码是如何调用的。这就是著名的“开闭”原则： 1）对扩展开放：允许新增Animal子类； 2）对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。

3.鸭子类型

一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。 对于静态语言（例如Java）来说，如果需要传入Animal类型，则传入的对象必须是Animal类型或者它的子类，否则，将无法调用run()方法。对于Python这样的动态语言来说，则不一定需要传入Animal类型。我们只需要保证传入的对象有一个run()方法就可以了，实际上对于Python，就是针对函数中调用的方法，只要有，不管定义的类型是什么，传递进去的类型是什么，都可以：

>>> def runtwice(anywithrun): anywithrun.run() anywithrun.run()

五、封装

在Class内部，可以有属性和方法，而外部代码可以通过直接 调用实例变量的方法（读写） 来操作数据，这样，就隐藏了内部的复杂逻辑。

1.私有变量

如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问。

class Student(object): def __init__(self, name, score): self.__name = name self.__score = score def print_score(self): print('%s: %s' % (self.__name, self.__score)) >>> bart = Student('Bart Simpson', 59) >>> bart.__name Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'Student' object has no attribute '__name'

注意：①如果变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以尽量避免使用这种变量。 ②如果变量名以一个下划线开头，这样的实例变量外部是可以访问的，但是，意思就是，请当作私有变量不要随意访问。 ③即使是private变量，Python也提供了访问的方法，因为Python解释器对外把__xxx变量改成了_类名__xxx，所有通过下面这种方式也可以访问，但是尽量不要这样做。

>>> bart._Student__name 'Bart Simpson'

2.读写方法

例如上面的例子，如果外部代码要获取name和score，可以给Student类增加get_name和get_score这样的方法，如果要允许外部代码修改score，可以再给Student类增加set_score方法：

class Student(object): ... def get_name(self): return self.__name def get_score(self): return self.__score def set_score(self, score): self.__score = score