Tekst źródłowy strony TI/Stałe i zmienne

==Stałe dosłowne==
Przykładem stałej dosłownej jest:
* liczba, np. <tt>5</tt>, <tt>1.23</tt>, <tt> 9.25e-3</tt>
* napis w rodzaju <tt>'To jest napis'</tt> albo <tt>"To też jest napis!"</tt>.
Nazywa się ją dosłowną, bo jest dosłowna, tzn. zawsze używasz jej wartości w sposób dosłowny. Przykładowo liczba <tt>2</tt> zawsze reprezentuje samą siebie i nic innego. Jest stałą, ponieważ jej wartości nie można zmienić. Stąd wszystkie stałe tego typu nazywa się stałymi dosłownymi.

====Zadanie====
Proszę skorzystać z linii poleceń pythona jak ze standardowego kalkulatora.

Wpisywane przez nas liczby to stałe dosłowne. Proszę zwrócić uwagę na wyniki dzielenia <tt>1/2</tt> i <tt>1.0/2</tt>
===Liczby===
Liczby w Pythonie dzielimy na trzy główne typy: całkowite (ang. ''integers''),
zmiennoprzecinkowe (ang. ''floating point'' albo krócej: ''float'') i zespolone (ang. ''complex'').

* Przykładami liczb całkowitych są <tt>2</tt> i <tt>1025</tt>.
* Przykłady liczb zmiennoprzecinkowych to: <tt>3.23</tt> i <tt>52.3E–4</tt>.
W przypadku liczb zmiennoprzecinkowych część znajdująca się przed znakiem <tt>E</tt> nazywana jest mantysą. Po znaku <tt>E</tt> znajduje się wykładnik. Wartość liczby to
mantysa razy 10 podniesione do danego wykładnika.
:{| align="left"
|- 
| <tt>52.3E–4</tt>
| = 52,3&middot;10<sup>–4</sup>
|-
|}<br style="clear: both" />

* Jednostkę urojoną zapisujemy jako <tt>j</tt> po liczbie, tak więc
:{| align="left"
|- 
| <tt>–5 + 4j</tt>
| = –5 + 4''i''
|-  
| <tt>2.3 – 4.6j</tt>
| = 2,3 – 4,6''i''
|-
| <tt>1j</tt>
| = ''i''
|}
<br style="clear: both" />

===Napisy===
Napis (ang. ''string'') to po prostu ciąg znaków.


