3. Podstawy

3.1. Przykładowy program w języku Python

Poniżej znajduje się program przedstawiający podstawowe cechy języka Python.

Program (bases_01)


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

# ----------------------------------
def affiche(chaine):
    # wyświetla ciąg znaków
    print "chaine=%s" % (chaine)


# ----------------------------------
def afficheType(variable):
    # wyświetla typ zmiennej
    print "type[%s]=%s" % (variable,type(variable))

# ----------------------------------
def f1(param):
    # dodaje 10 do parametru
    return param+10

# ----------------------------------
def f2():
    # zwraca 3 wartości
    return ("un",0,100);


# -------------------------------- program główny ------------------------------------
# to jest komentarz
# zmienna użyta bez zadeklarowania
nom="dupont"

# wyświetlanie na ekranie
print "nom=%s" % (nom)

# lista zawierająca elementy różnych typów
liste=["un","deux",3,4]

# liczba elementów
n=len(liste)

# pętla
for i in range(n):
  print "liste[%d]=%s" % (i,liste[i])

# inicjalizacja dwóch zmiennych za pomocą krotki
(chaine1,chaine2)=("chaine1","chaine2")

# konkatenacja dwóch ciągów znaków
chaine3=chaine1+chaine2

# wyświetlenie wyniku
print "[%s,%s,%s]" % (chaine1,chaine2,chaine3)

# użycie funkcji
affiche(chaine1)

# typ zmiennej może być znany
afficheType(n)
afficheType(chaine1)
afficheType(liste)

# typ zmiennej może ulec zmianie w trakcie wykonywania
n="a change"
afficheType(n)

# funkcja może zwracać wynik
res1=f1(4)
print "res1=%s" % (res1)

# funkcja może zwracać listę wartości
(res1,res2,res3)=f2()
print "(res1,res2,res3)=[%s,%s,%s]" % (res1,res2,res3)

# wartości te można by zapisać w zmiennej
liste=f2()
for i in range(len(liste)):
    print "liste[%s]=%s" % (i, liste[i])

# testy
for i in range(len(liste)):
    # wyświetla tylko ciągi znaków
    if (type(liste[i])=="str"):
        print "liste[%s]=%s" % (i,liste[i])

# kolejne testy
for i in range(len(liste)):
    # wyświetla tylko liczby całkowite większe niż 10
    if (type(liste[i])=="int" and liste[i]>10):
        print "liste[%s]=%s" % (i,liste[i])

# pętla 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)
# koniec programu

Uwaga:

wiersz 1: specjalny komentarz służący do zadeklarowania typu kodowania skryptu, w tym przypadku UTF-8. Zależy to od używanego edytora tekstu. Tutaj w programie Notepad++:

wiersz 4: słowo kluczowe def definiuje funkcję;
wiersze 5–6: treść funkcji. Jest ona wcięta w prawo o jeden tabulator. To właśnie to wcięcie w połączeniu ze znakiem „:” w instrukcji def określa treść funkcji. Dotyczy to wszystkich instrukcji zawierających treść: if, else, while, for, try, except;
wiersz 12: Python wewnętrznie zarządza typami zmiennych. Typ zmiennej można sprawdzić za pomocą funkcji type(variable), która zwraca zmienną typu „type”. Wyrażenie „%s” % (type(zmienna)) to ciąg znaków reprezentujący typ zmiennej;
wiersz 25: program główny. Znajduje się on po zdefiniowaniu wszystkich funkcji skryptu. Jego treść nie jest wcięta;
wiersz 28: w języku Python nie deklaruje się zmiennych. Python rozróżnia wielkość liter. Zmienna Nom różni się od zmiennej nom. Ciąg znaków można ująć w cudzysłowy „” lub apostrofy '. Można więc zapisać 'dupont' lub „dupont”;
wiersz 31: wyrażenie „xxxx%syyyy%szzzz” % (100, 200) to ciąg znaków "xxxx100yyy200szzzz", w którym każde %s zostało zastąpione elementem krotki. %s to format wyświetlania ciągów znaków. Istnieją również inne formaty;
wiersz 34: istnieje różnica między krotką (1,2,3) (zwróć uwagę na nawiasy) a listą [1,2,3] (zwróć uwagę na nawiasy kątowe). Krotka jest niezmienna, podczas gdy lista jest zmienna. W obu przypadkach element o numerze i jest oznaczony jako [i];
wiersz 40: range(n) to krotka (0,1,2,...,n-1);
wiersz 74: len(var) to liczba elementów zbioru var (krotka, lista, słownik itp.);
wiersz 86: pozostałe operatory boolowskie to or i not.

