Introdução às matrizes

[ Memória | Parâmetros | Vetores | C/Python | C | Python ]

Nesta seção examinaremos resumidamente como utilizar matrizes tanto em C quanto em Python.

Da mesma forma que o conceito de vetor é útil quando necessita-se de uma grande quantidade de valores associados, todos eles, a um mesmo tipo de dado (como as várias notas de determinado aluno), o conceito de matriz é útil quando naturalmente os dados considerados apresentam duas dimensões. Um exemplo é quando precisamos processar dados de um grupo de indivíduos (e.g. alunos), cada um deles com várias medidas (e.g. notas - vide figura 1).

Também vale a pena destacar que, tanto em C quanto em Python, a implementação de matriz é feita por meio de vetor de vetores. Desse modelo, em ambas pode-se tratar cada linha como um vetor. Por exemplo, se a matriz recebe o nome de `M`, então `M[0]` é sua primeira linha, `M[1]` a segunda linha e assim por diante. Se for necessário pegar um elemento específico da matriz, deve-se usar dois colcetes, como em `M[i][j]`, que devolve o valor da linha i na coluna j (e.g. `M[0][0]` devolve o valor da primeira posição da matriz e `M[1][0]` devolve o valor do primeiro elemento sua segunda linha).

Matrizes: sequência contígua de variáveis

Do ponto de vista computacional a implementação de matrizes segue o princípio dos vetores, uma matriz ocupa uma porção contígua da memória do computador, servindo para representar o conceito matemático associado. Lembrando que ao representar um vetor o acesso ao elemento da posição i pode ser feito por meio da sintaxe vet[i], no caso de matriz é necessário indicar em qual linha i e em qual coluna j o elemento está, por exemplo, se a variável tem por nome Mat, usaria Mat[i][j].

Este tipo de estrutura de dados é natural quando os dados apresentam 2 atributos. Por exemplo, em uma sala de aula, o professor precisa manter informações dos resultados obtidos pelos alunos em várias atividades, assim pode-se utilizar uma matriz para representar estes dados: as atividades de cada aluno estão em uma única linha da matriz Mat (e.g., Mat[i][0] é o resultado da atividade 0 para o aluno i).

Fig. 1. Ilustração de como uma matriz é representada na "memória" do computador.

Mas como é possível implementar computacionalmente esse tipo de estrutura? Na figura acima está representado uma matriz conceitual, com a ideia de alunos e notas, e à direita como estes dados estão na memória do computador, supondo-se M+1 alunos e N+1 atividades. Se na representação computacional, o nome da matriz for Mat, então os dados correspondentes ao aluno 0 são: Mat[0][1], Mat[0][1] e assim por diante até o Mat[0][N].

Matrizes: como parâmetro de função

Do mesmo modo que vetores, ao passar uma matriz como parâmetro de uma função, este funcionará como parâmetro por referência (ou por endereço). Ou seja, é passada uma referência ao parâmetro efetivo (em que chamou a função) de modo que qualquer alteração dentro da função, no parâmetro formal, significará que o valor na matriz que foi passada como parämetro (no local que chamou a função e portanto o parâmetro efetivo) será alterado.

Tanto em C quanto em Python as matrizes (e vetores) são passados por referência. O exemplo abaixo ilustra que alterar os dados de uma matriz dentro de uma função implica em alterar a matriz que lhe foi passada (parâmetro efetivo).

Tab. 1. Matrizes passadas via parâmetro para funções (equivale à uma referência à uma matriz "externa").

