Python 如何将函数应用于列表中的连续值对？

我有一本字典

tickers = {'BTC': [200, 149, 98, 44], 'ETH': [200, 320, 405, 460]}

now

和

prev

是列表的元素

我们比较这个元素和列表中的前一个元素

例如，在BTC中：

149与200之间
98对149
44对98

其中元素在每个股票代码的每一天都处于状态

---

如何操作？

如果将

check_state

的输入参数顺序从

def check_state（now，prev）：

反转为

def check_state（prev，now）：

则将函数应用于列表的连续值对的问题变得非常简单。我提出了以下功能：

import itertools


def apply_pairwise(values,
                   function):
    """
    Applies function to consecutive pairs of elements from an input list
    """
    def pairwise(iterable):
        """
        s -> (s0,s1), (s1,s2), (s2,s3), ...
        """
        a, b = itertools.tee(iterable)
        next(b, None)
        return zip(a, b)

    yield from itertools.chain([None],
                               itertools.starmap(function, pairwise(values)))

用法示例：

>>> btc = [200, 149, 98, 44]
>>> list(apply_pairwise(btc, check_state))
[None, 2, 3, 3]
>>> eth = [200, 320, 405, 460]
>>> list(apply_pairwise(eth, check_state))
[None, 1, 0, 0]

---

如果无法反转输入：

如果无法改变输入顺序，我们可以稍微采用我们的函数：

import itertools


def apply_pairwise(values,
                   function,
                   *,
                   reverse=False):
    """
    Applies function to consecutive pairs of elements from an input list
    """
    def pairwise(iterable):
        """
        s -> (s0,s1), (s1,s2), (s2,s3), ...
        or -> (s1,s0), (s2,s1), (s3,s2), ... if reverse
        """
        a, b = itertools.tee(iterable)
        next(b, None)

        if reverse:
            return zip(b, a)
        return zip(a, b)

    yield from itertools.chain([None],
                               itertools.starmap(function, pairwise(values)))

你可以这样使用它：

>>> btc = [200, 149, 98, 44]
>>> list(apply_pairwise(btc, check_state, reverse=True))
[None, 2, 3, 3]
>>> eth = [200, 320, 405, 460]
>>> list(apply_pairwise(eth, check_state, reverse=True))
[None, 1, 0, 0]

>>> list(pairwise(range(5)))
[(0, 1), (1, 2), (2, 3), (3, 4)]

>>> list(itertools.starmap(pow, [(2, 3), (2, 10), (10, 3), (3, 4)]))
[8, 1024, 1000, 81]

---

说明：

为了获得连续的元素对，我们可以使用以下配方中的辅助函数：

它的工作原理如下：

>>> btc = [200, 149, 98, 44]
>>> list(apply_pairwise(btc, check_state, reverse=True))
[None, 2, 3, 3]
>>> eth = [200, 320, 405, 460]
>>> list(apply_pairwise(eth, check_state, reverse=True))
[None, 1, 0, 0]

>>> list(pairwise(range(5)))
[(0, 1), (1, 2), (2, 3), (3, 4)]

>>> list(itertools.starmap(pow, [(2, 3), (2, 10), (10, 3), (3, 4)]))
[8, 1024, 1000, 81]

现在，对于每一对元素，我们将应用您的

check_state

函数。这里可能有用。它的工作原理如下：

>>> btc = [200, 149, 98, 44]
>>> list(apply_pairwise(btc, check_state, reverse=True))
[None, 2, 3, 3]
>>> eth = [200, 320, 405, 460]
>>> list(apply_pairwise(eth, check_state, reverse=True))
[None, 1, 0, 0]

>>> list(pairwise(range(5)))
[(0, 1), (1, 2), (2, 3), (3, 4)]

>>> list(itertools.starmap(pow, [(2, 3), (2, 10), (10, 3), (3, 4)]))
[8, 1024, 1000, 81]

剩下的唯一一件事就是通过

None

预加

starmap

生成的值。当

