{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Python Numérico (numpy): *arrays*\n",
"================================\n",
"\n",
"Introdução ao Numpy\n",
"------------------\n",
"\n",
"O pacote NumPy (lido como NUMerical PYthon) dá acesso a\n",
"\n",
"- uma nova estrutura de dados chamada `array` que permite\n",
"\n",
"- operações vetoriais e matriciais eficientes. Ela também fornece\n",
"\n",
"- uma série de operações de álgebra linear (como a resolução de sistemas de equações lineares e a computação de autovetores/autovalores).\n",
"\n",
"### Histórico\n",
"\n",
"Alguns conhecimentos prévios: existem duas outras implementações que fornecem quase a mesma funcionalidade do NumPy: `Numeric` e `numarray`.\n",
"\n",
"- `Numeric` foi a primeira provisão de um conjunto de métodos numéricos (semelhante ao Matlab) para Python. Ela evoluiu a partir de um projeto de doutorado.\n",
"\n",
"- `Numarray` é uma implementação de `Numeric` com certas melhorias (mas, para nossos propósitos, `Numeric` e `numarray` comportam-se praticamente de modo idêntico).\n",
"\n",
"- No início de 2006, decidiram combinar os melhores aspectos do `Numeric` e `numarray` no `Scipy` e fornecer o `array` (\"esperançosamente\", um produto final) como um tipo de dado incluído no módulo \"NumPy\".\n",
"\n",
"No restante do material, usaremos o pacote \"NumPy\" como fornecido pelo (novo) SciPy. Se, por algum motivo, isso não funcionar para você, é porque, provavelmente, sua versão do SciPy seja muito antiga. Nesse caso, `Numeric` ou `numarray` podem estar instaladas e devem fornecer quase que as mesmas capacidades. [5]\n",
"\n",
"### *Arrays*\n",
"\n",
"Apresentamos um novo tipo de dado (fornecido pelo NumPy) que é chamado de *array*. Uma matriz é \"parecida\" com uma lista, mas um *array* pode guardar apenas elementos do mesmo tipo (ao passo que uma lista pode misturar diferentes tipos de objetos). Isto significa que *arrays* são mais eficientes em armazenamento (porque não precisamos armazenar um tipo para cada elemento). *Arrays* também são a estrutura de dados de escolha para cálculos numéricos quando lidamos com vetores e matrizes. Vetores e matrizes (e matrizes com mais de dois índices) são todos chamados de *arrays* pela biblioteca NumPy.\n",
"\n",
"#### Vetores (*Arrays* 1D)\n",
"\n",
"A estrutura de dados de que precisaremos mais frequentemente é um vetor. Aqui estão alguns exemplos de como podemos gerar um:\n",
"\n",
"- Conversão de uma lista (ou tupla) em uma matriz usando `numpy.array`:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[ 0. 0.5 1. 1.5]\n"
]
}
],
"source": [
"import numpy as N\n",
"x = N.array([0, 0.5, 1, 1.5])\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Criação de um vetor usando \"ARRAYRange\":"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[ 0. 0.5 1. 1.5]\n"
]
}
],
"source": [
"x = N.arange(0, 2, 0.5)\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Criação de vetor de zeros"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[ 0. 0. 0. 0.]\n"
]
}
],
"source": [
"x = N.zeros(4)\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Uma vez que a matriz for estabelecida, podemos definir e recuperar valores individuais. Por exemplo:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[ 3.4 0. 4. 0. ]\n",
"3.4\n",
"[ 3.4 0. 4. ]\n"
]
}
],
"source": [
"x = N.zeros(4)\n",
"x[0] = 3.4\n",
"x[2] = 4\n",
"print(x)\n",
"print(x[0])\n",
"print(x[0:-1])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Observe que, tendo o vetor, podemos executar cálculos em cada elemento no vetor com uma única declaração:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[ 0. 0.5 1. 1.5]\n",
"[ 10. 10.5 11. 11.5]\n",
"[ 0. 0.25 1. 2.25]\n",
"[ 0. 0.47942554 0.84147098 0.99749499]\n"
]
}
],
"source": [
"x = N.arange(0, 2, 0.5)\n",
"print(x)\n",
"print(x + 10)\n",
"print(x ** 2)\n",
"print(N.sin(x))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Matrizes (*Arrays* 2D)\n",
"\n",
"Aqui estão duas maneiras de criar um *array* bidimensional:\n",
"\n",
"- Ao converter uma lista de listas (ou tuplas) em uma matriz:"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[1, 2, 3],\n",
" [4, 5, 6]])"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x = N.array([[1, 2, 3], [4, 5, 6]])\n",
"x"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Usando o método `zeros` para criar uma matriz com 5 linhas e 4 colunas"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0., 0., 0., 0.],\n",
" [ 0., 0., 0., 0.],\n",
" [ 0., 0., 0., 0.],\n",
" [ 0., 0., 0., 0.],\n",
" [ 0., 0., 0., 0.]])"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x = N.zeros((5, 4))\n",
"x"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"O \"formato\" de uma matriz pode ser consultado assim (aqui temos 2 linhas e 3 colunas):"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[1 2 3]\n",
" [4 5 6]]\n"
]
},
{
"data": {
"text/plain": [
"(2, 3)"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x=N.array([[1, 2, 3], [4, 5, 6]])\n",
"print(x)\n",
"x.shape"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Elementos individuais podem ser acessados e configurados usando esta sintaxe:"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x=N.array([[1, 2, 3], [4, 5, 6]])\n",
"x[0, 0] "
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x[0, 1]"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x[0, 2]"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"4"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x[1, 0]"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 4])"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x[:, 0]"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 2, 3])"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x[0,:]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Conversão de *array* para lista ou tupla\n",
"\n",
"Para converter um *array* de volta para uma lista ou tupla, podemos usar as funções padrão `list(s)` e `tuple(s)` do Python, que levam uma sequência `s` como argumento de entrada e retornam uma lista e uma tupla, respectivamente:"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 1, 4, 10])"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = N.array([1, 4, 10])\n",
"a"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1, 4, 10]"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list(a)"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(1, 4, 10)"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"tuple(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Operações de Álgebra Linear padrão \n",
"\n",
"#### Multiplicação de matrizes\n",
"\n",
"Dois *arrays* podem ser multiplicados na forma usual da álgebra linear usando `numpy.matrixmultiply`. Aqui está um exemplo:"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"collapsed": true,
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"import numpy as N\n",
"import numpy.random \n",
"A = numpy.random.rand(5, 5) # gera uma matriz aleatória 5x5\n",
"x = numpy.random.rand(5) # gera um vetor de 5 elementos\n",
"b=N.dot(A, x) # multiplica a matriz A pelo vetor x "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Solução de sistemas de equações lineares\n",
"\n",
"Para resolver um sistema de equações **Ax** = **b** que é dado na forma matricial (i.e. **A** é uma matriz e **x** e **b** são vetores, onde **A** e **b** são conhecidos e queremos encontrar o vetor desconhecido **x**), podemos usar o pacote de álgebra linear (`linalg`) do `numpy`:"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"collapsed": true,
"jupyter": {
"outputs_hidden": true
}
},
"outputs": [],
"source": [
"import numpy.linalg as LA\n",
"x = LA.solve(A, b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Calculando Autovetores e Autovalores\n",
"\n",
"Aqui está um pequeno exemplo que calcula os autovetores e autovalores \\[triviais\\] (`eig`) da matriz identidade (`eye`)):"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[ 1. 0. 0.]\n",
" [ 0. 1. 0.]\n",
" [ 0. 0. 1.]]\n"
]
}
],
"source": [
"import numpy\n",
"import numpy.linalg as LA\n",
"A = numpy.eye(3) #'eye'->I->1 (matriz identidade)\n",
"print(A)"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[ 1. 1. 1.]\n"
]
}
],
"source": [
"auto_valores, auto_vetores = LA.eig(A)\n",
"print(auto_valores)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[ 1. 0. 0.]\n",
" [ 0. 1. 0.]\n",
" [ 0. 0. 1.]]\n"
]
}
],
"source": [
"print(auto_vetores)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Observe que cada um desses comandos fornece sua própria documentação. Por exemplo, `help(LA.eig)` irá lhe dizer tudo sobre a função de autovetor e autovalor (uma vez que você tenha importado `numpy.linalg` como `LA`)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Ajuste polinomial de curvas \n",
"\n",
"Vamos supor que temos dados x-y para os quais queremos ajustar um polinômio (no sentido de quadrados mínimos).\n",
"\n",
"O `NumPy` fornece a rotina `polyfit(x, y, n)` (que é semelhante à função `polyfit` do Matlab, que toma por argumentos uma lista `x` de valores x para os pontos dos dados, uma lista `y` de valores y para os mesmos pontos de dados e `n`, a ordem desejada do polinômio que será determinado para ajustar os dados."
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAZQAAAEKCAYAAAA1qaOTAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSFyoUEREJC7+P4YWDkW1XQDlAAAAAElFTkSuQmCC\n",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"%matplotlib inline\n",
"import numpy\n",
"\n",
"# demonstração - ajuste de curva: `xdata` e `ydata` são dados de entrada\n",
"xdata = numpy.array([0.0 , 1.0 , 2.0 , 3.0 , 4.0 , 5.0])\n",
"ydata = numpy.array([0.0 , 0.8 , 0.9 , 0.1 , -0.8 , -1.0])\n",
"\n",
"# ajuste por um polinômio cúbico (ordem = 3) \n",
"z = numpy.polyfit(xdata, ydata, 3)\n",
"\n",
"# z é um array de coeficientes, maior grau primeiro, i . e .\n",
"# X^3 X^2 X 0\n",
"# z = array ([ 0.08703704 , -0.81349206 , 1.69312169 , -0.03968254])\n",
"\n",
"# É conveniente usar objetos ‘poly1d‘ para lidar com polinômios:\n",
"p = numpy.poly1d(z) # cria uma função polinomial p a partir dos coeficientes\n",
" # e p pode ser avaliado para todo x então.\n",
"\n",
"# cria plot\n",
"xs = [0.1 * i for i in range (50)]\n",
"ys = [p(x) for x in xs] # avalia p(x) para todo `x` na lista `xs`\n",
"\n",
"import pylab\n",
"pylab.plot(xdata, ydata, 'o', label='dados')\n",
"pylab.plot(xs, ys, label='curva ajustada')\n",
"pylab.ylabel('y')\n",
"pylab.xlabel('x')\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A figura mostra a curva ajustada (linha contínua) juntamente com os pontos de dados calculados precisos."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Mais exemplos NumPy\n",
"\n",
"Podem ser encontrados aqui: \n",
"\n",
"### NumPy para usuários do Matlab\n",
"\n",
"Há uma página dedicada que explica o módulo NumPy a partir da perspectiva de um usuário (experiente) do Matlab em ."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.4"
}
},
"nbformat": 4,
"nbformat_minor": 4
}