Wyniki wyświetlane na ekranie są następujące:

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. Zmiany typów

W tym miejscu skupiamy się na zmianach typów danych typu str (ciąg znaków), int (liczba całkowita), float (liczba zmiennoprzecinkowa) oraz bool (wartość logiczna).

Program (bases_01b)


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

# zmiany typu
# 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)

# obsługa błędów związanych ze zmianą typu
try:
    x=int("abc")
    print x, type(x)
except ValueError, erreur:
    print erreur

# różne przypadki typu bool
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)

Możliwych jest wiele zmian typów. Niektóre z nich mogą zakończyć się niepowodzeniem, jak na przykład te w wierszach 45–49, gdzie próbuje się przekształcić ciąg znaków „abc” w liczbę całkowitą. Błąd ten został obsłużony za pomocą struktury try / except. Ogólny kształt tej struktury jest następujący:


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

Jeśli którekolwiek z działań w bloku try wygeneruje wyjątek (zgłosi błąd), następuje natychmiastowe przejście do klauzuli except. Jeśli działania w bloku try nie wygenerują wyjątku, klauzula except jest pomijana. Atrybuty Exception i Message instrukcji except są opcjonalne. Gdy są obecne, Exception określa typ wyjątku przechwyconego przez instrukcję except, a Message zawiera komunikat o błędzie związany z wyjątkiem. Może występować wiele instrukcji except, jeśli chce się obsługiwać różne typy wyjątków w tej samej instrukcji try.

Instrukcja finally jest opcjonalna. Jeśli występuje, działania określone w instrukcji finally są zawsze wykonywane, niezależnie od tego, czy wystąpił wyjątek, czy nie.

Do kwestii wyjątków powrócimy nieco później.

Wiersze 52–61 przedstawiają różne próby przekształcenia danych typu str, int, float, NoneType na wartości logiczne. Jest to zawsze możliwe. Zasady są następujące:

bool(int i) ma wartość False, jeśli i wynosi 0, a True we wszystkich pozostałych przypadkach;
bool(float f) ma wartość False, jeśli f wynosi 0,0, a True we wszystkich pozostałych przypadkach;
Funkcja bool(str łańcuch) zwraca wartość False, jeśli łańcuch ma 0 znaków, a True we wszystkich pozostałych przypadkach;
bool(None) ma wartość False. None to wartość specjalna oznaczająca, że zmienna istnieje, ale nie ma wartości.

Wyniki wyświetlane na ekranie są następujące:

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. Zakres zmiennych

Program (bases_02)


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

# zakres zmiennych
def f1():
    # używa się zmiennej globalnej i
    global i
    i+=1
    j=10
    print "f1[i,j]=[%s,%s]" % (i,j)

def f2():
    # używa się zmiennej globalnej i
    global i
    i+=1
    j=20
    print "f2[i,j]=[%s,%s]" % (i,j)

def f3():
    # użyto zmiennej lokalnej i
    i=1
    j=30
    print "f3[i,j]=[%s,%s]" % (i,j)
  
# testy
i=0
j=0 # te dwie zmienne nie są znane funkcji f
    # tylko wtedy, gdy funkcja ta jawnie zadeklaruje je za pomocą instrukcji global
    # że zamierza z nich korzystać
f1()
f2()
f3()
print "test[i,j]=[%s,%s]" % (i,j)

Wyniki

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

Uwagi:

skrypt pokazuje wykorzystanie zmiennej i, zadeklarowanej jako globalna w funkcjach f1 i f2. W tym przypadku program główny oraz funkcje f1 i f2 współdzielą tę samą zmienną i.

3.4. Listy, krotki i słowniki

