intr_prog/introducao_matrizes.html

<!--
 Introdução à Programação - 2017 - Prof. Leoônidas de Oliveira Brandão
 Introdução às matrizes
 LInE (Laboratory of Informatics in Education) - http://www.usp.br/line
 IME - USP
 Material didático
 Pode usar livrevemente este material para fins não comerciais, devendo sempre fazer referência à autoria.
 Sugestões/apontamento são bem vindos: leo@ime.usp.br (favor indicar no assunto "material de introducao 'a programacao")
 Prof. Leônidas de Oliveira Brandão
 http://www.ime.usp.br/~leo
 http://line.ime.usp.br
 http://www.matemtica.br
-->

  <meta http-equiv='Content-Type' content='text/html; charset=UTF-8'>
  <meta name='keywords' content='mac0122, material, professores, leonidas de oliveira brandao'>
  <link rel='stylesheet' type='text/css' href='css_img_js_conf/all.css'>
  <link rel='stylesheet' type='text/css' href='css_img_js_conf/line_introducao_programacao.css'>
  <script src="css_img_js_conf/defineLInE.js"></script> <!-- para referencias 'a documentos internos -->
<div class="pagina">

<p class="secao">Introdução às matrizes</p>

<center><p>[
  <a href="#sequencia" title="matriz = sequencia contigua de variaveis em memoria">Memória</a> &nbsp; | &nbsp;
  <a href="#parametros" title="matriz como parametro de funcao">Parâmetros</a> &nbsp; | &nbsp;
  <a href="#vetores" title="linha = um vetor">Vetores</a> &nbsp; | &nbsp;
  <a href="#c-python" title="diferencas em C e em Python">C/Python</a> &nbsp; | &nbsp;
  <a href="#C" title="matrizes em C">C</a> &nbsp; | &nbsp;
  <a href="#Python" title="matrizes em Python">Python</a> &nbsp; &nbsp;
 ]</p>
</center>

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

<p>
  Da mesma forma que o conceito de <i>vetor</i> é ú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 <b style="color:#0000aa;">matriz</b> é ú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).
</p>

<p>
  Também vale a pena destacar que, tanto em <em>C</em> quanto em <em>Python</em>, 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 <tt>M</tt>, então <tt>M[0]</tt> é sua primeira linha,
  <tt>M[1]</tt> 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
  <tt>M[i][j]</tt>, que devolve o valor da linha <i>i</i> na coluna <i>j</i>
  (e.g. <tt>M[0][0]</tt> devolve o valor da primeira posição da matriz e <tt>M[1][0]</tt> devolve o valor do
  primeiro elemento sua segunda linha).
</p>


<a name="sequencia">
<p class="secao">Matrizes: sequência contígua de variáveis</p>
</a>

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

<center>
  <img src="img/int_mat_representacao.png" title="ilustracao de matriz em memoria"/>
  <br/>
  <i>Fig. 1. Ilustração de como uma matriz é representada na "memória" do computador.</i>
</center>

<p>
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 <i>Mat</i>, então os dados correspondentes ao
<i>aluno 0</i> são: <i>Mat[0][1]</i>, <i>Mat[0][1]</i> e assim por diante até o <i>Mat[0][N]</i>.
</p>


<a name="parametros">
<p class="subsecao">Matrizes: como parâmetro de função</p>  
</a>

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


<p>
Tanto em <em>C</em> quanto em <em>Python</em> 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).
</p>


<p><center>
<i>Tab. 1. Matrizes passadas via parâmetro para funções (equivale à uma referência à uma matriz "externa").</i>
<br/>           
<table class="tbCodeLinCol">
 <tr><th colspan="3">Função com computa soma de 2 matrizes em <i>C</i> e em  <i>Python</i> </th> </tr>
 <tr> 
     <th>Exemplo em <i>C</i></th>
     <th>Exemplo em <i>Python</i></th>
 </tr>
 <tr valign="top"><td><table class="tbCode">
   <tr><td><pre><incl1>#include</incl1> &lt;stdio.h&gt;
<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>
<tt class="tipo">void</tt> 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&lt; nL; i++)   <cyan>// "Ler" nL x nC valores </cyan>
    <azul>for</azul> (j=0; j&lt; 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>
<tt class="tipo">void</tt> 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&lt;nL; i++)   <cyan>// i entre 0 e nL-1</cyan>
    <azul>for</azul> (j=0; j&lt;nC; j++) <cyan>// j entre 0 e nC-1</cyan>
      <tt class="fnc">scanf</tt>("%d", &mat[i][j]);
  }
<cyan>// Funcao para imprimir matriz nL x nC, linha por linha</cyan>
<tt class="tipo">void</tt> 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&lt; 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&lt; 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>
  <tt class="fnc">scanf</tt>("%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;
  }</pre></td>
 </table></td>
   <td><pre><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</tt> 
<verm>def</verm> lerMatriz (mat, nL, nC) :
  <azul>for</azul> i in range(nL) :
    linha = [];
    <azul>for</azul> j in range(nC) :
      linha.append(<tt class="fnc">input</tt>());
    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 = <tt class="fnc">raw_input</tt>(); <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();</pre></td>
   </tr>
   </table></td></tr>
