3. Noções básicas

3.1. Um exemplo de programa em Python

Abaixo, você encontrará um programa que apresenta as principais características do Python.

O programa (bases_01)


# -*- coding=utf-8 -*-

# ----------------------------------
def affiche(chaine):
    # exibe a string
    print "chaine=%s" % (chaine)


# ----------------------------------
def afficheType(variable):
    # exibe o tipo de variável
    print "type[%s]=%s" % (variable,type(variable))

# ----------------------------------
def f1(param):
    # soma 10 ao parâmetro
    return param+10

# ----------------------------------
def f2():
    # retorna 3 valores
    return ("un",0,100);


# -------------------------------- programa principal ------------------------------------
# isso é um comentário
# variável usada sem ter sido declarada
nom="dupont"

# uma exibição na tela
print "nom=%s" % (nom)

# uma lista com elementos de tipos diferentes
liste=["un","deux",3,4]

# o número de elementos
n=len(liste)

# um loop
for i in range(n):
  print "liste[%d]=%s" % (i,liste[i])

# inicialização de duas variáveis com uma tupla
(chaine1,chaine2)=("chaine1","chaine2")

# concatenação das duas cadeias de caracteres
chaine3=chaine1+chaine2

# exibição do resultado
print "[%s,%s,%s]" % (chaine1,chaine2,chaine3)

# uso de função
affiche(chaine1)

# o tipo de uma variável pode ser conhecido
afficheType(n)
afficheType(chaine1)
afficheType(liste)

# o tipo de uma variável pode mudar durante a execução
n="a change"
afficheType(n)

# uma função pode retornar um resultado
res1=f1(4)
print "res1=%s" % (res1)

# uma função pode retornar uma lista de valores
(res1,res2,res3)=f2()
print "(res1,res2,res3)=[%s,%s,%s]" % (res1,res2,res3)

# esses valores poderiam ter sido armazenados em uma variável
liste=f2()
for i in range(len(liste)):
    print "liste[%s]=%s" % (i, liste[i])

# testes
for i in range(len(liste)):
    # exibe apenas as cadeias de caracteres
    if (type(liste[i])=="str"):
        print "liste[%s]=%s" % (i,liste[i])

# outros testes
for i in range(len(liste)):
    # exibe apenas os inteiros maiores que 10
    if (type(liste[i])=="int" and liste[i]>10):
        print "liste[%s]=%s" % (i,liste[i])

# um loop while
liste=(8,5,0,-2,3,4)
i=0
somme=0
while(i<len(liste) and liste[i]>0):
    print "liste[%s]=%s" % (i,liste[i])
    somme+=liste[i] #soma = soma + t[i]
    i+=1 #i = i + 1
print "somme=%s" % (somme)
# fim do programa

Observação:

linha 1: um comentário específico que serve para declarar o tipo de codificação do script, neste caso UTF-8. Isso depende do editor de texto utilizado. Aqui, com o Notepad++:

linha 4: a palavra-chave def define uma função;
linhas 5-6: o conteúdo da função. Ele está recuado à direita em uma tabulação. É esse recuo, associado ao caractere : da instrução def, que define o conteúdo da função. Isso se aplica a todas as instruções que possuem conteúdo: if, else, while, for, try, except;
linha 12: o Python gerencia internamente o tipo das variáveis. É possível saber o tipo de uma variável com a função type(variable), que retorna uma variável do tipo 'type'. A expressão '%s' % (type(variável)) é uma sequência de caracteres que representa o tipo da variável;
linha 25: o programa principal. Ele vem após a definição de todas as funções do script. Seu conteúdo não é indentado;
linha 28: em Python, não se declara variáveis. O Python diferencia maiúsculas de minúsculas. A variável Nom é diferente da variável nom. Uma sequência de caracteres pode ser colocada entre aspas " ou apóstrofos '. Portanto, é possível escrever 'dupont' ou "dupont";
linha 31: a expressão "xxxx%syyyy%szzzz" % (100, 200) é a sequência de caracteres "xxxx100yyy200szzzz", na qual cada %s foi substituído por um elemento da tupla. %s é o formato de exibição das sequências de caracteres. Existem outros formatos;
linha 34: há uma diferença entre uma tupla (1,2,3) (observe os parênteses) e uma lista [1,2,3] (observe os colchetes). A tupla é imutável, enquanto a lista é mutável. Em ambos os casos, o elemento nº i é denotado por [i];
linha 40: range(n) é a tupla (0,1,2,...,n-1);
linha 74: len(var) é o número de elementos da coleção var (tupla, lista, dicionário, ...);
linha 86: os demais operadores booleanos são or e not.

