>> import math >>> lista1 = [x, y, round (math, pi)] >>> print lista1 [1, 'dwa', 3.0] >>> lista2 = [0, lista1, 4] >>> print lista2 [0, [1, 'dwa', 3.0], 4] >>> lista3 = [lista2, (10/2, str(6))] >>> print lista3 [[0, [1, 'dwa', 3.0], 4], (5, '6')] >>> lista4 = [] >>> print lista4 [] >>>() () >>> type(()) >>> x = 1 >>> (x) # To nie jest krotka 1 >>>> (x,) # Krotka (1,) >>> lista = [2, "trzy", str(4)] >>> tup1 = (0, x, lista, (5, '6')) >>> print tup1 (0, 1, [2, 'trzy', '4'], (5, '6')) >>> dict = {} >>> lista2 = [dict] >>> tup2 = (lista2,) >>> print tup2 ([{ }],)">

Pobieranie prezentacji. Proszę czekać

Pobieranie prezentacji. Proszę czekać

1 Programowanie w językach skryptowych 1 Wykład 4: Podstawy Pythona Listy i krotki Opracował: Dr inż.. Marcin Janaszewski Katedra Informatyki Stosowanej.

Podobne prezentacje


Prezentacja na temat: "1 Programowanie w językach skryptowych 1 Wykład 4: Podstawy Pythona Listy i krotki Opracował: Dr inż.. Marcin Janaszewski Katedra Informatyki Stosowanej."— Zapis prezentacji:

1 1 Programowanie w językach skryptowych 1 Wykład 4: Podstawy Pythona Listy i krotki Opracował: Dr inż.. Marcin Janaszewski Katedra Informatyki Stosowanej Politechnika Łódzka

2 2 Wprowadzenie Podobnie jak łańcuchy są uporządkowanymi sekwencjami obiektów. Łańcuchy służą jednak tylko do przechowywania znaków, zaś listy i krotki przechowują kolekcje obiektów dowolnego typu. Listy i krotki są podobne do tablic w innych językach programowania. Listy są zmienne i mogą zawierać obiekty dowolnego typu (nawet inne listy). Mogą one być powiększane lub zmniejszane, łatwo je sortować, przeszukiwać i modyfikować. Listy są zapisywane w nawiasach kwadratowych: lista = [1, "dwa", 3.0] Krotki są podobne do list, lecz nie można ich modyfikować. Są one niezmienne (podobnie jak łańcuchy) i mają ustalony rozmiar. Krotki są zapisywane w zwykłych nawiasach: krotka = (1, "dwa", 3.0) Pomijając zmienność wiele operacji wykonywanych na listach i krotkach jest podobnych. Krotki działają szybciej i zajmują mniejsze obszary pamięci niż listy. W niektórych sytuacjach jest to również wymaganie samego języka Python (na przykład przy formatowaniu łańcuchów, w kluczach słownika i stosowaniu wielu argumentów funkcji). Krotki są także wygodne wtedy, gdy konieczna jest pewność, że dane nie zostaną zmodyfikowane poprzez alias.

3 3 Tworzenie listy i krotki >>> x = 1 >>> [x] [1] >>> y = "dwa" >>> import math >>> lista1 = [x, y, round (math, pi)] >>> print lista1 [1, 'dwa', 3.0] >>> lista2 = [0, lista1, 4] >>> print lista2 [0, [1, 'dwa', 3.0], 4] >>> lista3 = [lista2, (10/2, str(6))] >>> print lista3 [[0, [1, 'dwa', 3.0], 4], (5, '6')] >>> lista4 = [] >>> print lista4 [] >>>() () >>> type(()) >>> x = 1 >>> (x) # To nie jest krotka 1 >>>> (x,) # Krotka (1,) >>> lista = [2, "trzy", str(4)] >>> tup1 = (0, x, lista, (5, '6')) >>> print tup1 (0, 1, [2, 'trzy', '4'], (5, '6')) >>> dict = {} >>> lista2 = [dict] >>> tup2 = (lista2,) >>> print tup2 ([{ }],)

