Python의 모든 기능은 어떻게 작동하는가?

Python의 모든 기능은 어떻게 작동하는가?

나는 어떻게 그 일이 일어났는지 이해하려고 노력하고 있다.any()그리고all()파이톤 내장 기능이 작동한다.

나는 튜플을 비교해서 만약 어떤 값이 다르면 그것이 다시 돌아오도록 하려고 한다.True그리고 만약 그것들이 모두 같다면 그것은 돌아올 것이다.False 이 [을 반환하고 [거짓, 거짓, 거짓]을 반환하기 위해 이 사건에서 그들은 어떻게 일하고 있는가?

da이다defaultdict(list).

print d['Drd2']
# [[1, 5, 0], [1, 6, 0]]
print list(zip(*d['Drd2']))
# [(1, 1), (5, 6), (0, 0)]
print [any(x) and not all(x) for x in zip(*d['Drd2'])]
# [False, False, False]

내가 알기로는, 이것은 출력되어야 한다.

# [False, True, False]

(1,1)은 같고, (5,6)은 다르고, (0,0)은 같기 때문이다.

왜 그것은 모든 튜플에 대해 거짓으로 평가하고 있는가?

대충 생각하면 된다.any그리고all으로 말하자면.or그리고and각각 연산자.

아무 것이나

any돌아올 것이다True적어도 원소 중 하나가 트루티일 때.True Value Testing에 대해 읽어 보십시오.

전부

all돌아올 것이다True모든 원소들이 트루티일 때만.

진리표

+-----------------------------------------+---------+---------+
|                                         |   any   |   all   |
+-----------------------------------------+---------+---------+
| All Truthy values                       |  True   |  True   |
+-----------------------------------------+---------+---------+
| All Falsy values                        |  False  |  False  |
+-----------------------------------------+---------+---------+
| One Truthy value (all others are Falsy) |  True   |  False  |
+-----------------------------------------+---------+---------+
| One Falsy value (all others are Truthy) |  True   |  False  |
+-----------------------------------------+---------+---------+
| Empty Iterable                          |  False  |  True   |
+-----------------------------------------+---------+---------+

참고 1: 빈 반복 가능한 사례는 다음과 같이 공식 문서에 설명되어 있다.

any

반품True만약 수많은 요소 중 어떤 것이 사실이라면수 많은 항목이 비어 있으면 반환

어느 요소도 사실이 아니므로, 그것은 되돌아온다.False이 경우에는

all

반품True반복 가능한 모든 요소가 참인 경우(또는 반복 가능한 요소가 비어 있는 경우)

어느 원소도 거짓이 아니기 때문에, 그것은 되돌아온다.True이 경우에는

---

참고 2:

알아야 할 또 다른 중요한 것any그리고all그들이 결과를 아는 순간 사형 집행을 중단시킬 겁니다장점은 셀 수 없이 많은 것을 소비할 필요가 없다는 것이다.예를 들어,

>>> multiples_of_6 = (not (i % 6) for i in range(1, 10))
>>> any(multiples_of_6)
True
>>> list(multiples_of_6)
[False, False, False]

여기(not (i % 6) for i in range(1, 10))반환되는 제너레이터 식입니다.True6.1/9의 9의 1자녀 6의 .any반복하다multiples_of_6그리고 그것이 만났을 때6 즉시 Truthy를 True, 그리고 나머지 .multiples_of_6반복되지 않는다.그것이 우리가 인쇄할 때 볼 수 있는 것이다.list(multiples_of_6) , 의 .7 8그리고9.

이 훌륭한 것은 이 대답에 매우 교묘하게 쓰인다.

---

이 기본적인 이해로, 우리가 당신의 코드를 본다면, 당신은

any(x) and not all(x)

적어도 그 값들 중 하나는 트루티지만 전부 다가 아니라는 것을 확실히 해 준다.그래서 다시 돌아오는 것이다.[False, False, False]만약 당신이 두 숫자가 같지 않은지 정말로 확인하고 싶다면,

print [x[0] != x[1] for x in zip(*d['Drd2'])]

파이썬은 어때?any그리고all기능이 작동하나?

any그리고all반복해서 가져가서 돌아오다True원소의 전부(전체)가 다음과 같은 경우True.

>>> any([0, 0.0, False, (), '0']), all([1, 0.0001, True, (False,)])
(True, True)            #   ^^^-- truthy non-empty string
>>> any([0, 0.0, False, (), '']), all([1, 0.0001, True, (False,), {}])
(False, False)                                                #   ^^-- falsey

만약 반복이 비어있다면any돌아온다False그리고all돌아온다True.

>>> any([]), all([])
(False, True)

나는 시범을 보이고 있었다.all그리고any오늘 수업의 학생들을 위해서.그들은 대부분 빈 반복품에 대한 반환 값에 대해 혼란스러워했다.이렇게 설명하니 많은 전구가 켜졌다.

바로 가기 동작

그들은,any그리고all둘 다 평가를 중단할 수 있는 조건을 찾는다.내가 준 첫 번째 예제는 그들에게 전체 리스트의 각 원소에 대한 부울을 평가하도록 요구하였다.

(목록 리터럴은 그 자체로 느리게 평가되지 않는다 - 당신은 그것을 Iterator로 얻을 수 있다 - 그러나 이것은 단지 예시를 위한 것이다.)

Python 구현 방법:

def any(iterable):
    for i in iterable:
        if i:
            return True
    return False # for an empty iterable, any returns False!

def all(iterable):
    for i in iterable:
        if not i:
            return False
    return True  # for an empty iterable, all returns True!

물론 실제 구현은 C로 쓰여져 있고 훨씬 더 실행력이 높지만, 위와 같은 결과를 이 (또는 다른) 답변에서 코드에 대해 얻을 수 있다.

all

all가 될 False(그것이 돌아올 수 있도록)False) 그러면 돌아온다.True만약 그들 중 아무도 없다면.False.

