面向过程的编程思维是：按照处理流程，每一步需要做什么？用哪些函数可以解决？严格按照流程来把事情完成就ok了。这个在实际的应用中貌似还是多一点，因为简单，要求低一点。

相对来说，面向过程的编程就更抽象一点。考虑问题的出发点不再是问题解决的流程，而是everything is a object，对象有变量和方法，而解决问题的方式是：哪些对象需要具有哪些属性和方法？如何通过各个对象之间的信息传递来解决问题？

#代码清单-1 面向过程的程序示例：打印姓名和成绩

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

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

print_score(std1) print_score(std2)

#代码清单-2 面向对象的程序示例：打印姓名和成绩
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.类和实例

类是对象的抽象，比如笼统地提到“学生”，就是一个类，指的是学生那一类人群。而对象呢，则是类的一个实例化、具体化，比如一个叫“张三”的高中生就是“学生”这个类的一个实例，也就是“学生”类的一个对象。

每个对象都拥有相同的方法，但各自的数据则不尽相同。

1.1类的定义和实例化

下面的示例先定义了一个类，然后实例化了一个对象出来。

**#代码清单3-1： 定义类** class Student(object): def __init__(self, name, score): self.name = name self.score = score

**#代码清单3-2： 实例化** bart=Student('Bart Sipson',59) bart.name #'Bart Sipson' bart.score #59

1.2 数据封装

继续，在定义类的同时，定义、封装了两个新的方法：打印成绩和等级。

''' 定义类 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) def get_grade(self): if self.score>=90: return 'A' elif self.score>=60: return 'B' else: return 'C'

''' 调用封装的方法 bart.print_score() # Bart Sipson: 59 bart.get_grade() # 'C'

2.访问限制

以 __ （双下划线）开头的变量表示私有变量，外部无法访问。

''' 定义类，设置私有变量 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) def get_grade(self): if self.__score>=90: return 'A' elif self.__score>=60: return 'B' else: return 'C'

'''对象无法引用私有变量 bart = Student('Bart Simpson', 98) bart.__name '''报错信息： Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'Student' object has no attribute '__name'

可以使用get方法和set方法来获取和修改变量的值。那么问题来了， 如果不把变量设置为私有变量，也可以通过重新赋值的方式来修改值啊，那为什么要单独搞一个set方法呢？

因为set方法可以做参数检查，防止传入无效的参数。

'''定义类''' 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) def get_grade(self): if self.__score>=90: return 'A' elif self.__score>=60: return 'B' else: return 'C' '''set与get方法''' def get_name(self): return self.__name def get_score(self): return self.__score def set_score(self,score): if 0 <= score <= 100: self.__score=score else: raise ValueError('bad score') def set_name(self,name): self.__name=name

bart=Student('Bart Sipson',59) bart.get_score() #59 bart.set_score(63) bart.get_score() #63

3.继承和多态

子类可以继承父类的所有方法，同时也可以自行定义属于自己的方法。

class Animal(object): def run(self): print 'Animal is running...'
class Dog(Animal): pass
class Cat(Animal): pass
dog=Dog() dog.run()
cat=Cat() cat.run()
class Dog(Animal): def run(self): print 'Dog is running...' def eat(self): print 'Eating meat...'
class Cat(Animal): def run(self): print 'Cat is running...'
dog=Dog() dog.run()
cat=Cat() cat.run()

判断一个变量是否是某个类型可以用isinstance()判断：
a = list() # a是list类型 b = Animal() # b是Animal类型 c = Dog() # c是Dog类型

isinstance(a, list) #True isinstance(b, Animal) #True isinstance(c, Dog) #True isinstance(c, Animal) #True

理解多态，抓住“开闭”原则：对扩展开放：允许新增Animal子类；对修改封闭：不需要修改依赖Animal类型的run_twice()等函数。

下面的例子中，Dog，Cat，Tortoise都是Animal的子类，调用run_twice方法时，会自动调用属于自己的run方法。
def run_twice(animal): animal.run() animal.run()
run_twice(Animal()) run_twice(Dog()) run_twice(Cat())
class Tortoise(Animal): def run(self): print 'Tortoise is running slowly...'
run_twice(Tortoise())

4.获取对象信息

来判断对象类型，使用type()函数：

'''基本类型'''

type(123)
<type 'int'>
type('str')
<type 'str'>
type(None)
<type 'NoneType'>

'''函数或者类'''

type(abs)
type(a)
type(123)==type(456)
type('abc')==type('123')
type('abc')==type(123)

import types
type('abc')==types.StringType
type(u'abc')==types.UnicodeType
type([])==types.ListType
type(str)==types.TypeType
type(int)==type(str)==types.TypeType

使用isinstance()

a = Animal()
d = Dog()
h = Husky()

isinstance(h, Husky)
isinstance(h, Dog)
isinstance(h, Animal)
isinstance(d, Dog) and isinstance(d, Animal)
isinstance(d, Husky)

isinstance('a', str)
isinstance(u'a', unicode)
isinstance('a', unicode)

isinstance('a', (str, unicode))
isinstance(u'a', (str, unicode))
isinstance(u'a', basestring)

使用dir

dir('ABC')

len('ABC')
3
'ABC'.len()
3

class MyObject(object):
def len(self):
return 100

obj = MyObject()
len(obj)

'ABC'.lower()

class MyObject(object):
def init(self):
self.x = 9
def power(self):
return self.x * self.x

obj = MyObject()

hasattr(obj, 'x') # 有属性'x'吗？
True
obj.x
9
hasattr(obj, 'y') # 有属性'y'吗？
False
setattr(obj, 'y', 19) # 设置一个属性'y'
hasattr(obj, 'y') # 有属性'y'吗？
True
getattr(obj, 'y') # 获取属性'y'
19
obj.y # 获取属性'y'
19

getattr(obj, 'z') # 获取属性'z'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'MyObject' object has no attribute 'z'

getattr(obj, 'z', 404) # 获取属性'z'，如果不存在，返回默认值404
404

hasattr(obj, 'power') # 有属性'power'吗？
True
getattr(obj, 'power') # 获取属性'power'
<bound method MyObject.power of <main.MyObject object at 0x108ca35d0>>
fn = getattr(obj, 'power') # 获取属性'power'并赋值到变量fn
fn # fn指向obj.power
<bound method MyObject.power of <main.MyObject object at 0x108ca35d0>>
fn() # 调用fn()与调用obj.power()是一样的
81