starmap

生成一个元素时，我们可以使用将第一个

None

元素与其余元素组合起来

---

---

附言：将其应用于您的

ticker

dict的值应该很容易。我将把它留给您。

如果您将

check\u state

的输入参数顺序从

def check\u state（now，prev）：

颠倒到

def check\u state（prev，now）：

则将函数应用于列表中连续的值对的问题变得非常简单。我提出了以下功能：

import itertools


def apply_pairwise(values,
                   function):
    """
    Applies function to consecutive pairs of elements from an input list
    """
    def pairwise(iterable):
        """
        s -> (s0,s1), (s1,s2), (s2,s3), ...
        """
        a, b = itertools.tee(iterable)
        next(b, None)
        return zip(a, b)

    yield from itertools.chain([None],
                               itertools.starmap(function, pairwise(values)))

用法示例：

>>> btc = [200, 149, 98, 44]
>>> list(apply_pairwise(btc, check_state))
[None, 2, 3, 3]
>>> eth = [200, 320, 405, 460]
>>> list(apply_pairwise(eth, check_state))
[None, 1, 0, 0]

---

如果无法反转输入：

如果无法改变输入顺序，我们可以稍微采用我们的函数：

import itertools


def apply_pairwise(values,
                   function,
                   *,
                   reverse=False):
    """
    Applies function to consecutive pairs of elements from an input list
    """
    def pairwise(iterable):
        """
        s -> (s0,s1), (s1,s2), (s2,s3), ...
        or -> (s1,s0), (s2,s1), (s3,s2), ... if reverse
        """
        a, b = itertools.tee(iterable)
        next(b, None)

        if reverse:
            return zip(b, a)
        return zip(a, b)

    yield from itertools.chain([None],
                               itertools.starmap(function, pairwise(values)))

你可以这样使用它：

>>> btc = [200, 149, 98, 44]
>>> list(apply_pairwise(btc, check_state, reverse=True))
[None, 2, 3, 3]
>>> eth = [200, 320, 405, 460]
>>> list(apply_pairwise(eth, check_state, reverse=True))
[None, 1, 0, 0]

>>> list(pairwise(range(5)))
[(0, 1), (1, 2), (2, 3), (3, 4)]

>>> list(itertools.starmap(pow, [(2, 3), (2, 10), (10, 3), (3, 4)]))
[8, 1024, 1000, 81]

---

说明：

为了获得连续的元素对，我们可以使用以下配方中的辅助函数：

它的工作原理如下：

>>> btc = [200, 149, 98, 44]
>>> list(apply_pairwise(btc, check_state, reverse=True))
[None, 2, 3, 3]
>>> eth = [200, 320, 405, 460]
>>> list(apply_pairwise(eth, check_state, reverse=True))
[None, 1, 0, 0]

>>> list(pairwise(range(5)))
[(0, 1), (1, 2), (2, 3), (3, 4)]

>>> list(itertools.starmap(pow, [(2, 3), (2, 10), (10, 3), (3, 4)]))
[8, 1024, 1000, 81]

现在，对于每一对元素，我们将应用您的

check_state

函数。这里可能有用。它的工作原理如下：

>>> btc = [200, 149, 98, 44]
>>> list(apply_pairwise(btc, check_state, reverse=True))
[None, 2, 3, 3]
>>> eth = [200, 320, 405, 460]
>>> list(apply_pairwise(eth, check_state, reverse=True))
[None, 1, 0, 0]

>>> list(pairwise(range(5)))
[(0, 1), (1, 2), (2, 3), (3, 4)]

>>> list(itertools.starmap(pow, [(2, 3), (2, 10), (10, 3), (3, 4)]))
[8, 1024, 1000, 81]

剩下的唯一一件事就是通过

None

预加

starmap

生成的值。当

starmap

生成一个元素时，我们可以使用将第一个

None

元素与其余元素组合起来

---

---

附言：将其应用于您的

ticker

dict的值应该很容易。我将把它留给您。

