AttributeError: ‘Series’ Object Has No Attribute ‘IterItems’ | Fixes

What AttributeError: ‘Series’ Object Has No Attribute ‘IterItems’ Means

This message pops up when Python tries to call a method that no longer exists on a pandas Series. In this case the code still calls Series.iteritems(), but modern pandas removed that method and keeps only Series.items() for item iteration.

The full text, AttributeError: 'Series' object has no attribute 'iteritems', usually appears after a pandas upgrade. Pandas 2.0 removed Series.iteritems() and DataFrame.iteritems(), and the release notes tell users to call obj.items() instead. That change means older tutorials, snippets, and libraries that rely on iteritems() now raise this error once the runtime moves to pandas 2.x.

At a low level, Python raises AttributeError whenever attribute lookup fails on an object. A pandas Series still provides methods such as values, index, and items(), so those calls succeed. The lookup for iteritems fails because the method was deprecated for a while and then removed completely, so the attribute no longer exists on the Series class.

Where This Series IterItems AttributeError Usually Appears

Most projects hit this error in a few repeatable spots. Spotting which pattern matches your code makes the fix faster and cuts down on guesswork.

• Loops over value counts — A common pattern is for key, count in series.value_counts().iteritems():. Once pandas 2.x arrives, that loop crashes because iteritems() vanished from the Series that value_counts() returns.
• Custom data access layers — Internal helper functions sometimes accept a Series and then loop with for key, value in series.iteritems():. Those helpers may sit in one module and raise the error far away from the call site, which makes the stack trace look noisy.
• Third party libraries pinned too loosely — Some plotting, reporting, or analytics tools still call iteritems() inside their own code. When a project upgrades pandas without updating the library, the library code starts to fail with the same AttributeError.
• Old blog posts and notebooks — Code that came from an older tutorial can still run locally for years if the setup stays frozen. A fresh install on a new machine pulls in pandas 2.x by default, and the same notebook that once worked now crashes as soon as any Series iteration uses iteritems().

The exact wording of the error might differ slightly between systems, yet the root cause stays the same. The Series type in modern pandas no longer exposes iteritems, so any attempt to use it will fail until the call switches to a working pattern.

Quick Checks Before You Change Any Code

Before rewriting loops, run a few light checks. These small steps confirm that the problem truly comes from pandas and reveal which parts of the project rely on the removed method.

• Check the pandas version — Open a Python shell and run import pandas as pd; print(pd.__version__). Versions 2.0 and above no longer ship Series.iteritems(), while 1.x still keep it, though with deprecation warnings in late 1.x releases.
• Reproduce the Series behavior in isolation — In the same shell, build a small Series with pd.Series([1, 2, 3]) and call s.items(). That call should work. Then try s.iteritems(). On pandas 2.x you should see the same AttributeError as in your main project.
• Search for iteritems in the codebase — A quick search for the word iteritems across the project often reveals every place that still calls the removed method. That search should include your own files and any custom utility modules that wrap pandas.
• Check virtual envs and tools — Some editors and notebooks run behind a kernel that uses a different setup from your shell. Confirm that the version check runs in the same interpreter that raises the AttributeError so you do not chase the wrong configuration.

Once those checks line up, you can treat the error message as a straightforward compatibility gap: the code expects an older pandas API, while the runtime now runs pandas 2.x.

Reliable Fixes For The Series IterItems Error

There are several safe ways to fix this Series iteritems AttributeError without breaking code that already works. Pick the one that fits your stack and maintenance plans.

Switch Series Iteration From IterItems To Items

The most direct fix replaces iteritems() with items() on every Series. Pandas kept items() as the standard iterator long before 2.0, so this change works on both 1.x and 2.x.

• Update simple loops — Turn for key, value in series.iteritems(): into for key, value in series.items():. The new loop yields the same key and value pairs in the same order.
• Update value count loops — Turn for key, count in series.value_counts().iteritems(): into for key, count in series.value_counts().items():. That tiny change clears the error and keeps the logic intact.
• Patch libraries you control — If the failing call lives in an internal package, update the library code and publish a new version so every application that depends on it can upgrade cleanly.

Keep Older Libraries Working With A Small Compatibility Patch

Sometimes the failing call comes from a third party library that you cannot edit directly. In that case a short compatibility shim lets that library keep running while you wait for an upstream fix.

