Thành ngữ Python để trả về mục đầu tiên hoặc Không có

Tôi chắc chắn có một cách đơn giản hơn để làm điều này mà không xảy ra với tôi.

Tôi đang gọi một loạt các phương thức trả về một danh sách. Danh sách có thể trống. Nếu danh sách không trống, tôi muốn trả về mục đầu tiên; nếu không, tôi muốn trả về Không. Mã này hoạt động:

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

Dường như với tôi rằng nên có một thành ngữ một dòng đơn giản để làm điều này, nhưng đối với cuộc sống của tôi, tôi không thể nghĩ về nó. Lanhung?

Biên tập:

Lý do tôi đang tìm kiếm một biểu thức một dòng ở đây không phải là tôi thích mã cực kỳ ngắn gọn, mà bởi vì tôi phải viết rất nhiều mã như thế này:

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

Những gì tôi muốn làm chắc chắn có thể được thực hiện bằng một chức năng (và có thể sẽ được):

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

Tôi đã đăng câu hỏi vì tôi thường ngạc nhiên bởi những biểu thức đơn giản trong Python có thể làm gì và tôi nghĩ rằng viết một hàm là một việc ngớ ngẩn để làm nếu có một biểu thức đơn giản có thể thực hiện thủ thuật. Nhưng nhìn thấy những câu trả lời này, có vẻ như một chức năng là giải pháp đơn giản.

Python 2.6+

next(iter(your_list), None)

Nếu your_listcó thể là 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

Thí dụ:

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

Một tùy chọn khác là nội tuyến các chức năng trên:

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

Để tránh breakbạn có thể viết:

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

Ở đâu:

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

Cách tốt nhất là đây:

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

Bạn cũng có thể làm điều đó trong một dòng, nhưng lập trình viên khó đọc hơn nhiều:

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

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

Cần làm việc.

BTW Tôi không sử dụng biến list, vì nó ghi đè list()hàm dựng sẵn .

Chỉnh sửa: Tôi đã có một phiên bản đơn giản hơn một chút, nhưng sai ở đây trước đó.

Cách thành ngữ python nhất là sử dụng next () trên iterator vì danh sách có thể lặp lại . giống như những gì @JFSebastian đưa ra trong nhận xét vào ngày 13 tháng 12 năm 2011.

next(iter(the_list), None)Điều này trả về Không nếu the_listtrống. xem tiếp () Python 2.6+

hoặc nếu bạn biết chắc chắn the_listkhông trống:

iter(the_list).next()xem iterator.next () Python 2.2+

Nếu bạn thấy mình đang cố gắng thực hiện điều đầu tiên (hoặc Không có) từ việc hiểu danh sách, bạn có thể chuyển sang một trình tạo để làm điều đó như sau:

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

Pro: hoạt động nếu blah không thể lập chỉ mục Con: đó là cú pháp lạ. Nó rất hữu ích trong khi hack xung quanh và lọc các thứ trong ipython.

Giải pháp của OP đã gần kề, chỉ có một vài điều để làm cho nó trở nên nhiều Pythonic hơn.

Đối với một, không cần phải có chiều dài của danh sách. Danh sách trống trong Python đánh giá thành Sai trong kiểm tra nếu. Chỉ cần nói đơn giản

if list:

Ngoài ra, đó là một ý tưởng rất tồi để gán cho các biến trùng lặp với các từ dành riêng. "danh sách" là một từ dành riêng trong Python.

Vì vậy, hãy thay đổi điều đó thành

some_list = get_list()
if some_list:

Một điểm thực sự quan trọng mà rất nhiều giải pháp ở đây bỏ lỡ là tất cả các hàm / phương thức Python đều trả về Không theo mặc định . Hãy thử như sau.

def does_nothing():
    pass

foo = does_nothing()
print foo

Trừ khi bạn cần trả về Không để kết thúc chức năng sớm, không cần thiết phải trả lại Không rõ ràng. Khá ngắn gọn, chỉ cần trả lại mục đầu tiên, nếu nó tồn tại.

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

Và cuối cùng, có lẽ điều này đã được ngụ ý, nhưng chỉ để rõ ràng (vì rõ ràng là tốt hơn ngầm định ), bạn không nên có chức năng của mình lấy danh sách từ một chức năng khác; chỉ cần vượt qua nó như là một tham số. Vì vậy, kết quả cuối cùng sẽ là

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

