coding style of a python function

Instead of letting acquire_data open and read the entire content of the file, it would be more pythonic to pass a fileObj to acquire_data.

The Reason this is a better design

1. Uniform interface for sequence, generator and file
2. You do not need to read the entire data in the function
3. You can control the lifetime of the file, even when an exception happens

A skeleton code would be

def acquire_data(iterable):
    for line in iterable:
        # Do what ever you want

with open("whatever") as fin:
    acquire_data(fin)

acquire_data(some_seq)

acquire_data(some_gen)

How about just using different functions for different tasks: acquire_data_from_file, acquire_data_from_list, etc? A lot clearer and simpler.

If you really want a single function that can take either filenames or lists of data (which you probably don't, but you seem resistant to the more pythonic alternatives that oseiskar and Abhijit suggested), you definitely don't want to do it this way.

In general, if you find yourself doing type switching, you're doing something wrong. But doing fake type switching based on a string, and relying on the user to match the string to the type, is even more wrong.

One alternative is to just try to open the filename, and, if that fails, assume it was a sequence instead of a filename instead. (It's easier to ask forgiveness than permission.) For example:

def acquire_data(filename_or_list):
    try:
        with open(filename_or_list) as f:
            data = list(f)
    except TypeError:
        data = list(filename_or_list)
    # ... now the rest of your code uses data

This works even if the user passes a unicode filename instead of an str, or a tuple instead of a list, or even some class you've never heard of that works with the open or list function. That's the essence of duck typing.

Of course it's a bit of an abuse of duck typing, but that's inherent in your problem: You're trying to take a parameter that's of one of two different types, and any solution that makes that work will be abusing some feature.

The only worry is that someone might pass something that works with both open and list. In fact, that's true with a plain old str. So you need a generic decision for what to do with such cases—it seems like trying it as a pathname first, then as a sequence, is better than the other way around. That's certainly what you want from str, but you have to think through whether that would be true for every possible type that works both ways.

This kind of work I would to divide further and use dict as switch case :

def read_file(arg):
 # code

def read_data(arg):
 # code

def default_f(arg):
 # code

def acquire_data(mode, arg2):

    fun = {
    'read_from_file': read_file, 
    'use_this_list': read_data
    }.get(mode, default_f)

    fun(arg2)

EDIT:
Second approach: combined my and @möter.

def acquire_data(arg):
   fun = {
     True: read_file,
     False: read_data
     }.get(
         isinstance(arg, str),
         default_f
         )
   return fun(arg);

call this:

acquire_data('read_from_file',filename)
acquire_data('use_this_list',datalist)

Due to Python's duck-typing, having functions perform different behaviors depending on the datatype of a variable or argument, this type of practice is relatively common.

You could leave your function as is, though I'd consider doing

if mode == 'read_from_file':
        inputs=open(arg2)
        data = #etc.
elif mode == 'use_this_list':
        data = arg2  #or deepcopy(arg2) or whatever
else:
        raise InputError # or something like this

Jut to make sure that your function is extensible and that you don't have any improper arguments passed to the second part of the function.

Another way might be simply to accept an open file and/or filename in addition to the data itself:

def acquire_data(arg):
    if isinstance(arg, file):
        data = arg.read() # make sure to parse the data
    elif isinstance(arg, basestring):
        data = open(arg, 'r').read() # make sure to parse
    else:
        data = arg