TI/Sekwencje

Wprowadzenie

Struktury danych to typy danych posiadających pewną wewnętrzną organizację/strukturę. Struktury danych tworzymy łącząc w określony sposób prostsze typy danych. Przykładem może być książka telefoniczna, gdzie odpowiednio organizując i łącząc proste typy: napis (zawierający nazwisko) i int (zawierający numer telefonu) tworzymy nowy typ danych określający jak jest zbudowany pojedynczy wpisy do książki telefonicznej.

W Pythonie istnieją cztery podstawowe struktury danych — lista, krotka, słownik i zbiór. Tak naprawdę są to klasy — odpowiednio list, tuple, dict, set.

Niemniej, aby poprawnie używać obiektów, wystarczy wiedzieć, że obiekty pewnej klasy mają wspólne zachowanie zdefiniowane przez tę klasę. Oznacza to między innymi, że obiekty mają pewien zbiór metod, czyli funkcji które można uruchamiać pisząć obiekt.metoda().

Lista

Lista to struktura, która zawiera uporządkowaną sekwencję obiektów. Tych obiektów może być zero, wtedy lista jest pusta, lub dowolnie dużo. Ten sam obiekt może występować na liście wielokrotnie. Dwie najważniejsze operacje, jakie można wykonać na liście, to:

1. sekwencyjne działania na obiektach od zerowego do ostatniego. Dzięki temu można użyć listy do iterowania pętli. Wyrażenie for element in lista: rozpoczyna pętlę, w której dostępny jest kolejno każdy element listy.
2. wydobycie z listy obiektu o danym indeksie. Używamy to tego operatora indeksowania []

Łatwo sobie to wyobrazić za pomocą listy zakupów, na której masz zapisane rzeczy do kupienia. Jedyna różnica jest taka, że na liście zakupów zazwyczaj rzeczy wpisuje się jedną pod drugą, zaś w Pythonie listę zapisuje się rozdzieląc przecinkami obiekty.

Najprostszym sposobem uzyskania listy jest właśnie zapisanie w treści programu ciągu „rzeczy“ rozdzielonych przecinkami, wszystko objęte nawiasami kwadratowymi. Innym sposobem jest wywołanie funkcji, która zwróci listę.

Do listy można dodawać elementy i je z niej usuwać. Te operacje zmieniają listę, więc mówimy, że lista jest zmiennym typem danych.

Przykład użycia listy

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: lista.py

# To moja lista zakupów:
lista = ['jabłko', 'mango', 'marchew', 'kiwi']

print 'Mam', len(lista), 'rzeczy do kupienia.'

print 'Te rzeczy to:',
for i in lista:
    print i,

print '\nMuszę jeszcze kupić ryż.'
lista.append('ryż')
print 'Teraz moja lista to:', lista

print 'Posortuję moją listę.'
lista.sort()
print 'Posortowana lista to:', lista

print 'Pierwsza rzecz, jaką muszę kupić, to', lista[0]
rzecz = lista[0]
del lista[0]
print 'Kupiłem', rzecz
print 'Moja lista teraz to:', lista

Rezultat:

Mam 4 rzeczy do kupienia.
Te rzeczy to: jabłko mango marchew kiwi

Muszę jeszcze kupić ryż.
Teraz moja lista to: ['jabłko', 'mango', 'marchew', 'kiwi', 'ryż']
Posortuję moją listę.
Posortowana lista to: ['jabłko', 'kiwi', 'mango', 'marchew', 'ryż']
Pierwsza rzecz, jaką muszę kupić, to jabłko
Kupiłem jabłko
Moja lista teraz to: ['kiwi', 'mango', 'marchew', 'ryż']

Jak to działa?

Zmienna lista jest listą zakupów kogoś wybierającego się do sklepu. Przechowujemy tam jedynie słowa oznaczające przedmioty do kupienia, ale tak naprawdę lista może zawierać dowolne obiekty, np. liczby czy inne listy.

