Как составить список последовательности изображений эффективным способом?Сравнение числовых последовательностей в Python

Question

У меня есть каталог из 9 изображений:

image_0001, image_0002, image_0003
image_0010, image_0011
image_0011-1, image_0011-2, image_0011-3
image_9999

Я хотел бы иметь возможность эффективно перечислять их, например, так (4 записи для 9 изображений):

(image_000[1-3], image_00[10-11], image_0011-[1-3], image_9999)

Есть ли в python способ вернуть каталог изображений кратким / понятным способом (без перечисления каждого файла)?

Итак, возможно что-то вроде этого:

перечислить все изображения, отсортировать их численно, создать список (считая каждое изображение в последовательности от начала). Если изображение отсутствует (создайте новый список), продолжайте, пока не закончится оригинальный список файлов. Теперь у меня должны быть несколько списков, которые содержат неразорванные последовательности.

Я пытаюсь облегчить чтение / описание списка чисел. Если бы у меня была последовательность из 1000 последовательных файлов, она могла бы быть четко указана как файл [0001-1000], а не как файл ['0001', '0002', '0003' и т. Д.]]

Редактировать1 (на основе предложения): При наличии сплюснутого списка, как бы вы получили паттерны глобуса?

Edit2 Я пытаюсь разбить проблему на более мелкие части. Вот пример части решения: data1 работает, data2 возвращает 0010 как 64, data3 (данные реального мира) не работают:

# Find runs of consecutive numbers using groupby.  The key to the solution
# is differencing with a range so that consecutive numbers all appear in
# same group.
from operator import itemgetter
from itertools import *

data1=[01,02,03,10,11,100,9999]
data2=[0001,0002,0003,0010,0011,0100,9999]
data3=['image_0001','image_0002','image_0003','image_0010','image_0011','image_0011-2','image_0011-3','image_0100','image_9999']

list1 = []
for k, g in groupby(enumerate(data1), lambda (i,x):i-x):
    list1.append(map(itemgetter(1), g))
print 'data1'
print list1

list2 = []
for k, g in groupby(enumerate(data2), lambda (i,x):i-x):
    list2.append(map(itemgetter(1), g))
print '\ndata2'
print list2

возвращается:

data1
[[1, 2, 3], [10, 11], [100], [9999]]

data2
[[1, 2, 3], [8, 9], [64], [9999]]

Answer 1

Вот рабочая реализация того, чего вы хотите достичь, используя код, который вы добавили в качестве отправной точки:

#!/usr/bin/env python

import itertools
import re

# This algorithm only works if DATA is sorted.
DATA = ["image_0001", "image_0002", "image_0003",
        "image_0010", "image_0011",
        "image_0011-1", "image_0011-2", "image_0011-3",
        "image_0100", "image_9999"]

def extract_number(name):
    # Match the last number in the name and return it as a string,
    # including leading zeroes (that's important for formatting below).
    return re.findall(r"\d+$", name)[0]

def collapse_group(group):
    if len(group) == 1:
        return group[0][1]  # Unique names collapse to themselves.
    first = extract_number(group[0][1])  # Fetch range
    last = extract_number(group[-1][1])  # of this group.
    # Cheap way to compute the string length of the upper bound,
    # discarding leading zeroes.
    length = len(str(int(last)))
    # Now we have the length of the variable part of the names,
    # the rest is only formatting.
    return "%s[%s-%s]" % (group[0][1][:-length],
        first[-length:], last[-length:])

groups = [collapse_group(tuple(group)) \
    for key, group in itertools.groupby(enumerate(DATA),
        lambda(index, name): index - int(extract_number(name)))]

print groups

Это печатает ['image_000[1-3]', 'image_00[10-11]', 'image_0011-[1-3]', 'image_0100', 'image_9999'], что вам нужно.1006 * ИСТОРИЯ: Сначала я ответил на вопрос задом наперед, как @Mark Ransom указал ниже.Ради истории, мой первоначальный ответ был:

Вы ищете glob .Попробуйте:

import glob
images = glob.glob("image_[0-9]*")

Или, используя ваш пример:

images = [glob.glob(pattern) for pattern in ("image_000[1-3]*",
    "image_00[10-11]*", "image_0011-[1-3]*", "image_9999*")]
