Usporedba osnovnih elemenata C-a i python-a
===========================================

Pregled često korištenih tipova podataka
----------------------------------------

Sljedeća tablica prikazuje često korištene tipove podataka u pythonu i referencu na odjeljak gdje se navedeni tip detaljnije diskutira.


.. tabularcolumns:: p{ 2.2572893316728933in } p{ 2.2572893316728933in }  p{ 2.2572893316728933in } 
.. list-table::
  :header-rows: 1

  * 
    - opis
    - *mutable*
    - *immutable*
  * 
    - jednostavni tipovi, brojevi
    - 
    - :class:`int`, :class:`float`, :class:`complex`, :class:`bool`, :class:`NoneType` (vidi :ref:`osno`)
  * 
    - niz byteova
    - :class:`bytearray`
    - :class:`bytes` (vidi :ref:`datoteke_bin`, :ref:`unicode`)
  * 
    - niz unicode znakova (=string)
    - nema, ali :class:`io.StringIO`, :class:`array.array`, :class:`bytearray`, :class:`list` mogu poslužiti
    - :class:`str` (:ref:`stringovi`, :ref:`stringovi2`, detalji u :ref:`unicode`)

  * 
    - niz objekata
    - :class:`list`
    - :class:`tuple`
  * 
    - niz objekata određenog tipa ("homogeno" polje)
    - :class:`array.array`
    - 
  * 
    - niz objekata bez ponavljanja
    - :class:`set`
    - :class:`frozenset`
  * 
    - rječnik
    - :class:`dict` (vidi :ref:`rjecnik`)
    - 
*Mutable* varijable se mogu mijenjati, *immutable* varijable se ne mogu mijenjati (konstante su). Treba primijetiti da su u C-u primitivni tipovi podataka :class:`int`, :class:`float`, ... *mutable*, a u pythonu su *immutable*. Razlika između *mutable* i  *immutable* diskutira se u odjeljku :ref:`pridruzivanjelista`.


Osnovne primjere upotrebe možete naći u raznim tutorialima npr.:
  - http://www.diveintopython3.net/native-datatypes.html


Operatori
---------

Operatori su slični kao u C-u. Postoje razlike, npr. postoji poseban operator ``//`` za cjelobrojno dijeljenje kao i za potenciranje ``**``. 


.. tabularcolumns:: p{ 3.4689559983395597in } p{ 3.4689559983395597in } 
.. list-table::
  :header-rows: 1


  * 
    - Python
    - C
  * 
    - 
        ``and``
    - 
        ``&&``
  * 
    - 
        ``or``
    - 
        ``||``
  * 
    - 
        ``a**b``
    - 
        ``pow(a,b)``
  * 
    - 
        ``a/b``
    - 
        ``((double)a)/b`` (dijeljenje s decimalama)
  * 
    - 
        ``a//b``
    - 
        ``a/b`` ako su oba cjelobrojni, inače ``floor(a/b)``
  * 
    - 
        ``not``
    - 
        ``!``
  * 
    - 
        ``id(x)``
    - 
        ``&x`` (adresa od x)


U pythonu postoji operator ``in`` koji pretražuje postoji li element u skupu. Npr. u sljedećem primjeru provjeravamo jesu li ``1``, ``'1'``, ``''`` elementi liste ``a``:

.. literalinclude:: tipovi_in.py.filtered
  :language: pycon

Direktan rad s memorijom u pythonu nije podržan što znači da ne postoji operator za očitavanje vrijednosti na adresi kao ``*`` u C-u. Ne postoji operator za očitavanje adrese objekta ali postoji funkcija ``id()`` koja očitava "identitet" objekta. U CPythonu se kao "identitet" objekta koristi adresa objekta.

Popis operatora s jednostavnim primjerima:
  - https://www.tutorialspoint.com/python/python_basic_operators.htm


Korisne kratice
-----------------------------