Użyliśmy też pętli for...in... do przejścia po wszystkich elementach listy. W tym momencie można zauważyć, że lista jest przykładem sekwencji. Ale sekwencje poznasz trochę później.

Zauważ, że na końcu polecenia print użyliśmy przecinka. Powoduje to, że Python zakończy wypisywanie spacją, a nie przejściem do nowej linii.

Następnie dodaliśmy obiekt do listy metodą append, po czym sprawdziliśmy, czy to podziałało, po prostu każąc wypisać nową zawartość listy na ekran.

Po tym wszystkim posortowaliśmy listę za pomocą metody sort. Ważne jest to, że wynik powstaje przez przestawianie obiektów wewnątrz tej samej listy. Innymi słowy, żaden nowy obiekt nie zostaje stworzony, zmienia się tylko kolejność elementów na liście, co nazywamy sortowaniem w miejscu.

Zamiast sortowania w miejscu, można by stworzyć nową listę zawierającą te same elementy w innej kolejności. Do wykonania takiej operacji można wykorzystać funkcję sorted:

posortowana = sorted(lista)

Istotna różnica jest taka, że posortowana jest nowym obiektem, a stara lista pozostaje nienaruszona.

Z tego przykładu widać, że lista jest typem zmiennym, czyli obiekty tej klasy można modyfikować. W przypadku innych typów, jak krotka (tuple) czy napis (str), dysponujemy tylko tym drugim sposobem sortowania. Mówimy, że są to typy niezmienne, przez co rozumiemy, że obiekt tej klasy, raz stworzony, nie może być zmieniony.

Gdy kupiliśmy już jakąś rzecz z listy, chcemy tę pozycję usunąć. Używamy do tego polecenia del — tutaj chcemy wyrzucić pierwszy (czyli w Pythonie zerowy) element, więc piszemy del lista[0].

Przydatne metody klasy lista

Poniżej prezentujemy metody dla obiektów klasy list. Niech nasza przykładowa lista nazywa się L:

L.append(x)

Dodaje element x na koniec listy L. Taki sam efekt daje wyrażenie: L[len(L):] = [x].

L.extend(L2)

Wydłuża listę L dodając na jej końcu wszystkie elementy listy L2. Taki sam efekt daje wyrażenie: L[len(L):] = L2.

L.insert(i, x)

Wstawia element x do listy L na pozycji i. Dotychczasowe elementy listy L o indeksach od i do ostatniego mają teraz indeksy zwiększone o 1. Na przykład L.insert(0, x) wstawia element x na początek listy L natomiast L.insert(len(L), x) dodaje element na koniec listy.

L.remove(x)

Usuwa z listy L pierwszy napotkany element o wartości x. Uwaga: Jeśli takiego elementu nie ma funkcja generuje błąd!

L.pop(i)

Usuwa z listy L element o indeksie i i zwraca jego wartość. Jeśli nie podamy argumetu i to domyślnie funkcja zostanie zastosowana do ostatniego elementu listy.

L.index(x)

Zwraca pierwszy napotkany na liście L element o wartości x. Uwaga: Jeśli takiego elementu nie ma funkcja generuje błąd!

L.count(x)

Zwraca liczbę wystąpień elementu o wartości x na liście L.

L.sort()

Sortuje elementy listy L w miejscu.

L.reverse()

Odwraca kolejność elementów na liście L w miejscu.

>>> L = [66.25, 333, 333, 1, 1234.5]
>>> print L.count(333), L.count(66.25), L.count('x')
2 1 0
>>> L.insert(2, -1)
>>> L.append(333)
>>> L
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> L.index(333)
1
>>> L.remove(333)
>>> L
[66.25, -1, 333, 1, 1234.5, 333]
>>> L.reverse()
>>> L
[333, 1234.5, 1, 333, -1, 66.25]
>>> L.sort()
>>> L
[-1, 1, 66.25, 333, 333, 1234.5]

Zadanie: wariancja i odchylenie standardowe średniej

