.. _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.65145599834in } p{ 1.65145599834in } p{ 1.65145599834in } p{ 1.65145599834in }

.. list-table::
  :header-rows: 0
  
  * 
    - Pridruživanjem se ne kopira sadržaj. U sljedećem primjeru ``a`` i ``b`` pokazuju na isti objekt što znači kad se promijeni ``a[0]``, promijeni se i ``b``.
    - 
      .. 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.65145599834in } p{ 1.65145599834in } p{ 1.65145599834in } p{ 1.65145599834in }

.. list-table::
  :header-rows: 0
  
  * 
    - 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.65145599834in } p{ 1.65145599834in } p{ 1.65145599834in } p{ 1.65145599834in }

.. 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)``. (U C-u: ``&a``.)


.. tabularcolumns:: p{ 2.70874719801in } p{ 2.93447613117in } p{ 1.12864466584in }

.. list-table::
  :header-rows: 1
  
  * - immutable
    - mutable
    - 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.

    - 
        .. 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 :ref:`typesseq-mutable`).


Literatura

  - 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/2/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*