*******************************************************************************

Dataframe

Una de las mejores opciones para trabajar con datos tabulares en Python es usar la
Python Data Analysis Library (alias Pandas).

La biblioteca Pandas provee estructuras de datos, genera gráficos de alta calidad

con matplotlib y se integra de buena forma con otras bibliotecas que usan arrays de
NumPy (la cual es otra biblioteca de Python).

Que es un dataframe

Un DataFrame es una estructura de datos con dos dimensiones en la cual se puede

guardar datos de distintos tipos (como caractéres, enteros, valores de punto
flotante, factores y más) en columnas.

Es similar a una hoja de cálculo o una tabla de SQL o el data.frame de R. Un

DataFrame siempre tiene un índice (con inicio en 0). El índice refiere a la
posición de un elemento en la estructura de datos.

# Observemos los datos

df = pd.read_csv('data.csv', index_col=0)
print(df)

# Los parametros que recibe son

# data, el conjunto de datos
# index, la lista que serán los encabezados
# Para organizar los datos correctamente podemos utilizar el método .T para
transponer los datos
df = pd.DataFrame(data=data, index=columns).T

# Con esto obtenemos la estructura deseada

print(df)

# usando la expresión .to_csv exportamos los datos de nuestro dataframe hacia csv
# como definimos la ruta, se exportan directamente a la ruta del archivo python en
que se ejecuta el código
df.to_csv('data0316.csv')

# Para leer los datos ya exportados podemos usar el método read

# Indicamos que la columna 0, la primera, es nuestro indice
# Si no indicamos una columna
df_leido = pd.read_csv('data.csv', index_col=0)

# Leer surveys.csv
ruta_archivo = input("[1] Indique la ruta del archivo a importar: ")

# Si queremos leer una ruta fija, debemos colocar los dos \\ para escapar el
caracter \
ruta_archivo

# recordemos que para nuestro caso los datos tienen una columna indice
df_desde_ruta = pd.read_csv(ruta_archivo, index_col=0)

df_desde_ruta

# si no lo colocamos se crea una nueva columna autonumerica como indice

df_desde_ruta = pd.read_csv(ruta_archivo)

df_desde_ruta

# recordemos que para nuestro caso los datos tienen una columna indice
# leemos el archivo surveys.csv
df_desde_ruta = pd.read_csv(ruta_archivo, index_col=0)

df_desde_ruta

# Si usamos el método type podemos ver que que nuestro df es de tipo pandas
dataframe
type(df_desde_ruta)

# Podemos usar diversos métodos para explorar nuestros datos

# .head() devuelve los primeros 5 registros
df_desde_ruta.head()

# .head() devuelve los primeros 5 registros; podemos especificar cuantos queremos

ver
df_desde_ruta.head(20)

# .dtypes nos permite obtener el tipo de dato de cada columna

df_desde_ruta.dtypes

# .columns nos permite obtener el nombre de las columnas

df_desde_ruta.columns

# .shape nos devuelve la forma del dataframe en filas por columnas

df_desde_ruta.shape

# .tail nos devuelve los ultimos 5 datos; dentro de los paretensis podemos indicar
la cantidad de datos que
# queremos
df_desde_ruta.tail(10)

# podemos usar el método describe para obtener información sobre cada columna
df_desde_ruta.describe()

# Si queremos obetener información sobre una sola columna, podemos llamar a una
columna en particular
# usando slicing
df_desde_ruta['weight'].describe()

# También podemos llamar estadísticas particulares

# .min(), nos devuelve el mínimo de la columna
df_desde_ruta['weight'].min()

# .min(), nos devuelve el máximo de la columna

df_desde_ruta['weight'].max()

# .mean(), nos devuelve el promedio o media de la columna

df_desde_ruta['weight'].mean()

# .std(), nos devuelve la desviación estandar de la columna

df_desde_ruta['weight'].std()

# .count(), nos devuelve la cantiaad de datos de la columna

df_desde_ruta['weight'].count()
# Analicemos estos datos, que devuelve cada uno
# Devuelve el total de datos unicos de la columna indicada del df
print(df_desde_ruta['year'].nunique())
# Devuelve una lista cuyos elementos son los datos unicos del campo indicado del df
print(df_desde_ruta['year'].unique())
# Devuelve la cantidad de registros de la columna indicada del df
print(df_desde_ruta['year'].count())

# .info(), nos indica