Napisz program, który wczytuje wyniki pomiaru pewnej wielkości, czyli po prostu listę liczb. Niech użytkownik wpisuje liczby podając po jednej w każdej linijce „standardowego wejścia” — czyli na przykład wpisując je z klawiatury. Pusta linijka niech oznacza koniec danych.

Po wczytaniu wszystkich liczb, wypisz je w kolejności rosnącej, wraz z odchyleniem każdej liczby od średniej. Następnie wypisz nieobciążoną estymatę wariancji i odchylenia standardowego średniej całej sekwencji.

Przykład:

Wpisz liczby:
1
3
2.5

Dzięki.
Posortowane:
1     -1.167
2.5    0.333
3      0.833
wariancja=1.083
odchylenie=0.601

Wskazówka:

wariancja [math]\sigma^2 = \frac{1}{N -1} \sum_{i=1}^{N} (x_i - \mu)^2[/math]

oraz

odchylenie standardowe [math]\sigma = \sqrt{\frac{1}{{N -1}}{\sum_{i=1}^{N} (x_i - \mu)^2}}[/math]

oraz

odchylenie standardowe średniej [math]\bar\sigma = \frac{1}{\sqrt{N}}\sqrt{\frac{1}{{N -1}}{\sum_{i=1}^{N} (x_i - \mu)^2}}[/math]

Zadanie: outliers

Przez outliers rozumie się punkty odstające od reszty danych. W przypadku pomiarów takie punkty mogą na przykład pochodzić z błędnie przeprowadzonych pomiarów — jeśli mierzymy temperaturę termoparą i wszystkie pomiary temperatury dały ok. 30 mV, a tylko jeden 0 mV, to może w tym jednym pomiarze termopara odłączyła się od woltomierza? Niemniej zwyczajny statystyczny rozrzut wyników też może skutkować pomiarami leżącymi daleko od średniej, tyle że z małym prawdopodobieństwem.

W przypadku rozkładu Gaussa 99,7% wyników (średnio) pada w przedziale [μ−3σ, μ+3σ], gdzie μ to średnia, a σ to odchylenie standardowe. Napisz program, który tak jak w poprzednim przykładzie wczyta listę liczb, a następnie wypisze te z nich, które leżą poza przedziałem 3σ. Dla każdej z wypisywanych liczb wypisz też jej kolejność na liście. Na końcu napisz jaki procent liczb znalazł się poza przedziałem 3σ.

Zadanie: outliers 2

W poprzednim przykładzie liczby były wprowadzane przez użytkownika programu. Wprowadzanie liczb szybko robi się męczące. Na szczęście można użyć generatora liczb losowych, żeby „wprowadzić” liczby.

Generator liczb pseudolosowych zazwyczaj zwraca po prostu liczby z pewnego przedziału — np. pomiędzy 0 a 1 — zgodnie z rozkładem płaskim. Innymi słowy, wylosowanie liczby z dowolnego miejsca w całym przedziale jest tak samo prawdopodobne. Takim generatorem jest funkcja random.random.

W naszym przykładzie chcemy mieć liczby które przypominają wyniki pomiarów — czyli mają raczej rozkład normalny niż płaski. Jeśli dysponujemy generatorem liczb losowych płaskich, to bez problemu można „przerobić” go na generator liczb z dowolnego rozkładu jeśli tylko znamy dystrybuantę tego rozkładu. Na szczęście ten krok został już za nas wykonany i możemy po prostu skorzystać z funkcji random.normalvariate.

Funkcja normalvariate(mu, sigma) z modułu random ma dwa parametry — środek rozkładu i jego szerokość. Zwraca pojedynczą liczbę wylosowaną zgodnie z rozkładem normalnym.

Zmodyfikuj program z poprzedniego przykładu tak, by zamiast wczytywać liczby, generował je automatycznie. Od użytkownika pobierz tylko liczbę liczb n, i pożądane parametry μ, σ, a następnie posłuż się funkcją random.normalvariate by wygenerować n liczb z rozkładu normalnego.

Przykład:

>>> python outliers2.py
N= 100                        # 100 wpisane przez użytkownika
μ= 3                          # 3 wpisane przez użytkownika
σ= 1                          # 1 wpisane przez użytkownika
liczby:
2.93313883,  4.27443167,  3.02747082,  3.74820712,  1.67385955,
3.91314826,  2.85697077,  3.72747457,  0.83560025,  2.60574017,
...
3.90344627,  2.07056563,  2.01952891,  2.81624163,  -0.469027334
outliers:
100: -0.469027334
poza 3σ: 1%

Pamiętaj, że oczekiwana częstość występowania liczb spoza przedziału [math]3\sigma[/math] to tylko 3‰.

Krotka

Krotka to niemodyfikowalna lista.

Podobnie jak listy, krotki można wygodnie tworzyć, wykorzystując specjalną notację: krotkę definiuje się przez wypisanie jej elementów oddzielonych przecinkami. Często, dla czytelności, warto zamknąć definicję krotki w nawias.

Krotki używa się w sytuacji, gdy chcemy przechowywać niezmienną sekwencję obiektów.

Przykład:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: krotka.py

zoo = ('pyton', 'słoń', 'pingwin') # Pamiętaj, że nawiasy są opcjonalne.
print 'Liczba zwierząt w zoo:', len(zoo)

nowe_zoo = ('małpa', 'wielbłąd', zoo)
print 'Liczba klatek w nowym zoo:', len(nowe_zoo)
print 'Wszystkie zwierzęta w nowym zoo to:', nowe_zoo
print 'Zwierzęta sprowadzone ze starego zoo to:', nowe_zoo[2]
print 'Ostatnim zwierzęciem sprowadzonym ze starego zoo jest', nowe_zoo[2][2]
print 'Liczba zwierząt w nowym zoo:',len(nowe_zoo)-1+len(nowe_zoo[2])

Rezultat:

Liczba zwierząt w zoo: 3
Liczba klatek w nowym zoo: 3
Wszystkie zwierzęta w nowym zoo to: ('małpa', 'wielbłąd', ('pyton', 'słoń', 'pingwin'))
Zwierzęta sprowadzone ze starego zoo to: ('pyton', 'słoń', 'pingwin')
Ostatnim zwierzęciem sprowadzonym ze starego zoo jest pingwin
Liczba zwierząt w nowym zoo: 5

Jak to działa?

Zmienna zoo odnosi się do krotki złożonej ze zwierząt. Jak widać, dzięki funkcji len możemy sprawdzić długość krotki. To dodatkowo pokazuje, że krotka jest sekwencją.

Z powodu zamknięcia starego zoo, przenosimy zwierzęta do nowego. Dlatego też krotka nowe_zoo zawiera kilka zwierząt, które były już tam wcześniej, a także zwierzęta przeniesione ze starego zoo. Wracając do rzeczywistości, zauważ, że krotka w krotce nie traci swojej tożsamości.

Możemy odnieść się do pojedynczego elementu krotki poprzez podanie pozycji tego elementu w nawiasach kwadratowych, zupełnie jak przy listach. Nazywamy to operatorem indeksowania. Uzyskujemy trzeci element w krotce nowe_zoo przez wpisanie nowe_zoo[2] oraz trzeci element w trzecim elemencie tej krotki dzięki nowe_zoo[2][2].

Notacja „krotkowa”

Nawiasy

Pomimo, że są opcjonalne, warto często użyć nawiasów, by podkreślić, że tworzy się krotkę. Np.

a = (1, 2, 3)
# zamiast
a = 1, 2, 3

Z tych dwóch równoważnych wersji, pierwsza wydaje się czytelniejsza.

Odmienna sytuacja występuje w przypadku wypisywania zmiennych. Wyrażenia print 1,2,3 oraz print (1,2,3) mają różne znaczenia. Za pierwszym razem uzyskamy trzy cyfry oddzielone przecinkami, a za drugim krotkę (czyli te same trzy liczby oddzielone przecinkami, ale jeszcze dodatkowo otoczone nawiasami).

