3. Основи

3.1. Приклад програми на Python

Нижче наведено програму, що демонструє основні особливості Python.

Програма (bases_01)


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

# ----------------------------------
def affiche(chaine):
    # відображає рядок
    print "chaine=%s" % (chaine)


# ----------------------------------
def afficheType(variable):
    # відображає тип змінної
    print "type[%s]=%s" % (variable,type(variable))

# ----------------------------------
def f1(param):
    # додає 10 до параметра
    return param+10

# ----------------------------------
def f2():
    # повертає 3 значення
    return ("un",0,100);


# -------------------------------- головна програма ------------------------------------
# це коментар
# змінна, що використовується без оголошення
nom="dupont"

# виведення на екран
print "nom=%s" % (nom)

# список з елементами різних типів
liste=["un","deux",3,4]

# кількість елементів
n=len(liste)

# цикл
for i in range(n):
  print "liste[%d]=%s" % (i,liste[i])

# ініціалізація двох змінних за допомогою кортежу
(chaine1,chaine2)=("chaine1","chaine2")

# об'єднання двох рядків
chaine3=chaine1+chaine2

# виведення результату
print "[%s,%s,%s]" % (chaine1,chaine2,chaine3)

# використання функції
affiche(chaine1)

# тип змінної може бути відомим
afficheType(n)
afficheType(chaine1)
afficheType(liste)

# тип змінної може змінюватися під час виконання
n="a change"
afficheType(n)

# функція може повертати результат
res1=f1(4)
print "res1=%s" % (res1)

# функція може повертати список значень
(res1,res2,res3)=f2()
print "(res1,res2,res3)=[%s,%s,%s]" % (res1,res2,res3)

# ці значення можна було б зберегти у змінній
liste=f2()
for i in range(len(liste)):
    print "liste[%s]=%s" % (i, liste[i])

# тести
for i in range(len(liste)):
    # відображає лише рядки
    if (type(liste[i])=="str"):
        print "liste[%s]=%s" % (i,liste[i])

# інші тести
for i in range(len(liste)):
    # виводить лише цілі числа >10
    if (type(liste[i])=="int" and liste[i]>10):
        print "liste[%s]=%s" % (i,liste[i])

# цикл 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] #сума = сума + t[i]
    i+=1 #i = i + 1
print "somme=%s" % (somme)
# кінець програми

Зверніть увагу:

рядок 1: спеціальний коментар, що використовується для оголошення типу кодування скрипта, у даному випадку UTF-8. Це залежить від використовуваного текстового редактора. У даному випадку з Notepad++:

рядок 4: ключове слово def визначає функцію;
рядки 5–6: вміст функції. Він відступлений вправо на один табулятор. Саме цей відступ у поєднанні зі символом : у операторі def визначає вміст функції. Це стосується всіх операторів, що містять вміст: if, else, while, for, try, except;
рядок 12: Python внутрішньо керує типами змінних. Тип змінної можна дізнатися за допомогою функції type(variable), яка повертає змінну типу 'type'. Вираз '%s' % (type(variable)) — це рядок символів, що позначає тип змінної;
рядок 25: головна програма. Вона йде після визначення всіх функцій скрипта. Її вміст не має відступів;
рядок 28: у Python змінні не оголошуються. Python розрізняє регістр. Змінна Nom відрізняється від змінної nom. Строку можна взяти в лапки " або апострофи '. Отже, можна написати 'dupont' або "dupont";
рядок 31: вираз "xxxx%syyyy%szzzz" % (100, 200) — це рядок "xxxx100yyy200szzzz", у якому кожне %s замінено на елемент кортежу. %s — це формат відображення рядків. Існують й інші формати;
рядок 34: існує різниця між кортежем (1,2,3) (зверніть увагу на дужки) та списком [1,2,3] (зверніть увагу на квадратні дужки). Кортеж є незмінним, тоді як список — змінним. В обох випадках елемент № i позначається як [i];
рядок 40: range(n) — це кортеж (0,1,2,...,n-1);
рядок 74: len(var) — це кількість елементів колекції var (кортеж, список, словник тощо);
рядок 86: інші булеві оператори — це or та not.

Результати на екрані такі:

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. Зміни типів

Тут ми розглянемо зміни типів даних типу str (рядок символів), int (ціле число), float (дійсне число), bool (булеве значення).

Програма (bases_01b)


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

# зміна типів
# 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)

# обробка помилок при зміні типу
try:
    x=int("abc")
    print x, type(x)
except ValueError, erreur:
    print erreur

# різні випадки використання булевого типу
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)

Можливі численні зміни типів. Деякі з них можуть завершитися невдачею, як-от у рядках 45–49, де робиться спроба перетворити рядок «abc» на ціле число. Помилку було оброблено за допомогою структури try / except. Загальний вигляд цієї структури такий:


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

