>>> \'abc\'.count(\'a\')
1
>>> [1,2,3,\'a\',\'a\'].count(\'a\')
2

>>> from random import choice
>>> x=choice([\'Hello\',\'Python\',[1,2,3,4,\'e\',\'e\',]])
>>> x.count(\'e\')
1

>>> def add(x,y):
    return x+y

>>> add(1,2)
3
>>> add(\'jiamemg \',\'is so cool!\')
\'jiamemg is so cool!\'
>>> 1+2
3
>>> \'jiameng \'+\'is so cool!\'
\'jiameng is so cool!\'
#加法运算符不仅可以用于数，也可以用于字符串

>>> def length_message(x):
    print(\'the length of\',repr(x),\'is\',len(x))

#如你所见，这里使用了repr函数，repr函数是多态的集大成者之一，可用于任何对象  
>>> length_message(\'jiameng\')
the length of \'jiameng\' is 7
>>> length_message([1,2,3,4,5,6,7,8,9])
the length of [1, 2, 3, 4, 5, 6, 7, 8, 9] is 9
#如你所见，这个函数也是支持多态的，虽然你编写的时候可能不没有意识到这一点

>>> class person:
    def set_name(self ,name ):
        self.name=name;
    def get_name(self):
        return self.name
    def grett(self):
        print("Hello,Python!I\'m {}.".format(self.name))

#关键来了，关键来了，虽然这个示例很简单，但是它说清了self是什么！
        
>>> foo=person()
>>> bar=person()
>>> foo.set_name(\'jiameng\')
>>> bar.set_name(\'wangweili\')
>>> foo.grett()
Hello,Python!I\'m jiameng.
>>> bar.grett()
Hello,Python!I\'m wangweili.
#对foo调用set_name和grett时，foo都会作为第一个参数自动传递给它们。我们将这个参数命名为self。
#显然self很有用，如果没有它，所有的方法都无法访问对象本身——要操作的属性所属的对象
#与以前一样，也可以从外部访问他们
>>> foo.name
\'jiameng\'
>>> bar.name
\'wangweili\'

>>> class Class:
    def method(self):
        print(\'I have a self\')

        
>>> def function():
    print("I don\'t have")

    
>>> instance=Class()
>>> instance.method()
I have a self
>>> instance.method=function
>>> instance.method()
I don\'t have

>>> bird=Bird()
>>> bird.sing()
Squaawk!
>>> birdsong=bird.sing
>>> birdsong()
Squaawk!
#虽然最后一种方法调用看起来像是函数调用，单变量birdsong指向的是关联的方法bird.sing，这意味着它也能够访问参数self（即它也能够被关联到类的实例）

>>> 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()
Traceback (most recent call last):
  File "<pyshell#128>", line 1, in <module>
    s.__inaccessible()
AttributeError: \'Secretive\' object has no attribute \'__inaccessible\'
>>> s.accessible()
The secret message is ...
Bet you can\'t see me ...
#虽然以两个下划线打头有点怪异，但这样的方法类似于其它语言中的标准私有方法。

>>> Secretive._Secretive__inaccessible
<function Secretive.__inaccessible at 0x000002BC8D06E620>
#只要知道这种幕后处理方式之后，你就可以从外部继续访问了，但你不应该这样做。
>>> s._Secretive__inaccessible()
Bet you can\'t see me ...
#总之，你无法阻止别人访问对象的私有方法和属性，你只是以这种方式告诉他们不要这么做.....

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

        
>>> m1=MemberCounter()
>>> m1.init()
>>> MemberCounter.members
1
>>> m2=MemberCounter()
>>> m2.init()
>>> MemberCounter.members
2

>>> m1.members=\'AAA\'
>>> m1.members
\'AAA\'
>>> m2.members
2

>>> class Filter:
    def init(self):
        self.blocked=[]
    def filiter(self,sequence):
        return [x for x in sequence if x not in self.blocked ]

    
>>> 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):
    def init(self):#重写方法
        self.blocked=[\'SPAM\']

        
>>> f=Filter()
>>> f.init()
>>> f.filter([1,2,3,4,5,6])
[1, 2, 3, 4, 5, 6]
>>> s=SPAMFilter()
>>> s.init()
>>> s.filter([\'SPAM\',\'SPAM\',\'jiameng\',\'wangweili\'])
[\'jiameng\', \'wangweili\']

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

>>> SPAMFilter.__bases__
(<class \'__main__.Filter\'>,)

>>> isinstance(s,SPAMFilter)
True
>>> isinstance(s,Filter)
True
#如你所见，s也是Filter的实例

>>> s.__class__
<class \'__main__.SPAMFilter\'>
>>> type(s)
<class \'__main__.SPAMFilter\'>
#对于新式类（无论是通过使用 __mataclass__=type还是通过object继承创建的）的实例，还可以使用type(s)来获悉其所属的类。对于旧式类的实例，type都是返回instance

>>> hasattr(tc,\'talk\')#tc 包含属性talk
>>>Ture

>>> callable(getattr(tc,\'talk\',None))#检查属性talk是否可以被调用，请注意，这里没有在if语句中使用hasattr来直接访问属性，而是使用了getattr(它让我能够指定属性不存在时使用的默认值，这里为None),然后对返回的对象调用callable
>>>Ture

>>> setattr(tc,\'name\',\'Mr.Jia\')
>>> tc.name
 \'Mr.Jia\'

>>> from abc import ABC,abstractmethod
>>> class Talker(ABC):
    @abstractmethod#装饰器，这里的作用是将方法标记为抽象的
    def talk(self):
        pass

    
>>> Talker()
Traceback (most recent call last):
  File "<pyshell#214>", line 1, in <module>
    Talker()
TypeError: Can\'t instantiate abstract class Talker with abstract methods talk
#上边报错，是因为抽象类不能被实例化

#派生一个子类
>>> class knigget(Talker):
    pass


#上边实例化也会报错，下面重写方法talk
>>> class Knigget(Talker):
    def talk(self):
        print("Hi!")

#实例化完全没有问题。这是抽象类的主要用途。只有在这种情况下，使用isinstance 才是安全的：如果先检查给定的实例确实是Talker对象，就能相信这个实例在有需要的时候才有方法talk        
>>> k=Knigget()
>>> isinstance(k,Talker)
True
>>> k.talk()
Hi!

>>> class Herring:
    def talk(self):
        print("Blub.")

#这个类可以通过是否是Talker对象的检查，但它并不是Talker的对象        
>>> h=Herring()
>>> isinstance(h,Talker)
False

#诚然，你可以直接从Talker派生出herring但这样Herring也可能是从其他人的模块中导入的。在这种情况下，就无法采用这种方法。
#为了解决这个问题，你可以将Herring注册为Talker,这样所有的Herring对象都会被看做talker对象。
>>> Talker.register(Herring)
<class \'__main__.Herring\'>
>>> isinstance(h,Talker)
True
>>> issubclass(Herring,Talker)
True

>>> class Clam:
    pass

>>> 
>>> Talker.register(Clam)
<class \'__main__.Clam\'>
>>> issubclass(Clam,Talker)
True
>>> c=Clam()
>>> isinstance(c,Talker)
True
>>> c.talk()
Traceback (most recent call last):
  File "<pyshell#243>", line 1, in <module>
    c.talk()
AttributeError: \'Clam\' object has no attribute \'talk\'