Introdução às matrizes

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

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

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

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

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

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

  matC = somaMat(matA, matB, m, n); # parametros efetivos

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

main();

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.

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

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

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

main();

1.3. 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 língua (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 previamente 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.

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.

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

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

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

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

#define MAXL  20 // usar no maximo 20 linhas
#define MAXC  20 // usar no maximo 20 colunas

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

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

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

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.

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

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

main();

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

main();

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

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.

# Exemplo de matriz em Python passando linha em funcao que trabalha com vetor

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

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

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

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

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 :
2021/06/22: pequenos acertos (ä-â, ë-ê, é...), numeração de seções, alterações visibilidade desse rodapé
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.