Verifique se o objeto é semelhante a um arquivo em Python

Objetos semelhantes a arquivos são objetos em Python que se comportam como um arquivo real, por exemplo, têm um método read () e um método write (), mas têm uma implementação diferente. É uma realização do conceito Duck Typing .

É considerada uma boa prática permitir um objeto semelhante a um arquivo em todos os lugares onde um arquivo é esperado para que, por exemplo, um objeto StringIO ou um objeto Socket possa ser usado em vez de um arquivo real. Portanto, é ruim realizar uma verificação como esta:

if not isinstance(fp, file):
   raise something

Qual é a melhor maneira de verificar se um objeto (por exemplo, um parâmetro de um método) é "semelhante a um arquivo"?

Geralmente, não é uma boa prática ter verificações como essa em seu código, a menos que você tenha requisitos especiais.

Em Python, a digitação é dinâmica, por que você sente necessidade de verificar se o objeto é como um arquivo, em vez de apenas usá-lo como se fosse um arquivo e lidar com o erro resultante?

Qualquer verificação que você possa fazer vai acontecer no tempo de execução de qualquer maneira, então fazer algo como if not hasattr(fp, 'read')e lançar alguma exceção fornece pouco mais utilidade do que apenas chamar fp.read()e tratar o erro de atributo resultante se o método não existir.

Para 3.1+, um dos seguintes:

isinstance(something, io.TextIOBase)
isinstance(something, io.BufferedIOBase)
isinstance(something, io.RawIOBase)
isinstance(something, io.IOBase)

Para 2.x, "objeto semelhante a arquivo" é uma coisa muito vaga para verificar, mas a documentação para qualquer função (ões) com a qual você está lidando, esperançosamente, dirá o que eles realmente precisam; se não, leia o código.

Como outras respostas apontam, a primeira coisa a se perguntar é o que exatamente você está verificando. Normalmente, o EAFP é suficiente e mais idiomático.

O glossário diz "arquivo-como objeto" é sinônimo de "objeto de arquivo", que em última análise significa que é uma instância de uma das três classes base abstratas definidas no o iomódulo , que são eles próprios todas as subclasses de IOBase. Portanto, a forma de verificar é exatamente como mostrado acima.

(No entanto, a verificação IOBasenão é muito útil. Você pode imaginar um caso em que você precisa distinguir um arquivo real read(size)de alguma função de um argumento chamada readque não é semelhante a um arquivo, sem precisar também distinguir entre arquivos de texto e raw arquivos binários? Então, na verdade, você quase sempre deseja verificar, por exemplo, "é um objeto de arquivo de texto", não "é um objeto semelhante a um arquivo".)

Para 2.x, embora o iomódulo exista desde 2.6+, os objetos de arquivo embutidos não são instâncias de ioclasses, nem qualquer um dos objetos semelhantes a arquivos no stdlib, nem a maioria dos objetos semelhantes a arquivos de terceiros que você é provável que encontre. Não havia uma definição oficial do que significa "objeto semelhante a um arquivo"; é apenas "algo como um objeto de arquivo embutido ", e funções diferentes significam coisas diferentes por "curtir". Essas funções devem documentar o que significam; se não, você deve olhar o código.

No entanto, os significados mais comuns são "tem read(size)", "tem read()" ou "é um iterável de strings", mas algumas bibliotecas antigas podem esperar em readlinevez de um desses, algumas bibliotecas gostam de close()arquivos que você fornece, alguns esperam que se filenoestá presente, então outra funcionalidade está disponível, etc. E da mesma forma para write(buf)(embora haja muito menos opções nessa direção).

Como outros já disseram, você geralmente deve evitar tais verificações. Uma exceção é quando o objeto pode ser legitimamente de tipos diferentes e você deseja um comportamento diferente dependendo do tipo. O método EAFP nem sempre funciona aqui, pois um objeto pode se parecer com mais de um tipo de pato!

Por exemplo, um inicializador pode pegar um arquivo, string ou instância de sua própria classe. Você pode então ter um código como:

class A(object):
    def __init__(self, f):
        if isinstance(f, A):
            # Just make a copy.
        elif isinstance(f, file):
            # initialise from the file
        else:
            # treat f as a string

Usar o EAFP aqui pode causar todos os tipos de problemas sutis, pois cada caminho de inicialização é executado parcialmente antes de lançar uma exceção. Essencialmente, essa construção imita a sobrecarga de função e, portanto, não é muito Pythônica, mas pode ser útil se usada com cuidado.

Como uma observação lateral, você não pode fazer a verificação de arquivo da mesma maneira no Python 3. Você precisará de algo como isinstance(f, io.IOBase) .

O paradigma dominante aqui é EAFP: mais fácil pedir perdão do que permissão. Vá em frente e use a interface de arquivo e, a seguir, trate a exceção resultante ou deixe-as se propagarem para o chamador.

Geralmente é útil levantar um erro verificando uma condição, quando esse erro normalmente não seria levantado até muito mais tarde. Isso é especialmente verdadeiro para o limite entre o código 'terreno do usuário' e 'api'.

Você não colocaria um detector de metais em uma delegacia de polícia na porta de saída, mas sim na entrada! Se não verificar uma condição significa que pode ocorrer um erro que poderia ter sido detectado 100 linhas antes, ou em uma superclasse em vez de ser gerado na subclasse, então eu digo que não há nada de errado com a verificação.

Verificar os tipos adequados também faz sentido quando você está aceitando mais de um tipo. É melhor levantar uma exceção que diz "Eu preciso de uma subclasse de cadeia de base, arquivo OR" do que apenas lançar uma exceção porque alguma variável não tem um método de 'busca' ...

Isso não significa que você enlouqueça e faça isso em todos os lugares, na maioria das vezes eu concordo com o conceito de exceções se levantando, mas se você puder tornar sua API drasticamente clara ou evitar a execução desnecessária de código porque uma condição simples não foi atendida faça isso!

Você pode tentar chamar o método e capturar a exceção:

try:
    fp.read()
except AttributeError:
    raise something

Se você deseja apenas um método de leitura e gravação, pode fazer o seguinte:

if not (hasattr(fp, 'read') and hasattr(fp, 'write')):
   raise something

Se eu fosse você, escolheria o método try / except.

Na maioria das circunstâncias, a melhor maneira de lidar com isso é não. Se um método pega um objeto semelhante a um arquivo e descobre que o objeto que foi passado não é, a exceção que é gerada quando o método tenta usar o objeto não é menos informativa do que qualquer exceção que você possa ter levantado explicitamente.

Porém, há pelo menos um caso em que você pode querer fazer esse tipo de verificação e é quando o objeto não está sendo usado imediatamente pelo que você o passou, por exemplo, se está sendo definido no construtor de uma classe. Nesse caso, eu acho que o princípio do EAFP é superado pelo princípio de "falha rápida". Eu verificaria o objeto para ter certeza de que implementou os métodos de que minha classe precisa (e que eles são métodos), por exemplo:

class C():
    def __init__(self, file):
        if type(getattr(file, 'read')) != type(self.__init__):
            raise AttributeError
        self.file = file

Acabei encontrando sua pergunta quando estava escrevendo um open função semelhante a ela que poderia aceitar um nome de arquivo, descritor de arquivo ou objeto semelhante a arquivo pré-aberto.

Em vez de testar um readmétodo, como sugerem as outras respostas, acabei verificando se o objeto pode ser aberto. Se puder, é uma string ou descritor, e eu tenho um objeto semelhante a um arquivo válido em mãos do resultado. Se opengerar um TypeError, o objeto já é um arquivo.