• Monkey patch Series.iteritems once at startup — Add a small snippet near the entry point of the application: import pandas as pd; if not hasattr(pd.Series, "iteritems"): pd.Series.iteritems = pd.Series.items. That line defines iteritems in terms of items() for every Series instance.
• Document the temporary patch — Leave a short comment that points to the library and version that still calls iteritems(). Later maintainers can drop the patch once that dependency updates its pandas compatibility.

Adjust The Code To Avoid Item By Item Loops

Even with a compatibility shim, many loops run faster and read more clearly when they use native pandas operations instead of manual Python iteration.

• Replace loops with vectorized expressions — A loop that inspects every value one by one usually turns into a single expression such as series[series > 0], series.mean(), or series.where(mask).
• Use map or apply when you must touch each value — Sometimes custom logic cannot be written as a built in aggregation. Functions like series.map(func) or series.apply(func) still touch every item but let pandas handle the iteration details.
• Aggregate with groupby instead of manual counters — Instead of looping over value_counts() with iteritems(), call series.value_counts() and work directly with the returned Series or DataFrame.

Better Ways To Work With Pandas Series Than Iterating Row By Row

Fixing the error clears the immediate crash, yet it also offers a chance to tidy up data handling patterns. Series and DataFrame objects shine when they handle whole columns at once.

• Lean on built in reductions — Methods such as sum(), mean(), min(), max(), and nlargest() replace many manual loops that update counters or search for extremes.
• Filter with boolean masks — Expressions like series[series.isna()] or series[series > threshold] replace loops that append to a list under an if condition.
• Combine Series and DataFrame operations — Many tasks start from a Series derived from a DataFrame column, but the real work suits a DataFrame step such as groupby, pivot_table, or a merge. Tracing the data flow back one step often reveals a cleaner point to apply the change.

These patterns keep code shorter, easier to read, and often faster, because pandas performs the heavy lifting in native code instead of pure Python loops.

Related IterItems Errors In Dicts And DataFrames

The Series iteritems AttributeError often appears beside similar messages for dictionaries and DataFrame objects. All of them stem from the same basic idea. Older APIs used iteritems() to yield key or column pairs, while modern Python and pandas push callers toward items() instead.

• Dict iteritems in plain Python — In Python 2, my_dict.iteritems() streamed key and value pairs. Python 3 removed that method, so any call now raises an AttributeError on a normal dictionary in the same style as the Series error.
• DataFrame iteritems in pandas 2.x — Just as with Series, pandas 2.0 removed DataFrame.iteritems(). Code that once looped over columns with that method now needs DataFrame.items() or another pattern.
• Mixed projects with several data tools — A stack that combines pandas with plotting libraries or notebook extensions sometimes triggers multiple errors, because more than one tool relied on the removed method names.

When you see several iteritems errors in the same run, handle them with a single plan. Use items() on dicts, Series, and DataFrames, add a short compatibility patch only when you must, then open an issue or pull request on any library that still depends on the old names.

Version, Dependency, And Fix Reference For The IterItems Error

The last piece is a short reference that collects the key details about pandas versions and fixes for this Series iteritems AttributeError. This helps when you later review a project or lock an dependency file.

When you maintain multiple projects, this snapshot makes version planning easier. A service locked to pandas 1.5.x can keep older dependencies running, while a new project can start on pandas 2.x with code that already uses items() everywhere.

That plan works best when the package manager has clear constraints. A requirements file or lock file that pins pandas and key libraries avoids surprise upgrades on shared machines, especially in production systems where an unexpected AttributeError would hurt users.

• Pin pandas in requirements files — Write entries such as pandas==1.5.3 or pandas==2.2.0 so automated installs always pull a known version.
• Record the Python version beside pandas — Some tools need a matching Python and pandas pair, so note both in documentation and deployment scripts.
• Test the upgrade path in a throwaway env — Create a fresh virtual env, install the newer pandas release, run the project test suite, and only then roll the change into daily work.

The cleanest approach for new code is simple. Use series.items() whenever you truly need item by item iteration, prefer native pandas expressions for most data work, and keep an eye on release notes before upgrading major versions. With those habits, AttributeError: ‘Series’ Object Has No Attribute ‘IterItems’ turns from a blocking surprise into a quick fix during routine maintenance. Clear error logs make later debugging of iteritems issues far easier for teams.

Send us your feedbackTell us what you thought about this post

Name * Email *

Your comment *

Quick check — what is …? *

Send feedback