Mini Kurs Pythona #3: Jak zacząć ? Podstawowe typy danych.

Przyszedł czas na sprawdzenie podstaw Pythona w praktyce (nawiasem mówiąc nie znam skuteczniejszej metody nauki). Wykorzystamy do tego wspomnianą wcześniej sesję interaktywną. Po jej uruchomieniu zobaczymy mniej więcej coś takiego:

Python 3.5.2 (default, Nov 23 2017, 16:37:01)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.

>>>

A więc… Zaczynajmy ! Na początek tradycyjnie:

>>> print('Hello World')
Hello World

print jest funkcją wypisującą tekst na ekranie.

Po naciśnięciu przycisku ENTER każde wyrażenie wprowadzone w sesji interaktywnej jest natychmiast wykonywane, a jego wynik jest wypisywany na ekranie.

Podstawy.

Python posiada swój zestaw typów wbudowanych oraz operacji podstawowych. Jak już wspomniałem wcześniej, Python jest językiem typowanym dynamicznie. Nie musimy deklarować typów zmiennych przed ich użyciem.

Możemy po prostu wykonać przypisanie:

>>> x
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined
>>> x = 4
>>> x
4
>>> type(x)
<class 'int'>
>>> type(4)
<class 'int'>
>>>

Sesja zapamiętuje zmienną (nazwę) `x` oraz przypisaną do niej wartość. Podanie nazwy zmiennej w sesji interaktywnej powoduje wypisanie na ekran wartości przechowywanej w zmiennej. Zmienna `x` nie istnieje, dopóki czegoś do niej po raz pierwszy nie przypiszemy. W tym przypadku typem zmiennej (a tak naprawdę typem przechowywanej wartości) jest `int`. Mówi nam o tym wywołanie funkcji `type`.

Tak naprawdę każdy, nawet podstawowy typ danych, jest w Pythonie klasą.

Python jest dość intuicyjny, jeśli chodzi o podstawowe typy danych oraz operacje na nich. Możemy sprawdzić, jak radzi sobie sesja interaktywna w roli prostego kalkulatora:

>>> 2 + 2
4
>>> 3 * 4
12
>>> x = 2 * 5 - 1
>>> x
9
>>> x + 11
20

Brak zaskoczeń 🙂 Ale przyjrzyjmy się temu nieco bliżej…

Podstawowe typy danych.

Python posiada szereg typów wbudowanych. Są to:
– liczby (`int, float, complex`): `13, 3.14, 4j + 7`
– tekst (`str`): `’przykład nr 1′, „przykład nr 2″`
– lista (`list`): `[3, 17, 'tekst’, False]`
– krotka (`tuple`): `(3, 17, 'tekst’, False)`
– słownik (`dict`): `[’klucz’: 'wartość’, 44: 77, 'status’: False]`
– typ logiczny (`bool`): `True, False`

Pomimo tego, że zmiennych nie musimy deklarować z konkretnym typem (dynamiczne typowanie), typ przechowywanych wartości zawsze jest ściśle zdefiniowany (silne typowanie).

Zmienne możemy modyfikować na 3 sposoby:
– używając operatorów (przy czym dla różnych typów przechowywanych wartości ten sam operator może oznaczać coś innego)
– używając ogólnych funkcji wbudowanych
– używając funkcji wewnętrznych, zdefiniowanych tylko dla pojedynczego typu (klasy)

Poćwiczmy na konkretnych przykładach…

Liczby.

Zabawa operatorami jest bardzo intuicyjna w przypadku liczb:

>>> 4 + 7
11
>>> 3 - 5
-2
>>> 3.5 + 1.5
5.0
>>> 1.11 * 4
4.44
>>> 12 / 3
4.0
>>> 7 / 3
2.3333333333333335
>>> 7 // 3
2
>>> 7 % 3
1

Jedyną ciekawostką jest tutaj dzielenie. W Pythonie 3, standardowym operatorem dzielenia jest pojedynczy ukośnik (`/`). Natomiast znak podwójnego ukośnika (`//`) wykonuje dzielenie całkowitoliczbowe (bez reszty). Operatorem reszty z dzielenia jest znak procenta (`%`).

Podobnie sprawa wygląda w przypadku operatorów logicznych:

>>> 3 < 5
True
>>> 3 == 3
True
>>> 2 == 7
False
>>> 13 > 44
False
>>> 0 != 1
True
>>> 8 <= 10
True

Wynikiem działania operatorów logicznych jest zawsze prawda lub fałsz.

Teksty.

Klasa `str` reprezentuje w Pythonie wszelkiego rodzaju teksty:

>>> 'tekst'
'tekst'
>>> str1 = 'przykład'
>>> str1
'przykład'
>>> type(str1)
<class 'str'>
>>> "To" + " jest" + " przykład" + " tekstu."
'To jest przykład tekstu.'

Tekst możemy umieścić pomiędzy znakami pojedynczego (`”`) lub podwójnego (`„”`) cudzysłowu – efekt będzie dokładnie taki sam. Jak widzimy, operator dodawania oznacza dla tekstów ich konkatenację (łączenie) w jeden wynikowy tekst.

Python posiada wiele przydatnych funkcji, dzięki którym możemy w łatwy sposób badać i modyfikować teksty. Oto kilka przykładów:

>>> len(tekst)
24

Funkcja `len` zwraca długość tekstu.

>>> tekst[0]
'P'
>>> tekst[3]
'g'

Tekst (obiekt klasy `str`) jest w Pythonie tzw. uporządkowaną kolekcją. Dzięki temu za pomocą operatora `[]` możemy dostać się do dowolnego elementu tej kolekcji. W przypadku tekstu są to po prostu pojedyncze litery – powyżej wyświetlamy pierwszą i czwartą literę naszego tekstu. Kolekcje są indeksowane od zera (podobnie jak tablice w większości języków programowania).

>>> tekst.upper()
'PROGRAMUJĘ W PYTHONIE :)'

Funkcja `upper` klasy `str` zamienia wszystkie litery na ich wielkie odpowiedniki.

>>> tekst = 'Jestem {} i mam {} lata'.format('Michał', 32)
>>> tekst
'Jestem Michał i mam 32 lata'

Jedną z najczęściej wykorzystywanych funkcji, jeśli chodzi o przetwarzanie tekstów, jest `format`. Dzięki niej można wygodnie formatować teksty, wstawiając do nich dowolne wartości.

Listy.

Listy to takie dużo bardziej inteligentne i intuicyjne tablice 🙂 W Pythonie można w nich przechowywać różnego typu wartości:

>>> lista_1 = [4, 7, 13, 44]
>>> lista_1
[4, 7, 13, 44]
>>> lista_2 = [1, 'tekst', 3.14]
>>> lista_2
[1, 'tekst', 3.14]
>>> pusta_lista = []
>>> pusta_lista
[]

Znakiem rozpoznawczym listy są nawiasy kwadratowe. Podobnie, jak w przypadku tekstów (a także krotek), możemy dostać się do każdego przechowywanego obiektu za pomocą operatora `[]`, czyli:

>>> lista = [3, 5, 7, 9, 11]
>>> lista
[3, 5, 7, 9, 11]
>>> lista[2]
7
>>> lista[4]
11
>>>

Podobnie jak wcześniej, lista jest indeksowana od zera. Co ciekawe, stosując indeksy ujemne, możemy pobrać element każdej kolekcji, licząc od końca. Np. indeks `-1` wskazuje na ostatni element listy:

>>> lista[-1]
11

Jest to sposób niezależn y od ilości elementów w kolekcji.

Kolejnym przydatnym elementem języka są tzw. wycinki, czyli możliwość uzyskania podzbioru kolekcji (tutaj listy):

>>> lista = [2, 'python', 44, 3.0, '123']
>>> lista[0:2]
[2, 'python']
>>> lista[1:4]
['python', 44, 3.0]
>>>

Zapis `lista[1:4]` oznacza, że interesuje nas zakres od elementu o indeksie `1` do elementu o indeksie `4`. Trzeba pamiętać o tym, że ten przedział jest lewostronnie domknięty i prawostronnie otwarty. Oznacza to, że w wynikowej liście znajdzie się element o indeksie `1`, ale nie znajdzie się element o indeksie 4. Rezultaty widać powyej.

Podobnie jak teksty, listy można łączyć ze sobą:

