Comments on: More Python and C# idioms: Finding the difference between two lists

By: csharptalk.com

csharptalk.com — Tue, 27 Oct 2009 12:58:31 +0000

quite good article.

thanks
csharptalk.com

By: Michael Chermside

Michael Chermside — Mon, 26 Oct 2009 23:43:46 +0000

I like the convenience of C#’s “.Except” – someone in a hurry might not think of the sets immediately, but would certainly bother to look at the list’s methods.

Of course, this only works because you’re using the built-in list type which has rich features. The python approach works on pretty much anything you can iterate over, which is handy for those of us who sometimes use OTHER data structures besides the built-in ones.

By: Amit Patel

Amit Patel — Sun, 25 Oct 2009 18:58:42 +0000

The OO syntax (noun.verb) is great when there’s one noun. When there are zero or two or more it doesn’t work as nicely, and the functional syntax (verb (noun, noun, noun)) works better. When there’s just one noun, you can dispatch on the type of that, which also means you can control namespaces.

For dispatching the alternative not limited to one noun is multimethods. They don’t seem to take off. For namespaces the alternative isn’t explored as much, but Koenig lookup in C++ is a stab at it.

I think we should also look at sentences in spoken languages. We tend to always have a verb, and then we have some nouns. So the functional approach seems like a better match. However at least in English the verb often occurs after the subject, so noun.verb is a better order.

Noun.verb also gives better completion in IDEs, because the noun is drawn from a limited namespace (locals and globals) and then the verb can also be drawn from a limited namespace (only the methods defined on the type of the noun).

As far as my preference, I am not a big fan of uniformity. I like things to look different syntactically so that I can easily distinguish them when scanning code. I don’t have a strong opinion for set difference though.

By: Jon Udell

Jon Udell — Fri, 23 Oct 2009 00:30:53 +0000

> set(L1).difference(L2)

Oh, so there’s the noun-verb pattern. Thanks!

By: David W

David W — Fri, 23 Oct 2009 00:13:43 +0000

Hey Jon,

Python sets are wonderful, but they can be a little deceiving, particularly in the memory usage department. They also require that contained objects are immutable (having meaningful order and hash values).

For these reasons, and especially for larger collections that are approaching memory limits, the merge algorithm is a great alternative. http://pastie.org/666041 is an implementation I use for diffing large lists of integers in a Google AppEngine application (memory limit ~60mb). This algorithm only requires memory to store the differences, rather than also including intermediary sets.

Another useful set-related trick is, if you use set’s methods rather than its operator overloads, you may directly pass any sequence as the right operand without first converting it to a set:

set(L1) – set(L2)

Becomes:

set(L1).difference(L2)