3.4.1. Listy jednowymiarowe

Program (bases_03)


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

# listy jednowymiarowe
# inicjalizacja
list1=[0,1,2,3,4,5]

# przeglądanie – 1
print "list1 a %s elements" % (len(list1))
for i in range(len(list1)):
    print "list1[%s]=%s" % (i, list1[i])

list1[1]=10;
# przeglądanie – 2
print "list1 a %s elements" % (len(list1))
for element in list1:
    print element

# dodanie dwóch elementów
list1[len(list1):]=[10,11]
print ("%s") % (list1)

# usunięcie dwóch ostatnich elementów
list1[len(list1)-2:]=[]
print ("%s") % (list1)

# dodanie krotki na początku listy
list1[:0]=[-10, -11, -12]
print ("%s") % (list1)

# wstawienie dwóch elementów w środku listy
list1[3:3]=[100,101]
print ("%s") % (list1)

# usunięcie dwóch elementów ze środka listy
list1[3:4]=[]
print ("%s") % (list1)

Uwagi:

notacja tablica[i:j] oznacza elementy od i do j-1 tablicy;
notacja [i:] oznacza elementy od i oraz kolejne w tablicy;
zapis [:i] oznacza elementy tablicy od 0 do i-1;
wiersz 20: print (%s) % (list1) wyświetla ciąg znaków: „[ list1[0], list1[2], ..., list1[n-1]]”.

Wyniki

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]

Powyższy kod można zapisać inaczej (bases_03b), korzystając z niektórych metod list:


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

# listy jednowymiarowe

# inicjalizacja
list1=[0,1,2,3,4,5]

# przeglądanie – 1
print "list1 a %s elements" % (len(list1))
for i in range(len(list1)):
    print "list1[%s]=%s" % (i, list1[i])

list1[1]=10
# przeglądanie – 2
print "list1 a %s elements" % (len(list1))
for element in list1:
    print element

# dodanie dwóch elementów
list1.extend([10,11])
print ("%s") % (list1)

# usunięcie dwóch ostatnich elementów
del list1[len(list1)-2:]
print ("%s") % (list1)

# dodanie krotki na początku listy
for i in (-12, -11, -10):
    list1.insert(0,i)
print ("%s") % (list1)

# wstawienie w środku listy
for i in (101,100):
    list1.insert(3,i)
print ("%s") % (list1)

# usunięcie w środku listy
del list1[3:4]
print ("%s") % (list1)

Uzyskane wyniki są takie same jak w poprzedniej wersji.

3.4.2. Słownik

Program (bases_04)


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

def existe(conjoints,mari):
    # sprawdza, czy klucz „mari” występuje w słowniku „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)


# ----------------------------- Główna
# słowniki
conjoints={"Pierre":"Gisele", "Paul":"Virginie", "Jacques":"Lucette","Jean":""}

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

# lista kluczy słownika
print "liste des cles-------------"
cles=conjoints.keys()
print ("%s") % (cles)

# lista wartości słownika
print "liste des valeurs------------"
valeurs=conjoints.values()
print ("%s") % (valeurs)

# wyszukiwanie klucza
existe(conjoints,"Jacques")
existe(conjoints,"Lucette")
existe(conjoints,"Jean")

# usunięcie pary klucz-wartość
del (conjoints["Jean"])
print "Nombre d'elements du dictionnaire : %s " % (len(conjoints))
print ("%s") % (conjoints)

Uwagi:

wiersz 17: conjoints.items() zwraca listę par (klucz, wartość) ze słownika połączonego;
wiersz 22: conjoints.keys() zwraca klucze słownika conjoints;
wiersz 27: conjoints.values() zwraca wartości ze słownika conjoints;
wiersz 7: conjoints.has_key(mąż) zwraca True, jeśli klucz mari istnieje w słowniku conjoints, w przeciwnym razie zwraca False;
wiersz 38: słownik można wyświetlić w jednym wierszu.

Wyniki

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. Krotki

Program (bases_05)


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

# krotki
# inicjalizacja
tab1=(0,1,2,3,4,5)