Umnožak stringa i broja slijepi više primjeraka tog stringa npr. ``'xy'*3`` daje ``'xyxyxy'``. Slično za liste i tupleove: ``[1,2]*3`` daje ``[1,2,1,2,1,2]``.

Korisne kratice su i:


.. tabularcolumns:: p{ 3.4689559983395597in } p{ 3.4689559983395597in } 
.. list-table::
  :header-rows: 1

  * 
    - Python
    - C
  * 
    - ``a<b<c`` 
    - ``a<b && b<c``
  * 
    - ``a,b,c = 1,2,3`` 
    - ``a=1; b=2; c=3;``
  *
    - 
      Na sličan način funkcija može vratiti "dvije vrijednosti":

      .. literalinclude:: tipovi_ret2.py
        :language: python
      .. literalinclude:: tipovi_ret2.py.filtered
        :language: text

      Također, (generatorske) funkcije mogu vratiti više vrijednosti, ali jednu po jednu, što ima prednost da nisu sve odjednom u memoriji (vidi npr. :ref:`gen_pridr`).


    -
      U C-u se to obično radi koristeći polja ili strukture što je manje elegantno.

Zadavanje vrijednosti tipa :class:`tuple`, :class:`list`, :class:`set`
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Povratnu vrijednost u gornjem primjeru mogli smo pridružiti i jednoj varijabli.

.. literalinclude:: tipovi_ret2b.py
  :language: python
.. literalinclude:: tipovi_ret2b.py.filtered
  :language: text

Vidimo da je vrijednost te varijable ``(12, 20)`` a tip :class:`tuple`.

.. note::
  Nizovi vrijednosti tipa :class:`tuple` zadaju se pomoću okruglih zagrada, 
  nizovi tipa :class:`list` pomoću uglatih, 
  nizovi tipa :class:`set` (kao i :class:`dict`)  pomoću vitičastih.
  
  U slučaju tipa :class:`tuple` zagrade se u nekim slučajevima mogu izostaviti. 
  To smo vidjeli kod naredbe ``return`` (npr. ``return a,b,c`` je isto što i ``return (a, b, c)``). 
  Naredbe koje to dopuštaju su npr. ``yield``, ``for`` i pridruživanje.

.. literalinclude:: tipovi_zad.py
  :language: python
.. literalinclude:: tipovi_zad.py.filtered
  :language: text


.. _osno:

Osnovni tipovi podataka
-----------------------


.. tabularcolumns:: p{ 2.9344761311747614in } p{ 2.031560398505604in } p{ 1.8058314653383147in }

