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


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


.. tabularcolumns:: p{ 2.93447613117in } p{ 2.03156039851in } p{ 1.80583146534in }

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

  * 
    - Python
    - Komentar
    - C
  * 
    - ``boolean``

        .. 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``.
      
    - 
      Nema, u C-u se ``int`` koristi umjesto ``boolean`` (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 igrati se s pojedinačnim bitovima 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>`_.


  * 
    - ``int``
        
        .. literalinclude:: tipovi02.py.filtered
          :language: pycon
        
    - Pythonov ``int`` je implementiran pomoću C-ovog ``long``-a.
    - ``long``
  * 
    - ``long``
        
        .. literalinclude:: tipovi03.py.filtered
          :language: pycon
        
    - Pythonov ``long`` drži cijele brojeve proizvoljnog broja znamenaka.
    - C nema ugrađen takav tip.
  * 
    - ``float``
        
        .. literalinclude:: tipovi04.py.filtered
          :language: pycon
        
    - Python-ov ``float`` je implementiran pomoću C-ovog ``double``-a
    - ``double``
  * 
    - ``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``
  * 
    - ``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 ``NoneType`` a to je ``None``.


Literatura

  - https://docs.python.org/2/library/stdtypes.html#numeric-types-int-float-long-complex
  - http://www.diveintopython3.net/native-datatypes.html
  - http://www.tutorialspoint.com/python/python_variable_types.htm
  - http://www.python-course.eu/sequential_data_types.php
  - http://stackoverflow.com/questions/47981/how-do-you-set-clear-and-toggle-a-single-bit-in-c-c
  - http://graphics.stanford.edu/~seander/bithacks.html





Osnovni elementi
-----------------

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



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


  * 
    - Python
    - C
  * 
    - 
        ``and``
    - 
        ``&&``
  * 
    - 
        ``or``
    - 
        ``||``
  * 
    - 
        ``a**b``
    - 
        ``pow(a,b)``
  * 
    - 
        ``not``
    - 
        ``!``
  * 
    - 
        ``id(x)``
    - 
        ``&x`` (adresa od x)
  * 
    - 
        ``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;
        }



U sljedećoj tablici su dane daljnje sličnosti i razlike.





.. tabularcolumns:: p{ 5.02998619759in } p{ 1.90792579909in } 
.. 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 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)
    - 
        ``"xx"``
  * 
    - 
        nema tip podataka znak (char). umjesto toga koristi string duljine 1: ``"x"`` ili ``'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 


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




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


  * 
    - Python
    - C

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

      funkcija :func:`range` u pythonu proizvodi listu sa zadanim granicama.

      .. 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) 


      .. tip::
        
        ako se na ovakav način radi, python2, u memoriji drži odjednom sve vrijednosti koje se pojavljuju u petlji. to, naravno, nije zgodno u slučaju ``range(0,1000000000)`` pa se u tom slučaju koristi ``xrange(0,1000000000)``. :func:`xrange` ne generira cijelu listu unaprijed pa ne zauzima nepotrebno memoriju. (u pythonu 3 range se ponaša kao xrange u pythonu 2. u pythonu 3 xrange ne postoji.)

        http://stackoverflow.com/questions/135041/should-you-always-favor-xrange-over-range

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



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




.. tabularcolumns:: p{ 2.25728933167in } p{ 2.25728933167in } p{ 2.25728933167in }

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

      .. tip::

        korisna stvar u pythonu 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/2/library/string.html#format-examples
  - https://docs.python.org/2/library/string.html#template-strings



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


.. tabularcolumns:: p{ 2.25728933167in } p{ 2.25728933167in } p{ 2.25728933167in }

.. 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.91869593192in } p{ 1.91869593192in } p{ 2.93447613117in }

.. 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 onda takve strukture nadodavati s jedne liste na drugu...



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


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







.. tabularcolumns:: p{ 2.25728933167in } p{ 2.25728933167in } p{ 2.25728933167in }

.. 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/2/library/stdtypes.html#string-methods


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




.. tabularcolumns:: p{ 3.46895599834in } p{ 3.46895599834in } 
.. 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