Programowanie Fizyka Medyczna
Wykład III
20 marca 2012
Przypomnienie i rozszerzenie wiadomości z poprzednich wykładów

typy złożone: krotka, lista, zbiór, słownik

ilość argumentów w wywołaniu funkcji,

funkcja zwracająca sekwencję.
Definicja klasy:

__init__()

self,

pola i metody prywatne,

przeciążanie operatorów.
Standardowe moduły:

sys,

os,
Moduł PyDicom:

wprowadzenie.
Typy złożone
Mutable? Hashable Indexable Iterable Postać
Krotka immutable Zależy od Tak Tak ( 'a', 0 )
(tuple) elementów
Lista mutable Nie Tak Tak [ 'a', 0 ]
(list)
Zbiór mutable Nie Nie Tak { 'a', 0 }
(set)
Zbiór immutable Tak Nie Tak Konwersja z
set
domknięty
(frozenset)
Słownik mutable Nie Klucz Tak { 'a':'1', 0:2 }
(dictionary)
Ciąg Unicode immutable Tak Tak Tak "As to pies"
(str)
Ciąg bajtów immutable Tak Tak Tak b"As to pies"
(bytes)
Ciąg bajtów mutable Nie Tak Tak Konwersja z
(bytearray) bytes
iterator range() immutable Tak Tak Tak Range(1,10,2)
Programowanie FizMed, wykład 4 2
Przypomnienie sposobu użycia
Typy indeksowalne
>>> b[0] # zwraca jeden, pierwszy element obiektu
Typy iterowalne
>>> for i in b:
print (i)
Dla słownika powyższa instrukcje zwracają klucze a nie wartości.
Dostęp do wartości odbywa się poprzez:
>>> for i in b:
print (b[i]) # indeksowanie przez klucz
Jeżeli potrzebny jest numer elementu to używamy enumerate().
Funkcja enumerate() zwraca krotkę (indeks, element), którą można rozpakować:
Dla słownika
>>> for i, ti in enumerate(b):
print (i, ti, b[ti]); # wypisze dla słownika b - indeks, klucz, wartość elementu
Dla pozostałych sekwencji, również "not iterable".
>>> for i, ti in enumerate(b):
print (i, ti); # wypisze indeks, wartość elementu [i]
Typy "hashable" mogą być kluczem w słowniku lub elementem zbioru.
Programowanie FizMed, wykład 4 3
Dodawanie elementów do listy - append
1 5 7
Q = [7,8]
2 6 8
L = [1, 2, 3, 4]
3 Q
P = [5, 6, Q] # definiujemy trzy listy
4
L.append(P) # dodaje do listy L referencję do listy P
1 5 7
[1, 2, 3, 4, [5, 6, [7, 8] ]
2 6 8
# zmiana P zmienia L
3 Q
# zmiana Q zmienia L i P
4
P
L.append(P[:]) # dodaje do listy L "shallow copy" P
1 5 7
[1, 2, 3, 4, [5, 6, [7, 8] ]
2 6 8
# zmiana P nie zmienia L
3 Q
# zmiana Q zmienia L i P oraz "shallow copy" P 4
[]
5
L.append("Ala")
6
[1, 2, 3, 4, "Ala")
Q
Programowanie FizMed, wykład 4 4
Dodawanie elementów do listy  extend, insert
Jeżeli nie chcemy wstawiać na końcu
L.insert(0, P) # dodaje do listy L obiekt P od indeksu 0
[[5, 6, ['a', 8]], 1, 2, 3, 4]
# zmiana P zmienia L
# zmiana Q zmienia L i P
Pozostałe cechy jak w append().
L.extend(P) # dodaje do listy L elementy innej zmiennej iterable
[1, 2, 3, 4, 5, 6, [7, 8] ]
1
5 7
# zmiana P nie zmienia L
2
6 8
# zmiana Q zmienia L i P
3
Q
4
L.extend("Ala")
5
[1, 2, 3, 4, 'A', 'l', 'a' ]
6
Q
Programowanie FizMed, wykład 4 5
Usuwanie elementów z listy
del lista[0]
del lista[0:1]
del lista # kasuje całą listę, jak i każdą inną zmienną
lista.pop() # zwraca wartość ostatnią i ją usuwa
lista.pop(0) # zwraca wartość pierwszą i ją usuwa
lista.pop(i) # zwraca wartość i-tą i ją usuwa
lista.remove(wart) # usuwa pierwsze wystąpienie wartości wart
L = ['a', 'b', 'b', 'c', 'd', 'a']
L. remove('a')
['b', 'b', 'c', 'd', 'a']
Programowanie FizMed, wykład 4 6
Przydatne operacje na liście
L = ['a', 'b', 'b', 'c', 'd', 'a']
'count'  zwraca ilość wystąpień danego elementu w liście
L.count('a')
2
'reverse'  odwraca kolejność elementów wewnątrz listy
Nie tworzy nowej. Tzw. 'in-place'
L.reverse() # zmienia listę L
['a', 'd', 'c', 'b', 'b', 'a']
'sort'  sortuje listę L 'in-place'
L.sort()
['a', 'a', 'b', 'b', 'c', 'd']
O ile pomiędzy elementami listy może być ustalony porządek
Programowanie FizMed, wykład 4 7
List comprehension = lista składana
[ wyrażenie(zm1) for zm1 in iterable1 if warunek1 ]
[ x*3 for x in range(5) if x%2 != 0 ]
Pomnóż razy 3, wszystkie liczby z zakresu od 0 do 4, które mają
resztę z dzielenia przez 2 rózną od zera (nieparzyste)
[3, 9]
Zakres x Zakres y
[ (x, y) for x in range(5) for y in range(5) if y%2 == 0 ]
Utwórz listę krotek (x,y), gdzie x jest liczbą z zakresu od 0 do 4 a
y jest liczbą parzystą z zakresu od 0 do 4.
[(0, 0), (0, 2), (0, 4), (1, 0), (1, 2), (1, 4), (2, 0), (2, 2), (2, 4), (3, 0),
(3, 2), (3, 4), (4, 0), (4, 2), (4, 4)]
Programowanie FizMed, wykład 4 8
Operacje na zbiorach
Uwaga praktyczna  najłatwiej jest chyba operować na liście i potem konwertować
ją na żądany typ.
L = ['a', 'd', 'c', 'b', 'b', 'a']
S = set(L)
{ 'a', 'b', 'c', 'd' }
'update'  jak extend  dodaje elementy z iterable
S.update("Ala ma kota")
{'a', 'A', 'c', 'b', 'd', ' ', 'k', 'm', 'l', 'o', 't'}
'add'  jak append dodaje jeden element hashable
S.add("Ala ma kota")
{'a', 'c', 'b', 'Ala ma kota', 'd'}
'discard'  usuwa element, ale nie powoduje błędu jeżeli go nie ma
'remove'  usuwa i powoduje błąd jeżeli nie ma
'pop'  zwraca i usuwa jeden element zbioru
'clear'  czyści zbiór
S1 = S # 'reference' zmiana S zmienia S1 i na odwrót
S2 = S.copy() # shallow copy zmiana S nie zmienia S2, ale w S2
przechowywane są referencje do elementów S.
Programowanie FizMed, wykład 4 9
s2 = set(s)
Operacje na zbiorach  teoria mnogości
S = set("Ala ma kota")
{'A', 'a', ' ', 'k', 'm', 'l', 'o', 't'}
P = set("As to pies Ali")
{'A', ' ', 'e', 'i', 'l', 'o', 'p', 's', 't'}
'difference'  różnica
S.difference(P) # tworzy nowy zbiór
{'a', 'k', 'm'}
'union' - suma
S.union(P) # tworzy nowy zbiór
{'A', 'a', 'e', ' ', 'i', 'k', 'm', 'l', 'o', 'p', 's', 't'}
'symmetric_difference'  alternatywa rozłączna
S.symmetric_difference(P) # tworzy nowy zbiór
{'a', 'e', 'i', 'k', 'm', 'p', 's'}
'intersection'  część wspólna/ iloczyn
S.intersection(P) # tworzy nowy zbiór
{'A', ' ', 'l', 'o', 't'}
Programowanie FizMed, wykład 4 10
Operacje na zbiorach  teoria mnogości
Argumentem użytych wcześniej funkcji może być nie tylko zbiór (P), ale
dowolny typ iterable np. str.
S.difference("kota")
{'A', ' ', 'm', 'l'}
Funkcje te (oprócz pary union - update) mają też wersje działające 'in-
place' np.
S.difference_update(P) nie tworzy nowej listy tylko zmienia S.
W przypadku, gdy S i P są zbiorami, możemy użyć zapisu operatorowego
'difference' S - P
'difference_update' S = S  P S -= P
'update' S = S | P S |= P
'union' S | P
'symmetric_difference' S ^ P
'symmetric_difference_update' S = S ^ P S ^= P
'intersection' S & P
'intersection_update' S = S & P S &= P
'issubset' S <= P zawiera się
'issuperset' S >= P zawiera
Programowanie FizMed, wykład 4 11
Operacje na słowniku
Tworzenie polega na podaniu pary klucz:wartość
D = { 1:2, "a":3, 3: "b" }
D1 = dict(Pon = 1, Wto = 2, Sro = 3 ) # tylko, gdy klucze są ciągami znaków
{'Pon': 1, 'Sro': 3, 'Wto': 2}
Poprzez połączenie 2 obiektów iterowalnych (np. list)
L1 = range(5)
L2 = range(5,10)
0 1 2 3 4
z = zip(L1, L2)
D2 = dict(z)
{0: 5, 1: 6, 2: 7, 3: 8, 4: 9}
0 1 2 3 4
Dodawanie elementów
D1["Czw"] = 4
D2.update(D2) #łączy 2 słowniki
Usuwanie elementów
del D1["Czw"] # usuwa o ile istnieje
D1.pop("Sro") # usuwa i zwraca wartość dla klucza "Sro"
D1.popitem() # zwraca jakąś krotkę (klucz, wartość)
Programowanie FizMed, wykład 4 12
Wróćmy do args i kwargs
def f3(a, b=1,c=2, *args, **kwargs):
print("Wartości a = {}, b={}, c={}".format(a,b,c))
print(args)
print(kwargs)
Funkcja f3 oczekuje na jeden argument a.
Następne dwie wartości nie muszą być podane, ale jeżeli się pojawią będa
przypisane w kolejności b i c , chyba że jawnie poda się nazwy.
Pozostałe wartości bez nazw zostaną "zapakowane" do krotki o nazwie args.
Pozostałe named arguments zostaną "zapakowane" do słownika o nazwie kwargs.
Na przykład:
f3(1,2,3,4,5,6, ala=7)
args = (4, 5, 6)
kwargs = {"ala": 7}
UWAGA! Nie można mieszać named arguments ze zwykłymi parametrami
F3(1,2, ala=7, 3,4,5,6) # Błąd !
Programowanie FizMed, wykład 4 13
Funkcja zwracająca sekwencję np. listę
Poniższy kod działa tylko dla listy.
Wersja 1
def mojafunkcja(a):
result = []
if type(a) == list:
for i in a:
result.append(3*i)
return result
else:
return a*3
Wersja 1a używająca listy składanej (comprehensive list)
def mojafunkcja(a):
if type(a) == list:
return [ i*3 for i in a]
else:
return a*3
Programowanie FizMed, wykład 3 14
Funkcja zwracająca sekwencję np. listę
Wersja 2
def moja(*args):
if len(args)>1:
print("Tylko jeden argument: liczba lub coś iterowalne")
return None
if type(args[0])== int or type(args[0]) == float:
return args[0]*3
result = []
mytype = type(args[0])
for _tii in args[0]:
result.append(_tii*3)
return mytype(result)
Wersja 2a z listą składaną oraz operatorem przynależności in.
def moja(*args):
if len(args)>1:
print("Tylko jeden argument: liczba lub coś iterowalne")
return None
if type(args[0]) in (int, float):
return args[0]*3
mytype = type(args[0])
return mytype( [ i*3 for i in args[0] ])
Programowanie FizMed, wykład 3 15
Obiekt jako przedstawiciel klasy
class mojaklasa(object):
pass # zarezerwowany symbol class oznacza początek
# definicji klasy mojaklasa
# klasa object jest domyślną klasą bazową
To jest najprostsza klasa. Możemy już utworzyć jej przedstawiciela, czyli
obiekt.
a = mojaklasa()
a jest obiektem klasy mojaklasa. Klasa ta może mieć kilku przedstawicieli.
b = mojaklasa()
b też jest obiektem klasy mojaklasa.
Aby obiekty mogły realizować jakieś funkcje musimy rozszerzyć o nie
definicję klasy. Mówimy wtedy o metodach (methods) danej klasy czy
obiektu.
Aby obiekty mogły przechowywać jakieś dane musimy wpisać je w definicję
klasy. Mówimy wtedy o własnościach (properties) danej klasy.
Programowanie FizMed, wykład 4 16
Inicjalizacja obiektu
class mojaklasa(object):
pass
W definicji każdej klasy możemy użyć funkcji o specjalnych nazwach,
które posiadają specyficzne znaczenie. Ponieważ definicja klasy dotyczy
wszystkich jej przedstawicieli (instancji), musi one mieć możliwość
rozpoznania, który konkretnie obiekt się do niej odwołuje.
Dlatego w definicji klasy wprowadzono specjalny, pierwszy argument
funkcji, który jest odnośnikiem do danej instancji. Nazywa się on self.
class mojaklasa(object):
def __init__(self):
print("W init mojaklasa ", self)
>>> a = mojaklasa()
W init mojaklasa <__main__.mojaklasa object at 0x02E08830>
>>> b = mojaklasa()
W init mojaklasa <__main__.mojaklasa object at 0x0269B0B0>
Metoda __init__() jest wywoływana podczas tworzenia każdej instancji
danej klasy. Jest to dobre miejsce na inicjalizację obiektu.
Programowanie FizMed, wykład 4 17
Inicjalizacja obiektu  przekazanie parametrów
class mojaklasa(object):
def __init__(self):
print("W init mojaklasa ", self)
W tej chwili inicjalizacja obiektu nie pobiera żadnych argumentów. self nie
jest argumentem widocznym z zewnątrz.
a = mojaklasa() # OK
b = mojaklasa(1) # Błąd - __init__ nie oczekuje na argumenty
Aby to zmienić musimy podać inne argumenty lub skorzystać ze sposobów
na przekazanie ich zmiennej ilości.
class mojaklasa(object):
def __init__(self, *args, **kwargs):
print("W init mojaklasa ", self, args, kwargs)
a = mojaklasa() # OK
W init mojaklasa <__main__.mojaklasa object at 0x02E08530> () {}
b = mojaklasa(1) # OK, na razie nie używamy, ale nie ma błędu
W init mojaklasa <__main__.mojaklasa object at 0x02E08E10> (1,) {}
Programowanie FizMed, wykład 4 18
Inicjalizacja obiektu  własności lokalne i globalne
class mojaklasa(object):
def __init__(self, *args, **kwargs):
print("W init mojaklasa ", self, args, kwargs)
self.wartosc = 0
if "wartosc" in kwargs: self.wartosc = kwargs["wartosc"]
>>> a = mojaklasa()
W init mojaklasa <__main__.mojaklasa object at 0x02E16230> () {}
>>> a.wartosc
0
>>> b = mojaklasa(wartosc = 10)
W init mojaklasa <__main__.mojaklasa object at 0x02E086F0> () {'wartosc': 10}
>>> b.wartosc
10
Każdy obiekt przechowuje swoją osobistą wartość w polu wartosc.
Programowanie FizMed, wykład 4 19
Inicjalizacja obiektu  własności lokalne i globalne
class mojaklasa(object):
wspolna_wartosc = ['a', 'b', 'c']
def __init__(self, *args, **kwargs):
print("W init mojaklasa ", self, args, kwargs)
self.wartosc = 0
if "wartosc" in kwargs: self.wartosc = kwargs["wartosc"]
Własności utworzone bez użycia self, są współdzielone pomiędzy obiektami.
Jeżeli jeden z obiektów ją zmieni (ale nie zamaże!!) to zmieni się wszędzie.
a.wspolna_wartosc
['a', 'b', 'c']
b.wspolna_wartosc
['a', 'b', 'c']
b.wspolna_wartosc[1] = 'f' # zmieniamy w obiekcie b
a.wspolna_wartosc # zmiana pojawia się w a
['a', 'f', 'c']
c = mojaklasa()
c.wspolna_wartosc # nowe obiekty dostają już zmienioną wartość
['a', 'f', 'c']
Programowanie FizMed, wykład 4 20
Pola prywatne i publiczne
class mojaklasa(object):
wspolna_wartosc = ['a', 'b', 'c']
def __init__(self, *args, **kwargs):
print("W init mojaklasa ", self, args, kwargs)
self.wartosc = 0
self.__pryw = 1
if "wartosc" in kwargs: self.wartosc = kwargs["wartosc"]
def zmien_pryw(self, a):
self.__pryw = a
def zwroc_pryw(self):
return self.__pryw
W sytuacji, w której nie chcemy, żeby użytkownicy mieli bezpośredni
dostęp do jakiegoś pola możemy go ukryć. Rozpoczęcie nazwy własności
od podwójnego podkreślnika powoduje, że taka zmienna jest zmienną
prywatną.
Można ją zmienić tylko używając metod klasy np. zmien_pryw, a nie
bezpośrednio. Podobnie ze zwróceniem wartości metodą zwroc_pryw.
a = mojaklasa()
a.__pryw # Błąd!!!!
a.zwroc_pryw() # OK
1
Programowanie FizMed, wykład 4 21
Pola prywatne i publiczne  uwaga !!!
class mojaklasa(object):
__pryw = 2 # globalny prywatny
wspolna_wartosc = ['a', 'b', 'c']
def __init__(self, *args, **kwargs):
print("W init mojaklasa ", self, args, kwargs)
self.wartosc = 0
self.__pryw = 1 # lokalny prywatny przykrywa globalny
if "wartosc" in kwargs: self.wartosc = kwargs["wartosc"]
def zmien_pryw(self, a):
self.__pryw = a
def zwroc_pryw(self):
return self.__pryw
a = mojaklasa()
a.__pryw # Błąd nie ma takiego pola
a.__pryw = 3 # OK tworzy nowe pole poza prywatnym słownikiem
a.__pryw
3
a.zwroc_pryw()
1
del a.__pryw # kasuje a.__pryw = 3
Programowanie FizMed, wykład 4 22
Wypisywanie obiektu i jego reprezentacja tekstowa
class mojaklasa(object):
def __init__(self, *args, **kwargs):
print("W init mojaklasa ", self, args, kwargs)
self.wartosc = 0
self.__pryw = 1
if "wartosc" in kwargs: self.wartosc = kwargs["wartosc"]
a = mojaklasa()
W interpreterze Python mamy 2 możliwości wyświetlenia zawartości obiektu.
print(a)
<__main__.mojaklasa object at 0x02E180B0>
Lub po prostu
a
<__main__.mojaklasa object at 0x02E180B0>
Aby uzyskać własną informację musimy dopisać (zaimplementować) dwie
specjalne funkcje __repr__() oraz __str()__
Programowanie FizMed, wykład 4 23
Wypisywanie obiektu i jego reprezentacja tekstowa
class mojaklasa(object):
def __init__(self, *args, **kwargs):
self.wartosc = 0
self.__pryw = 1
if "wartosc" in kwargs: self.wartosc = kwargs["wartosc"]
print("W init mojaklasa ", args, kwargs)
# print(self) wykonuje właśnie __repr__
def __repr__(self):
print("W __repr__ możemy wypisać co chcemy")
return "wartosc = {0}, __pryw = {1}".format(self.wartosc, self.__pryw)
>>> a = mojaklasa()
W init mojaklasa () {}
>>> a
W __repr__ możemy wypisać co chcemy
wartosc = 0, __pryw = 1.
>>> print(a)
W __repr__ możemy wypisać co chcemy
wartosc = 0, __pryw = 1
Programowanie FizMed, wykład 4 24
Wypisywanie obiektu i jego reprezentacja tekstowa
class mojaklasa(object):
def __init__(self, *args, **kwargs):
self.wartosc = 0
self.__pryw = 1
if "wartosc" in kwargs: self.wartosc = kwargs["wartosc"]
print("W init mojaklasa ", args, kwargs)
# print(self) wykonuje właśnie __repr__
def __repr__(self):
print("W __repr__ możemy wypisać co chcemy")
return "wartosc = {0}, __pryw = {1}".format(self.wartosc, self.__pryw)
def __str__(self):
print("W __str__ też możemy wypisać co chcemy")
return "wartosc = {0}, __pryw = {1}".format(self.wartosc, self.__pryw)
>>> a = mojaklasa()
W init mojaklasa () {}
>>> a
W __repr__ możemy wypisać co chcemy
wartosc = 0, __pryw = 1
>>> print(a)
W __str__ też możemy wypisać co chcemy
wartosc = 0, __pryw = 1
Programowanie FizMed, wykład 4 25
Wywoływanie obiektu jak funkcji - __call__
class mojaklasa(object):
def __init__(self, *args, **kwargs):
self.wartosc = 0
self.__pryw = 1
if "wartosc" in kwargs: self.wartosc = kwargs["wartosc"]
def __call__(self, *args, **kwargs):
print("Wywołałeś mnie z {} oraz {}".format(args, kwargs))
return self.__pryw
Jeżeli nasz obiekt ma mieć możliwość wywołania go jak funkcji musi mieć
zdefiniowaną metodę __call__().
Tak jak w innych funkcjach powinniśmy zadbać o poprawne przetworzenie
argumentów oraz zwrócić jakąś wartość.
>>> a = mojaklasa()
>>> a()
Wywołałeś mnie z () oraz {}
1
Programowanie FizMed, wykład 4 26
Odwołanie do obiektu jak do słownika lub listy - __getitem__
class mojaklasa(object):
def __init__(self, *args, **kwargs):
self.wartosc = 0
self.__pryw = 1
if "wartosc" in kwargs: self.wartosc = kwargs["wartosc"]
def __getitem__(self, *args, **kwargs):
print("Wywołałeś getitem z {} oraz {}".format(args, kwargs))
if "wartosc" in args: return self.wartosc
return self.__pryw
Metoda __call__ powoduje, że nasz obiekt poprawnie przejmuje odwołania do
indeksu lub klucza, czyli jest subscriptable.
a["wartosc"]
Wywołałeś getitem z ('wartosc',) oraz {}
0
a["warto"]
Wywołałeś getitem z ('warto',) oraz {}
1
Programowanie FizMed, wykład 4 27
Przeciążanie operatorów np. '+'
class mojaklasa(object):
def __init__(self, *args, **kwargs):
self.wartosc = 0
self.__pryw = 1
if "wartosc" in kwargs: self.wartosc = kwargs["wartosc"]
def __add__(self, skladnik):
print("Jestem w add")
if isinstance(skladnik, mojaklasa): # sprawdzamy czy dobrze dodajemy
return mojaklasa(wartosc = self.wartosc + skladnik.wartosc)
raise(TypeError)
Co zrobić, aby nasze obiekty obsługiwały operatory arytmetyczne np. użycie '+'
dodawało pola wartosc? Musimy zdefiniować metodę, która odpowiada
danemu operatorowi (patrz poprzedni wykład). Dla '+' jest to __add__(self,x)
a = mojaklasa(wartosc = 1)
b = mojaklasa(wartosc = 3)
c = a+b
c.wartosc
4
Wbudowana w Python funkcja isinstance(obiekt, klasa) sprawdza, czy dany
obiekt jest instancją danej klasy. W przeciwny razie zgłaszamy błąd typu.
Programowanie FizMed, wykład 4 28
Obiekt jako zmienna logiczna
class mojaklasa(object):
def __init__(self, *args, **kwargs):
self.wartosc = 0
self.__pryw = 1
if "wartosc" in kwargs: self.wartosc = kwargs["wartosc"]
def __bool__(self):
if self.wartosc == 0:
return False
return True
Jeżeli nasz obiekt ma pełnić rolę zmiennej logicznej, tzn. pojawiać się w
wyrażeniach typu
a = mojaklasa()
if a:
print("Jest dobrze") # bez __bool__ się wypisze, z powyższym - nie.
Musi implementować metodę __bool__(). Jeżeli jej nie ma jego logiczna
wartość zawsze będzie prawdą. Czyli całość problemu sprowadza się do
napisania funkcji, która określa kiedy stan naszego obiektu odpowiada
logicznemu fałszowi.
Programowanie FizMed, wykład 4 29
Moduł sys
Moduł ten daje nam dostęp do podstawowych informacji o systemie
operacyjnym i interpreterze python
import sys
Niektóre częściej używane funkcje:
sys,hexversion Wersja interpretera Python zapisana jako liczba szestnastkowa
sys.platform Windows czy Linux, 64bit czy 32bit
sys.executable scieżka do interpretera Python
sys.argv argumenty wywołania skryptu
sys.float_info słowniki przechowujące informacje o szczegółach
sys.int_info implementacji typów int i float
sys.path lista zawierająca katalogi przeszukiwane w poszukiwaniu
plików.
sys.modules lista załadowanych modułów
Programowanie FizMed, wykład 4 30
Moduł os
Moduł do podstawowych operacji w systemie
import os
os.linesep  znak końca linii ('\r' lub '\n') w *nix lub MacOS, '\r\n' w Windows
os.path.abspath(s) absolutna ścieżka dla nazwy względnej s
os.path.split(s) dzieli ścieżkę s na listę nazw [dysk, katalogi, plik]
os.path.join(s,p) łączy dwie części ścieżki w jedną używając porawnego
łącznika
os.path.basename(s) zwraca nazwę pliku lub ostatniego katalogu
os.path.dirname(s) zwraca wszystko przed basename
os.path.exists(s) sprawdza czy dana ścieżka/plik istnieje
os.stat(s) informacja o statusie obiektu na dysku (poniżej konkretne
pola)
os.path.getatime(s) czas ostatniego dostępu do obiektu na dysku
getctime(s) utworzenia
getmtime(s) modyfikacji
os.path.getsize(s) rozmiar pliku
os.path.isdir(s) czy jest katalogiem
os.path.isfile(s) czy jest plikiem
Programowanie FizMed, wykład 4 31
Pakiet PyDicom
Podstawowe operacje na plikach dicom
import dicom
Podstawowym obiektem jest dataset, który można uważać za specjalny słownik.
dicom.read_file(s) wczytuje plik o ścieżce s i zwraca dataset
ds2 = dicom.read_file("MR_small.dcm")
Wyświetlenie elementów słownika możliwe jest przez wpisanie jego nazwy
ds2
(0008, 0008) Image Type CS: [b'DERIVED', b'SECONDARY', b'OTHER']
(0008, 0012) Instance Creation Date DA: b'20040826'
(0008, 0013) Instance Creation Time TM: b'185434'
DICOM TAG  para liczb określających typ pola
DICOM Tag Name  nazwa typu pola wynikająca z jego znacznika/tagu
VR  Value Record  jakiego typu jest wartość pola (CS-string, DA - Date)
Interesuje nas pixel_array, która zawiera obraz
import pylab
pylab.imshow(ds2.pixel_array, cmap=pylab.cm.bone)
pylab.show()
Programowanie FizMed, wykład 4 32
Koniec na dzisiaj!
Programowanie FizMed, wykład 4 33