Check if a variable is iterable?

python check if iterable but not string
python check if list or tuple
check if object is iterable javascript
python check if sequence
python check if string
python iter
python isinstance
python check if tuple

Is there any way to check if an arbitrary variable type is iterable?

So to check if it has indexed elements or I can actually loop over it's children? (Use foreach for example?)

Is it possible to create a universal template for that?

I've found techniques for other programming languages while searching for it. Yet still have to find out how to do this in C++.

It depends on what you mean by "iterable". It is a loose concept in C++ since you could implement iterators in many different ways.

If by foreach you're referring to C++11's range-based for loops, the type needs begin() and end() methods to be defined and to return iterators that respond to operator!=, operator++ and operator*.

If you mean Boost's BOOST_FOREACH helper, then see BOOST_FOREACH Extensibility.

If in your design you have a common interface that all iterable containers inherit from, then you could use C++11's std::is_base_of:

struct A : IterableInterface {}
struct B {}
template <typename T>
constexpr bool is_iterable() {
    return std::is_base_of<IterableInterface, T>::value;
}
is_iterable<A>(); // true
is_iterable<B>(); // false

How to check if an object is iterable in Python?, You can check for this using isinstance and collections.Iterable >>> from collections import Iterable >>> l = [1, 2, 3, 4] >>> isinstance(l, Iterable)  The is_iterable() function checks whether the contents of a variable is an iterable value or not. This function returns true (1) if the variable is iterable, otherwise it returns false/nothing.

You may create a trait for that:

namespace detail
{
    // To allow ADL with custom begin/end
    using std::begin;
    using std::end;

    template <typename T>
    auto is_iterable_impl(int)
    -> decltype (
        begin(std::declval<T&>()) != end(std::declval<T&>()), // begin/end and operator !=
        void(), // Handle evil operator ,
        ++std::declval<decltype(begin(std::declval<T&>()))&>(), // operator ++
        void(*begin(std::declval<T&>())), // operator*
        std::true_type{});

    template <typename T>
    std::false_type is_iterable_impl(...);

}

template <typename T>
using is_iterable = decltype(detail::is_iterable_impl<T>(0));

Live example.

How to check whether an object is iterable in Python ?, This article describes the different methods that could be used to check whether a given object in Python is an iterable or not. It also briefly explains what an  As of Python 3.4, the most accurate way to check whether an object x is iterable is to call iter(x) and handle a TypeError exception if it isn’t. This is more accurate than using isinstance(x, abc.Iterable), because iter(x) also considers the legacy __getitem__ method, while the Iterable ABC does not.

In Python, how do I determine if an object is iterable , In Python, how do I determine if an object is iterable? Is there a method like isiterable ? The only solution I have found so far is to call hasattr(myObj, '__iter__'​). satoru wrote: > hi, all > i want to check if a variable is iterable like a list, how can i > implement this? this would be one way, though I'm sure others exist:

cpprefence has an example answering your question. It is using SFINAE, here is a slightly modified version of that example (in case the content of that link gets changed over time):

template <typename T, typename = void>
struct is_iterable : std::false_type {};

// this gets used only when we can call std::begin() and std::end() on that type
template <typename T>
struct is_iterable<T, std::void_t<decltype(std::begin(std::declval<T>())),
                                  decltype(std::end(std::declval<T>()))
                                 >
                  > : std::true_type {};

// Here is a helper:
template <typename T>
constexpr bool is_iterable_v = is_iterable<T>::value;

Now, this is how it can be used

std::cout << std::boolalpha;
std::cout << is_iterable_v<std::vector<double>> << '\n';
std::cout << is_iterable_v<std::map<int, double>> << '\n';
std::cout << is_iterable_v<double> << '\n';
struct A;
std::cout << is_iterable_v<A> << '\n';

Output:

true
true
false
false

Having said that, all it checks is, the declaration of begin() const and end() const, so accordingly, even following is verified as an iterable:

struct Container
{
  void begin() const;
  void end() const;
};

std::cout << is_iterable_v<Container> << '\n'; // prints true

You can see these pieces together here

How do I check if an object is a collection in Python 3? : learnpython, Iterable but you'll possibly end up with a generator, iterator, set, mapping or another iterable type when you were expecting a Sequence. An iterable is an object that returns an iterator. An iterator is used to iterate through an object. Examples of iterables in python are list, tuple, string, dictionary etc. any() in python is used to check if any element in an iterable is True. That means it will return True if anything inside an iterable is True, else it will return False. The syntax of any() is as below :

In Python, how do I determine if an object is iterable?, Checking for an instance of Iterable or Sequence , or checking for the attribute __​iter__ is not enough. If an object o implements only  Verify that the contents of a variable is accepted by the iterable pseudo-type, i.e. that it is either an array or an object implementing Traversable Parameters var

In Python, how do I determine if an object is iterable?, try: for i in object_in_question: do_something except TypeError: do_something_for_non_iterable. But if you need to check it explicitly, you can test for an iterable  An iterable is something you can loop over. An iterator is an object representing a stream of data. It does the iterating over an iterable. Additionally, in Python, the iterators are also iterables which act as their own iterators. However, the difference is that iterators don’t have some of the features that some iterables have.

is_iterable - Manual, (PHP 7 >= 7.1.0). is_iterable — Verify that the contents of a variable is an iterable value Return Values ¶. Returns TRUE if var is iterable, FALSE otherwise. hasattr(object,'__iter__') You are correct in the fact that you check if an object is iterable. rather than using isinstance to check if it is of a partucular type. You are doing things 'the pythonic way' ;)

How to check whether an object is iterable in Python, Iterable vs Iterator. In simple words, any object that could be looped over is an iterable . For instance, a list object is an iterable  Oddly, if I set a breakpoint inside the log_variables keyword and print out the list of variables, the internal name of the variable is @{faker} rather than ${faker}. So, even though I explicitly set the variable name as ${faker} , it's getting stored as @{faker} , and that seems to break log variables .

Comments
  • Assuming iterability is expressed as a type, maybe RTTI? en.wikibooks.org/wiki/C%2B%2B_Programming/RTTI
  • Could you provide an example or two of what you're asking?
  • I'm using the Maya API and it's classes. You can iterate over its MVectorArray, MIntArray classes, but also the MVector, MPoint, MColor because they contain more than a single numerical value (or string for the MString/MStringArray). Now I'm trying to create a template that supports adding (or multiplying, or dividing and more generic mathematical equations) any of the arbitrary values together. Which would mean for iterable elements to iterate over them and add a single element to each of its elements/indices. Does that make any sense?
  • possible duplicate of Match iterable types (arrays and classes with begin()/end())
  • This is such a good example, it tought me a real good use of std::declval. Thank you very much!
  • this is SFINE for functions, and with decltype like above is the most elegant way for many different problems (why do we need any other way? use this and enable_if for everything). There is just one side note I have seen here in the comments about the need to stuff void() to break overloading operator,. It is not needed for this answer, but in general may be necessary in some cases.
  • @Jarod42, why do you have an int as the argument type in the declaration auto is_iterable_impl(int)? Also, what is the evil operator here?
  • @user2635088: int is used to provide order when both overload are viable. f(int) is a better match than f(...).
  • We can overload operator ,, doing so might invalidate the test whereas it would be valid. (No match for A(), B() but A() and B() are both valid).