如果我有一个NumPy的阵列,例如5×3,有没有办法把它解压到通过一次全部列接一列传递给一个函数,而不是像这样:my_func(arr[:, 0], arr[:, 1], arr[:, 2])？
有点像*args列表拆包但是按列.
给出一个简单的词典列表
lst = [{'key1': 1}, {'key2': 2}, {'key3': 3}]
我想找到一个dict,它产生使用此处未详述的方法评估的最小值.我的第一个想法是迭代列表以通过dict检查dict,但是这失败了:
for k, v in [x.items() for x in lst]:
print(k, v)
结果ValueError(以及使用生成器而不是列表):
for k, v in [x.items() for x in lst]:
ValueError: not enough values to unpack (expected 2, got 1)
然而,
for x in lst:
for k, v in x.items():
print(k, v)
产量
key1 1
key2 2
key3 3
正如所料.我假设所有方法都按预期工作(除非PEBKAC),但为什么它不能使用列表理解？有人可以开导我吗？
编辑:我使用python 3,我知道items()产生一个dict_view,但我不明白为什么逻辑不起作用.
我知道星号在Python中的函数定义中是什么意思.
不过,我经常会看到使用参数调用函数的星号:
def foo(*args, **kwargs):
first_func(args, kwargs)
second_func(*args, **kwargs)
第一个和第二个函数调用有什么区别？
我收到一个错误type object argument after ** must be a mapping, not tuple.
我有这个代码:
create_character = player.Create(**generate_player.generate())
这是player.py模块:
class Create(object):
def __init__(self,name,age,gender):
self.name = name
self.age = age
self.gender = gender
这是generate_player.py模块:
import prompt
def generate():
print "Name:"
name = prompt.get_name()
print "Age:"
age = prompt.get_age()
print "Gender M/F:"
gender = prompt.get_gender()
return name, age, gender
该prompt模块只是一串raw_input返回字符串或整数(int for age)的s .
为什么它会返回元组？当我print type在generate_player模块中运行时,我得到了我的参数的字符串,int,字符串.
我有类似的数据data = [[t1, t2, ...], [v1, v2, ...]]。我想将其包装在一个类中，这样我就可以调用data.t而不必使用data[0].
我尝试通过以下方法来做到这一点：
class Variable:
def __init__(self, data):
self.t = data[0]
self.v = data[1]
def __getitem__(self, key):
if key == 0:
return self.t
elif key == 1:
return self.v
else:
raise ValueError("not valid key '{}'".format(key))
def __setitem__(self, key, value):
if key == 0:
self.t = value
elif key == 1:
self.v = value
else:
raise ValueError("not valid key '{}'".format(key))
__getitem__和重载的原因__setitem__是为了向后兼容，以便data[0]仍然有效。这适用于大多数情况，但是我在以下调用中遇到了问题：
func_that_takes_two_arguments(*data) # unpacking …def fun(a, b, c, d):
print('a:', a, 'b:', b, 'c:', c, 'd:', d)
为什么这个有效
fun(3, 7, d=10, *(23,))
并打印出：
a: 3 b: 7 c: 23 d: 10
而这
fun(3, 7, c=10, *(23,))
才不是
Traceback (most recent call last):
File "/home/lookash/PycharmProjects/PythonLearning/learning.py", line 10, in <module>
fun(3, 7, c=10, *(23,))
TypeError: fun() got multiple values for argument 'c'
考虑一个定义为的函数：
def fun(a, *args):
print(type(args), args)
调用时，它将额外的位置参数打包为tuple。
>>> fun(2, 3, 4)
<class 'tuple'> (3, 4)
我想在函数参数之外实现类似的事情。所以，我想我可以通过扩展的可迭代解包来实现同样的事情，但它总是将东西打包成一个列表，而不是一个元组：
# RHS is a tuple
>>> (a, *args) = (2, 3, 4)
>>> type(args)
<class 'list'>
>>> args
[3, 4] #but args is not a tuple!
使它与：
# RHS is a list
>>> (a, *args) = [2, 3, 4]
>>> type(args)
<class 'list'>
>>> args
[3, 4]
我可以理解这也是PEP 中提出的方式。
我在问是否有另一种方法来实现我想要的。
当然，我可以args稍后通过以下方式转换为元组：
>>> args = …python tuples argument-unpacking python-3.x iterable-unpacking
我有一个d维数组,A和长度等于d的向量inds.我想在inds访问A的值.
理想情况下,我会做类似A(*inds)的东西(借用Python的解包语法).我不知道如何在MATLAB中做到这一点.
如果我做A(inds),我实际上从A得到了单独的值,这不是我想要的.我想要的是inds的元素i是函数调用A()中的第i个参数.
在 Python 中，按照惯例，下划线 ( _) 通常用于丢弃解包元组的一部分，如下所示
>>> tup = (1,2,3)
>>> meaningfulVariableName,_,_ = tup
>>> meaningfulVariableName
1
我正在尝试对 lambda 的元组参数执行相同的操作。只能用 2 元组来完成这似乎不公平......
>>> map(lambda (meaningfulVariableName,_): meaningfulVariableName*2, [(1,10), (2,20), (3,30)]) # This is fine
[2, 4, 6]
>>> map(lambda (meaningfulVariableName,_,_): meaningfulVariableName*2, [(1,10,100), (2,20,200), (3,30,300)]) # But I need this!
SyntaxError: duplicate argument '_' in function definition (<pyshell#24>, line 1)
有什么想法吗？实现这一目标的最佳方法是什么？
在 C++ 中，如果函数返回 a std::pair<int, int>，我们可以按如下方式自动接收它：
auto pr = some_function();
std::cout << pr.first << ' ' << pr.second;
现在，C++17 标准提供了一种将这对直接解包为单独变量的漂亮方法，如下所示：
auto [x, y] = some_function();
std::cout << x << ' ' << y;
然后是std::minmax_element()库函数，它返回一对迭代器。所以如果我将 a 传递vector<int>给这个函数，它会给我一对指向向量中最小和最大元素的迭代器。
现在我可以像往常一样接受这些迭代器的一种方法，然后按如下方式取消引用它们。
std::vector<int> v = {4,1,3,2,5};
auto [x, y] = std::minmax_element(v.begin(), v.end());
std::cout << (*x) << ' ' << (*y); // notice the asterisk(*)
现在我的问题是：有没有办法在解包时取消引用它们？或者更准确地说，给定以下代码，我可以用有效的 C++替换var1和var2并打印这些迭代器指向的值吗？
std::vector<int> v = {4,1,3,2,5};
auto [var1, …