Krotka pusta lub z 1 elementem

Krotkę pustą tworzy się za pomocą pustej pary nawiasów:

pusta = ()

Krotka jednoelementowa to już większy problem. Jeśli napiszesz wyrażenie zawierające pojedynczą zmienną w nawiasach okrągłych, to (teoretycznie), można by to rozumieć jako

1. krotkę jednoelementową
2. jedno-elementowe wyrażenie wzięte w nawias

Z tych dwóch możliwości twórcy języka wybrali tą drugą. Dlatego aby stworzyć krotkę, należy użyć przecinka po pierwszym (i jedynym) jej elemencie.

Na przykład:

samotnik = (2, )

Uwaga dla programujących w Perlu

Listy w listach nie tracą swojej tożsamości. Nie są one spłaszczane, jak w Perlu. To samo odnosi się do krotki w krotce, krotki w liście, listy w krotce itd. Dla Pythona to po prostu obiekty przechowywane w innym obiekcie, to wszystko.

Sekwencje

Listy, krotki i napisy określamy mianem sekwencji. Kolejność elementów w sekwencji jest ustalona i elementy te są ponumerowane. Jest to cecha wspólna wszystkich sekwencji. Numer elementu w sekwencji jest nazywany indeksem. Podstawową operacją dla sekwencji jest pobranie wartości elementu o zadanym indeksie. Ponadto możemy sprawdzić czy dany obiekt jest elementem danej sekwencji (operatory in i not in).

Wymienione wcześniej trzy typy sekwencji — lista, krotka i ciąg znaków, mogą być dodatkowo pocięte, dzięki czemu uzyskujemy wycinek, czyli pod-sekwencję zawierającą część obiektów z oryginalnej sekwencji.

Wybieranie elementów przez indeksowanie lub wycinanie pokażemy dokładniej na przykładzie napisu. Napisy są również przykładem sekwencji elementów (liter).

Indeksy

Indeksując napis odwołujemy się do wybranego znaku. Znaki mogą być liczone od początku napisu (pierwszy ma numer 0) lub od jego końca (ostatni ma numer –1).

		0		1		2		...		–2		–1
		↓		↓		↓		↓		↓		↓
tekst =	"	S		T		R		I		N		G	"
		↑										↑
		[										]

Na powyższym rysunku czerwone indeksy są liczone od początku napisu, a niebieskie od jego końca.

Teraz przykłady:

tekst[0]	→	"S"
tekst[1]	→	"T"
tekst[2]	→	"R"
tekst[−2]	→	"N"
tekst[−0]	→	"S"
tekst[20]	→	IndexError

Nie ma indeksu −0, bo w Pythonie −0 == 0, więc −0 również wskazuje na początek napisu.

Numery wskazujące na miejsca poza końcem napisu lub przed jego początkiem są błędne, Python zwróci informację o błędzie, tzw. IndexError.

Przykład drugi:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: sekwencja.py

lista = ['jabłko', 'mango', 'marchew', 'kiwi']
imie = 'Juliusz'

# Indeksowanie
print 'Rzecz 0 to', lista[0]
print 'Rzecz 1 to', lista[1]
print 'Rzecz 2 to', lista[2]
print 'Rzecz 3 to', lista[3]
print 'Rzecz -1 to', lista[-1]
print 'Rzecz -2 to', lista[-2]
print 'Litera 0 to', imie[0]

# Cięcie listy.
print 'Rzeczy od 1 do 3 to', lista[1:3]
print 'Rzeczy od 2 do końca to', lista[2:]
print 'Rzeczy od 1 do -1 to', lista[1:-1]
print 'Rzeczy od początku do końca to', lista[:]

# Cięcie ciągu znaków.
print 'Litery od 1 do 3 to', imie[1:3]
print 'Litery od 2 do końca to', imie[2:]
print 'Litery od 1 do -1 to', imie[1:-1]
print 'Litery od początku do końca to', imie[:]