.. list-table::
  :header-rows: 1

  * 
    - Python
    - Komentar
    - C
  * 
    - :class:`bool`

        .. literalinclude:: tipovi01.py.filtered
          :language: pycon
        
    - Logički tip podataka ``True``, ``False``. 
      U Pythonu ``None``, razne nule (``0``, ``0.0``), prazne liste ``[]``, stringovi ``""``, itd. kad se koriste kao logički uvjet znače ``False``.
      
    - 
      U starijem standardu C-a ne postoji, od C99 nadalje postoji i naziva se ``_Bool``. I u starim i u novim verzijama C-a tip ``int`` se može svugdje koristiti umjesto ``_Bool`` (na računalima u F26 ``_Bool`` zauzima 4 bytea što možemo vidjeti pomoću  ``sizeof(1==0)`` koji vrati broj 4). 

      Kad je potrebno držati u memoriji polje ``boolean`` vrijednosti, radi štednje memorije možemo koristiti npr. ``char`` umjesto ``int`` ili radi još veće uštede koristiti pojedinačne bitove unutar veće varijable kao `ovdje <http://stackoverflow.com/questions/47981/how-do-you-set-clear-and-toggle-a-single-bit-in-c-c>`_ ili `ovdje <http://graphics.stanford.edu/~seander/bithacks.html>`_.


  * 
    - :class:`int`
        
        .. literalinclude:: tipovi02.py.filtered
          :language: pycon
        
        .. literalinclude:: tipovi03.py.filtered
          :language: pycon
        
    - Pythonov :class:`int` drži cijele brojeve proizvoljnog broja znamenaka.
    - C nema ugrađen takav tip. Slični tipovi su ``int``, ``long``, samo oni ne drže proizvoljan broj znamenki.
  * 
    - :class:`float`
        
        .. literalinclude:: tipovi04.py.filtered
          :language: pycon
        
    - Python-ov :class:`float` je implementiran pomoću C-ovog ``double``-a
    - ``double``
  * 
    - :class:`complex`
        
        .. literalinclude:: tipovi05.py.filtered
          :language: pycon
        
    - Noviji C prevoditelji podržavaju kompleksne brojeve. Primjeri na: http://stackoverflow.com/questions/6418807/how-to-work-with-complex-numbers-in-c.
    - ``double complex``
  * 
    - :class:`NoneType`
        
        .. literalinclude:: tipovi06.py.filtered
          :language: pycon
        
    - Varijabla se postavi na ovaj tip kad je definirana ali nije inicijalizirana. Primjer je funkcija koja zaboravi vratiti vrijednost:

      .. literalinclude:: tipovi07.py
        :language: python
      .. literalinclude:: tipovi07.py.filtered
        :language: text
        

    - Podsjeća na ``void`` u C-u, samo u C-u nisu postojale vrijednosti tipa ``void``, postojao je samo tip ``void``. U pythonu postoji samo jedna moguća vrijednost tipa :class:`NoneType` a to je ``None``.


Literatura

  - https://docs.python.org/3/library/stdtypes.html#numeric-types-int-float-long-complex
  - http://www.tutorialspoint.com/python/python_variable_types.htm
  - http://www.python-course.eu/sequential_data_types.php





Grananje i petlje
-----------------

Neke očite sličnosti i razlike  C-a i python-a vidimo u sljedećoj tablici.



.. tabularcolumns:: p{ 1.7344779991697798in } p{ 1.7344779991697798in } 
.. list-table::
  :header-rows: 1


  * 
    - Python
    - C
  * 
    - 
        ``break``
    -
        ``break;``
  * 
    - 
        ``continue``
    -
        ``continue;``
  * 
    - 
      ::
        
        if uvjet:
          radnja
    -
      .. code-block:: c 
        
        if(uvjet){
          radnja;
        }
  * 
    - 
      ::
        
        if uvjet:
          radnja1
        else:
          radnja2
    - 
      .. code-block:: c 
        
        if(uvjet){
          radnja1;
        }
        else{
          radnja2;
        }

  * 
    - 
      ::
        
        while uvjet:
          radnja1
    - 
      .. code-block:: c 
        
        while(uvjet){
          radnja1;
        }



Osnovni elementi programa
---------------------------------------------------------