# przeglądanie – 1
print "tab1 a %s elements" % (len(tab1))
for i in range(len(tab1)):
    print "tab1[%s]=%s" % (i, tab1[i])

# przeglądanie – 2
print "tab1 a %s elements" % (len(tab1))
for element in tab1:
    print element

# modyfikacja elementu
tab1[0]=-1

Wyniki

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

Uwagi:

wiersze 15–18 wyników: pokazują, że krotki nie można modyfikować.

3.4.4. Listy wielowymiarowe

Program (bases_06)


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

# listy wielowymiarowe

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

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

# słowniki wielowymiarowe
# inicjalizacja
multi={"zero":[0,1], "un":[10,11,12,13], "deux":[20,21,22,23,24]}

# przeglądanie
for (cle,valeur) in multi.items():
    for i2 in range(len(multi[cle])):
        print "multi[%s][%s]=%s" % (cle,i2,multi[cle][i2])

Wyniki

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. Powiązania między łańcuchami a listami

Program (bases_07)


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

# przekształcanie ciągu znaków w listę
chaine='1:2:3:4'
tab=chaine.split(':')
print type(tab)

# wyświetlanie listy
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

# z listy do ciągu znaków
chaine2=":".join(tab)
print "chaine2=%s" % (chaine2)

# dodajmy puste pole
chaine+=":"
print "chaine=%s" % (chaine)
tab=chaine.split(":")

# wyświetlanie listy
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

# dodajmy ponownie puste pole
chaine+=":"
print "chaine=%s" % (chaine)
tab=chaine.split(":")

# wyświetlanie listy
print "tab a %s elements" % (len(tab))
print ("%s") % (tab)

Uwagi:

wiersz 5: metoda chaine.split(separator) dzieli ciąg znaków chaine na elementy oddzielone separatorem séparateur i zwraca je w postaci listy. W ten sposób wyrażenie '1:2:3:4'.split(":") ma za wartość listę ('1','2','3','4');
wiersz 13: 'separateur'.join(liste) ma wartość ciągu znaków 'lista[0]+separator+lista[1]+separator+...'.

Wyniki

<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. Wyrażenia regularne

Program (bases_09)


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

import re

# --------------------------------------------------------------------------
def compare(modele,chaine):
    # porównaj ciąg znaków „chaîne” z wzorcem „modele”
    # wyświetlanie wyników
    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)


# wyrażenia regularne w języku Python
# pobieranie poszczególnych pól z ciągu znaków
# wzorzec: ciąg cyfr otoczony dowolnymi znakami
# chcemy wyodrębnić tylko ciąg cyfr
modele=r"^.*?(\d+).*?$"

# porównujemy ciąg znaków z wzorcem
compare(modele,"xyz1234abcd")
compare(modele,"12 34")
compare(modele,"abcd")

# wzór: ciąg cyfr otoczony dowolnymi znakami
# chcemy uzyskać ciąg cyfr wraz z polami poprzedzającymi i następującymi po nim
modele=r"^(.*?)(\d+)(.*?)$"

# porównujemy ciąg znaków z wzorcem
compare(modele,"xyz1234abcd")
compare(modele,"12 34")
compare(modele,"abcd")

# wzorzec – data w formacie dd/mm/rr
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")

# wzór – liczba dziesiętna
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")
# koniec

Uwagi:

zwróć uwagę na moduł zaimportowany w wierszu 3. To właśnie on zawiera funkcje do obsługi wyrażeń regularnych;
wiersz 10: porównanie ciągu znaków z wyrażeniem regularnym (wzorem) zwraca wartość logiczną True, jeśli ciąg znaków pasuje do wzoru, a w przeciwnym razie – False;
wiersz 12: match.groups() to krotka, której elementami są fragmenty ciągu odpowiadające elementom wyrażenia regularnego ujętym w nawiasy. W wzorcu:
^.*?(\d+).*?, match.groups() będzie krotką zawierającą jeden element;
^(.*?)(\d+)(.*?)$, match.groups() będzie krotką składającą się z 3 elementów.

Wyniki

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. Sposób przekazywania parametrów funkcji

Program (bases_10)


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

def f1(a):
    a=2

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