Função com computa soma de 2 matrizes em C e em Python
Exemplo em C | Exemplo em Python
--- | ---

    <incl1>#include</incl1> <stdio.h>
    <def>#define</def> NL 20 <cyan>// constante para maximo de linhas</cyan>
    <def>#define</def> NC 20 <cyan>// constante para maximo de colunas</cyan>
    <cyan>// Funcao para gerar nova matriz MA + MB</cyan>
    void somaMat (<verm>int</verm> MA[][NC], <verm>int</verm> MB[][NC], <verm>int</verm> MC[][NC], <verm>int</verm> nL, <verm>int</verm> nC) {
      <verm>int</verm> i, j; <cyan>// auxiliar, para indexar os matrizes</cyan>
      <azul>for</azul> (i=0; i< nL; i++)   <cyan>// "Ler" nL x nC valores </cyan>
        <azul>for</azul> (j=0; j< nC; j++) <cyan>// inteiros armazenando-os</cyan>
          MC[i][j] = MA[i][j] + MB[i][j];
      }
    <cyan>// Funcao para entrar matriz nL x nC, linha por linha</cyan>
    void lerMatriz (<verm>int</verm> mat[][NC], <verm>int</verm> nL, <verm>int</verm> nC) {
      <verm>int</verm> i,j; <cyan>// declara indices</cyan>
      <azul>for</azul> (i=0; i<nL; i++)   <cyan>// i entre 0 e nL-1</cyan>
        <azul>for</azul> (j=0; j<nC; j++) <cyan>// j entre 0 e nC-1</cyan>
          scanf("%d", &mat[i][j]);
      }
    <cyan>// Funcao para imprimir matriz nL x nC, linha por linha</cyan>
    void imprimeMatriz (<verm>int</verm> mat[][NC], <verm>int</verm> nL, <verm>int</verm> nC) {
      <verm>int</verm> i,j; <cyan>// declara indices</cyan>
      <azul>for</azul> (i=0; i< nL; i++) { <cyan>// i entre 0 e nL-1</cyan>
        <verm>printf</verm>("%2d: ", i); <cyan>// "Imprime" numero desta linha</cyan>
        <azul>for</azul> (j=0; j< nC; j++) <cyan>// j entre 0 e nC-1</cyan>
          <verm>printf</verm>("%3d ", mat[i][j]); <cyan>// em 3 espacos</cyan>
        <verm>printf</verm>("\n"); <cyan>// Mude de linha</cyan>
        }
      }
    <verm>int</verm> main (void) {
      <verm>int</verm> i, j; <cyan>// auxiliar, para indexar os matrizes</cyan>
      <verm>int</verm> m, n; <cyan>// tamanho util das matrizes</cyan>
      <verm>int</verm> matA[NL][NC], matB[NL][NC], matC[NL][NC]; <cyan>// Matriz para inteiros (ate' NL*NC elementos)</cyan>
      scanf("%d %d", &m, &n);
      <verm>printf</verm>("Entra matriz A:\n"); lerMatriz(matA, m, n);
      <verm>printf</verm>("Entra matriz B:\n"); lerMatriz(matB, m, n);
      <verm>printf</verm>("Gera matriz C:\n"); somaMat(matA, matB, matC, m, n); <cyan>// parametros efetivos</cyan>

      <verm>printf</verm>("Matriz A:\n"); imprimeMatriz(matA, m, n); <cyan>// 'matA' e' parametro efetivo</cyan>
      <verm>printf</verm>("Matriz B:\n"); imprimeMatriz(matB, m, n); <cyan>// aqui e' 'matB'</cyan>
      <verm>printf</verm>("Matriz C:\n"); imprimeMatriz(matC, m, n); <cyan>// aqui e' 'matC'</cyan>
      return 0;
      }

    <incl1>from</incl1> __future__ import print_function; <cyan># imprime sem mudar linha Python 2</cyan>
    <cyan># Funcao para gerar nova matriz MA + MB</cyan>
    <verm>def</verm> somaMat (MA, MB, nL, nC) :
      MC = []; <cyan># inicia matriz que sera devolvida</cyan>
      linha = []; <cyan># inicia vetor para compor linha de MC</cyan>
      <azul>for</azul> i in range(nL) : <cyan># i varia entre 0 e nL-1</cyan>
        <azul>for</azul> j in range(nC) : <cyan># j varia entre 0 e nC-1</cyan>
          linha.append(MA[i][j] + MB[i][j]); <cyan># novo elemento de "linha"</cyan>
        MC.append(linha); <cyan># para conseguir estrutura adequada</cyan>
      return MC;
    <cyan># Funcao para entrar matriz nL x nC, linha por linha
    <verm>def</verm> lerMatriz (mat, nL, nC) :
      <azul>for</azul> i in range(nL) :
        linha = [];
        <azul>for</azul> j in range(nC) :
          linha.append(input());
        mat.append(linha);
    <cyan># Funcao para imprimir matriz nL x nC, linha por linha</cyan>
    <verm>def</verm> imprimeMatriz (mat, nL, nC) :
      <azul>for</azul> i in range(0, nL) : <cyan># i entre 0 e nL-1</cyan>
        <verm>print</verm>("%2d: " % i, end=""); <cyan># "Imprime" numero desta linha</cyan>
        <azul>for</azul> j in range(0, nC) :
          <verm>print</verm>("%3d " % mat[i][j], end=""); <cyan># em 3 espacos</cyan>
        <verm>print</verm>(); <cyan># Mude de linha</cyan>
    <verm>def</verm> main () :
      matA = [];
      matB = [];
      linha = raw_input(); <cyan># ler linha em Python 2 (no 3 usar apenas "input()")</cyan>
      m, n = map(int, linha.split()); <cyan># quebrar entrada em 2 inteiros</cyan>
      <verm>print</verm>("Matriz A:"); lerMatriz(matA, m, n);
      <verm>print</verm>("Matriz B:"); lerMatriz(matB, m, n);

      matC = somaMat(matA, matB, m, n); <cyan># parametros efetivos</cyan>

      <verm>print</verm>("Matriz A:"); imprimeMatriz(matA, m, n); <cyan># 'matA' e' parametro efetivo</cyan>
      <verm>print</verm>("Matriz B:"); imprimeMatriz(matB, m, n); <cyan># aqui e' 'matB'</cyan>
      <verm>print</verm>("Matriz C:"); imprimeMatriz(matC, m, n); <cyan># aqui e' 'matC'</cyan>

    main();