Якщо одна з дій блоку try викликає виняток (повідомляє про помилку), виконується негайний перехід до блоку except. Якщо дії блоку try не викликають винятку, блок except ігнорується. Атрибути Exception та Message оператора except є необов’язковими. Якщо вони присутні, Exception визначає тип винятку, перехопленого інструкцією except, а Message містить повідомлення про помилку, пов’язане з винятком. Може бути кілька команд except, якщо потрібно обробляти різні типи винятків у тому самому try.

Інструкція finally є необов’язковою. Якщо вона присутня, дії finally виконуються завжди, незалежно від того, чи стався виняток.

Ми повернемося до винятків трохи пізніше.

У рядках 52–61 показано різні спроби перетворення даних типів str, int, float, NoneType у булеві значення. Це завжди можливо. Правила такі:

bool(int i) дорівнює False, якщо i дорівнює 0, і True у всіх інших випадках;
bool(float f) дорівнює False, якщо f дорівнює 0.0, і True у всіх інших випадках;
bool(str chaine) дорівнює False, якщо chaine має 0 символів, True у всіх інших випадках;
bool(None) дорівнює False. None — це спеціальне значення, яке означає, що змінна існує, але не має значення.

Результати на екрані такі:

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. Область дії змінних

Програма (bases_02)


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

# область дії змінних
def f1():
    # використовується глобальна змінна i
    global i
    i+=1
    j=10
    print "f1[i,j]=[%s,%s]" % (i,j)

def f2():
    # використання глобальної змінної i
    global i
    i+=1
    j=20
    print "f2[i,j]=[%s,%s]" % (i,j)

def f3():
    # використовується локальна змінна i
    i=1
    j=30
    print "f3[i,j]=[%s,%s]" % (i,j)
  
# тести
i=0
j=0 # ці дві змінні не відомі функції f
    # лише якщо вона явно оголошена за допомогою оператора global
    # що вона хоче їх використовувати
f1()
f2()
f3()
print "test[i,j]=[%s,%s]" % (i,j)

Результати

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

Примітки:

скрипт демонструє використання змінної i, оголошеної як глобальна у функціях f1 та f2. У цьому випадку головна програма та функції f1 і f2 використовують одну й ту саму змінну i.

3.4. Списки, кортежі та словники

3.4.1. Одновимірні списки

Програма (bases_03)


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

# одновимірні списки
# ініціалізація
list1=[0,1,2,3,4,5]

# обхід — 1
print "list1 a %s elements" % (len(list1))
for i in range(len(list1)):
    print "list1[%s]=%s" % (i, list1[i])

list1[1]=10;
# обхід — 2
print "list1 a %s elements" % (len(list1))
for element in list1:
    print element

# додавання двох елементів
list1[len(list1):]=[10,11]
print ("%s") % (list1)

# видалення двох останніх елементів
list1[len(list1)-2:]=[]
print ("%s") % (list1)

# додавання кортежу на початок списку
list1[:0]=[-10, -11, -12]
print ("%s") % (list1)

# вставлення двох елементів у середину списку
list1[3:3]=[100,101]
print ("%s") % (list1)

# видалення двох елементів із середини списку
list1[3:4]=[]
print ("%s") % (list1)

Примітки:

запис масив[i:j] позначає елементи від i до j-1 масиву;
позначення [i:] позначає елементи масиву, починаючи з i;
запис [:i] позначає елементи масиву від 0 до i-1;
рядок 20: print (%s) % (list1) виводить рядок: «[ list1[0], list1[2], ..., list1[n-1]]».

Результати

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]

Попередній код можна записати інакше (bases_03b), використовуючи певні методи списків:


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

# одновимірні списки

# ініціалізація
list1=[0,1,2,3,4,5]

# обхід — 1
print "list1 a %s elements" % (len(list1))
for i in range(len(list1)):
    print "list1[%s]=%s" % (i, list1[i])

list1[1]=10
# обхід — 2
print "list1 a %s elements" % (len(list1))
for element in list1:
    print element

# додавання двох елементів
list1.extend([10,11])
print ("%s") % (list1)

# видалення двох останніх елементів
del list1[len(list1)-2:]
print ("%s") % (list1)

# додавання кортежу на початок списку
for i in (-12, -11, -10):
    list1.insert(0,i)
print ("%s") % (list1)

# вставка в середину списку
for i in (101,100):
    list1.insert(3,i)
print ("%s") % (list1)

# видалення з середини списку
del list1[3:4]
print ("%s") % (list1)

Отримані результати такі самі, як і в попередній версії.

3.4.2. Словник

Програма (bases_04)


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

