Is there a method like `isiterable`? The only solution I have found so far is to call

    hasattr(myObj, &#39;__iter__&#39;)

But I am not sure how fool-proof this is.



In Python, how do I determine if an object is iterable?

&gt; **Possible Duplicate:**  
&gt; [LINQ analogues in Scala](https://stackoverflow.com/questions/3785413/linq-analogues-in-scala)  

&lt;!-- End of automatically inserted text --&gt;

I am looking for chart which shows equivalents in Scala of LINQ methods for IEnumerable:

 - First is head
 - Select is map
 - SingleOrDefault is ... (I don&#39;t know)
 - ... and so on

Does anyone know anything of such &quot;translate&quot; table?

Chart of IEnumerable LINQ equivalents in Scala?

In Java 8 we have the class [Stream&amp;lt;T&gt;][1], which curiously have a method

    Iterator&lt;T&gt; iterator()

So you would expect it to implement interface [Iterable&amp;lt;T&gt;][2], which requires exactly this method, but that&#39;s not the case.

When I want to iterate over a Stream using a foreach loop, I have to do something like

    public static Iterable&lt;T&gt; getIterable(Stream&lt;T&gt; s) {
        return new Iterable&lt;T&gt; {
            @Override
            public Iterator&lt;T&gt; iterator() {
                return s.iterator();
            }
        };
    }

    for (T element : getIterable(s)) { ... }

Am I missing something here?

  [1]: http://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html
  [2]: http://docs.oracle.com/javase/8/docs/api/java/lang/Iterable.html

Why does Stream&lt;T&gt; not implement Iterable&lt;T&gt;?

Many Java framework classes implement `Iterable`, however `String` does not. It makes sense to iterate over characters in a `String`, just as one can iterate over items in a regular array.

Is there a reason why `String` does not implement `Iterable`?

Why doesn&#39;t the String class in Java implement Iterable?

How can I get a `java.lang.Iterable` from a collection like a `Set` or a `List`?
Thanks!

Collection to Iterable

Is there a good, succinct/built-in way to see if all the values in an iterable are zeros?  Right now I am using `all()` with a little list comprehension, but (to me) it seems like there should be a more expressive method.  I&#39;d view this as somewhat equivalent to a `memcmp()` in C.

    values = (0, 0, 0, 0, 0)
    # Test if all items in values tuple are zero
    if all([ v == 0 for v in values ]) :
        print &#39;indeed they are&#39;

I would expect a built-in function that does something like:

    def allcmp(iter, value) :
        for item in iter :
            if item != value :
                return False
        return True

Does that function exist in python and I&#39;m just blind, or should I just stick with my original version?

# Update

I&#39;m not suggesting that `allcmp()` is the solution. It is an example of what I *think* might be more meaningful.  This isn&#39;t the place where I would suggest new built-ins for Python.

In my opinion, `all()` isn&#39;t that meaningful.  It doesn&#39;t express what &quot;all&quot; is checking for.  You could assume that `all()` takes an iterable, but it doesn&#39;t express what the function is looking for (an iterable of `bool`s that tests all of them for `True`).  What I&#39;m asking for is *some function like* my `allcmp()` that takes two parameters: an iterable and a comparison value.  I&#39;m asking if there is a built-in function that does something similar to my made up `allcmp()`.

I called mine `allcmp()` because of my C background and `memcmp()`, **the name of my made up function is irrelevant** here.

Check if all values of iterable are zero

I am wondering why the `Iterable` interface does not provide the `stream()` and `parallelStream()` methods. Consider the following class:

    public class Hand implements Iterable&lt;Card&gt; {
        private final List&lt;Card&gt; list = new ArrayList&lt;&gt;();
        private final int capacity;

        //...

        @Override
        public Iterator&lt;Card&gt; iterator() {
            return list.iterator();
        }
    }

It is an implementation of a *Hand* as you can have cards in your hand while playing a Trading Card Game.

Essentially it wraps a `List&lt;Card&gt;`, ensures a maximum capacity and offers some other useful features. It is better as implementing it directly as a `List&lt;Card&gt;`.

Now, for convienience I thought it would be nice to implement `Iterable&lt;Card&gt;`, such that you can use enhanced for-loops if you want to loop over it. (My `Hand` class also provides a `get(int index)` method, hence the `Iterable&lt;Card&gt;` is justified in my opinion.)

The `Iterable` interface provides the following (left out javadoc):

    public interface Iterable&lt;T&gt; {
        Iterator&lt;T&gt; iterator();
    
        default void forEach(Consumer&lt;? super T&gt; action) {
            Objects.requireNonNull(action);
            for (T t : this) {
                action.accept(t);
            }
        }
    
        default Spliterator&lt;T&gt; spliterator() {
            return Spliterators.spliteratorUnknownSize(iterator(), 0);
        }
    }

Now can you obtain a stream with:

    Stream&lt;Hand&gt; stream = StreamSupport.stream(hand.spliterator(), false);

So onto the real question:

- Why does `Iterable&lt;T&gt;` not provide a default methods that implement `stream()` and `parallelStream()`, I see nothing that would make this impossible or unwanted?

A related question I found is the following though: https://stackoverflow.com/questions/20129762/why-does-streamt-not-implement-iterablet  
Which is oddly enough suggesting it to do it somewhat the other way around.

Why does Iterable&lt;T&gt; not provide stream() and parallelStream() methods?

I am new in Java and I&#39;m really confused with iterator and iterable. Can anyone explain to me and give some examples?

What is the difference between iterator and iterable and how to use them?

What is the [&quot;one [...] obvious way&quot;][1] to add all items of an iterable to an existing `set`?

  [1]: http://www.python.org/dev/peps/pep-0020/

How do I add the contents of an iterable to a set?

Why does the `Iterator` interface not extend `Iterable`?

The `iterator()` method could simply return `this`.

Is it on purpose or just an oversight of Java&#39;s designers?

It would be convenient to be able to use a for-each loop with iterators like this:

    for(Object o : someContainer.listSomeObjects()) {
        ....
    }

where `listSomeObjects()` returns an iterator.

Why is Java&#39;s Iterator not an Iterable?

I have an Array of primitives, for example for int, int[] foo. It might be a small sized one, or not.

    int foo[] = {1,2,3,4,5,6,7,8,9,0};

What is the best way to create an `Iterable&lt;Integer&gt;` from it?

    Iterable&lt;Integer&gt; fooBar = convert(foo);

Notes:

Please do not answer using loops (unless you can give a good explanation on how the compiler do something smart about them?)

Also note that 

    int a[] = {1,2,3};
    List&lt;Integer&gt; l = Arrays.asList(a);
Will not even compile

    Type mismatch: cannot convert from List&lt;int[]&gt; to List&lt;Integer&gt;

Also check
https://stackoverflow.com/questions/1160081/why-is-an-array-not-assignable-to-iterable
before answering.
	
Also, if you use some library (e.g., Guava), please explain why this is the Best. ( Because its from Google is not a complete answer :P )

Last, since there seems to be a homework about that, avoid posting homeworkish code.


Convert Java Array to Iterable

Python provides a nice method for getting length of an eager iterable, `len(x)` that is. But I couldn&#39;t find anything similar for lazy iterables represented by generator comprehensions and functions. Of course, it is not hard to write something like:

    def iterlen(x):
      n = 0
      try:
        while True:
          next(x)
          n += 1
      except StopIteration: pass
      return n

But I can&#39;t get rid of a feeling that I&#39;m reimplementing a bicycle.

(While I was typing the function, a thought struck my mind: maybe there really is no such function, because it &quot;destroys&quot; its argument. Not an issue for my case, though).

P.S.: concerning the first answers - yes, something like `len(list(x))` would work too, but that drastically increases the usage of memory.

P.P.S.: re-checked... Disregard the P.S., seems I made a mistake while trying that, it works fine. Sorry for the trouble.

Length of generator output

Say you have an array-like Javascript ES6 Iterable that you know in advance will be finite in length, what&#39;s the best way to convert that to a Javascript Array?

The reason for doing so is that many js libraries such as underscore and lodash only support Arrays, so if you wish to use any of their functions on an Iterable, it must first be converted to an Array.

In python you can just use the list() function. Is there an equivalent in ES6?

Convert ES6 Iterable to Array

What is the most basic definition of &quot;iterable&quot;, &quot;iterator&quot; and &quot;iteration&quot; in Python?

I have read multiple definitions but I am unable to identify the exact meaning as it still won&#39;t sink in.

Can someone please help me with the 3 definitions in layman terms?

What exactly are iterator, iterable, and iteration?

I need to figure out the number of elements in an `Iterable` in Java.
I know I can do this:
  
    Iterable values = ...
    it = values.iterator();
    while (it.hasNext()) {
      it.next();
      sum++;
    }

I could also do something like this, because I do not need the objects in the Iterable any further:
    
    it = values.iterator();
    while (it.hasNext()) {
      it.remove();
      sum++;
    }

A small scale benchmark did not show much performance difference, any comments or other ideas for this problem?

Get size of an Iterable in Java

Both of these interfaces define only one method
    
    public operator fun iterator(): Iterator&lt;T&gt;

Documentation says `Sequence` is meant to be lazy. But isn&#39;t `Iterable` lazy too (unless backed by a `Collection`)?

Kotlin&#39;s Iterable and Sequence look exactly same. Why are two types required?

I have an interface which returns `java.lang.Iterable&lt;T&gt;`.

I would like to manipulate that result using the Java 8 Stream API.

However Iterable can&#39;t &quot;stream&quot;.

Any idea how to use the Iterable as a Stream without converting it to List?


Convert Iterable to Stream using Java 8 JDK

In my application I use 3rd party library (Spring Data for MongoDB to be exact).

Methods of this library return `Iterable&lt;T&gt;`, while the rest of my code expects `Collection&lt;T&gt;`.

Is there any utility method somewhere that will let me quickly convert one to the other? I would like to avoid creating a bunch of `foreach` loops in my code for such a simple thing.


Easy way to convert Iterable to Collection

Here&#39;s my code:

    import math

    print(&quot;Hey, lets solve Task 4 :)&quot;)

    number1 = input(&quot;How many digits do you want to look at? &quot;)
    number2 = input(&quot;What would you like the digits to add up to? &quot;)

    if number1 == 1:
        cow = range(0,10)
    elif number1 == 2:
        cow = range(10,100)
    elif number1 == 3:
        cow = range(100,1000)
    elif number1 == 4:
        cow = range(1000,10000)
    elif number1 == 5:
        cow = range(10000,100000)
    elif number1 == 6:
        cow = range(100000,1000000)
    elif number1 == 7:
        cow = range(1000000,10000000)
    elif number1 == 8:
        cow = range(10000000,100000000)
    elif number1 == 9:
        cow = range(100000000,1000000000)
    elif number1 == 10:
        cow = range(1000000000,10000000000)

    number3 = cow[-1] + 1

    n = 0
    while n &lt; number3:
        number4 = list(cow[n])
        n += 1

I am looking to make a loop so that for each element in the list, it will get broken down into each of it&#39;s characters. For example, say the number `137` was in the list then it would be turned into `[1,3,7]`. Then I want to add these numbers together (I haven&#39;t started that bit yet but I have some idea of how to do it).

However, I keep getting this error message:

    TypeError: &#39;int&#39; object is not iterable

What am I doing wrong?


Python - TypeError: &#39;int&#39; object is not iterable

Why isn&#39;t is possible to use objects in for of loops? Or is this a browser bug? This code doesn&#39;t work in Chrome 42, saying undefined is not a function:

    test = { first: &quot;one&quot;}
    
    for(var item of test) {
      console.log(item)
    }

Using Objects in For Of Loops

If I want the number of items in an iterable without caring about the elements themselves, what would be the pythonic way to get that? Right now, I would define

    def ilen(it):
        return sum(itertools.imap(lambda _: 1, it))    # or just map in Python 3

but I understand `lambda` is close to being considered harmful, and `lambda _: 1` certainly isn&#39;t pretty.

(The use case of this is counting the number of lines in a text file matching a regex, i.e. `grep -c`.)

What&#39;s the shortest way to count the number of items in a generator/iterator?

&gt; **Possible Duplicate:**  
&gt; [Why is Java&amp;#39;s Iterator not an Iterable?](https://stackoverflow.com/questions/839178/why-is-javas-iterator-not-an-iterable)  
&gt;
&gt; https://stackoverflow.com/questions/3883131/idiomatic-way-to-use-for-each-loop-given-an-iterator
&gt;
&gt; https://stackoverflow.com/questions/2162917/can-we-use-for-each-loop-for-iterating-the-objects-of-iterator-type

&lt;!-- End of automatically inserted text --&gt;

The foreach loop are as far as I know syntax sugar added in Java 5. So

    Iterable&lt;O&gt; iterable;
    for(O o : iterable) {
        // Do something
    }

will essentially produce the same bytecode as

    Iterable&lt;O&gt; iterable;
    for(Iterator&lt;O&gt; iter = iterable.iterator(); iter.hasNext(); /* NOOP */) {
        O o = iter.next();
        // Do something
    }

However, if I do not have an iterable in the first place, but only an iterator (say, because a class offers two different iterators), I cannot use the syntax sugar foreach loop. Obviously I can still do the plain old style iteration. However, I&#39;d actually like to do:

    Iterator&lt;O&gt; iter;
    for(O o : iter /* Iterator&lt;O&gt;, not Iterable&lt;O&gt;! */) {
         // Do something
    }

And of course I can do a fake `Iterable`:

    class Adapter&lt;O&gt; implements Iterable&lt;O&gt; {
        Iterator&lt;O&gt; iter;

        public Adapter(Iterator&lt;O&gt; iter) {
            this.iter = iter;
        }

        @Override
        public Iterator&lt;O&gt; iterator() {
            return iter;
        }
    }

(Which in fact is an ugly abuse of the Iterable API, as it can only be iterated once!)

If it were designed around `Iterator` instead of iterable, one could do a number of interesting things:

    for(O o : iterable.iterator()) {} // Iterate over Iterable and Collections

    for(O o : list.backwardsIterator()) {} // Or backwards

    Iterator&lt;O&gt; iter;
    for(O o : iter) {
        if (o.something()) { iter.remove(); }
        if (o.something()) { break; }
    }
    for(O : iter) { } // Do something with the remaining elements only.

Does anyone know *why* the language was designed this way? To avoid ambiguity if a class would implement both `Iterator` and `Iterable`? To avoid programmer errors that assume that &quot;for(O o : iter)&quot; will process all elements twice (and forget to get a fresh iterator)? Or is there some other reason for this?

Or is there some language trick I just do not know?

Why does Java not allow foreach on iterators (only on iterables)?

The Python built-in function `any(iterable)` can help to quickly check if any `bool(element)` is `True` in a iterable type.

    &gt;&gt;&gt; l = [None, False, 0]
    &gt;&gt;&gt; any(l)
    False
    &gt;&gt;&gt; l = [None, 1, 0]
    &gt;&gt;&gt; any(l)
    True

But is there an elegant way or function in Python that could achieve the opposite effect of `any(iterable)`? That is, if any `bool(element) is False` then return `True`, like the following example:

    &gt;&gt;&gt; l = [True, False, True]
    &gt;&gt;&gt; any_false(l)
    &gt;&gt;&gt; True


Opposite of any() function

What&#39;s the shortest way to get first item of `OrderedDict` in Python 3?

My best:

    list(ordered_dict.items())[0]

Quite long and ugly.

I can think of: 

    next(iter(ordered_dict.items()))       # Fixed, thanks Ashwini

But it&#39;s not very self-describing. 

Any better suggestions?

Shortest way to get first item of `OrderedDict` in Python 3

Is there a &#39;decent&#39; way in unittest to check the equality of the contents of two iterable objects? 
I am using a lot of tuples, lists and numpy arrays and I usually only want to test for the contents and not for the type. Currently I am simply casting the type:

    self.assertEqual (tuple (self.numpy_data), tuple (self.reference_list))

I used this list comprehension a while ago:

    [self.assertEqual (*x) for x in zip(self.numpy_data, self.reference_list)]

But this solution seems a bit inferior to the typecast because it only prints single values if it fails and also it does not fail for different lengths of reference and data (due to the zip-function).

Unittest&#39;s assertEqual and iterables - only check the contents

In Java 5 and above you have the foreach loop, which works magically on anything that implements ```Iterable```:

    for (Object o : list) {
      doStuff(o);
    }

However, ```Enumerable``` still does not implement ```Iterable```, meaning that to iterate over an ```Enumeration``` you must do the following:

    for(; e.hasMoreElements() ;) {
      doStuff(e.nextElement());
    }

Does anyone know if there is a reason why ```Enumeration``` still does not implement ```Iterable```?

**Edit:** As a clarification, I&#39;m not talking about the language concept of an [enum][1], I&#39;m talking a Java-specific class in the Java API called &#39;[Enumeration][2]&#39;. 


  [1]: http://en.wikipedia.org/wiki/Enumerated_type
  [2]: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Enumeration.html

Why aren&#39;t Enumerations Iterable?

If I have a collection, such as `Collection&lt;String&gt; strs`, how can I get the first item out? I could just call an `Iterator`, take its first `next()`, then throw the `Iterator` away. Is there a less wasteful way to do it?

Java: Get first item from a collection

As you may know, [implementing a `__getitem__` method makes a class iterable](https://stackoverflow.com/questions/926574/why-does-defining-getitem-on-a-class-make-it-iterable-in-python):

    class IterableDemo:
        def __getitem__(self, index):
            if index &gt; 3:
                raise IndexError
    
            return index
    
    demo = IterableDemo()
    print(demo[2])  # 2
    print(list(demo))  # [0, 1, 2, 3]
    print(hasattr(demo, &#39;__iter__&#39;))  # False


However, this doesn&#39;t hold true for regex match objects:

    &gt;&gt;&gt; import re
    &gt;&gt;&gt; match = re.match(&#39;(ab)c&#39;, &#39;abc&#39;)
    &gt;&gt;&gt; match[0]
    &#39;abc&#39;
    &gt;&gt;&gt; match[1]
    &#39;ab&#39;
    &gt;&gt;&gt; list(match)
    Traceback (most recent call last):
      File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
    TypeError: &#39;_sre.SRE_Match&#39; object is not iterable

It&#39;s worth noting that this exception isn&#39;t thrown in the `__iter__` method, because that method isn&#39;t even implemented:

    &gt;&gt;&gt; hasattr(match, &#39;__iter__&#39;)
    False

So, how is it possible to implement `__getitem__` without making the class iterable?


All Iterable Solutions on Gang of Coders

Total of 28 Iterable Solutions

In Python, how do I determine if an object is iterable?

Chart of IEnumerable LINQ equivalents in Scala?

Why does Stream<T> not implement Iterable<T>?

Why doesn't the String class in Java implement Iterable?

Collection to Iterable

Check if all values of iterable are zero

Why does Iterable<T> not provide stream() and parallelStream() methods?

What is the difference between iterator and iterable and how to use them?

How do I add the contents of an iterable to a set?

Why is Java's Iterator not an Iterable?

Convert Java Array to Iterable

Length of generator output

Convert ES6 Iterable to Array

What exactly are iterator, iterable, and iteration?

Get size of an Iterable in Java

Kotlin's Iterable and Sequence look exactly same. Why are two types required?

Convert Iterable to Stream using Java 8 JDK

Easy way to convert Iterable to Collection

Python - TypeError: 'int' object is not iterable

Using Objects in For Of Loops

What's the shortest way to count the number of items in a generator/iterator?

Why does Java not allow foreach on iterators (only on iterables)?

Opposite of any() function

Shortest way to get first item of `OrderedDict` in Python 3

Unittest's assertEqual and iterables - only check the contents

Why aren't Enumerations Iterable?

Java: Get first item from a collection

How come regex match objects aren't iterable even though they implement getitem?