Estadisticas

Python para análisis estadístico

Estadísticas

La estadística es la disciplina que estudia la recopilación , organización , visualización , análisis , interpretación y presentación de datos. La estadística es una rama de las matemáticas que se recomienda como requisito previo para la ciencia de datos y el aprendizaje automático. La estadística es un campo muy amplio pero en esta sección nos centraremos sólo en la parte más relevante. Después de completar este desafío, puede continuar con el camino del desarrollo web, análisis de datos, aprendizaje automático y ciencia de datos. Cualquiera que sea el camino que sigas, en algún momento de tu carrera obtendrás datos en los que podrás trabajar. Tener algunos conocimientos estadísticos te ayudará a tomar decisiones basadas en datos, los datos dicen como dicen .

Datos

¿Qué son los datos? Los datos son cualquier conjunto de caracteres que se recopilan y traducen con algún propósito, generalmente análisis. Puede ser cualquier carácter, incluidos texto y números, imágenes, sonido o vídeo. Si los datos no se ponen en contexto, no tienen ningún sentido para un humano o una computadora. Para que los datos tengan sentido, debemos trabajar con ellos utilizando diferentes herramientas.

El flujo de trabajo del análisis de datos, la ciencia de datos o el aprendizaje automático parte de los datos. Los datos pueden proporcionarse desde alguna fuente de datos o pueden crearse. Hay datos estructurados y no estructurados.

Los datos se pueden encontrar en pequeño o gran formato. La mayoría de los tipos de datos que obtendremos se han tratado en la sección de manejo de archivos.

Módulo de Estadísticas

El módulo de estadísticas de Python proporciona funciones para calcular estadísticas matemáticas de datos numéricos. El módulo no pretende competir con bibliotecas de terceros como NumPy, SciPy o paquetes estadísticos propietarios con todas las funciones dirigidos a estadísticos profesionales como Minitab, SAS y Matlab. Está dirigido al nivel de calculadoras gráficas y científicas.

NumPy

En la primera sección definimos Python como un excelente lenguaje de programación de propósito general por sí solo, pero con la ayuda de otras bibliotecas populares como (numpy, scipy, matplotlib, pandas, etc.) se convierte en un entorno poderoso para la informática científica.

NumPy es la biblioteca central para informática científica en Python. Proporciona un objeto de matriz multidimensional de alto rendimiento y herramientas para trabajar con matrices.

Hasta ahora hemos estado usando vscode pero de ahora en adelante recomendaría usar Jupyter Notebook. Para acceder a jupyter notebook, instalemos anaconda . Si está utilizando anaconda, la mayoría de los paquetes comunes están incluidos y no tiene paquetes de instalación si instaló anaconda.

asabeneh@Asabeneh:~/Desktop/30DaysOfPython$ pip install numpy

Importando números

El cuaderno Jupyter está disponible si está a favor del cuaderno Jupyter.

    # How to import numpy
    import numpy as np
    # How to check the version of the numpy package
    print('numpy:', np.__version__)
    # Checking the available methods
    print(dir(np))

Creando una matriz numpy usando

Creando matrices int numpy

    # Creating python List
    python_list = [1,2,3,4,5]

    # Checking data types
    print('Type:', type (python_list)) # <class 'list'>
    #
    print(python_list) # [1, 2, 3, 4, 5]

    two_dimensional_list = [[0,1,2]]

    print(two_dimensional_list)  # [[0, 1, 2]]

    # Creating Numpy(Numerical Python) array from python list

    numpy_array_from_list = np.array(python_list)
    print(type (numpy_array_from_list))   # <class 'numpy.ndarray'>
    print(numpy_array_from_list) # array([1, 2, 3, 4, 5])

