Python Generic functions with generic parameters

I'm not sure if I used the right terms in the title. This maybe a known way to program interface functions for a subsystem or module but because I don't know the keywords, I'm not finding the results in my search queries.

I want to create a function whose intention can be clearly described in the functions name but the parameters are flexible. I want to write the function to be generic enough so that the function can complete the intention with whatever parameters it receives from whichever caller.

Let's take a function do_foo. do_foo can take in some_obj whose attributes allows do_foo to do its work. Additionally, do_foo can just take in the individual attributes it cares about like obj_attr0 or obj_attr1 and perform the same work. In both cases, the expected result is the same as well.

So this would look something like this:

Class SomeObj(): 
   def __init__(self, obj_attr0, obj_attr1, obj_attrN):
     self.obj_attr0 = None
     self.obj_attr1 = None
     self.obj_attrN = None # denotes an N number of attributes

def do_foo(params)
   # unpack params. do_foo requires obj_attr0 and obj_attr1 and so its searching it in the params iterable
   # determine which data is passed in 
   # execute the work the same way regardless of what form the data is passed in
   pass

obj_attr0 = None
obj_attr1 = None
obj_attrN = None
some_obj = SomeObj(obj_attr0, obj_attr1, obj_attrN)
# One can either call with a subset of attributes that would make up SomeObj or SomeObj itself if all the information is there. E.g.:

params = (some_obj)
do_foo(params)

# OR

params = (obj_att0, obj_attr1)
do_foo(params)

I know python offers *args and **kwargs facilities that offer the flexibility above. I'm looking for some examples of where the implementation lends itself to reducing pitfalls. What is a good way to implement the above? And if there are any resources out there what are examples/articles/or terms that describe the above style of programming? Clearly, I'm trying to write my interface functions to be generic and usable in multiple logic paths where the users has its data in different forms where sticking to a specific parameter list is limiting.