my_list = get_list()
first_item = get_first_item(my_list)

Như tôi đã nói, OP đã ở gần đó và chỉ một vài cú chạm cho nó hương vị Python mà bạn đang tìm kiếm.

for item in get_list():
    return item

Thẳng thắn mà nói, tôi không nghĩ có một thành ngữ tốt hơn: bạn rõ ràng và ngắn gọn - không cần bất cứ điều gì "tốt hơn". Có thể, nhưng đây thực sự là một vấn đề của hương vị, bạn có thể thay đổi if len(list) > 0:với if list:- một danh sách trống sẽ luôn luôn đánh giá thành Sai.

Trên một lưu ý liên quan, Python không phải là Perl (không có ý định chơi chữ!), Bạn không cần phải lấy mã tuyệt vời nhất có thể.
Trên thực tế, mã tồi tệ nhất tôi đã thấy trong Python, cũng rất tuyệt :-) và hoàn toàn không thể nhầm lẫn.

Nhân tiện, hầu hết các giải pháp tôi đã thấy ở đây không xem xét khi danh sách [0] ước tính thành Sai (ví dụ: chuỗi rỗng hoặc 0) - trong trường hợp này, tất cả đều trả về Không và không phải là phần tử chính xác.

Thành ngữ Python để trả về mục đầu tiên hoặc Không có?

Cách tiếp cận Pythonic nhất là những gì câu trả lời được đánh giá cao nhất đã thể hiện, và đó là điều đầu tiên tôi nghĩ đến khi tôi đọc câu hỏi. Đây là cách sử dụng nó, đầu tiên nếu danh sách trống có thể được truyền vào một hàm:

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

Và nếu danh sách được trả về từ một get_listhàm:

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

Những cách khác được chứng minh để làm điều này ở đây, với lời giải thích

for

Khi tôi bắt đầu cố gắng nghĩ ra những cách thông minh để làm điều này, đây là điều thứ hai tôi nghĩ đến:

for item in get_list():
    return item

Điều này giả sử hàm kết thúc ở đây, hoàn toàn trả về Nonenếu get_listtrả về một danh sách trống. Mã rõ ràng dưới đây là chính xác tương đương:

for item in get_list():
    return item
return None

if some_list

Sau đây cũng được đề xuất (tôi đã sửa tên biến không chính xác) cũng sử dụng ẩn None. Điều này sẽ thích hợp hơn ở trên, vì nó sử dụng kiểm tra logic thay vì lặp lại có thể không xảy ra. Điều này sẽ dễ hiểu hơn những gì đang xảy ra. Nhưng nếu chúng ta viết cho khả năng đọc và bảo trì, chúng ta cũng nên thêm phần rõ ràng return Nonevào cuối:

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

cắt or [None]và chọn chỉ số zeroth

Câu hỏi này cũng nằm trong câu trả lời được bình chọn nhiều nhất:

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

Các lát cắt là không cần thiết và tạo thêm một danh sách một mục trong bộ nhớ. Sau đây nên được thực hiện nhiều hơn. Để giải thích, ortrả về phần tử thứ hai nếu phần tử thứ nhất nằm Falsetrong ngữ cảnh boolean, vì vậy nếu get_listtrả về một danh sách trống, biểu thức có trong ngoặc đơn sẽ trả về một danh sách với 'Không', sau đó sẽ được 0chỉ mục truy cập :

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

Cái tiếp theo sử dụng thực tế và trả về mục thứ hai nếu mục thứ nhất nằm Truetrong ngữ cảnh boolean và vì nó tham chiếu my_list hai lần, nên không tốt hơn biểu thức ternary (và về mặt kỹ thuật không phải là một lớp lót):

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

next

Sau đó, chúng ta có cách sử dụng thông minh của nội dung nextvàiter

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

Để giải thích, itertrả về một iterator bằng một .nextphương thức. ( .__next__trong Python 3.) Sau đó, hàm dựng sẵn nextgọi .nextphương thức đó và nếu iterator hết, trả về mặc định mà chúng ta đưa ra , None.

biểu thức ternary dự phòng ( a if b else c) và quay trở lại

Những điều dưới đây đã được đề xuất, nhưng điều ngược lại sẽ tốt hơn, vì logic thường được hiểu rõ hơn ở dạng tích cực thay vì phủ định. Vì get_listđược gọi hai lần, trừ khi kết quả được ghi nhớ theo một cách nào đó, điều này sẽ hoạt động kém:

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