>>> lista = [2, 'python', 44, 3.0, '123']
>>> inna_lista = ['txt', 7, (4,5,6)]
>>> lista
[2, 'python', 44, 3.0, '123']
>>> inna_lista
['txt', 7, (4, 5, 6)]
>>> lista + inna_lista
[2, 'python', 44, 3.0, '123', 'txt', 7, (4, 5, 6)]
>>>

Wynik jest dość intuicyjny – dodawana lista jest po prostu doklejana do pierwszej.

Na listach można też wykonywać szereg zdefiniowanych operacji – zarówno ogólnych dla kolekcji (np. funkcja `len`), jak i typowych dla samych list. Bardzo szybko można posortować naszą listę:

>>> lista = [55, 2, 34, 77, 124, 22, 0, -4, -100, 13]
>>> lista
[55, 2, 34, 77, 124, 22, 0, -4, -100, 13]
>>> lista.sort()
>>> lista
[-100, -4, 0, 2, 13, 22, 34, 55, 77, 124]
>>>

lub dodać nowy element na jej końcu:

>>> lista = [55, 2, 34, 77, 124, 22, 0, -4, -100, 13]
>>> lista
[55, 2, 34, 77, 124, 22, 0, -4, -100, 13]
>>> lista.append(4444)
>>> lista
[55, 2, 34, 77, 124, 22, 0, -4, -100, 13, 4444]
>>>

Wszystko wygląda tutaj bardzo prosto i intuicyjnie.

Krotki.

Krotki są bardzo podobne do list. Zasadnicza różnica polega na tym, że krotki są niezmienne – podobnie do tekstów. Nie można zmodyfikować krotki po jej utworzeniu. Drugim wyróżnikiem są tutaj nawiasy okrągłe zamiast kwadratowych:

>>> krotka = (7, 20, 'tekst', 50)
>>> krotka
(7, 20, 'tekst', 50)
>>> krotka[3]
50
>>> druga_krotka = (34, 1, 0, -17)
>>> krotka + druga_krotka
(7, 20, 'tekst', 50, 34, 1, 0, -17)
>>> len(krotka)
4
>>> krotka[0:3]
(7, 20, 'tekst')
>>>

Jak widać powyżej, podobnie do tekstów i list (również kolekcji), krotki można indeksować, dodawać do siebie, tworzyć z nich wycinki i sprawdzać ich długość funkcją `len`.

Z powodu niezmienności nie rozszerzymy krotki o kolejny element (brak funkcji `append`), ani nie zamienimy wartości wybranego elementu na inną:

>>> krotka = (7, 20, 'tekst', 50)
>>> krotka.append(100)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'tuple' object has no attribute 'append'
>>> krotka[1] = 22
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>

Słowniki.

Słowniki implementują znane z innych języków programowania typy nazywane tablicami asocjacyjnymi lub nieuporządkowanymi mapami. Słownik przechowuje w sposób nieuporządkowany pary klucz:wartość.

Wygląda to tak:

>>> slownik = {1: 44, 'klucz': 'wartosc', 'xxx': 7, 100: 4444}
>>> slownik
{1: 44, 'klucz': 'wartosc', 100: 4444, 'xxx': 7}
>>> slownik['xxx']
7
>>> slownik[100]
4444
>>> slownik.keys()
dict_keys([1, 'klucz', 100, 'xxx'])
>>> slownik.values()
dict_values([44, 'wartosc', 4444, 7])
>>>

Podając klucz jako indeks, możemy się dostać do przechowywanej wartości. Przykładowe metody `keys` oraz `values` pozwalają wyświetlić wszystkie klucze oraz wartości pzrechowywane w słowniku.

Podsumowanie.

Nasza zabawa z podstawowymi typami danych w Pythonie dobiegła końca. Zachęcam do własnych eksperymentów – powyżej ledwie spojrzeliśmy na ten ciekawy temat. Mogę was zapewnić, że te podstawowe typy danych Pythona doskonale się uzupełniają i każdy będzie przez Was często wykorzystywany.

Zachęcam również do dodawania komentarzy i opinii dotyczących tego wpisu i nauki Pythona. Chętnie wezmę pod uwagę Wasze sugestie dotyczące tego artykułu – wolałbym w pierwszej kolejności opisać tematy najbardziej Was interesujące.

W następonych wpisach z serii będziemy poznawać kolejne konstrukcje języka oraz bibliotekę standardową Pythona.

Kontynuuj naukę: Mini Kurs Pythona #4: Zmienne.