Multiply a tuple by a constant

[Jay Davis]

I often need to multiply a tuple by a
constant and the methods I use now are
not very pretty. The idea is to get a
new tuple that is some factor times the
start tuple, like 'newtup = .5 * oldtup'.

Is there a slick way to do this?

[Peter Otten]

Jay Davis wrote:

I often need to multiply a tuple by a
constant and the methods I use now are
not very pretty. The idea is to get a
new tuple that is some factor times the
start tuple, like 'newtup = .5 * oldtup'.

Is there a slick way to do this?

Not really slick, but it works:

tuple(map(5 .__mul__, (1,2,3))) (5, 10, 15)

The space after the 5 is necessary. Alternatively, you can wrap the constant
in brackets:
tuple(map((5)._ _mul__, (1,2,3)))

(5, 10, 15)

Peter

[Peter Otten]

These days list comprehensions are preferred:

tuple([5*i for i in (1,2,3)])

(5, 10, 15)

[Jeremy Sanders]

On Fri, 13 Feb 2004 02:20:06 -0800, Jay Davis wrote:

I often need to multiply a tuple by a constant and the methods I use now
are not very pretty. The idea is to get a new tuple that is some factor
times the start tuple, like 'newtup = .5 * oldtup'.

Is there a slick way to do this?

I suggest looking at Numarray - a very convenient way of doing maths on
sets of numbers. Of course if you don't do very much it's not worth doing
this.

http://www.stsci.edu/resources/softw...dware/numarray

You can do things like:

import numarray

a = numarray.array( (1.,2.,5.,-46.) )
a *= 0.5
b = a + 3.4

Jeremy

[Larry Bates]

two ways:

t=(1,2,3)
newt=tuple(map( lambda x: x*0.5, t))

Note: apparently the map function is slated for deprication
(to be replaced by list comprehension)

List comprehension:

t=(1,2,3)
newt=tuple([x*0.5 for x in t])

-Larry Bates
-----------------------------------------------------------
"Jay Davis" <dj********@yah oo.com> wrote in message
news:1d******** *************** ***@posting.goo gle.com...

I often need to multiply a tuple by a
constant and the methods I use now are
not very pretty. The idea is to get a
new tuple that is some factor times the
start tuple, like 'newtup = .5 * oldtup'.

Is there a slick way to do this?

[Michele Simionato]

dj********@yaho o.com (Jay Davis) wrote in message news:<1d******* *************** ****@posting.go ogle.com>...

I often need to multiply a tuple by a
constant and the methods I use now are
not very pretty. The idea is to get a
new tuple that is some factor times the
start tuple, like 'newtup = .5 * oldtup'.

Is there a slick way to do this?

You can always subclass tuple and redefine "*". Dunno if you would
consider it slick enough.

Michele