Aula Numpy 01 - Criação arrays NumPy

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

{
 "cells": [
 {
 "cell_type": "markdown",
 "metadata": {},
 "source": [
 "# NumPy - Numerical Python\n",
 "\n",
 "## Criando arrays NumPy"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "# Importando o NumPy\n",
 "import numpy as np"
 ]
 },
 {
 "cell_type": "markdown",
 "metadata": {},
 "source": [
 "### Criando arrays de 1 dimensão"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "a1D = np.array([1, 2, 3])\n",
 "a1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "# O objeto criado é um ndarray: n-dimensional array\n",
 "type(a1D)"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "# Verificando o tipo dos elementos\n",
 "a1D.dtype"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "b1D = np.array([1, 2, 3], dtype = float)\n",
 "b1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "b1D.dtype"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "c1D = np.array([1, 2, 3], dtype = str)\n",
 "c1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "# str > float > int > bool\n",
 "d1D = np.array([1, 3.14, \"NumPy\", True])\n",
 "d1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "e1D = np.array([1, 3.14, False, True])\n",
 "e1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "e1D.dtype"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "f1D = np.array([1, False, True])\n",
 "f1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "f1D.dtype"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "g1D = np.array([False, True])\n",
 "g1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "g1D.dtype"
 ]
 },
 {
 "cell_type": "markdown",
 "metadata": {},
 "source": [
 "### Criando arrays de 2 dimensões"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "a2D = np.array([ [1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
 "a2D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "a2D.dtype"
 ]
 },
 {
 "cell_type": "markdown",
 "metadata": {},
 "source": [
 "### Criando arrays de 3 dimensões"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "a3D = np.array( [ [ [1,2,3], [4,5,6], [7,8,9] ], [ [11,12,13], [14,15,16], [17,18,19] ], [ [21,22,23], [24,25,26], [27,28,29] ]])\n",
 "a3D"
 ]
 },
 {
 "cell_type": "markdown",
 "metadata": {},
 "source": [
 "## Outras formas de criar arrays\n",
 "\n",
 "### Arrays preenchidos com zeros - zeros()"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "# 1 dimensão\n",
 "azeros = np.zeros(5)\n",
 "azeros"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "# 2 dimensões\n",
 "bzeros = np.zeros((3, 4)) # 3 linhas e 4 colunas\n",
 "bzeros"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "# 3 dimensões\n",
 "czeros = np.zeros((3, 4, 2)) # 3 páginas, 4 linhas e 2 colunas\n",
 "czeros"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "# 2 dimensões\n",
 "dzeros = np.zeros((3, 4), dtype = int) # 3 linhas e 4 colunas\n",
 "dzeros"
 ]
 },
 {
 "cell_type": "markdown",
 "metadata": {},
 "source": [
 "### Arrays preenchidos com 1's - ones()"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "# 1 dimensão\n",
 "a_um_1D = np.ones(5)\n",
 "a_um_1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "b_um_1D = np.ones(10, dtype = str)\n",
 "b_um_1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "c_um_1D = np.ones(5, dtype = int)\n",
 "c_um_1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "# 2 dimensões\n",
 "d_um_2D = np.ones((4, 3)) # 4 linhas e 3 colunas\n",
 "d_um_2D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "# 3 dimensões\n",
 "e_um_3D = np.ones((5, 2, 3)) \n",
 "e_um_3D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "# 4 dimensões\n",
 "f_um_4D = np.ones((3, 4, 2, 3)) \n",
 "f_um_4D"
 ]
 },
 {
 "cell_type": "markdown",
 "metadata": {},
 "source": [
 "### Arrays preenchidos com faixas de valores - arange()"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "# Cria um ndarray preenchido com os elementos de 0 a n-1\n",
 "# No exemplo abaixo vai criar um ndarray com os elementos 0 a 9\n",
 "a1D = np.arange(10)\n",
 "a1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "# Cria um ndarray preenchido com os elementos variando entre o valor inicial e o valor final - 1\n",
 "# Nesse exemplo vai criar um array com os elementos de 5 a 14\n",
 "b1D = np.arange(5, 15)\n",
 "b1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "# Cria um ndarray preenchido com os elementos variando entre o valor inicial e o valor final - 1, com um determinado step\n",
 "# No exemplo vai criar um array com os elementos de 5 a 100, com passo 10. Ou seja: 5, 15, 25...95\n",
 "c1D = np.arange(5,100, 10)\n",
 "c1D"
 ]
 },
 {
 "cell_type": "markdown",
 "metadata": {},
 "source": [
 "### Criando arrays preenchidos com valores igualmente espaçados - linspace()"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "# Cria um array com n elementos entre o valor inicial e valor final, igualmente
espaçados\n",
 "d1D = np.linspace(0,10, 2) # Cria um array com 2 valores entre 0 e 10\n",
 "d1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "e1D = np.linspace(0,10, 4) # Cria um array com 2 valores entre 0 e 10\n",
 "e1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "f1D = np.linspace(1,1000) # Se não for passada a quantidade de elementos, o padrão é gerar 50 elementos\n",
 "f1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "g1D = np.linspace(1,1000, dtype = int) # gerando int, a função simplesmente corta as casas decimais\n",
 "g1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "h1D = np.linspace(0,50, 10, endpoint = True) # O valor final é incluído\n",
 "h1D\n"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "i1D = np.linspace(0,50, 10, endpoint = False) # O valor final não é incluído\n",
 "i1D"
 ]
 },
 {
 "cell_type": "markdown",
 "metadata": {},
 "source": [
 "### Criando arrays preenchidos com um único valor passado por parâmetro - full()"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "a1D = np.full(10, 5) # ndarray contendo 10 números 5\n",
 "a1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "a2D = np.full((3, 5), 3) # ndarray de 3 linhas e 5 colunas contendo o número 3\n",
 "a2D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "a3D = np.full((3, 5, 8), -1) # ndarray de 3 páginas, 5 linhas e 8 colunas contendo o número -1\n",
 "a3D"
 ]
 },
 {
 "cell_type": "markdown",
 "metadata": {},
 "source": [
 "### Criando matriz identidade - eye()"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "ident = np.eye(5) # Cria uma matriz 5x5 preenchida com 1s na diagonal principal e 0 nas posições restantes\n",
 "ident"
 ]
 },
 {
 "cell_type": "markdown",
 "metadata": {},
 "source": [
 "### Criando matriz com elementos aleatórios"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "a1D = np.random.randint(0, 100, 10) # Cria um ndarray com 10 elementos entre 0 e 99\n",
 "a1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "a2D = np.random.randint(1, 500, (4,5))\n",
 "a2D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "# Gerando 10 combinações para a mega-sena\n",
 "# Valores vão de 1 a 60, 10 páginas, 1 linha, 6 colunas\n",
 "a3D = np.random.randint(1,61,(10,1,6)) \n",
 "a3D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "b1D = np.random.random(10) # Cria um ndarray contendo 10 elementos aleatórios entre 0 e 1\n",
 "b1D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": [
 "c2D = np.random.random((4,5)) # Cria um ndarray de 4 linhas e 5 colunas contendo elementos aleatórios entre 0 e 1\n",
 "c2D"
 ]
 },
 {
 "cell_type": "code",
 "execution_count": null,
 "metadata": {
 "collapsed": true
 },
 "outputs": [],
 "source": []
 }
 ],
 "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.6.3"
 }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}