AQUIVOS EM PYTHON

Uesb - DCEN – Disciplina I.C.C. – Prof. Modesto A. Chaves

REVISÃO DE STRINGS

Essa aula vai dar uma geral nos vários métodos de manipular uma string, cobrindo coisas de
métodos básicos até expressões regulares em Python. Manipular uma string é uma técnica
que todo programador Python devia se familiarizar.
 Métodos de Strings
O jeito mais básico de manipular strings é através de métodos que estão
dentro delas (strings). Podemos fazer um limitado número de tarefas em
strings através desses métodos. Abra sua Python Shell e vamos criar uma
string e brincar um pouco com elas.

>>>  test  =  'This  is  just  a  simple  string.'

 Métodos de Strings
Vamos dar uma volta rápida e usar a função len. Ela pode ser usada para
encontrar o tamanho de uma string contando espaços e caracteres
especiais, ou seja, tudo que pertencer a essa string.

>>>  len(test)
29
 
 Métodos de Strings
Beleza, agora vamos voltar aos métodos que eu estava falando.Vamos
pegar nossa string e substituir uma palavra usando o
método replace.

>>>test  =  test.replace('simple',  'short')

>>>  test
'This  is  just  a  short  string.'
 
 Métodos de Strings
Agora vamos contar o numero de vezes que a palavra especificada aparece
na string, nesse caso estou apenas procurando por um caracter 'r'.

>>>test.count('r')
2
 
 Métodos de Strings
Podemos também achar em que posição está certa letra ou palavra.

>>> test.find('r')
18
>>>  test[18]
'r'
 
 Métodos de Strings
Separar uma string é uma coisa que eu frequentemente faço. O método split
é usado para isso.

>>>test.split()
['This',  'is',  'just',  'a',  'short',  'string.']
 
 Métodos de Strings
Podemos escolher o ponto a ser separado

>>> test.split('a')
['This  is  just  ',  '  short  string.']
 
 Métodos de Strings
Para juntar nossa string separada, podemos usar o método join

>>> '  some  '.join(test.split('a'))

'This  is  just    some    short  string.'
 
 Métodos de Strings
Podemos brincar com a caixa das letras (maiúsculo ou minúsculo). Vamos
deixar tudo maiúsculo.

>>> test.upper()
'THIS  IS  JUST  A  SHORT  STRING.'
 
 Métodos de Strings
Agora vamos deixar tudo minúsculo

>>>  test.lower()
'this  is  just  a  short  string.'
 
 Métodos de Strings
Vamos deixar apenas a primeira letra maiúscula de uma string minúscula

>>>  test.lower().capitalize()
'This  is  just  a  short  string.'
 
 Métodos de Strings
Podemos usar o método title, que deixa as letras de cada palavra da string
maiúscula.

>>>test.title()
'This  Is  Just  A  Short  String.'
 
 Métodos de Strings
Uma troca também é possível.O que for maiúsculo vira minúsculo e vice-
versa

>>> test.swapcase()
'tHIS  IS  JUST  A  SHORT  STRING.'
 
 Métodos de Strings
Podemos rodar alguns testes numa string usando poucos métodos. Vamos
ver se a string dada é totalmente maiúscula.

>>>'UPPER'.isupper()
True
>>>  'UpPEr'.isupper()
False
 
 Métodos de Strings
Do mesmo modo, podemos checar se a string dada é minúscula.

>>> 'lower'.islower()
True
>>>  'Lower'.islower()
False
 
 Métodos de Strings
Checando se ela é um title, no caso, todas as palavras com a primeira letra
maiúscula.

>>> 'This  Is  A  Title'.istitle()

True
>>>  'This  is  A  title'.istitle()
False
 
 Métodos de Strings
Podemos checar se a string é alfa-numérica, ou seja, contém apenas letras
e números, sem caracteres especiais.

>>> 'aa44'.isalnum()
True
>>>  'a$44'.isalnum()
False
 
 Métodos de Strings
É possível checar se uma string contém apenas letras

>>>'letters'.isalpha()
True
>>>  'letters4'.isalpha()
False
 
 Métodos de Strings
Agora checando se ela contém apenas números.

>>> '306090'.isdigit()
True
>>>  '30-60-90  Triangle'.isdigit()
False
 
 Métodos de Strings
Podemos checar se uma string contém apenas espacos.

