COMPUTAÇÃO II - Python Revisão de Arquivos em Python: (ver

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
2
4
4
6
6
8
é maior que 1
é maior que 3
é maior que 5
é 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
=======================