Rezultat:

Rzecz 0 to jabłko
Rzecz 1 to mango
Rzecz 2 to marchew
Rzecz 3 to kiwi
Rzecz -1 to kiwi
Rzecz -2 to marchew
Litera 0 to J
Rzeczy od 1 do 3 to ['mango', 'marchew']
Rzeczy od 2 do końca to ['marchew', 'kiwi']
Rzeczy od 1 do -1 to ['mango', 'marchew']
Rzeczy od początku do końca to ['jabłko', 'mango', 'marchew', 'kiwi']
Litery od 1 do 3 to ul
Litery od 2 do końca to liusz
Litery od 1 do -1 to ulius
Litery od początku do końca to Juliusz

Jak to działa?

Najpierw używamy indeksów do pobrania wartości poszczególnych elementów sekwencji. Nawiasy kwadratowe są operatorem indeksowania — gdy przy sekwencji podasz liczbę w nawiasach kwadratowych to uzyskasz element z danej pozycji. Pamiętaj, że w Pythonie, podobnie jak w C i wielu innych językach programowania, sekwencje czy tablice numeruje się od 0, dlatego lista[0] to pierwszy element, a lista[3] to czwarty.

Indeks może też być ujemny, wtedy liczenie zaczyna się od końca sekwencji. Dlatego lista[-1] to ostatni element, a lista[-2] to przedostatni.

Operacja pobierania wycinka jest wykonywana przez podanie obiektu do pocięcia, a następnie dwóch liczb w nawiasie kwadratowym, przedzielonych dwukropkiem.

Pierwsza liczba (przed dwukropkiem) w operacji pobrania wycinka oznacza pozycję startową, zaś druga (za dwukropkiem) wyznacza dokąd cięcie ma zostać wykonane. Jeżeli nie ma pierwszej liczby, to Python zacznie wycinać od początku. Gdy nie ma drugiej, to wytnie aż do końca. Zauważ, że cięcie zaczyna się równo z pozycją startową, ale kończy się przed pozycją końcową. To znaczy, że pozycja startowa jest zawarta w wyciętym fragmencie, ale pozycja końcowa już nie jest.

W związku z tym, lista[1:3] zwraca elementy 1 i 2, ale nie zwraca już trzeciego, zaś lista[:] (tzw. pełny wycinek) zwraca kopię sekwencji.

Możesz także podać trzeci argument, którym jest krok cięcia (domyślnie 1).

>>> lista = ['jabłko', 'mango', 'marchew', 'kiwi']
>>> lista[::1]
['jabłko', 'mango', 'marchew', 'kiwi']
>>> lista[::2]
['jabłko', 'marchew']
>>> lista[::3]
['jabłko', 'kiwi']
>>> lista[::-1]
['kiwi', 'marchew', 'mango', 'jabłko']

Jak widzisz, gdy krok wynosi 2, uzyskujemy elementy numer 0, 2, ..., zaś gdy wynosi 3, uzyskujemy elementy numer 0, 3, ... itd.

Wypróbuj różne kombinacje używając interpretera w trybie interaktywnym. Najlepsze jest to, że możesz dokładnie to samo robić na każdym typie sekwencji, czy to lista, czy krotka, czy ciąg znaków!

Zadanie

Wytwórz listę liczb naturalnych od 1 do 20. Następnie pobierz z tej sekwencji wycinek zawierający wyłącznie liczby parzyste oraz wycinek zawierający liczby nieparzyste od ostatniej do pierwszej.

Wybierz co trzecią liczbę zaczynając od 10 i nie przekraczając 20.}}

Zadanie

Masz pewien napis zawierający poszukiwane hasło w nawiasach klamrowych.

 napis = "dane_użytkownika =     {tajne hasło} login=użytkownik    "

Napisz funkcję która weźmie napis jako parametr i zwróci samo hasło bez nawiasów klamrowych.

Odniesienia