</table></center>
</p>


<a name="vetores">
<p class="subsecao">Matrizes: uma linha equivale a um vetor</p>
</a>

<p>
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 <i>contexto</i> determina o significado dos dados.
Assim, se tivermos uma função <i>soma_vetor</i> 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: <i>soma_vetor(mat[i],n)</i>, para qualquer <i>i</i> entre <i>0</i> e <i>M</i> do exemplo acima.
</p>

<p>
Desse modo, o exemplo abaixo ilustra uma função preparada para somar elementos de um vetor (<tt>soma += vet[i];</tt>) sendo usada para
somar as linhas de uma matriz.
<!--
Vamos supor que no trecho de código que invoca a função <i>soma_vetor</i>, usa-se como <i>parämetro efetivo</i> a linha <i>k</i>
(nesse caso entre <i>0 <u><</u> k <u><</u> M</i>) da matriz <i>mat</i>.-->
Então, na execução do laço dentro função, o comando usando o <i>parâmetro formal</i> <i>soma</i>, <tt>soma += vet[i]</tt> equivalerá
ao código <tt>soma += mat[k][i];</tt> no trecho que invocou a função <i>soma_vetor</i>.
</p>

<p><center>
<i>Tab. 2. Uma linha de um matriz é na verdade um vetor.</i>
<br/>           
<table class="tbCodeLinCol">
 <tr><th colspan="3">Função de função para somar elementos de vetor sendo usado com linhas de matrizes em <i>C</i> e em  <i>Python</i> </th> </tr>
 <tr> 
     <th>Exemplo em <i>C</i></th>
     <th>Exemplo em <i>Python</i></th>
 </tr>
 <tr valign="top"><td><table class="tbCode">
   <tr><td><pre><incl1>#include</incl1> &lt;stdio.h&gt;
...
<verm>int</verm> soma_vetor (int vet[], int n) {
  <verm>int</verm> i, soma = 0;
  <azul>for</azul> (i=0; i &lt; 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;
  }</pre></td>
 </table></td>
   <td><pre><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();</pre></td>
   </tr>
   </table></td></tr>
</table></center>
</p>


<p class="subsecao">Diferença entre linguagem compilada (<i>C</i>) e linguagem interpretada (<i>Python</i>)</p>
</a>

<p>
Uma grande diferença entre as linguagens <i>C</i> e <i>Python</i> é que a primeira é
<b>compilada</b> enquanto a segunda é <b>interpretada</b>.
</p>

<p>Uma linguagem <b>compilada</b> (como <i>C</i>) implica na existência de um programa (<b>compilador</b>) que traduz o texto do
programa na linguagem referida, gerando um código equivalente em <b>linguagem de máquina</b>. Desse modo, existem dois momentos
muito distintos, o <i>tempo da compilação</i> e o <i>tempo da execução</i>.
Além disso, é preciso que cada "máquina"
(que significa o computador/CPU e o sistema operacional - como o <i>Linux</i>) 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)
</p>

<p>
Em uma linguagem <b>interpretada</b> (como <i>Python</i>), existe um
programa executável (para a máquina específica em que roda), que é o <b>interpretador</b> para a linguagem específica
(e.g. <i>Python</i>).
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.
</p>

<p>
  Outra diferença grande entre <i>C</i> e <i>Python</i> é 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 <i>Python</i>, 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...).
  <br/>
  Um bom exemplo são os pacotes para tratamento do protocolo <i>HTTP</i>.
  Existem também para <i>C</i> pacotes livres para fazer implementações para serviços <i>Web</i> (usando <i>HTTP</i>), mas
  geralmente eles não estão integrados aos compiladores.
</p>


<a name="C">
<p class="subsecao">Matrizes em <i>C</i></p>
</a>

<p>
Como em <i>C</i> 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 <i>int</i>, <i>char</i> e <i>float</i>.
</p>


<p><center>
<i>Tab. 3. Exemplos de tratamento de matrizes em <i>C</i> (com inteiros, caracteres e "flutuantes").</i>
<br/>           
<table class="tbCodeLinCol">
 <tr><th colspan="3">Matrizes em <i>C</i> </th> </tr>
 <tr> 
     <th>Matriz de inteiros</th>
     <th>Matriz de caracteres</th>
     <th>Matriz de flutuantes</th></tr>
 <tr valign="top"><td><table class="tbCode">
   <tr><td><pre><incl1>#include</incl1> &lt;stdio.h&gt;
<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>
  <tt class="fnc">scanf</tt>("%d %d", &nL, &nC);
  <azul>for</azul> (i=0; i&lt; nL; i++)   <cyan>// "Ler" nL x nC valores </cyan>
    <azul>for</azul> (j=0; j&lt; nC; j++) <cyan>// inteiros armazenando-os</cyan>
      <tt class="fnc">scanf</tt>("%d", &mat[i][j]);  <cyan>// na matriz</cyan>
  <azul>for</azul> (i=0; i&lt; 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&lt; 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;
  }</pre></td>
 </table></td>
   <td><pre><incl1>#include</incl1> &lt;stdio.h&gt;
