If you are talking strictly about C#/Java-like interface, then the answer is simple. They are concepts that belong to statically typed languages and do not really apply to dynamic language such as Python.
The usual pythonic approach is to trust the objects you get and assume they have the necessary traits you need. Should they do not, you might expect runtime errors that can be handled or left for the caller. This matches the general dynamic nature of the language: if something goes wrong, you can expect it to surface at runtime.
Interfaces from Java or C#, on the other hand, are means for checking necessary preconditions (i.e. objects having certain methods) during compilation. This (arguably) trades off some of the runtime flexibility for increased safety of compile-time checks.
Note that it doesn't mean that any concept of interface has no place in dynamically typed language. In fact, Python has a slightly blurred notion of "meta-types" - such as iterables - that are often checked against, e.g. by verifying the presence of particular method(s):
def process_sequence(seq):
if not hasattr(seq, '__iter__'):
seq = [seq] # turn single element into iterable
for elem in seq:
process_element(elem)
This is conceptually similar to non-manifest interfaces from Go language. If you want to have your own iterable, you just implement the __iter__ method - without explicitly stating that you will implement it (as in Java, where you would inherit from List class). Should anyone wants to check whether your object is indeed an iterable, they can verify whether the "contract" - i.e. having __iter__ method - is indeed fulfilled. This is what andronikus described in their answer.
As a shameless plug, I can point out to the pyduck library that I'm implementing. It aims to simplify (and maybe even standarize) verification of such "contracts" (via reflection) and make it slightly more reliable.
