面向过程的编程思维是：按照处理流程，每一步需要做什么？用哪些函数可以解决？严格按照流程来把事情完成就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
