# coding:utf-8

#--------------------------------------------------  对象魔力  -----------------------------------------

#多态

#多态方法

print 'abc'.count('a')

#1

print [1, 2, 'a'].count('a')

#1

#不用关心count('a')里面是什么类型数据，只要知道count方法，可以返回a出现多少次，就行了，这就是多态方法

#choice函数，可以从序列中随机选出元素。

from random import choice

x = choice(['Hello, world!', [1, 2, 'e', 'e', 4]])

#x可能是Hello,world字符串，可能是[1, 2, 'e', 'e', 4]列表，不用关心到底是哪个类型，只要关心变量x中字符e出现了多少次。不管x是字符串还是列表，都可以使用count函数。

print x.count('e')

#2              #本例中，看来列表胜出了。

#多态多种形式

#当面对对象不知道是什么类型，但又要对对象做些什么时候，就会用到多态

#这不仅限于方法，很多内建运算符和函数都有多态的性质。比如：

print 1 + 2

#3

print 'Fish' + 'license'

#Fishlicense

#这里的加运算符对于数字和字符串都能起作用。

#为说明这一点，假设有个叫做add的函数，它可以将两个对象相加。可以直接将其定义成上面的形式。

def add(x, y):

   return x+y

#对于很多类型的参数都可以用：

print add(1, 2)

#3

print add('Fish', 'license')

#Fishlicense

#如果需要编写打印对象长度消息的函数，只需对象具有长度（len函数可用）即可。

def length_message(x):

   print "The length of", repr(x), "is", len(x)

#可以看到，函数中还使用了repr函数，repr函数是多态特性。

length_message('Fnord')

#The length of 'Fnord' is 5

length_message([1, 2, 3])

#The length of [1, 2, 3] is 3

#很多函数和运算符都是多态的---你写的绝多数程序可能都是，即便你并非有意这样。只要使用多态函数和运算符，就会与“多态”发生关联。

#事实上，唯一能毁掉多态的就是使用函数检查类型，比如type,isinstance以及issubclass函数等。

#如果可能的话，应该尽力避免使用这些毁掉多态的方式。真正重要的是如何让对象按照你所希望的方式工作，不管它是否是正确的类型（或者类）。

#封装

#封装是指向程序中的其他部分隐藏对象的具体实现细节原则。

#接下面再论私有化进行详细解释

#继承

#就是函数，类等调用，相同代码不想重复写，直接调用给其他代码，就是继承。

#--------------------------------------------  类和类型 ------------------------------------------

#创建类

__metaclass__ = type           #确定使用新式类，一种写法格式，创建类写上即可

class Person:

   def setName(self, name):

       self.name = name

   def getName(self):

       return self.name

   def greet(self):

       print "Hello, world! I'm %s." % self.name

#这个例子包含3个方法定义，除了它们是写在class语句里，一切都像是函数定义。Person是类的名字。class语句会在函数定义的地方创建自己的命名空间。

#self参数看起来有点奇怪，它是对于对象自身的引用。那么它是什么对象？创建一些实例看看：

foo = Person()

bar = Person()

foo.setName('Luke Skywalker')               #foo将自己为第一个参数传入到self里

bar.setName('Anakin Skywalker')

foo.greet()

#Hello, world! I'm Luke Skywalker.

bar.greet()

#Hello, world! I'm Anakin Skywalker.

#在调用foo的setName和greet函数时，foo自动将自己作为第一个参数传入函数中---因此形象地命名为self。对于这个变量，每个人可能都会有自己的叫法，但是因为它总是对象自己，所以习惯上总是叫做self

#显然这就是self的用处和存在的必要性。没有它的话，成员方法就没法访问它们要对其特性进行操作的对象本身了。

#特性可以在外部访问：

#就是setName函数里的self.name = name

print foo.name

#Luke Skywalker

bar.name = 'Yoda'

bar.greet()

#Hello, world! I'm Yoda.

#如果知道foo是Person的实例的话，那么可以把foo.greet()写成：

Person.greet(foo)           #方便的简写

