첫 번째 항목을 반환하는 Python 관용구 또는 없음

나에게 일어나지 않는 간단한 방법이 있다고 확신합니다.

목록을 반환하는 많은 메소드를 호출하고 있습니다. 목록이 비어있을 수 있습니다. 목록이 비어 있지 않으면 첫 번째 항목을 반환하고 싶습니다. 그렇지 않으면 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

파이썬에서 간단한 표현식이 할 수있는 일에 자주 놀랐 기 때문에 질문을 게시했으며 간단한 표현식이 있으면 트릭을 수행 할 수있는 경우 함수를 작성하는 것이 어리석은 일이라고 생각했습니다. 그러나 이러한 답변을 보면 함수 가 간단한 솔루션 인 것 같습니다 .

파이썬 2.6 이상

next(iter(your_list), None)

만약 your_list할 수 있습니다 None:

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

파이썬 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]

작동합니다.

BTW list내장 변수 를 덮어 쓰기 때문에 변수를 사용하지 않았습니다 list().

편집 : 나는 조금 더 간단하지만 여기서 잘못된 버전을 가지고있었습니다.

가장 파이썬적인 관용적 방법은 list가 iterable 이기 때문에 iterator에서 next ()를 사용하는 것 입니다. @JFSebastian이 2011 년 12 월 13 일 코멘트에 언급 한 것과 같습니다.

next(iter(the_list), None)the_list비어 있으면 None을 반환합니다 . 참조 다음 () 파이썬 2.6+

또는 the_list비어 있지 않다는 것을 알고 있다면 :

iter(the_list).next()iterator.next () 참조 파이썬 2.2 이상

목록 이해에서 첫 번째 항목 (또는 없음)을 뽑으려고하는 경우 발전기로 전환하여 다음과 같이 할 수 있습니다.

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

장점 : blah를 색인 할 수없는 경우 작동합니다. Con : 익숙하지 않은 구문입니다. ipython에서 해킹하고 필터링하는 동안 유용합니다.

OP의 솔루션은 거의 거기에 있으며 Pythonic을 더 만들려면 몇 가지가 있습니다.

하나, 목록의 길이를 얻을 필요가 없습니다. 파이썬에서 빈 목록은 if 검사에서 False로 평가됩니다. 간단히 말해

if list:

또한 예약어와 겹치는 변수에 할당하는 것은 매우 나쁜 생각입니다. "list"는 파이썬에서 예약 된 단어입니다.

그래서 그것을

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:False로 항상을 평가합니다 빈리스트 -.

관련 참고에 따르면, 파이썬은 Perl 이 아닙니다 (말장난 이 아닙니다 !), 가장 멋진 코드를 얻을 필요는 없습니다.
실제로, 파이썬에서 본 최악의 코드는 매우 시원했고 완전히 유지할 수 없었습니다.

그건 그렇고, 여기에서 본 대부분의 솔루션은 list [0]이 False로 평가 될 때 고려하지 않습니다 (예 : 빈 문자열 또는 0).이 경우 모두 올바른 요소가 아닌 None을 반환합니다.

첫 번째 항목을 반환하는 파이썬 관용구 또는 없음?

가장 파이썬적인 접근 방식은 가장 많이 찬성 된 답변으로, 질문을 읽을 때 가장 먼저 떠 올랐습니다. 비어있는 목록이 함수에 전달 된 경우이를 사용하는 방법은 다음과 같습니다.

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

이것은 함수가 여기에서 끝나고 빈 목록을 반환 None하면 암시 적으로 반환 한다고 가정합니다 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는 목록뿐만 아니라 모든 iterable에 대해 일반적으로 확장됩니다.

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 초
전체 목록 :
  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

BTW : 일반적인 프로그램 흐름을 다음과 같이 다시 작성하겠습니다.

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을 잘못 반환합니다.

내 코드에서이 버그를 너무 많이 만들었습니다!

Extract Method를 사용할 수 있습니다 . 즉, 해당 코드를 호출 한 메소드로 추출하십시오.

나는 그것을 더 많이 압축하려고하지 않을 것입니다. 하나의 라이너는 자세한 버전보다 읽기가 어렵습니다. 추출 방법을 사용하면 하나의 라이너입니다.)

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