Das deutsche Python-Forum

Code: Alles auswählen

found = set()
res = []
for i, sublist in enumerate(unterliste):
    for j, item in enumerate(sublist):
         if item in found: 
                res.append((I, j))
          found.add(item)

Code: Alles auswählen

e = 0
d = len(test)
f = 0
count = 0
while e <= d:
    for x in test:
	if test[f][1] in x:
	    count = count + 1
	elif count >= 1:
	    with open(my_test2_path,'a') as my_test2:
		my_test2.write(str(test[f][1]) + " : " + str(count) + "\n")
		count = 0
		f = f + 1
	elif count == 1 or count <= 1:
	    count = 0
	    f = f + 1
    e = e +1

Code: Alles auswählen

f = 0
count = 0
with open(my_test2_path,'a') as output:
    for _ in test:
        for x in test:
            if test[f][1] in x:
                count += 1
            else:
                if count >= 1:
                    output.write(f"{test[f][1]} : {count}\n")
                count = 0
                f += 1

Code: Alles auswählen

#!/usr/bin/env python3
from collections import defaultdict


def main():
    data = [['A', 'B'], ['C', 'D'], ['E', 'F'], ['C', 'E'], ['F', 'C']]
    print(data)

    letter2paths = defaultdict(list)
    for i, letters in enumerate(data):
        for j, letter in enumerate(letters):
            letter2paths[letter].append((i, j))
    
    for letter, paths in sorted(letter2paths.items()):
        path_count = len(paths)
        if path_count > 1:
            paths_string = ', '.join(f'[{i}][{j}]' for i, j in paths)
            print(f'{letter!r} kommt {path_count} mal vor: {paths_string}.')


if __name__ == '__main__':
    main()

Code: Alles auswählen

[['A', 'B'], ['C', 'D'], ['E', 'F'], ['C', 'E'], ['F', 'C']]
'C' kommt 3 mal vor: [1][0], [3][0], [4][1].
'E' kommt 2 mal vor: [2][0], [3][1].
'F' kommt 2 mal vor: [2][1], [4][0].

Code: Alles auswählen

#!/usr/bin/env python3
from collections import defaultdict


def main():
    data = [["A", "B"], ["C", "D"], ["E", "F"], ["C", "E"], ["F", "C"]]
    print(data)

    letter2paths = defaultdict(list)
    for i, letters in enumerate(data):
        for j, letter in enumerate(letters):
            letter2paths[letter].append((i, j))

    for letter, paths in sorted(letter2paths.items()):
        path_count = len(paths)
        if path_count > 1:
            paths_string = ", ".join("[{}][{}]".format(i, j) for i, j in paths)
            print(
                "{!r} kommt {} mal vor: {}.".format(
                    letter, path_count, paths_string
                )
            )


if __name__ == "__main__":
    main()

Code: Alles auswählen

In [94]: 'parrot' == "parrot"
Out[94]: True

Code: Alles auswählen

#!/usr/bin/env python3
from collections import defaultdict


def main():
    data = [["A", "B"], ["C", "D"], ["E", "F"], ["C", "E"], ["F", "C"]]
    print(data)

    letter2paths = defaultdict(list)
    for i, letters in enumerate(data):
        for j, letter in enumerate(letters):
            letter2paths[letter].append((i, j))

    for letter, paths in sorted(letter2paths.items()):
        path_count = len(paths)
        if path_count > 1:
            paths_string = ", ".join("[{}][{}]".format(i, j) for i, j in paths)
            print(
                "{!r} kommt {} mal vor: {}.".format(
                    letter, path_count, paths_string
                )
            )
    
    seen = set()
    result = list()
    for letters in data:
        filtered_letters = list()
        for letter in letters:
            if letter not in seen:
                seen.add(letter)
                filtered_letters.append(letter)
        result.append(filtered_letters)
    print(result)
    

if __name__ == "__main__":
    main()

Code: Alles auswählen

[['A', 'B'], ['C', 'D'], ['E', 'F'], ['C', 'E'], ['F', 'C']]
'C' kommt 3 mal vor: [1][0], [3][0], [4][1].
'E' kommt 2 mal vor: [2][0], [3][1].
'F' kommt 2 mal vor: [2][1], [4][0].
[['A', 'B'], ['C', 'D'], ['E', 'F'], [], []]

Code: Alles auswählen

#!/usr/bin/env python3
from collections import defaultdict
from glom import Flatten, glom, Merge, Path, SKIP


class GetPath:
    @staticmethod
    def glomit(target, scope):
        return (target, scope[Path])


class UnseenOnly:
    def __init__(self):
        self.seen = set()

    def glomit(self, target, _scope):
        if target in self.seen:
            return SKIP
        else:
            self.seen.add(target)
            return target


def target_to_paths():
    def init():
        return defaultdict(list)

    def update(mapping, pair):
        target, path = pair
        mapping[target].append(path)

    return Merge(init=init, op=update)


def format_path(path):
    return "".join(map("[{}]".format, path))


def format_paths(paths):
    return ", ".join(map(format_path, paths))


def print_duplicates(data):
    spec = (
        [[GetPath()]],
        Flatten(init="lazy"),
        target_to_paths(),
        lambda t: sorted((x, ps) for x, ps in t.items() if len(ps) > 1),
    )
    for letter, paths in glom(data, spec):
        print(
            "{!r} kommt {} mal vor: {}.".format(
                letter, len(paths), format_paths(paths)
            )
        )


def main():
    data = [["A", "B"], ["C", "D"], ["E", "F"], ["C", "E"], ["F", "C"]]
    print(data)

    print_duplicates(data)

    filtered_data = glom(data, [[UnseenOnly()]])
    print(filtered_data)


if __name__ == "__main__":
    main()