>>> all([1, 2, 3, 4])                 # has to test to the end!
True
>>> all([0, 1, 2, 3, 4])              # 0 is False in a boolean context!
False  # ^--stops here!
>>> all([])
True   # gets to end, so True!

any

그 길any은 이다.True(그것이 돌아올 수 있도록)True), then it returns거짓의if none of them were"그렇다.

>>> any([0, 0.0, '', (), [], {}])     # has to test to the end!
False
>>> any([1, 0, 0.0, '', (), [], {}])  # 1 is True in a boolean context!
True   # ^--stops here!
>>> any([])
False   # gets to end, so False!

나는 당신이 짧은 커팅 행동을 명심한다면, 당신은 진실 테이블을 참조할 필요 없이 그것들이 어떻게 작동하는지 직관적으로 이해할 것이라고 생각한다.

의의 all그리고any바로 가기:

먼저 노이즈가 많은_iterator를 생성하십시오.

def noisy_iterator(iterable):
    for i in iterable:
        print('yielding ' + repr(i))
        yield i

이제 우리의 예를 들어, 목록을 시끄럽게 반복해 봅시다.

>>> all(noisy_iterator([1, 2, 3, 4]))
yielding 1
yielding 2
yielding 3
yielding 4
True
>>> all(noisy_iterator([0, 1, 2, 3, 4]))
yielding 0
False

우리는 볼 수 있다.all첫 번째 False Boolean Check에서 중지하십시오.

그리고any 번째 :첫째 째 True Boolean Check on the first True Boolean Check on True Boolean

>>> any(noisy_iterator([0, 0.0, '', (), [], {}]))
yielding 0
yielding 0.0
yielding ''
yielding ()
yielding []
yielding {}
False
>>> any(noisy_iterator([1, 0, 0.0, '', (), [], {}]))
yielding 1
True

출처

위의 내용을 확인하기 위해 출처를 살펴보자.

다음에 대한 출처:

static PyObject *
builtin_any(PyObject *module, PyObject *iterable)
{
    PyObject *it, *item;
    PyObject *(*iternext)(PyObject *);
    int cmp;

    it = PyObject_GetIter(iterable);
    if (it == NULL)
        return NULL;
    iternext = *Py_TYPE(it)->tp_iternext;

    for (;;) {
        item = iternext(it);
        if (item == NULL)
            break;
        cmp = PyObject_IsTrue(item);
        Py_DECREF(item);
        if (cmp < 0) {
            Py_DECREF(it);
            return NULL;
        }
        if (cmp > 0) {
            Py_DECREF(it);
            Py_RETURN_TRUE;
        }
    }
    Py_DECREF(it);
    if (PyErr_Occurred()) {
        if (PyErr_ExceptionMatches(PyExc_StopIteration))
            PyErr_Clear();
        else
            return NULL;
    }
    Py_RETURN_FALSE;
}

그리고 여기 다음에 대한 출처가 있다.

