3. Conceptos básicos

3.1. Un ejemplo de programa en Python

A continuación, se muestra un programa que presenta las primeras características de Python.

El programa (bases_01)


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

# ----------------------------------
def affiche(chaine):
    # muestra cadena
    print "chaine=%s" % (chaine)


# ----------------------------------
def afficheType(variable):
    # muestra el tipo de variable
    print "type[%s]=%s" % (variable,type(variable))

# ----------------------------------
def f1(param):
    # suma 10 a param
    return param+10

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


# -------------------------------- programa principal ------------------------------------
# esto es un comentario
# variable utilizada sin haber sido declarada
nom="dupont"

# una salida a pantalla
print "nom=%s" % (nom)

# una lista con elementos de tipo diferente
liste=["un","deux",3,4]

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

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

# inicialización de 2 variables con una tupla
(chaine1,chaine2)=("chaine1","chaine2")

# concatenación de las 2 cadenas
chaine3=chaine1+chaine2

# visualización del resultado
print "[%s,%s,%s]" % (chaine1,chaine2,chaine3)

# uso de una función
affiche(chaine1)

# se puede conocer el tipo de una variable
afficheType(n)
afficheType(chaine1)
afficheType(liste)

# el tipo de una variable puede cambiar durante la ejecución
n="a change"
afficheType(n)

# una función puede devolver un resultado
res1=f1(4)
print "res1=%s" % (res1)

# una función puede devolver una lista de valores
(res1,res2,res3)=f2()
print "(res1,res2,res3)=[%s,%s,%s]" % (res1,res2,res3)

# se podrían haber almacenado estos valores en una variable
liste=f2()
for i in range(len(liste)):
    print "liste[%s]=%s" % (i, liste[i])

# pruebas
for i in range(len(liste)):
    # solo muestra las cadenas
    if (type(liste[i])=="str"):
        print "liste[%s]=%s" % (i,liste[i])

# otras pruebas
for i in range(len(liste)):
    # solo muestra los enteros >10
    if (type(liste[i])=="int" and liste[i]>10):
        print "liste[%s]=%s" % (i,liste[i])

# un bucle 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] #suma = suma + t[i]
    i+=1 #i = i + 1
print "somme=%s" % (somme)
# fin del programa

Nota:

línea 1: un comentario especial que sirve para declarar el tipo de codificación del script, en este caso UTF-8. Esto depende del editor de texto utilizado. Aquí con Notepad++:

línea 4: la palabra clave def define una función;
líneas 5-6: el contenido de la función. Está sangrado a la derecha una tabulación. Es esta sangría, junto con el carácter : de la instrucción def, la que define el contenido de la función. Esto es válido para todas las instrucciones que tienen contenido: if, else, while, for, try, except;
línea 12: Python gestiona internamente el tipo de las variables. Se puede conocer el tipo de una variable con la función type(variable), que devuelve una variable de tipo «type». La expresión «%s» % (type(variable)) es una cadena de caracteres que representa el tipo de la variable;
línea 25: el programa principal. Este viene después de la definición de todas las funciones del script. Su contenido no está sangrado;
línea 28: en Python no se declaran las variables. Python distingue entre mayúsculas y minúsculas. La variable Nombre es diferente de la variable nombre. Una cadena de caracteres puede ir entre comillas " o entre apóstrofos '. Por lo tanto, se puede escribir 'dupont' o "dupont";
línea 31: la expresión «xxxx%syyyy%szzzz» % (100, 200) es la cadena de caracteres «xxxx100yyy200szzzz», en la que cada %s se ha sustituido por un elemento de la tupla. %s es el formato de visualización de las cadenas de caracteres. Existen otros formatos;
línea 34: hay una diferencia entre una tupla (1,2,3) (fíjate en los paréntesis) y una lista [1,2,3] (fíjate en los corchetes). La tupla no es modificable, mientras que la lista sí lo es. En ambos casos, el elemento n.º i se denota como [i];
línea 40: range(n) es la tupla (0,1,2,...,n-1);
línea 74: len(var) es el número de elementos de la colección var (tupla, lista, diccionario, ...);
línea 86: los demás operadores booleanos son or y not.

Los resultados en pantalla son los siguientes:

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. Cambios de tipo

