3. Conceptos básicos

3.1. Un ejemplo de programa en Python

A continuación, se presenta un programa que muestra las características básicas 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 diferentes tipos
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 dos 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 números enteros mayores que 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 que se utilice. 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 hacia 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 se aplica a todas las instrucciones que tienen contenido: if, else, while, for, try, except;
línea 12: Python maneja 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 aparece 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 Nom es diferente de la variable nom. Una cadena de caracteres puede estar 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", donde cada %s ha sido reemplazado 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 enfocamos 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)

# manejo de errores de conversión de tipos
try:
    x=int("abc")
    print x, type(x)
except ValueError, erreur:
    print erreur

# casos diversos del tipo 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 a 49, que intentan convertir la cadena «abc» en un número entero. Hemos manejado 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 bloque «try» genera una excepción (indica un error), se pasa inmediatamente a la cláusula «except». Si las acciones del bloque «try» no generan ninguna excepción, se omite 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 manejar diferentes tipos de excepción en el mismo try.

La instrucción finally es opcional. Si está presente, las acciones de la instrucción finally siempre se ejecutan, independientemente de si hubo una excepción o no.

Volveremos a hablar de las excepciones más adelante.

Las líneas 52 a 61 muestran diversos intentos de convertir datos de tipo str, int, float y NoneType en valores booleanos. Esto siempre es posible. Las reglas son las siguientes:

bool(int i) es igual a False si i es igual a 0, y a True en todos los demás casos;
bool(float f) es igual a False si f es igual a 0.0, y a True en todos los demás casos;
bool(str cadena) es igual a False si cadena tiene 0 caracteres, y a 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 alcance de las variables

Programa (bases_02)


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

# alcance 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 desea 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

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

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

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

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

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

Notas:

la notación matriz[i:j] se refiere a los elementos del i al j-1 de la matriz;
la notación [i:] se refiere a los elementos i y siguientes de la matriz;
la notación [:i] se refiere a 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 manera (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

# agregar dos elementos
list1.extend([10,11])
print ("%s") % (list1)

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

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

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

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

Los resultados obtenidos son los mismos que con la versión anterior.

3.4.2. El diccionario

El programa (bases_04)


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

def existe(conjoints,mari):
    # verifica 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)


# ----------------------------- Principal
# 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 de conjuntos;
línea 22: conjoints.keys() devuelve las claves del diccionario «conjuntos»;
línea 27: conjoints.values() devuelve los valores del diccionario «conjuntos»;
línea 7: conjoints.has_key(marido) devuelve True si la clave mari existe en el diccionario conjoints, False en caso contrario;
línea 38: un diccionario puede mostrarse 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 cadenas 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)

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

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

# agregamos nuevamente 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 chaine en elementos separados por séparateur y los devuelve en forma de lista. Por lo tanto, la expresión '1:2:3:4'.split(":") tiene como valor la lista ('1','2','3','4');
línea 13: 'separateur'.join(liste) 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
# extraer los distintos campos de una cadena
# el patrón: una secuencia de números rodeada de cualquier carácter
# solo queremos extraer 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 números rodeada de caracteres cualquiera
# se quiere 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 para manejar las 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 coinciden 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 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)
  
# ------------------------ 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:

todo es un objeto en Python. Algunos objetos se denominan «inmutables»: no se pueden modificar. Este es el caso de los números, las cadenas de caracteres y las tuplas. Cuando los objetos de Python se pasan como parámetros a funciones, lo que se pasa son sus referencias, a menos que dichos objetos sean «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 busca 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 concluye 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 almacena 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 «dico» 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):
    # 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 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 de 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 tabla
    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()

# procesamiento del diccionario
afficheInfos(dico,"login10")
afficheInfos(dico,"X")

Notas:

línea 37: para finalizar 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`