[[https://github.com/carlsvelz/30-Days-Of-Python/blob/master/24_Day_Statistics/24_statistics.md#creating-float-numpy-arrays]]Creando matrices flotantes numerosas

Crear una matriz flotante y numerosa a partir de una lista con un parámetro de tipo de datos flotante

    # Python list
    python_list = [1,2,3,4,5]

    numy_array_from_list2 = np.array(python_list, dtype=float)
    print(numy_array_from_list2) # array([1., 2., 3., 4., 5.])

[[https://github.com/carlsvelz/30-Days-Of-Python/blob/master/24_Day_Statistics/24_statistics.md#creating-boolean-numpy-arrays]]Creando matrices booleanas numpy

Crear una matriz booleana numpy a partir de la lista

    numpy_bool_array = np.array([0, 1, -1, 0, 0], dtype=bool)
    print(numpy_bool_array) # array([False,  True,  True, False, False])

Creando una matriz multidimensional usando numpy

Una matriz numerosa puede tener una o varias filas y columnas

    two_dimensional_list = [[0,1,2]]
    numpy_two_dimensional_list = np.array(two_dimensional_list)
    print(type (numpy_two_dimensional_list))
    print(numpy_two_dimensional_list)

    <class 'numpy.ndarray'>
    [[0 1 2]
     [3 4 5]
     [6 7 8]]

Convirtiendo una matriz numpy en una lista

# We can always convert an array back to a python list using tolist().
np_to_list = numpy_array_from_list.tolist()
print(type (np_to_list))
print('one dimensional array:', np_to_list)
print('two dimensional array: ', numpy_two_dimensional_list.tolist())

    <class 'list'>
    one dimensional array: [1, 2, 3, 4, 5]
    two dimensional array:  [[0, 1, 2]]

Creando una matriz numpy a partir de una tupla

# Numpy array from tuple
# Creating tuple in Python
python_tuple = (1,2,3,4,5)
print(type (python_tuple)) # <class 'tuple'>
print('python_tuple: ', python_tuple) # python_tuple:  (1, 2, 3, 4, 5)

numpy_array_from_tuple = np.array(python_tuple)
print(type (numpy_array_from_tuple)) # <class 'numpy.ndarray'>
print('numpy_array_from_tuple: ', numpy_array_from_tuple) # numpy_array_from_tuple:  [1 2 3 4 5]

Forma de matriz numerosa

El método de forma proporciona la forma de la matriz como una tupla. La primera es la fila y la segunda es la columna. Si la matriz es solo unidimensional, devuelve el tamaño de la matriz.

    nums = np.array([1, 2, 3, 4, 5])
    print(nums)
    print('shape of nums: ', nums.shape)
    print(numpy_two_dimensional_list)
    print('shape of numpy_two_dimensional_list: ', numpy_two_dimensional_list.shape)
    three_by_four_array = np.array([[0, 1, 2, 3],
        [4,5,6,7],
        [8,9,10, 11]])
    print(three_by_four_array.shape)

    [1 2 3 4 5]
    shape of nums:  (5,)
    [[0 1 2]
     [3 4 5]
     [6 7 8]]
    shape of numpy_two_dimensional_list:  (3, 3)
    (3, 4)

Tipo de datos de matriz numpy

Tipo de tipos de datos: str, int, float, complex, bool, list, Ninguno

int_lists = [-3, -2, -1, 0, 1, 2,3]
int_array = np.array(int_lists)
float_array = np.array(int_lists, dtype=float)

print(int_array)
print(int_array.dtype)
print(float_array)
print(float_array.dtype)

    [-3 -2 -1  0  1  2  3]
    int64
    [-3. -2. -1.  0.  1.  2.  3.]
    float64

Tamaño de una matriz numerosa

En numpy, para saber la cantidad de elementos en una lista de matriz numpy, usamos el tamaño

numpy_array_from_list = np.array([1, 2, 3, 4, 5])
two_dimensional_list = np.array([[0, 1, 2],
                              [3, 4, 5],
                              [6, 7, 8]])

print('The size:', numpy_array_from_list.size) # 5
print('The size:', two_dimensional_list.size)  # 3

    The size: 5
    The size: 9

Operación matemática usando numpy

La matriz NumPy no es exactamente como la lista de Python. Para realizar una operación matemática en la lista de Python, tenemos que recorrer los elementos, pero numpy puede permitir realizar cualquier operación matemática sin realizar un bucle. Operacion matematica:

• Suma (+)
• Resta (-)
• Multiplicación (*)
• División (/)
• Módulos (%)
• División de piso(//)
• Exponencial(**)

Suma

# Mathematical Operation
# Addition
numpy_array_from_list = np.array([1, 2, 3, 4, 5])
print('original array: ', numpy_array_from_list)
ten_plus_original = numpy_array_from_list  + 10
print(ten_plus_original)

    original array:  [1 2 3 4 5]
    [11 12 13 14 15]

Sustracción

# Subtraction
numpy_array_from_list = np.array([1, 2, 3, 4, 5])
print('original array: ', numpy_array_from_list)
ten_minus_original = numpy_array_from_list  - 10
print(ten_minus_original)

    original array:  [1 2 3 4 5]
    [-9 -8 -7 -6 -5]

Multiplicación

# Multiplication
numpy_array_from_list = np.array([1, 2, 3, 4, 5])
print('original array: ', numpy_array_from_list)
ten_times_original = numpy_array_from_list * 10
print(ten_times_original)

    original array:  [1 2 3 4 5]
    [10 20 30 40 50]

División

# Division
numpy_array_from_list = np.array([1, 2, 3, 4, 5])
print('original array: ', numpy_array_from_list)
ten_times_original = numpy_array_from_list / 10
print(ten_times_original)

    original array:  [1 2 3 4 5]
    [0.1 0.2 0.3 0.4 0.5]

Módulo

# Modulus; Finding the remainder
numpy_array_from_list = np.array([1, 2, 3, 4, 5])
print('original array: ', numpy_array_from_list)
ten_times_original = numpy_array_from_list % 3
print(ten_times_original)

    original array:  [1 2 3 4 5]
    [1 2 0 1 2]

División de piso

# Floor division: the division result without the remainder
numpy_array_from_list = np.array([1, 2, 3, 4, 5])
print('original array: ', numpy_array_from_list)
ten_times_original = numpy_array_from_list // 10
print(ten_times_original)

Exponencial

# Exponential is finding some number the power of another:
numpy_array_from_list = np.array([1, 2, 3, 4, 5])
print('original array: ', numpy_array_from_list)
ten_times_original = numpy_array_from_list  ** 2
print(ten_times_original)

    original array:  [1 2 3 4 5]
    [ 1  4  9 16 25]

Comprobando tipos de datos

#Int,  Float numbers
numpy_int_arr = np.array([1,2,3,4])
numpy_float_arr = np.array([1.1, 2.0,3.2])
numpy_bool_arr = np.array([-3, -2, 0, 1,2,3], dtype='bool')

print(numpy_int_arr.dtype)
print(numpy_float_arr.dtype)
print(numpy_bool_arr.dtype)

    int64
    float64
    bool

Tipos de conversión

Podemos convertir los tipos de datos de una matriz numpy.

1. Int a flotar

numpy_int_arr = np.array([1,2,3,4], dtype = 'float')
numpy_int_arr

array([1., 2., 3., 4.])

2. Flotar a Int

numpy_int_arr = np.array([1., 2., 3., 4.], dtype = 'int')
numpy_int_arr

    array([1, 2, 3, 4])

3. int o booleano

np.array([-3, -2, 0, 1,2,3], dtype='bool')

    array([ True,  True, False,  True,  True,  True])

4. int a cadena

numpy_float_list.astype('int').astype('str')

    array(['1', '2', '3'], dtype='<U21')

Matrices multidimensionales

# 2 Dimension Array
two_dimension_array = np.array([(1,2,3),(4,5,6), (7,8,9)])
print(type (two_dimension_array))
print(two_dimension_array)
print('Shape: ', two_dimension_array.shape)
print('Size:', two_dimension_array.size)
print('Data type:', two_dimension_array.dtype)

    <class 'numpy.ndarray'>
    [[1 2 3]
     [4 5 6]
     [7 8 9]]
    Shape:  (3, 3)
    Size: 9
    Data type: int64

Obtener elementos de una matriz numerosa

# 2 Dimension Array
two_dimension_array = np.array([[1,2,3]])
first_row = two_dimension_array[0]
second_row = two_dimension_array[1]
third_row = two_dimension_array[2]
print('First row:', first_row)
print('Second row:', second_row)
print('Third row: ', third_row)

    First row: [1 2 3]
    Second row: [4 5 6]
    Third row:  [7 8 9]

first_column= two_dimension_array[:,0]
second_column = two_dimension_array[:,1]
third_column = two_dimension_array[:,2]
print('First column:', first_column)
print('Second column:', second_column)
print('Third column: ', third_column)
print(two_dimension_array)

    First column: [1 4 7]
    Second column: [2 5 8]
    Third column:  [3 6 9]
    [[1 2 3]
     [4 5 6]
     [7 8 9]]

Cortar la matriz Numpy

Cortar en numpy es similar a cortar en una lista de Python

two_dimension_array = np.array([[1,2,3]])
first_two_rows_and_columns = two_dimension_array[0:2, 0:2]
print(first_two_rows_and_columns)

    [[1 2]
     [4 5]]

¿Cómo invertir las filas y toda la matriz?

two_dimension_array[::]

    array([[1, 2, 3],
           [4, 5, 6],
           [7, 8, 9]])

Invertir las posiciones de filas y columnas.

    two_dimension_array = np.array([[1,2,3]])
    two_dimension_array[::-1,::-1]

    array([[9, 8, 7],
           [6, 5, 4],
           [3, 2, 1]])

¿Cómo representar los valores faltantes?

    print(two_dimension_array)
    two_dimension_array[1,1] = 55
    two_dimension_array[1,2] =44
    print(two_dimension_array)

    [[1 2 3]
     [4 5 6]
     [7 8 9]]
    [[ 1  2  3]
     [ 4 55 44]
     [ 7  8  9]]

    # Numpy Zeroes
    # numpy.zeros(shape, dtype=float, order='C')
    numpy_zeroes = np.zeros((3,3),dtype=int,order='C')
    numpy_zeroes

    array([[0, 0, 0],
           [0, 0, 0],
           [0, 0, 0]])

# Numpy Zeroes
numpy_ones = np.ones((3,3),dtype=int,order='C')
print(numpy_ones)

    [[1 1 1]
     [1 1 1]
     [1 1 1]]

twoes = numpy_ones * 2

# Reshape
# numpy.reshape(), numpy.flatten()
first_shape  = np.array([(1,2,3), (4,5,6)])
print(first_shape)
reshaped = first_shape.reshape(3,2)
print(reshaped)

    [[1 2 3]
     [4 5 6]]
    [[1 2]
     [3 4]
     [5 6]]

flattened = reshaped.flatten()
flattened

    array([1, 2, 3, 4, 5, 6])

    ## Horitzontal Stack
    np_list_one = np.array([1,2,3])
    np_list_two = np.array([4,5,6])

    print(np_list_one + np_list_two)

    print('Horizontal Append:', np.hstack((np_list_one, np_list_two)))

    [5 7 9]
    Horizontal Append: [1 2 3 4 5 6]

    ## Vertical Stack
    print('Vertical Append:', np.vstack((np_list_one, np_list_two)))

    Vertical Append: [[1 2 3]
     [4 5 6]]

Generando números aleatorios

    # Generate a random float  number
    random_float = np.random.random()
    random_float

    0.018929887384753874

    # Generate a random float  number
    random_floats = np.random.random(5)
    random_floats

    array([0.26392192, 0.35842215, 0.87908478, 0.41902195, 0.78926418])

    # Generating a random integers between 0 and 10

    random_int = np.random.randint(0, 11)
    random_int

    4

    # Generating a random integers between 2 and 11, and creating a one row array
    random_int = np.random.randint(2,10, size=4)
    random_int

    array([8, 8, 8, 2])

    # Generating a random integers between 0 and 10
    random_int = np.random.randint(2,10, size=(3,3))
    random_int

    array([[3, 5, 3],
           [7, 3, 6],
           [2, 3, 3]])

Generación de números aleatorios

    # np.random.normal(mu, sigma, size)
    normal_array = np.random.normal(79, 15, 80)
    normal_array

    array([ 89.49990595,  82.06056961, 107.21445842,  38.69307086,
            47.85259157,  93.07381061,  76.40724259,  78.55675184,
            72.17358173,  47.9888899 ,  65.10370622,  76.29696568,
            95.58234254,  68.14897213,  38.75862686, 122.5587927 ,
            67.0762565 ,  95.73990864,  81.97454563,  92.54264805,
            59.37035153,  77.76828101,  52.30752166,  64.43109931,
            62.63695351,  90.04616138,  75.70009094,  49.87586877,
            80.22002414,  68.56708848,  76.27791052,  67.24343975,
            81.86363935,  78.22703433, 102.85737041,  65.15700341,
            84.87033426,  76.7569997 ,  64.61321853,  67.37244562,
            74.4068773 ,  58.65119655,  71.66488727,  53.42458179,
            70.26872028,  60.96588544,  83.56129414,  72.14255326,
            81.00787609,  71.81264853,  72.64168853,  86.56608717,
            94.94667321,  82.32676973,  70.5165446 ,  85.43061003,
            72.45526212,  87.34681775,  87.69911217, 103.02831489,
            75.28598596,  67.17806893,  92.41274447, 101.06662611,
            87.70013935,  70.73980645,  46.40368207,  50.17947092,
            61.75618542,  90.26191397,  78.63968639,  70.84550744,
            88.91826581, 103.91474733,  66.3064638 ,  79.49726264,
            70.81087439,  83.90130623,  87.58555972,  59.95462521])

Numpy y las estadísticas

import matplotlib.pyplot as plt
import seaborn as sns
sns.set()
plt.hist(normal_array, color="grey", bins=50)

    (array([2., 0., 0., 0., 1., 2., 2., 0., 2., 0., 0., 1., 2., 2., 1., 4., 3.,
            4., 2., 7., 2., 2., 5., 4., 2., 4., 3., 2., 1., 5., 3., 0., 3., 2.,
            1., 0., 0., 1., 3., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 1.]),
     array([ 38.69307086,  40.37038529,  42.04769973,  43.72501417,
             45.4023286 ,  47.07964304,  48.75695748,  50.43427191,
             52.11158635,  53.78890079,  55.46621523,  57.14352966,
             58.8208441 ,  60.49815854,  62.17547297,  63.85278741,
             65.53010185,  67.20741628,  68.88473072,  70.56204516,
             72.23935959,  73.91667403,  75.59398847,  77.27130291,
             78.94861734,  80.62593178,  82.30324622,  83.98056065,
             85.65787509,  87.33518953,  89.01250396,  90.6898184 ,
             92.36713284,  94.04444727,  95.72176171,  97.39907615,
             99.07639058, 100.75370502, 102.43101946, 104.1083339 ,
            105.78564833, 107.46296277, 109.14027721, 110.81759164,
            112.49490608, 114.17222052, 115.84953495, 117.52684939,
            119.20416383, 120.88147826, 122.5587927 ]),
     <a list of 50 Patch objects>)

Matriz en números

four_by_four_matrix = np.matrix(np.ones((4,4), dtype=float))

four_by_four_matrix

matrix([[1., 1., 1., 1.],
            [1., 1., 1., 1.],
            [1., 1., 1., 1.],
            [1., 1., 1., 1.]])

np.asarray(four_by_four_matrix)[2] = 2
four_by_four_matrix

matrix([[1., 1., 1., 1.],
            [1., 1., 1., 1.],
            [2., 2., 2., 2.],
            [1., 1., 1., 1.]])

Numpy numpy.arange()

¿Qué es Organizar?

A veces, desea crear valores que estén espaciados uniformemente dentro de un intervalo definido. Por ejemplo, desea crear valores del 1 al 10; puedes usar la función numpy.arange()

# creating list using range(starting, stop, step)
lst = range(0, 11, 2)
lst

range(0, 11, 2)

for l in lst:
    print(l)

    2
    4
    6
    8
    10

# Similar to range arange numpy.arange(start, stop, step)
whole_numbers = np.arange(0, 20, 1)
whole_numbers

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
           17, 18, 19])

natural_numbers = np.arange(1, 20, 1)
natural_numbers

odd_numbers = np.arange(1, 20, 2)
odd_numbers

    array([ 1,  3,  5,  7,  9, 11, 13, 15, 17, 19])

even_numbers = np.arange(2, 20, 2)
even_numbers

    array([ 2,  4,  6,  8, 10, 12, 14, 16, 18])

Crear secuencia de números usando linspace

# numpy.linspace()
# numpy.logspace() in Python with Example
# For instance, it can be used to create 10 values from 1 to 5 evenly spaced.
np.linspace(1.0, 5.0, num=10)

    array([1.        , 1.44444444, 1.88888889, 2.33333333, 2.77777778,
           3.22222222, 3.66666667, 4.11111111, 4.55555556, 5.        ])

# not to include the last value in the interval
np.linspace(1.0, 5.0, num=5, endpoint=False)

array([1. , 1.8, 2.6, 3.4, 4.2])

# LogSpace
# LogSpace returns even spaced numbers on a log scale. Logspace has the same parameters as np.linspace.

# Syntax:

# numpy.logspace(start, stop, num, endpoint)

np.logspace(2, 4.0, num=4)

array([  100.        ,   464.15888336,  2154.43469003, 10000.        ])

# to check the size of an array
x = np.array([1,2,3], dtype=np.complex128)

x

    array([1.+0.j, 2.+0.j, 3.+0.j])

x.itemsize

16

# indexing and Slicing NumPy Arrays in Python
np_list = np.array([(1,2,3), (4,5,6)])
np_list

    array([[1, 2, 3],
           [4, 5, 6]])

print('First row: ', np_list[0])
print('Second row: ', np_list[1])

    First row:  [1 2 3]
    Second row:  [4 5 6]

print('First column: ', np_list[:,0])
print('Second column: ', np_list[:,1])
print('Third column: ', np_list[:,2])

    First column:  [1 4]
    Second column:  [2 5]
    Third column:  [3 6]

Funciones estadísticas NumPy con ejemplo

NumPy tiene funciones estadísticas bastante útiles para encontrar mínimo, máximo, media, mediana, percentil, desviación estándar y varianza, etc. de los elementos dados en la matriz. Las funciones se explican a continuación: Función estadística Numpy está equipado con la función estadística robusta que se detalla a continuación.

• Numerosas funciones
  • Min np.min()
  • Max np.max()
  • Media np.media()
  • Mediana np.mediana()
  • Varianza
  • percentil
  • Desviación estándar np.std()

np_normal_dis = np.random.normal(5, 0.5, 100)
np_normal_dis
## min, max, mean, median, sd
print('min: ', two_dimension_array.min())
print('max: ', two_dimension_array.max())
print('mean: ',two_dimension_array.mean())
# print('median: ', two_dimension_array.median())
print('sd: ', two_dimension_array.std())

min:  1
max:  55
mean:  14.777777777777779
sd:  18.913709183069525

min:  1
max:  55
mean:  14.777777777777779
sd:  18.913709183069525

print(two_dimension_array)
print('Column with minimum: ', np.amin(two_dimension_array,axis=0))
print('Column with maximum: ', np.amax(two_dimension_array,axis=0))
print('=== Row ==')
print('Row with minimum: ', np.amin(two_dimension_array,axis=1))
print('Row with maximum: ', np.amax(two_dimension_array,axis=1))

[[ 1  2  3]
 [ 4 55 44]
 [ 7  8  9]]
Column with minimum:  [1 2 3]
Column with maximum:  [ 7 55 44]
=== Row ==
Row with minimum:  [1 4 7]
Row with maximum:  [ 3 55  9]

¿Cómo crear secuencias repetidas?

a = [1,2,3]

# Repeat whole of 'a' two times
print('Tile:   ', np.tile(a, 2))

# Repeat each element of 'a' two times
print('Repeat: ', np.repeat(a, 2))

Tile:    [1 2 3 1 2 3]
Repeat:  [1 1 2 2 3 3]

¿Cómo generar números aleatorios?

# One random number between [0,1)
one_random_num = np.random.random()
one_random_in = np.random
print(one_random_num)

0.6149403282678213

0.4763968133790438

0.4763968133790438

# Random numbers between [0,1) of shape 2,3
r = np.random.random(size=[2,3])
print(r)

[[0.13031737 0.4429537  0.1129527 ]
 [0.76811539 0.88256594 0.6754075 ]]

print(np.random.choice(['a', 'e', 'i', 'o', 'u'], size=10))

['u' 'o' 'o' 'i' 'e' 'e' 'u' 'o' 'u' 'a']

['i' 'u' 'e' 'o' 'a' 'i' 'e' 'u' 'o' 'i']

['iueoaieuoi']

## Random numbers between [0, 1] of shape 2, 2
rand = np.random.rand(2,2)
rand

array([[0.97992598, 0.79642484],
       [0.65263629, 0.55763145]])

rand2 = np.random.randn(2,2)
rand2

array([[ 1.65593322, -0.52326621],
       [ 0.39071179, -2.03649407]])

# Random integers between [0, 10) of shape 2,5
rand_int = np.random.randint(0, 10, size=[5,3])
rand_int

array([[0, 7, 5],
       [4, 1, 4],
       [3, 5, 3],
       [4, 3, 8],
       [4, 6, 7]])

from scipy import stats
np_normal_dis = np.random.normal(5, 0.5, 1000) # mean, standard deviation, number of samples
np_normal_dis
## min, max, mean, median, sd
print('min: ', np.min(np_normal_dis))
print('max: ', np.max(np_normal_dis))
print('mean: ', np.mean(np_normal_dis))
print('median: ', np.median(np_normal_dis))
print('mode: ', stats.mode(np_normal_dis))
print('sd: ', np.std(np_normal_dis))

    min:  3.557811005458804
    max:  6.876317743643499
    mean:  5.035832048106663
    median:  5.020161980441937
    mode:  ModeResult(mode=array([3.55781101]), count=array([1]))
    sd:  0.489682424165213

plt.hist(np_normal_dis, color="grey", bins=21)
plt.show()

# numpy.dot(): Dot Product in Python using Numpy
# Dot Product
# Numpy is powerful library for matrices computation. For instance, you can compute the dot product with np.dot

# Syntax

# numpy.dot(x, y, out=None)

Álgebra lineal

1. Producto escalar

## Linear algebra
### Dot product: product of two arrays
f = np.array([1,2,3])
g = np.array([4,5,3])
### 1*4+2*5 + 3*6
np.dot(f, g)  # 23

Multiplicación de matrices NumPy con np.matmul()

### Matmul: matruc product of two arrays
h = [[1,2]]
i = [[5,6]]
### 1*5+2*7 = 19
np.matmul(h, i)

    array([[19, 22],
           [43, 50]])

## Determinant 2*2 matrix
### 5*8-7*6np.linalg.det(i)

np.linalg.det(i)

-1.999999999999999

Z = np.zeros((8,8))
Z[1::2,::2] = 1
Z[::2,1::2] = 1

Z

array([[0., 1., 0., 1., 0., 1., 0., 1.],
       [1., 0., 1., 0., 1., 0., 1., 0.],
       [0., 1., 0., 1., 0., 1., 0., 1.],
       [1., 0., 1., 0., 1., 0., 1., 0.],
       [0., 1., 0., 1., 0., 1., 0., 1.],
       [1., 0., 1., 0., 1., 0., 1., 0.],
       [0., 1., 0., 1., 0., 1., 0., 1.],
       [1., 0., 1., 0., 1., 0., 1., 0.]])

new_list = [ x + 2 for x in range(0, 11)]

new_list

[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

[2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

np_arr = np.array(range(0, 11))
np_arr + 2

matriz([2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])

Usamos ecuaciones lineales para cantidades que tienen una relación lineal. Veamos el ejemplo a continuación:

temp = np.array([1,2,3,4,5])
pressure = temp * 2 + 5
pressure

matriz([7, 9, 11, 13, 15])

plt.plot(temp,pressure)
plt.xlabel('Temperature in oC')
plt.ylabel('Pressure in atm')
plt.title('Temperature vs Pressure')
plt.xticks(np.arange(0, 6, step=0.5))
plt.show()

Dibujar la distribución normal gaussiana usando numpy. Como puede ver a continuación, numpy puede generar números aleatorios. Para crear una muestra aleatoria, necesitamos la media (mu), sigma (desviación estándar) y una cantidad de puntos de datos.

mu = 28
sigma = 15
samples = 100000

x = np.random.normal(mu, sigma, samples)
ax = sns.distplot(x);
ax.set(xlabel="x", ylabel='y')
plt.show()

Veraniego

Para resumir, las principales diferencias con las listas de Python son:

1. Las matrices admiten operaciones vectorizadas, mientras que las listas no.
2. Una vez que se crea una matriz, no puede cambiar su tamaño. Tendrás que crear una nueva matriz o sobrescribir la existente.
3. Cada matriz tiene un solo tipo de dtype. Todos los elementos que contiene deben ser de ese tipo.
4. Una matriz numpy equivalente ocupa mucho menos espacio que una lista de listas de Python.
5. Las matrices numerosas admiten la indexación booleana.