TUPLES (TUPLAS)

En Python, hay diferentes tipos de datos: cadena(string), entero(integer) y flotante(float). Todos estos
tipos de datos pueden estar contenidos en una tupla de la siguiente manera:
str int float
“tipo de cambio” 100 3.35

#Crea tu primera tupla

tupla1=(“tipo de cambio”,100,3.35)
tupla1
 ('tipo de cambio', 100, 3.35)
El tipo de variable es una tupla

#Imprime el tipo de la tupla que tú creaste

type(tupla1)
 tuple

Indexación
Se puede acceder a cada elemento de una tupla a través de un índice. La siguiente tabla representa la
relación entre el índice y los elementos en la tupla. Cada elemento se puede obtener por el nombre de
la tupla seguido de un corchete con el número de índice:

0 “tipo de cambio” tupla1[0] : “tipo de cambio”

1 100 tupla1[1] : 100
2 3.35 tupla1[2] : 3.35
También podemos usar indexación negativa.

-3 “tipo de cambio” tupla1[-3] : “tipo de cambio”

-2 100 tupla1[-2] : 100
-1 3.35 tupla1[-1] : 3.35

Podemos imprimir los valores de la tupla

# Imprimir la variable de los primeros dos índices
print(tupla1[0])
 tipo de cambio
print(tupla1[1])
 100
Podemos imprimir el tipo de cada valor en la tupla:
# Imprime el tipo de valor en cada índice
print(type(tupla1[0]))
 <class ‘str’>
print(type(tupla1[1]))
 <class ‘int’>
print(type(tupla1[1]))
 <class ‘float’>

Concatenación de tuplas
Podemos concatenar o combinar tuplas utilizando el signo +:
# Concatenar dos tuplas
tupla2=tupla1+ (“exportaciones”,”importaciones”)
tupla2
 ('tipo de cambio', 100, 3.35, 'exportaciones', 'importaciones')

Podemos cortar tuplas obteniendo múltiples valores como lo demuestra la siguiente figura:

(“tipo de cambio”, 100, 3.35, “exportaciones”, “importaciones”)

0 1 2 3 4

tupla2[3:5]
 (‘exportaciones’, ‘importaciones’)
tupla2[1:4]
 (100, 3.35, ‘exportaciones’)

Podemos obtener la longitud de una tupla usando el comando length

# Obtener la longitud de la tupla

len(tupla2)
5
Ordenar
Considere la siguiente tupla:

#Una muestra de tupla

Tipo_de_cambio = (3.30, 3.29, 3.27, 3.36, 3.32)

Podemos ordenar los valores en una tupla y guardarla en una tupla nueva con el comando sorted:

#Ordenar la tupla
tipo_de_cambio_ordenado=sorted(tipo_de_cambio)
tipo_de_cambio_ordenado
 [3.27, 3.29, 3.3, 3.32, 3.36]

Tupla anidada
Una tupla puede contener otra tupla así como otros tipos de datos más complejos. Este proceso se
llama 'anidamiento'. Considera la siguiente tupla con varios elementos:

#Crear una tupla anidada

PBI=(“consumo”, “inversión”, “gastos del gobierno”,(“exportaciones”,”importaciones”))

Cada elemento de la tupla, incluidas otras tuplas, se puede obtener a través de un índice como se
muestra en la figura:

PBI=(“consumo”, “inversión”, “gastos del gobierno”,(“exportaciones”,”importaciones”))

0 1 2 3

# Imprimir elemento en cada índice

print(“Familias:”,PBI[0])
 Familias: consumo
print(“Empresas:”,PBI[1])
 Empresas: inversión
print(“Estado:”,PBI[2])
 Estado: gastos del gobierno
print(“Extranjero:”,PBI[3])
 Extranjero: (‘exportaciones’,’importaciones’)
Podemos usar el segundo índice para acceder a otras tuplas como se muestra en la figura:

PBI=(“consumo”, “inversión”, “gastos del gobierno”,(“exportaciones”,”importaciones”))

0 1 2 3

PBI[3]

(“exportaciones”,”importaciones”)

0 1
PBI[3][0] PBI[3][1]

Podemos acceder a las tuplas anidadas:

# Imprimir elemento en cada índice, incluyendo índices de nido

print(“ventas al extranjero:”, PBI[3][0])
 ventas al extranjero: exportaciones
print(“compras al extranjero:”, PBI[3][1])
 compras al extranjero: importaciones
 LISTS (LISTAS)
Indexación
Una lista es una colección secuenciada de diferentes objetos, como enteros, cadenas y otras listas
también. La dirección de cada elemento dentro de una lista se llama índice. Se usa un índice para
acceder y referirse a elementos dentro de una lista.
Índice Elementos

0 Elemento 1
1 Elemento 2
2 Elemento 3

Para crear una lista, escríbala entre corchetes [ ], con su contenido dentro del paréntesis y separados
por comas.
#Crear una lista
Balanza_de_pagos=[“balanza en cuenta corriente”, ”balanza de capitales”]
Balanza_de_pagos
 ['balanza en cuenta corriente', 'balanza de capitales']

Al igual que con la tuplas podemos imprimir sus elementos llamando a sus índices:

Balanza_de_pagos[0]
 'balanza en cuenta corriente'
Balanza_de_pagos[1]
 'balanza de capitales'
Balanza_de_pagos[-2]
 'balanza en cuenta corriente'
Balanza_de_pagos[-1]
Contenido
 'balanzadedelacapitales'
lista