Os resultados exibidos na tela são os seguintes:

nom=dupont
liste[0]=un
liste[1]=deux
liste[2]=3
liste[3]=4
[chaine1,chaine2,chaine1chaine2]
chaine=chaine1
type[4]=<type 'int'>
type[chaine1]=<type 'str'>
type[['un', 'deux', 3, 4]]=<type 'list'>
type[a change]=<type 'str'>
res1=14
(res1,res2,res3)=[un,0,100]
liste[0]=un
liste[1]=0
liste[2]=100
liste[0]=8
liste[1]=5
somme=13

3.2. Mudanças de tipos

Aqui, estamos interessados nas conversões de tipos com dados do tipo str (cadeia de caracteres), int (inteiro), float (real) e bool (booleano).

O programa (bases_01b)


# -*- coding=utf-8 -*-

# conversões de tipo
# int --> str, float, bool
x=4
print x, type(x)
x=str(4)
print x, type(x)
x=float(4)
print x, type(x)
x=bool(4)
print x, type(x)

# bool --> int, float, str
x=True
print x, type(x)
x=int(True)
print x, type(x)
x=float(True)
print x, type(x)
x=str(True)
print x, type(x)

# str → int, float, bool
x="4"
print x, type(x)
x=int("4")
print x, type(x)
x=float("4")
print x, type(x)
x=bool("4")
print x, type(x)

# float → str, int, bool
x=4.32
print x, type(x)
x=str(4.32)
print x, type(x)
x=int(4.32)
print x, type(x)
x=bool(4.32)
print x, type(x)

# gestão de erros de conversão de tipo
try:
    x=int("abc")
    print x, type(x)
except ValueError, erreur:
    print erreur

# casos diversos do booleano
x=bool("abc")
print x, type(x)
x=bool("")
print x, type(x)
x=bool(0)
print x, type(x)
x=None
print x, type(x)
x=bool(None)
print x, type(x)

São possíveis diversas conversões de tipo. Algumas podem falhar, como as das linhas 45 a 49, que tentam converter a string 'abc' em um número inteiro. O erro foi tratado por meio de uma estrutura try / except. A forma geral dessa estrutura é a seguinte:


try:
    actions
except Exception, Message:
    actions
finally:
    actions

Se uma das ações do bloco try lançar uma exceção (se sinalizar um erro), o controle passa imediatamente para a cláusula except. Se as ações do bloco try não lançarem nenhuma exceção, a cláusula except é ignorada. Os atributos Exception e Message da instrução except são opcionais. Quando presentes, Exception especifica o tipo de exceção interceptada pela instrução except e Message contém a mensagem de erro relacionada à exceção. Pode haver várias instruções except, caso se deseje gerenciar diferentes tipos de exceção no mesmo try.

A instrução finally é opcional. Se estiver presente, as ações da instrução finally serão sempre executadas, independentemente de ter ocorrido uma exceção ou não.

Voltaremos a abordar as exceções um pouco mais adiante.

As linhas 52 a 61 mostram diversas tentativas de converter dados dos tipos str, int, float e NoneType em booleanos. Isso sempre é possível. As regras são as seguintes:

bool(int i) é igual a False se i for 0, e a True em todos os outros casos;
bool(float f) é igual a False se f for igual a 0,0, e a True em todos os outros casos;
bool(str chaine) é igual a False se chaine tiver 0 caractere, e a True em todos os outros casos;
bool(None) é igual a False. None é um valor especial que significa que a variável existe, mas não possui valor.

Os resultados na tela são os seguintes:

4 <type 'int'>
4 <type 'str'>
4.0 <type 'float'>
True <type 'bool'>
True <type 'bool'>
1 <type 'int'>
1.0 <type 'float'>
True <type 'str'>
4 <type 'str'>
4 <type 'int'>
4.0 <type 'float'>
True <type 'bool'>
4.32 <type 'float'>
4.32 <type 'str'>
4 <type 'int'>
True <type 'bool'>
invalid literal for int() with base 10: 'abc'
True <type 'bool'>
False <type 'bool'>
False <type 'bool'>
None <type 'NoneType'>
False <type 'bool'>
False <type 'bool'>

3.3. O escopo das variáveis

Programa (bases_02)


# -*- coding=utf-8 -*-

# escopo das variáveis
def f1():
    # usa-se a variável global i
    global i
    i+=1
    j=10
    print "f1[i,j]=[%s,%s]" % (i,j)

def f2():
    # usa-se a variável global i
    global i
    i+=1
    j=20
    print "f2[i,j]=[%s,%s]" % (i,j)

def f3():
    # usa-se uma variável local i
    i=1
    j=30
    print "f3[i,j]=[%s,%s]" % (i,j)
  
# testes
i=0
j=0 # essas duas variáveis não são conhecidas por uma função f
    # a menos que esta as declare explicitamente por meio da instrução global
    # que pretende utilizá-las
f1()
f2()
f3()
print "test[i,j]=[%s,%s]" % (i,j)

Resultados

f1[i,j]=[1,10]
f2[i,j]=[2,20]
f3[i,j]=[1,30]
test[i,j]=[2,0]

Notas:

o script demonstra o uso da variável i, declarada como global nas funções f1 e f2. Nesse caso, o programa principal e as funções f1 e f2 compartilham a mesma variável i.

3.4. Listas, tuplas e dicionários

3.4.1. Listas unidimensionais

Programa (bases_03)


# -*- coding=utf-8 -*-

# listas unidimensionais
# inicialização
list1=[0,1,2,3,4,5]

# iteração - 1
print "list1 a %s elements" % (len(list1))
for i in range(len(list1)):
    print "list1[%s]=%s" % (i, list1[i])

list1[1]=10;
# percurso - 2
print "list1 a %s elements" % (len(list1))
for element in list1:
    print element

# adição de dois elementos
list1[len(list1):]=[10,11]
print ("%s") % (list1)

# remoção dos dois últimos elementos
list1[len(list1)-2:]=[]
print ("%s") % (list1)

# adição de uma tupla no início da lista
list1[:0]=[-10, -11, -12]
print ("%s") % (list1)

# inserção de dois elementos no meio da lista
list1[3:3]=[100,101]
print ("%s") % (list1)

# remoção de dois elementos no meio da lista
list1[3:4]=[]
print ("%s") % (list1)

Notas:

a notação matriz[i:j] designa os elementos de i a j-1 da matriz;
a notação [i:] designa os elementos i e seguintes da matriz;
a notação [:i] designa os elementos de 0 a i-1 da matriz;
linha 20: print (%s) % (list1) exibe a sequência de caracteres: “[ list1[0], list1[2], ..., list1[n-1]]”.

Resultados

list1 a 6 elements
list1[0]=0
list1[1]=1
list1[2]=2
list1[3]=3
list1[4]=4
list1[5]=5
list1 a 6 elements
0
10
2
3
4
5
[0, 10, 2, 3, 4, 5, 10, 11]
[0, 10, 2, 3, 4, 5]
[-10, -11, -12, 0, 10, 2, 3, 4, 5]
[-10, -11, -12, 100, 101, 0, 10, 2, 3, 4, 5]
[-10, -11, -12, 101, 0, 10, 2, 3, 4, 5]

