DataFrame and Series iterators have many inconsistencies
There seem to be many inconsistencies between the iterators of `Series` and `DataFrame`. I'll lay them out here. To address these, we'll probably need to open up several other issues. And before anyone reading this gets squeamish, **I'd like to offer my help in fixing these problems.**

`Series.items()` and `DataFrame.items()` don't have similar behavior and this is confusing, especially since the docs state `DataFrame.items()` is 'Equivalent to `Series.items()` for `DataFrame`.' Which is simply not true. 

This is also an issue for `Series.iteritems()` and `DataFrame.iteritems()`:
`Series.iteritems()` is exactly the same as `Series.items()`, which both yield `(index, value)`
`DataFrame.iteritems()` is exactly the same as `DataFrame.items()` except for in the documentation `.items()` uses "Yields" in the docs while `.iteritems()` uses "Returns", another inconsistency. Both of these yield `(column, df[column])`.

On another note, `iter(DataFrame)` is functionally equivalent to `iter(DataFrame.columns)`, which is worth noting, and at least from my perspective, not an expected behavior. Under the current implementation, I'd expect the same results as `DataFrame.iteritems()` or, under my preferred implementation, I'd expect the same results as `DataFrame.iterrows()`.
`iter(Series)` is the one method out of all of these that makes the most sense to me as it simply yields `value`. Still, this behavior is dissimilar to `iter(DataFrame)`, which, in my opinion,results in unnecessary confusion.

There are other inconsistencies between `DataFrame.iterrows()`, `DataFrame.itertuples()`, and `Series.iteritems()`/`Series.items()`. All of them have similar functionality. The most similar functionality is between `DataFrame.iterrows()` and `Series.iteritems()`/`Series.items()`, which both return `(index, row/value)` 

`DataFrame.itertuples()` is the only one that has an `index` parameter, which allows us to include or exclude the index in the tuple that's being iterated over. Itertuples does have a different behavior than the other iterators though since it includes the index in the tuple instead of outside the iterator. `Series.itertuples()` does not exist, but merits existence since with the indexes included, it would behave the same as `DataFrame.itertuples()` and return something like `(index, value)` or `(multiindex1, multiindex2, value)`.

Nonetheless, being able to decide whether to include the index in other situations would be useful so I could do things like what I would do now with `map(lambda x: x[1], my_series.iteritems())`. 

In my situation, I'm most in need of a `Series.itertuples()` with a similar functionailty as the current `DataFrame.itertuples()`. 

I understand that I can just do this simply with `my_series.to_frame().itertuples()` or `map(lambda x: (x[0][0], x[0][1], x[1]), my_series` (I have a multiindex) but it seems like there should be a better way and there are a lot of other inconsistencies that should be fixed before that happens.

I'm happy to do a lot of the work for this myself, but I would need guidance on how to go about this since implementing these changes involves some decision-making.

Also, with the breadth of this post, I might have missed something or made a mistake somewhere, but I think I've generally cataloged the majority of the problems.