#Hello, world! I'm Luke Skywalker.

#特性，函数，方法

__metaclass__ = type

class Class:

   def method(self):

       print 'I have a self!'

def function():

       print "I don't..."

instance = Class()              #调用类

instance.method()               #instance是实例，method是方法，有self参数

#I have a self!

instance.method = function      #绑定到一个普通函数上，没有self参数

instance.method()

#I don't...

__metaclass__ = type

class Bird:

   song = 'Squaawk!'

   def sing(self):

       print self.song

bird = Bird()

bird.sing()

#Squaawk!

birdsong = bird.sing

birdsong()              #调用方法和函数十分相似，但变量绑定方法bird.sing还是会对self参数进行访问

#Squaawk!

#再论私有化，接上面的封装

#使用上面类的例子：

__metaclass__ = type

class Person:

   def setName(self, name):

       self.name = name

   def getName(self):

       return self.name

   def greet(self):

       print "Hello, world! I'm %s." % self.name

o = Person()            #调用类

o.setName('Sir Lancelot')

print o.getName()

#Sir Lancelot

#变量o绑定到对象（Person类）上，可以使用setName和getName方法。一切看起来很完美。但是假设变量o将它的名字存储在全局变量globalName中：

#但假设变量o将它的名字存储在全局变量globalName中：

#globalName

#'Sir Lancelot'

#这意味着在使用OpenObject类的实例时候，不得不关心globalName的内容。实际上要确保不会对它进行任何更改：

#globalName = 'Sir Gumby'

#o.getName()

#'Sir Gumby'

#如果创建了多个OpenObject实例的话就会出现问题，因为变量相同，所以可能会混淆：

#o1 = OpenObject()

#o2 = OpenObject()

#o1.setName('Robin Hood')

#o2.getName()

#'Robin Hood'

#设定一个名字后，其他名字也自动设定了。

#为了让方法或者特性变成私有（外部无法访问），只要在它的名字前面加上双下划线即可。

__metaclass__ = type

class Secretive:

   def __inaccessible(self):            #让方法变成私有化（外部无法访问），只要在它的名字前面加上双下划线即可

       print "Bet you can`t see me..."

   def accessible(self):

       print "The secret message is:"

       self.__inaccessible()           #内部调用

s = Secretive()

# s.__inaccessible()              #报错无法调用

s.accessible()                  #内部可以调用

#The secret message is:

#Bet you can`t see me...

s._Secretive__inaccessible()       #也有外部调用方法，但不应该这么做

#Bet you can`t see me...

#类的命名空间

__metaclass__ = type

class MemberCounter:

   members = 0

   def init(self):

       MemberCounter.members += 1

#上面代码中，在类作用域内定义了一个可供所有成员（实例）访问的变量（members），用来计算类的成员数量。注意init用来初始化所有实例。

m1 = MemberCounter()        #调用类

m1.init()

print MemberCounter.members

#1

m2 = MemberCounter()

m2.init()

print MemberCounter.members

#2

#类作用域内的变量也可以被所有实例访问：

print m1.members

#2

print m2.members

#2

m1.members = 'Two'              #新的numbers值被写到了m1特性中，屏蔽了类范围内的变量。这跟函数内的局部和全局变量的行为十分类似。

print m1.members

#Two

print m2.members

#2

#指定超类

__metaclass__ = type

class Filter:           #写一个过滤作用的类（超类）

   def init(self):

       self.blocked = []

   def filter(self, sequence):

       return [x for x in sequence if x not in self.blocked]  # 如何理解这句话，同等于下面注释

#        l = []

#        for x in sequence:

#            if x not in self.blocked:

#                l.append(x)

#        return l

#Filter是个用于过滤序列的通用类，事实上它自身不能过滤任何东西

f = Filter()

f.init()

print f.filter([1, 2, 3])

#[1, 2, 3]

#Filter类的用处在于它可以用作其他类的（基类）超类，比如下面SPAMFilter类，可以将序列中的'SPAM'过滤出去。