O código anterior pode ser escrito de maneira diferente (bases_03b) utilizando certos métodos das listas:


# -*- coding=utf-8 -*-

# listas unidimensionais

# inicialização
list1=[0,1,2,3,4,5]

# percorro - 1
print "list1 a %s elements" % (len(list1))
for i in range(len(list1)):
    print "list1[%s]=%s" % (i, list1[i])

list1[1]=10
# percorro - 2
print "list1 a %s elements" % (len(list1))
for element in list1:
    print element

# adição de dois elementos
list1.extend([10,11])
print ("%s") % (list1)

# remoção dos dois últimos elementos
del list1[len(list1)-2:]
print ("%s") % (list1)

# adição de uma tupla no início da lista
for i in (-12, -11, -10):
    list1.insert(0,i)
print ("%s") % (list1)

# inserção no meio da lista
for i in (101,100):
    list1.insert(3,i)
print ("%s") % (list1)

# remoção no meio da lista
del list1[3:4]
print ("%s") % (list1)

Os resultados obtidos são os mesmos da versão anterior.

3.4.2. O dicionário

O programa (bases_04)


# -*- coding=utf-8 -*-

def existe(conjoints,mari):
    # verifica se a chave “mari” existe no dicionário “conjuges”
    if(conjoints.has_key(mari)):
        print "La cle [%s] existe associee a la valeur [%s]" % (mari, conjoints[mari])
    else:
        print "La cle [%s] n'existe pas" % (mari)


# ----------------------------- Main
# dicionários
conjoints={"Pierre":"Gisele", "Paul":"Virginie", "Jacques":"Lucette","Jean":""}

# percurso - 1
print "Nombre d'elements du dictionnaire : %s " % (len(conjoints))
for (cle,valeur) in conjoints.items():
    print "conjoints[%s]=%s" % (cle,valeur)

# lista das chaves do dicionário
print "liste des cles-------------"
cles=conjoints.keys()
print ("%s") % (cles)

# lista de valores do dicionário
print "liste des valeurs------------"
valeurs=conjoints.values()
print ("%s") % (valeurs)

# busca por uma chave
existe(conjoints,"Jacques")
existe(conjoints,"Lucette")
existe(conjoints,"Jean")

# exclusão de um par chave-valor
del (conjoints["Jean"])
print "Nombre d'elements du dictionnaire : %s " % (len(conjoints))
print ("%s") % (conjoints)

Notas:

linha 17: conjoints.items() retorna a lista de pares (chave, valor) do dicionário como conjuntos;
linha 22: conjoints.keys() retorna as chaves do dicionário conjoints;
linha 27: conjoints.values() retorna os valores do dicionário “conjoints”;
linha 7: conjoints.has_key(marido) retorna True se a chave mari existir no dicionário conjoints, False caso contrário;
linha 38: um dicionário pode ser exibido em uma única linha.

Os resultados

Nombre d'elements du dictionnaire : 4
conjoints[Paul]=Virginie
conjoints[Jean]=
conjoints[Pierre]=Gisele
conjoints[Jacques]=Lucette
liste des cles-------------
['Paul', 'Jean', 'Pierre', 'Jacques']
liste des valeurs------------
['Virginie', '', 'Gisele', 'Lucette']
La cle [Jacques] existe associee a la valeur [Lucette]
La cle [Lucette] n'existe pas
La cle [Jean] existe associee a la valeur []
Nombre d'elements du dictionnaire : 3
{'Paul': 'Virginie', 'Pierre': 'Gisele', 'Jacques': 'Lucette'}

3.4.3. Os tuplos

Programa (bases_05)


# -*- coding=utf-8 -*-

# tuplas
# inicialização
tab1=(0,1,2,3,4,5)

