Идиома Python для возврата первого элемента или None

Я уверен, что есть более простой способ сделать это, что просто не происходит со мной.

Я вызываю кучу методов, которые возвращают список. Список может быть пустым. Если список не пустой, я хочу вернуть первый элемент; в противном случае я хочу вернуть None. Этот код работает:

my_list = get_list()
if len(my_list) > 0: return my_list[0]
return None

Мне кажется, что для этого должна быть простая однострочная идиома, но я не могу об этом думать. Здесь?

Редактировать:

Причина, по которой я ищу здесь однострочное выражение, не в том, что мне нравится невероятно лаконичный код, а в том, что мне приходится писать много такого кода:

x = get_first_list()
if x:
    # do something with x[0]
    # inevitably forget the [0] part, and have a bug to fix
y = get_second_list()
if y:
    # do something with y[0]
    # inevitably forget the [0] part AGAIN, and have another bug to fix

То, что я хотел бы сделать, безусловно, может быть выполнено с помощью функции (и, вероятно, будет):

def first_item(list_or_none):
    if list_or_none: return list_or_none[0]

x = first_item(get_first_list())
if x:
    # do something with x
y = first_item(get_second_list())
if y:
    # do something with y

Я опубликовал вопрос, потому что меня часто удивляет, что могут делать простые выражения в Python, и я думал, что написание функции было бы глупо, если бы существовало простое выражение, которое могло бы сработать. Но, увидев эти ответы, кажется, что функция - это простое решение.

Python 2.6+

next(iter(your_list), None)

Если your_listможно None:

next(iter(your_list or []), None)

Python 2.4

def get_first(iterable, default=None):
    if iterable:
        for item in iterable:
            return item
    return default

Пример:

x = get_first(get_first_list())
if x:
    ...
y = get_first(get_second_list())
if y:
    ...

Другой вариант - встроить вышеуказанную функцию:

for x in get_first_list() or []:
    # process x
    break # process at most one item
for y in get_second_list() or []:
    # process y
    break

Чтобы избежать, breakвы можете написать:

for x in yield_first(get_first_list()):
    x # process x
for y in yield_first(get_second_list()):
    y # process y

Куда:

def yield_first(iterable):
    for item in iterable or []:
        yield item
        return

Лучший способ это:

a = get_list()
return a[0] if a else None

Вы также можете сделать это в одну строку, но программисту гораздо сложнее читать:

return (get_list()[:1] or [None])[0]

(get_list() or [None])[0]

Это должно работать.

Кстати, я не использовал переменную list, потому что это перезаписывает встроенную list()функцию.

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

Самый идиоматический способ Python - это использовать next () на итераторе, так как список итеративен . так же, как то, что @JFSebastian поместил в комментарии 13 декабря 2011 года.

next(iter(the_list), None)Это возвращает None, если the_listпусто. смотрите далее () Python 2.6+

или если вы точно знаете, the_listне пусто:

iter(the_list).next()смотрите iterator.next () Python 2.2+

Если вы обнаружите, что пытаетесь вырвать первое (или ничего) из понимания списка, вы можете переключиться на генератор, чтобы сделать это следующим образом:

next((x for x in blah if cond), None)

Pro: работает, если бла не индексируется. Con: это незнакомый синтаксис. Это полезно при хакерстве и фильтрации содержимого в ipython.

Решение ОП уже близко, есть всего несколько вещей, которые делают его более питонским.

Во-первых, нет необходимости получать длину списка. Пустые списки в Python оцениваются как False в проверке if. Просто скажи

if list:

Кроме того, это очень плохая идея - присваивать переменным, которые пересекаются с зарезервированными словами. "список" является зарезервированным словом в Python.

Итак, давайте изменим это на

some_list = get_list()
if some_list:

Действительно важным моментом, который здесь пропускают многие решения, является то, что все функции / методы Python возвращают None по умолчанию . Попробуйте следующее ниже.

def does_nothing():
    pass

foo = does_nothing()
print foo

Если вам не нужно возвращать None, чтобы досрочно завершить функцию, нет необходимости явно возвращать None. Очень кратко, просто верните первую запись, если она существует.

some_list = get_list()
if some_list:
    return list[0]

И, наконец, возможно, это подразумевалось, но просто чтобы быть явным (потому что явное лучше, чем неявное ), вы не должны заставлять вашу функцию получать список из другой функции; просто передайте это как параметр. Итак, конечный результат будет

def get_first_item(some_list): 
    if some_list:
        return list[0]

my_list = get_list()
first_item = get_first_item(my_list)