def existe(conjoints,mari):
    # перевіряє, чи існує ключ «mari» у словнику «conjoints»
    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)


# ----------------------------- Головна
# словники
conjoints={"Pierre":"Gisele", "Paul":"Virginie", "Jacques":"Lucette","Jean":""}

# проходження — 1
print "Nombre d'elements du dictionnaire : %s " % (len(conjoints))
for (cle,valeur) in conjoints.items():
    print "conjoints[%s]=%s" % (cle,valeur)

# список ключів словника
print "liste des cles-------------"
cles=conjoints.keys()
print ("%s") % (cles)

# список значень словника
print "liste des valeurs------------"
valeurs=conjoints.values()
print ("%s") % (valeurs)

# пошук ключа
existe(conjoints,"Jacques")
existe(conjoints,"Lucette")
existe(conjoints,"Jean")

# видалення ключа-значення
del (conjoints["Jean"])
print "Nombre d'elements du dictionnaire : %s " % (len(conjoints))
print ("%s") % (conjoints)

Примітки:

рядок 17: conjoints.items() повертає список пар (ключ, значення) зі з'єднаного словника;
рядок 22: conjoints.keys() повертає ключі словника conjoints;
рядок 27: conjoints.values() повертає значення словника «conjoints»;
рядок 7: conjoints.has_key(mari) повертає True, якщо ключ mari існує у словнику conjoints, False — в іншому випадку;
рядок 38: словник можна відобразити в одному рядку.

Результати

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. Кортежі

Програма (bases_05)


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

# кортежі
# ініціалізація
tab1=(0,1,2,3,4,5)

# обхід — 1
print "tab1 a %s elements" % (len(tab1))
for i in range(len(tab1)):
    print "tab1[%s]=%s" % (i, tab1[i])

# обхід — 2
print "tab1 a %s elements" % (len(tab1))
for element in tab1:
    print element

# зміна елемента
tab1[0]=-1

Результати

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

Примітки:

рядки 15–18 результатів: показують, що кортеж не можна змінити.

3.4.4. Багатовимірні списки

Програма (bases_06)


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

# багатовимірні списки

# ініціалізація
multi=[[0,1,2], [10,11,12,13], [20,21,22,23,24]]

# проходження
for i1 in range(len(multi)):
    for i2 in range(len(multi[i1])):
        print "multi[%s][%s]=%s" % (i1,i2,multi[i1][i2])

# багатовимірні словники
# ініціалізація
multi={"zero":[0,1], "un":[10,11,12,13], "deux":[20,21,22,23,24]}

# обхід
for (cle,valeur) in multi.items():
    for i2 in range(len(multi[cle])):
        print "multi[%s][%s]=%s" % (cle,i2,multi[cle][i2])

Результати

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. Зв’язки між ланцюгами та списками

Програма (bases_07)


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

# перетворення рядка у список
chaine='1:2:3:4'
tab=chaine.split(':')
print type(tab)

# виведення списку
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

# перетворення списку в рядок
chaine2=":".join(tab)
print "chaine2=%s" % (chaine2)

# додамо порожнє поле
chaine+=":"
print "chaine=%s" % (chaine)
tab=chaine.split(":")

# відображення списку
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

# додамо ще одне порожнє поле
chaine+=":"
print "chaine=%s" % (chaine)
tab=chaine.split(":")

# відображення списку
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

Примітки:

рядок 5: метод chaine.split(роздільник) розбиває рядок chaine на елементи, розділені séparateur, і повертає їх у вигляді списку. Таким чином, вираз '1:2:3:4'.split(":") має значення у вигляді списку ('1','2','3','4');
рядок 13: значення виразу 'separateur'.join(liste) — це рядок 'список[0]+роздільник+список[1]+роздільник+...'.

Результати

<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. Регулярні вирази

Програма (bases_09)


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

import re

# --------------------------------------------------------------------------
def compare(modele,chaine):
    # порівняння рядка «chaîne» із шаблоном «modele»
    # відображення результатів
    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)


# регулярні вирази в Python
# витяг різних полів із рядка
# шаблон: послідовність цифр, оточена довільними символами
# потрібно витягти лише послідовність цифр
modele=r"^.*?(\d+).*?$"

# порівнюємо рядок із шаблоном
compare(modele,"xyz1234abcd")
compare(modele,"12 34")
compare(modele,"abcd")

# шаблон: послідовність цифр, оточена довільними символами
# потрібна послідовність цифр, а також поля, що йдуть перед нею та після неї
modele=r"^(.*?)(\d+)(.*?)$"

# порівнюємо рядок із шаблоном
compare(modele,"xyz1234abcd")
compare(modele,"12 34")
compare(modele,"abcd")

