Python 将元组乘以标量

我有以下代码：

print(img.size)
print(10 * img.size)

这将打印：

(70, 70)
(70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70)

我想把它打印出来：

(700, 700)

有没有什么方法可以不用写：

print(10 * img.size[0], 10 * img.size[1])

---

PS:

img.size

是PIL图像。我不知道在这种情况下这是否有什么关系。

可能是一种更好的方式，但这应该是可行的

tuple([10*x for x in img.size])

---

您可以尝试以下方法：

print [10 * s for s in img.size]

---

它将为您提供一个新的列表，其中包含元组中的所有元素乘以10

，pythonic方法将使用列表理解：

y = tuple([z * 10 for z in img.size])

另一种方法可以是：

y = tuple(map((10).__mul__, img.size))

---

也许有比这更简单的方法，但是

print map(lambda x: 10*x, img.size)

---

虽然它打印为列表而不是元组，但它几乎可以执行您想要的操作。如果希望将

map

调用包装在

tuple（map…

中，以元组（括号而不是方括号）的形式进行打印。

如果您经常遇到此问题，并且元组或列表较大，则可能需要使用库，它允许您对数组执行各种数学操作。然而，在这种简单的情况下，这完全是过火了。

只增加了多样性

import operator
img_size = (70, 70)
map(operator.mul, img_size, len(img_size)*(10,))

解决方案：

set1=(70, 70)
tuple(2*array(set1))

说明：

数组

使直接标量乘法成为可能。因此，这里称为

set1

的

元组

被转换为

数组

。我假设您希望继续使用

元组

，因此我们将

数组

转换回

元组

---

此解决方案是为了避免显式且冗长的

for

循环。我不知道这两种情况下是更快还是发生完全相同的事情。

与前面的答案一致，但使用numpy：

import numpy as np
result = tuple(10*np.array(img.size))

---

您正试图将该函数作为一个整体应用于元组。 您需要将其应用于各个元素并返回一个新的元组

newTuple = tuple([10*x for x in oldTuple])

---

请记住，您不能更改元组。

如果您正在编写一堆代码，但不想要更复杂的向量库，那么这是一件简单的事情

class V(tuple):
    '''A simple vector supporting scalar multiply and vector add'''
    def __new__ (cls, *args):
        return super(V, cls).__new__(cls, args)
    def __mul__(self,s):
        return V( *( c*s for c in self) )
    def __add__(self,s):
        return V( *( c[0]+c[1] for c in zip(self,s)) )
    def __repr__(self):
        return "V" + super(V, self).__repr__()

# As long as the "vector" is on the left it just works

xaxis = V(1.0, 0.0)
yaxis = V(0.0, 1.0)
print xaxis + yaxis      # => V(1.0, 1.0)
print xaxis*3 + yaxis*5  # => V(3.0, 5.0)
print 3*xaxis            # Broke, => (1.0, 0.0, 1.0, 0.0, 1.0, 0.0)

否则，“V”实例的行为就像元组一样。这要求使用相同数量的元素创建“V”实例。例如，您可以添加到新的

if len(args)!=2: raise TypeError('Must be 2 elements')

---

要强制所有实例都是二维向量….

只需概述一下

import timeit
#元组元素乘法运算
#土生土长的
map_lambda=“”
a=元组（范围（10000））
b=元组（映射（λx:x*2，a））
"""
#土生土长的
元组_=“”
a=元组（范围（10000））
b=元组（x*2表示a中的x）
"""
#努比
使用_numpy=“”
将numpy作为np导入
a=元组（范围（10000））
b=元组（（np.array（a）*2.tolist（））
"""
打印（'map_lambda='，timeit.timeit（map_lambda，number=1000））
打印（'tuple\u construction='，timeit.timeit（tuple\u construction，number=1000））
打印（'using_numpy='，timeit.timeit（using_numpy，number=1000））

我的机器上的计时

map_lambda=1.541315148000649
元组理解=1.083845213999662
使用_numpy=1.2488984129995515
（10*img.size[0]，10*img.size[1]）有什么问题？我不明白为什么你需要过度设计像2个整数的乘法这样简单的东西。请注意，此元组始终只有两个元素！我没有过度设计。我在问是否有更好更简单的方法。再看一次我的帖子。@paprika:…因为所讨论的元组可能没有已知的长度。在本例中确实如此（正如我遇到这个问题时所做的那样），但是为假定的元组长度编码、重复标量n次以及必须正确获取n个索引是非常困难的，如果可以直接避免的话。第二个非常棒。。。哈哈，这两个例子都没有抓住问题的关键。两者都迫使程序员接受一个简单的想法（标量乘以矩阵乘法）并对其进行解构。虽然对于一个简单的例子来说，使用numpy可能有些过分，但问题的关键似乎是“python是否提供了一种可以用数学简单表示模拟操作的方法？”我的意思是，如果你有一个矩阵a=[70]，那么2A=[140].稍微好一点：
tuple（10*x表示img.size中的x）
据我所知，这在Python 2或3中不起作用。我假设
array
来自
array
模块？Python需要一个字符作为
数组
的第一个参数，因此仅传入一个元组将因
类型错误而失败：数组（）参数1或类型代码必须是char（字符串或长度为1的ascii unicode），而不是元组
。你能用一个更完整的例子来扩展它吗？我假设它是一个numpy数组？lambda函数可以替换为“map（（10）。\uuuuuuuuuuuuuuuuuuuuuuuuuu，img.size）”
if len(args)!=2: raise TypeError('Must be 2 elements')