Matrizes: uma linha equivale a um vetor

Uma vez que os elementos em uma linha da matriz estão em posições contíguas da memória, eles podem ser olhados como um vetor, novamente o contexto determina o significado dos dados. Assim, se tivermos uma função soma_vetor que recebe como parâmetro um vetor (e sua dimensão) e que gera a soma de seus elementos, pode-se fazer a seguinte chamada: soma_vetor(mat[i],n), para qualquer i entre 0 e M do exemplo acima.

Desse modo, o exemplo abaixo ilustra uma função preparada para somar elementos de um vetor (`soma += vet[i];`) sendo usada para somar as linhas de uma matriz. Então, na execução do laço dentro função, o comando usando o parâmetro formal soma, `soma += vet[i]` equivalerá ao código `soma += mat[k][i];` no trecho que invocou a função soma_vetor.

Tab. 2. Uma linha de um matriz é na verdade um vetor.

Função de função para somar elementos de vetor sendo usado com linhas de matrizes em C e em Python
Exemplo em C | Exemplo em Python
--- | ---

    <incl1>#include</incl1> <stdio.h>
    ...
    <verm>int</verm> soma_vetor (int vet[], int n) {
      <verm>int</verm> i, soma = 0;
      <azul>for</azul> (i=0; i < n; i++)
        soma += vet[i];
      return soma;
      }
    <verm>int</verm> main (void) {
      <verm>int</verm> mat[NL][NC]; ...
      ...
        <verm>print</verm>("soma linha %d : %d\n", i, soma_vetor(mat[i], n));
      ...
      return 0;
      }

    <incl1>from</incl1> __future__ import print_function; <cyan># imprime sem mudar linha Python 2</cyan>
    <verm>def</verm> soma_vetor (vet, n) :
      soma = 0;
      <azul>for</azul> i in range(n) :
        soma += vet[i];
      return soma;

    <verm>def</verm> main () :
      ...
      <verm>print</verm>("soma linha %d : %d\n" % (i, soma_vetor(mat[i], n)));
      ...

    main();

Diferença entre linguagem compilada (C) e linguagem interpretada (Python)