Aquí nos centramos en los cambios de tipo con datos de tipo str (cadena de caracteres), int (entero), float (real) y bool (booleano).

El programa (bases_01b)


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

# cambios 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)

# gestión de errores de cambio de tipo
try:
    x=int("abc")
    print x, type(x)
except ValueError, erreur:
    print erreur

# casos diversos del 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)

Son posibles numerosos cambios de tipo. Algunos pueden fallar, como el de las líneas 45-49, que intentan convertir la cadena «abc» en un entero. Hemos gestionado el error con una estructura try / except. Una forma general de esta estructura es la siguiente:


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

Si alguna de las acciones del try lanza una excepción (señala un error), se pasa inmediatamente a la cláusula except. Si las acciones del try no lanzan ninguna excepción, se ignora la cláusula except. Los atributos Exception y Message de la instrucción except son opcionales. Cuando están presentes, Exception especifica el tipo de excepción interceptada por la instrucción except y Message contiene el mensaje de error relacionado con la excepción. Puede haber varias instrucciones except, si se desea gestionar diferentes tipos de excepción en el mismo try.

La instrucción finally es opcional. Si está presente, las acciones del finally siempre se ejecutan, haya habido o no una excepción.

Volveremos sobre las excepciones más adelante.

Las líneas 52-61 muestran diversos intentos de convertir un dato de tipo str, int, float, NoneType, en booleano. Esto siempre es posible. Las reglas son las siguientes:

bool(int i) es False si i es 0, True en todos los demás casos;
bool(float f) devuelve False si f es 0.0, y True en todos los demás casos;
bool(str cadena) es False si cadena tiene 0 caracteres, True en todos los demás casos;
bool(None) es False. None es un valor especial que significa que la variable existe pero no tiene valor.

Los resultados en pantalla son los siguientes:

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. El ámbito de las variables

Programa (bases_02)


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

# ámbito de las variables
def f1():
    # se utiliza la variable global i
    global i
    i+=1
    j=10
    print "f1[i,j]=[%s,%s]" % (i,j)

def f2():
    # se utiliza la variable global i
    global i
    i+=1
    j=20
    print "f2[i,j]=[%s,%s]" % (i,j)

def f3():
    # se utiliza una variable local i
    i=1
    j=30
    print "f3[i,j]=[%s,%s]" % (i,j)
  
# pruebas
i=0
j=0 # estas dos variables no son conocidas por una función f
    # a menos que esta las declare explícitamente mediante la instrucción global
    # que quiere utilizarlas
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:

el script muestra el uso de la variable i, declarada como global en las funciones f1 y f2. En este caso, el programa principal y las funciones f1 y f2 comparten la misma variable i.

3.4. Listas, tuplas y diccionarios

3.4.1. Listas unidimensionales

Programa (bases_03)


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

# listas unidimensionales
# inicialización
list1=[0,1,2,3,4,5]

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

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

# añadir dos elementos
list1[len(list1):]=[10,11]
print ("%s") % (list1)

# eliminación de los dos últimos elementos
list1[len(list1)-2:]=[]
print ("%s") % (list1)

# adición de una tupla al principio de la lista
list1[:0]=[-10, -11, -12]
print ("%s") % (list1)

# inserción de dos elementos en el centro de la lista
list1[3:3]=[100,101]
print ("%s") % (list1)

# eliminación de dos elementos en el centro de la lista
list1[3:4]=[]
print ("%s") % (list1)

Notas:

la notación matriz[i:j] designa los elementos i a j-1 de la matriz;
la notación [i:] designa los elementos i y siguientes de la matriz;
la notación [:i] designa los elementos del 0 al i-1 de la matriz;
línea 20: print (%s) % (list1) muestra la cadena 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]

El código anterior se puede escribir de otra forma (bases_03b) utilizando ciertos métodos de las listas:


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

# listas unidimensionales

# inicialización
list1=[0,1,2,3,4,5]

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

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

# adición de dos elementos
list1.extend([10,11])
print ("%s") % (list1)

# eliminación de los dos últimos elementos
del list1[len(list1)-2:]
print ("%s") % (list1)

# adición de una tupla al principio de la lista
for i in (-12, -11, -10):
    list1.insert(0,i)
