Das deutsche Python-Forum

Code: Alles auswählen

myList = [
    ("foo", "bar"),
    ("blah", "blubb")
]

Code: Alles auswählen

def inList(x, l):
    r = []
    for i in l:
        if i == x:
            r.append(i)
    return r

print inList(("foo", "bar"), myList)

Code: Alles auswählen

def inList(x, l):
    return [i for i in l if i == x]

print inList(("foo", "bar"), myList)

Code: Alles auswählen

def in_list(x, l):
    return filter(lambda i: x == i, l)

Code: Alles auswählen

print inList(('foo', 'bar'), myList) *10000000

Code: Alles auswählen

print in_list(('foo', 'bar'), myList) *1000000

Code: Alles auswählen

for a in range(1000000):
    print in_list(('foo', 'bar'), myList)

Code: Alles auswählen

In [20]: import dis

In [21]: def a(x, l):
   ....:     r = []
   ....:     for i in l:
   ....:         if i == x:
   ....:             r.append(i)
   ....:     return r
   ....:

In [22]: def b(x, l):
   ....:     return [i for i in l if i == x]
   ....:

In [23]: dis.dis(a)
  2           0 BUILD_LIST               0
              3 STORE_FAST               3 (r)

  3           6 SETUP_LOOP              44 (to 53)
              9 LOAD_FAST                1 (l)
             12 GET_ITER
        >>   13 FOR_ITER                36 (to 52)
             16 STORE_FAST               2 (i)

  4          19 LOAD_FAST                2 (i)
             22 LOAD_FAST                0 (x)
             25 COMPARE_OP               2 (==)
             28 JUMP_IF_FALSE           17 (to 48)
             31 POP_TOP

  5          32 LOAD_FAST                3 (r)
             35 LOAD_ATTR                4 (append)
             38 LOAD_FAST                2 (i)
             41 CALL_FUNCTION            1
             44 POP_TOP
             45 JUMP_ABSOLUTE           13
        >>   48 POP_TOP
             49 JUMP_ABSOLUTE           13
        >>   52 POP_BLOCK

  6     >>   53 LOAD_FAST                3 (r)
             56 RETURN_VALUE

In [24]: dis.dis(b)
  2           0 BUILD_LIST               0
              3 DUP_TOP
              4 STORE_FAST               2 (_[1])
              7 LOAD_FAST                1 (l)
             10 GET_ITER
        >>   11 FOR_ITER                30 (to 44)
             14 STORE_FAST               3 (i)
             17 LOAD_FAST                3 (i)
             20 LOAD_FAST                0 (x)
             23 COMPARE_OP               2 (==)
             26 JUMP_IF_FALSE           11 (to 40)
             29 POP_TOP
             30 LOAD_FAST                2 (_[1])
             33 LOAD_FAST                3 (i)
             36 LIST_APPEND
             37 JUMP_ABSOLUTE           11
        >>   40 POP_TOP
             41 JUMP_ABSOLUTE           11
        >>   44 DELETE_FAST              2 (_[1])
             47 RETURN_VALUE

Code: Alles auswählen

myList = [
    ("foo", "bar"),
    ("blah", "blubb")
]

def inList(x, l):
    if len([i for i in l if i == x]) == 0:
        return False
    else:
        return True

print inList(("foo", "bar"), myList)

Code: Alles auswählen

myDict = {
    1: ("foo", "bar"),
    2: ("blah", "blubb")
}

def inDict(v, d):
    for i in d:
        if d[i] == v:
            return True
    return False

print inDict(("foo", "bar"), myDict)

Code: Alles auswählen

cache = []
cache.append(("foo", "bar"))
cache.append(("blah", "blubb"))

Code: Alles auswählen

("foo", "bar") in myDict.values()

Code: Alles auswählen

print ('foo', 'bar') in my_dict.itervalues()

Code: Alles auswählen

#!/usr/bin/python

class FlatTree:
	""" Is a flatened model of a tree like a SQL table. Consists of a list of
	values (e.g. directory or file names) with a unique ID and their parent ID.
	
	Example: /foo/bar
	
	id | value | parentID
	---+-------+---------
	 1 |       | None
	 2 | foo   | 1
	 3 | bar   | 2 """
	def __init__(self):
		self.ID = 0
		self.tree = {}
		# caching needs more memory but makes `GetTreeID` working faster
		self.caching = True
		self.cache = {}
	
	def CreateID(self):
		""" Raises unique ID and returns it. """
		self.ID += 1
		return self.ID
	
	def AddBranch(self, value, parentID=None, attributes=None):
		""" Adds a child node to a parent node and returns the new unique
		ID. """
		ID = self.CreateID()
		self.tree[ID] = {}
		self.tree[ID]['value'] = value
		self.tree[ID]['attributes'] = attributes
		self.tree[ID]['parentID'] = parentID
		if self.caching == True:
			# cache value and parent ID as unique identifiers
			self.cache[(value, parentID)] = ID
		return ID
	
	def AddRoot(self, value, attributes=None):
		""" Adds a root node having no parent node and returns the new unique
		ID. """
		return self.AddBranch(value, None, attributes)
	
	def RebuildPath(self, ID):
		""" Rebuilds the full path from a unique ID in the tree by going
		through it recursively. Returns False if ID is not in the tree.
		Otherwise returns a list of values that can be concatenated. """
		path = []
		parentID = ID
		while parentID is not None:
			parent = self.tree[parentID]
			parentID = parent['parentID']
			path.append(parent['value'])
		path.reverse()
		return path
	
	def GetTreeID(self, value, parentID):
		""" Checks if value and parentID are present in the tree. If yes, it
		returns the unique ID of the tree item containing both. If no, it
		returns False. """
		if self.caching == True:
			# with caching the ID can be found much faster
			if (value, parentID) in self.cache:
				return self.cache[(value, parentID)]
			else:
				return False
		else:
			# without caching the ID will be searched
			for ID in self.tree:
				if self.tree[ID]['value'] == value and self.tree[ID]['parentID'] == parentID:
					return  ID
			return False

if __name__ == "__main__":
	t = FlatTree()
	root = t.AddRoot("")
	foo = t.AddBranch("foo", root)
	bar = t.AddBranch("bar", foo)
	print "/".join(t.RebuildPath(bar))

Code: Alles auswählen

class PathElement(object):
    def __init__(self, name, parent, attributes):
        self.name = name
        self.parent = parent
        self.attributes = attributes
    
    def __cmp__(self, other):
        return (cmp(self.name, other.name)
                or cmp(id(self.parent), id(other.parent)))
    
    def __hash__(self):
        return hash((self.name, id(self.parent)))
    
    def path_to_element(self):
        result = [self.name]    # Oder nur [].
        parent = self.parent
        while parent is not None:
            result.append(parent.name)
            parent = parent.parent
        result.reverse()
        return result