4 4 Pakowanie i rozpakowywanie krotki Podczas tworzenia krotki można pominąć nawiasy, jeśli nie stanowi ona części większego wyrażenia. Przypisanie w następującej postaci: a = 1, 2, 3 zwane jest pakowaniem krotki, ponieważ Python wewnętrznie grupuje (czyli pakuje") wartości podane po prawej stronie do pojedynczej krotki, a następnie wykonuje przypisanie. Odwrotnością pakowania krotki jest rozpakowanie sekwencji: x, y, z = a W tym przypadku Python rozpakowuje poszczególne pozycje w sekwencji a, a następnie przypisuje każdą wartość odpowiedniej zmiennej podanej po lewej stronie (liczba zmiennych po lewej stronie musi odpowiadać liczbie pozycji w a). Rozpakowywanie sekwencji działa wtedy, gdy po prawej stronie znajduje się łańcuch, lista lub krotka. Zagnieżdżone listy są często stosowane do reprezentowania dwuwymiarowych macierzy. Na przykład lista o postaci: [[1, 2] [3, 4]] reprezentuje macierz. Jeśli istnieje potrzeba wykonania operacji macierzowych w Pythonie, należy skorzystać z Numeric Python.

5 5 Określanie rozmiaru listy lub krotki >>> print len(()), len([]) 0 >>> lista1 = [1, 'dwa', 3.0] >>> len(lista1) 3 >>> lista2 = [[0, lista1, 4], (5, '6')] >>> len(lista2) 2 >>> krotka1 = (0,) >>> len(krotka1) 1 % >>> krotka2 = (0, [], (), {}, "", None) >>> len(krotka2) 6 >>> krotka3 = (0, [1], 2, (3, (4, 5), 6)) >>> len(krotka3) 4 >>> len([[1, 1, [2, [3, 3], 2, 2], 1]]) 1

6 6 Indeksowanie listy lub krotki >>> ['zero', 1, 2, 3][2] 2 >>> ('zero', 1, 2)[-2] 1 >>> lista = [0, 'jeden', [2, 3.0], 4, '5'] >>> len(lista) 5 >>> print lista[1], lista[2], lista[3] jeden [2, 3.0] 4 >>> krotka= ((0, 1), (2, 3), 4, (5, 6)) >>> len(krotka) 4 >>> krotka[len(krotka)] Traceback (most recent call last): File " ", line 1, in ? IndexError: tuple index out of range >>> krotka[len(krotka) - 1] (5, 6) >>> krotka[-len(krotka)] (0, 1) >>> krotka[-len(krotka) + 1] (2, 3) >>> n = -2 >>> lista[n] == lista[len(lista) + n] 1 >>> krotka [1.5] Traceback (most recent call last): File " ", line 1, in ? TypeError: sequence index must be integer

7 7 Indeksowanie zagnieżdżonej sekwencji >>> krotka = ((0, 1), [2, 3], (4, 5, 6)) >>> krotka[1] [2, 3] >>> krotka[1][0] 2 >>> krotka[-1] [2] 6 >>> krotka[-1][-3] 4 >>> krotka[0][-1] 1 >>> lista = [ 1, ["dwa", [ 3,"sekwoja"], 4 ]] >>> lista[1] ['dwa', [3, 'sekwoja'], 4] >>> lista[1][1] [3, 'sekwoja'] >>> lista[1][1][1] 'sekwoja' >>> lista[1][1][1][2] 'k' >>> lista[-1][-2][-2] 3

8 8 Wycinanie listy lub krotki Wycinek jest segmentem listy lub krotki, który jest określony za pomocą dwóch indeksów wyznaczających ciągłą sekwencję pozycji. Przy wycinaniu indeksy wskazują miejsca między pozycjami. Jeśli obydwa indeksy są dodatnie, to w wyniku wycinania uzyskuje się segment rozpoczynający się od pierwszego indeksu i kończący na indeksie drugim (z wyłączeniem tego drugiego). Indeksy ujemne oznaczają zliczanie od końca listy lub krotki. >>> i = [1, 2, 3, 4, 5] >>> i[1:-1] [2, 3, 4] >>> print i[0:2], i[1:3], i[-3:-l], i[2:-2] [1, 2] [2, 3] [3, 4] [3] >>> print i[2:], i[:2], i[-2:], i[:-2] [3, 4, 5] [1, 2] [4, 5] [1, 2, 3] >>> i[:] [1, 2, 3, 4, 5] >>> krotka = ((0, 1), [2, 3], (4, 5, 6)) >>> krotka[1:3] ([2, 3], (4, 5, 6)) >>> krotka[1:3][-1][1:] (5, 6) >>> lista = ["sekwoja", ["mimetyczny", "wielostop"]] >>> lista[krotka[0][1]][0][:-3] 'mimetyc' >>> lista[:1] + lista[1:] ['sekwoja', ['mimetyczny', 'wielostop']] >>> krotka[:-2] + krotka[-2:] ((0, 1), [2, 3], (4, 5, 6))

9 9 Niejawne ograniczenia wartości indeksów >>> i = [1, 2, 3, 4, 5] >>> i[-100:100] [1, 2, 3, 4, 5] >>> i[1:100] [2, 3, 4, 5] >>> i[100:] [] >>> i[:100] [1, 2, 3, 4, 5] >>> i[-100:] [1, 2, 3, 4, 5] >>> i[:-100] [] >>> i[-100:2] [1, 2] >>> i[6:2] []

10 10 Kopiowanie listy lub krotki Przypisanie a=b tworzy kopię a >>> a = (1, 2, 3) >>> b = a >>> print b (1, 2, 3) >>> a = (4, 5, 6) >>> print a (4, 5, 6) >>> print b (1, 2, 3) Przypisanie a=b nie tworzy kopii >>> a = [1, 2, 3] >>> b = a >>> print b [1, 2, 3] >>> a[1] = -99 >>> print a [1, -99, 3] >>> print b [1, -99, 3] Aby utworzyć prawdziwą kopię należy zastosować wycinanie >>> a = [1, 2, 3] >>> b = a[:] >>> print b [1, 2, 3] >>> a[1] = -99 >>> print a [1, -99, 3] >>> print b [1, 2, 3]

11 11 Kopie płytkie i kopie głębokie Poprzednio opisane sposoby tworzenia kopii krotki lub listy służyły do tworzenia tzw. płytkiej kopii. Jeśli lista lub krotka zawiera zagnieżdżoną listę (lub zagnieżdżony słownik albo inny zagnieżdżony obiekt zmienny), w płytkiej kopii będzie utworzone odwołanie do takiego zagnieżdżonego obiektu (a nie jego kopia). Zatem nawet wówczas, gdy a i b są różnymi obiektami, każda zmiana we współużytkowanym odwołaniu będzie wpływać na obydwa. Aby rozwiązać ten problem, w Pythonie wprowadzono metodę deepcopy() zawartą w module copy. Głębokie kopiowanie polega na utworzeniu rzeczywistych kopii wszystkich obiektów oryginału (niezależnie od poziomu ich zagnieżdżenia).

12 12 Kopie płytkie i głębokie, przykłady >>> a = [1, [2, 3], 4] >>> b = a[:] >>> print b [1, [2, 3], 4] >>> a[0] = -99 >>> print a [-99, [2, 3], 4] >>> print b [1, [2, 3], 4] >>> a[1][1] = "sekwoja" >>> print a [-99, [2, 'sekwoja'], 4] >>> print b [1, [2, 'sekwoja'], 4] >>> import copy >>> a = [1, [2, 3], 4] >>> b = copy.deepcopy(a) >>> print b [1, [2, 3], 4] >>> a[1][1] = "sekwoja" >>> print a [1, [2, 'sekwoja'], 4] >>> print b [1, [2, 3], 4]

13 13 Modyfikacja zmiennego obiektu niezmiennej krotki jest możliwa >>> a = (1, [2, 3], 4) >>> a[0] = -99 # nie działa! Traceback (most recent call last): File " ". line 1, in ? TypeError: object doesn't support item assignment >>> a[1] = ['dwa', 'trzy'] # nie działa! Traceback (most recent call last): File " ", line 1. in ? TypeError: object doesn't support item ^assignment >>> a[1][1] = "sekwoja" # Działa! >>> print a (1, [2, 'sekwoja'], 4)

14 14 Łączenie list i krotek >>> print [] + [], () + () [] () >>> lista = [1, 2, 3] >>> [] + lista + [] [1, 2, 3] >>> lista + [4, 5] [1, 2, 3, 4, 5] >>> krotka = ('cztery', 'piec') >>> krotka + () ('cztery', 'piec') >>> krotka + ('szesc',) ('cztery', 'piec', 'szesc') >>> lista + [krotka] [1, 2, 3, ('cztery', 'piec')] >>> (lista,) + krotka ([1, 2, 3], 'cztery', 'piec') >>> lista + krotka Traceback (most recent cali last): File " ", line 1, in ? TypeError: can only concatenate list (not "tupie") to list >>> lista = [1, 2, 3] >>> lista += [4, 5] >>> lista += [] >>> lista += [6] >>> print lista [1, 2, 3, 4, 5, 6] >>> krotka = ('a',) >>> krotka += (lista[1:3]) >>> krotka += krotka >>> print krotka ('a', [2, 3], 'a', [2, 3])

15 15 Powtarzanie listy lub krotki >>> a = [1, 2, 3] >>> a * 3 [1, 2, 3, 1, 2, 3, 1, 2, 3] >>> a * 0 [] >>> a * -2 [] >>> a * 3.5 Traceback (most recent call last): File " ", line 1, in ? TypeError: unsupported operand type(s) for * >>> [] * 1000 [] >>> [0] * 5 [0, 0, 0, 0, 0] >>> [a] * 2 [[1, 2, 3], [1, 2, 3]] >>> a[1:] + [4] * 2 [2, 3, 4, 4] >>> (a[1:] + [4]) * 2 [2, 3, 4, 2, 3, 4] >>> ('a', 'b', 'c')[0:2] * 2 ('a', 'b', 'a', 'b')

16 16 Przekształcanie sekwencji na listę >>> s = "mimetyczny" >>> list(s[0:4]) ['m'. 'i', 'm', 'e'] >>> list((1, 2, ('a', 'b'))) [1, 2, ('a', 'b')] >>> krotka = ('a', 'b', 'c') >>> list(krotka) ['a', 'b', 'c'] >>> print list(()), list([]), list('') [] [] [] >>> a = [1, 2, 3] >>> list(a + list(krotka)) [1, 2, 3, 'a', 'b', 'c'] >>> list((krotka,)) [('a', 'b', 'c')]

17 17 Przekształcenie sekwencji na krotkę >>> s = "sekwoja" >>> tuple(s[:4] + "ens") ('s', 'e', 'k', 'w', 'e', 'n', 's') >>> lista = [1, 2, 3] >>> tuple( lista) (1, 2, 3) >>> print tuple(()), tuple([]), tuple(") () () () >>> a = ('a', 'b', 'c') >>> tuple(a + tuple(lista)) ('a', 'b', 'c', 1, 2, 3) >>> tuple((a,) + (lista,)) (('a', 'b', 'c'), [1, 2, 3]) >>> tuple(list(a)) ('a', 'b', 'c')

18 18 Przekształcenie listy lub krotki na łańcuch >>> lista = [1, 2, 3] >>> krotka = ('a', 'b', 'c') >>> str(lista) '[1, 2, 3]' >>> repr(lista) '[1, 2, 3]' >>> 'krotka' "('a', 'b', 'c')" >>> str('lista' + 'krotka') "[1, 2, 3]('a', 'b', 'c')" >>> str(lista + list(krotka)) "[1, 2, 3, 'a', 'b', 'c']" >>> str([krotka]) "[('a', 'b', 'c')]"

19 19 Porównanie list lub krotek >>> a = [1, 2, 3] >>> a < [1, 2, 4] 1 >>> a > [1, 2] 1 >>> a == [int(1), float(2), long('3')] 1 >>> a < [1, 2, '3'] 1 >>> a != tuple(a) 1 >>> ['a', 'B'] < ['a', 'b'] 1 >>> ['a', 'B'] == ['a', 'b'.upper()] 1 >>> a > [] 1 >>> a = a + [] 1 >>> import math >>> ["A", 1, (2, 3)] = [chr(65), a[0], (int(math.e), 6/2)] 1 >>> ('a', ('b',)) != ('a', 'b') > ('a') 1

20 20 Znajdowanie największej i najmniejszej listy lub krotki >>> a = [1, 2, 3] >>> b = [0, 2, 3] >>> c = [0, 1] >>> print min(a, b, c), max(a, b, c) [0, 1] [1, 2, 3] >>> print min(a, b, c, []) [] >>> print min(a), max(b + c) 1 3 >>> p = ["mimetyczny", "wielostop"] >>> q = [p] >>> min(p, q) [['mimetyczny', 'wielostop']] >>> r = [p[0], p[1].title()] >>> min(p, r) ['mimetyczny', 'Wielostop'] >>> max(r)[0:4] 'mime'

21 21 Sprawdzanie przynależności do listy lub krotki >>> a = [1, 'dwa', 3.0] >>> 3 not in a[: -1] 1 >>> print "" in a, None in a, [] in a >>> print 'dwa' in a, 'Dwa' not in a 1 >>> print float(1) in a, 6/2 in a 1 >>> b = (0, a, (4, 5)) >>> a in b 1 >>> (4, 5) in b 1 >>> 4 in b 0 >>> 4 in b[2] 1

22 22 Modyfikacja listy OperacjaOpis s[i] = x Przypisanie pozycji: zamienia pozycję s[i] na x s[i:j] = t Przypisanie wycinka: zamienia wycinek s[ i: j] na wartości z listy t del s[i] Usunięcie pozycji: usuwa pozycję s[i] z s del s[i:j] Usunięcie wycinka: usuwa wycinek s[i:j] z s s.append(x) Dołącza pozycję x na końcu s s.extend(sequence) Dołącza pozycje z sekwencji sequence na końcu listy s s.count(x) Zlicza wystąpienia x w s s.index(x) Zwraca najmniejsze i, gdzie s[i]==x s.insert(i, x) Wstawia x do s w miejscu wskazanym przez indeks i s.pop([i]) Zwraca s[i] i usuwa je z s. Domyślnie i wynosi -1 (ostatnia pozycja listy s) s.remove(x) Wyszukuje pozycję x i usuwa ją z listy pierwsze wystąpienie s s.reverse() Odwraca kolejność pozycji listy s w miejscu s.sort([cmpfunc}) Sortuje pozycje z s w miejscu. Funkcja cmpfunc jest opcjonalną funkcją porównującą

23 23 Zastępowanie kilku pozycji listy >>> a = [1, 2, 3, 4, 5] >>> a[0:2] = ["jeden", "dwa"] >>> a ['jeden', 'dwa', 3, 4, 5] >>> a[-2:] = [-a[-2], "piec"] >>> a ['jeden', 'dwa', 3, -4, 'piec'] >>> a[3:] = [6, 7, 8, 9] >>> a ['jeden', 'dwa', 3, 6, 7, 8, 9] >>> a[:4] = [10/2] >>> a [5, 7, 8, 9] >>> a[1:1] = [6] >>> a [5, 6, 7, 8, 9] >>> a[-100:1] = ["piec"] >>> a ['piec', 6, 7, 8, 9] >>> a[-2:] = [[8, 9, 10]] >>> a ['piec', 6, 7, [8, 9, 10]] >>> a[-1][-2:] = ["dziewięć", "dziesięć"] >>> a ['piec', 6, 7, [8, 'dziewięć', 'dziesięć']] >>> a[1:] = [] >>> a ['piec'] >>> a[:] = [] >>> a []

24 24 Zliczanie pasujących wartości w liście >>> a = [1] + (2 * ["dwa"]) + (3 * [3]) >>> a [1, 'dwa', 'dwa', 3, 3, 3] >>> x, y, z = a.count(1), a. count("dwa"), a.count(3) >>> print x, y, z >>> a[2:].count("dwa") 1 >>> print a.count(''), a. count ("Dwa"), a.count([]) >>> a[3:] = [[3, 3, 3]] >>> a [1. 'dwa', 'dwa', [3, 3, 3]] >>> a.count([3.0, 6/2, int('3')]) 1 >>> a.count(3) 0 >>> a[-1].count(3) 3 >>> a[-1][-2:].count(3) 2 >>> b = ["mimetyczny", "wielostop"] >>> b. count("m") 0 >>> b[0].count("m") 2

25 25 Przeszukiwanie listy Metoda index() zwraca najmniejszy indeks, przy którym w liście występuje dana wartość. >>> a = [1, 2, 2, [3, ["mimetyczny", "wielostop"], 3], 3] >>> len(a) 5 >>> print a.index(1), a.index(2), a.index(3) >>> a.index("dwa") Traceback (most recent call last): File " ", line 1, in ? ValueError: list.index(x): x not in list >>> x = a.index(2) >>> print a[x + 1:] [2, [3, ['mimetyczny', 'wielostop'], 3], 3] >>> a[x +1:].index(2) 0 >>> a[3].index(3) 0 >>> a[1:].index(3) 3 >>> a[3][1].index("wielostop") 1 >>> a[3][1].index("wielo") Traceback (most recent call last): File " ", line 1, in ? ValueError: list.index(x): x not in list >>> a[3][1][1][5:].index("p") # "stop" 3 >>> a.index([]) Traceback (most recent call last): File " ", line 1, in ? ValueError: list.index(x): x not in list

26 26 Dołączanie pozycji do listy Metoda append() dołącza pojedynczą pozycję do końca listy. Metoda extend() łączy dwie listy. Metoda insert() wstawia pozycję w określonym miejscu listy. >>> a = [1, 2] >>> a.append(3) >>> a.append(6/2) >>> a [1, 2, 3, 3] >>> a.append([6, 7]) >>> a.append(a[0:2]) >>> a.append([]) >>> a.append('') >>> a [1, 2, 3, 3, [6, 7], [1, 2], [], ''] >>> a[4].append(8) >>> a [1, 2, 3, 3, [6, 7, 8], [1. 2], [], ''] >>> a = [1, 2] >>> a.extend([6/2]) >>> a [1, 2, 3] >>> a.extend([]) >>> a.extend('') >>> a [1, 2, 3] >>> a.extend([[5, 6]]) >>> a.extend("abe") >>> a.extend(('d',)) >>> a [1, 2, 3, [5, 6], 'a', 'b', 'c', 'd'] >>> a[3].extend([7]) >>> a [1, 2, 3, [5, 6, 7], 'a', 'b', 'c', 'd'] >>> a.extend(8) Traceback (most recent call last): File " ", line 1, in ? TypeError: list.extend() argument must be a sequence

27 27 Wstawianie pozycji w dowolnym miejscu listy s.insert(i, x), by wstawić pozycję x w miejscu określonym przez, indeks i listy s. >>> a = [1, 2] >>> a.insert(0, -2) >>> a [-2, 1, 2] >>> a.insert(-100, a[0] -1) >>> a.insert(100, abs(a[0])) >>> a [-3, -2, 1, 2, 3] >>> a.insert(3, -99) >>> a.insert(len(a), [4, 5]) >>> a.insert(len(a), []) >>> a [-3, -2. 1, -99, 2, 3, [4, 5], []] >>> a.insert(len(a)/2, "mid") >>> a [-3, -2, 1, -99, 'mid', 2, 3, [4, 5], []] >>> a[-2].insert(1, 4.5) >>> a [-3, -2, 1, -99, 'mid', 2, 3, [4, 4.5, 5], []]

28 28 Insert. Wskazówka Interpretacja ujemnego indeksu i w metodzie insert() jest inna, niż można się spodziewać. Zamiast odliczania wstecz od końca listy s Python zawsze umieszcza x na pierwszej pozycji listy s, jeśli i < 0. Jeśli na przykład a jest równe [1, 2, 3], to a.insert(-1, 4) zmienia a do postaci [4, 1, 2, 3] (a nie [1, 2, 3, 4]).

29 29 Usuwanie pozycji z listy Python umożliwia usuwanie z listy pozycji o określonym położeniu lub wartości. Instrukcja del usuwa jedną lub więcej sąsiadujących ze sobą pozycji. Metoda pop() usuwa pozycję i zwraca jej wartość. Metoda remove() wyszukuje i usuwa z listy pozycję o podanej wartości. W del i pop() stosuje się indeksowanie i wycinanie. >>> a = [1, "sekwoja", [3, 4, 5], 6, 7] >>> del a [3] >>> a [1, 'sekwoja', [3, 4, 5], 7] >>> del a[2][-2] >>> a [1, 'sekwoja', [3, 5], 7] >>> del a[-1] >>> a [1, 'sekwoja', [3, 5]] >>> del a[a[0]] >>> a [1] >>> a = [1, "sekwoja", [3, 4, 5], 6, 7] >>> del a[2][1:] >>> a [1, 'sekwoja', [3], 6, 7] >>> del a[1: -2] >>> a [1, 6, 7] >>> del a[:] >>> a []

30 30 Zdejmowanie z listy >>> a = [1, 2, 3, 4, 5] >>> x = a.pop() >>> print x 5 >>> print a [1, 2, 3, 4] >>> y = a.pop(2) >>> print y 3 >>> print a [1, 2, 4] >>> a.pop(-2) 2 >>> a [1, 4] >>> a.pop(0) 1 >>> a [4]

31 31 Wyszukiwanie wartości i usuwanie jej z listy >>> a = [1, 2.0, 2, "dwa", [3, 4, 3]] >>> a.remove(2) >>> print a [1, 2, 'dwa', [3, 4, 3]] >>> a.remove(2) >>> print a [1, 'dwa', [3, 4, 3]] >>> a.remove(3) Traceback (most recent call last): File " ", 1ine 1, in ? ValueError: list.remove(x): x not in list >>> a[2].remove(3) >>> print a [1, 'dwa', [4, 3]] >>> a.remove(a[-1]) >>> print a [1, 'dwa'] >>> a.remove("Dwa") Traceback (most recent call last): File " ", line 1, in ? ValueError: 1ist.remove(x): x not in list >>> a.remove("Dwa".lower()) >>> a.remove(float(1.0)) >>> print a []

32 32 Sortowanie listy >>> import math >>> a = [2.0, -0.11, 4, -2, 0, 2, 1, round(math.pi, 0)] >>> a.sort() >>> print a [-2, -0.11, 0, 1, 2.0, 2, 3.0, 4] >>> print a.sort() None >>> b= ["Nigdy", "parzysty", "lub", "nieparzysty", ""] >>> b. sort() >>> print b ["", 'Nigdy', 'lub', 'nieparzysty', 'parzysty'] >>> c = [[4, 2], [0, 1], [-1, 0], [4, 2, 0], []] >>> c. sort() >>> print c [[], [-1, 0], [0, 1], [4, 2], [4, 2, 0]] >>> d = [[1], (1,), "1", 1, {"jeden": 1}] >>> d.sort() >>> print d [1, {'jeden': 1}, [1], '1', (1,)]

33 33 Wstawianie pozycji do posortowanej listy. Moduł bisect zawiera funkcje służące do działań wykonywanych na posortowanych listach. Funkcja insort() wstawia pozycję do listy z zachowaniem kolejności sortowania. Funkcja bisect() zwraca indeks listy, pod którym w posortowanej liście powinna się znaleźć dana pozycja. Funkcje te działają przy założeniu, że listy są już posortowane. >>> a = [4, 1, 3, 4, 0] >>> a.sort() >>> print a [0, 1, 3, 4, 4] >>> x = bisect.bisect(a, 2) >>> print x 2 >>> bisect.insort(a, 2) >>> print a [0, 1, 2, 3, 4, 4] >>> b = ["Nigdy", "parzysty", "lub", "nieparzysty"] >>> b.sort() >>> print b ['Nigdy', 'lub', 'nieparzysty', 'parzysty'] >>> y = bisect.bisect(b, "Mimetyczny") >>> print y 0 >>> bisect.insort(b, "Mimetyczny") >>> print b ['Mimetyczny', 'Nigdy', 'lub', ^'nieparzysty', 'parzysty'] >>> bisect.insort(b, "") >>> print b [", 'Mimetyczny', 'Nigdy', 'lub', ^'nieparzysty', 'parzysty']

34 34 Dzielenie posortowanej listy >>> a = [1, 2, 3, 5, 7, 9, 11] >>> import bisect >>> a[:bisect.bisect(a, 5)] [1, 2, 3, 5] >>> a[bisect.bisect (a, 5):] [7, 9, 11] >>> a[bisect.bisect (a, 6):] [7, 9, 11] >>> a [bisect.bisect (a, 13):] # bisect zwraca 7 [] >>> a[bisect.bisect (a, -1):] # bisect zwraca 0 [1, 2, 3, 5, 7, 9, 11] >>> a[bisect.bisect (a, len(a)/2):] [5, 7, 9, 11] >>> a[:bisect.bisect(a, len(a)/2)] [1, 2, 3]

35 35 Definiowanie relacji < Metoda sort() sortuje listy zgodnie z domyślnymi regułami sortowania obowiązującymi w języku Python. Metoda ta korzysta wewnętrznie z funkcji cmp() przy porównywaniu wartości dwóch obiektów. Funkcja cmp(x,y) porównuje obiekty x i y oraz zwraca -1, jeśli x y. Aby zdefiniować własną kolejność sortowania, należy utworzyć własną funkcję podobną do funkcji cmp() i przekazać ją jako argument do metody sort() Sortowanie listy według samodzielnie określonej kolejności sortowania 1.Zdefiniuj funkcję porównującą cmpfunc która pobierać będzie dwa argumenty (pozycje listy) i będzie zwracać -1, 0 lub 1 w zależności od tego, czy pierwszy argument zostanie potraktowany jako mniejszy, równy lub większy niż drugi argument. 2.Wpisz s.sort(cmpfunc), by posortować listę s w kolejności zdefiniowanej przez cmpfunc. Wyrażenie s jest wyrażeniem listy.

36 36 Przykłady >>> cmp("sekwoja", "mimetyczny") 1 >>> cmp(5.0, 5) 0 >>> cmp([], [0, 1]) >>> cmp(("a", "b"), ("a", "B")) 1 >>> cmp("aa", "b") -1 >>> cmp(len("aa"), len("b")) 1 >>> def cmp_ignorecasetx, y): … return cmp(x.lower(), y.lower()) … >>> a = "Travis trips trapshooting Trappist traders".split() >>> print a ['Travis', 'trips', 'trapshooting', 'Trappist', 'traders'] >>> >>> a.sort() # Sortowanie domyślne >>> print a ['Trappist', 'Travis', 'traders', 'trapshooting', 'trips'] >>> >>> a.sort(cmp_ignorecase) # Sortowanie definiowane >>> print a ['traders', 'Trappist', 'trapshooting', 'Travis', 'trips']

37 37 Własna relacja < - Uwagi Sortowanie definiowane przez użytkownika wykonywane jest bardzo wolno w porównaniu z sortowaniem domyślnym. Można zdefiniować funkcję sortującą cmpfunc w taki sposób, by lista była sortowana w kolejności malejącej, jednak szybciej będą działać metody sort() i reverse() cmpfunc nie musi obowiązkowo zwracać -1, 0 lub 1. Może ona zwracać dowolną liczbę ujemną, zero lub dowolną liczbę dodatnią. Funkcje z modułu bisect nie działają poprawnie w przypadku list posortowanych według samodzielnie zdefiniowanej kolejności

38 38 Odwracanie kolejności listy >>> a = [4, 1, 3. 4, 0] >>> a.reverse() >>> print a [0, 4, 3, 1, 4] >>> a.sort() >>> a.reverse() >>> print a [4, 4, 3, 1, 0] >>> b = "Nigdy parzysty lub nieparzysty" >> c = list(b) >> c.reverse() >>> b = "".join(c) >>> print b ytsyzrapein bul ytsyzrap ydgiN

39 39


Pobierz ppt "1 Programowanie w językach skryptowych 1 Wykład 4: Podstawy Pythona Listy i krotki Opracował: Dr inż.. Marcin Janaszewski Katedra Informatyki Stosowanej."

Podobne prezentacje


Reklamy Google