Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > Python > dot operations

Reply
Thread Tools

dot operations

 
 
jm.suresh@no.spam.gmail.com
Guest
Posts: n/a
 
      01-11-2007
Hi,
Frequently I get to do like this:
a = (1, 2, 3, 4) # some dummy values
b = (4, 3, 2, 1)
import operator
c = map(operator.add, a, b)

I am finding the last line not very readable especially when I combine
couple of such operations into one line. Is it possible to overload
operators, so that, I can use .+ for element wise addition, as,
c = a .+ b
which is much more readable.

Similarly, I want to use .- , .*, ./ . Is it possible to do?

thanks.

-
Suresh

 
Reply With Quote
 
 
 
 
robert
Guest
Posts: n/a
 
      01-11-2007
http://www.velocityreviews.com/forums/(E-Mail Removed) wrote:
> Hi,
> Frequently I get to do like this:
> a = (1, 2, 3, 4) # some dummy values
> b = (4, 3, 2, 1)
> import operator
> c = map(operator.add, a, b)
>
> I am finding the last line not very readable especially when I combine
> couple of such operations into one line. Is it possible to overload
> operators, so that, I can use .+ for element wise addition, as,
> c = a .+ b
> which is much more readable.
>
> Similarly, I want to use .- , .*, ./ . Is it possible to do?


import numpy

You'll not even need dots
 
Reply With Quote
 
 
 
 
Paddy
Guest
Posts: n/a
 
      01-11-2007

(E-Mail Removed) wrote:
> Hi,
> Frequently I get to do like this:
> a = (1, 2, 3, 4) # some dummy values
> b = (4, 3, 2, 1)
> import operator
> c = map(operator.add, a, b)
>
> I am finding the last line not very readable especially when I combine
> couple of such operations into one line. Is it possible to overload
> operators, so that, I can use .+ for element wise addition, as,
> c = a .+ b
> which is much more readable.
>
> Similarly, I want to use .- , .*, ./ . Is it possible to do?
>
> thanks.
>
> -
> Suresh


List comprehensions?

>>> a = (1, 2, 3, 4)
>>> b = (4, 3, 2, 1)
>>> import operator
>>> c = map(operator.add, a, b)
>>> c

[5, 5, 5, 5]
>>> c1 = [a1+b1 for a1,b1 in zip(a,b)]
>>> c1

[5, 5, 5, 5]
>>>



- Paddy.

 
Reply With Quote
 
jm.suresh@no.spam.gmail.com
Guest
Posts: n/a
 
      01-11-2007

Paddy wrote:
> (E-Mail Removed) wrote:
> > Hi,
> > Frequently I get to do like this:
> > a = (1, 2, 3, 4) # some dummy values
> > b = (4, 3, 2, 1)
> > import operator
> > c = map(operator.add, a, b)
> >
> > I am finding the last line not very readable especially when I combine
> > couple of such operations into one line. Is it possible to overload
> > operators, so that, I can use .+ for element wise addition, as,
> > c = a .+ b
> > which is much more readable.
> >
> > Similarly, I want to use .- , .*, ./ . Is it possible to do?
> >
> > thanks.
> >
> > -
> > Suresh

>
> List comprehensions?
>
> >>> a = (1, 2, 3, 4)
> >>> b = (4, 3, 2, 1)
> >>> import operator
> >>> c = map(operator.add, a, b)
> >>> c

> [5, 5, 5, 5]
> >>> c1 = [a1+b1 for a1,b1 in zip(a,b)]
> >>> c1

> [5, 5, 5, 5]
> >>>

>


I just found this from :
http://aspn.activestate.com/ASPN/Coo.../Recipe/384122

class Infix(object):
def __init__(self, function):
self.function = function
def __ror__(self, other):
return Infix(lambda x, self=self, other=other:
self.function(other, x))
def __or__(self, other):
return self.function(other)
def __rlshift__(self, other):
return Infix(lambda x, self=self, other=other:
self.function(other, x))
def __rshift__(self, other):
return self.function(other)
def __call__(self, value1, value2):
return self.function(value1, value2)

import operator
dotplus = Infix(lambda x,y: map(operator.add, x, y))

a = range(4)
b = range(4)

c = a |dotplus| b

>
> - Paddy.


 
Reply With Quote
 
Steven W. Orr
Guest
Posts: n/a
 
      01-11-2007
On Thursday, Jan 11th 2007 at 11:41 +0100, quoth robert:

=>(E-Mail Removed) wrote:
=>> Hi,
=>> Frequently I get to do like this:
=>> a = (1, 2, 3, 4) # some dummy values
=>> b = (4, 3, 2, 1)
=>> import operator
=>> c = map(operator.add, a, b)
=>>
=>> I am finding the last line not very readable especially when I combine
=>> couple of such operations into one line. Is it possible to overload
=>> operators, so that, I can use .+ for element wise addition, as,
=>> c = a .+ b
=>> which is much more readable.
=>>
=>> Similarly, I want to use .- , .*, ./ . Is it possible to do?
=>
=>import numpy
=>
=>You'll not even need dots

I'm very new so my plea to be gentle is still on.