# cantidad de registros no nulos
# y tipo de datos de cada columna
df_desde_ruta.info()

Agrupando datos - Nivel 1

Podemos generar una agrupación de datos por un campo en especial, como por ejemplo
el campo sex

# Generamos un nuevo df, que va a agrupar por cada una de las valores de
# esta columna
# Para nuestro caso, sex sólo tiene 2 valores, F y M
datos_agrupados = df_desde_ruta.groupby('sex')

# No se devuelven datos, debemos realizar una operación de agrupación para obtener

los datos necesarios
print(datos_agrupados)

# Apliquemos la función media a cada columna

datos_agrupados.mean()

# Ejercicios
# Como podriamos obtener la cantidad de individuos de cada sexo
datos_agrupados['month'].count()

# Como realizariamos la agrupación por 2 campos, como plot_id y sex, generando el

conteo
datos_agrupados2 = df_desde_ruta.groupby(['sex','plot_id'])
datos_agrupados2.count()

Obteniendo datos resumen directamente¶

Por ejemplo, si quisieramos obtener los datos del número de muestras de cada
especie, podemos usar combinar el agrupado con el conteo de la siguiente manera

df_desde_ruta

# Primero agrupamos por el campo species_id, luego solo por el campo day, hacemos
un conteo de los registros
conteo_especies = df_desde_ruta.groupby('species_id')['day'].count()
print(conteo_especies)
type(conteo_especies)

# También pudiesemos obtener el conteo de las especie DO

df_desde_ruta.groupby('species_id')['day'].count()['DO']

# Como obtendriamos los datos de más de una especie, por ejemplo D0, UR y UP
df_desde_ruta.groupby('species_id')['day'].count().tail()
Leyendo datos desde Excel

De manera similar que se leen los datos de csv, se pueden leer datos desde excel

# Para leer desde Excel, usamos la instrucción de pandas read_excel()