====Apostrof (<tt>'</tt>)====
Napis można zapisać w programie używając apostrofów
<source lang=python>
'Możecie mnie cytować.'
</source>
Wszystkie znaki (litery, odstępy, tabulatory) są zachowane w niezmienionej postaci.

====Cudzysłów (<tt>"</tt>)====
Napisy w cudzysłowach zapisuje się tak samo jak w apostrofach.
<source lang=python>
"Zażółcić gęślą jaźń."
</source>
Różnica jest taka, że w napisie w apostrofach można łatwo zawrzeć cudzysłów,
a w napisie w cudzysłowach, apostrof. Później, w trakcie używania napisu, nie ma żadnego znaczenia to, w jaki sposób został on zapisany.

====Potrójny cudzysłów lub apostrof (<tt>"""</tt> lub <tt><nowiki>'''</nowiki></tt>)====
Za pomocą potrójnych cudzysłowów lub apostrofów możesz oznaczać napisy wielolinijkowe. Co więcej, wewnątrz nich możesz swobodnie używać zarówno cudzysłowów jak i apostrofów. Najlepiej zilustruje to przykład:

<source lang=python>
'''Litwo, ojczyzno moja,
ty jesteś jak zdrowie.
Ile cię trzeba cenić,
ten tylko się dowie,
kto cię stracił.
'''
</source>

====Sekwencje specjalne====
Wyobraź sobie, że chcesz zapisać napis, który zawiera apostrof (<tt>'</tt>), na przykład <tt>Nie lubię Harry'ego</tt>.  Nie można zapisać <tt>'Nie lubię Harry'ego'</tt>, bo Python nie zrozumie, gdzie napis ma koniec. Musimy więc wyraźnie zaznaczyć, że ten konkretny apostrof pomiędzy <tt>y</tt> a <tt>e</tt> nie oznacza końca napisu. Tutaj z pomocą przychodzą nam właśnie ''sekwencje specjalne''. Za ich pomocą możemy zapisać ów apostrof jako <tt>\'</tt>, z ukośnikiem wstecznym. Zatem nasz napis, poprawnie zapisany, wygląda tak: <tt>'Nie lubię Harry\'ego'</tt>.

W tym konkretnym wypadku lepiej jednak jest użyć cudzysłowów do zaznaczenia granic napisu: <tt>"Nie lubię Harry'ego"</tt>. Po to właśnie istnieje możliwość używania zarówno cudzysłowów jak i apostrofów.

A co w przypadku napisów wielolinijkowych? Można użyć potrójnych cudzysłowów, jak pokazaliśmy wyżej. Można także użyć znaków ucieczki, aby zapisać ''znak specjalny'' &mdash; znak nowej linii. Robimy to w następujący sposób: <tt>To jest pierwszy wiersz\nTo jest drugi wiersz</tt>.

Oprócz <tt>\n</tt> istnieje więcej znaków specjalnych, ale w miarę często używa się tylko jeszcze jednego, czyli znaku tabulacji <tt>\t</tt>. Znak tabulacji zachowuje się trochę jak 8 lub 4 spacje.

Możemy także zrobić rzecz odwrotną, a mianowicie zapisać napis niezawierający znaków nowej linii w wielu wierszach w programie:

<source lang=python>
"To jest pierwsze zdanie. \
A to drugie."
</source>

Powyższy przykład jest równoważny napisowi <tt>"To jest pierwsze zdanie. A to drugie."</tt>. Zauważ, że umieściliśmy spację przed ukośnikiem wstecznym &mdash; w przeciwnym wypadku <tt>A</tt> występowałoby w napisie bezpośrednio po kropce.

;Napisy surowe
Jeżeli musisz stworzyć napis, który nie zawiera żadnych sekwencji specjalnych, a zawiera fragmenty ze wstecznymi ukośnikami, przydatną opcją są napisy ''surowe'' (ang. ''raw''). Tworzymy je, poprzedzając napis literą <tt>r</tt> lub <tt>R</tt>. Przykład: <tt>r"Nowe linie zapisujemy za pomocą \n."</tt>.

;Napisy Unikodowe 
Unikod (ang. ''Unicode'') jest zestandaryzowanym sposobem zapisu tekstu w różnych językach. Jeśli chcesz zapisać tekst np. w języku polskim, prawdopodobnie wiesz, że najlepiej jest użyć edytora z obsługą unikodu. Python również daje Ci możliwość użycia Unikodu: wystarczy przy zapisie napisu jako przedrostek dodać <tt>u</tt> lub <tt>U</tt>, na przykład: <tt>u"Ten tekst zapisaliśmy w Unikodzie."</tt>. Niezależnie od tego, z jakiego kodowania korzysta dany komputer, nie będzie on miał problemu z poprawnym odczytaniem tekstu zapisanego w unikodzie, więc używaj unikodowego zapisu napisów dla tekstów, które zawierają np. polskie znaki, a mogą być odczytywane przez różne komputery.

W systemie linuks możemy zadeklarować chęć korzystania ze znaków w kodowaniu UTF. Do tego służy nam linijka <tt># -*- coding: utf-8 -*-</tt> na początku kodu, która informuje interpreter, że w kodzie mogą się pojawić znaki niestandardowe (teksty zostaną zakodowane w systemie UTF-8).  W systemie Windows musimy dopisywać literkę <tt>u</tt> przed ciągiem znaków zawierających polskie litery. W Linuksie owe <tt>u</tt> nie przeszkadza, więc chcąc mieć przenośny kod powinniśmy to <tt>u</tt> dopisywać.

;Napisy są niezmienne (ang. ''immutable'')
Oznacza to, że jeżeli już raz utworzyłeś napis, nie możesz go zmienić. 

;Automatyczne łączenie napisów zapisanych obok siebie
Jeżeli umieścimy dwa napisy obok siebie, Python automatycznie je połączy. Spójrz na przykład: <tt>'Jak ' 'Cię zwą?'</tt> zostanie automatycznie przekonwertowane do <tt>'Jak Cię zwą?'</tt>.
{{Wyjaśnienie|title=Uwaga dla programujących w innych językach====
;Uwaga dla programujących w C/C++
:W Pythonie nie ma wydzielonego typu <tt>char</tt>. Nie ma takiej potrzeby, bo napis o długości 1 służy jako znak.

;Uwaga dla programujących w Perlu/PHP
:Pamiętajcie, że napisy zawarte w pojedynczych i podwójnych cudzysłowach są dokładnie tym samym: nie ma żadnej różnicy za wyjątkiem zapisu.


==Zmienne==
Używanie tylko stałych dosłownych może szybko stać się nudne — potrzebujemy sposobu przechowywania informacji i manipulowania nimi. Do tego właśnie służą ''zmienne''. Są dokładnie tym, co mówi nam ich nazwa, czyli mogą ulegać zmianom, a to oznacza, że możesz w nich przechowywać cokolwiek. Zmienne to nic innego, tylko fragmenty pamięci Twojego komputera, w których przechowywana jest jakaś informacja. W przeciwieństwie do stałych, musisz mieć możliwość dostępu do tych danych, tak więc zmiennym nadajemy nazwy. Najpierw tylko zobaczmy, jakie nazwy możesz nadać zmiennym.

=== Nazewnictwo identyfikatorów ===
Zmienne są przykładami identyfikatorów. ''Identyfikatory'' to nazwy, które nadajemy ''czemuś'' do zidentyfikowania tego. Tworząc identyfikatory w Pythonie, musisz trzymać się kilku zasad:

* Pierwszym znakiem identyfikatora musi być mała lub wielka litera alfabetu łacińskiego (więc polskie znaki są niedopuszczalne) albo podkreślnik (<tt>_</tt>).
* Pozostałe znaki mogą zawierać małe lub wielkie litery alfabetu łacińskiego, podkreślniki oraz cyfry (<tt>0</tt>-<tt>9</tt>).
* Wielkość znaków w identyfikatorze jest ważna. Stąd <tt>mojanazwa</tt> i <tt>mojaNazwa</tt> to zupełnie co innego. Zwróć uwagę na wielkie <tt>N</tt> w drugim przykładzie.
* Przykłady ''poprawnych'' identyfikatorów to: <tt>i</tt>, <tt>__moja_nazwa</tt>, <tt>nazwa_23</tt>, <tt>a1b2_c3</tt>.
* Przykłady ''niepoprawnych'' identyfikatorów to: <tt>2nazwy</tt>, <tt>nazwa ze spacjami</tt>, <tt>moja-nazwa</tt>.

Aby nadać zmiennej jakąś wartość trzeba wartość ''przypisać'' do zmiennej. Robi się to przy pomocy operatora '''=''' (operatora przypisania). Zwróć uwagę, że jest to zupełnie inny sens znaku „=” niż w matematyce.

====Zadanie====
Proszę w linii komend wytworzyć na próbę prawidłowe i nieprawidłowe nazwy zmiennych.


;Uwaga  dla programujących w językach ze statycznym typowaniem (jak C/C++)
Aby użyć zmiennej, wystarczy przydzielić jej jakąś wartość. Nie musimy tej zmiennej deklarować ani nadawać jej konkretnego typu danych.

=== Przykład użycia zmiennych i stałych dosłownych ===
Teraz zobaczymy, jak w programach używać zmiennych razem ze stałymi dosłownymi.
====Polecenie====
 Zapisz poniższy przykład i uruchom program.

<source lang= python>
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: zmienne.py
i = 5
print i
i = i + 1
print i
s = '''To jest napis wielolinijkowy.
To jest drugi wiersz.'''
print s
</source>

;Spodziewany wynik<nowiki>:</nowiki>
<source lang= python>
$ python zmienne.py
5
6
To jest napis wielolinijkowy.
To jest drugi wiersz.
</source>

=== Jak to działa? ===
Najpierw przypisujemy stałą dosłowną <tt>5</tt> do zmiennej <tt>i</tt> za pomocą operatora przypisania (<tt>=</tt>). Linia ta nazywa się poleceniem, ponieważ zleca ona Pythonowi wykonanie czegoś: w tym przypadku łączymy nazwę zmiennej <tt>i</tt> z wartością <tt>5</tt>.

Następnie, również za pomocą polecenia, wypisujemy wartość zmiennej <tt>i</tt> na ekran, używając <tt>print</tt>.

Później dodajemy <tt>1</tt> do wartości przechowywanej w zmiennej <tt>i</tt> i zapisujemy nowo obliczoną wartość z powrotem do zmiennej <tt>i</tt>. Potem wypisujemy wartość zmiennej <tt>i</tt> i, jak się spodziewaliśmy, dostajemy <tt>6</tt>.

Analogicznie postępujemy ze zmienną <tt>s</tt>, której przydzielamy wartość dosłowną napisu i wypisujemy ją.

====Zadanie====
Napisać program <tt>witaj</tt> ze zmienną (tzn. niech imię będzie zmienną, a program będzie wypisywał <tt>Witaj, </tt>imię).


W czasie wykonywania programu możemy podawać mu dane. Jedną z funkcji służących do wprowadzania danych przez użytkownika w czasie wykonywania programu jest <tt>raw_input()</tt>. Z funkcji tej można skorzystać np. tak: <tt>a = raw_input(''napis, który program ma wyświetlić'')</tt>. Takie wywołanie funkcji powoduje wyświetlenie w konsoli podanego w argumencie napisu. Następnie funkcja czeka, aż użytkownik napisze coś i zakończy wprowadzanie danych naciśnięciem <tt>Enter</tt>. Wprowadzony przez użytkownika napis przypisywany jest do zmiennej <tt>a</tt>.

====Zadanie====
 Napisać program <tt>witaj</tt>, który najpierw zapyta użytkownika o imię  a następnie wypisze <tt>Witaj, </tt>imię).


== Typy danych ==
Zmienne przechowują wartości różnego rodzaju: są to ''typy danych''. Podstawowe typy danych już poznaliśmy, są to liczby i napisy. W następnych rozdziałach dowiemy się, jak tworzyć nasze własne typy danych za pomocą klas.

=== Obiekty===
Od teraz zapamiętaj, że Python traktuje wszystkie rzeczy użyte w programie jako ''obiekty''. Rozumiemy to w ogólnym sensie. Zamiast mówić "to ''coś''", mówimy "ten ''obiekt''".
{{Wyjaśnienie|title=Uwaga dla programujących w językach zorientowanych obiektowo| text=
Python jest silnie zorientowany obiektowo, co oznacza, że wszystko jest obiektem, włącznie z liczbami, napisami i funkcjami.


==Operatory==
Większość poleceń, jak będziesz w przyszłości pisał, będzie zawierała '''wyrażenia''' (ang. ''expressions''). Prostym przykładem wyrażenia może być <tt>2 + 3</tt>. Wyrażenie możemy podzielić na operatory i operandy.

''Operatory'' to funkcjonalności, które coś robią i są reprezentowane przez symbole, jak <tt>+</tt>, albo przez specjalne słowa kluczowe. Operatory, jak sama nazwa wskazuje, muszą na czymś operować &mdash; tym czymś są ''operandy''. W naszym przypadku operandami są <tt>2</tt> i <tt>3</tt>.
Spójrz na tabelę przedstawiającą operatory i ich użycie.

Zanim jednak to zrobisz, pozwól, że przypomnę Ci, że możesz obliczyć wartość wyrażenia, bezpośrednio używając linii poleceń interpretera. Spójrz na przykład:

<source lang= python>
>>> 2 + 3
5
>>> 3 * 5
15
>>>
</source>

====Polecenie====
Proszę przetestować działnie wybranych operatorów z poniższej tabeli


===Tabela operatorów ===

Uwaga: nie musisz od razu przyswajać sobie całej poniższej tabeli. Jest ona duża, ale po to, żeby wszystkie informacje na ten temat były zebrane w jednym miejscu. Można będzie do niej wracać w razie potrzeby, w trakcie późniejszej nauki.
{| border="1" class='wikitable'
|+ '''Operatory i ich użycie'''
!
!Operator
!Nazwa
!Wyjaśnienie
!Przykłady
|- style="background-color:#e3d9d9"
| rowspan=7 align=center style="background-color:#e3c5c5" | o<br>p<br>e<br>r<br>a<br>c<br>j<br>e<br><br>a<br>l<br>g<br>e<br>b<br>r<br>a<br>i<br>c<br>z<br>n<br>e
| align=center | +
| Plus
| Dodaje dwa obiekty.
| <tt>3 + 5</tt> daje <tt>8</tt>.<tt>'a' + 'b'</tt> daje <tt>'ab'</tt>.
|- style="background-color:#e3d9d9"
| align=center | –
| Minus
| Daje liczbę przeciwną do danej liczby bądź odejmuje jedną liczbę od drugiej.
| <tt>–5.2</tt> daje liczbę ujemną.

<tt>50 – 24</tt> daje <tt>26</tt>.
|- style="background-color:#e3d9d9"
| align=center | <nowiki>*</nowiki>
| Mnożenie
| Daje iloczyn dwóch liczb bądź zwraca napis powtórzony zadaną liczbę razy.
| <tt>2 * 3</tt> daje <tt>6</tt>.

<tt>'la' * 3</tt> daje <tt>'lalala'</tt>.
|- style="background-color:#e3d9d9"
| align=center | <nowiki>**</nowiki>
| Potęgowanie
| Zwraca x do potęgi y.
| <tt>3 ** 4</tt> daje <tt>81</tt> (czyli <tt>3 * 3 * 3 * 3</tt>).
|- style="background-color:#e3d9d9"
| align=center | /
| Dzielenie
| Dzieli x przez y.
| <tt>4 / 3</tt> daje <tt>1</tt> (ponieważ dzielimy dwie liczby całkowite).

<tt>4.0 / 3</tt> oraz <tt>4 / 3.0</tt> daje <tt>1.3333333333333333</tt>.
|- style="background-color:#e3d9d9"
| align=center | //
| Dzielenie całkowite (ang. ''floor division'')
| Zwraca wynik dzielenia całkowitego.
| <tt>4 // 3.0</tt> daje <tt>1</tt>.
|- style="background-color:#e3d9d9"
| align=center | %
| Dzielenie modulo
| Zwraca wynik z dzielenia modulo, czyli po prostu resztę z dzielenia.
| <tt>8 % 3</tt> daje <tt>2</tt>.

<tt>-25.5 % 2.25</tt> daje <tt>1.5</tt>.
|-
| rowspan=6 align=center style="background-color:#d3d9d9" | o<br>p<br>e<br>r<br>a<br>c<br>j<br>e<br><br>b<br>i<br>t<br>o<br>w<br>e
| align=center | <<
| Przesunięcie bitowe (ang. ''shift'') w lewo
| Przesuwa daną liczbę o zadaną liczbę bitów w lewo (pamiętaj, że liczby są zapisywane w pamięci postaci dwójkowej, czyli przez 0 i 1).
| <tt>2 << 2</tt> daje <tt>8</tt>. <tt>2</tt> to <tt>10</tt> w zapisie dwójkowym. Przesunięcie w lewo o 2 bity daje <tt>1000</tt>, czyli <tt>8</tt> w zapisie dziesiętnym.
|-
| align=center | >>
| Przesunięcie bitowe w prawo
| Przesuwa daną liczbę o zadaną liczbę bitów w prawo.
| <tt>11 >> 1</tt> daje <tt>5</tt>. <tt>11</tt> w zapisie dwójkowym to <tt>1011</tt>, czyli przesuwając o 1 bit w prawo dostajemy <tt>101</tt>, czyli <tt>5</tt> w zapisie dziesiętnym.
|-
| align=center | &
| Iloczyn bitowy (bitowe „i”, ang. ''bitwise AND'')
| Zwraca iloczyn bitowy wszystkich odpowiadających bitów podanych liczb.
| <tt>5 & 3</tt> daje <tt>1</tt>.
|-
| align=center | <nowiki>|</nowiki>
| Suma (alternatywa) bitowa (bitowe „lub”, ang. ''bitwise OR'')
| Zwraca sumę bitową wszystkich odpowiadających bitów podanych liczb.
| <tt>5 <nowiki>|</nowiki> 3</tt> daje <tt>7</tt>.
|-
| align=center | ^
| Bitowa różnica symetryczna (bitowe „albo”, ang. ''bitwise XOR'')
| Zwraca bitową różnicę symetryczną wszystkich odpowiadających bitów podanych liczb.
| <tt>5 ^ 3</tt> daje <tt>6</tt>.
|-
| align=center | ~
| Odwrócenie wszystkich bitów (ang. ''bitwise invert'')
| Odwrócenie wszystkich bitów x daje –(x+1).
| <tt>~5</tt> daje <tt>–6</tt>.
|- style="background-color:#e3d9d9"
| rowspan=6 align=center style="background-color:#e3c5c5" | p<br>r<br>z<br>y<br>r<br>ó<br>w<br>n<br>a<br>n<br>i<br>a
| align=center | <
| Mniejsze niż
| Zwraca wartość logiczną zdania „x mniejsze od y”. Wszystkie operatory porównania zwracają <tt>True</tt> (prawda) lub <tt>False</tt> (fałsz). Zwróć uwagę na wielkie litery na początku.
| <tt>5 < 3</tt> daje <tt>False</tt>, a <tt>3 < 5</tt> daje <tt>True</tt>.

Porównania mogą być dowolnie łączone: <tt>3 < 5 < 7</tt> daje <tt>True</tt>.
|- style="background-color:#e3d9d9"
| align=center | >
| Większe niż
| Zwraca wartość logiczną zdania „x większe od y”.
| <tt>5 > 3</tt> daje <tt>True</tt>.
|- style="background-color:#e3d9d9"
| align=center | <=
| Mniejsze lub równe
| Zwraca wartość logiczną zdania „x mniejsze lub równe y”.
| <tt>x = 3; y = 6</tt>

<tt>x <= y</tt> daje <tt>True</tt>.
|- style="background-color:#e3d9d9"
| align=center | >=
| Większe lub równe
| Zwraca wartość logiczną zdania „x większe lub równe y”.
| <tt>x = 4; y = 3</tt>

<tt>x >= 3</tt> daje <tt>True</tt>.
|- style="background-color:#e3d9d9"
| align=center | <nowiki>==</nowiki>
| Równe
| Zwraca wartość logiczną zdania „x równe y”.
| <tt>x = 2; y = 2; x == y</tt> daje <tt>True</tt>.

<tt>x = 'str'; y = 'stR'; x == y</tt> daje <tt>False</tt>.

<tt>x = 'str'; y = 'str'; x == y</tt> daje <tt>True</tt>.
|- style="background-color:#e3d9d9"
| align=center | !=
| Nie jest równe
| Zwraca wartość logiczną zdania „x nie jest równe y”.
| <tt>x = 2; y = 3</tt>

<tt>x != y</tt> daje <tt>True</tt>.
|-
| rowspan=3 align=center style="background-color:#d3d9d9" |  o<br>p<br>e<br>r<br>c<br>j<br>e<br><br>l<br>o<br>g<br>i<br>c<br>z<br>n<br>e
| align=center | not
| Zaprzeczenie logiczne (logiczne „nie”, ang. ''boolean NOT'')
| Jeśli x jest prawdą, zwracane jest <tt>False</tt>. Jeśli x jest fałszem, zwracane jest <tt>True</tt>.
| <tt>x = True; not x</tt> daje <tt>False</tt>.
|-
| align=center | and
| Iloczyn logiczny (logiczne „i”, ang. ''boolean AND'')
| <tt>x and y</tt> zwraca <tt>x</tt>, jeżeli <tt>x</tt> jest fałszem, w przeciwnym wypadku zwraca <tt>y</tt>
| <tt>x = False; y = sin(30)</tt>

<tt>x and y</tt> daje <tt>False</tt>, ponieważ <tt>x</tt> jest fałszem. W tym przypadku Python nie oblicza wartości <tt>y</tt>, ponieważ w trakcie wykonywania iloczynu okazuje się, że lewa strona wyrażenia jest nieprawdą, co oznacza, że na pewno całe wyrażenie jest nieprawdą, niezależnie od wartości logicznej <tt>y</tt>. Nazywa się to warunkowym obliczaniem wartości wyrażenia {{ang|short-circuit evaluation.
|-
| align=center | or
| Suma logiczna (logiczne „lub”, ang. ''boolean OR'')
| Jeśli <tt>x</tt> jest prawdą, zwracane jest <tt>x</tt>, w przeciwnym wypadku zwracane jest <tt>y</tt>.
| <tt>x = 3; y = False</tt>

<tt>x or y</tt> zwraca <tt>3</tt>. Warunkowe wyliczanie wartości również tutaj ma zastosowanie.
|-
| rowspan=10 align=center style="background-color:#d3f9d3" |  o<br>p<br>e<br>r<br>c<br>j<br>e<br><br>n<br>a<br><br>z<br>b<br>i<br>o<br>r<br>a<br>c<br>h
| align=center | <nowiki>|</nowiki>
| Suma zbiorów
| Zwraca zbiór wszystkich elementów które są w pierwszym zbiorze lub są w drugim zbiorze.
| <tt>set([1,3,5]) <nowiki>|</nowiki> set([7,3])</tt> daje <tt>set([1,3,5,7])</tt>.
|-
| align=center | &minus;
| Różnica zbiorów
| Zwraca zbiór elementów które są w pierwszym zbiorze i nie są w drugim zbiorze.
| <tt>set([1,3,5]) &minus; set([7,3])</tt> daje <tt>set([1,5])</tt>. 
|-
| align=center | <nowiki>&</nowiki>
| Przecięcie (część wspólna, iloczyn) zbiorów
| Zwraca zbiór elementów które są w pierwszym zbiorze i są w drugim zbiorze.
| <tt>set([1,3,5]) <nowiki>&</nowiki> set([7,3])</tt> daje <tt>set([3])</tt>. 
|-
| align=center | <nowiki>^</nowiki>
| Elementy unikalne
| Zwraca zbiór zawierający elementy nie będące wspólne dla dwu zbiorów.
| <tt>set([1,3,5]) <nowiki>^</nowiki> set([7,3])</tt> daje <tt>set([1,5,7])</tt>. 
|-
| align=center | in
| Sprawdzenie czy jest elementem.
| Zwraca wartość logiczną zdania &bdquo;x jest elementem zbioru A&rdquo;.
| <tt>3 in set([1,3,5])</tt> daje <tt>True</tt>. 
|-
| align=center | not in
| Sprawdzenie czy nie jest elementem
| Zwraca wartość logiczną zdania &bdquo;x nie jest elementem zbioru A&rdquo;.
| <tt>3 not in set([1,3,5])</tt> daje <tt>False</tt>. 
|-
| align=center | <
| Sprawdzenie czy jest podzbiorem
| Zwraca wartość logiczną zdania &bdquo;A jest podzbiorem zbioru B&rdquo;.
| <tt>set([1,3]) < set([7,3])</tt> daje <tt>False</tt>.<br><tt>set([1,3]) < set([1,7,3])</tt> daje <tt>True</tt>. 
|-
| align=center | >
| Sprawdzenie czy jest nadzbiorem
| Zwraca wartość logiczną zdania &bdquo;A jest nadzbiorem zbioru B&rdquo;.
| <tt>set([1,5,3]) > set([7,3])</tt> daje <tt>False</tt>.<br><tt>set([1,5,3]) > set([1,3])</tt> daje <tt>True</tt>. 
|-
| align=center | ==
| Sprawdzenie czy są jednakowe
| Zwraca wartość logiczną twierdzenia, że każdy element pierwszego zbioru jest elementem drugiego zbioru i każdy element drugiego zbioru jest elementem pierwszego.
| <tt>set([1,3,5]) == set([7,3])</tt> daje <tt>False</tt>.<br><tt>set([1,3,5]) == set([5,3,1])</tt> daje <tt>True</tt>. 
|-
| align=center | !=
| Sprawdzenie czy nie są jednakowe
| Zwraca wartość logiczną twierdzenia, że pierwszy zbiór nie jest jednakowy z drugim.
| <tt>set([1,3,5]) != set([7,3])</tt> daje <tt>True</tt>. 

|}

Nie ma obowiązku przyswojenia całej tabeli operatorów naraz &mdash; jej zawartość jest po kolei omawiana w następnych rozdziałach: operacje algebraiczne [[#Wyrażenia|za moment]], operacje logiczne i przyrównania w rozdziale o [[TI\Programowanie z Pythonem/Wykonanie warunkowe|wykonaniu warunkowym]], a operacje bitowe w rozdziale [[Operacje bitowe|o operacjach bitowych]].

===Kolejność wykonywania===

Jeśli mamy wyrażenie typu <tt>2 + 3 * 4</tt>, co jest wykonywane najpierw: dodawanie czy mnożenie? Znając reguły matematyczne, możemy stwierdzić, ze mnożenie powinno być wykonane w pierwszej kolejności, co oznacza, że operator mnożenia ma wyższy priorytet {{ang|precedence od operatora dodawania. O kolejności wykonywania operacji decyduje tabela priorytetów operatorów.

Jeśli chcesz zmienić kolejność wykonywania działań, również musisz użyć nawiasów. Aby dodawanie zostało wykonane przed mnożeniem, należy napisać na przykład <tt>(2 + 3) * 4</tt>.

Czasem używa się nawiasów, mimo że nie powoduje to zmiany kolejności wykonywania.
Przykładowo można napisać <tt>2 + (3 * 4)</tt>, żeby podkreślić, że mnożenie jest wykonywane wcześniej. Nie należy z tym przesadzać.

Poniższa tabela daje nam spojrzenie na priorytety operatorów w Pythonie, od najwyższego (wykonywanego najpierw) do najniższego (wykonywany w ostatniej kolejności). W praktyce wygląda to tak, że w wyrażeniu najpierw wykonane zostaną operacje położone wyżej w tabeli, a dopiero potem te z niższych wierszy.

Poniższa tabela jest dość obszerna (pochodzi z [http://docs.python.org/reference/expressions.html#evaluation-order dokumentacji Pythona]), aby dać pełne spojrzenie na to zagadnienie.
Priorytety operatorów są dobrane tak, by były zgodne z przyzwyczajeniami wziętymi z matematyki,
a także by można były popularne wyrażenia zapisać bez nawiasów.
O tym, czy należy użyć nawiasów w sytuacji gdy nie są konieczne, decyduje czytelność.
Jeśli program jest bardziej zrozumiały z nawiasami, to należy ich użyć.

{| border="1" class='wikitable'
|+ '''Priorytety operatorów'''
! Operator
! Opis
|-
| <tt>()</tt>, <tt>[]</tt>, <tt>{}</tt>, <tt>` `</tt>
| wszystkie formy naturalnie zagnieżdzone: konstrukcja krotki, listy i słownika, przekształcenie w napis
|-
| f(argumenty ...), x[indeks:indeks], x[indeks], x.atrybut
| wywołanie funkcji, pobranie wycinka, wydobycie elementu, dostęp do atrybutu.
|-
| **
| potęgowanie
|-
| ~x, +x, –x
| inwersja bitowa, liczba, liczba przeciwna (operatory jednoargumentowe).
|-
| <nowiki>*</nowiki>, /, //, %
| mnożenie, dzielenie, dzielenie całkowite i dzielenie modulo
|-
| +, –
| dodawanie i odejmowanie (operatory dwuargumentowe)
|-
| <<, >>
| przesunięcia bitowe
|-
| &
| iloczyn bitowy
|-
| ^
| bitowa różnica symetryczna
|-
| <nowiki>|</nowiki>
| suma bitowa
|-
| is, is not, in, not in, <, <=, >, >=, !=, ==
| sprawdzanie identyczności, sprawdzanie przynależności, porównania. 
|-
| not x
| zaprzeczenie logiczne
|-
| and
| iloczyn logiczny
|-
| or
| suma logiczna
|-
| lambda
| wyrażenie lambda
|}


Operatory, z którymi się jeszcze nie zapoznaliśmy, zostaną wyjaśnione w następnych rozdziałach.

Operatory mające ''taki sam priorytet'' znajdują się w jednym wierszu powyższej tabeli. Przykładowo, <tt>+</tt> i <tt>–</tt> mają taki sam priorytet.

====przykład====
Weźmy wyrażenie <tt>-x**1/2</tt>. Jak zostanie ono zinterpretowane?

W tym wyrażeniu występują trzy operatory, <tt>-</tt>, <tt>**</tt> i <tt>/</tt>, oraz trzy operandy, <tt>x</tt>, <tt>1</tt> i <tt>2</tt>. Jeśli zajrzymy do tabelki powyżej, to zobaczymy, że idąc od góry, najpierw pojawia się potęgowanie, potem negacja, a jeszcze później dzielenie.

Wobec tego właściwa kolejność wykonywania jest taka: <tt>(-(x**1))/2</tt>.


====przykład dla bardziej zaawansowanych====
Załóżmy, że chcemy sprawdzić, czy rozwiązania równania kwadratowego, <math>x_1</math>, <math>x_2</math>, są poprawne i&nbsp;ułożone rosnąco.
<source lang=python>
  delta < 0 or a*x1**2 + b*x1 + c == 0 and a*x2**2 + b*x2 + c == 0 and x1 <= x2
</source>

Wyrażenie nie jest zbyt przejrzyste, więc w prawdziwym programie lepiej byłoby tak nie pisać. Niemniej jest poprawne, co widać w poniższym równoważnym zapisie. 
<source lang=python>
(
   ( delta < 0 )
   or
   (
     ((a*x1**2 + b*x1 + c) == 0 )
     and
     ((a*x2**2 + b*x2 + c) == 0 )
     and
     (x1 <= x2)
   )
)
</source>
Szczegółowo:
# <tt>or</tt> ma najniższy priorytet
# <tt>and</tt> jest zaraz potem
# przyrównanie <tt>==</tt> ma niższy priorytet niż operacje algebraiczne <tt>*</tt>,<tt>**</tt>, <tt>+</tt>
# kolejność wykonywania operacji algebraicznych jest taka sama jak w zwykłej matematyce, czyli najpierw potęgowanie, potem mnożenie, a na końcu dodawanie.


===Łączność operatorów===
Operatory są zazwyczaj łączone od lewej do prawej, co oznacza, że operacje z tym samym pierwszeństwem są wykonywane od lewej do prawej. Przykładowo <tt>2 - 3 - 4</tt> jest wykonywane jak <tt>(2 - 3) - 4</tt>, czyli daje wynik &minus;5.

Wyjątkiem w stosunku do łączności lewostronnej jest operator potęgowania, który jest łączony od prawej do lewej, np. <tt>3**3**3</tt> daje <math>3^{\left(3^3\right)}</math>, a nie <math>\left(3^3\right)^3</math>. Czyli potęgowanie w Pythonie zachowuje się tak jak normalnie w matematyce.

Przyrównania (<tt>==</tt>, <tt><=</tt>, <tt><=</tt>, <tt>>=</tt>, <tt><</tt>, <tt>></tt>, <tt>!=</tt>) w zasadzie są łączne lewostronnie, ale w praktyce w przypadku zwykłych obiektów wynik nie zależy od kolejności wykonania. Jeśli wielokrotne przyrównania są połączone w ciąg, to wartością takiego wyrażenia jest iloczyn logiczny wszystkich przyrównań.<source lang=python>
x1 < 0 < x2
# lub równoważnie
x1 < 0 and 0 < x2
</source>

Przypisanie do wielu zmiennych jest traktowane jak przypisanie do wszystkich tych zmiennych tej samej wartości. Np. <tt>a = b = c</tt> to to samo co <tt>a = c</tt> i <tt>b = c</tt>.


====Polecenie====
Proszę przećwiczyć różne kombinacje operatorów i nawiasów.

==Wyrażenia==
Wyrażenia są kombinacjami zmiennych, stałych i łączących je operatorów. Przykładem może być wzór na obliczanie pola lub obwodu jakiejś figury geometrycznej.
==== Algorytm==== 

# Zmierz długość prostokąta i zapamiętaj jako <tt>dlugosc</tt>.
# Zmierz szerokość prostokąta i zapamiętaj jako <tt>szerokosc</tt>.
# Oblicz pole prostokąta jako długość&middot;szerokość (użyj zapamiętanych wartości) i zapamiętaj jako <tt>pole</tt>.
# Wypisz napis 'Pole wynosi' oraz wartość zapamiętaną jako <tt>pole</tt>.
# Wypisz napis 'Obwód wynosi' oraz wynik obliczenia 2&middot;(długość+szerokość) używając zapamiętanych wartości, wyniku nie zapamiętuj.


====Implementacja==== 
Proszę przepisać i uruchomić poniższy przykład

<source lang= python>
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: wyrazenia.py

dlugosc = 5
szerokosc = 2
pole = dlugosc * szerokosc
print 'Pole wynosi', pole
print 'Obwód wynosi', 2 * (dlugosc + szerokosc)
</source>




;Spodziewany wynik:

<pre>
$ python wyrazenia.py
Pole wynosi 10
Obwód wynosi 14
</pre>

=== Jak to działa? ===
Długość i szerokość prostokąta są przechowywane w zmiennych o tych samych nazwach. Użyjemy tych zmiennych, aby za pomocą wyrażeń obliczyć pole i obwód tego prostokąta. Przechowujemy wynik wyrażenia <tt>dlugosc * szerokosc</tt> w zmiennej <tt>pole</tt>, aby wypisać jej wartość za pomocą polecenia <tt>print</tt>. W przypadku obwodu bezpośrednio używamy wyrażenia <tt>2 * (dlugosc + szerokosc)</tt> w poleceniu <tt>print</tt>.

Zwróć uwagę na to, że Python jest napisany tak, by ułatwić życie programiście. Mimo, że nie umieściliśmy spacji pomiędzy <tt>'Pole wynosi'</tt>, a zmienną <tt>pole</tt>, Python wstawił ją tam za nas. Oddzielenie wypisywanych wartości spacjami to najpowszechniejsza potrzeba programisty, więc tak się dzieje, jeśli poda on pare rzeczy do wypisania.

====Zadanie==== 
Proszę napisać program do obliczania pola i obwodu koła.