Как я уже сказал, OP уже почти у цели, и всего несколько прикосновений придают ему тот вкус Python, который вы ищете.

for item in get_list():
    return item

Честно говоря, я не думаю, что есть лучшая идиома: ваша ясна и лаконична - не нужно ничего «лучшего». Может быть, но это действительно дело вкуса, вы можете изменить if len(list) > 0:с if list:- пустым списком всегда будет оценивать Ложь.

С другой стороны, Python - это не Perl (не каламбур!), Вам не нужно получать самый крутой из возможных кодов.
На самом деле, худший код, который я видел в Python, также был очень крутым :-) и совершенно не поддерживаемым.

Кстати, большинство решений, которые я видел здесь, не учитывается, когда list [0] оценивается как False (например, пустая строка или ноль) - в этом случае все они возвращают None, а не правильный элемент.

Идиома Python для возврата первого элемента или нет?

Самый питонский подход - это то, что продемонстрировал самый голосующий голос, и это было первое, что пришло мне в голову, когда я прочитал вопрос. Вот как это использовать, во-первых, если возможно пустой список передается в функцию:

def get_first(l): 
    return l[0] if l else None

И если список возвращается из get_listфункции:

l = get_list()
return l[0] if l else None

Другие способы продемонстрировали, чтобы сделать это здесь, с объяснениями

for

Когда я начал пытаться придумать умные способы сделать это, это второе, о чем я подумал:

for item in get_list():
    return item

Это предполагает, что функция заканчивается здесь, неявно возвращая Noneif get_listвозвращает пустой список. Приведенный ниже явный код в точности соответствует

for item in get_list():
    return item
return None

if some_list

Было также предложено следующее (я исправил неправильное имя переменной), в котором также используется неявное None. Это было бы предпочтительнее вышеописанного, так как в нем используется логическая проверка вместо итерации, которая может не произойти. Это должно быть легче сразу понять, что происходит. Но если мы пишем для удобочитаемости и удобства сопровождения, мы также должны добавить явное return Noneв конце:

some_list = get_list()
if some_list:
    return some_list[0]

нарезать or [None]и выбрать нулевой индекс

Этот также в наиболее проголосовавшем ответе:

return (get_list()[:1] or [None])[0]

Срез не нужен, и создает дополнительный список из одного элемента в памяти. Следующее должно быть более производительным. Для объяснения orвозвращает второй элемент, если первый находится Falseв логическом контексте, поэтому, если get_listвозвращается пустой список, выражение, содержащееся в скобках, вернет список с «None», к которому затем будет обращаться 0индекс:

return (get_list() or [None])[0]

Следующий использует тот факт, что и возвращает второй элемент, если первый находится Trueв логическом контексте, и поскольку он дважды ссылается на my_list, он ничем не лучше троичного выражения (и технически не является однострочным):

my_list = get_list() 
return (my_list and my_list[0]) or None

next

Тогда у нас есть следующее умное использование встроенного nextиiter

return next(iter(get_list()), None)

Чтобы объяснить, iterвозвращает итератор с .nextметодом. ( .__next__В Python 3.) Тогда встроенные nextвызовы .nextметода, и если итератор будет исчерпан, возвращает значение по умолчанию мы даем, None.

избыточное троичное выражение ( a if b else c) и кружение назад

Было предложено ниже, но обратное было бы предпочтительнее, так как логика обычно лучше понимается в положительном, а не отрицательном. Так как get_listвызывается дважды, если результат не запомнен каким-либо образом, это будет плохо работать:

return None if not get_list() else get_list()[0]

Лучшее обратное:

return get_list()[0] if get_list() else None

Более того, используйте локальную переменную так, чтобы она get_listвызывалась только один раз, и у вас сначала было рекомендовано решение Pythonic:

l = get_list()
return l[0] if l else None

Что касается идиомы, есть itertools рецепт называется nth.

Из рецептов itertools:

def nth(iterable, n, default=None):
    "Returns the nth item or a default value"
    return next(islice(iterable, n, None), default)

Если вам нужны однострочные, рассмотрите возможность установки библиотеки, которая реализует этот рецепт для вас, например more_itertools:

import more_itertools as mit

mit.nth([3, 2, 1], 0)
# 3

mit.nth([], 0)                                             # default is `None`
# None

Доступен другой инструмент, который возвращает только первый названный элемент more_itertools.first.

mit.first([3, 2, 1])
# 3

mit.first([], default=None)
# None

Эти itertools масштабируются для любых итераций, а не только для списков.

my_list[0] if len(my_list) else None