# Esta recibe diversos parametros, entre ellos
# la ruta del archivo
# el nombre de la hoja
# si tiene una columna de indice o no
df_ventas = pd.read_excel(r'ruta del archivo
Datos.xlsx',sheet_name='Ventas',index_col=0)

df_ventas

# también se pueden leer los datos por los indices de cada hoja
df_productos = pd.read_excel('Datos.xlsx',sheet_name=1,index_col=0)

df_productos

# Ejercicio
# Leer las otras 2 hojas
df_vendedores = pd.read_excel('Datos.xlsx',sheet_name=2,index_col=0)
df_vendedores

df_ciudad = pd.read_excel('Datos.xlsx',sheet_name=3,index_col=0)
df_ciudad

Merge

Cuando trabajamos con dataframes, algunas veces necesitamos cruzar información de

unos con otros.

Para esto podemos usar el método merge para unir los dos dataframes

# Parametros del método merge

# inicia con pd.merge
# el primer parametros es uno de los dataframes a unir
# el segundo parametros es el otro dataframe a unir
# el tercer parametros es el tipo de unión
# el cuarto parametro, left_on, indica los campos por lo que se cruzará del primer
dataframe
# (si son varios se listan en el orden a cruzar separados por comas)
# el cuarto parametro, right_on, indica los campos por lo que se cruzará del
segundo dataframe
# (si son varios se listan en el orden a cruzar separados por comas)

df_cons = pd.merge(df_ventas,df_productos,how='left',left_on=['Producto'],
right_on=['Id'])

df_cons

# En este caso como tenemos dos columnas en ambas tablas llamadas Producto
# al momento de la union se les anexan unos indices _x y _y para diferenciarlas

# podemos renombrar las columnas usando la siguiente instrucción, .columns

# pasando el nombre de cada una de las columnas
df_cons.columns =
['Fecha','Id_Producto','Id_Vendedor','Cantidad','Des_Producto','Costo','Valor']

df_cons

# Ejercicio
# Realizar la union del df_cons con los otros dos df, df_vendedores y df_ciudad
# vendedores
df_cons = pd.merge(df_cons,df_ciudad,how='left',left_on=['Ciudad'],
right_on=['Id'])
df_cons

df_cons.head()

Filtrando los datos, usando el método query

En algunos casos vamos a necesitar por algún motivo realizar un filtro de los
datos.

Esto lo podemos realizar usando el método .query de los dataframe

df_cons

# Por ejemplo, si queremos sólo obtener un df con el producto aretes

# Es importante realizar el método .copy() al final para garantizar que sean
objetos independientes
df_aretes = df_cons.query("Id_Producto == 3").copy()

df_aretes.head()

# Ejercicio
# Como solicitar solo los productos aretes y manillas donde la cantidad haya sido
superior a 3
df_are_y_man = df_cons.query("Des_Producto in ('Aretes','Manillas') and Cantidad >
10").copy()
df_are_y_man = df_cons.query('(Des_Producto == "Aretes" or Des_Producto ==
"Manilla")and(Cantidad >=10)').copy()

df_are_y_man

Ejercicios adicionales

Generar un dataframe que permita conocer las ventas sólo realizadas del producto
Collar en la ciudad de Bogotá de Género Femenino.

df_bogota = df_cons.query('Des_Producto == "Collar" and Ciudad_y == "Bogotá" and

Género =="F"')
df_bogota

Generando nuevas columnas

También podemos generar nuevas columnas a partir de columnas ya existentes en el

dataframe.

Por ejemplo, generemos una columna ganancia

df_cons['Ganancia'] = df_cons['Cantidad'] * (df_cons['Valor'] - df_cons['Costo'])

df_cons.head()

Ejercicio adicional 1
Generar un dataframe que permita conocer las ventas sólo realizadas del producto
Manilla y Aretes en la ciudad de Medelín donde la ganancia haya sido superior o
igual a 50000. a. Especial, una vez generado, que se pueda exportar a Excel, pero
que le solicite al usuario donde desea generarlo b. Especial 2, que el archivo
exportado no sea csv sino Excel, sin los indices y que la hoja se llame
RepEspecial1

Tip - usar el método df.to_excel que recibe

nombre o ruta del archivo

sheet_name='', donde dentro de las '' indicamos el nombre de la hoja
index = False, sino queremos que contenga los indices

df_medellin = df_cons.query('Des_Producto in ("Aretes","Manilla") and Ciudad_y ==

"Medellín" and Ganancia > 50000')
df_medellin.head()

df_medellin.to_excel('Reporte Medellin.xlsx', sheet_name='RepMed2020', index =

False)

Eliminando columnas

Dado que ya realizamos algunos cruces, podemos eliminar algunas columnas usando el
método de los dataframe .drop

# Eliminando la columna Id_Producto

df_cons.drop(['Id_Producto'], axis=1)

# Miremos si sí se elimino
df_cons

# Para eliminarla, debemos confirmar agregando inplace=True

df_cons.drop(['Id_Producto'], axis=1, inplace=True)

df_cons

# Ejercicio
# Eliminar las demás columnas con llaves de las que ya tenemos valores

Seleccionando Filas y Columnas

Para seleccionar las filas y las columnas, podemos usar los métodos loc e iloc

# Método loc
# Realizar la búsqueda basado en la columna indice, para nuestro caso los indices
son similares
# a un enumarado
# Incluye ambos valores, el inicio y el final
df_cons.loc[1:5]

# Recordemos nuestro otro df

df

# Devuelve sólo la etiqueta 'KAZ'

df.loc['KAZ']

# Devuelve desde el principio hasta la etiqueta BRA incluso

df.loc[:'BRA']
# Método iloc
# Devuelve las filas indicadas, sin importar los enteros asociados
# No incluye el final
df_cons.iloc[1:5]

# con el otro df
df.iloc[1:5]

Agrupando datos - nivel 2

Es normal que se requieran agrupar los datos por diferentes niveles y medidas, como
sumas, promedios o demás

df_cons

# Agrupando nivel 2
# con la instrucción groupby indicamos los campos que queremos agrupar
# dentro de agg, definimos las medidas que queremos revisar
# al final identificamos sólo las columnas que queremos resumir
df_agru1 = df_cons.groupby(['Des_Producto']).agg(['mean','sum','nunique'])
[['Cantidad','Costo','Valor']]

df_agru1

Ejercicios propuesto por el profe :)

Maneras simplificadas de obtener resumenes

# Métodos abreviados de resumenes

# Conocer la cantidad de items totales

df_cons['Fecha'].count()

# Conocer la ganancia más alta

df_cons['Ganancia'].max()

# Conocer la cantidad de ventas en cada fecha

df_cons['Fecha'].value_counts()

# Conocer el monto vendida por Manilla

df_cons['Ganancia'][df_cons['Des_Producto'] == 'Manilla'].sum()

#
-----------------------------------------------------------------------------------
---------------------
# Adicionales
# Recorriendo hojas iguales en un libro para consolidarlas

# Consolidar hojas de un mismo excel

hojas_dict = pd.read_excel('Notas.xlsx', sheet_name=None)

for nombre, hoja in hojas_dict.items():

# colocamos el nombre de la hoja en un campo de cada df llamado hoja
hoja['hoja'] = nombre
# realizamos el cambios del nombre de la hoja si hay espacios
hoja = hoja.rename(columns=lambda x: x.split('\n')[-1])
# Anexamos a la lista cada df de cada curso
todas_las_hojas.append(hoja)
# encadenamos cada una de las hojas a una df completo
tabla_completa = pd.concat(todas_las_hojas)

# reseteamos el indice
tabla_completa.reset_index(inplace=True, drop=True)

print(tabla_completa)

tabla_completa.to_excel('Notas Consolidadas.xlsx', sheet_name='Consolidado',

index=False)

#
-----------------------------------------------------------------------------------
---------------------

# Consolidar hojas de diferentes libros

#importar pandas y os
import pandas as pd
import os

# Consolidar hojas de misma ruta

ruta_insumos = "C:\\Users\\Andres\\Curso Python 2022\\Sesion 20220618\\Hojas\\"

ruta_salida = "C:\\Users\\Andres\\Curso Python 2022\\Sesion 20220618\\Hojas\\

Consolidado\\"

lista_archivos_excel = os.listdir(ruta_insumos)
lista_archivos_excel

df = pd.DataFrame()

for archivo_excel in lista_archivos_excel:

if archivo_excel.endswith(".xlsx"):
df1 = pd.read_excel(ruta_insumos+archivo_excel)
df1['nombre_archivo'] = archivo_excel
df = df.append(df1)

df.to_excel(ruta_salida+"Consolidado.xlsx", index=False)

#
-----------------------------------------------------------------------------------
-----------------------

# Ejemplo Leyendo datos donde en los resumenes se cumplan condiciones especiales

# como que un conteo sea mayor que

import pandas as pd
df = pd.read_csv('50000 HRA Records.csv')

# Conteo de los trabajadores

df.groupby(['Age', 'Department'])['DailyRate'].count()

# Muestra con menos de 200 trabajadores

df.query("Age == 18 and Department == 'Sales'")

# Muestra con mas de 200 trabajadores

df.query("Age == 18 and Department == 'Hardware'")
# metodo transform
# nos permite para un resumen, generar filtros de los datos cuando
# se cumplan condiciones en este resumen
# para este caso, sacamos el conteo, .transform('count')
# sobre ese conteo, generamos los mayores que 200, .gt(200)
df.groupby(['Age', 'Department'])['DailyRate'].transform('count').gt(200)

df[df.groupby(['Age', 'Department'])['DailyRate'].transform('count').eq(189)]

***********************************************************************************
**************************

Tuplas

# Método 1
a = 1,2,3,'ejemplo',4,5,'hola'

print(a)

type(a)

# Método 2
b = (1,2,3,'otra,',5,6,'tupla')

print(b)

type(b)

- Métodos

b.append(1)

b[0] = 0

lista = [1,2,3,'hola',5,6,'tarde']

lista

type(lista)

Operaciones con Tuplas

a = 1,2,3,4
b = 5,6,7,8

c = a + b

print(c)

type(c)

print(a * 3)

# El elemento 4 está en en a, devuelve True o False

4 not in a

# Se usa el método index para ubicar la posición de un elemento

a = 1,2,3,4,5,6,7
a.index(2)
# usamos el método count para revisar la cantidad de veces que se repite un
elemento
tup1 = 1,2,3,4,1,2,1,5,6,7

tup1.count(1)

type(tup1)

Modificacion Tuplas

# para modificar tuplas las podemos convertir en listas usando list() y luego en
tuplas usando tuple()
a = 1,2,3,4,5
a = list(a)
a.sort(reverse=True)
a = tuple(a)
print(a)

a[:2]

a = (1,(1,2,3),3,4)

a[1]

a[1][2]

a = (1,[1,2,3],3,4)

a[1]

type(a[1])

a[1][1]

a[1][1] = 234

type(a)

type(a[1])

Conjuntos

conjunto1 = set({1,2,3})

conjunto1

conjunto2 = {1,2,3}

type(conjunto2)

# Pueden almacenar varios items como tuplas

conjunto = {True, 3.14, None, False, "Hola mundo", (1, 2)}

print(conjunto)

# No puede contener otros elementos como listas, conjuntos

conjunto = {0,1,2,3,4,{1,2}}

# add, para adicionar items

conjunto = {1,2,3}
conjunto.add(4)

print(conjunto)

conjunto.add(0)

print(conjunto)

conjunto.add(0)

# mantiene solo un elemento, no guarda elementos repetidos

print(conjunto)

lis1 = [1,2,3,4,1,2]
# convertimos a conjunto una lista
con1 = set(lis1)

#Método remove, elimina un elemento de un conjunto; debe estar presente

con1.remove(4)
con1

con1.remove(4)
con1

#Método remove, elimina un elemento de un conjunto; si no esta presente no hay

error
con1.discard(4)
con1

# Método clear, limpia el conjunto

con1.clear()
con1

## Método difference, realiza la diferencia entre 2 sets; sólo deja los diferentes
con1 = {1,2,3,4,5}
con2 = {10,5,2,3,40}
con3 = con1.difference(con2)
print(con3)

## Método union, suma 2 conjuntos

con1 = {1,2,3,4,5}
con2 = {10,5,2,3,40}
con3 = con2.union(con1)
print(con3)

print(con3)

# Método pop, elimina un elemento aleatorio del set

con3.pop()

print(con3)

Operaciones en conjuntos con caracteres

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}

# Union
a | b

# Intersección
a & b

# Diferencia
a - b

b - a

# también se puede comparar

{1, 2, 3} == {3, 2, 1, 1, 1}

{1, 2, 3} == {4, 5, 6, 6}

# También soporta las sentencias in, y not

grupo = {'Pedro','Natalia','Camilo'}

'Natalia' in grupo

'Camilo' not in grupo

*********************************************************************************

Reutilizando Código

La reutilización de código es una parte muy importante de la programación en

cualquier lenguaje. El aumento del tamaño del código hace que sea más difícil de
mantener, por eso la utilidad de manejar los bucles.

Las funciones

Cualquier declaración que consista en una palabra seguida de información entre

paréntesis es una llamada a la función. Las palabras delante de los paréntesis son
nombres de funciones, y los valores separados por comas dentro de los paréntesis
son argumentos de funciones. Aquí hay algunos ejemplos que ya has visto:

print("Hello world!")

range(2, 20)

print(str(12))

list(range(10, 20, 3))

Además de utilizar funciones predefinidas, puede crear sus propias funciones

utilizando la instrucción def. Aquí hay un ejemplo de una función llamada my_func.
No requiere argumentos e imprime "spam" tres veces.

Se define y luego se llama. Las declaraciones en la función se ejecutan solo cuando

se llama a la función.

def my_func():
print("spam")
print("spam")
print("spam")
my_func()

El bloque de código dentro de cada función comienza con dos puntos (:) y está
indentado.

hello()

def hello():
print("Hello world!")

Argumentos

La mayoría de las funciones toman argumentos.El siguiente ejemplo define una

función que toma un argumento:

def print_with_exclamation(word):
print(word + "!")
print("Fin impresión de",word)

# Primer llamado a la fxn

print_with_exclamation("pan")
# Segundo llamado a la fxn
print_with_exclamation("eggs")

También puede definir funciones con más de un argumento; separarlos con comas.

def print_sum_twice(x, y):

print(x + y)
print(x * y)

print_sum_twice(5, 8)

Los Argumentos de la Función

Los argumentos de la función se pueden usar como variables dentro de la definición

de la función. Sin embargo, no pueden ser referenciados fuera de la definición de
la función. Esto también se aplica a otras variables creadas dentro de una función.

def print_sum_twice(x, y):

print(x + y)
print(x - y)

print_sum_twice(5, 8)

def function(yes):
yes = yes + 1
print(yes)

function(7)

# Genera error debido a que yes sólo existe dentro de la funcion function
print(yes)

Técnicamente, los parámetros son las variables en una definición de función, y los
argumentos son los valores puestos en los parámetros cuando se llaman funciones.
# Complete los espacios en blanco para definir una función que imprima
# "yes", si su parámetro es un número par, y "Not" de lo contrario.

def even(x):
if x%2 == 0:
print("Yes")
else:
print("No")

even(201)

def even(x):
if x%2 == 0:
return "Yes"
else:
return "No"
even(3)

Return de las funciones

Ciertas funciones, como int o str, devuelven un valor que se puede usar más
adelante. Para hacer esto con las funciones definidas, se puede usar la declaración
return.

def max(x=1, y=10):

if x >=y:
return x * 3
else:
return y * 2

r = max()
print(r)

¿ Cuál es la diferencia entre print y return?

La declaración return no se puede usar fuera de una definición de función.
print es una función o método que se usa básicamente para imprimir algo
En cambio return se usa en las funcione para devolver un valor

Una vez return obtiene un valor de una función, deja de ejecutarse inmediatamente.
Cualquier código después de la declaración return nunca sucederá. Por ejemplo:

def add_numbers(x, y):

total = x + y
return total
print("This won't be printed")
print(add_numbers(4, 5))

del(add_numbers)
print(add_numbers(4, 5))

Comentarios

Los comentarios son anotaciones al código que se utilizan para facilitar su

comprensión. No afectan cómo se ejecuta el código. En Python, se crea un comentario
insertando un hash: #). Todo el texto después de él en esa línea se ignora. Por
ejemplo:
Docstrings

Las cadenas de documentos (cadenas de documentación) tienen un propósito similar a

los comentarios, ya que están diseñadas para explicar el código. Sin embargo, son
más específicos y tienen una sintaxis diferente. Se crean colocando una cadena
multilínea que contiene una explicación de la función debajo de la primera línea de
la función

def shout(word):
"""
Print a word with an
exclamation mark following it.
"""
print(word + "!")

shout("spam")

A diferencia de los comentarios convencionales, los Docstrings se conservan durante

el tiempo de ejecución del programa. Esto permite que el programador inspeccione
estos comentarios en tiempo de ejecución.

Funciones como objetos

Aunque se crean de manera diferente a las variables normales, las funciones son
como cualquier otro tipo de valor. Se pueden asignar y reasignar a variables, y
luego hacer referencia a ellos con esos nombres.

a = 10
b = 34

def multiply(x, y):

return x * y

operation = multiply

type(operation)

print(operation(a, b))

def shout (word):

return word + "!"
print(shout("shout"))

Las funciones también se pueden usar como argumentos de otras funciones.

def add(x, y):

return x + y

def do_twice(func, x, y):

return func(func(x, y), func(x, y))

a = 5
b = 10

print(do_twice(add, a, b))

do_twice(add,a,b) def do_twice(func, x, y) do_twice(add,5,10) func = add x= 5 y= 10

return func(func(x, y), func(x, y)) return add(add(5,10),func(5,10)) add(5,10)
def add(x, y): return x + y return 5+10= 15

return add(add(5,10),func(5,10)) return add(15,15) 30

def square(x):
return x * x

def test(func, x):

print(func(x))

test(square, 42)

Modulos

Los módulos son piezas de código que otras personas han escrito para cumplir tareas
comunes, como generar números aleatorios, realizar operaciones matemáticas, etc.

La forma básica de usar un módulo es agregar import module_name en la parte

superior de su código, y luego usar module_name.var para acceder a funciones y
valores con el nombre var en el módulo. Por ejemplo, el siguiente ejemplo usa el
módulo aleatorio para generar números aleatorios:

import random

for i in range(5):
value = random.randint(1, 6)
print(value)

El método randint () devuelve un elemento seleccionado de número entero del rango

especificado. El código utiliza la función randint definida en el módulo aleatorio
para imprimir 5 números aleatorios en el rango de 1 a 6.

from math import pi

print(pi)

from math import pi, sqrt

print(pi)
print(sqrt(9))

* Importa todos los objetos de un módulo. Por ejemplo:

from math import *
Esto generalmente se desaconseja, ya que confunde las variables en su código con
las variables en el módulo externo.

Puede importar un módulo u objeto con un nombre diferente utilizando la palabra

clave as. Esto se usa principalmente cuando un módulo u objeto tiene un nombre
largo o confuso.
Por ejemplo:

from math import sqrt as square_root, pi as nropi

print(square_root(100))
print(nropi)

Profundización Funciones
def saludar():
print("Hola este print se llama desde la función saludar")
saludar()

def dibujar_tabla_del_5():
for i in range(10):
print("5 x",i,"=",i*5)
dibujar_tabla_del_5()

def test(n=12):
return n * 100
test(345)

print(n)

m = 10
def test():
print(m)
test()

m = 10
def test(m):
for i in range(m):
print("5 x",i,"=",i*5)
test(m)

def test():
print(l)
l=20
test()

del l

def test():
o=5
print(o)
test()
o=10
test()
print(o)

o=10

test()

# n Goblal
n=5
def test():
# n de la función
n=10
return n
print(test())
print(n)

del n

Argumentos y Parametros
def resta(a,b):
return a-b
x = 10
y = 20
print(resta(x,y))

print(resta(1,2))

print(resta(b=2,a=10))

resta()

def resta(a=None,b=None):
if a == None or b == None:
print("Error, se deben enviar dos números a la función")
return
else:
return a-b
resta(a=1,b=0.5)

resta()

Argumentos por valor y referencia¶

# Cuando enviamos un valor a una función

# en la función se hace una copia de estos valores pero el valor
# enviado no se modifica
# esto se conoce como argumentos por valor
def doblar_valor(numero):
a = numero * 2
print("Resultado del numero",numero,"multiplicado por 2 es",a)
n=10
doblar_valor(n)
print(n)

# Si enviamos colecciones de datos como una lista

# estos se envían por referencia
# Es decir, que lo realice la función sobre estos datos
# Afecta los valores originales de la lista
def doblar_valores(numeros):
for i, n in enumerate(numeros):
numeros[i] *= 2
ns = [10,50,100]
doblar_valores(ns)
ns

# Obetenemos 20 porque redefinimos el valor de n

# para que almacene el resultado de la función
def doblar_valor(numero):
return numero * 2
n = 10
n = doblar_valor(n)
n

# Se aplica el doblar valores a cada elemento de la lista

def doblar_valores(numeros):
for i, n in enumerate(numeros):
numeros[i] *= 2
ns = [10,50,100]
doblar_valores(ns)
ns

Argumentos indeterminados

# Usando *args le decimos a python

# que no sabemos el tipo de argumentos a recibir
# la primera manera es recibir los argumentos por posición
# para esto usamos *args

# Obtenemos una tupla al imprimir porque los parametros que enviamos

# No deberían poder modificarse al momento de ser usados por la función

def indeterminados_posicion(*args):
print(args)
for arg in args:
print(arg)
indeterminados_posicion(1,"Hola",[1,2,3,4,5],"Otro texto",[1,1,1],1.90)

# También los podemos recibir como indeterminados por el nombre

# Esto nos devuelve una diccionario en lugar de una tupla

# Le indicamos que los argumentos los queremos crear con nombre y valor
# agregando ** y normalmente se utiliza la palabra kwargs que significa
# kw = keyword y args= argumentos para indicar que son parejas de datos
def indeterminados_por_nombre(**kwargs):
print(kwargs)
indeterminados_por_nombre(n=1,c="Hola",l=[1,2,3,4,5])

# Juntemos todo un poco para ver como

# podría funcionar
def super_funcion(*args,**kwargs):
t = 0
print("Argumentos sin llave",args)
for arg in args:
t += arg
print("Sumatorio indeterminado es", t)
print("Argumentos con llave",kwargs)
for kwarg in kwargs:
print(kwarg," ",kwargs[kwarg])
super_funcion(10,50,-10,2.5,nombre='Andrés',edad='??')

Funciones recursivas

# Recursividad es cuando una función se llama a si misma

# Miremos un ejemplo

# Estas funciones recursivas deben dejar de llamarse en algún punto

# para nuestro caso es cuando ingresa al else

def cuenta_atras(num):
num -= 1
if num > 0:
print("Quedan",num,"segundos")
cuenta_atras(num)
else:
print("Explosión!!!")
 # Este print esta por fuera del if y dentro de la función cuenta_atras
# Siempre se ejecuta
print("fin de la fxn",num)
cuenta_atras(10)

# Miremos un ejemplo más

def factorial(n):
print("Valor inicial",n)
if n > 1:
n = n*factorial(n-1)
print("Valor final",n)
return n
factorial(5)

Funciones integradas

n = int("10")
n

f = float("10.5")
f

c = "Un texto " + str(10) + " " + str(3.14)

print(c)

print(bin(10))

print(hex(10))

print(int('0b1010',2))

print(int('0xa',16))

print(abs(10))
print(abs(-10))

print(round(5.8))
print(round(5.4))

eval('2+5')

n = 10
eval('n*10-5')

len("Una cadena")

len([])

help()