# iteração - 1
print "tab1 a %s elements" % (len(tab1))
for i in range(len(tab1)):
    print "tab1[%s]=%s" % (i, tab1[i])

# percorro - 2
print "tab1 a %s elements" % (len(tab1))
for element in tab1:
    print element

# modificação de um elemento
tab1[0]=-1

Os resultados

tab1 a 6 elements
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1 a 6 elements
0
1
2
3
4
5
Traceback (most recent call last):
  File "exemple_05.py", line 18, in <module>
    tab1[0]=-1
TypeError: 'tuple' object does not support item assignment

Notas:

linhas 15-18 dos resultados: mostram que uma tupla não pode ser modificada.

3.4.4. Listas multidimensionais

Programa (bases_06)


# -*- coding=utf-8 -*-

# listas multidimensionais

# inicialização
multi=[[0,1,2], [10,11,12,13], [20,21,22,23,24]]

# percurso
for i1 in range(len(multi)):
    for i2 in range(len(multi[i1])):
        print "multi[%s][%s]=%s" % (i1,i2,multi[i1][i2])

# dicionários multidimensionais
# inicialização
multi={"zero":[0,1], "un":[10,11,12,13], "deux":[20,21,22,23,24]}

# navegação
for (cle,valeur) in multi.items():
    for i2 in range(len(multi[cle])):
        print "multi[%s][%s]=%s" % (cle,i2,multi[cle][i2])

Resultados

multi[0][0]=0
multi[0][1]=1
multi[0][2]=2
multi[1][0]=10
multi[1][1]=11
multi[1][2]=12
multi[1][3]=13
multi[2][0]=20
multi[2][1]=21
multi[2][2]=22
multi[2][3]=23
multi[2][4]=24
multi[zero][0]=0
multi[zero][1]=1
multi[un][0]=10
multi[un][1]=11
multi[un][2]=12
multi[un][3]=13
multi[deux][0]=20
multi[deux][1]=21
multi[deux][2]=22
multi[deux][3]=23
multi[deux][4]=24

3.4.5. Vínculos entre canais e listas

Programa (bases_07)


# -*- coding=Utf-8 -*-

# conversão de string para lista
chaine='1:2:3:4'
tab=chaine.split(':')
print type(tab)

# exibição de lista
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

# da lista para a cadeia
chaine2=":".join(tab)
print "chaine2=%s" % (chaine2)

# vamos adicionar um campo vazio
chaine+=":"
print "chaine=%s" % (chaine)
tab=chaine.split(":")

# exibição da lista
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

# vamos adicionar novamente um campo vazio
chaine+=":"
print "chaine=%s" % (chaine)
tab=chaine.split(":")

# exibição da lista
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

Notas:

linha 5: o método chaine.split(separador) divide a cadeia de caracteres chaine em elementos separados por séparateur e os retorna na forma de uma lista. Assim, a expressão '1:2:3:4'.split(":") tem como valor a lista ('1','2','3','4');
linha 13: 'separateur'.join(liste) tem como valor a sequência de caracteres 'lista[0]+separador+lista[1]+separador+...'.

Resultados

<type 'list'>
tab a 4 elements
['1', '2', '3', '4']
chaine2=1:2:3:4
chaine=1:2:3:4:
tab a 5 elements
['1', '2', '3', '4', '']
chaine=1:2:3:4::
tab a 6 elements
['1', '2', '3', '4', '', '']

3.5. Expressões regulares

Programa (bases_09)


# -*- coding=utf-8 -*-

import re

# --------------------------------------------------------------------------
def compare(modele,chaine):
    # compara a string string com o padrão padrão
    # exibição dos resultados
    print "\nResultats(%s,%s)" % (chaine,modele)
    match=re.match(modele,chaine)
    if match:
        print match.groups()
    else:
        print "La chaine [%s] ne correspond pas au modele [%s]" % (chaine,modele)


