标签: iterable

dict.update([other])说

使用其他的键/值对更新字典，覆盖现有的键。返回无。

update() 接受另一个字典对象或键/值对的可迭代对象（作为元组或长度为 2 的其他可迭代对象）。如果指定了关键字参数，则字典将使用这些键/值对进行更新：d.update(red=1, blue=2)。

但

>>> {}.update( ("key", "value") )
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: dictionary update sequence element #0 has length 3; 2 is required

那么为什么 Python 显然会尝试使用元组的第一个字符串呢？

我想使用Iterable<String>和 谓词来执行一个字符串列表过滤函数来选择要保留的字符串，其他字符串必须从列表中删除，但我并没有低估如何进行删除。

static <T> Iterable<T> select(Iterable<T> it, Predicate<T> pred) {
    for (T s: it) {
        if (pred.test(s)==false) {
            // what to do here?
        }
    }
    return ...;
}

对于此输入：

{"a","","b",""}

我预计

{"a","b"}

我需要使用 argparse 从命令行接受可变数量的字符串，但是当我传递零个参数时，我得到一个字符串作为结果，而不是一个字符串的列表。

argparser = argparse.ArgumentParser()
argparser.add_argument(
    '--example',
    nargs='*',
    default='default_value',
    type=str)

args = argparser.parse_args()

for e in args.example:
    print(e)

执行此操作时python program --example first_arg second_arg我得到预期结果：

first_arg
second_arg

即使只有一个参数，一切都很好，但是执行这个python program我得到：

d
e
f
a
u
l
t
_
v
a
l
u
e

我需要迭代列表而不考虑它有多少元素，我该如何解决这个问题？先感谢您。

我试图将一个函数应用于包含任意子列表子级别的列表的每个元素。像这样。

a = [1,2,3]
b = [[1,2,3],[4,5,6]]
c = [[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]]

function = lambda x: x+1
def apply(iterable,f): 
    # do stuff here

print(apply(a,function)) # [2,3,4]
print(apply(b,function)) # [[2,3,4],[5,6,7]]
print(apply(c,function)) # [[[2,3,4],[5,6,7]],[[8,9,10],[11,12,13]]]

基本上我找不到编写apply函数的方法。我尝试过 numpy，但这当然不是解决方案，因为列表的内容也可以是字符串、对象......

我发现自己制作多级词典相当多。我总是不得不编写非常冗长的代码来遍历包含大量临时变量的字典的所有级别。

有没有办法概括这个函数来迭代多个级别而不是硬编码并手动指定有多少级别？

def iterate_multilevel_dictionary(d, number_of_levels):
    # How to auto-detect number of levels? 
    # number_of_levels = 0
    if number_of_levels == 1:
        for k1, v1 in d.items():
            yield k1, v1
    if number_of_levels == 2:
        for k1, v1 in d.items():
            for k2, v2 in v1.items():
                yield k1, k2, v2
    if number_of_levels == 3:
        for k1, v1 in d.items():
            for k2, v2 in v1.items():
                for k3, v3 in v2.items():
                    yield k1, k2, k3, v3
                    
# Level 1
d_level1 = {"a":1,"b":2,"c":3}
for items in iterate_multilevel_dictionary(d_level1, …

我需要匹配输入可迭代的情况。这是我尝试过的：

from typing import Iterable

def detector(x: Iterable | int | float | None) -> bool:
    match x:
        case Iterable():
            print('Iterable')
            return True
        case _:
            print('Non iterable')
            return False

这会产生这个错误：

TypeError: called match pattern must be a type

是否可以通过匹配/大小写来检测可迭代性？

请注意，这两个问题解决了相同的错误消息，但两个问题都不是关于如何检测可迭代性：

• 如何修复 TypeError: 调用的匹配模式必须是 Python 3.10 中的类型

• Python 中的模式匹配出现错误：调用的匹配模式必须是一种类型

我正在学习 JavaScript，我来自 Java。

Java 开发人员可以轻松评估接口的有用性，因为所有已知的实现类都已记录在案。请点击此处查看示例。

JavaScript 中情况并非如此。例如，对于可迭代对象，下面的链接仅显示了可迭代对象的几个示例。它们没有显示所有内置类和 DOM 类的实现。（例如，他们提到“像 NodeList 这样的集合类型也是可迭代的”。那么，除了 NodeList 之外，我怎样才能找到其他可迭代的 DOM 类？是否有一些我可以运行的 JS 代码来实现这一点？谢谢！）

JavaScript 开发人员如何找到接口的实现类？

谢谢！

关于可迭代的 MDN 文档：

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#built-in_iterables

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Iterator#description

更新1：

我正在寻找的是可以进入Array.from()第一个参数的迭代。谢谢！

这只是有是一个傻瓜,但我只是没有找到这个问题的任何现有实例...

在Python中将任何iterable转换为数组的最简单方法是什么(理想情况下,不导入任何东西)？

注意:理想情况下,如果输入是一个数组,那么它不应该复制它(但这不是必需的).

在Python中,您可以这样写:

def add(a, b, c):
    return a + b + c

list_of_args = [4, 5, 6]
print(add(*list_of_args))

前面的星号list_of_args展开了iterable,使其元素是参数a,b和c的值.

你能在F#做类似的事吗？具体来说,我正在寻找一个好的或惯用的F#解决方案,并且不想用反射等来解决问题.

a=['1','2','3']

map(int,a) 可以使用list来耗尽输出:

list(map(int,a))

输出: 1,2,3

a=['1','2','3']
b=['1','2']

如何耗尽以下条件:

map(int,a,b)