Из любопытства я выбрал время для двух решений. Решение, которое использует оператор return для преждевременного завершения цикла for, немного дороже на моей машине с Python 2.5.1, я подозреваю, что это связано с настройкой итерируемого.

import random
import timeit

def index_first_item(some_list):
    if some_list:
        return some_list[0]


def return_first_item(some_list):
    for item in some_list:
        return item


empty_lists = []
for i in range(10000):
    empty_lists.append([])

assert empty_lists[0] is not empty_lists[1]

full_lists = []
for i in range(10000):
    full_lists.append(list([random.random() for i in range(10)]))

mixed_lists = empty_lists[:50000] + full_lists[:50000]
random.shuffle(mixed_lists)

if __name__ == '__main__':
    ENV = 'import firstitem'
    test_data = ('empty_lists', 'full_lists', 'mixed_lists')
    funcs = ('index_first_item', 'return_first_item')
    for data in test_data:
        print "%s:" % data
        for func in funcs:
            t = timeit.Timer('firstitem.%s(firstitem.%s)' % (
                func, data), ENV)
            times = t.repeat()
            avg_time = sum(times) / len(times)
            print "  %s:" % func
            for time in times:
                print "    %f seconds" % time
            print "    %f seconds avg." % avg_time

Это время, которое я получил:

empty_lists:
  index_first_item:
    0,748353 секунды
    0,741086 секунд
    0,741191 секунды
    0,743543 секунды
  return_first_item:
    0,785511 секунд
    0,822178 секунд
    0,782846 секунд
    0,796845 секунд
full_lists:
  index_first_item:
    0,762618 секунд
    0,788040 секунд
    0,786849 секунд
    0,779169 секунд
  return_first_item:
    0,802735 секунд
    0,878706 секунд
    0,808781 секунд
    0,830074 секунды
mixed_lists:
  index_first_item:
    0,791129 секунд
    0,743526 секунд
    0,744441 секунды
    0,759699 секунд
  return_first_item:
    0,784801 секунды
    0,785146 секунд
    0,840193 секунды
    0,803380 секунд в среднем

try:
    return a[0]
except IndexError:
    return None

def head(iterable):
    try:
        return iter(iterable).next()
    except StopIteration:
        return None

print head(xrange(42, 1000)  # 42
print head([])               # None

Кстати, я бы переделал ваш общий поток программ в нечто вроде этого:

lists = [
    ["first", "list"],
    ["second", "list"],
    ["third", "list"]
]

def do_something(element):
    if not element:
        return
    else:
        # do something
        pass

for li in lists:
    do_something(head(li))

(Избегая повторения, когда это возможно)

Как насчет этого:

(my_list and my_list[0]) or None

Примечание: Это должно работать нормально для списков объектов, но может возвращать неправильный ответ в случае списка чисел или строк в комментариях ниже.

Не уверен, насколько это pythonic, но пока в библиотеке нет первой функции, я включаю ее в источник:

first = lambda l, default=None: next(iter(l or []), default)

Это всего лишь одна строка (соответствует черному цвету) и позволяет избежать зависимостей.

Используя трюк и / или:

a = get_list()
return a and a[0] or None

Вероятно, не самое быстрое решение, но никто не упомянул эту опцию:

dict(enumerate(get_list())).get(0)

если get_list()можете вернуть Noneвы можете использовать:

dict(enumerate(get_list() or [])).get(0)

Преимущества:

-одна линия

-вы просто позвоните get_list()один раз

-Легко понять

Мой вариант использования был только для установки значения локальной переменной.

Лично я нашел попытку и кроме стиля чище читать

items = [10, 20]
try: first_item = items[0]
except IndexError: first_item = None
print first_item

чем нарезать список.

items = [10, 20]
first_item = (items[:1] or [None, ])[0]
print first_item

Несколько человек предложили сделать что-то вроде этого:

list = get_list()
return list and list[0] or None

Это работает во многих случаях, но будет работать, только если list [0] не равен 0, False или пустой строке. Если list [0] равен 0, False или пустой строке, метод по ошибке вернет None.

Я создал эту ошибку в своем собственном коде слишком много раз!

Вы можете использовать метод извлечения . Другими словами, извлеките этот код в метод, который вы бы затем вызвали.

Я не стал бы пытаться сжать его намного больше, так как кажется, что однострочники труднее читать, чем многословную версию. И если вы используете метод извлечения, это один вкладыш;)

if mylist != []:

       print(mylist[0])

   else:

       print(None)

не идиоматический питон, эквивалентный тернарным операторам в стиле C

cond and true_expr or false_expr

то есть.

list = get_list()
return list and list[0] or None