Tekst źródłowy strony 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 &mdash; lista, krotka, słownik i zbiór.
<!-- podstawowe, nie wbudowane, bo wbudowanych jest więcej, np. frozenset -->
Tak naprawdę są to klasy &mdash; odpowiednio <tt>list</tt>, <tt>tuple</tt>, <tt>dict</tt>, <tt>set</tt>.

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ąć <tt>obiekt.metoda()</tt>.

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

Ł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 &bdquo;rzeczy&ldquo; 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 ===

<source lang = python>
#!/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
</source>

;Rezultat<nowiki>:</nowiki>

<source lang='bash'>
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ż']
</source>

; Jak to działa?
Zmienna <tt>lista</tt> 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 <tt>for...in...</tt> do przejścia po wszystkich elementach listy. W tym momencie można zauważyć, że lista jest przykładem ''sekwencji''. Ale sekwencje poznasz  [[TI\Programowanie_z_Pythonem/Sekwencje#Sekwencje|trochę później]].

Zauważ, że na końcu polecenia <tt>print</tt> 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ą <tt>append</tt>, 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 <tt>sort</tt>. 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ę <tt>sorted</tt>:
<source lang='py'>posortowana = sorted(lista)</source> Istotna różnica jest taka, że <tt>posortowana</tt> jest nowym obiektem, a stara <tt>lista</tt> 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 (<tt>tuple</tt>) czy napis (<tt>str</tt>), 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 <tt>del</tt> &mdash; tutaj chcemy wyrzucić pierwszy (czyli w Pythonie zerowy) element, więc piszemy <tt>del lista[0]</tt>.

=== Przydatne metody klasy lista ===

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

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

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

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

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

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

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

 <tt>L.count(x)</tt>
Zwraca liczbę wystąpień elementu o wartości <tt>x</tt> na liście <tt>L</tt>.

 <tt>L.sort()</tt>
Sortuje elementy listy <tt>L</tt> '''w miejscu'''.

 <tt>L.reverse()</tt>
Odwraca kolejność elementów na liście <tt>L</tt> '''w miejscu'''.

<source lang = python>
>>> 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]
</source>

=== 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 &bdquo;standardowego wejścia&rdquo; &mdash; 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:''
<source lang='shell_example'>
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
</source>

''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 &mdash; jeśli mierzymy temperaturę termoparą i wszystkie pomiary temperatury dały ok.&nbsp;30&nbsp;mV, a&nbsp;tylko jeden 0&nbsp;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 [&mu;&minus;3&sigma;, &mu;+3&sigma;], gdzie &mu; to średnia, a &sigma; 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&sigma;. 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&sigma;.

=== 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 &bdquo;wprowadzić&rdquo;
liczby.

Generator liczb pseudolosowych zazwyczaj zwraca po prostu liczby z pewnego przedziału &mdash; np. pomiędzy 0 a 1 &mdash; 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 <tt>random.random</tt>. 

W naszym przykładzie chcemy mieć liczby które przypominają wyniki pomiarów &mdash; czyli mają raczej rozkład normalny niż płaski. Jeśli dysponujemy generatorem liczb losowych płaskich, to bez problemu można &bdquo;przerobić&rdquo; 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&nbsp;możemy po prostu skorzystać z funkcji <tt>random.normalvariate</tt>.

Funkcja <tt>normalvariate(mu, sigma)</tt> z modułu <tt>random</tt> ma dwa parametry &mdash; ś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 &mu;, &sigma;, a następnie posłuż się funkcją <tt>random.normalvariate</tt> by wygenerować ''n'' liczb z rozkładu normalnego.

''Przykład:''
<source lang='shell_example'>
>>> 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%
</source>
<!-- v = numpy.random.normal(3,1,100)
     for i in v[numpy.abs(v - v.mean()) > 3*v.var(ddof=1)**0.5]: print i
  -->
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<nowiki>:</nowiki>

<source lang = python>
#!/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])
</source>

;Rezultat<nowiki>:</nowiki>

<source lang='shell_example'>
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
</source>

;Jak to działa?
Zmienna <tt>zoo</tt> odnosi się do krotki złożonej ze zwierząt. Jak widać, dzięki funkcji <tt>len</tt> możemy sprawdzić długość krotki. To dodatkowo pokazuje, że krotka jest [[#Sekwencje|sekwencją]].

Z powodu zamknięcia starego zoo, przenosimy zwierzęta do nowego. Dlatego też krotka <tt>nowe_zoo</tt> 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 <tt>nowe_zoo</tt> przez wpisanie <tt>nowe_zoo[2]</tt> oraz trzeci element w trzecim elemencie tej krotki dzięki <tt>nowe_zoo[2][2]</tt>. 

=== Notacja &bdquo;krotkowa&rdquo; ===
====Nawiasy====
Pomimo, że są opcjonalne, warto często użyć nawiasów, by podkreślić, że tworzy się krotkę. Np.
<source lang='py'>
a = (1, 2, 3)
# zamiast
a = 1, 2, 3
</source>
Z tych dwóch równoważnych wersji, pierwsza wydaje się czytelniejsza.

Odmienna sytuacja występuje w przypadku wypisywania zmiennych.
Wyrażenia <tt>print 1,2,3</tt> oraz <tt>print (1,2,3)</tt> 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<nowiki>:</nowiki> <source lang='py'>pusta = ()</source>

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
# krotkę jednoelementową
# 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: <source lang='py'>samotnik = (2, )</source>

;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 <tt>in</tt> i <tt>not in</tt>).

Wymienione wcześniej trzy typy sekwencji &mdash; 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).

<tt>
{| style="text-align:center" cellspacing="0px"
|
| style="width:2ex" |
| style="width:2ex;color:red" |0
| style="width:2ex" |
| style="width:2ex;color:red" |1
| style="width:2ex" |
| style="width:2ex;color:red" |2
| style="width:2ex" |
| style="width:2ex" | ...
| style="width:2ex" |
| style="width:2ex;color:blue" | –2
| style="width:2ex" |
| style="width:2ex;color:blue" | –1
| style="width:2ex" |
|-
|
|
| style="background:#FFFF88" |&darr;
|
| style="background:#FFFF88" |&darr;
|
| style="background:#FFFF88" |&darr;
|
| style="background:#FFFF88" |&darr;
|
| style="background:#FFFF88" |&darr;
|
| style="background:#FFFF88" |&darr;
|
|
|-
| tekst = 
|"
! style="background:#FFFF88" | S
! 
! style="background:#FFFF88" | T
!
! style="background:#FFFF88" | R
!
! style="background:#FFFF88" | I
!
! style="background:#FFFF88" | N
!
! style="background:#FFFF88" | G
|"
|-
|
|
| style="background:#FFFF88" |&uarr;
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |&uarr;
|
|
|-
|
|
| [
|
|
|
|
|
|
|
|
|
| ]
|
|}
</tt>

Na powyższym rysunku <span style="color:red">czerwone</span> indeksy są liczone od początku napisu, a <span style="color:blue">niebieskie</span> od jego końca.

Teraz przykłady<nowiki>:</nowiki>

<tt>
{|
|-
|tekst[0] || style="width:3em;text-align:center" | &rarr; || "S"
|-
|tekst[1] || style="width:3em;text-align:center" | &rarr; || "T"
|-
|tekst[2] || style="width:3em;text-align:center" | &rarr; || "R"
|-
|tekst[&minus;2] || style="width:3em;text-align:center" | &rarr; || "N"
|-
|tekst[&minus;0] || style="width:3em;text-align:center" | &rarr; || "S"
|-
|tekst[20] || style="width:3em;text-align:center" | &rarr; || {{color|red|IndexError}}
|-
|}
</tt>

Nie ma indeksu &minus;0, bo w Pythonie <tt>&minus;0 == 0</tt>, więc &minus;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. <tt>IndexError</tt>.



;Przykład drugi<nowiki>:</nowiki>

<source lang = python>
#!/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[:]
</source>

;Rezultat<nowiki>:</nowiki>

<source lang='shell_example'>
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
</source>

===Jak to działa?===
Najpierw używamy indeksów do pobrania wartości poszczególnych elementów sekwencji. Nawiasy kwadratowe są operatorem indeksowania &mdash; 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 <tt>lista[0]</tt> to pierwszy element, a <tt>lista[3]</tt> to czwarty.

Indeks może też być ujemny, wtedy liczenie zaczyna się od końca sekwencji. Dlatego <tt>lista[-1]</tt> to ostatni element, a <tt>lista[-2]</tt> 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, <tt>lista[1:3]</tt> zwraca elementy 1 i 2, ale nie zwraca już trzeciego, zaś <tt>lista[:]</tt> (tzw. ''pełny wycinek'') zwraca kopię sekwencji.

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

<source lang = python>
>>> 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']
</source>

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!


<!-- {{Solution|title=Przykład na użyteczność wycinka|text=
{{TI:Indeksowanie napisu/obcięcie cudzysłowó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<nowiki>:</nowiki>

<source lang = python>
#!/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.
</source>

;Rezultat<nowiki>:</nowiki>

<source lang='shell_example'>
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']
</source>

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ę <tt>str</tt>. Poniżej zaprezentowane jest użycie kilku ciekawych metod tej klasy. Więcej informacji znajdziesz wywołując <tt>help(str)</tt>.

;Przykład<nowiki>:</nowiki>

<source lang = python>
#!/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)
</source>

;Rezultat<nowiki>:</nowiki>

<source lang='shell_example'>
$ 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
</source>

===Jak to działa?===
Tu widzimy wiele metod w akcji. Metoda <tt>startswith</tt> sprawdza, czy tekst się zaczyna od podanego ciągu znaków. Operator <tt>in</tt> sprawdza, czy dany ciąg znaków znajduje się w tym tekście.

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