The Traditional for Loop

for (int i=0; i < items.Count; i++)
{
    if (i % 2 == 0 && item[i].IsAwesome)
    {
        items[i].DoThatThing();
    }
}

C# inherits for from its predecessors, and to be honest it feels vestigial at best (and otherwise obnoxious). Keep in mind that for has always been a weird-looking, but usefully pithy, shortcut for a while loop, such as:

int i=0;
while (i < items.Count)
{
    if (i % 2 == 0 && item.IsAwesome)
    {
        items[i].DoThatThing();
    }

    i++;
}

I think that more of the usecases of for should be available in the other looping constructs, but more on that in a bit when I talk about Python.

Note the additional complications that you are doing your own bounds checking here, and that even that varies from type to type. For instance: IList<T> uses the Count property, arrays use Length, and gets more complicated in additional dimensions.

The More Moderne foreach

foreach (Item item in items)
{
    if (item.IsAwesome)
    {
        item.DoThatThing();
    }
}

This is the C# workhorse for use with anything that supports IEnumerable and/or IEnumerable<T>. Note that there is no strong, pithy way to get the current index/count during iteration other than:

int i = 0;
foreach (Item item in items)
{
    if (i % 2 == 0 && item.IsAwesome)
    {
        item.DoThatThing();
    }

    i++;
}

More often than not, using the equivalent for loop is pithier, and often preferred stylistically, if for no other reason.

The Lonely List<T>.ForEach

items.ForEach(item => if (item.IsAwesome) item.DoThatThing());

Very useful for short, pithy one-liners when using the most recent anonymous functions syntax, but only available in specific situations (List<T> as the big example). It predates LINQ, and is definitely oddly vestigial, or at least under-exploited.

I am curious why LINQ didn't bother adding a more general version as an IEnumerable<T> extension method. I'm also curious why ForEach doesn't have an overload that also provides the integer list position as well as the item...

LINQ "Fluent" Syntax

var query = items.Where(item => item.IsAwesome);

foreach (var item in query)
{
    item.DoThatThing();
}

LINQ queries are lazy, which is great, but they rely on the existing foreach, or a conversion extension method like .ToList<T>() and .ToArray<T>(), which I've already noticed are easy to abuse/mis-use.

A generic ForEach equivalent could help with that. Fluent syntax embedded into the foreach loop is fairly common, and makes things slightly pithier, but can easily degenerate into a parenthetical jungle. [1]

LINQ Query Syntax

var query = from item in items
            where item.IsAwesome
            select item;

foreach (var item in query)
{
    item.DoThatThing();
}

LINQ Query Syntax is one of the best parts of LINQ in C#, IMNSHO. Again, however, foreach or a conversion operator is needed.

foreach (var item in from item in items
                     where item.IsAwesome
                     select item)
{
    item.DoThatThing();
}

foreach (var item in items where item.IsAwesome)
{
    item.DoThatThing();
}

Python for

Python basically sticks to an iterators-only approach (iterators being the rough Python equivalent to C# IEnumerator<T>). While you can still unroll the shortcut of a classic ALGOL-family for loop with a do or while loop, the Python for loop is actually the equivalent of C#'s foreach:

for item in items:
    if item.is_awesome:
        item.do_that_thing()

for i in range(0, len(items)):
    if i % 2 == 0 and items[i].is_awesome:
        item.do_that_thing()

foreach (var i in int.Range(0, items.Count))
{
    if (i % 2 == 0 && items[i].IsAwesome)
    {
        items[i].DoThatThing();
    }
}

for i, item in enumerate(items):
    if i % 2 == 0 and item.is_awesome:
        item.do_that_thing()

Python Generators

Python generators have a rough equivalence to LINQ statements, in some cases:

query = (item.do_that_thing() for item in items if item.is_awesome)

for _ in query: pass

Certainly Python doesn't yet have the diversity of operators that LINQ supports, nor the ability to as easily use generators to lazily build things like database queries.

Due to Python's dynamic nature, generators can be (but rarely are) used solely for side-effects/procedural operations and "void" functions used in the equivalent of Python's select. (C# will give a compiler error for a from item in items select item.DoThatThing() if item.DoThatThing() is a void function.)

[item.do_that_thing() for item in items if item.is_awesome]

Aggregation Clauses

LOOP has explicit aggregation clauses:

(loop for item in items maximize (price item))

While LINQ of course provides aggregation tools, C# does not expose operators for them. Equivalent C# currently would either of the following:

var maxprice = (from item in items select item.Price).Max();
var maxprice = items.Max(item => item.Price);

One useful possibility for C#'s query syntax might be something along the lines of:

var maxprice = from item in items select maximum item.Price;

Present Participles

One interesting feature of Lisp's LOOP macro is that all of its keywords can be written using the present participle (-ing), which can often result in slightly more readable (from an English perspective, at least) statements. For example, rewriting the above:

(loop for item in items when (is-awesome? item) doing (do-that-thing item))
(loop for item in items maximizing (price item))

It may seem like a subtle change in these examples, but definitely in larger, more complicated LOOP examples with many clauses, the change can make things surprisingly clearer.

It's probably a lot to ask for LINQ in C# to support multiple verb forms, but there has been a few times already where I've seen long LINQ queries and thought that they would be easier to read with the present participle, particularly given how lazy LINQ queries are.