static PyObject *
builtin_all(PyObject *module, PyObject *iterable)
{
    PyObject *it, *item;
    PyObject *(*iternext)(PyObject *);
    int cmp;

    it = PyObject_GetIter(iterable);
    if (it == NULL)
        return NULL;
    iternext = *Py_TYPE(it)->tp_iternext;

    for (;;) {
        item = iternext(it);
        if (item == NULL)
            break;
        cmp = PyObject_IsTrue(item);
        Py_DECREF(item);
        if (cmp < 0) {
            Py_DECREF(it);
            return NULL;
        }
        if (cmp == 0) {
            Py_DECREF(it);
            Py_RETURN_FALSE;
        }
    }
    Py_DECREF(it);
    if (PyErr_Occurred()) {
        if (PyErr_ExceptionMatches(PyExc_StopIteration))
            PyErr_Clear();
        else
            return NULL;
    }
    Py_RETURN_TRUE;
}

이게 오래됐다는 건 알지만, 코드에서 이런 기능들이 어떤 모습인지 보여주는 게 도움이 될 수도 있다고 생각했다.이것은 정말로 논리학을 잘 보여준다, 텍스트나 테이블 IMO보다. 실제로는 그것들은 순수한 파이톤이 아닌 C로 구현되지만, 이것들은 동등하다.

def any(iterable):
    for item in iterable:
        if item:
            return True
    return False

def all(iterable):
    for item in iterable:
        if not item:
            return False
    return True

특히 빈 이터블에 대한 결과는 특별한 경우가 아닌 자연스러운 결과일 뿐이라는 것을 알 수 있다.당신은 또한 단락 행동을 볼 수 있다; 실제로 단락이 발생하지 않는 것이 더 많은 일이 될 것이다.

귀도 판 로섬(Python의 창시자)이 처음 덧셈을 제안했을 때, 그는 위의 코드 조각들을 정확히 게시하는 것으로 설명하였다.

당신이 묻고 있는 문제의 코드는 여기 주어진 내 대답에서 나온 것이다.여러 비트 어레이를 비교하는 문제(즉, 컬렉션)를 해결하기 위한 것이었다.1그리고0.

any그리고all값의 "부울성" 즉, 부울 컨텍스트에서 값의 "부울성"에 의존할 수 있을 때 유용하다.1은True그리고 0은False대답하는 편리함을 이용했다.우연히도 5는True그래서 가능한 입력에 그걸 섞으면...글쎄, 안 먹혀.

대신 이런 일을 할 수 있다.

[len(set(x)) > 1 for x in zip(*d['Drd2'])]

전답의 미학이 결여되어 있다(나는 정말 그 표정이 좋았다.any(x) and not all(x)() 그러나 그것은 그 일을 완성한다.

>>> any([False, False, False])
False
>>> any([False, True, False])
True
>>> all([False, True, True])
False
>>> all([True, True, True])
True

s = "eFdss"
s = list(s)
all(i.islower() for i in s )   # FALSE
any(i.islower() for i in s )   # TRUE

all() 함수는 컬렉션의 모든 구성원이 truthy인지 아닌지를 확인하는 데 사용된다.예를 들어, all() 함수는 다음과 같은 형식의 문구를 보다 간결하게 조건화하는데 사용할 수 있다.

if all entre's are vegan this is a vegan restaurant

코드:

restaurant_is_vegan = all(x is vegan for x in menu)

메뉴의 모든 항목(x)이 조건부(채식주의자; x ==채식주의자)에 대해 True로 평가될 경우, 모든 문장은 True로 평가된다.

자세한 예: https://www.alpharithms.com/python-all-function-223809/

개념은 간단하다.

M =[(1, 1), (5, 6), (0, 0)]

1) print([any(x) for x in M])
[True, True, False] #only the last tuple does not have any true element

2) print([all(x) for x in M])
[True, True, False] #all elements of the last tuple are not true

3) print([not all(x) for x in M])
[False, False, True] #NOT operator applied to 2)

4) print([any(x)  and not all(x) for x in M])
[False, False, False] #AND operator applied to 1) and 3)
# if we had M =[(1, 1), (5, 6), (1, 0)], we could get [False, False, True]  in 4)
# because the last tuple satisfies both conditions: any of its elements is TRUE 
#and not all elements are TRUE 

list = [1,1,1,0]
print(any(list)) # will return True because there is  1 or True exists
print(all(list)) # will return False because there is a 0 or False exists
return all(a % i for i in range(3, int(a ** 0.5) + 1)) # when number is divisible it will return False else return True but the whole statement is False .

참조URL: https://stackoverflow.com/questions/19389490/how-do-pythons-any-and-all-functions-work