Las listas pueden contener cadenas, flotadores y enteros. Podemos anidar otras listas, y también
podemos anidar tuplas y otras estructuras de datos. Las mismas convenciones de indexación aplican
para el anidamiento:

#Muestra de lista
Balanza_de_pagos=[(“balanza comercial”, ”balanza de servicios”, ”renta de factores”, “balanza de
transferencias corrientes”), “balanza de capitales”]
Balanza_de_pagos
 [(‘balanza comercial’, ‘balanza de servicios’, ‘renta de factores’, ‘balanza de transferencias
corrientes’), ‘balanza de capitales’]
Operaciones con listas
También podemos usar el método “extend” para agregar nuevos elementos a la lista

#Usar extend para agregar nuevos elementos a la lista

Balanza_en_cuenta_corriente=[(“balanza comercial”, ”balanza de servicios”, ”renta de factores”,
“balanza de transferencias corrientes”)]
Balanza_en_cuenta_corriente.extend([“balanza de capitales”])
Balanza_de_pagos=Balanza_en_cuenta_corriente
Balanza_de_pagos
 [('balanza comercial', 'balanza de servicios', 'renta de factores', 'balanza de transferencias
corrientes'), 'balanza de capitales']

Otro método similar es “append”. Si aplicamos agregar en lugar de “extend”, agregamos solo un
elemento a la lista

#Usa “append” para agregar un elemento a la lista

Balanza_en_cuenta_corriente=[(“balanza comercial”, ”balanza de servicios”, ”renta de factores”,
“balanza de transferencias corrientes”)]
Balanza_en_cuenta_corriente.append([“balanza de capitales”])
Balanza_de_pagos=Balanza_en_cuenta_corriente
Balanza_de_pagos
 [('balanza comercial', 'balanza de servicios', ‘renta de factores’, 'balanza de transferencias
corrientes'), ['balanza de capitales']]

Como podemos ver, si aplicamos el método extend obtenemos elementos libres; a diferencia de
cuando aplicamos el método append y obtenemos elementos como una nueva lista.
Además podemos cambiar las listas ya que son mutables, por ejemplo:

#Cambia el elemento con el índice 1

Balanza_de_pagos = [('balanza comercial', 'balanza de servicios', ‘renta de factores’, 'balanza de
transferencias corrientes'), ['balanza de capitales']]
print( “Antes del cambio:”, Balanza_de_pagos)
Balanza_de_pagos[1] = “BK”
print(“Después del cambio:”, Balanza_de_pagos)
 Antes del cambio: [('balanza comercial', 'balanza de servicios', 'renta de factores', 'balanza de
transferencias corrientes'), ['balanza de capitales']]
Después del cambio: [('balanza comercial', 'balanza de servicios', 'renta de factores', 'balanza
de transferencias corrientes'), 'BK']
Para eliminar un elemento utilizamos el comando “del”
#Eliminar el tercer elmento de la siguiente lista
Macroeconomía= [“inflación”, “tasa de interés”, “isocuanta”, “desempleo”]
del (Macroeconomía[2])
Macroeconomía
 [‘inflación’, ‘tasa de interés’, ‘desempleo’]

Podemos convertir una cadena a una lista usando “split”, este traduce cada grupo de caracteres
separados por un espacio en un elemento en una lista:
# Dividir la cadena, el valor predeterminado es por espacio
PBI=“C I G X M”.split()
PBI
 ['C', 'I', 'G', 'X', 'M']
 SETS (CONJUNTOS)
Contenido de un set
Un set(conjunto) es una colección única de objetos en Python. Puedes denotarlo con un corchete {}.
Python eliminará automáticamente los elementos duplicados:
#Crear un set
Macroeconomía = { “inflación”, “tasa de interés”, “desempleo”, “inflación”, “tipo de cambio”}
Macroeconomía
 { “inflación”, “tasa de interés”, “desempleo”, “tipo de cambio”}

También podemos crear un set de una lista

# Convertir una lista a set

BCC=[“balanza comercial”, ”balanza de servicios”, ”renta de factores”, “balanza de transferencias
corrientes”]
BCC_set=set(BCC)
BCC_set
 {‘balanza comercial’, ‘balanza de servicios’, ‘balanza de transferencias corrientes’, ‘renta de
factores’}

Operaciones con un set

Podemos agregar un elemento a un set usando el método add( )

# Agregar elementos a un set

BCC_set = {‘balanza comercial’, ‘balanza de servicios’, ‘renta de factores’, ‘balanza de transferencias
corrientes’}
BCC_set.add(“balanza de capitales”)
BP = BCC_set
BP
 {'balanza comercial', 'balanza de capitales', 'balanza de servicios', 'balanza de transferencias
corrientes', 'renta de factores'}

Podemos remover un elemento del set usando el método “remove”

BP.remove (“balanza de capitales”)
BCC=BP
BCC
 {'balanza comercial', 'balanza de servicios', 'balanza de transferencias corrientes',
'renta de factores'}
Podemos verificar si un elemento está en el set usando el comando “in”
“balanza comercial” in BCC
 True
“balanza de capitales” in BCC
 False

Operaciones lógicas con los sets

#Considerar las siguientes muestras de sets
BCC = {‘BC', ‘BS’, 'BT', 'RF'}
BP = {‘BC', ‘BS’, 'BT', 'RF', ‘BK’}

Podemos graficarlo de la siguiente manera:

BP

BCC
‘BC' ‘BS’ ‘BK’

'BT' 'RF'

#Encontramos su intersección con “&”

BCC&BP
 {'BC', 'BS', 'BT', 'RF'}
#También podemos hallar su intersección con el comando “.intersection”
BCC.intersection(BP)
 {'BC', 'BS', 'BT', 'RF'}
#Encontramos su unión con el comando “.union”
BCC.union(BP)
 {'BC', 'BK', 'BS', 'BT', 'RF'}
#Encontremos los elementos en el el set BP pero no en el set BCC
BP.difference(BCC)
 {'BK'}
#Encontremos los elementos en el el set BCC pero no en el set BP
BCC.difference(BP)
 set()

Como vemos en el gráfico de los sets no hay ningún elemento que pertenezca a BCC pero no a BP,
por lo que su diferencia es un conjunto vacío “ set() “

#Revisemos si el set BCC está incluido en el set BP

BCC.issubset(BP)
 True
#Revisemos si el set BP incluye al set BCC
BP.issuperset(BCC)
 True
#Revisemos si el set BCC incluye al set {“BC”}
BCC.issuperset({"BC"})
 True
 DICTIONARY (DICCIONARIO)
Un diccionario consta de claves y valores. Es útil comparar un diccionario con una lista. En lugar de los
índices numéricos, como una lista, los diccionarios tienen claves (keys). Estas claves son las claves
que se utilizan para acceder a los valores (values) dentro de un diccionario.

Key 1 Value 1
Key 2 Value 2
Key 3 Value 3
... ...
Como una lista, un diccionario contiene una secuencia de elementos separados por comas. Cada
elemento está representado por una clave y su valor correspondiente. Los diccionarios se crean con
dos llaves que contienen claves y valores separados por dos puntos. Para cada clave, solo puede
haber un único valor, sin embargo, varias claves pueden tener el mismo valor. Las claves solo pueden
ser cadenas, números o tuplas, pero los valores pueden ser cualquier tipo de datos. Un diccionario
vacío sin elementos se escribe con solo dos llaves, como este "{}".

#Muestra de diccionario con las variables del PBI y su porcentaje respecto al PBI del Perú 2018
PBI = {“C”:64.7, “I”:17, “G”:16.3, “X”:25,”M”:23}
PBI
 {'C': 64.7, 'I': 17, 'G': 16.3, 'X': 25, 'M': 23}

Es útil visualizar el diccionario como una tabla, como en la siguiente tabla. La primera columna
representa las claves, la segunda columna representa los valores.

KEY VALUE
“C” 64.7
“I” 17
“G” 16.3
“X” 25
“M” 23

A continuación presentamos los comandos aplicables a los diccionarios y su función:

# Hallar el valor de la primera clave
PBI[“C”]
 64.7
# Para obtener todas las claves del diccionario usando el método “.keys()”
PBI.keys()
 dict_keys(['C', 'I', 'G', 'X', 'M'])
# Para obtener todas los valores del diccionario usando el método “.values()”
PBI.values()
 dict_values([64.7, 17, 16.3, 25, 23])
# Agregar una nueva clave y su valor en el diccionario
PBI[“Total”]=100
PBI
 {'C': 64.7, 'I': 17, 'G': 16.3, 'X': 25, 'M': 23, 'Total': 100}
# Eliminamos la clave y su valor del diccionario con el comando “del”
del(PBI[“Total”])
PBI
 {'C': 64.7, 'I': 17, 'G': 16.3, 'X': 25, 'M': 23}
#Verificamos si una clave está en el diccionario con el comando “in”
“G” in PBI
 True
 DECLARACIONES DE CONDICIÓN
Operadores de comparación
Las operaciones de comparación comparan algún valor u operando y, en función de una condición,
producen un valor booleano (True or False). Al comparar dos valores puedes usar estos operadores:

Igual ==
No es igual !=
Mayor que >
Menor que <
Mayor o igual que >=
Menor o igual que <=

Asignemos a “a” un valor de 5. Use el operador de igualdad indicado con dos signos == iguales para
determinar si dos valores son iguales. El siguiente caso compara la variable “a” con 6.
#Condición igual
a=5
a==6
 False

El resultado es Falso porque 5 no es igual a 6

Considere el siguiente operador de comparación de igualdad i> 5. Si el valor del operando izquierdo,
en este caso la variable i, es mayor que el valor del operando derecho, en este caso 5, entonces la
declaración es True. De lo contrario, la afirmación es False. Si i es igual a 6, porque 6 es mayor que 5,
la salida es True.
#Signo mayor que
i=6
i>5
 True
i=2
i>5
 False

La prueba de desigualdad usa un signo de exclamación que precede al signo de igualdad, si dos
operandos no son iguales, entonces la condición se vuelve verdadera. Por ejemplo, la siguiente
condición producirá True siempre que el valor de i no sea igual a 6:

#Signo de desigualdad
i=2
i!=6
 True
También podemos usar estos operadores con cadenas
Ramificación
La ramificación nos permite ejecutar diferentes declaraciones para diferentes entradas. Es útil pensar
en la declaración “if” como una habitación cerrada, si la declaración es verdadera podemos ingresar a
la sala y su programa ejecutará algunas tareas predefinidas, pero si la declaración es Falsa, el
programa ignorará la tarea. Utilice las declaraciones de condición aprendidas anteriormente, ya que las
condiciones deben verificarse en la instrucción if. La sintaxis es tan simple como una declaración de
condición:, que contiene una palabra if, cualquier declaración de condición y dos puntos al final.
Comience sus tareas que deben ejecutarse bajo esta condición en una nueva línea con una sangría.
Las líneas de código después de los dos puntos y con una sangría solo se ejecutarán cuando la
sentencia if sea verdadera. Las tareas terminarán cuando la línea de código no contenga la sangría.

#Ejemplo de la declaración "if"

inflación=2.5
#Declaración que se ejecutará independientemente de si la condición es verdadera o falsa
print("tipo de inflación:")
#Expresión que puede ser verdadera o falsa
Esif inflación<10:
útil usar el siguiente diagrama para ilustrar el proceso. En el lado izquierdo, vemos lo que sucede
cuando la condición es verdadera. La persona ingresa al concierto de ACDC que representa el código
en la#Dentro
sangríade la sangría,
que tenemos la expresión
se está ejecutando; que
luego sigue se ejecuta
adelante En si
el la condición
lado esvemos
derecho, verdadera
lo que sucede
cuando la condición es falsa; no se le otorga acceso a la persona, y la persona sigue adelante. En este
print("moderada")
caso, el segmento de código en la sangría no se ejecuta, pero el resto de las sentencias se ejecutan.
if 10<=inflación<35:
print("ordinaria")
La instrucción else ejecuta un bloque de código si ninguna de las condiciones es Verdadera antes de
esta instrucción else. Usemos la analogía del concierto de ACDC nuevamente. Si el usuario tiene 17
if 35<=inflación<1000:
años, no puede ir al concierto de ACDC, pero puede ir al concierto de Meatloaf. La sintaxis de la
print("galopante")
sentencia else es similar a la sintaxis de la sentencia if, como else:. Tenga en cuenta que, no hay
ninguna declaración: de condición para otra cosa. Intenta cambiar los valores de la edad para ver qué
if 1000<=inflación
pasa:
print("hiperinflación")
 tipo de inflación:
moderada
La declaración “else” ejecuta un bloque de código si ninguna de las condiciones es Verdadera antes de
esta declaración else. La sintaxis de la declaración else es similar a la sintaxis de la declaración
if(else:) Tenga en cuenta que, no hay ninguna declaración de condición para else.

#Ejemplo de declaración else

inflación=2.5
if 1<inflación<3:
print("dentro de la banda de inflación")
else :
print("fuera de la banda de inflación")
 dentro de la banda de inflación

Operadores lógicos
A veces desea verificar más de una condición a la vez. Por ejemplo, es posible que desee verificar si
una condición y otra condición son verdaderas. Los operadores lógicos le permiten combinar o
modificar condiciones.

 y (and)
 o (or)
 no (!)
Estos operadores se resumen para dos variables usando las siguientes tablas de verdad:

A B A&B A B A or B
False False False False False False
False True False False True True
True False False True False True
True True True True True True

A A!
False True
True False

La declaración "y" solo es verdadera cuando ambas condiciones son verdaderas. La declaración "o" es
verdadera si una condición es verdadera. La declaración "no" produce el valor de verdad opuesto.

# Ejemplo de uso del operador "and"

inflación = 5
if(inflación > 1) and (inflación < 3):
print ("dentro de la banda de inflación")
else:
print("fuera de la banda de inflación")
 fuera de la banda de inflación
# Ejemplo de uso del operador "or"
album_year = 1990
if(album_year < 1980) or (album_year > 1989):
print ("Album was not made in the 1980's")
else:
print("The Album was made in the 1980's ")
 Album was not made in the 1980's

# Ejemplo de uso del operador "not"

album_year = 1983
if not (album_year == '1984'):
print ("Album year is not 1984")
 Album year is not 1984
 FUNCIONES
¿Qué es una función?
Una función es un bloque de código reutilizable que realiza las operaciones especificadas en la
función. Le permiten desglosar tareas y reutilizar su código en diferentes programas.
Hay dos tipos de funciones:
- Funciones predefinidas
- Funciones definidas por el usuario
Puede definir funciones para proporcionar la funcionalidad requerida. Aquí hay reglas simples para
definir una función en Python:

 Los bloques de funciones comienzan “def” seguidos del nombre de la función y los paréntesis
().
 Hay parámetros de entrada o argumentos que se deben colocar dentro de estos paréntesis.
 También puede definir parámetros dentro de estos paréntesis.
 Hay un cuerpo dentro de cada función que comienza con dos puntos (:) y tiene sangría.
 También puede colocar la documentación delante del cuerpo.
 La declaración de retorno sale de una función, opcionalmente devolviendo un valor
Un ejemplo de una función que multiplica los parámetros “a” y”b”

# Definir una función para multiplicar dos números

def Mult(a,b):
c=a*b
return(c)
Mult (2,3)
6

Funciones pre definidas

print() Imprime los elementos de una lista o un enunciado que se le indique

sum() Devuelve la suma de los elementos en una lista o tupla

len() Muestra la longitud de una lista o tupla

return() Útil cuando tienes alguna declaración “if” en la función y quieres que su salida
dependa de alguna condición
type() Averiguar el tipo de un objeto
 PANDAS
Las dependencias o bibliotecas son códigos escritos previamente para ayudar a resolver problemas.
En este caso presentaremos pandas, una biblioteca popular para el análisis de datos.
Podemos importar la biblioteca o una dependencia como pandas usando el siguiente comando y para
simplificarnos la tarea la denominaremos pd

# Podemos importar la biblioteca o una dependencia como pandas usando el siguiente comando.
import pandas as pd
Ahora tenemos acceso a un gran número de clases y funciones pre-construidas como read_csv(),
Series(), DataFrame, values, etc. Esto supone que la biblioteca está instalada. En nuestro entorno de
laboratorio, todas las bibliotecas necesarias están instalados.
Ahora digamos que nos gustaría cargar un archivo Excel utilizando la función pd.read_excel
# Importamos la biblioteca pandas
import pandas as pd
# Cargamos un archivo Excel almacenado en el equipo. La variable arch_exc1 almacena la ruta del
archivo
arch_exc1="PBI POR SECTORES.xlsx"
# Ahora almacenaremos los datos con el nombre df como la abreviatura de dataframe (marco de
datos)
df=pd.read_excel(arch_exc1)
# El comando head nos devolverá las primeras 5 filas del marco de datos. Aunque también
podemos incluir un número en los paréntesis para indicar el número de filas que queremos mostrar.
df.head()
 Año Agropecuario Pesca ... Comercio Servicios PBI
0 2014 25027.696036 1762.067826 ... 52192.745952 227646.948870 467376.448798
1 2015 25893.986531 2041.675707 ... 54216.598319 236957.188935 482676.378219
2 2016 26583.878106 1835.705442 ... 55198.885012 246497.737959 502190.580507
3 2017 27277.218087 1921.352686 ... 55767.047957 254635.062453 514618.214873
4 2018 29335.385955 2684.715322 ... 57243.356379 265843.265334 535171.357857
[5 rows x 10 columns]
df.head(1)
 Año Agropecuario Pesca ... Comercio Servicios PBI
0 2014 25027.696036 1762.067826 ... 52192.745952 227646.94887 467376.448798
[1 rows x 10 columns]
Marco de datos con diccionarios
Un marco de datos se compone de filas y columnas. Podemos crear un marco de datos a partir de un
diccionario. Las claves (keys) corresponden a las etiquetas de columna. Los valores (values) son listas
correspondientes a las filas. Luego, el diccionario se convierte en un marco de datos utilizando la
función DataFrame.

# Creamos un diccionario
PBI_SECTORES={"Año":[2016,2017,2018], "Sectores primarios":[111864,115290,119058],
"Sectores no primarios":[390327,399328,416113],"PBI":[502191,514618,535171]}
# Convertimos el diccionario a un marco de datos con la función DataFrame
PBI_SECTORES_df=pd.DataFrame(PBI_SECTORES)
PBI_SECTORES_df
 Año Sectores primarios Sectores no primarios PBI
0 2016 111864 390327 502191
1 2017 115290 399328 514618
2 2018 119058 416113 535171
# Podemos crear un nuevo marco de datos que consta de una columna. Esxribimos el nombre del
marco de datos y el nombre del encabezado de columna incluida en dobles corchetes. El resultado
es un nuevo marco de datos compuesto por la columna indicada.
x=PBI_SECTORES_df[["PBI"]]
x
 PBI
0 502191
1 514618
2 535171
# Podemos hacer lo mismo para varias columnas. El resultado es un nuevo marco de datos
compuesto por las columnas especificadas.
y=PBI_SECTORES_df[["Sectores primarios","Sectores no primarios"]]
y
 Sectores primarios Sectores no primarios
0 111864 390327
1 115290 399328
2 119058 416113
# Para acceder a los elementos utilizamos el método iloc. Puedes acceder a la 2° fila y 1° columna de
la siguiente manera:
print("El PBI real peruano de los sectores primarios en el año 2018 fue:",
PBI_SECTORES_df.iloc[2,1], "millones de soles" )
 El PBI real peruano de los sectores primarios en el año 2018 fue: 119058 millones de soles
# Otra forma de acceder a los elementos es mencionar el número de la fila y el nombre de la columna.
Pero esta avez utilizaremos el método loc
print("En el año 2016 PBI real del Perú ascendió a:", PBI_SECTORES_df.loc[0,"PBI"],"millones de
soles")
 En el año 2016 PBI real del Perú ascendió a: 502191 millones de soles
# También puede dividir los marcos de datos y asignar los valores a un nuevo marco de datos.
Asignamos las dos últimas filas y las tres primeras columnas a la variable z. El resultado es un marco
de datos compuesto por las filas y columnas seleccionadas.
Sect_2años=PBI_SECTORES_df.iloc[1:3,0:3]
Sect_2años
 Año Sectores primarios Sectores no primarios
1 2017 115290 399328
2 2018 119058 416113
# También puede dividir los marcos de datos y asignar los valores a un nuevo marco de datos
utilizando los nombres de la columna. El código asigna las últimas 2 filas y las tres primeras columnas
desde “Año” hasta “Sectores no primarios”. El resultado es un nuevo marco de datos con los valores
correspondientes.
Sect_2prim_años=PBI_SECTORES_df.loc[1:3,"Año":"Sectores no primarios"]
Sect_2prim_años
 Año Sectores primarios Sectores no primarios
1 2017 115290 399328
2 2018 119058 416113
 INTRODUCCIÓN A CLASES Y OBJETOS
Creando una clase
La primera parte de crear una clase es darle un nombre: Aquí, crearemos un círculo. Necesitamos
determinar todos los datos que conforman esa clase, y llamamos a eso un atributo. Considere este
paso como crear una impresión azul que usaremos para crear objetos. En la figura adjunta vemos el
círculo (la clase) que tiene el radio y el color como atributo. Usemos los ejemplos visuales de esta
forma antes de que lleguemos al código, ya que esto te ayudará a acostumbrarte al vocabulario.

Class Circle
Atributos: radio, color
Color
radio

Instancias de una clase: objetos y atributos

Una instancia de un objeto es la realización de una clase, y en la figura siguiente vemos dos instancias
del círculo de la clase. Le asignamos un nombre a cada objeto: círculo rojo y círculo amarillo. Cada
objeto tiene atributos diferentes, por lo tanto, concentrémonos en el atributo de color para cada objeto.
El atributo de color para el círculo rojo es el color rojo y para el círculo amarillo el atributo de color es
amarillo

Círculo amarillo
Círculo rojo

Métodos
Los métodos te dan una manera de cambiar o interactuar con el objeto; Son funciones que interactúan
con los objetos. Por ejemplo, digamos que nos gustaría aumentar el radio en una cantidad específica
de un círculo. Podemos crear un método llamado add_radio (r) que aumenta el radio en r. Esto se
muestra en la siguiente figura, donde después de aplicar el método al "objeto de círculo naranja", el
radio del objeto aumenta en consecuencia. La notación de "punto" significa aplicar el método al objeto,
que esencialmente es aplicar una función a la información en el objeto.

2 4
.add_radio(2)

Creando una clase

Primero debemos importar una biblioteca para dibujar los objetos:

# Importar la biblioteca
import matplotlib.pyplot as plt
El primer paso para crear su propia clase es usar la palabra clave “class”, luego el nombre de la clase
“círculo” . En este curso, el padre de la clase siempre será “object”.
El siguiente paso es un método especial llamado constructor __init__, que se utiliza para inicializar el
objeto. Las entradas son atributos de datos. El término self contiene todos los atributos del conjunto.
Por ejemplo, self.color da el valor del color de atributo y self.radius le dará el radio del objeto. También
tenemos el método add_radius () con el parámetro r, el método agrega el valor de r al radio del
atributo. Para acceder al radio usamos la sintaxis self.radius.

# Crear una clase: Circle

class Circle(object):
# Constructor
def __init__(self, radius=3, color='blue'):
self.radius = radius
self.color = color
# Método
def add_radius(self, r):
self.radius = self.radius + r
return(self.radius)
# Método
def drawCircle(self):
plt.gca().add_patch(plt.Circle((0, 0), radius=self.radius, fc=self.color))
plt.axis('scaled')
plt.show()
Vamos a crear el objeto RedCircle de tipo Circle:

# Crear el objeto RedCircle

RedCircle = Circle(10, "red")
# Descubre los métodos que se pueden utilizar en el objeto RedCircle. Muchos de ellos son métodos
predeterminados de Python..
dir (RedCircle)
 ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
'__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__',
'__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__',
'__subclasshook__', '__weakref__', 'add_radius', 'color', 'drawCircle', 'radius']
# Imprimir el atributo del objeto: radio
RedCircle.radius
 10
# Imprimir el atributo del objeto: color
RedCircle.color
 ‘red’
# Cambiar los atributos del objeto
RedCircle.radius=1
RedCircle.radius
1
# Dibujar el objeto usando el método drawCircle()
RedCircle.drawCircle()

# Podemos incrementar el radio del círculo aplicando el método add_radius
RedCircle.add_radius(2)
3
# Vamos a crear un círculo azul. Como el color predeterminado es azul, todo lo que tenemos que
hacer es especificar cuál es el radio:
BlueCircle=Circle(radius=100)
BlueCircle.drawCircle()

 1D NUMPY EN PYTHON
¿Qué es numpy?
El arreglo numpy es similar a una lista. Normalmente es de tamaño fijo y cada elemento es del mismo
tipo. Podemos convertir una lista a una matriz numpy importando primero numpy:

# Importar la biblioteca numpy

import numpy as np
# A continuación, emitimos la lista de la siguiente manera:
a=np.array([2,4,5,1])
a
 array([2, 4, 5, 1])
# Imprimir sus elementos
print(“a[0]:”, a[0])
a[0]: 2
# Revisar el tipo de arreglo
type(a)
 <class 'numpy.ndarray'>
# Como los arreglos numpy contienen datos del mismo tipo, podemos usar el atributo "dtype" para
obtener el tipo de datos de los elementos del arreglo. En este caso un entero de 32 bits:
a.dtype
 dtype('int32')
# Podemos cambiar el valor de un elemento
a[0]=3
a
 array([3, 4, 5, 1])
Otros atributos
Revisemos algunos atributos básicos de array usando el arreglo a:

# El atributo size es el número de elementos del arreglo

a.size
4
# Los siguientes dos atributos tendrán más sentido cuando lleguemos a dimensiones más altas,
pero revisémoslos. El atributo ndim representa el número de dimensiones del arreglo o el rango del
arreglo, en este caso, uno:
a.ndim
1
# El atributo shape es una tupla de enteros que indica el tamaño del arreglo en cada dimensión:
a.shape
(4,)
# Con el atributo mean obtenemos la media de los elementos del arreglo
a.mean()
 3.25
# Con el atributo std obtenemos la desviación estándar del arreglo
a.std()
 1.479019945774904
# Para conseguir el máximo y mínimo valor utilizamos el atributo max() y min() respectivamente
a.max()
5
a.min()
1
Operaciones con Numpy Array
Adición
Considera las matrices numpy u y v

# Considera las matrices numpy u y v

u=np.array([1,0])
u
 array([1,0])
v=np.array([0,1])
v
 array([0,1])
# Ahora procederemos a sumarlas y asignar el nombre z
z=u+v
z
 array([1,1])
# Para graficar los vectores tenemos que importar algunas bibliotecas y definir una función
import time
import sys
import numpy as np
import matplotlib.pyplot as plt
def Plotvec1(u, z, v):
ax = plt.axes()
ax.arrow(0, 0, *u, head_width=0.05, color='r', head_length=0.1)
plt.text(*(u + 0.1), 'u')

ax.arrow(0, 0, *v, head_width=0.05, color='b', head_length=0.1)

plt.text(*(v + 0.1), 'v')
ax.arrow(0, 0, *z, head_width=0.05, head_length=0.1)
plt.text(*(z + 0.1), 'z')
plt.ylim(-2, 2)
plt.xlim(-2, 2)
 # Aplicamos la función Plotvec1 definida anteriormente
Plotvec1(u, z, v)
# Para mostrar la imagen utilizamos el comando plt.show()
plt.show()


Multiplicación

# Considera el vector numpy array y:

y=np.array([2,3,4])
y
 array([2, 3, 4])
# Podemos multiplicar cada elemento por 2
z=2*y
z
 array([4, 6, 8])
Producto de dos Numpy Arrays
# Considere los siguientes arreglos m y n:
m=np.array([1,2,3])
n=np.array([3,2,4])
# Calculamos el producto de los arreglos m y n
p=m*n
p
 array([ 3, 4, 12])

Producto dot
El producto dot de las dos matrices numpy m y n viene dado por la suma de los elementos de su
producto

np.dot(m,n)

 19

Agregando constante a una matriz de numpy

# Considere el siguiente arreglo:
u=np.array([-1,0,3,-2])
u+1
# Agregamos una constante al arreglo
array([ 0, 1, 4, -1])

Funciones matemáticas
# En Python el valor de pi está dado por:
np.pi
 3.141592653589793
# Crea el siguiente numpy array en radianes
x = np.array([0, np.pi/2 , np.pi])
# Calcula el seno de cada elemento.
y=np.sin(x)
y
 array([0.0000000e+00, 1.0000000e+00, 1.2246468e-16])
Linspace
Una función útil para trazar funciones matemáticas es el "espacio de líneas". El espacio de líneas
devuelve números espaciados uniformemente en un intervalo específico. Especificamos el punto inicial
de la secuencia y el punto final de la secuencia. El parámetro "num" indica el número de muestras a
generar, en este caso 5:

# Limitemos el numpy array con [-2,2] y demos un rango de 5 elementos

np.linspace(-2,2,num=5)
 array([-2., -1., 0., 1., 2.])
# Si cambiamos el parámetro num a 9, obtenemos 9 números espaciados uniformemente en el
intervalo de -2 a 2:
np.linspace(-2,2,num=9)
 array([-2. , -1.5, -1. , -0.5, 0. , 0.5, 1. , 1.5, 2. ])

Podemos usar el espacio de línea de función para generar 100 muestras espaciadas uniformemente
del intervalo 0 a 2π:

# Creamos un numpy array dentro de [0, 2π] y con 100 elementos

x = np.linspace(0, 2*np.pi, num=100)
# Calculamos el seno de x
y=np.sin(x)
# Graficamos el resultado
plt.plot(x,y)
 [<matplotlib.lines.Line2D object at 0x07685D70>]
plt.show()

 2D NUMPY EN PYTHON
Podemos crear matrices numpy con más de una dimensión, esta sección se centrará solo en numpy
array 2D, pero puede usar numpy para crear arreglos de dimensiones superiores.

# Importar la biblioteca numpy

import numpy as np
# A continuación, convertimos una lista a Numpy Array
a=np.array([[1,2,3],[4,5,6],[7,8,9]])
a
 array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
# Imprimir sus elementos teniendo en cuenta que el primer número representa el número de filas,
mientras el segundo, de columnas. La numeración empieza en 0
print(“a[1,2]:”, a[1,2])
 a[1,2]: 6
# Otra forma de acceder a los elementos es la siguiente:
a[2][0]
7
a[0:2,1]
 array([2, 5])
# Revisar el tipo de arreglo
type(a)
 <class 'numpy.ndarray'>
# Como los arreglos numpy contienen datos del mismo tipo, podemos usar el atributo "dtype" para
Otros atributos
Revisemos algunos atributos básicos de array usando el arreglo a:

# El atributo size es el número de elementos del arreglo

a.size
9
# El atributo ndim representa el número de dimensiones o ejes del arreglo, en este caso, dos:
a.ndim
2
# El atributo shape devuelve una tupla correspondiente al tamaño o número de cada dimensión.
a.shape
(3, 3)
# Para conseguir el máximo y mínimo valor utilizamos el atributo max() y min() respectivamente
a.max()
9
a.min()
1
# Si queremos crear la matriz identidad podemos utilizar el siguiente comando, el número indicará
su número de filas y columnas
# Matriz identidad de 2x2
I = np.eye(2)
I
 array([[1., 0.],
[0., 1.]])
# Matriz identidad 3x3
I = np.eye(3)
I
 array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
Operaciones básicas
Adición
También podemos añadir arrays. El proceso es idéntico a la adición de matrices.

# Considera las matrices numpy X y Y

X=np.array([[1,0], [0,1]])
X
 array([[1, 0],
[0, 1]])
Y =np.array([[2,1],[1,2]])
Y
 array([[2, 1],
[1, 2]])
# Ahora procederemos a sumarlas y asignar el nombre Z
Z=X+Y
Z
 array([[3, 1],
[1, 3]])

Multiplicación de un Numpy Array por un escalar

El proceso es idéntico a multiplicar una matriz por un escalar. Si multiplicamos la matriz Y por el
escalar 4, simplemente multiplicamos cada elemento de la matriz por 4.

# Considera el numpy array Z hallado anteriormente

Z
# Podemos multiplicar cada elemento por 4
4*Z
 array([[12, 4],
[ 4, 12]])
Producto de dos Numpy Arrays
La multiplicación de dos arrays corresponde a un producto de elementos o un producto de Hadamard.
Considere las matrices X e Y. El producto de Hadamard corresponde a multiplicar cada uno de los
elementos en la misma posición. El resultado es una nueva matriz que es del mismo tamaño que la
matriz Y o X, como se muestra en la siguiente figura.

# Considere los siguientes arreglos m y n:

m=np.array([[3, 2], [0, 4]])
n=np.array([[0, 1], [5, 2]])
# Calculamos el producto de los numpy array m y n
p=m*n
p
 array([[0, 2],
[0, 8]])

Producto dot
También podemos realizar la multiplicación de matrices con los arrays numpy A y B de la siguiente
manera. Teniendo en cuenta que el número de columnas del primer factor debe ser igual al número de
filas del segundo factor.

# Creamos las matrices A y B

A = np.array([[0, 1, 1], [1, 0, 1]])
B = np.array([[1, 1], [1, 1], [-1, 1]])
# Calculamos el producto dot
np.dot(A,B)
 array([[0, 2],
[0, 2]])

Agregando constante a una matriz de numpy

# Considere el siguiente arreglo:
A = np.array([[0, -1, 1], [1, 0, -5]])
# Agregamos una constante a la matriz
A+5
 array([[5, 4, 6],
[6, 5, 0]]
Funciones matemáticas
# Considerar la siguiente matriz
M = np.array([[1,0,3], [2,5,6],[-1,7,9]])
M
 array([[ 1, 0, 3],
[ 2, 5, 6],
[-1, 7, 9]])
# Hallar su transpuesta
M.T
 array([[ 1, 2, -1],
[ 0, 5, 7],
[ 3, 6, 9]])
# Hallar su determinante
np.linalg.det(M)
 60.000000000000036
# Hallar su inversa
A_inv=np.linalg.inv(M)
A_inv
 array([[ 0.05 , 0.35 , -0.25 ],
[-0.4 , 0.2 , 0. ],
[ 0.31666667, -0.11666667, 0.08333333]])
Ejemplo práctico
A continuación se describe la interacción entre tres sectores de una economía. Hallar la matriz de
coeficientes técnicos de producción. Si a 10 años, las demandas finales cambian a 150, 280 y 420 y
para las industrias I, II y III respectivamente. ¿Cuánto deberá producir cada sector con objeto de
satisfacer las demandas proyectadas?

DEMANDA
INDUSTRIA VBP
INDUSTRIA S FINALES
I II III
I 20 40 30 10 100
II 30 20 90 60 200
III 40 100 60 100 300
VALOR
10 40 120 170
AGREGADO
VBP 100 200 300

# Primero debemos importas las siguientes bibliotecas

import numpy as np
import matplotlib.pyplot as plt
# Considere la siguiente lista, que contiene tres listas anidadas, cada una de igual tamaño. Luego la
convertimos a una Numpy Array como sigue
A=np.array([[20., 40., 30.], [30., 20., 90.], [40., 100., 60.]])
A
 array([[ 20, 40. , 30. ],
[ 30, 20. , 90. ],
[ 40, 100. , 60. ]])
# Hallamos la Matriz de Coeficientes Técnicos de Producción dividiendo
A[0:3,0]=1/100*A[0:3,0]
A[0:3,1]=1/200*A[0:3,1]
A[0:3,2]=1/300*A[0:3,2]
A
 array([[0.2, 0.2, 0.1],
[0.3, 0.1, 0.3],
[0.4, 0.5, 0.2]])
# Renombramos la matriz A como MCTP
MCTP=A
Para hallar la matriz de producción futura tenemos la siguiente fórmula:

X =(I −MCTP)−1 D
Donde:
X=Matriz de producción futura I = Matriz identidad D= Matriz de demanda proyectada

# En Python la matriz identidad es

I=np.eye(3)
I
 array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
# La inversa de una matriz se obtiene con el comando np.linalg.inv() y para multiplicar matrices
usamos el comando np.dot( , )
D=np.array([150,280,420])
X=np.dot(np.linalg.inv(I-MCTP),D)
X
 array([ 622.52252252, 1007.20720721, 1465.76576577])

Es decir:
La producción bruta de la industria I será 622.52
La producción bruta de la industria II será 1007.21
La producción bruta de la industria III será 1465.77

Ahora crearemos una nueva matriz

MCTP[0:3,0]=X[0]*MCTP[0:3,0]
MCTP[0:3,1]=X[1]*MCTP[0:3,1]
MCTP[0:3,2]=X[2]*MCTP[0:3,2]
MCTP
 array([[124.5045045 , 201.44144144, 146.57657658],
[186.75675676, 100.72072072, 439.72972973],
 DEMANDAS
INDUSTRIA VBP
INDUSTRIA FINALES
I II III
I 125 201 147 150 623

II 187 101 440 280 1007

III 249 504 293 420 1466

VALOR 62 201 586 850

AGREGADO
VBP 623 1007 1466