changed:
-
Dotaz
--------
Jsem začátečník a pravděpodobně se ptám úplně hloupě. Potřebuji řešit nějaké operace s maticemi a nerad bych vymýšlel vymyšlené. Předně bych se chtěl zeptat, jaký je nejvhodnější formát pro zápis matic - n-tice n-tic? Nebo něco jiného? Dále by mě pak zajímalo, zda neexistuje nějaká knihovna, která by nástroje pro práci s maticemi obsahovala. 

První odpověď
------------------
zkus NumPy

Druhá odpověď
------------------

Hotovou knihovnu jiste najdete, ale pokud jste zacatecnik jiste pro
vas bude uzitecne zkusit si zakladni operace naprogramovat. Pro
reprezentaci matic bych pouzil seznam seznamu (cisel) spise nez n-tice
n-tic napriklad proto, ze seznamy lze na rozdil od n-tic upravovat
(pridavat/menit/ubirat prvky).

Matici reprezentovanou jako seznam seznamu bych obalil objektem, coz
vam umozni napriklad pretizeni aritmetickych operatoru +,-,*, atd. tak
aby fungovaly spravne pro matice. Napriklad, operator + pretizite
pridanim metody __add__(self, other) kde other je matice ktera se
pricita (k matici self) --- viz priklad nize. Dale bych pretizil
indexovaci operator [], ktery vam umozni pristupovat k prvkum matice
primo jako by objekt byl primo seznam seznamu. Indexovaci operator
pretizite pridanim metody __getitem__(self, key) kde key je index toho
prvku ktery ma metoda vratit (napriklad kdyz zavolate m[3] tak key je
3).

Shruba receno udelal bych to nejak takto::

    class Matice(object):
        def __init__(self, matice=[[]]):
            self.matice = matice
    
        def __getitem__(self, key):
            # umozni indexovani objektu jakoby matice byla primo seznam seznamu
            return self.matice[key]
    
        def __str__(self):
            # vrati retezec reprezentujici matici (vytiskne ji po radcich)
            radky = ''.join([str(radek)+"\n" for radek in self.matice])
            return radky.rstrip("\n")
    
        def __add__(self, other):
            # soucet matic
            radky = zip(self.matice, other.matice)
            soucet = [[a+b for (a,b) in zip(radA,radB)] for (radA,radB) in radky]
            return Matice(soucet)

Takovy objekt pak muzete pouzit napriklad takto::

    >>> >>> m1 = Matice([[1,2,3],[4,5,6]])
    >>> >>> m2 = Matice([[1,2],[4,5],[4,5]])
    >>> >>> print m1
    [1, 2, 3]
    [4, 5, 6]
    >>> >>> print m2
    [1, 2]
    [4, 5]
    [4, 5]
    >>> >>> print m1[1][1]
    5
    >>> >>> print m1+m2
    [2, 4]
    [8, 10]

To vse je jen tak velice zhruba. Muzete dale pridat kontrolu radu
matic a scitat pouze matice stejneho radu. Muzete pretizit dalsi
numericke operatory jako - (odcitani matic metodou __sub__), *
(nasobeni matic metodou __mul__), ~ (inverzni matice metodou
__invert__), - (opacna matice metodou __neg__) a dalsi...

V neposledni  se take muze hodit doplnit dalsi funkce indexovaciho
operatoru pridanim metod __setitem__, __delitem__, __setslice__ a
mnohem vic  ;-) 

class Matice(object):
    def __init__(self, matice=[[]]):
        self.matice = matice

    def __getitem__(self, key):
        # umozni indexovani objektu jakoby matice byla primo seznam seznamu
        return self.matice[key]

    def __str__(self):
        # vrati retezec reprezentujici matici (vytiskne ji po radcich)
        radky = ''.join([str(radek)+"\n" for radek in self.matice])
        return radky.rstrip("\n")

    def __add__(self, other):
        # soucet matic
        radky = zip(self.matice, other.matice)
        soucet = [[a+b for (a,b) in zip(radA,radB)] for (radA,radB) in radky]
        return Matice(soucet)

>>> >>> m1 = Matice([[1,2,3],[4,5,6]])
>>> >>> m2 = Matice([[1,2],[4,5],[4,5]])
>>> >>> print m1
[1, 2, 3]
[4, 5, 6]
>>> >>> print m2
[1, 2]
[4, 5]
[4, 5]
>>> >>> print m1[1][1]
5
>>> >>> print m1+m2
[2, 4]
[8, 10]