Uma grande diferença entre as linguagens C e Python é que a primeira é compilada enquanto a segunda é interpretada.

Uma linguagem compilada (como C) implica na existência de um programa (compilador) que traduz o texto do programa na linguagem referida, gerando um código equivalente em linguagem de máquina. Desse modo, existem dois momentos muito distintos, o tempo da compilação e o tempo da execução. Além disso, é preciso que cada "máquina" (que significa o computador/CPU e o sistema operacional - como o Linux) tenha o compilador para aquela linguagem. Isso funciona como se traduzir um texto de uma lingua (como Inglês) para outra (como o Português)

Em uma linguagem interpretada (como Python), existe um programa executável (para a máquina específica em que roda), que é o interpretador para a linguagem específica (e.g. Python). Assim, a tradução e a execução é feita praticamente ao mesmo tempo, como em uma tradução simultänea de uma conferência em Inglës para o Português.

Outra diferença grande entre C e Python é que a primeira é muito mais "estável", sua definição não sofre alterações há anos, enquanto a segunda está em constante mudança. Por outro lado, os interpretadores Python, em geral, apresentam uma vasta gama de pacotes integrados, trazendo muitos recursos préviamente programadas, facilitando a "vida do programador" (e dificultando a dos professores que precisam ficar vetando recursos para poder fazer os aprendizes entenderem que tudo foi programada e poderem entender como o básico...).
Um bom exemplo são os pacotes para tratamento do protocolo HTTP. Existem também para C pacotes livres para fazer implementações para serviços Web (usando HTTP), mas geralmente eles não estão integrados aos compiladores.

Matrizes em C

Como em C deve-se sempre declarar o tipo da variável, no caso de matriz deve-se declarar seu tipo e seu tamanho. No exemplo abaixo ilustramos as declarações e uso de matrizes dos tipos básicos int, char e float.

Tab. 3. Exemplos de tratamento de matrizes em C (com inteiros, caracteres e "flutuantes").