>>>  '      '.isspace()

True
>>>  ''.isspace()
False  
 Métodos de Strings
Falando em espacos, podemos adicionar espacos em ambos os lados de
uma string.Vamos adicionar espacos no lado direito de uma string.

>>>  'A  string.'.ljust(15)

'A  string  
 Métodos de Strings
Para adicionar espacos do lado esquerdo, o método rjust é usado

>>>'A  string.'.rjust(15)
'            A  string.'
 
 Métodos de Strings
O método center é usado para centralizar uma string dentro de espaços.

>>>  'A  string.'.center(15)

'      A  string.      '
 
 Métodos de Strings
Podemos separar os espacos de ambos os lados de uma string.

>>> 'String.'.rjust(15).strip()
'String.'
>>>  'String.'.ljust(15).rstrip()
'String.'
 
Mais alguns detalhes

• Valores de string definidos com delimitadores de aspas ou apóstrofos devem

ser definidos em uma única linha. Se a string tiver que representar texto de
várias linhas, temos duas opções. Uma é usar apóstrofos triplos, como
fazemos nesse poema de Emily Dickinson:
Mais alguns detalhes

• Vejamos como a variável poema é avaliada:

Mais alguns detalhes

• Temos outro exemplo de uma string que contém uma sequência de escape.
A sequência de escape \n significa um caractere de nova linha. Quando ela
aparece em um argumento de string da função print(), a sequência de
escape de nova linha \n inicia uma nova linha:
Mais alguns detalhes

• Outra forma de criar uma string multilinha é codificar os novos caracteres de

linha explicitamente:
Saída Formatada

• Os resultados da execução de um programa normalmente são mostrados na

tela ou gravados em um arquivo. De qualquer forma, os resultados deverão
ser apresentados de uma maneira que seja visualmente eficaz. As
ferramentas de formatação de saída do Python ajudam a conseguir isso.
Nesta seção, vamos aprender como formatar a saída usando recursos da
função print()e o método de string format(). As técnicas que aprendemos
aqui se transformarão na formatação da saída para arquivos, algo que
discutiremos na próxima seção.
Saída Formatada

• Função print()

