标签: argument-unpacking

我正在尝试传递多个字符串来填充容器，但收到此错误。使用 gcc 4.9.3

template< class T >
struct DataCompare {
    bool operator()( const T& lhs, const T& rhs ) const
    {
        return operator<( lhs->getCode(), rhs->getCode() );
    }
};

using AggContainer = boost::container::flat_set< T, C >; 
using DataPtr      = boost::shared_ptr< BomQueueData >;
using PropertyQueueDataLess = DataCompare< DataPtr >;
using QueueDataPtrs = AggContainer< DataPtr, DataLess >;

QueueDataPtrs vector_name;

template< class Container, typename ... Args >
static void fillWithData(Container & oDataContainer, Args const & ... args)
{
    typedef typename Container::value_type::element_type QueueDataPtr;
    oDataContainer.emplace(new QueueDataPtr(args)); …

a_proc = Proc.new {|a,b,*c| p c; c.collect {|i| i*b }}
puts a_proc[2,2,4,3]

根据https://ruby-doc.org/core-2.2.0/Proc.html，上面的代码非常直观，a_proc [2,2,4,3]只是a_proc.call（2,2 ，4,3）隐藏“通话”

但是以下内容（效果很好）让我很困惑

a=[2,2,4,3]
puts a_proc.call(a)
puts a_proc.call(*a)

似乎与普通的函数调用有很大不同，因为它不检查传入的数字参数。

但是，按预期方式，如果同样使用参数，则调用语义的方法将引发错误

def foo(a,b,*c)
  c.collect{|i| i*b}
end
foo([1,2,3,4]) #`block in <main>': wrong number of arguments (given 1, expected 2+) (ArgumentError)

foo(*[1,2,3,4]) #works as expected

我不认为这种不一致是设计故障，因此，对此有任何见解将不胜感激。

我无法弄清楚如何正确地注释这段代码:

from typing import Iterable

def f(*params: Iterable) -> str:
    return ":".join(params)

我知道这Iterable是不正确的,因为mypy告诉我:

error: Argument 1 to "join" of "str" has incompatible type Tuple[Iterable[Any], ...]; expected Iterable[str]

......但我不明白为什么.

在 Python 中，要使用字典格式化字符串，可以简单地执行以下操作：

geopoint = {
  'latitude': 41.123,
  'longitude':71.091
}

print('{latitude} {longitude}'.format(**geopoint))

输出将为41.123 71.091. 如何在 Go 中实现字符串格式映射的相同关键字解包？

编辑：抱歉，如果问题中不清楚，但我想要做的是，就像在 Python 中一样，提供格式字符串内的值的键。

我想创建一个类来像字典一样解压它的对象。

例如，使用字典，您可以这样做

foo = {
  "a" : 1
  "b" : 2
}

def bar(a,b):
   return a + b

bar(**foo)

输出3

我希望能够做到这一点

class FooClass:
    def __init__(self):
        self.a = a
        self.b = b

f = FooClass()
bar(**f)

并让它输出3

这是我能找到的最相关的问题，但它没有解决这个问题，所以我认为这可能是不可能的。

目前我的解决方案是这样的：

class FooClass:
    def __init__(self):
        self.a = a
        self.b = b

    def to_dict(self):
        return {
          "a" : self.a,
          "b" : self.b
        }

f = FooClass()
bar(**f.to_dict())

我正在Elixir写一个游戏引擎.(是的,我知道它不是一种本身就适合的语言 - 关键是要看一下非典型语言的使用如何影响结果的结构.)

因此,我有几个主管要在比赛开始时运行 - 但他们应该监督什么取决于游戏.我的想法是让用户在config.exs文件中列出必要的子节点,加上参数和选项作为元组列表,然后管理程序本身只是从应用程序环境中提取这些元组并使用它们的内容作为参数worker\2(或者worker\3,视情况而定).

但是,我找不到任何Elixir等同于Python的元组解包.我可以通过一个简单的函数自己完成这个特定的情况:

def unpack_worker({module, args}) do
  worker(module, args)
end

def unpack_worker({module, args, opts}) do
  worker(module, args, opts)
end

但这种情况充其量只是笨拙,并且必须再次针对我可能需要这种可配置性的每个功能进行编写.

我正在使用kinterbasdb模块,该模块有一个名为fetchone的函数,它返回执行查询的结果:

cursor.execute("....")
cursor.fetchone()

这会返回一个元组:("value1",),我想要访问第一个项目,但是最后避免使用[0]它,因为它没有说明多少,这是一个神奇的数字.可能吗？也许有些内置功能？

我试图用:

value, _ = cursor.fetchone()

但这是回归:ValueError: need more than 1 value to unpack因为索引1没有任何东西.

有没有一种方法可以将函数的关键字参数指定为字典，类似于.允许我们提供位置参数列表的方法？我正在寻找类似于 python 的*args 和 **kwargs的东西。

更详细地说：

如果我们想在函数中处理任意数量的位置参数，我们可以这样定义它：

(define (my-add . args)
  (apply + args))

并将其与可变数量的参数一起使用，如下所示：

(define numbers '(1 2 3))
(apply my-add numbers) ;=> 6
(define numbers '(1 2 3 4 5))
(apply my-add numbers) ;=> 15

即使对于没有通过.语法显式处理位置参数的“其余”部分的函数，我们也可以使用它apply从列表中解包位置参数。

(apply expt '(2 3)) ;=> 8

我发现除了位置参数之外，apply 它还转发关键字参数。但是，只有当调用的函数本身标识了它所期望的特定关键字参数时，这才有效。例如，在分派情况下，函数本身不使用关键字参数，而只是打算将它们转发到某个适当的处理程序，以这种方式使用 apply 并不能满足我们的需要，因为函数需要了解其分派到的任何函数接受的所有关键字参数，更不用说在调用处理程序之前以某种方式重新打包它们了。

作为说明该问题的具体示例，请考虑一个简单的“echo args”函数，该函数会回显传递给它的所有参数：

(define (echo-args . args)
  (printf "~a" args))

仅使用位置参数：

> (echo-args 1 2 5)
(1 2 5)

使用关键字参数：

> …

您好，感谢您的时间；

我正在使用 *args 来获取各种参数，这会创建一个元组。如何将元组“解包”到列表中？以下代码在列表中附加了一个元组。

grades = []

def add_grades(*args):
    grades.append(args):
    return grades

print(add_grades(99,88,77))

我可以使用 for 循环并遍历元组来执行此操作，但希望查看是否可以直接解压缩。

我正在阅读一份解释解包的在线文档（*args和**kwargs）。被以下两个断言搞糊涂了，不知道为什么第二个函数无效。谁能帮助我理解原因？

def f(x, y, z):
    return [x, y, z]

t = (3,)  
d = {"z": 4}
assert f(2, *t, **d) == [2, 3, 4]
assert f(x=2, *t, **d) == [2, 3, 4]  # TypeError: f() got multiple values for argument 'x'

参考 https://caisbalderas.com/blog/python-function-unpacking-args-and-kwargs/

注意：这个问题与TypeError: got multiple values for argument不同，因为它需要额外了解 Python 中参数解包的工作原理。

从 PHP7.4 开始，有一种新的技术可以使用数字键重新索引数组。

我会称它为“数组重新打包”或者一些有趣的东西，比如“ splatpacking ”。简单的过程包括使用 splat 运算符 ( ...) —— 又名“扩展运算符”——来解包一个数组，然后通过“对称数组解构”用第一级元素填充一个新数组。

• RFC：数组表达式中的扩展运算符
• 扩展运算符在 PHP5.6 中可用
• 对称数组解构在 PHP7.1 中可用
• Laravel 新闻：PHP 7.4 中的数组扩展运算符

比较代码：（演示）

$array = [2 => 4, 5 => 3, "3" => null, -10.9 => 'foo'];

var_export(array_values($array));
var_export([...$array]);

两者都会输出：

array (
  0 => 4,
  1 => 3,
  2 => NULL,
  3 => 'foo',
)

同样，splatpacking 技术严格限于带有数字键的数组，因为 splat 运算符会阻塞其他任何东西，并且只有 PHP7.4 及更高版本才能将解压缩的值直接写入数组。

由于这两种技术在排位赛中提供相同的输出，我什么时候应该使用一种而不是另一种？

请注意，这不是关于如何重新索引键，而是array_values()与新可用技术的比较。

这不同于：

• 重新索引数字数组键
• 你如何在 PHP 中重新索引数组？
• PHP重新索引数组？[复制]
• array_unique 然后重新编号键 …