Matrizes em C
Matriz de inteiros | Matriz de caracteres | Matriz de flutuantes
--- | --- | ---

    <incl1>#include</incl1> <stdio.h>
    <def>#define</def> NL 20 <cyan>// constante para maximo de linhas</cyan>
    <def>#define</def> NC 20 <cyan>// constante para maximo de colunas</cyan>
    <verm>int</verm> main (void) {
      <verm>int</verm> i, j; <cyan>// auxiliar, para indexar os matrizes</cyan>
      <verm>int</verm> nL, nC; <cyan>// tamanho util das matrizes</cyan>
      <verm>int</verm>  mat[NL][NC]; <cyan>// Matriz para inteiros (ate' NL*NC elementos)</cyan>
      scanf("%d %d", &nL, &nC);
      <azul>for</azul> (i=0; i< nL; i++)   <cyan>// "Ler" nL x nC valores </cyan>
        <azul>for</azul> (j=0; j< nC; j++) <cyan>// inteiros armazenando-os</cyan>
          scanf("%d", &mat[i][j]);  <cyan>// na matriz</cyan>
      <azul>for</azul> (i=0; i< nL; i++) { <cyan>// "Imprimir" os nL x nC</cyan>
        <verm>printf</verm>("%2d: ", i); <cyan>// "Imprime" numero desta linha</cyan>
        <azul>for</azul> (j=0; j< nL; j++)   <cyan>// valores inteiros, ajustando</cyan>
          <verm>printf</verm>("%3d ", mat[i][j]); <cyan>// em 3 espacos</cyan>
        <verm>printf</verm>("\n"); <cyan>// Mude de linha</cyan>
        }
      return 0;
      }

    <incl1>#include</incl1> <stdio.h>
    <def>#define</def> NL 20 <cyan>// constante para maximo de linhas</cyan>
    <def>#define</def> NC 20 <cyan>// constante para maximo de colunas</cyan>
    <verm>int</verm> main (void) {
      <verm>int</verm> i, j; <cyan>// auxiliar, para indexar os matrizes</cyan>
      <verm>int</verm> nL, nC; <cyan>// tamanho util dos matrizes</cyan>
      char matC[NL][NC]; <cyan>// Matriz para caracteres</cyan>
      scanf("%d %d", &nL, &nC);
      <azul>for</azul> (i=0; i< nL; i++)   <cyan>// "Ler" nL x nC valores</cyan>
        <azul>for</azul> (j=0; j< nC; j++) <cyan>// tipo "char" armazenando-os</cyan>
          scanf("%c", &matC[i][j]);  <cyan>// na matriz</cyan>
      <azul>for</azul> (i=0; i< nL; i++) { <cyan>// "Imprimir" os nL x nC</cyan>
        <verm>printf</verm>("%2d: ", i); <cyan>// "Imprime" numero desta linha</cyan>
        <azul>for</azul> (j=0; j< nC; j++)       <cyan>// valores tipo "char",</cyan>
          <verm>printf</verm>("%2c", matC[i][j]); <cyan>// ajustando em 2 espacos</cyan>
        <verm>printf</verm>("\n"); <cyan>// Mude de linha</cyan>
        }
      return 0;
      }

    <incl1>#include</incl1> <stdio.h>
    <def>#define</def> M 20 <cyan>// usado para constante</cyan>
    <verm>int</verm> main (void) {
      <verm>int</verm> i, j; <cyan>// auxiliar, para indexar os matrizes</cyan>
      <verm>int</verm> nL, nC; <cyan>// tamanho util dos matrizes</cyan>
      float matF[NL][NC]; <cyan>// Matriz para caracteres</cyan>
      scanf("%d %d", &nL, &nC);
      <azul>for</azul> (i=0; i< nL; i++)      <cyan>// "Ler" nL x nC valores </cyan>
        <azul>for</azul> (j=0; j< nC; j++)    <cyan>// tipo "char" armazenando-os</cyan>
          scanf("%f", &matF[i][j]); <cyan>// na matriz</cyan>
      <azul>for</azul> (i=0; i< nL; i++) { <cyan>// "Imprimir" os nL x nC</cyan>
        <verm>printf</verm>("%2d: ", i); <cyan>// "Imprime" numero desta linha</cyan>
        <azul>for</azul> (j=0; j< nC; j++)      <cyan>// valores tipo "float",</cyan>
           <verm>printf</verm>("%5.1f", matF[i][j]); <cyan>// usando 5 esp. e 1 dec.</cyan>
        <verm>printf</verm>("\n"); <cyan>// Mude de linha</cyan>
        }
      return 0;
      }

No C padrão NÃO é possível declarar as dimensões da matriz usando a variável que será usada para informar o número efetivo de posições "úteis" na matriz, ou seja, não tente fazer algo como: `int m, n; float mat[m][n];`. A razão disso é que C, por ser uma linguagem compilada, durante a fase de compilação deve-se reservar o espaço máximo a ser usado pelo matriz. Já as variáveis `m` e `n` só serão conhecidas durante a execução do programa.

Apesar de algumas implementações de compiladores C permitirem esse tipo de declarção "dinâmica", NÃO usem sob pena de seu programa não funcionar em outros compiladores.