class SPAMFilter(Filter):               #继承上面的类，可以不用写一大堆过滤的类，从上面继承更加方便。SPAMFilter是Filter的子类，Filter是SPAMFilter的超类

   def init(self):                     #重写超类Filter中的init方法

       self.blocked = ['SPAM']         #本来过滤关键字没写，现在写入SPAM

s = SPAMFilter()

s.init()

print s.filter(['SPAM','SPAM','SPAM','eggs','bacon','SPAM'])

#['eggs', 'bacon']

#检查继承

#如果想要查看一个类是否是另外一个的子类，可以使用内建的issubclass的函数：

print issubclass(SPAMFilter, Filter)        #查看SPAMFilter是否是Failter的子类

#True

print issubclass(Filter, SPAMFilter)

#False

#如果想要知道已知类的基类（们）（注意下节解释），可以使用特殊特性__bases__：

print SPAMFilter.__bases__       #已知类的基类，使用__bases__

#(<class '__main__.Filter'>,)

print Filter.__bases__

#(<type 'object'>,)

#使用isinstance方法检查一个对象是否是一个类的实例：

s = SPAMFilter()

print isinstance(s, SPAMFilter)

#True

print isinstance(s, Filter)

#True

print isinstance(s, str)

#False

#想知道一个对象属于哪个类，可以使用__class__特性

print s.__class__

#<class '__main__.SPAMFilter'>

#多个超类

#上节提到一个类的基类（们），也就暗示它的基类可能会多于一个。事实上就是这样，建立几个新类来试试：

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

#子类（TalkingCalculator）自己不做任何事，它从自己的超类继承所有的行为。它从Calculator类那里继承calculate方法，从Talker类那里继承talk方法，这样它就成了会说话的计算器。

tc = TalkingCalculator()

tc.calculate('1+2*3')

tc.talk()

#Hi, my value is 7

#这种行为称为多重继承，是个非常有用的工具。但除非特别熟悉多重继承，否则应该尽量避免使用，因为有些时候会出现不可预见的麻烦。

#需要注意是如果一个方法从多个超类继承（也就是说有两个具有相同名字的不同方法），那么必须注意下超类的顺序（在class语句中）：先继承的类中的方法会重写后继承的类中的方法。

#如果前例中Calculator:类也有个叫talk方法（函数），那么它会覆盖Talker的talk方法（使其无法访问）。如果把它们顺序掉过来，像下面这样：

#class TalkingCalculator(Talker， Calculator): pass

#就会让Talker的talk方法可用了。

#接口和内省

#可以查看方法是否存在（接口）

print hasattr(tc, 'talk')

#True

print hasattr(tc, 'fnord')

#False

#小结

#对象

#对象包括特性和方法。特性只是作为对象的一部分的变量，方法则是存储在对象内的函数。（绑定）方法和其他函数的区别在于方法总是将对象作为自己的第一个参数，这个参数一般称为self。

#类

#类代表对象的集合（或一类对象），每个对象（实例）都有一个类。类的主要任务是定义它的实例会用到方法。

#多态

#多态是实现将不同类型和类的对象进行同样对待的特性---不需要知道对象属于哪个类就能调用的方法。

#封装

#对象可以将它们的内部状态隐藏（或封装）起来。在一些语言中，这意味着对象的状态（特性）只对自己的方法可用。在Python中，所有的特性都是公开可用的，但是程序员应该在直接访问对象状态时谨慎行事，因为他们可能无意中使得这些特性在某些方面不一致。

#继承

#一个类可以是一个或者多个类的子类。子类从超类继承所有方法。可以使用多个超类，这个特性可以用来组成功能的正交部分（没有任何联系）。普通的实现方式是使用核心的超类和一个或者多个混合的超类。

#接口和内省

#一般来说，对于对象不用探讨过深。程序猿可以靠多态调用自己需要的方法。不过如果想要知道对象到底有什么方法和特性，有些函数可以帮助完成这项工作。

#面向对象设计

#关于如何（或者说是否应该进行）面向对象设计有很多的观点。不管你持什么观点，完全理解这个问题，并且创建容易理解的设计是很重要的。