.. _pridruzivanjelista:

Pridruživanje lista
===================

I u C-u i u pythonu postoje sličnosti pri radu sa stringovima i sa listama (poljima). Najveća razlika između stringova i lista u pythonu dolazi od toga da su stringovi u pythonu nepromjenjivi (*immutable*)::

          a = "100"
          #a[2] = "1" ovo bi izbacilo grešku

.. note:: U pythonu postoji i *immutable* verzija liste i taj tip podataka se naziva *tuple*. Za razliku od liste koja se zadaje uglatim, tuple se zadaje okruglim zagradama npr. ``a = (1, 2, 3)``. O razlici lista i tupleova na: http://stackoverflow.com/a/1708538










Pridruživanje vs. *shallow copy*
--------------------------------


.. tabularcolumns:: p{ 1.6514559983395598in } p{ 1.6514559983395598in } p{ 1.6514559983395598in } p{ 1.6514559983395598in }

.. list-table::
  :header-rows: 0
  
  * 
    - Pridruživanjem lista pomoću operatora pridruživanja (=) ne kopira se sadržaj liste. 
      Samo se varijabli slijeva pridruži postojeća lista navedena desno od operatora pridruživanja.
      U sljedećem primjeru vidimo da nakon pridruživanja ``a`` i ``b`` pokazuju na isti objekt što znači da ako se naknadno promijeni ``a[0]``, promijeni se i ``b[0]``.
    - 
      .. literalinclude:: list_assignment.txt.filtered
        :language: python
        :emphasize-lines: 2
    - U sljedećem primjeru pomoću ``a[:]`` cijeli sadržaj liste je kopiran i ta nova kopija je pridružena varijabli ``b``. Sad možemo mijenjati ``a`` neovisno o ``b``.
    - 
      .. literalinclude:: list_shallow.txt.filtered
        :language: python
        :emphasize-lines: 2

*Shallow copy* vs. *deep copy*
---------------------------------


.. tabularcolumns:: p{ 1.6514559983395598in } p{ 1.6514559983395598in } p{ 1.6514559983395598in } p{ 1.6514559983395598in }

.. list-table::
  :header-rows: 0
  
  * 
    - U sljedećem primjeru kopiramo listu koja u sebi sadrži referencu na drugu listu.
      Za kopiranje koristimo *shallow-copy* način iz prethodnog primjera.
      U prethodnom primjeru, *shallow-copy* je omogućio da liste ``a`` i ``b`` budu neovisne.
      Ovdje vidimo da to još uvijek vrijedi za prvi nivo liste.
      Sad je jasno zašto se ovo zove plitko kopiranje (shallow copy): kopiran je samo prvi nivo liste, drugi nivo je kopiran kao pokazivač, pa u listi ``b`` još uvijek "živi" isti objekt ``c`` koji živi u ``a``.
    - 
      .. literalinclude:: list_shallow2.txt.filtered
        :language: python
        :emphasize-lines: 3
    - Funkcija :func:`copy.deepcopy` služi da se kopiraju svi nivoi liste, tako da su u ovom primjeru ``a`` i ``b`` potpuno neovisni.
    - 
      .. literalinclude:: list_deep2.txt.filtered
        :language: python
        :emphasize-lines: 4



Razne operacije koje sve funkcioniraju kao *shallow copy*
-------------------------------------------------------------


.. tabularcolumns:: p{ 1.6514559983395598in } p{ 1.6514559983395598in } p{ 1.6514559983395598in } p{ 1.6514559983395598in }

.. list-table::
  :header-rows: 0
  
  * - 
      .. literalinclude:: list_shallow4.txt.filtered
        :language: python
        :emphasize-lines: 4
    - 
      .. literalinclude:: list_shallow3.txt.filtered
        :language: python
        :emphasize-lines: 3
    - 
      .. literalinclude:: list_shallow2.txt.filtered
        :language: python
        :emphasize-lines: 3
    - 
      .. literalinclude:: list_shallow5.txt.filtered
        :language: python
        :emphasize-lines: 3

Usporedba *immutable* i *mutable* veličina
-----------------------------------------------
Sve varijable u pythonu su interno pointeri. Python u pravilu ne omogućuje očitavanje adresa iako je u nekim implementacijama pythona (npr. u uobičajenoj implementaciji CPython) adresu moguće očitati pomoću ``id(a)``.


.. tabularcolumns:: p{ 3.4689559983395597in } p{ 3.4689559983395597in } 

.. list-table::
  :header-rows: 1
  
  * - Immutable
    - Mutable
  * - 
        .. literalinclude:: string_shallow.py
          :language: python
        .. literalinclude:: string_shallow.py.filtered
          :language: text

        Treba primijetiti da se ``b`` nije promijenio jer se stringovi ne mogu mijenjati, samo može nastati novi string.
    - 
        .. literalinclude:: string_shallow2.py
          :language: python
        .. literalinclude:: string_shallow2.py.filtered
          :language: text

        Treba primijetiti da se i ``b`` promijenio zato što je pokazivao na listu koja se u međuvremenu promijenila.


.. tabularcolumns:: p{ 3.4689559983395597in } p{ 3.4689559983395597in } 


.. list-table::
  :header-rows: 1
  
  * 
    - Mutable (*inplace* operacija)
    - Mutable (operacija koja kopira)
  * - 
        .. literalinclude:: string_shallow3.py
          :language: python
        .. literalinclude:: string_shallow3.py.filtered
          :language: text

        Isto kao primjer s :func:`list.append` (ostale moguće operacije u tablici o operacijama nad *mutable* tipovima :ref:`typesseq-mutable`).
    - 
        .. literalinclude:: string_shallow4.py
          :language: python
        .. literalinclude:: string_shallow4.py.filtered
          :language: text

        Iako je tip mutable, kad se umjesto ``+=`` koristi ``+``, rezultat je stvaranje novog neovisnog objekta, a ne proširivanje postojećeg. 


Literatura

  - https://www.python-course.eu/python3_deep_copy.php
  - http://en.wikipedia.org/wiki/Object_copy
  - http://stackoverflow.com/questions/184710/what-is-the-difference-between-a-deep-copy-and-a-shallow-copy
  - https://docs.python.org/3/library/copy.html
  - http://stackoverflow.com/questions/17246693/what-exactly-is-the-difference-between-shallow-copy-deepcopy-and-normal-assignm
  - na google-u tražiti: *shallow deep copy python*