Vejamos o exemplo da função soma_vetor sendo chamada com cada linha de uma matriz, com código completo em C.

    <cyan>// Exemplo de matriz em Python passando linha em funcao que trabalha com vetor</cyan>
    <incl1>#include</incl1> <stdio.h>

    <def>#define</def> MAXL  20 <cyan>// usar no maximo 20 linhas</cyan>
    <def>#define</def> MAXC  20 <cyan>// usar no maximo 20 colunas</cyan>

    <verm>int</verm> soma_vet (<verm>int</verm> vet[], <verm>int</verm> n) {
      <verm>int</verm> soma = 0, i;
      <azul>for</azul> (i=0; i<n; i++)
        soma += vet[i];
      return soma;
      }

    <verm>int</verm> main (void) {
      <verm>int</verm> mat[MAXL][MAXC]; <cyan>// declara que existira uma matriz (vetor de vetor)</cyan>
      <verm>int</verm> i, j, m = 3, n = 4; <cyan>// dimensoes fixas por simplicidade</cyan>
      <azul>for</azul> (i=0; i<m; i++) {
        <azul>for</azul> (j=0; j<n; j++) {
          mat[i][j] = i*n + j; <cyan>// como ja' existe espaco reservado atribua "i*m + j" para a posicao linha i e coluna j</cyan>
          <verm>printf</verm>(" %3d", mat[i][j]); <cyan>// imprime sem mudar de linha</cyan>
          }
        <verm>printf</verm>("\n"); <cyan>// muda de linha</cyan>
        }

      <verm>printf</verm>("Imprime somas das linhas\n");
      <azul>for</azul> (i=0; i<m; i++)
        <verm>printf</verm>("Linha %d tem soma: %3d\n", i, soma_vet(mat[i], n)); <cyan>// %3d ajusta 3 casas 'a direita</cyan>
      return 1;
      }

Matrizes em Python

Em Python pode-se gerar listas de variadas maneiras, a forma sugerida abaixo é gerar uma lista de listas, sendo que a segunda lista será uma linha da matriz. No código abaixo ilustramos isso.

A linha de uma matriz é na verdade um vetor

O exemplo abaixo ilustra a declaração e uso de matrizes, ccom os tipos básicos int, char e float.

Tab. 4. Exemplos de tratamento de matrizes em Python (com inteiros, caracteres e "flutuantes").

Matrizes em Python
Matriz de inteiros | Matriz de caracteres | Matriz de flutuantes
--- | --- | ---

    <verm>def</verm> main () :
      nL = int(input()); nC = int(input()); <cyan># "Ler" dimensoes nL, nc</cyan>
      mat = []; <cyan># Matriz: iniciar uma lista vazia</cyan>
      <azul>for</azul> i in range(0, nL) :
        linha = [];	<cyan># iniciar lista vazia para a linha atual</cyan>
        <azul>for</azul> j in range(0, nC) : <cyan># ler nI inteiros</cyan>
          linha.append(int(input())); # anexar mais um elemento</cyan>
         mat.append(linha); <cyan># anexar a linha `a matriz</cyan>
      <cyan># Em Python para imprimir de modo mais "bonito" a matriz,</cyan>
      <cyan># pode-se fazer impressao dos elementos da linha sem "quebre",</cyan>
      <cyan># ou compondo uma "string". Neste exemplo usamos o segundo "truque".</cyan>
      <azul>for</azul> i in range(0, nL) :
        strLinha = ""; <cyan># Truque: compor um "string" com a linha i toda</cyan>
        <azul>for</azul> j in range(0, nC) :
          strLinha += "%3i" % mat[i][j]; <cyan># formatar ajustando 3 pos.</cyan>
        <verm>print</verm>("%2i: " % i + strLinha); <cyan># "Imprimir" a linha i</cyan>

    main();

    <verm>def</verm> main () :
      nL = int(input()); nC = int(input()); <cyan># "Ler" dimensoes nL, nc</cyan>
      mat = []; <cyan># Matriz: iniciar uma lista vazia</cyan>
      <azul>for</azul> i in range(0, nL) :
        linha = []; <cyan># iniciar lista vazia para a linha atual</cyan>
        <azul>for</azul> j in range(0, nC) : <cyan># ler nI inteiros</cyan>
          linha.append(raw_input()); <cyan># anexar mais um elemento</cyan>
        mat.append(linha); # anexar a matriz a linha</cyan>
      <cyan># Nesse exemplo imprimimos usando a biblioteca "print_function"</cyan>
      <cyan># para nao "quebrar" linha entre 2 impressoes.</cyan>
      <azul>for</azul> i in range(0, nL) :
        <verm>print</verm>("%2i: " % i, end=""); <cyan># parametro "end" impede a quebra</cyan>
        <azul>for</azul> j in range(0, nC) :
          <verm>print</verm>("%4c" % mat[i][j], end="");
        <verm>print</verm>(); <cyan># agora "quebre" a linha (final linha i)!</cyan>

    main();

    <verm>def</verm> main () :
      nL = int(input()); nC = int(input()); <cyan># "Ler" dimensoes nL, nc</cyan>
      mat = []; <cyan># Matriz: iniciar uma lista vazia</cyan>
      <azul>for</azul> i in range(0, nL) :
        linha = []; <cyan># iniciar lista vazia para a linha atual</cyan>
        <azul>for</azul> j in range(0, nC) : <cyan># ler nI inteiros</cyan>
          linha.append(float(input())); <cyan># anexar mais um elemento</cyan>
        mat.append(linha); <cyan># anexar a matriz a linha</cyan>
      <cyan># Neste exemplo usamos novamente o "truque" de usar</cyan>
      <cyan># "string" para imprimir cada linha da matriz</cyan>
      <azul>for</azul> i in range(0, nL) :
        strLinha = ""; <cyan># Truque para imprimir "por linha"</cyan>
        <azul>for</azul> j in range(0, nC) :
          strLinha += "%5.1f" % mat[i][j]; <cyan># usar 5 espacos, 1 pto dec.</cyan>
        <verm>print</verm>("%2i: " % i + strLinha); <cyan># "Imprimir" esta linhalinha = [];</cyan>

    main();

