Uma forma implicita para criar listas
A forma explicita de criar uma lista de outra
lista = []
for x in a:
lista.append(2*x+1)uma compreensao de lista:
lista = [ 2*x+1 for x in a ] A compreensão de lista pode conter um if implicito
lista = []
for x in a:
if x mod 3 == 0:
lista.append(2*x+1)
lista = [ 2*x+1 for x in a if x mod 3 == 0] Matrizes são generalizações de listas simples vistas anteriormente.
Suponha por exemplo que devemos armazenar as notas de cada aluno em cada laboratório de MC102.
Podemos criar 15 listas (um para cada lab.) de tamanho 50 (tamanho da turma), onde cada lista representa as notas de um laboratório específico.
Matrizes permitem fazer a mesma coisa mas com todas as informações sendo acessadas por um nome em comum (ao invés de 15 nomes distintos).
Para criar uma matriz de dimensões \(l \times c\) inicialmente vazia podemos utilizar compreensão de listas.
Exemplo de uma matriz \(3 \times 4\) inicialmente vazia:
>> mat = [ [] for i in range(3) ] #dentro da lista externa cria-se vazia 3 listas []
>> mat
[[], [], []]Lembre-se que os indices de uma lista começam em 0.
Note que cada lista interna representa uma linha da matriz, e seu tamanho pode ser 4 ou qualquer outro valor.
Utilizando laços:
mat = []
for i in range(3): #para cada linha de 0 até 2
l = [] #linha começa vazia
for j in range(4): #para cada coluna de 0 até 3
l.append(i*j) #preenche colunas da linha i
mat.append(l) #adiciona linha na matriz
print(mat)Obtendo o mesmo resultado utilizando compreensão de listas:
mat = [ [i*j for j in range(4)] for i in range(3)]Em ambos os casos a saída é:
\([[0, 0, 0, 0], [0, 1, 2, 3], [0, 2, 4, 6]]]\)
Em qualquer lugar onde você usaria uma variável no seu programa, você pode usar um elemento específico de uma matriz da seguinte forma:
nome_da_matriz [ind_linha][ind_coluna]
onde ind_linha (respectivamente ind_coluna) é um índice inteiro especificando a linha (respectivamente coluna) a ser acessada.
No exemplo abaixo é criada uma matriz \(10 \times 20\) inicializada com 0s, e depois é atribuído o valor 67 para a linha 6 e coluna 14 dela.
#cria matriz 10x20 toda com zeros
mat = [ [0 for j in range(20)] for i in range(10)]
mat[5][15] = 67Em qualquer lugar onde você escreveria uma variável no seu programa, você pode usar um elemento de sua matriz, da seguinte forma:
nome_da_matriz [<linha>] [<coluna>]
Ex: matriz [1][10] Refere-se a variável na \(2^a\) linha e na \(11^a\) coluna da matriz.
Lembre-se que, como a matriz está implementada com listas, a primeira posição em uma determinada dimensão começa no índice 0.
O acesso a posições inválidas causa um erro de execução.
Imprime elemento da posição \((2,3)\) da matriz criada anteriormente:
mat = [ [i*j for j in range(4)] for i in range(3)]
print(mat[2][3])Saída: 6
Acessa posição inválida \((2,4)\) da matriz:
mat = [ [i*j for j in range(4)] for i in range(3)]
print(mat[2][4])IndexError: list index out of range
Podemos criar matrizes multi-dimensionais utilizando listas de listas como no caso bidimensional.
Para criar uma matriz de dimensões \(d_1 \times d_2 \ldots \times d_l\) inicialmente vazio podemos utilizar compreensão de listas: \[[\, [ \,[ \,[\,]\, \text{for}\, i_{l-1} \, \text{in range}(d_{l-1}) \, ] \ldots \, ] \, \text{for}\, i_2 \, \text{in range}(d_2)\,] \, \text{for} \, i_1 \, \text{ in range}(d_1)]\]
Exemplo de vetor \(3 \times 4 \times 5\) inicialmente vazio
>>mat = [ [ [] for j in range(4) ] for i in range(3) ]
>> mat
[[[], [], [], []],
[[], [], [], []],
[[], [], [], []]]Exemplo de matriz \(3 \times 4 \times 5\) inicialmente com zeros.
>>mat = [ [ [0 for j in range(5)] for j in range(4) ] for i in range(3) ]
>> mat
[ [ [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]],
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]],
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]]Criar funções que implementa as operações básicas sobre matrizes quadradas:
Soma de 2 matrizes com dimensões \(n \times n\).
Subtração de 2 matrizes com dimensões \(n \times n\).
Cálculo da transposta de uma matriz de dimensão \(n \times n\).
Multiplicação de 2 matrizes com dimensões \(n \times n\).
Primeiramente vamos implementar o código para se fazer a leitura e a impressão de uma matriz:
def lemat(n)
#Código que lê uma matriz do teclado
mat = [[] for i in range(n)]
for i in range(n):
for j in range(n):
aux = float(input("Num. da pos. ("+str(i+1)+","+str(j+1)+"): "))
mat[i].append(aux)
return mat
def printmat(mat):
#Código que faz a impressão linha por linha da matriz
for l in mat:
for j in l:
print(j, end=", ") #imprime números na mesma linha separados por ,
print() #após impressão de uma linha, pula uma linhaVamos implementar a funcionalidade de soma de matrizes quadradas.
Primeiramente lemos as duas matrizes:
n = int(input("Dimensão das matrizes: "))
print("Lendo Mat1 linha por linha")
mat1 =lemat(n)
print("Lendo Mat2 linha por linha")
mat2 = lemat(n)Agora para cada posição \((i,j)\) fazemos \[\text{mat3}[i][j] = \text{mat1}[i][j] + \text{mat2}[i][j]\] tal que o resultado da soma das matrizes estará em mat3.
def somamat(mat1,mat2):
#calcula a soma de mat1 com mat2
n = len(mat1)
mat3 = [[0 for j in range(n) ] for i in range(n)]
for i in range(n):
for j in range(n):
mat3[i][j] = mat1[i][j] + mat2[i][j]
print("Imprimindo Mat3 linha por linha")
printmat(mat3)Vamos implementar a funcionalidade de multiplicação de matrizes quadradas.
Vamos multiplicar duas matrizes \(M_1\) e \(M_2\) (de dimensão \(n \times n\)).
O resultado será uma terceira matriz \(M_3\).
Lembre-se que uma posição \((i,j)\) de \(M_3\) terá o produto interno do vetor linha \(i\) de \(M_1\) com o vetor coluna \(j\) de \(M_2\): \[M_3[i,j] = \sum_{k=0}^{n-1} M_1[i,k] \cdot M_2[k,j]\]
def multmat(mat1,mat2):
mat3 = [[0 for j in range(n) ] for i in range(n)]
for i in range(n):
for j in range(n):
for k in range(n): #calcula prod. interno da linha i por coluna j
mat3[i][j] = mat3[i][j] + (mat1[i][k] * mat2[k][j])
return mat3Faça um programa para realizar operações com matrizes que tenha as seguintes funcionalidades:
Um menu para escolher a operação a ser realizada:
Leitura de uma matriz\(_1\).
Leitura de uma matriz\(_2\).
Impressão da matriz\(_1\) e matriz\(_2\).
Cálculo da soma de matriz\(_1\) com matriz\(_2\), e impressão do resultado.
Cálculo da multiplicação de matriz\(_1\) com matriz\(_2\), e impressão do resultado.
Cálculo da subtração de matriz\(_1\) com matriz\(_2\), e impressão do resultado.
Impressão da transposta de matriz\(_1\) e matriz\(_2\).
Escreva um programa que leia todas as posições de uma matriz \(10\times10\). O programa deve então exibir o número de posições não nulas na matriz.
Escreva um programa que lê todos os elementos de uma matriz \(4\times4\) e mostra a matriz e a sua transposta na tela.
c c Matriz & Transposta
\(\left[\begin{array}{c c c c} 0 & 1 & 0 & 2 \\ 0 & 1 & 0 & 2 \\ 0 & 1 & 0 & 2 \\ 0 & 1 & 0 & 2 \\ \end{array}\right]\) &
\(\left[\begin{array}{c c c c} 0 & 0 & 0 & 0 \\ 1 & 1 & 1 & 1 \\ 0 & 0 & 0 & 0 \\ 2 & 2 & 2 & 2 \\ \end{array}\right]\)
NumPy é uma biblioteca para Python que contém tipos para representar vetores e matrizes juntamente com diversas operações, dentre elas operações comuns de algebra linear e transformadas de Fourier.
NumPy é implementado para trazer maior eficiência do código em Python para aplicações científicas.
Primeiramente deve-se instalar o NumPy baixando-se o pacote de http://www.numpy.org/
Para usar os itens deste pacote deve-se importá-lo inicialmente com o comando
>>> import numpy
O objeto mais simples da biblioteca é o array que serve para criar vetores homogêneos multi-dimensionais.
Um array pode ser criado a partir de uma lista:
>>> import numpy
>>> a = numpy.array([1,2,3])
>>> a
array([1, 2, 3])
>>> a.ndim
1
>>> a.size
3
>>> Neste exemplo criamos um array de dimensão 1 com tamanho 3.
Um array pode ser criado a partir de uma lista de mais do que uma dimensão:
>>> a = numpy.array([[1,2,3],[4,5,6]])
>>> a
array([[1, 2, 3],
[4, 5, 6]])
>>> a.ndim
2
>>> a.size
6
>>> Neste exemplo criamos um array de dimensão 2 com tamanho 6.
Um array pode ser criado com mais do que uma dimensão utilizando as funções arange e reshape.
>>> a = numpy.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> a = numpy.arange(10).reshape(2,5)
>>> a
array([[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9]])
>>> Neste exemplo criamos um array de dimensão 1 com tamanho 10 e depois outro bidimensional \(2 \times5\).
NumPy oferece a função zeros que cria um array contendo apenas zeros. Seu argumento de entrada é uma tupla.
>>> numpy.zeros((3))
array([ 0., 0., 0.])
>>> numpy.zeros((3,4))
array([[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.]])
>>> Também existe a função ones que cria um array inicializado com uns.
>>> numpy.ones((2,5))
array([[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.]])
>>> Os operadores *, - , + , /, **, quando utilizados sob arrays, são aplicados em cada posição do array.
>>> m = numpy.ones((2,3))
>>> m+1
array([[ 2., 2., 2.],
[ 2., 2., 2.]])
>>> m*4
array([[ 4., 4., 4.],
[ 4., 4., 4.]])
>>> m = m +1
>>> m
array([[ 2., 2., 2.],
[ 2., 2., 2.]])
>>> m**3
array([[ 8., 8., 8.],
[ 8., 8., 8.]])
>>> NumPy oferece operações de algebra linear no pacote numpy.linalg.
>>> from numpy import *
>>> from numpy.linalg import *
>>> a = arange(9).reshape(3,3)
>>> b = array([ [2,2,2], [2,2,2], [2,2,2] ])
>>> a
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
>>> b
array([[2, 2, 2],
[2, 2, 2],
[2, 2, 2]])
>>> dot(a,b)
array([[ 6, 6, 6],
[24, 24, 24],
[42, 42, 42]])
>>> dot(b,a)
array([[18, 24, 30],
[18, 24, 30],
[18, 24, 30]])
>>> dot corresponde à multiplicação de matrizes.
inv calcula a inversa de uma matriz.
>>> a = array([ [2, 7, 2], [0,1, 3], [1,0,2]])
>>> a
array([[2, 7, 2],
[0, 1, 3],
[1, 0, 2]])
>>> b = inv(a)
>>> b
array([[ 0.08695652, -0.60869565, 0.82608696],
[ 0.13043478, 0.08695652, -0.26086957],
[-0.04347826, 0.30434783, 0.08695652]])
>>> dot(a,b)
array([[ 1., 0., 0.],
[ 0., 1., 0.],
[ 0., 0., 1.]])