Revisão de Arquivos em Python

Prévia do material em texto

COMPUTAÇÃO II - Python 
Revisão de Arquivos em Python: (ver também aula LabArquivos de 15/10/09) 
referências: http://docs.python.org/library/stdtypes.html 
 
Escrever e gravar um texto com várias linhas, usando string literal: 
 
# -*- coding: utf-8 -*- 
nomearq = 'c:\\python\\exemplos\\arquivos\\arqTextoDig.txt' 
arq = open(nomearq, 'w') 
 
# Usando a notação de string literal longa 
# Note que todos os fim-de-linha digitados são incluídos no texto: 
texto = """primeira linha 
segunda linha 
terceira linha 
quarta linha 
quinta linha 
""" 
# Usa-se o comando write para gravar toda a string do texto: 
arq.write(texto) 
arq.close() 
 
Gravando uma lista de linhas: 
# -*- coding: utf-8 -*- 
nomearq = 'c:\\python\\exemplos\\arquivos\\arqlista.txt' 
arq = open(nomearq, 'w') 
 
# Note a necessidade do \n em cada linha da lista de linhas: 
listaStr = ['primeira linha\n', 'segunda linha\n', 'terceira linha\n', \ 
 'quarta linha\n', 'quinta linha\n'] 
 
# Grava de uma vez todas as linhas da lista: 
arq.writelines(listaStr) 
arq.close() 
================================================================================= 
Lendo arquivos texto para o programa: 
 
arq = open(nomearq,'r') ou apenas arq = open(nomearq) ('r' é parâmetro default) 
 
Formas de leitura: 
textostring = arq.read() # lê todos os caracteres, a partir da posição corrente, para uma única string, que é 
retornada. Se não houver mais caracteres, retorna uma string vazia (""). 
textostring = arq.read(n) # lê até n caracteres a partir da posição corrente (ou todos, se houver n ou menos) 
listaStrings = arq.readlines() # cria na memória uma lista das linhas do arquivo, incluindo o \n. 
linha = arq.readline() # lê a próxima linha (ou seja, da posição atual até (e inclusive) o primeiro fim-de-linha) 
 
================================================================================= 
Métodos seek() e tell(): 
Os arquivos são seqüências de bytes. O primeiro byte está na posição 0, o segundo na posição 1, etc. Todo arquivo 
usado no programa tem um "cursor" interno que indica a posição do próximo byte a ser lido ou gravado com os 
comandos read, write, etc. 
A posição desse "cursor" interno pode ser vista com o comando tell(). 
Quando abrimos um arquivo, o cursor vai normalmente para posição 0. A cada comando de leitura ou gravação, o 
cursor avança o número de bytes correspondentes. 
Por exemplo, os comandos abaixo imprimem a posição em que o cursor parou depois de ler a primeira linha do arquivo 
criado nos exemplos anteriores: 
 
nomearq = 'c:\\python\\exemplos\\arquivos\\arqTextoDig.txt' 
arq = open(nomearq) # cursor posiciona-se em 0 
linha = arq.readline() # lê os caracteres até o primeiro \n, inclusive, e o cursor avança até o byte seguinte. 
print arq.tell() # imprime 16L (inteiro longo) (no Windows) 
Porque imprime 16L? 
O nosso arquivo tem a seguinte sequencia de caracteres, cada caractere ocupando 1 byte: 
primeira linha\nsegunda linha\nterceira linha\n......... 
01234567890123456789012345678901234566789012345 
 
Contando os caracteres, a partir da posição inicial 0, vemos que o primeiro \n está na posição 14. Mas no Windows, 
cada \n é representado internamente por 2 bytes, um CR (carriage return, ou "retorno de carro", valor 0x0D, ou 13) 
seguido de um LF (line feed, ou "avanço de linha", valor 0x0A ou 10). Por isso, o primeiro caractere da segunda linha 
começa na posição 16. Nos ambientes UNIX/Linux o caractere \n é representado apenas por 1 byte (o valor LF). 
 
Existem utilitários que convertem arquivos criados em ambientes Windows para formato Unix/linux, e vice-versa . 
 
O método seek(deslocamento, origem) permite reposicionar o cursor um certo número de bytes (ou caracteres) a partir 
de uma determinada posição. O default é a partir do início do arquivo, com o parâmetro origem = 0 ou SEEK_SET. 
Outras possibilidades são: a partir da posição atual (onde o cursor está) , com origem = 1 ou SEEK_CUR, e a partir do 
final, com origem = 2 ou SEEK_END. O valor do deslocamento é relativo em relação à origem, e pode ser negativo. 
Portanto, uma forma de posicionar o cursor no final do arquivo, e dar um deslocamento zero a partir do final, assim: 
arq.seek(0, 2) ou arq.seek(0, SEEK_END) 
 
Arquivos podem ser tratados como seqüências, e admitem o uso de laços for para percorrer eficientemente as linhas de 
um arquivo texto, como no exemplo abaixo: 
 
arq.seek(0) # desloca o indicador de posição para o inicio do arquivo (byte 0) 
for linha in arq: 
 print linha 
 
Note que os métodos seek() e tell() trabalham com posições em bytes, enquanto o método 
read(n) trabalha com número de caracteres. 
================================================================================= 
 
 
Modos de operção mistos com texto: 
a) Arquivos podem ser abertos para leitura de texto, e aceitar também gravação não destrutiva: 
modo 'r+' 
 
b) Arquivos podem ser abertos para gravação destrutiva de texto, e aceitar também leitura: 
modo 'w+' 
 
c) Arquivos podem ser abertos para gravação não destrutiva de textos somente no final (adicionar ou append), e 
aceitar leitura também: modo 'a' 
 
 
 
Outras revisões: 
 
Comando break: 
- só termina o laço onde ocorre, o laço externo a ele continua normalmente 
 
Comando else, em laços for: 
- um laço for pode ter um comando else a seguir. Se o laço terminar normalmente, os comandos do else serão 
executados. Se o laço terminar por um break, os comandos do else não serão executados: 
 
Exemplos: 
x = [1,3,5,7] 
for i in x: 
 k = i+1 
 for n in range(10): 
 if n > i: 
 print n, "é maior que", i 
 break 
 print k 
 
Saída: 
2 é maior que 1 
2 
4 é maior que 3 
4 
6 é maior que 5 
6 
8 é maior que 7 
8 
 
======================= 
x = [1,3,5,7] 
for i in x: 
 if i > 3: 
 print i+1 
 break 
else: 
 print 'acabou' 
 
Saída: 
6 
 
======================= 
x = [1,3,5,7] 
for i in x: 
 if i > 3: 
 print i+1 
else: 
 print 'acabou' 
 
Saída: 
6 
8 
acabou 
 
=======================