# expressões regulares em Python
# recuperar os diferentes campos de uma string
# o padrão: uma sequência de números entre caracteres quaisquer
# queremos recuperar apenas a sequência de números
modele=r"^.*?(\d+).*?$"

# comparamos a string com o padrão
compare(modele,"xyz1234abcd")
compare(modele,"12 34")
compare(modele,"abcd")

# o modelo: uma sequência de números entre caracteres quaisquer
# queremos a sequência de números, bem como os campos que a precedem e a seguem
modele=r"^(.*?)(\d+)(.*?)$"

# comparamos a sequência com o modelo
compare(modele,"xyz1234abcd")
compare(modele,"12 34")
compare(modele,"abcd")

# o modelo: uma data no formato dd/mm/aa
modele=r"^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$"
compare(modele,"10/05/97")
compare(modele," 04/04/01 ")
compare(modele,"5/1/01")

# o modelo — um número decimal
modele=r"^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$"
compare(modele,"187.8")
compare(modele,"-0.6")
compare(modele,"4")
compare(modele,".6")
compare(modele,"4.")
compare(modele," + 4")
# fim

Notas:

observe o módulo importado na linha 3. É ele que contém as funções de gerenciamento de expressões regulares;
linha 10: a comparação de uma string com uma expressão regular (padrão) retorna o valor booleano True se a string corresponder ao padrão, e False caso contrário;
linha 12: match.groups() é uma tupla cujos elementos são as partes da string que correspondem aos elementos da expressão regular entre parênteses. No modelo:
^.*?(\d+).*?, match.groups() será uma tupla de um elemento;
^(.*?)(\d+)(.*?)$, match.groups() será uma tupla de 3 elementos.

Resultados

Resultats(xyz1234abcd,^.*?(\d+).*?$)
('1234',)

Resultats(12 34,^.*?(\d+).*?$)
('12',)

Resultats(abcd,^.*?(\d+).*?$)
La chaine [abcd] ne correspond pas au modele [^.*?(\d+).*?$]

Resultats(xyz1234abcd,^(.*?)(\d+)(.*?)$)
('xyz', '1234', 'abcd')

Resultats(12 34,^(.*?)(\d+)(.*?)$)
('', '12', ' 34')

Resultats(abcd,^(.*?)(\d+)(.*?)$)
La chaine [abcd] ne correspond pas au modele [^(.*?)(\d+)(.*?)$]