.. tabularcolumns:: p{ 5.029986197592361in } p{ 1.907925799086758in } 
.. list-table::
  :header-rows: 1


  * 
    - Python
    - C
  * 
    - 
        Indentacija

        .. note:: U pythonu nema vitičastih zagrada, a blok naredbi je definiran time što je uvučen u desno, **relativno na prethodni red**, pomoću razmaka ili tabova. Kako broj razmaka koje tab predstavlja nije fiksan (tj. može se namjestiti u editoru po želji) bitno je to indentiranje raditi uniformno. Preporuča se koristiti isključivo razmake za uvlačenje (npr. 2 ili 4). Da bi se olakšalo upisivanje obično je moguće namjestiti u editoru da pritisak na tab generira npr. 4 razmaka ``' '`` (a ne tab ``'\t'``).
        .. note:: U C-u se lako moglo definirati prazan blok pomoću ``;`` ili ``{}``. Za tu svrhu u pythonu postoji naredba ``pass`` koja isto tako ne radi ništa.

    - 
        Vitičaste zagrade
  * 
    - 
        Svaka naredba u svom redu ili ``;``
    - 
        ``;``
  * 
    - 
        ``'xx'`` ili ``"xx"`` ili ``"""xx"""`` (trostruki navodnici mogu uključivati više redaka teksta)

        Kod unosa stringova u pythonu postoje još neke mogućnosti koje postignu dodavanjem slova (tzv. prefiksa) ispred prvih navodnika.

        Prefiks ``r`` omogućuje upis znaka ``\`` bez potrebe da se piše ``\\``, tj. dovoljno je samo ``r"\"``. 
        Naravno u takvom zapisu ne možemo upisati znak za novi red ``\n`` jer je ``r"\n"`` isto što i ``"\\n"``. 
        Ovakav zapis je koristan kad je potrebno upisivati stringove koji sadrže veliki broj znakova ``\``.

        Prefiks ``f`` omogućuje lagano ubacivanje vrijednosti varijabli u string, te formatiranje. (Više na https://realpython.com/python-f-strings/)

        .. literalinclude:: op_fstr.py
          :language: python
        .. literalinclude:: op_fstr.py.filtered
          :language: text

        Prefiks ``u`` se koristio u pythonu 2. U pythonu 3 se podrazumijeva da su stringovi nizovi unicode znakova.

    - 
        ``"xx"``
  * 
    - 
        Nema tip podataka znak (char). Umjesto toga koristi string duljine 1: ``"x"`` (ili niz byteova duljine 1: ``b"x"``).
    - 
        ``'x'``
  * 
    - 
        Python izvršava kôd naredbu po naredbu. Ne pregledava točnost unaprijed kao C nego tek u trenutku izvršavanja. To znači da ako se program u pythonu uspije pokrenuti, ne znači da u njemu nema tipfelera.

    - 
        C sve provjerava unaprijed.
  * 
    - Case sensitive (tj. razlikuje velika i mala slova)
    - Također case sensitive 
  * 
    - Heksadecimalni brojevi unose se koristeći prefiks ``0x``.

      Dodatno, radi preglednosti, grupe znamenki se mogu razdvajati znakom ``_``.
      Npr.:
      
      .. literalinclude:: op_grupe.py
        :language: python
      .. literalinclude:: op_grupe.py.filtered
        :language: text


    - Također ``0x``.


``for`` petlja
----------------------------




.. tabularcolumns:: p{ 5.029986197592361in } p{ 1.907925799086758in } 
.. list-table::
  :header-rows: 1


  * 
    - Python
    - C

  * 
    - 
      ::
        
        for i in range(pocetak,kraj,korak):
          radnja

      :func:`range` je oznaka za interval sa zadanim granicama i iznosom koraka. U pythonu 2 rezultat poziva ``range(...)`` je lista brojeva, u pythonu 3 rezultat je objekt tipa ``range``.
      
      .. literalinclude:: op1_for_range.py
        :language: python
      .. literalinclude:: op1_for_range.py.filtered
        :language: text

      Tip ``range`` predstavlja niz podataka (tj. *sequence type*) kao ``tuple`` i ``list``. Može se lako pretvoriti u listu:

      .. literalinclude:: op1_for_range_seq.py
        :language: python
      .. literalinclude:: op1_for_range_seq.py.filtered
        :language: text

      Za potrebe for petlje možemo koristiti bilo koji tip koji je niz ili koji se može iterirati. Ne mora nužno biti ``range``. O generatorima/iteratorima vidi napomenu u :ref:`gen`.

      .. literalinclude:: op1_17.py
        :language: python
      .. literalinclude:: op1_17.py.filtered
        :language: text

      .. attention::

        Bitno je uočiti da su elementi liste uvijek manji od granice ``kraj``. (npr. u gornjem primjeru broj 26 nije u listi) 

    - 
      .. code-block:: c 
        
        for(i=pocetak; i<kraj; i+=korak){
          radnja;
        }



Formatiranje (formatirani ispis)
----------------------------------




.. tabularcolumns:: p{ 2.2572893316728933in } p{ 2.2572893316728933in } p{ 2.2572893316728933in }

.. list-table::
  :header-rows: 0
  
  * 
    - 
      Formatiranje stringova i brojeva.

      .. tip::

        Korisna mogućnost pythona je operator ``%`` koji radi više manje isto što i ``sprintf`` iz C-a
      .. tip::

        U pythonu nije moguće direktno zbrojiti string i broj nego broj treba pretvoriti u string: ``"broj = " + str(6)``
    - 
        .. literalinclude:: op1_2.py
          :language: python
        .. literalinclude:: op1_2.py.filtered
          :language: text

    - 
        .. literalinclude:: op1_2.c
          :language: c
        .. literalinclude:: op1_2.c.filtered
          :language: text

Python podržava i druge načine formatiranja. Pogledati primjere na:

  - https://docs.python.org/3/tutorial/inputoutput.html
  - https://cito.github.io/blog/f-strings/
  - https://docs.python.org/3/library/string.html#format-examples
  - https://docs.python.org/3/library/string.html#template-strings
  - https://www.python.org/dev/peps/pep-0498/
  - https://realpython.com/python-f-strings/

.. _stringovi:

Stringovi i polja (liste)
-----------------------------


.. tabularcolumns:: p{ 2.2572893316728933in } p{ 2.2572893316728933in } p{ 2.2572893316728933in }

.. list-table::
  :header-rows: 0
  
  * 
    - 
      Duljina stringa
    - 
      .. code-block:: python

        len(a)
    - 
      .. code-block:: c

        strlen(a)
  * 
    - 
      Duljina polja
    - 
        .. literalinclude:: op1_4.py
          :language: python
        .. literalinclude:: op1_4.py.filtered
          :language: text
    - 
        .. literalinclude:: op1_4.c
          :language: c
        .. literalinclude:: op1_4.c.filtered
          :language: text
  * 
    - 
        Ispis elemenata polja
    - 
        .. literalinclude:: op1_5.py
          :language: python
        .. literalinclude:: op1_5.py.filtered
          :language: text
    - 
        .. literalinclude:: op1_5.c
          :language: c
        .. literalinclude:: op1_5.c.filtered
          :language: text
  * 
    - 
      .. tip::
        
        Ispis elemenata polja na
        način tipičan za python
    - 
        .. literalinclude:: op1_5b.py
          :language: python
        .. literalinclude:: op1_5b.py.filtered
          :language: text
    -


Zbrajanje i nadodavanje
^^^^^^^^^^^^^^^^^^^^^^^^^



.. tabularcolumns:: p{ 1.9186959319219592in } p{ 1.9186959319219592in } p{ 2.9344761311747614in }

.. list-table::
  :header-rows: 0
  
  * 
    - 
      Zbrajanje stringova = nadodavanje stringa na string
    - 
        .. literalinclude:: op1_3.py
          :language: python
        .. literalinclude:: op1_3.py.filtered
          :language: text
    - 
        .. literalinclude:: op1_3.c
          :language: c
        .. literalinclude:: op1_3.c.filtered
          :language: text
  *
    -
        Zbrajanje lista = nadodavanje liste na listu
    -
        .. literalinclude:: op1_8.py
          :language: python
        .. literalinclude:: op1_8.py.filtered
          :language: text
    -
        .. literalinclude:: op1_7.c
          :language: c
        .. literalinclude:: op1_7.c.filtered
          :language: text
  *
    -
        Nadodavanje elemenata na listu

    -
        .. literalinclude:: op1_18.py
          :language: python
        .. literalinclude:: op1_18.py.filtered
          :language: text
    -
        .. literalinclude:: op1_18.c
          :language: c
        .. literalinclude:: op1_18.c.filtered
          :language: text

  *
    -
        Zbrajanje lista moguće i za liste s elementima raznih tipova
    -
        .. literalinclude:: op1_6.py
          :language: python
        .. literalinclude:: op1_6.py.filtered
          :language: text
    -
        U C-u je ovo komplicirano. Trebalo bi raditi s listom struktura koji sadrže: informacije o tipu podataka + pointer na same podatke i takve strukture nadodavati s jedne liste na drugu.



.. note:: Python omogućuje i razne druge operacije nad listama - pogledati https://docs.python.org/3/tutorial/datastructures.html


.. _stringovi2:

Rad sa stringovima
------------------







.. tabularcolumns:: p{ 2.2572893316728933in } p{ 2.2572893316728933in } p{ 2.2572893316728933in }

.. list-table::
  :header-rows: 0


  *
    -
        mijenjanje stringova
    -
        u pythonu nije dopušteno mijenjati stringove, iako to ne dolazi do izražaja jer je dopušteno::
        
          a=a+"3"
        
        gornja naredba kreira **novi** string a zaboravi stari.
        nakon izvršavanja gornje naredbe ``a`` pokazuje na novi string.
        memoriju zauzetu starim stringom oslobodi u nekom trenutku python-ov 
        *garbage collector*, ako više nije potrebna.

        u žargonu se kaže da su u pythonu stringovi *immutable*. (a liste su *mutable*)

        .. note:: pogledati :ref:`pridruzivanjelista`
    -
        u C-u je promjena dopuštena. 

        .. code-block:: c
          
          strcat(a,"3")

        gornja naredba je promijenila sadržaj na koji ``a`` pokazuje, ali sam pointer ``a`` je ostao isti.
        
        za razliku od pythona programer mora paziti da se ne prekorači rezervirana duljina od ``a``.
  *
    -
        mala u velika slova
    -
        .. literalinclude:: op1_13.py
          :language: python
        .. literalinclude:: op1_13.py.filtered
          :language: text

        treba primijetiti da je sam ``a`` ostao isti tj. ``"string"``

    -
        .. literalinclude:: op1_13.c
          :language: c
        .. literalinclude:: op1_13.c.filtered
          :language: text

        u C-u je lakše napraviti tako da se sadržaj od ``a`` promijeni (u žargonu: *in-place* operacija)


  *
    -
        traženje podstringa u stringu
    -
        .. literalinclude:: op1_15.py
          :language: python
        .. literalinclude:: op1_15.py.filtered
          :language: text

    -
        .. literalinclude:: op1_15.c
          :language: c
        .. literalinclude:: op1_15.c.filtered
          :language: text

  *
    -
        pristup pojedinim znakovima u stringu
    -
        .. code-block:: python

          a[1]
    -
        .. code-block:: c

          a[1]
  *
    -
        pristup podstringovima
    -
        .. literalinclude:: op1_16.py
          :language: python
        .. literalinclude:: op1_16.py.filtered
          :language: text
    -
        .. literalinclude:: op1_16.c
          :language: c
        .. literalinclude:: op1_16.c.filtered
          :language: text

.. note:: Popis funkcija (preciznije, metoda) za rad sa stringovima na https://docs.python.org/3/library/stdtypes.html#string-methods


Dijelovi stringa/liste
----------------------




.. tabularcolumns:: p{ 3.4689559983395597in } p{ 3.4689559983395597in } 
.. list-table::
  :header-rows: 1


  *
    -
        radnja
    -
        kôd
  *
    -
        sve osim prvog
    -
        .. literalinclude:: op1_12.py.filtered
          :language: pycon
  *
    -
        prva 3 znaka/elementa
    -
        .. literalinclude:: op1_11.py.filtered
          :language: pycon
  *
    -
        zadnja 3 znaka/elementa
    -
        .. literalinclude:: op1_10.py.filtered
          :language: pycon
  *
    -
        odbaciti prvi i zadnji
    -
        .. literalinclude:: op1_9.py.filtered
          :language: pycon