# шаблон — дата у форматі дд/мм/рр
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")

# шаблон — десяткове число
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")
# кінець

Примітки:

зверніть увагу на імпортований модуль у рядку 3. Саме він містить функції для роботи з регулярними виразами;
рядок 10: порівняння рядка з регулярним виразом (шаблоном) повертає логічне значення True, якщо рядок відповідає шаблону, і False — у протилежному випадку;
рядок 12: match.groups() — це кортеж, елементи якого є частинами рядка, що відповідають елементам регулярного виразу, взятим у дужки. У шаблоні:
^.*?(\d+).*?, match.groups() буде кортежем з одного елемента;
^(.*?)(\d+)(.*?)$, match.groups() буде кортежем із 3 елементів.

Результати

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. Спосіб передачі параметрів функцій

Програма (bases_10)


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

def f1(a):
    a=2

def f2(a,b):
    a=2
    b=3
    return (a,b)
  
# ------------------------ головна
x=1
f1(x)
print "x=%s" % (x)
(x,y)=(-1,-1)
(x,y)=f2(x,y)
print "x=%s, y=%s" % (x,y)

Результати

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

Примітки:

у Python усе є об’єктом. Деякі об’єкти називаються «незмінними»: їх неможливо змінити. Це стосується чисел, рядків та кортежів. Коли об’єкти Python передаються як аргументи до функцій, передаються їхні посилання, за винятком випадків, коли ці об’єкти є «незмінними» — тоді передається саме значення об’єкта;
функції f1 (рядок 3) та f2 (рядок 6) мають на меті проілюструвати передачу вихідного параметра. Ми хочемо, щоб фактичний параметр функції був змінений самою функцією;
рядки 3–4: функція f1 змінює свій формальний параметр a. Потрібно з’ясувати, чи буде змінено також і фактичний параметр.
рядки 12–13: фактичним параметром є x=1. Результат рядка 1 показує, що фактичний параметр не змінюється. Отже, фактичний параметр x і формальний параметр a — це два різні об’єкти;
рядки 6–9: функція f2 змінює свої формальні параметри a та b і повертає їх як результати;
рядки 15–16: до функції f2 передаються фактичні параметри (x, y), а результат функції f2 записується в (x, y). Рядок 2 результатів показує, що фактичні параметри (x, y) були змінені.

Звідси випливає, що коли «незмінні» об’єкти є вихідними параметрами, вони повинні бути частиною результатів, що повертаються функцією.

3.7. Текстові файли

Програма (bases_11)


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

import sys

# послідовна обробка текстового файлу
# цей файл складається з рядків у форматі login:pwd:uid:gid:infos:dir:shell
# кожен рядок заноситься до словника у вигляді login => [uid,gid,infos,dir,shell]

# --------------------------------------------------------------------------
def afficheInfos(dico,cle):
    # виводить значення, пов’язане з ключем у словнику dico, якщо воно існує
    valeur=None
    if dico.has_key(cle):
        valeur=dico[cle]
    if 'list' in str(type(valeur)):
        print "[{0},{1}]".format(cle,":".join(valeur))
    else:
        # ключ не є ключем словника «dico»
        print "la cle [{0}] n'existe pas".format(cle)           


def cutNewLineChar(ligne):
    # видаляється позначка кінця рядка, якщо вона існує
    l=len(ligne);
    while(ligne[l-1]=="\n" or ligne[l-1]=="\r"):
        l-=1
    return(ligne[0:l]);
    
# встановлює ім’я файлу
INFOS="infos.txt"

# файл відкривається для створення
try:
    fic=open(INFOS,"w")
except:
    print "Erreur d'ouverture du fichier INFOS en écriture\n"
    sys.exit()

# генерується довільний вміст
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")

# файл закривається
fic.close()

# відкриваємо його для читання
try:
    fic=open(INFOS,"r")
except:
    print "Erreur d'ouverture du fichier INFOS en écriture\n"
    sys.exit()

# початково порожній словник
dico={}

# читання рядка  
ligne=fic.readline()  
while(ligne!=''):
    # видаляється символ кінця рядка
    ligne=cutNewLineChar(ligne)
  
    # заносимо рядок у масив
    infos=ligne.split(":")
  
    # отримано логін
    login=infos[0]
  
    # видаляємо два перші елементи [login,pwd]
    infos[0:2]=[]
  
    # створюємо запис у словнику
    dico[login]=infos
  
    # читання рядка  
    ligne=fic.readline()  

# закриваємо файл
fic.close()

# обробка словника
afficheInfos(dico,"login10")
afficheInfos(dico,"X")

Примітки:

рядок 37: щоб завершити скрипт посередині коду.

Результати

Файл 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

Результати на екрані:

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