images = [image for seq in images for image in seq]  # flatten the list

Answer 2

Хорошо, я нашел ваш вопрос увлекательной загадкой.Я оставил, как «сжимать» числовые диапазоны до вас (помеченные как TODO), так как есть разные способы сделать это в зависимости от того, как вам нравится форматирование и хотите ли вы минимальное количество элементов или минимальную строкудлина описания.

Это решение использует простое регулярное выражение (цифровые строки) для классификации каждой строки на две группы: статическую и переменную.После того, как данные классифицированы, я использую groupby для сбора статических данных в самые длинные совпадающие группы для достижения суммарного эффекта.Я смешиваю целочисленные индексы в результат (в matchGrouper), чтобы я мог повторно выбрать изменяющиеся части из всех элементов (в распакованном виде). ​​

import re
import glob
from itertools import groupby
from operator import itemgetter

def classifyGroups(iterable, reObj=re.compile('\d+')):
    """Yields successive match lists, where each item in the list is either
    static text content, or a list of matching values.

     * `iterable` is a list of strings, such as glob('images/*')
     * `reObj` is a compiled regular expression that describes the
            variable section of the iterable you want to match and classify
    """
    def classify(text, pos=0):
        """Use a regular expression object to split the text into match and non-match sections"""
        r = []
        for m in reObj.finditer(text, pos):
            m0 = m.start()
            r.append((False, text[pos:m0]))
            pos = m.end()
            r.append((True, text[m0:pos]))
        r.append((False, text[pos:]))
        return r

    def matchGrouper(each):
        """Returns index of matches or origional text for non-matches"""
        return [(i if t else v) for i,(t,v) in enumerate(each)]

    def unpack(k,matches):
        """If the key is an integer, unpack the value array from matches"""
        if isinstance(k, int):
            k = [m[k][1] for m in matches]
        return k

    # classify each item into matches
    matchLists = (classify(t) for t in iterable)

    # group the matches by their static content
    for key, matches in groupby(matchLists, matchGrouper):
        matches = list(matches)
        # Yield a list of content matches.  Each entry is either text
        # from static content, or a list of matches
        yield [unpack(k, matches) for k in key]

Наконец, мы добавили достаточно логики, чтобы выполнить красивую печатьВыведите и запустите пример.

def makeResultPretty(res):
    """Formats data somewhat like the question"""
    r = []
    for e in res:
        if isinstance(e, list):
            # TODO: collapse and simplify ranges as desired here
            if len(set(e))<=1:
                # it's a list of the same element
                e = e[0]
            else: 
                # prettify the list
                e = '['+' '.join(e)+']'
        r.append(e)
    return ''.join(r)

fnList = sorted(glob.glob('images/*'))
re_digits = re.compile(r'\d+')
for res in classifyGroups(fnList, re_digits):
    print makeResultPretty(res)

Мой каталог изображений был создан из вашего примера.Вы можете заменить fnList следующим списком для тестирования:

fnList = [
 'images/image_0001.jpg',
 'images/image_0002.jpg',
 'images/image_0003.jpg',
 'images/image_0010.jpg',
 'images/image_0011-1.jpg',
 'images/image_0011-2.jpg',
 'images/image_0011-3.jpg',
 'images/image_0011.jpg',
 'images/image_9999.jpg']

И когда я запускаю этот каталог, мой вывод выглядит так:

StackOverflow/3926936% python classify.py
images/image_[0001 0002 0003 0010].jpg
images/image_0011-[1 2 3].jpg
images/image_[0011 9999].jpg

Answer 3

def ranges(sorted_list):
    first = None
    for x in sorted_list:
        if first is None:
            first = last = x
        elif x == increment(last):
            last = x
        else:
            yield first, last
            first = last = x
    if first is not None:
        yield first, last

Функция increment оставлена ​​в качестве упражнения для читателя.

Edit: вот пример того, как она будет использоваться с целыми числами вместо строк в качестве ввода.

def increment(x): return x+1

list(ranges([1,2,3,4,6,7,8,10]))
[(1, 4), (6, 8), (10, 10)]

Для каждого непрерывного диапазона на входе вы получаете пару, указывающую начало и конец диапазона.Если элемент не является частью диапазона, начальное и конечное значения идентичны.