Gdy tworzysz obiekt i przypisujesz go do zmiennej, zmienna jedynie odnosi się do tego obiektu, a nie reprezentuje go. Nazywamy to związywaniem (ang. binding) nazwy z obiektem. Tak więc, nazwa zmiennej jedynie wskazuje miejsce w pamięci komputera, w którym znajdują się określone dane. Pociąga to za sobą pewne konsekwencje, które ilustruje poniższy przykład.

Przykład:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: odniesienie.py

print 'Proste Przypisywanie'
lista = ['jabłko', 'mango', 'marchew', 'kiwi']
mojalista = lista # mojalista to tylko inna nazwa dla tej samej zmiennej!

del lista[0] # Kupiłem pierwszą rzecz, więc ją usuwam z listy.

print 'Lista zakupów:', lista
print 'Moja lista:', mojalista
# Obydwie listy będą zawierać dokładnie to samo, czyli trzy pozycje.
# W żadnej z nich nie pojawi się "jabłko", bo dotyczą tego samego obiektu.

print 'Kopiowanie za pomocą pełnego wycinka'
mojalista = lista[:] # Stwórz kopię za pomocą pełnego wycinka...
del mojalista[0] # Usuń pierwszą rzecz...

print 'Lista zakupów:', lista
print 'Moja lista:', mojalista
# Teraz te listy będą się różniły.

Rezultat:

Proste Przypisywanie
Lista zakupów: ['mango', 'marchew', 'kiwi']
Moja lista: ['mango', 'marchew', 'kiwi']
Kopiowanie za pomocą pełnego wycinka
Lista zakupów: ['mango', 'marchew', 'kiwi']
Moja lista: ['marchew', 'kiwi']

Pamiętaj, że jak chcesz zrobić kopię jakiejś złożonej zmiennej (nie prostej, jak ciąg znaków), to musisz przypisać mu pełny wycinek. Jeżeli zamiast tego po prostu przypiszesz zmiennej inną nazwę, obydwie nazwy będą się odnosić do tego samego obiektu.

Uwaga dla programujących w Perl

Pamiętaj, że przypisanie listy do zmiennej nie tworzy kopii! Zawsze do skopiowania sekwencji potrzebne jest pobranie pełnego wycinka.

Więcej o ciągach znaków

Już wcześniej omówiliśmy dogłębnie ciągi znaków, więc co jeszcze można dodać? Cóż... Czy wiedziałeś, że to też są obiekty i również mają swoje metody, jak na przykład sprawdzanie, czy w danym tekście jest określone słowo?

Wszystkie ciągi znaków, jakie używasz, mają przypisaną klasę str. Poniżej zaprezentowane jest użycie kilku ciekawych metod tej klasy. Więcej informacji znajdziesz wywołując help(str).

Przykład:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: str_metody.py

imie = 'Aleksander' # To obiekt klasy str.

if imie.startswith('Ale'):
    print 'Tak, to imię zaczyna się od "Ale"'

if 'a' in imie:
    print 'Tak, to imię zawiera literę "a"'

if imie.find('san') != -1:
    print 'Tak, w tym imieniu jest ciąg "san"'

separator = ' do '
mojalista = ['Brazylii', 'Rosji', 'Indii', 'Chin']
print 'Wielka podróż z', separator.join(mojalista)

Rezultat:

$ python str_metody.py
Tak, to imię zaczyna się od "Ale"
Tak, to imię zawiera literę "a"
Tak, w tym imieniu jest ciąg "san"
Wielka podróż z Brazylii do Rosji do Indii do Chin

Jak to działa?

Tu widzimy wiele metod w akcji. Metoda startswith sprawdza, czy tekst się zaczyna od podanego ciągu znaków. Operator in sprawdza, czy dany ciąg znaków znajduje się w tym tekście.

Metoda find sprawdza pozycję podanego ciągu znaków w tekście. Zwraca ona -1, gdy nic nie znajdzie. Klasa str ma też ciekawą metodę join, która łączy elementy sekwencji w jeden długi ciąg znaków, używając podanego ciągu jako separatora.