python operator模块学习

>>> a=2
>>> b=5
>>> from operator import *
>>> not_(a)
False
>>> truth(a)
True
>>> is_(a, b)
False
>>> is_not(a,b)
True

from operator import *
a = 1
b = 5
for func in (lt, le, eq, ne, ge, gt):
    print func(a,b)

a = [1,2,3]
b = ['a', 'b', 'c']
print concat(a,b)
print repeat(a,3)

print contains(a,1)    
print contains(b,"d")   
print countOf(a)
print countOf(b,"d")
print indexOf(a,1)

>>> from operator import *
>>> a=[1,2,3]
>>> b=['a','b','c']
>>> getitem(b,1)
'b'
>>> getslice(a,1,3)
[2, 3]
>>> setitem(b,1,'d')
>>> b
['a', 'd', 'c']
>>> setslice(a,1,3,[4,5])
>>> a
[1, 4, 5]

>>> delitem(b,1)
>>> b
['a', 'c']
>>> delslice(a,1,3)
>>> a
[1]

>>> a=-1
>>> b=5
>>> c=[1,2,3]
>>> d=['a','b','c']
>>> a=iadd(a,b)
>>> a
4
>>> c=iconcat(c,d)
>>> c
[1, 2, 3, 'a', 'b', 'c']

from operator import *
class MyObj(object):
    def __init__(self, arg):
        super(MyObj, self).__init__()
        self.arg = arg
    def __repr__(self):
        return 'MyObj(%s)' % self.arg

objs = [MyObj(i) for i in xrange(5)]
print "Object:", objs

g = attrgetter("arg")
vals = [g(i) for i in objs]
print "arg values:", vals

objs.reverse()
print "reversed:", objs
print "sorted:", sorted(objs, key=g)

Object: [MyObj(0), MyObj(1), MyObj(2), MyObj(3), MyObj(4)]
arg values: [0, 1, 2, 3, 4]
reversed: [MyObj(4), MyObj(3), MyObj(2), MyObj(1), MyObj(0)]
sorted: [MyObj(0), MyObj(1), MyObj(2), MyObj(3), MyObj(4)]

from operator import *

l = [dict(val=-1*i) for i in xrange(4)]
print "dictionaries:", l
g = itemgetter("val")
vals  = [g(i) for i in l]
print "values: ", vals
print "sorted:", sorted(l, key=g)

l = [(i,i*-2) for i in xrange(4)]
print "tuples: ", l
g = itemgetter(1)
vals = [g(i) for i in l]
print "values:", vals
print "sorted:", sorted(l, key=g)

dictionaries: [{'val': 0}, {'val': -1}, {'val': -2}, {'val': -3}]
values:  [0, -1, -2, -3]
sorted: [{'val': -3}, {'val': -2}, {'val': -1}, {'val': 0}]
tuples:  [(0, 0), (1, -2), (2, -4), (3, -6)]
values: [0, -2, -4, -6]
sorted: [(3, -6), (2, -4), (1, -2), (0, 0)]

from operator import *

class MyObj(object):
    def __init__(self, val):
        super(MyObj, self).__init__()
        self.val = val
        return 

    def __str__(self):
        return "MyObj(%s)" % self.val

    def __lt__(self, other):
        return self.val < other.val

    def __add__(self, other):
        return MyObj(self.val + other.val)

a = MyObj(1)
b = MyObj(2)

print lt(a, b)
print add(a,b)

True
MyObj(3)

from operator import *

class NoType(object):
    pass

class MultiType(object):
    def __len__(self):
        return 0

    def __getitem__(self, name):
        return "mapping"

    def __int__(self):
        return 0

o = NoType()
t = MultiType()

for func in [isMappingType, isNumberType, isSequenceType]:
    print "%s(o):" % func.__name__, func(o)
    print "%s(t):" % func.__name__, func(t)

isMappingType(o): False
isMappingType(t): True
isNumberType(o): False
isNumberType(t): True
isSequenceType(o): False
isSequenceType(t): True

from operator import methodcaller

class Student(object):
    def __init__(self, name):
        self.name = name

    def getName(self):
        return self.name

stu = Student("Jim")
func = methodcaller('getName')
print func(stu)   # 输出Jim

f=methodcaller('name', 'foo', bar=1)
f(b)    # return   b.name('foo', bar=1)

def methodcaller(name, *args,  **kwargs):
      def caller(obj):
            return getattr(obj, name)(*args, **kwargs)
      return caller