Resultats(10/05/97,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
('10', '05', '97')

Resultats( 04/04/01 ,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
('04', '04', '01')

Resultats(5/1/01,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
La chaine [5/1/01] ne correspond pas au modele [^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$]

Resultats(187.8,^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '187.8')

Resultats(-0.6,^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('-', '0.6')

Resultats(4,^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '4')

Resultats(.6,^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '.6')

Resultats(4.,^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '4.')

Resultats( + 4,^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('+', '4')

3.6. Modo de passagem de parâmetros das funções

Programa (bases_10)


# -*- coding=utf-8 -*-

def f1(a):
    a=2

def f2(a,b):
    a=2
    b=3
    return (a,b)
  
# ------------------------ principal
x=1
f1(x)
print "x=%s" % (x)
(x,y)=(-1,-1)
(x,y)=f2(x,y)
print "x=%s, y=%s" % (x,y)

Resultados

1 2	`x=1 x=2, y=3`

Notas:

tudo é um objeto em Python. Alguns objetos são chamados de “imutáveis”: não é possível modificá-los. É o caso de números, cadeias de caracteres e tuplas. Quando objetos Python são passados como parâmetros para funções, são suas referências que são passadas, a menos que esses objetos sejam “imutáveis”; nesse caso, é o valor do objeto que é passado;
as funções f1 (linha 3) e f2 (linha 6) têm como objetivo ilustrar a passagem de um parâmetro de saída. Queremos que o parâmetro efetivo de uma função seja modificado pela própria função;
linhas 3-4: a função f1 modifica seu parâmetro formal a. Queremos saber se o parâmetro efetivo também será modificado.
linhas 12-13: o parâmetro efetivo é x=1. O resultado da linha 1 mostra que o parâmetro efetivo não é alterado. Assim, o parâmetro efetivo x e o parâmetro formal a são dois objetos diferentes;
linhas 6-9: a função f2 altera seus parâmetros formais a e b e os retorna como resultados;
linhas 15-16: os parâmetros efetivos (x, y) são passados para f2, e o resultado de f2 é atribuído a (x, y). A linha 2 dos resultados mostra que os parâmetros efetivos (x, y) foram alterados.

Conclui-se que, quando objetos “imutáveis” são parâmetros de saída, eles devem fazer parte dos resultados retornados pela função.

3.7. Os arquivos de texto

Programa (bases_11)


# -*- coding=utf-8 -*-

import sys

# processamento sequencial de um arquivo de texto
# este é um conjunto de linhas no formato login:pwd:uid:gid:infos:dir:shell
# cada linha é inserida em um dicionário no formato login => [uid,gid,infos,dir,shell]

# --------------------------------------------------------------------------
def afficheInfos(dico,cle):
    # exibe o valor associado à chave no dicionário “dico”, caso ela exista
    valeur=None
    if dico.has_key(cle):
        valeur=dico[cle]
    if 'list' in str(type(valeur)):
        print "[{0},{1}]".format(cle,":".join(valeur))
    else:
        # a chave não é uma chave do dicionário “dico”
        print "la cle [{0}] n'existe pas".format(cle)           


def cutNewLineChar(ligne):
    # remove-se o marcador de fim de linha, caso exista
    l=len(ligne);
    while(ligne[l-1]=="\n" or ligne[l-1]=="\r"):
        l-=1
    return(ligne[0:l]);
    
# define-se o nome do arquivo
INFOS="infos.txt"

# abre-se o arquivo para criação
try:
    fic=open(INFOS,"w")
except:
    print "Erreur d'ouverture du fichier INFOS en écriture\n"
    sys.exit()

# gera-se um conteúdo arbitrário
for i in range(1,101):
    ligne="login%s:pwd%s:uid%s:gid%s:infos%s:dir%s:shell%s" % (i,i,i,i,i,i,i)
    fic.write(ligne+"\n")

# fecha-se o arquivo
fic.close()

# abre-se o arquivo para leitura
try:
    fic=open(INFOS,"r")
except:
    print "Erreur d'ouverture du fichier INFOS en écriture\n"
    sys.exit()

# dicionário vazio inicialmente
dico={}

# leitura de linha  
ligne=fic.readline()  
while(ligne!=''):
    # remove-se o caractere de fim de linha
    ligne=cutNewLineChar(ligne)
  
    # colocamos a linha em uma tabela
    infos=ligne.split(":")
  
    # recupera-se o login
    login=infos[0]
  
    # removem-se os dois primeiros elementos [login,pwd]
    infos[0:2]=[]
  
    # cria-se uma entrada no dicionário
    dico[login]=infos
  
    # leitura da linha  
    ligne=fic.readline()  

# fecha-se o arquivo
fic.close()

# processamento do dicionário
afficheInfos(dico,"login10")
afficheInfos(dico,"X")

Notas:

linha 37: para encerrar o script no meio do código.

Resultados

O arquivo infos.txt:

login0:pwd0:uid0:gid0:infos0:dir0:shell0
login1:pwd1:uid1:gid1:infos1:dir1:shell1
login2:pwd2:uid2:gid2:infos2:dir2:shell2
...
login98:pwd98:uid98:gid98:infos98:dir98:shell98
login99:pwd99:uid99:gid99:infos99:dir99:shell99

Resultados na tela:

1 2	`[login10,uid10:gid10:infos10:dir10:shell10] la cle [X] n'existe pas`