示例

# -*- coding: cp936 -*-
#类型检查
x = (1,2,3)
print isinstance(x, tuple) #是否为元组类型
print isinstance(x, list) #是否为列表类型
print isinstance(x, str) #是否为字符串类型
print isinstance(x, dict) #是不为字典类型
print isinstance(x, int) #是否为整型
print isinstance(x, float) #是否为浮点型

#count函数: 统计字符出现的个数
print 'abca'.count('a')
print [1,2,'a'].count('a')

from random import choice
x = choice(['Hello,world!', [1,2,'e',4]]) #choice方法:随机从列表中选择1项
print x.count('e');

#定义一个类
#类中定义的变量在Python中称为特性
__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

print '调用类'
foo = Person()
bar = Person()
foo.setName('Luke Skywalker')
bar.setName('Anakin Skywalker')
foo.greet()
bar.greet()
#或者这样调用
Person.greet(foo)
Person.greet(bar)
print '访问特性'
print foo.name
bar.name = 'Yoda'
bar.greet()

print '将特性绑定到普通函数上'
class Class:
    def method(self):
        print 'I have a self!'

def function():
    print "I don't'..."

instance = Class()
instance.method()
instance.method = function
instance.method()

class Bird:
    song = 'Squaawk!'
    def sing(self):
        print self.song

bird = Bird()
bird.sing()
birdsong = bird.sing
birdsong()

print '特性私有化(外部不能访问)'
#在它的名字前面加上双下划线即可
#前面带星号的名字都不会被带星号的import语句(from module import *)导入
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()

class C:
    print 'Class C being defined...'#类的作用域内也可以写普通代码语句


print '类的命名空间'
class MemberCounter:
    members = 0 #此变量的作用域为类
    def init(self):
        MemberCounter.members += 1 #类变量加1


m1 = MemberCounter()
m1.init()
print MemberCounter.members
m2 = MemberCounter()
m2.init()
print MemberCounter.members
print m1.members
print m2.members

print '重绑实例特性' #只影响单个实例
m1.members = 'Two'
print m1.members
print m2.members

print '指定超类'
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): #Filter是SPAMFilter的父类
    def init(self): #重写Filter超类中的init方法
        self.blocked = ['SPAM']

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


#判断一个类是否为另一个类的子类
print 'issubclass函数'
print issubclass(SPAMFilter, Filter)
print issubclass(Filter, SPAMFilter)

print '查看已知类的基类'
print SPAMFilter.__bases__
print Filter.__bases__

#检查一个对象是否为一个类的实例
print 'isinstance函数'
s = SPAMFilter()
print isinstance(s, SPAMFilter)
print isinstance(s, Filter)
print isinstance(s, str)

print '查看已知对象所属类'
print s.__class__
#如果使用_metaclass__=type或从object继承的方式来定义新式类,那么可以使用type(s)
#查看实例所属的类。
print type(s)

print '多个超类'
class Calculator:
    def calculate(self, expression):
        self.value = eval(expression)

class Talker:
    def talk(self):
        print 'Hi, my value is', self.value

#注意：先继承的类会覆盖后继承类的同名方法
#如果Calculator类中也有talk方法,Talker中的talk方法会被覆盖。
class TalkingCalculator(Calculator, Talker):#多重继承
    pass #这个类什么也不做

tc = TalkingCalculator()
tc.calculate('1+2*3')
tc.talk()

print '检查特性是否存在'
print hasattr(tc, 'talk')
print hasattr(tc, 'fnord')

print '检查特性是否可调用'
#callable函数在Python3.0中已不再可用,可以使用hasattr(x.'__call__')来代替。
print callable(getattr(tc, 'talk', None))
print callable(getattr(tc, 'fnord', None))

print '设置对象特性'
setattr(tc, 'name', 'Mr.Gumby')
print tc.name

print '查看对象内所有存储的值'
print tc.__dict__

#inspect模块可查看对象由什么组成(编写对象浏览器编程有用)

运行测试