• A função print() é usada para exibir valores na tela. Sua entrada é um objeto 
e ela exibe  uma representação de string do valor do objeto. (

>>> n = 5 

>>> print(n) 

5 
 Saída Formatada

• Função print() 

A função print() pode aceitar uma quantidade qualquer de objetos de entrada, não necessariam
ente do mesmo tipo. Os valores dos objetos serão impressos namesma linha e espaços em br
anco (isto é, caracteres ' ') serão inseridos entre eles:
>>> r = 5/3 
>>> print(n, r) 
5 1.66666666667 
>>> nome = 'Ida’ 
>>> print(n, r, nome) 
5 1.66666666667 Ida  
 
 Saída Formatada

• Função print() 
O espaço em branco inserido entre os valores é simplesmente o separador padrão. Se
quisermos inserir sinais de ponto e vírgula entre os valores, em vez de espaços em branco,
também podemos. A função print() usa um argumento de separação opcional sep, além
dos objetos a serem exibidos:

>>> print(n, r, nome, sep=';’)

5;1.66666666667;Ida

O argumento sep=';' especifica que sinais de ponto e vírgula devem ser inseridos para
separar os valores exibidos de n, r e nome.
 Saída Formatada

• Função print() 

Em geral, quando o argumento sep=<alguma string> é acrescentado

aos argumentos da função print(), a string <alguma string> será
inserida entre os valores. Aqui estão alguns usos comuns do
separador. Se quisermos exibir cada valor separado pela string ', '
(vírgula e espaço em branco), usaremos:
>>> print(n, r, nome, sep=', ‘)
5, 1.66666666667, Ida
 Saída Formatada

• Função print()

Se quisermos exibir os valores em linhas separadas, o separador

deverá ser o caractere de nova linha, ' \n’:
>>> print(n, r, nome, sep='\n’)
5
1.66666666667
Ida
 
Saída Formatada
 Saída Formatada

Função print()
A função print() admite outro argumento de formatação, end, além de sep.
Normalmente, cada chamada de função print() sucessiva exibirá em uma linha
separada:
>>> for nome in ['Joe', 'Sam', 'Tim', 'Ann’]:
print(nome)
Joe
Sam
Tim
Ann
 Saída Formatada
• Função print() 
O motivo para esse comportamento é que, como padrão, a instrução print() acrescenta um
caractere de nova linha (\n) aos argumentos a serem impressos. Suponha que a saída que
realmente queremos é:
 
Joe! Sam! Tim! Ann!
(Só chamamos nossos bons amigos, e estamos em um tipo de clima exclamativo.) Quando o
argumento end=<alguma string> é acrescentado aos argumentos a serem exibidos, a string
<alguma string> é exibida após todos os argumentos terem sido exibidos. Se o argumento
end=<alguma string> não existir, então a string padrão '\n', o caractere de nova linha, é exibido em
vez disso; isso faz com que a linha atual termine. Assim, para obter a saída de tela no formato que
queremos, precisamos acrescentar o argumento end = '!' à nossa chamada de função print():
 
>>> for nome in ['Joe', 'Sam', 'Tim', 'Ann']:
print(nome, end='! ')
Joe! Sam! Tim! Ann!
 Saída Formatada
• Função print() 

Problema Prático 4.4

Escreva a função par() que toma um inteiro positivo n como entrada e

exibe na tela todos os números entre 2 (inclusive) e n, que sejam
divisíveis por 2 ou por 3, usando este formato de saída:
>>> even(17)
2, 3, 4, 6, 8, 9, 10, 12, 14, 15, 16,
 Saída Formatada
Método de String format()

O argumento sep pode ser acrescentado aos argumentos de uma chamada de

função print() para inserir a mesma string entre os valores impressos. A inserção
da mesma string separadora nem sempre é o que queremos. Considere o
problema de exibir o dia e a hora da forma como esperamos ver a hora, dadas
estas variáveis:

>>> diasemana = 'Quarta'

>>> mês = 'Outubro'
>>> dia = 9
>>> ano = 2013
>>> hora = 11
>>> minuto = 45
>>> segundo = 33
 Saída Formatada
Método de String format()

O que queremos é chamar a função print() com as variáveis definidas como

argumentos de entrada e obter algo do tipo:

Quarta, 9 de outubro de 2013 às 11:45:33

Fica evidente que não podemos usar um argumento separador para obter essa
saída. Um modo de consegui-la seria usar a concatenação de strings para
construir uma string no formato correto:

>>> print(diasemana+', '+str(dia)+' de ' +mês+ ', +str(ano)

+' às '+str(hora)+ ' : '+str(minuto)+':'str(segundo))
SyntaxError: invalid syntax (<pyshell#36>, line 1)
 Saída Formatada
Método de String format()

Opa, cometi um engano. Esqueci de incluir um + antes de str(segundo). Isso

resolve (verifique!), mas não devemos estar satisfeitos. O motivo para que eu
cometesse esse erro é que a técnica usada é bastante tediosa e passível de
erros. Há um modo mais fácil e bem mais flexível de formatar a saída. A classe
de string (str) oferece um método de classe poderoso, format(), para essa
finalidade.
O método de string format() é invocado sobre uma string que representa o
formato da saída. Os argumentos da função format() são os objetos a serem
impressos. Para explicar o uso da função format(), começamos com uma
pequena versão do nosso exemplo de data e hora, na qual só queremos exibir a
hora:
>>> '{0}:{1}:{2}'.format(hora, minuto, segundo)
'11:45:33'
 Saída Formatada
Método de String format()

Os objetos a serem impressos (hora, minuto e segundo) são argumentos do método format(). A
string invocando a função format() — ou seja, a string '{0}:{1}:{2}' — é a string de formato: ela
descreve o formato da saída. Todos os caracteres fora das chaves — ou seja, os dois sinais de
dois-pontos (':') — serão exibidos literalmente. As chaves {0}, {1} e {2} são marcadores de lugar,
em que os objetos serão impressos. Os números 0, 1 e 2 indicam explicitamente que os
marcadores de lugar são o primeiro, segundo e terceiro argumentos da chamada de função
format(), respectivamente. Veja uma ilustração na Figura
 Saída Formatada
Método de String format()

A Figura a seguir mostra o que acontece quando movemos os índices 0, 1 e 2 no exemplo anterior:

>>> '{2}:{0}:{1}'.format(hora, minuto, segundo)

 Saída Formatada
Método de String format()

O padrão, quando nenhum número explícito é indicado entre as chaves, é

atribuir o primeiro marcador de lugar (da esquerda para a direita) ao primeiro
argumento da função format(), o segundo marcador ao segundo argumento, e
assim por diante, conforme mostra a Figura a seguir:

>>> '{}:{}:{}'.format(hora, minuto, segundo)

'11:45:33'
 Saída Formatada
Método de String format()

Verificamos isso (veja na Figura a seguir ) a ilustração do mapeamento de variáveis

aos marcadores de lugar):
>>> print('{}, {} {}, {} at {}:{}:{}'.format(diasemana, mês, dia, ano, hora, minuto, segundo))

Quarta, Outubro 10, 2013 às 11:45:33

 Saída Formatada
Método de String format()
 Saída Formatada
Método de String format()

Alinhando Dados em Colunas

Agora, vamos considerar o problema de apresentar dados visualmente alinhados em

colunas. Para motivar o problema, pense simplesmente em como os campos De,
Assunto e Data no seu cliente de e-mail são organizados, ou como as informações de
saída e chegada de voos são apresentadas nas telas. Ao começarmos a lidar com
quantidades de dados maiores, às vezes também precisaremos apresentar os
resultados em formato de coluna.
Para ilustrar essas questões, vamos considerar o problema de alinhar corretamente os
valores das funções i2, i3 e 2i para i = 1, 2, 3,… O alinhamento correto dos valores é útil
porque ilustra as taxas de crescimento muito diferentes dessas funções:
 Saída Formatada
Método de String format()
 Saída Formatada
Método de String format()

Agora, como podemos obter essa saída? Em nossa primeira tentativa, acrescentamos
um argumento sep à função print() para inserir um número apropriado de espaços entre
os valores impressos em cada linha:
>>> print('i i**2 i**3 2**i')
>>> for i in range(1,13):
        print(i, i**2, i**3, 2**i, sep='   ')
A saída que obtemos é:
 Saída Formatada
Método de String format()

Embora as primeiras linhas pareçam estar corretas, podemos ver que as entradas
na mesma coluna não estão alinhadas corretamente. O problema é que um
separador de tamanho fixo empurra as entradas mais para a direita quando o
número de dígitos na entrada aumenta. Um separador com tamanho fixo não é a
ferramenta correta para essa tarefa. O modo apropriado de representar uma
coluna de números é fazer com que todos os dígitos de unidade sejam alinhados.
O que precisamos é de uma maneira de fixar a largura de cada coluna de
números e exibir os valores alinhados à direita dentro dessas colunas de largura
fixa. Podemos fazer isso com strings de formato.

Dentro das chaves de uma string de formato, podemos especificar como o valor
mapeado para o marcador de lugar de chave deverá ser apresentado; podemos
especificar sua largura de campo, alinhamento, precisão decimal, tipo e assim por
diante.
 Saída Formatada
Método de String format()

Podemos especificar a largura de campo (mínima) com um inteiro decimal

definindo o número de posições de caractere reservadas para o valor. Se não for
especificada ou se a largura do campo especificada for insuficiente, então a
largura do campo será determinada pelo número de dígitos/caracteres no valor
exibido. Veja um exemplo:

>>> '{0:3},{1:5}'.format(12, 354)

' 12, 354'
 Saída Formatada
Método de String format()

Nesse exemplo, estamos imprimindo os valores inteiros 12 e 354. A string de

formato tem um marcador de lugar para 12 com '0:3' dentro das chaves. O 0
refere-se ao primeiro argumento da função format() (12), conforme já vimos. Tudo
depois do ':' especifica a formatação do valor. Nesse caso, 3 indica que a largura
do marcador de lugar deve ser 3.

Como 12 é um número de dois dígitos, um espaço em branco extra é

acrescentado na frente. O marcador de lugar para 354 contém '1:5', de modo que
dois espaços em branco extras são acrescentados na frente.
 Saída Formatada
Método de String format()

Quando a largura do campo for maior que o número de dígitos, o padrão é alinhar
à direita — ou seja, empurrar o valor numérico para a direita. As strings são
alinhadas à esquerda. No próximo exemplo, um campo com largura de 10
caracteres é reservado para cada argumento primeiro e último. Observe que
espaços extras são acrescentados após o valor da string:

>>> primeiro = 'Bill'

>>> último = 'Gates'
>>> '{:10}{:10}'.format(primeiro, último)
'Bill Gates ‘
 Saída Formatada
Método de String format()

A precisão é um número decimal que especifica quantos dígitos devem ser

exibidos antes e depois do ponto decimal de um valor de ponto flutuante. Ele vem
após a largura do campo e um ponto os separa. No próximo exemplo, a largura
do campo é 8, mas somente quatro dígitos do valor de ponto flutuante são
exibidos:

>>> '{:8.4}'.format(1000 / 3)
' 333.3'
Compare isso com a saída não formatada:

>>> 1000 / 3
333.3333333333333
 Saída Formatada
Método de String format()

A precisão é um número decimal que especifica quantos dígitos devem ser

exibidos antes e depois do ponto decimal de um valor de ponto flutuante. Ele vem
após a largura do campo e um ponto os separa. No próximo exemplo, a largura
do campo é 8, mas somente quatro dígitos do valor de ponto flutuante são
exibidos:

>>> '{:8.4}'.format(1000 / 3)
' 333.3'
Compare isso com a saída não formatada:

>>> 1000 / 3
333.3333333333333
 Saída Formatada
Método de String format()
 Saída Formatada
Método de String format()

Duas das opções de apresentação para valores de ponto flutuante são f e e. A

opção de tipo f mostra o valor como um número de ponto fixo (ou seja, com um
ponto decimal e uma parte fracionária).

>>> '{:6.2f}'.format(5 / 3)
' 1.67'
Nesse exemplo, a especificação de formato ':6.2f' reserva uma largura mínima de
6 com exatamente dois dígitos após o ponto decimal para um valor de ponto
flutuante representado como um número de ponto fixo.
 Saída Formatada
Método de String format()
 Saída Formatada
Método de String format()
Problema Prático 4.6
Implemente a função rol(), que recebe uma lista contendo informações de estudantes e exibe um
rol, como vemos a seguir. As informações do estudante, consistindo em seu sobrenome, nome,
nível e nota média, serão armazenadas nessa ordem em uma lista. Portanto, a lista de entrada é
uma lista de listas. Cuide para que o rol exibido tenha 10 espaços para cada valor de string e 8
para a nota, incluindo 2 espaços para a parte decimal.
 Arquivos
Um arquivo é uma sequência de bytes armazenados em um dispositivo de
memória secundário, como uma unidade de disco. Um arquivo poderia ser um
documento de texto ou uma planilha, um arquivo HTML ou um módulo Python.
Esses arquivos são denominados arquivos de texto. Os arquivos de texto contêm
uma sequência de caracteres que são codificados usando alguma codificação
(ASCII, utf-8 etc.). Um arquivo também pode ser uma aplicação executável (como
python.exe), uma imagem ou um arquivo de áudio. Esses arquivos são
denominados arquivos binários, pois são apenas uma sequência de bytes e não
há codificação.

Todos os arquivos são gerenciados pelo sistema de arquivos, que apresentamos

em seguida.
 Arquivos
• Entrada e saída são operações de
comunicação de um programa com o
mundo externo
• Essa comunicação se dá usualmente
através de arquivos
• Em Python, um arquivo pode ser
lido/escrito através de um objeto da
classe file
 Abrindo Arquivos
• open (name, mode)
– name: nome do arquivo a abrir
– mode: (opcional) modo de abertura – string
contendo
• r : leitura (default)
• w : escrita (se o arquivo existir terá o conteúdo apagado
• a : escrita a partir do final (não apaga conteúdo)
• r+ : indica leitura e escrita
• b : binário (rb, wb, ab)
 Exemplo
• O comando open retorna um objeto do tipo
file (arquivo)
• O objeto file é usado para operações de
entrada e saída:
>>> arq = open ("teste.txt", "w")
>>> arq.write ("Oi")
>>> arq.close ()
>>> arq = open ("teste")
>>> x = arq.read()
>>> x
'Oi'
 Open
>>> f = open(‘texto.txt','w')
>>> f.write('Ola Mundo!')

• Não devemos esquecer de fechar o

arquivo:

>>> f.close()
 Métodos Read, Write e
Close
• read(num)
– Lê num bytes do arquivo e os retorna numa
string
– Se num não é especificado, todos os bytes desde
o ponto atual até o fim do arquivo são retornados
 Métodos Read, Write e
Close
• write(string)
– Escreve string no arquivo
– Devido ao uso de buffers, a escrita pode não ser
feita imediatamente
• Use o método flush() ou close()
para assegurar a escrita física
• close()
– Termina o uso do arquivo para operações de
leitura e escrita
 ExemploRead
>>> f = open(‘texto.txt',‘r‘)
>>> ler = f.read()
>>> f.close()
>>> print ler
Ola Mundo!

• Metodo read()() usado sem nenhum

argumento, mostrará tudo que esta no
aquivo
 ExemploRead
• Se quisermos ler apenas os três primeiros
caracteres (bytes), podemos usar da seguinte
maneira:
>>> f = open(‘texto.txt’) # r é
default
>>> ler = f.read(3)
>>> f.close()
>>> print ler
Ola
 ExemploRead
• e caso queira ler o restante, o read()
começará de onde parou:
>>> restante = f.read()
>>> print restante
Mundo!
 Fim de Linha
• Arquivos de texto são divididos em linhas
usando caracteres especiais
• Python usa sempre \n para separar linhas
– Leitura ou escrita de arquivo aberto em modo
texto
– Em modo binário, entretanto, a conversão não é
feita
 Lendo e Escrevendo
Linhas
• readline(n)
– Se n não é especificado, retorna exatamente uma
linha lida do arquivo
– Caso contrário, lê uma linha, mas busca no
máximo n caracteres pelo final de linha
– Se o tamanho da linha é zero significa que o
final do arquivo foi atingido
 Lendo e Escrevendo
Linhas
• readlines(n)
– Se n não é especificado, retorna o restante do
conteúdo do arquivo em uma lista de strings
– Caso n seja especificado, a leitura é limitada a n
caracteres no máximo
 Lendo e Escrevendo
Linhas
• writelines(lista)
– Escreve a lista (ou qualquer seqüência) de
strings, uma por uma no arquivo

– Caracteres de final de de linha não são

acrescentados
 Exemplos
• adicionar mais alguma coisa no arquivo do
exemplo:
>>> f = open(‘texto.txt’, ‘a‘)
>>> f.write('\nOla Python')
>>> f.close()
• o 'a' (append) é usado para adicionar texto
sem apagar o que ja havia no arquivo
• '\n' é usado pra pular uma linha, lembrando
que tudo é string ( este caractere fica visível)
 Exemplos
>>> f = open(‘texto.txt',‘r‘)
>>> linha1 = f.readline()
>>> linha2 = f.readline()
>>> f.close()
>>> print linha1
Ola Mundo!\n
>>> print linha2
Ola Python
Exemplos
 Resumo
operação Interpretação
output = open(“c:/teste.txt”,”w”) Cria arquivo de saída (“w” significa gravação)
input = open(“c:/teste.txt”,”r”) Cria arquivo de entrada (“r” significa leitura)
S = input.read() Lê o arquivo inteiro em uma única string
S = input.read(N) Lê N byte (1 ou mais)
S = input.readline() Lê a próxima linha
L = input.readlines() Cria uma lista onde cada elemento é uma linha
do arquivo
output.write(S) Grava a string S no arquivo
output.writelines(L) Grava no arquivo todas as strings da lista L
output.close() Fechamento manual do arquivo
 Método seek()
• Muda a posição do cursor no arquivo
• f.seek(deslocamento, ref)
• A nova posição é computada adicionando o
deslocamento ao ponto de referência
• O ponto de referência é determinado pelo
parâmetro ref que pode ser:
– 0 (default): deslocar a partir do início do arquivo
– 1 deslocar a partir da posição atual e
– 2 usar o final do arquivo como ponto de referência
 Método seek()
• Exemplos
 Interação com o
Sistema Operacional
• Operações de entrada e saída são na verdade
realizadas pelo sistema operacional

• O módulo os possui variáveis e funções que

ajudam um programa Python a se adequar ao
sistema operacional
 Interação com o SO
>>>os.getcwd()
retorna o diretório corrente
>>>os.chdir(dir)
muda o diretório corrente para dir
>>>os.sep
string com o caractere que separa componentes de
um caminho ('/' para Unix, '\\' para
Windows)
>>>os.path.exists(path)
diz se path se refere ao nome de um arquivo
existente
Exemplos
Fim