I just looked at the numpy package. Seems very cool, but for the life of
me I didn't understand the method by which python allows for creation of
infix operators. Can someone please explain or point me to a reference?

TIA

--
Time flies like the wind. Fruit flies like a banana. Stranger things have .0.
happened but none stranger than this. Does your driver's license say Organ ..0
Donor?Black holes are where God divided by zero. Listen to me! We are all- 000
individuals! What if this weren't a hypothetical question?
steveo at syslang.net
 
Reply With Quote
 
Steven D'Aprano
Guest
Posts: n/a
 
      01-11-2007
On Thu, 11 Jan 2007 06:06:39 -0800, (E-Mail Removed) wrote:

>> (E-Mail Removed) wrote:
>> > Hi,
>> > Frequently I get to do like this:
>> > a = (1, 2, 3, 4) # some dummy values
>> > b = (4, 3, 2, 1)
>> > import operator
>> > c = map(operator.add, a, b)
>> >
>> > I am finding the last line not very readable especially when I combine
>> > couple of such operations into one line. Is it possible to overload
>> > operators, so that, I can use .+ for element wise addition, as,
>> > c = a .+ b
>> > which is much more readable.


[snip]

> I just found this from :
> http://aspn.activestate.com/ASPN/Coo.../Recipe/384122
>
> class Infix(object):


[snip code]

> c = a |dotplus| b



Personally, I find that to be the least readable of all the alternatives.
It is also slow, so slow that using it is (in my opinion) a pessimation
rather than an optimization.

Let me make the usual warnings about premature optimization being
the root of all evil, blah blah blah. Readability counts, and nobody cares
if you shave one hundredth of a millisecond off some code that your
program runs once. But, having said that, map is *fast*, especially with
the functions from operator.

>>> import timeit
>>> timeit.Timer("map(operator.add, a, b)",

.... "import operator; a = (1, 2, 3, 4); b = (4, 3, 2, 1)").timeit()
4.0072550773620605

It is even faster if you get rid of the dot lookup:

>>> timeit.Timer("map(add, a, b)", "from operator import add; "

.... "a = (1, 2, 3, 4); b = (4, 3, 2, 1)").timeit()
3.6557090282440186

Using lambda can be much slower:

>>> timeit.Timer("map(lambda x,y: x+y, a, b)",

.... "a = (1, 2, 3, 4); b = (4, 3, 2, 1)").timeit()
6.1221940517425537

A list comprehension is in the middle, speed-wise:

>>> timeit.Timer("[x+y for x,y in zip(a,b)]",

.... "a = (1, 2, 3, 4); b = (4, 3, 2, 1)").timeit()
5.0318419933319092

But the Infix recipe is slower than a wet week:

>>> timeit.Timer("a|dotplus|b",

.... "a = (1, 2, 3, 4); b = (4, 3, 2, 1); "
.... "from __main__ import dotplus").timeit()
15.195909976959229


Speaking for myself, I find list comprehensions to be the most readable of
the alternatives and the most Pythonic.



--
Steven.

 
Reply With Quote
 
Dan Bishop
Guest
Posts: n/a
 
      01-12-2007
On Jan 11, 10:21 am, "Steven W. Orr" <(E-Mail Removed)> wrote:
> On Thursday, Jan 11th 2007 at 11:41 +0100, quoth robert:
>
> =>(E-Mail Removed) wrote:=>> Hi,
> =>> Frequently I get to do like this:
> =>> a = (1, 2, 3, 4) # some dummy values
> =>> b = (4, 3, 2, 1)
> =>> import operator
> =>> c = map(operator.add, a, b)
> =>>
> =>> I am finding the last line not very readable especially when I combine
> =>> couple of such operations into one line. Is it possible to overload
> =>> operators, so that, I can use .+ for element wise addition, as,
> =>> c = a .+ b
> =>> which is much more readable.
> =>>
> =>> Similarly, I want to use .- , .*, ./ . Is it possible to do?
> =>
> =>import numpy
> =>
> =>You'll not even need dots
>
> I'm very new so my plea to be gentle is still on.
>
> I just looked at the numpy package. Seems very cool, but for the life of
> me I didn't understand the method by which python allows for creation of
> infix operators. Can someone please explain or point me to a reference?


Python doesn't allow the creation of new operators, but you can
overload the existing ones (except for "and" and "or"). This is done
by implementing the methods __add__, __sub__, __mul__, etc.

http://docs.python.org/ref/specialnames.html

 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
Re: what is the difference between the vb dot net and asp dot net Nathan Sokalski ASP .Net 11 08-14-2009 08:22 PM
Dot Net Project Execution without Dot Net and Framework.... krishnan ASP .Net Building Controls 0 01-07-2006 08:51 AM
Dynamically resize visible text and append dot dot dot (like gmail subject lines.. ) how to question? jawolter@gmail.com Javascript 6 12-12-2005 04:09 PM
volatile struct in dot h vs dot c Christopher M. Lusardi C Programming 3 05-15-2004 12:17 AM
To dot or not to dot? SamuŽl van Laere HTML 8 10-16-2003 02:55 PM



Advertisments