Nghịch đảo tốt hơn:

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

Thậm chí tốt hơn, sử dụng một biến cục bộ để get_listchỉ được gọi một lần và bạn đã có giải pháp Pythonic được đề xuất trước tiên:

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

Về thành ngữ, có một công thức itertools được gọi là nth.

Từ công thức nấu ăn itertools:

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

Nếu bạn muốn một lớp lót, hãy xem xét việc cài đặt một thư viện thực hiện công thức này cho bạn, ví dụ more_itertools:

import more_itertools as mit

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

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

Một công cụ khác có sẵn mà chỉ trả về mục đầu tiên, được gọi more_itertools.first.

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

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

Các itertools này chia tỷ lệ chung cho bất kỳ lần lặp nào, không chỉ cho các danh sách.

my_list[0] if len(my_list) else None

Vì tò mò, tôi chạy theo thời gian trên hai trong số các giải pháp. Giải pháp sử dụng câu lệnh return để kết thúc sớm vòng lặp for tốn kém hơn một chút trên máy của tôi với Python 2.5.1, tôi nghi ngờ điều này phải làm với việc thiết lập vòng lặp.

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

Đây là những khoảng thời gian tôi nhận được:

danh sách trống:
  index_first_item:
    0,748353 giây
    0,741086 giây
    0,741191 giây
    0,743543 giây avg.
  return_first_item:
    0,785511 giây
    0.822178 giây
    0,782846 giây
    0,796845 giây avg.
danh sách đầy đủ:
  index_first_item:
    0,762618 giây
    0,788040 giây
    0,786849 giây
    0,779169 giây avg.
  return_first_item:
    0,802735 giây
    0,878706 giây
    0,808781 giây
    0.830074 giây avg.
hỗn hợp:
  index_first_item:
    0,791129 giây
    0,743526 giây
    0,744441 giây
    0,759699 giây avg.
  return_first_item:
    0,784801 giây
    0,785146 giây
    0,840193 giây
    0,803380 giây avg.

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

BTW: Tôi sẽ làm lại chương trình chung của bạn thành một thứ như thế này:

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

(Tránh lặp lại bất cứ khi nào có thể)

Còn cái này thì sao:

(my_list and my_list[0]) or None

Lưu ý: Điều này sẽ hoạt động tốt cho danh sách các đối tượng nhưng nó có thể trả về câu trả lời không chính xác trong trường hợp danh sách số hoặc chuỗi theo các bình luận bên dưới.

Không chắc đây là pythonic như thế nào nhưng cho đến khi có một chức năng đầu tiên trong thư viện tôi đưa nó vào nguồn:

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

Đó chỉ là một dòng (phù hợp với màu đen) và tránh phụ thuộc.

Sử dụng và và hoặc:

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

Có lẽ không phải là giải pháp nhanh nhất, nhưng không ai đề cập đến tùy chọn này:

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

Nếu get_list()có thể trở lại, Nonebạn có thể sử dụng:

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

Ưu điểm:

-một đường thẳng

-bạn chỉ cần gọi get_list()một lần

-dễ hiểu

Trường hợp sử dụng của tôi chỉ để đặt giá trị của một biến cục bộ.

Cá nhân tôi đã tìm thấy thử và ngoại trừ phong cách sạch hơn để đọc

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

hơn là cắt một danh sách.

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

Một số người đã đề nghị làm một cái gì đó như thế này:

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

Điều đó hoạt động trong nhiều trường hợp, nhưng nó sẽ chỉ hoạt động nếu danh sách [0] không bằng 0, Sai hoặc một chuỗi rỗng. Nếu danh sách [0] là 0, Sai hoặc một chuỗi trống, phương thức sẽ trả về không chính xác Không có.

Tôi đã tạo ra lỗi này trong mã của riêng tôi quá nhiều lần!

Bạn có thể sử dụng Phương pháp trích xuất . Nói cách khác, trích xuất mã đó thành một phương thức mà sau đó bạn gọi.

Tôi sẽ không cố nén nó nhiều hơn nữa, một lớp lót có vẻ khó đọc hơn phiên bản dài dòng. Và nếu bạn sử dụng Phương thức trích xuất, thì đó là một lớp lót;)

if mylist != []:

       print(mylist[0])

   else:

       print(None)

không phải là con trăn thành ngữ tương đương với các toán tử ternary kiểu C

cond and true_expr or false_expr

I E.

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