No segundo exemplo acima, utilizamos recurso da biblioteca `print_function`, assim no Python 2 é obrigatório incluir esta biblioteca, como indicado nas primeiras linhas do exemplo abaixo. No caso do Python 3 a inclusão é desnecessária.

O exemplo abaixo ilustra outro conceito importante: cada linha da matriz comporta-se como lista e portanto pode-se aplicar sobre cada linha da matriz, qualquer função que tenha como parâmetro formal uma lista. O exemplo será aquele da função soma_vetor, que soma os elementos de um vetor.

    <cyan># Exemplo de matriz em Python passando linha em funcao que trabalha com vetor</cyan>

    <cyan># Python2 para 'print' sem pular linha : print("*" , end = "");</cyan>
    <incl1>from</incl1> __future__ import print_function

    <verm>def</verm> soma_vet (vet, n) :
      soma = 0;
      <azul>for</azul> i in range(0,n) :
        soma += vet[i];
      return soma;

    mat = []; <cyan># declara que existira uma "lista" (que sera' lista de lista - ou vetor de vetor)</cyan>
    m = 3; n = 4; <cyan># dimensoes fixas por simplicidade</cyan>
    <azul>for</azul> i in range(0,m) :
      linha = []; <cyan># declara um "lista" (ou vetor) que sera' um linha da matriz 'mat[][]'</cyan>
      <azul>for</azul> j in range(0,n) :
        linha.append(i*n + j); <cyan># equivale a fazer "mat[i][j] = i*m + j" (mas assim resulta erro em Python)</cyan>
        <verm>print</verm>(" %3d" % linha[j], end=""); <cyan># imprime sem mudar de linha</cyan>
      <verm>print</verm>(); <cyan># muda de linha</cyan>
      mat.append(linha); <cyan># define a linha i da matriz (algo como mat[i] = linha)</cyan>

    <verm>print</verm>("Imprime somas das linhas");
    <azul>for</azul> i in range(0,m) :
      <verm>print</verm>("Linha %d tem soma: %3d" % (i, soma_vet(mat[i], n))); <cyan># %3d ajusta 3 casas 'a direita</cyan>

Muita atenção ao método usado para construir a matriz, usando uma lista auxiliar `linha` e a necessidade de anexar cada linha separadamente (`mat.append(linha);`. Se isso não está suficientemente claro, sugiro que peguem este exemplo e "brinquem" com ele, até entendê-lo bem.

Bem, em resumo é isso.

Leônidas de Oliveira Brandão
http://line.ime.usp.br

Alterações:
2020/08/15: novo formato, pequenas revisões
2020/05/18: inserido um código Python explicando como criar matrizes.
2019/06/06: vários pequenos acertos ao longo do texto.