您可以使用一个函数来比较列表中的每一对连续值，该函数在列表中循环，并使用enumerate启用对上一个列表项的访问以进行比较。然后在函数中使用dict CONTRUSION生成原始dict的映射版本，其中包含比较的值

在下面的示例中，它从第二个列表项开始循环通过列表的一个片段，因此前一个元素由当前值

i

访问，因为该片段实际上将索引值移动了1

tickers = {'BTC': [200, 149, 98, 44], 'ETH': [200, 320, 405, 460]}

def check_states(data):
    states = [None]
    for i, n in enumerate(data[1:]):
        state = None
        p = data[i]
        (low, high) = (p / 1.5, p * 1.5)
        if n >= p:
            state = 0 if n <= high else 1
        else:
            state = 2 if n >= low else 3           
        states.append(state)    
    return states

tickers_state = {k: check_states(v) for k, v in tickers.items()}

print(tickers_state)
# OUTPUT
# {'BTC': [None, 2, 3, 3], 'ETH': [None, 1, 0, 0]}

tickers={'BTC'：[2001499844]，'ETH'：[200320405460]}
def检查_状态（数据）：
国家=[无]
对于枚举中的i，n（数据[1:]）：
状态=无
p=数据[i]
（低，高）=（p/1.5，p*1.5）
如果n>=p：
如果n=低，则状态为0，否则为3
states.append（state）
返回状态
tickers_state={k:检查tickers.items（）中k、v的_状态（v）}
打印（票务状态）
#输出
#{'BTC'：[None，2，3，3]，'ETH'：[None，1，0，0]}

您可以使用一个函数来比较列表中的每一对连续值，该函数在列表中循环，并使用enumerate启用对上一个列表项的访问以进行比较。然后在函数中使用dict CONTRUSION生成原始dict的映射版本，其中包含比较的值

在下面的示例中，它从第二个列表项开始循环通过列表的一个片段，因此前一个元素由当前值

i

访问，因为该片段实际上将索引值移动了1

tickers = {'BTC': [200, 149, 98, 44], 'ETH': [200, 320, 405, 460]}

def check_states(data):
    states = [None]
    for i, n in enumerate(data[1:]):
        state = None
        p = data[i]
        (low, high) = (p / 1.5, p * 1.5)
        if n >= p:
            state = 0 if n <= high else 1
        else:
            state = 2 if n >= low else 3           
        states.append(state)    
    return states

tickers_state = {k: check_states(v) for k, v in tickers.items()}

print(tickers_state)
# OUTPUT
# {'BTC': [None, 2, 3, 3], 'ETH': [None, 1, 0, 0]}

tickers={'BTC'：[2001499844]，'ETH'：[200320405460]}
def检查_状态（数据）：
国家=[无]
对于枚举中的i，n（数据[1:]）：
状态=无
p=数据[i]
（低，高）=（p/1.5，p*1.5）
如果n>=p：
如果n=低，则状态为0，否则为3
states.append（state）
返回状态
tickers_state={k:检查tickers.items（）中k、v的_状态（v）}
打印（票务状态）
#输出
#{'BTC'：[None，2，3，3]，'ETH'：[None，1，0，0]}

ok。1） 首先，在我迭代每个列表中的所有元素之后，我迭代了ticker dict中的所有元素3）在我尝试检查每个项目之后------------------------------------------如何修改第一个项目？什么是函数的参数？@Freedomillusions你的问题不清楚。例如，您将149与200进行比较，在函数中使用4种不同的

if:else

条件，并且只期望一个值作为比较？你的问题应该尽可能清楚明白。1） 首先，在我迭代每个列表中的所有元素之后，我迭代了ticker dict中的所有元素3）在我尝试检查每个项目之后------------------------------------------如何修改第一个项目？什么是函数的参数？@Freedomillusions你的问题不清楚。例如，您将149与200进行比较，在函数中使用4种不同的

if:else

条件，并且只期望一个值作为比较？你的问题应该尽可能清楚