Wyniki

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

Uwagi:

w języku Python wszystko jest obiektem. Niektóre obiekty są określane jako „niezmienne”: nie można ich modyfikować. Dotyczy to liczb, ciągów znaków i krotek. Gdy obiekty języka Python są przekazywane jako parametry do funkcji, przekazywane są ich odwołania, chyba że obiekty te są „niezmienne” – w takim przypadku przekazywana jest wartość obiektu;
funkcje f1 (wiersz 3) i f2 (wiersz 6) mają na celu zilustrowanie przekazywania parametru wyjściowego. Chcemy, aby rzeczywisty parametr funkcji został przez nią zmodyfikowany;
wiersze 3–4: funkcja f1 modyfikuje swój parametr formalny a. Chcemy sprawdzić, czy parametr rzeczywisty również zostanie zmodyfikowany.
wiersze 12–13: parametrem rzeczywistym jest x=1. Wynik z wiersza 1 pokazuje, że parametr rzeczywisty nie ulega zmianie. Zatem parametr rzeczywisty x i parametr formalny a to dwa różne obiekty;
wiersze 6–9: funkcja f2 modyfikuje swoje parametry formalne a i b, a następnie zwraca je jako wyniki;
wiersze 15–16: do funkcji f2 przekazywane są parametry rzeczywiste (x, y), a wynik funkcji f2 jest zapisywany w (x, y). Wiersz 2 wyników pokazuje, że parametry rzeczywiste (x, y) zostały zmodyfikowane.

Wniosek jest taki, że gdy obiekty „niezmienne” są parametrami wyjściowymi, muszą one stanowić część wyników zwracanych przez funkcję.

3.7. Pliki tekstowe

Program (bases_11)


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

import sys

# sekwencyjne przetwarzanie pliku tekstowego
# plik ten składa się z wierszy o postaci login:pwd:uid:gid:infos:dir:shell
# każdy wiersz jest umieszczany w słowniku w postaci login => [uid,gid,infos,dir,shell]

# --------------------------------------------------------------------------
def afficheInfos(dico,cle):
    # wyświetla wartość powiązaną z kluczem w słowniku „dico”, jeśli istnieje
    valeur=None
    if dico.has_key(cle):
        valeur=dico[cle]
    if 'list' in str(type(valeur)):
        print "[{0},{1}]".format(cle,":".join(valeur))
    else:
        # klucz nie występuje w słowniku „dico”
        print "la cle [{0}] n'existe pas".format(cle)           


def cutNewLineChar(ligne):
    # usuwa się znak końca linii, jeśli istnieje
    l=len(ligne);
    while(ligne[l-1]=="\n" or ligne[l-1]=="\r"):
        l-=1
    return(ligne[0:l]);
    
# ustala się nazwę pliku
INFOS="infos.txt"

# otwiera się go w trybie tworzenia
try:
    fic=open(INFOS,"w")
except:
    print "Erreur d'ouverture du fichier INFOS en écriture\n"
    sys.exit()

# generuje się dowolną treść
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")

# plik zostaje zamknięty
fic.close()

# otwieramy go w trybie odczytu
try:
    fic=open(INFOS,"r")
except:
    print "Erreur d'ouverture du fichier INFOS en écriture\n"
    sys.exit()

# słownik jest początkowo pusty
dico={}

# odczyt linii  
ligne=fic.readline()  
while(ligne!=''):
    # usuwamy znak końca linii
    ligne=cutNewLineChar(ligne)
  
    # wpisujemy wiersz do tablicy
    infos=ligne.split(":")
  
    # pobieranie loginu
    login=infos[0]
  
    # usuwamy dwa pierwsze elementy [login,pwd]
    infos[0:2]=[]
  
    # tworzymy wpis w słowniku
    dico[login]=infos
  
    # odczyt wiersza  
    ligne=fic.readline()  

# zamykamy plik
fic.close()

# przetwarzanie słownika
afficheInfos(dico,"login10")
afficheInfos(dico,"X")

Uwagi:

wiersz 37: w celu zakończenia skryptu w środku kodu.

Wyniki

Plik 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

Wyniki na ekranie:

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