print ("%s") % (list1)

# inserción en el centro de la lista
for i in (101,100):
    list1.insert(3,i)
print ("%s") % (list1)

# eliminación en el centro de la lista
del list1[3:4]
print ("%s") % (list1)

Los resultados obtenidos son los mismos que con el anterior version.

3.4.2. El diccionario

El programa (bases_04)


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

def existe(conjoints,mari):
    # comprueba si la clave «marido» existe en el diccionario «cónyuges»
    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
# diccionarios
conjoints={"Pierre":"Gisele", "Paul":"Virginie", "Jacques":"Lucette","Jean":""}

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

# lista de claves del diccionario
print "liste des cles-------------"
cles=conjoints.keys()
print ("%s") % (cles)

# lista de valores del diccionario
print "liste des valeurs------------"
valeurs=conjoints.values()
print ("%s") % (valeurs)

# búsqueda de una clave
existe(conjoints,"Jacques")
existe(conjoints,"Lucette")
existe(conjoints,"Jean")

# eliminación de una clave-valor
del (conjoints["Jean"])
print "Nombre d'elements du dictionnaire : %s " % (len(conjoints))
print ("%s") % (conjoints)

Notas:

línea 17: conjoints.items() devuelve la lista de pares (clave, valor) del diccionario conjoints;
línea 22: conjoints.keys() devuelve las claves del diccionario conjoints;
línea 27: conjoints.values() devuelve los valores del diccionario conjoints;
línea 7: conjoints.has_key(marido) devuelve True si la clave marido existe en el diccionario conyuges, False en caso contrario;
línea 38: un diccionario se puede mostrar en una sola línea.

Los 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. Las tuplas

Programa (bases_05)


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

# tuplas
# inicialización
tab1=(0,1,2,3,4,5)

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

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

# modificación de un elemento
tab1[0]=-1

Los 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:

líneas 15-18 de los resultados: muestran que una tupla no se puede modificar.

3.4.4. Listas multidimensionales

Programa (bases_06)


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

# listas multidimensionales

# inicialización
multi=[[0,1,2], [10,11,12,13], [20,21,22,23,24]]

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

# diccionarios multidimensionales
# inicialización
multi={"zero":[0,1], "un":[10,11,12,13], "deux":[20,21,22,23,24]}

# recorrido
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 canales y listas

Programa (bases_07)


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

# cadena a lista
chaine='1:2:3:4'
tab=chaine.split(':')
print type(tab)

# visualización de lista
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

# de lista a cadena
chaine2=":".join(tab)
print "chaine2=%s" % (chaine2)

# añadamos un campo vacío
chaine+=":"
print "chaine=%s" % (chaine)
tab=chaine.split(":")

# visualización de lista
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

# añadamos de nuevo un campo vacío
chaine+=":"
print "chaine=%s" % (chaine)
tab=chaine.split(":")

# visualización de lista
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

Notas:

línea 5: el método chaine.split(separador) divide la cadena de caracteres cadena en elementos separados por separador y los devuelve en forma de lista. Así, la expresión '1:2:3:4'.split(":") tiene como valor la lista ('1','2','3','4');
línea 13: «separador».join(lista) tiene como valor la cadena 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. Las expresiones regulares

Programa (bases_09)


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

import re

# --------------------------------------------------------------------------
def compare(modele,chaine):
    # compara la cadena cadena con el patrón patrón
    # visualización de 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)


# expresiones regulares en Python
# Recuperar los diferentes campos de una cadena
# el patrón: una secuencia de dígitos rodeada de caracteres cualquiera
# solo queremos recuperar la secuencia de números
modele=r"^.*?(\d+).*?$"

# comparamos la cadena con el patrón
compare(modele,"xyz1234abcd")
compare(modele,"12 34")
compare(modele,"abcd")

# el patrón: una secuencia de dígitos rodeada de caracteres arbitrarios
# queremos la secuencia de números, así como los campos que la preceden y la siguen
modele=r"^(.*?)(\d+)(.*?)$"

# comparamos la cadena con el patrón
compare(modele,"xyz1234abcd")
compare(modele,"12 34")
compare(modele,"abcd")

# el patrón: una fecha en 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")

# el patrón: un 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")
# fin

Notas:

fíjate en el módulo importado en la línea 3. Es el que contiene las funciones de gestión de expresiones regulares;
línea 10: la comparación de una cadena con una expresión regular (patrón) devuelve el valor booleano True si la cadena coincide con el patrón, y False en caso contrario;
línea 12: match.groups() es una tupla cuyos elementos son las partes de la cadena que se corresponden con los elementos de la expresión regular entre paréntesis. En el patrón:
^.*?(\d+).*?, match.groups() será una tupla de un elemento;
^(.*?)(\d+)(.*?)$, match.groups() será una 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 paso de los parámetros de las funciones

Programa (bases_10)


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

def f1(a):
    a=2

def f2(a,b):
    a=2
    b=3
    return (a,b)
  
# ------------------------ mano
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:

todo es un objeto en Python. Algunos objetos se denominan «inmutables»: no se pueden modificar. Es el caso de los números, las cadenas de caracteres y las tuplas. Cuando se pasan objetos de Python como parámetros a funciones, se pasan sus referencias, salvo si dichos objetos son «inmutables», en cuyo caso se pasa el valor del objeto;
las funciones f1 (línea 3) y f2 (línea 6) pretenden ilustrar el paso de un parámetro de salida. Se quiere que el parámetro efectivo de una función sea modificado por la función;
líneas 3-4: la función f1 modifica su parámetro formal a. Queremos saber si el parámetro efectivo también se modificará.
líneas 12-13: el parámetro efectivo es x=1. El resultado de la línea 1 muestra que el parámetro efectivo no se modifica. Por lo tanto, el parámetro efectivo x y el parámetro formal a son dos objetos diferentes;
líneas 6-9: la función f2 modifica sus parámetros formales a y b, y los devuelve como resultados;
líneas 15-16: se pasan a f2 los parámetros efectivos (x,y) y el resultado de f2 se asigna a (x,y). La línea 2 de los resultados muestra que los parámetros efectivos (x,y) han sido modificados.

De ello se deduce que, cuando los objetos «inmutables» son parámetros de salida, deben formar parte de los resultados devueltos por la función.

3.7. Los archivos de texto

Programa (bases_11)


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

import sys

# procesamiento secuencial de un archivo de texto
# este es un conjunto de líneas con el formato login:pwd:uid:gid:infos:dir:shell
# cada línea se introduce en un diccionario con el formato login => [uid,gid,infos,dir,shell]

# --------------------------------------------------------------------------
def afficheInfos(dico,cle):
    # muestra el valor asociado a la clave en el diccionario si existe
    valeur=None
    if dico.has_key(cle):
        valeur=dico[cle]
    if 'list' in str(type(valeur)):
        print "[{0},{1}]".format(cle,":".join(valeur))
    else:
        # la clave no es una clave del diccionario dico
        print "la cle [{0}] n'existe pas".format(cle)           


def cutNewLineChar(ligne):
    # se elimina el marcador de fin de línea si existe
    l=len(ligne);
    while(ligne[l-1]=="\n" or ligne[l-1]=="\r"):
        l-=1
    return(ligne[0:l]);
    
# se establece el nombre del archivo
INFOS="infos.txt"

# se abre en modo de creación
try:
    fic=open(INFOS,"w")
except:
    print "Erreur d'ouverture du fichier INFOS en écriture\n"
    sys.exit()

# se genera un contenido arbitrario
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")

# se cierra el archivo
fic.close()

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

# diccionario vacío al inicio
dico={}

# lectura de línea  
ligne=fic.readline()  
while(ligne!=''):
    # se elimina el carácter de fin de línea
    ligne=cutNewLineChar(ligne)
  
    # se coloca la línea en una matriz
    infos=ligne.split(":")
  
    # se recupera el nombre de usuario
    login=infos[0]
  
    # se eliminan los dos primeros elementos [login,pwd]
    infos[0:2]=[]
  
    # se crea una entrada en el diccionario
    dico[login]=infos
  
    # lectura de línea  
    ligne=fic.readline()  

# se cierra el archivo
fic.close()

# explotación del diccionario
afficheInfos(dico,"login10")
afficheInfos(dico,"X")

Notas:

línea 37: para terminar el script en medio del código.

Resultados

El archivo 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 en pantalla:

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