<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>
  <tt class="fnc">scanf</tt>("%d %d", &nL, &nC);
  <azul>for</azul> (i=0; i&lt; nL; i++)   <cyan>// "Ler" nL x nC valores</cyan>
    <azul>for</azul> (j=0; j&lt; nC; j++) <cyan>// tipo "char" armazenando-os</cyan>
      <tt class="fnc">scanf</tt>("%c", &matC[i][j]);  <cyan>// na matriz</cyan>
  <azul>for</azul> (i=0; i&lt; 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&lt; 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;
  }</pre></td>
   <td><pre><incl1>#include</incl1> &lt;stdio.h&gt;
<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>
  <tt class="fnc">scanf</tt>("%d %d", &nL, &nC);
  <azul>for</azul> (i=0; i&lt; nL; i++)      <cyan>// "Ler" nL x nC valores </cyan>
    <azul>for</azul> (j=0; j&lt; nC; j++)    <cyan>// tipo "char" armazenando-os</cyan>
      <tt class="fnc">scanf</tt>("%f", &matF[i][j]); <cyan>// na matriz</cyan>
  <azul>for</azul> (i=0; i&lt; 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&lt; 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;
  }</pre></td></tr>
   </table></td></tr>
</table></center>
</p>


<p>
No <i>C</i> 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, <b>não</b> tente fazer algo como:
<tt><font color="#a000">int m, n; float mat[m][n];</font></tt>.
A razão disso é que <i>C</i>, por ser uma linguagem compilada, durante a <b>fase de compilação</b> deve-se reservar o
espaço máximo a ser usado pelo matriz.
Já as variáveis <tt>m</tt> e <tt>n</tt> só serão conhecidas durante a <b>execução</b> do programa.
</p>

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

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

<div class="codigo"><pre><cyan>// Exemplo de matriz em Python passando linha em funcao que trabalha com vetor</cyan>
<incl1>#include</incl1> &lt;stdio.h&gt;

<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&lt;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&lt;m; i++) {
    <azul>for</azul> (j=0; j&lt;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&lt;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;
  }
</pre></div>
</p>


<a name="Python">
<p class="subsecao">Matrizes em <i>Python</i></p>
</a>

<p>
Em <i>Python</i> 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.
</p>


<p class="subsecao">A linha de uma matriz é na verdade um vetor</p>

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

<p><center>
<i>Tab. 4. Exemplos de tratamento de matrizes em <i>Python</i> (com inteiros, caracteres e "flutuantes").</i>
<br/>           
<table class="tbCodeLinCol">
 <tr><th colspan="3">Matrizes em <i>Python</i> </th> </tr>
 <tr> 
     <th>Matriz de inteiros</th>
     <th>Matriz de caracteres</th>
     <th>Matriz de flutuantes</th></tr>
 <tr valign="top"><td><table class="tbCode">
   <tr><td><pre><verm>def</verm> main () :
  nL = int(<tt class="fnc">input</tt>()); nC = int(<tt class="fnc">input</tt>()); <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(<tt class="fnc">input</tt>())); # 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();</pre></td>
 </table></td>
   <td><pre><verm>def</verm> main () :
  nL = int(<tt class="fnc">input</tt>()); nC = int(<tt class="fnc">input</tt>()); <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(<tt class="fnc">raw_input</tt>()); <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();</pre></td>
   <td><pre><verm>def</verm> main () :
  nL = int(<tt class="fnc">input</tt>()); nC = int(<tt class="fnc">input</tt>()); <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(<tt class="fnc">input</tt>())); <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();</pre></td>
</tr>
   </table></td></tr>
</table></center>
</p>

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

<p>
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 <i>soma_vetor</i>, que soma os elementos de um vetor.

<div class="codigo"><pre><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></pre>
</div>
</p>

<p>
Muita atenção ao método usado para construir a matriz, usando uma
lista auxiliar <tt>linha</tt> e a necessidade de anexar cada linha separadamente (<tt>mat.append(linha);</tt>.
Se isso não está suficientemente claro, sugiro que peguem
<a href="codigos/introducao_matrizes_teste_linhas.py" title="exemplo ilustrativo de construcao de matriz">este exemplo</a>
e "brinquem" com ele, até entendê-lo bem.
</p>

<p>
Bem, em resumo é isso.</p>


  <p class="autoria">
    <a href="https://www.ime.usp.br/~leo" target="_blank" title="seguir para a pagina do prof. Leônidas">Leônidas de Oliveira Brandão</a><br/>
    <a href="http://www.ime.usp.br/~leo" target="_blank" title="seguir para a página do LInE">http://line.ime.usp.br</a>
  </p>

  <p class="rodape">
    <b>Alterações</b>:<br/>
    2020/08/15: novo formato, pequenas revisões<br/>
    2020/05/18: inserido um código <i>Python</i> explicando como criar matrizes.<br/>
    2019/06/06: vários pequenos acertos ao longo do texto.
    <!-- 201?/??/??: primeira versão. -->
  </p>


</div>