Python 习惯用法返回第一项或 None

Question

我正在调用一堆返回列表的方法。 该列表可能为空。 如果列表非空，我想返回第一项； 否则，我想返回None。 这段代码有效：

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

但在我看来，应该有一个简单的单行习惯用法来执行此操作。 有没有？

Answer 1

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))

尽可能避免重复）

Answer 2

借用 more_itertools.first_true 代码会产生不错的结果可读：

def first_true(iterable, default=None, pred=None):
    return next(filter(pred, iterable), default)

def get_first_non_default(items_list, default=None):
    return first_true(items_list, default, pred=lambda x: x!=default)

Answer 3

以下代码涵盖了使用 lambda 的几种场景：

l1 = [1,2,3]
l2 = []
l3 = None
first_elem = lambda x: x[0] if x else None
print(first_elem(l1))
print(first_elem(l2))
print(first_elem(l3))

Answer 4

如果您碰巧已经在使用 funcy 库....

...它为 python 提供了大量有用的、受函数式编程启发的实用程序——正如我经常发现自己所做的那样——然后，您可以利用...

first 函数来自他们关于序列相关函数的部分：

返回序列中的第一项。 如果序列为空，则返回 None。 典型用法是选择一些生成的变体中的第一个。

...然后你可以执行如下操作：

from funcy import first

my_list = get_list()
result = first(my_list) if my_list else None

Answer 5

使用 and-or 技巧：

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

Answer 6

可能不是最快的解决方案，但没有人提到这个选项：

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

如果 get_list() 可以返回 None 你可以使用：

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

优点：

-one line

-you just call get_list () 一次

- 易于理解

Answer 7

我的用例只是设置局部变量的值。

就我个人而言，我发现 try and except 风格

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

Answer 8

您可以使用提取方法。 换句话说，将该代码提取到您随后调用的方法中。

我不会尝试将其压缩得更多，单行似乎比冗长的版本更难阅读。 如果你使用提取方法，它就是一个衬垫；）

Answer 9

有几个人建议这样做：

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

这在很多情况下都有效，但只有在 list[0] 不等于 0、False 或空字符串时才有效。 如果 list[0] 为 0、False 或空字符串，则该方法将错误地返回 None。

<块引用>

我在自己的代码中多次创建了此错误！

Answer 10

惯用的 python 不等于 C 风格的三元运算符

cond and true_expr or false_expr

吗？

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

Answer 11

if mylist != []:

       print(mylist[0])

   else:

       print(None)

Answer 12

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

Answer 13

最好的方法是这样的：

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

您也可以在一行中完成，但对于程序员来说更难阅读：

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

Answer 14

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

那应该有效。

---

顺便说一句，我没有使用变量 list，因为它会覆盖内置的 list() 函数。

Answer 15

最惯用的 Python 方法是在迭代器上使用 next()，因为列表是可迭代的。 就像 @JFSebastian 在 2011 年 12 月 13 日的评论中所说的那样。

next(iter(the_list), None) 如果 the_list 为空，则返回 None。 请参阅 next() Python 2.6+

或者如果您确定the_list 不为空：

iter(the_list).next() 请参阅迭代器.next() Python 2.2+

Answer 16

Python 习惯用法返回第一项还是 None？

最Pythonic的方法是最受支持的答案所证明的，这是我读到这个问题时首先想到的。 下面是如何使用它，首先如果可能为空的列表被传递到函数中：

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

如果列表是从 get_list 函数返回的：

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

Python 3.8 中的新功能，赋值表达式

赋值表达式使用就地赋值运算符（非正式地称为海象运算符），:=，Python 3.8 中的新功能，允许我们就地进行检查和赋值，从而实现单行：

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

作为一名长期 Python 用户，这感觉就像我们试图在一行上做太多事情 - 我觉得这样做会是更好的风格，假定性能相同：

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

支持这一表述的是 Tim Peter 的 文章在 PEP 中提议对语言进行此项更改。 他没有提及第一个表述，但基于他确实喜欢的其他表述，我认为他不会介意。

此处演示了执行此操作的其他方法，并带有解释

for

当我开始尝试考虑巧妙的方法来执行此操作时，这是我想到的第二件事：

for item in get_list():
    return item

这假定函数在此结束，隐式返回 <如果 get_list 返回空列表，则 code>None 。 下面的显式代码完全等效：

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]

该切片是不必要的，并且会在内存中创建一个额外的单项列表。 以下应该更具性能。 解释一下，如果布尔上下文中第一个元素为 False，则 or 返回第二个元素，因此如果 get_list 返回空列表，则表达式包含括号中的将返回一个包含“None”的列表，然后将通过 0 索引访问该列表：

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

下一个使用以下事实：如果第一个为 True<，则返回第二个项目/code> 在布尔上下文中，并且由于它引用了 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 方法的迭代器。 （Python 3 中的 .__next__。）然后内置的 next 调用该 .next 方法，如果迭代器耗尽，则返回我们默认的值。给，无。

冗余三元表达式（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

Answer 17

如果您发现自己试图从列表理解中提取第一件事（或无），您可以切换到生成器来执行此操作，如下所示：

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

优点：如果 blah 不可索引，则可以使用缺点：这是不熟悉的语法。 不过，它在修改和过滤 ipython 中的内容时很有用。

Answer 18

OP 的解决方案已经接近完成，只需做一些事情就可以使其更加Pythonic。

其一，无需获取列表的长度。 Python 中的空列表在 if 检查中计算结果为 False。 只是简单地说

if list:

此外，分配给与保留字重叠的变量是一个非常糟糕的主意。 “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 风格。

Answer 19

关于习语，有一个名为 nth 的 itertools Recipe 。

来自 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

这些 itertool 一般适用于任何可迭代对象，而不仅仅是列表。

Answer 20

for item in get_list():
    return item

Answer 21

坦率地说，我不认为有更好的成语：你的表达清晰简洁——不需要任何“更好”的东西。 也许吧，但这确实是一个品味问题，您可以更改 if len(list) > 0: 和 if list: - 空列表将始终评估为 False。

与此相关的是，Python不是Perl（没有双关语！），您不必获得尽可能酷的代码。
事实上，我在 Python 中见过的最糟糕的代码也非常酷:-)并且完全无法维护。

顺便说一句，我在这里看到的大多数解决方案都没有考虑 list[0] 计算结果为 False 时（例如空字符串或零） - 在这种情况下，它们都返回 None 而不是正确的元素。

Answer 22

my_list[0] if len(my_list) else None

Answer 23

不确定这有多Pythonic，但在库中出现第一个函数之前，我将其包含在源代码中：

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

它只是一行（符合黑色）并避免依赖关系。

Answer 24

出于好奇，我对其中两个解决方案进行了计时。 使用 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 seconds
    0.741086 seconds
    0.741191 seconds
    0.743543 seconds avg.
  return_first_item:
    0.785511 seconds
    0.822178 seconds
    0.782846 seconds
    0.796845 seconds avg.
full_lists:
  index_first_item:
    0.762618 seconds
    0.788040 seconds
    0.786849 seconds
    0.779169 seconds avg.
  return_first_item:
    0.802735 seconds
    0.878706 seconds
    0.808781 seconds
    0.830074 seconds avg.
mixed_lists:
  index_first_item:
    0.791129 seconds
    0.743526 seconds
    0.744441 seconds
    0.759699 seconds avg.
  return_first_item:
    0.784801 seconds
    0.785146 seconds
    0.840193 seconds
    0.803380 seconds avg.

Answer 25

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