search

camilomejiar / Python_Intermedio

0 stars 0 forks source link

Python Intermedio: Comprehensions Funciones y Manejo Errores #3

Open camilomejiar opened 1 year ago

camilomejiar commented 1 year ago

Python_Intermedio: Comprehensions, Lambdas y Manejo de Errores

Zen de Python

Pero qué es el Zen de Python?, pues su definición corresponde a los principios de Phyton, los cuales fueron escritos por su creador Tim Peters.

Para encontrar estos principios de Python, solo se debe ingresar a la consola y escribir el siguiente código: import this

  • Bello es mejor que feo.
  • Explícito es mejor que implícito.
  • Simple es mejor que complejo.
  • Complejo es mejor que complicado.
  • Plano es mejor que anidado.
  • Espaciado es mejor que denso.
  • La legibilidad es importante.
  • Los casos especiales no son lo suficientemente especiales como para romper las reglas.
  • Sin embargo la practicidad le gana a la pureza.
  • Los errores nunca deberían pasar silenciosamente.
  • A menos que se silencien explícitamente.

Frente a la ambigüedad, evitar la tentación de adivinar. Debería haber una, y preferiblemente solo una, manera obvia de hacerlo. A pesar de que eso no sea obvio al principio a menos que seas Holandés. Ahora es mejor que nunca. A pesar de que nunca es muchas veces mejor que ahora mismo. Si la implementación es difícil de explicar, es una mala idea. Si la implementación es fácil de explicar, puede que sea una buena idea. Los espacios de nombres son una gran idea, ¡tengamos más de esos!

SET (Conjuntos)

Corresponde a la misma definición básica a lo que son los conjuntos, el cual agrupa elementos que tienen algo en común.

Sus propiedades:

Set es uno de los 4 tipos de datos incorporados en Python que se utilizan para almacenar colecciones de datos, los otros son: list, Tuple y Dictionary, cada uno con una característica y funcionalidad distinta.

Los Set se utilizan para almacenar varios elementos en una sola variable, para este ejemplo vamos a utilizar frutas como la variable y sus elementos serán: "banana, manzana y pera".

Ejemplo en consola Nota: Se escriben con corchetes set_fruits = {"banana,", "manzana", "pera"} print (set_fruits)

Obtengo: {'pera', 'manzana', 'banana'}

INMUTABLE, es decir que después de haber sido creados no se pueden cambiar, es decir que después de haber sido creados no se pueden cambiar dentro del conjunto.

NO PERMITE DUPLICADOS, con esto se quiere decir que dentro de la variable, Python no permite almacenar mas de dos artículos con el mismos valor, python solo elige el primer valor y el segundo no lo determina.

Ejemplo en consola Nota: Se escriben con corchetes set_fruits = {"banana,", "manzana", "pera", "banana"} print (set_fruits)

Obtengo: {'pera', 'manzana', 'banana'}

LONGITUD DE UN CONJUNTO, cuando quieres saber cuántos artículos hay en un conjunto utilizas la función: len().

Ejemplo en consola Nota: Se escriben con corchetes

set_fruits = {"banana,", "manzana", "pera"} print (len(set_fruits))

Obtengo: 3

TIPOS DE DATOS, los tipos de datos en python, pueden ser de tipo cadena, int o booleanos, algunos ejemplos de ello: Nota: Se escriben con corchetes

Ejemplo en consola

set_fruit1 = {"banana", "manzana", "pera"}
set_fruit2 = {1, 2, 3}
set_fruit3 = {True, False, True,}
print (set_fruit1)
print (set_fruit2)
print (set_fruit3)}

Obtengo

{"banana", "manzana", "pera"} set_fruit2 = {1, 2, 3} {True, False, True,}

En Python, se pueden escribir diferentes tipos de datos ya sean cadenas, int o booleanos

Ejemplo consola Nota: Se escriben con corchetes

set1 = {"abc", 34, True, 40, "male"}

print(set1)

Obtengo

{True, 34, 'abc', 40, 'male'}

TYPE, Desde Python, los conjuntos se determinan como objetos con el tipo de datos "sets":

Ejemplo consola Nota: Se escriben con corchetes

set_fruit1 = {"banana", "manzana", "pera"}

print(type(set_fruit1))

Obtengo

class 'set'

STRING, con String lo que hacemos es que podemos crear los elementos a partir del string.

Ejemplo consola Nota: Se escriben con paréntesis ()

set_fruit_string = set("banana")
print(set_fruit_string)

Obtenemos {'b', 'a', 'n'}

Como en este caso la palabra inicial es "banana", pero recuerda que en python solo guarda un unico valor y no lo repite, así que solo deja una sola vocal 'a'.

Colecciones de Python (matrices), podemos construir una recopilación distinta dentro del lenguaje Python.

Ejemplo Se escribe con llaves []

numbers = [1, 2, 3, 4, 4, 5]
set_numbers = set(numbers)
print (set_numbers)

Obtenemos

{1, 2, 3, 4}

Ejemplo Se escribe con llaves []

numbers_tuples = [1, 2, 3, 4, 4, 5]
print (numbers_tuples)

Obtenemos

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

Ejemplo Se escribe con llaves []

numbers = [1, 2, 3, 4, 4, 5]
numbers = set(numbers)
print (numbers)

Obtenemos

{1, 2, 3, 4, 5}

Ejemplo_ Se escribe con llaves []

numbers = [1, 2, 3, 4, 4, 5]
numbers_set = set(numbers)
numbers_list = list(numbers)
print (numbers_list)

Obtenemos

set =>{1, 2, 3, 4, 4, 5} list =>{1, 2, 3, 4, 5} set =>{1, 2, 3, 4, 4, 5}

MODIFICAR ELEMENTOS DEL CONJUNTO Es posible realizar multiples modificaciones, cambios o hasta eliminar los valores que se encuentren dentro de un conjunto (set), para ello vamos a utilizar los siguientes elementos:

Contar Valores

fruts = {
  "tropical" : "PineApple",
  "sweet" : "papaya",
  "acid" : "mango"
}
fruts = len(fruts)
print(fruts)

Obtenemos

3

Modificar Valores de manera directa & add()

fruts = {
 "tropical" : "PineApple",
  "sweet" : "papaya",
  "acid" : "mango"
}
fruts["acid"] = "maracuya"
print(fruts)

Obtenemos

{'tropical': 'PineApple', 'sweet': 'papaya', 'acid': 'maracuya'}

fruts = {"PineApple", "papaya", "mango"}
fruts.add("aguacate")

Obtenemos

{'PineApple', 'papaya', 'mango', 'aguacate'}

Para validar que el elemento "aguacate" fue agregado escribimos fruts = len(fruts) y nos registra el valor 4

fruts = {
  "tropical" : "PineApple",
  "sweet" : "papaya",
  "acid" : "mango"
}
fruts["vegetal"] = "aguacate"
fruts = len (fruts)
print(fruts)

Obtenemos

{'tropical': 'PineApple', 'sweet': 'papaya', 'acid': 'mango', 'vegetal': 'aguacate'}
4

Actualizar un elemento con update()

Permite agregar cualquier tipo de objeto iterable como lo son listas o tuplas, dentro de un conjunto solo debemos ingresar el comando update() de la siguiente manera:

frutas = { "manzana", "pera", "mora"}
print(frutas)
frutas.update("papaya", "kiwi")
print(frutas)

Obtenemos:

{manzana, pera, mora, kiwi, papaya}

REMOVER ELEMENTOS DENTRO DEL CONJUNTO

Dentro de los conjuntos podemos remover parcial o total un elemento, con lo cual lo realizamos utilizando los siguientes comandos:

remove()

Esta función nos permite eliminar un elemento y si este NO existe dentro del conjunto lanza un error keyError

frutas = {"manzana", "pera", "mora"}
frutas.update({'sandia','lentejas'})
print(frutas)

frutas.remove('lentejas')
print(frutas)

Obtenemos:

{'manzana', 'pera', 'sandia', 'lentejas', 'mora'}
{'manzana', 'pera', 'sandia', 'mora'}

Ahora si vamos a buscar el valor "lenteja" nos genera el error keyError de la siguiente manera:

frutas = {"manzana", "pera", "mora"}
frutas.update({'sandia','lentejas'})
frutas.remove('lenteja')
print(frutas)

Obtenemos el siguiente error:

Traceback (most recent call last):
  File "set.py", line 3, in <module>
    frutas.remove('lenteja')
KeyError: 'lenteja'

clear() Quizas una de las funciones mas PELIGROSAS ya que elimina TODO es decir toda la información registrada en el conjunto queda vacia.

para esto tomaremos el siguiente ejemplo.

frutas = {"manzana", "pera", "mora"}
frutas.clear()
print(frutas)

Obtenemos:

set()

Materialde apoyo

OPERACIONES CON CONJUNTOS

Ahora como ya sabemos como agregar, modificar o eliminar elementos dentro de un conjunto (SET), lo que vamos hacer es unir dos o mas conjuntos y para ello utilizaremos las siguientes reglas:

UNION o SET()

Con esta funcion nos permite realiza la "Union" o "SET" entre dos conjuntos, con lo cual se simplifica como la suma de dos conjuntos entre sí generando uno nuevo sin que se repitan los datos, para ello vamos a revisar el siguiente ejemplo.

set_a ={'manzana', 'pera', 'kiwi'}
set_b ={'uva', 'cereza', 'melocoton'}
set_c = set_a.union(set_b)
print(set_c)

Obtenemos

{'melocoton', 'uva', 'manzana', 'pera', 'cereza', 'kiwi'}

Ahora si queremos agregar mas datos al conjunto _set_c_ debemos crear el conjunto _set_d_ y le agregamos la información correspondiente bajo el método union().

set_a ={'manzana', 'pera', 'kiwi'}
set_b ={'uva', 'cereza', 'melocoton'}
set_d ={'1', '2,', '3', 'uva'}
set_c = set_a.union(set_b)
set_c = set_c.union(set_d)
print(set_c)

Obtenemos:

{'melocoton', '2,', '3', 'pera', 'kiwi', '1', 'uva', 'manzana', 'cereza'}

Ahora podemos realizar el mismo ejercicio pero esta vez vamos a utilizar el operador matemático |. Este operador matemático representa la union de dos conjuntos, con lo el resultado tanto .union() como para | es el mismo.

set_a ={'manzana', 'pera', 'kiwi'}
set_b ={'uva', 'cereza', 'melocoton'}
set_d ={'1', '2,', '3', 'uva'}
set_c = set_a.union(set_b)
print(set_c)
set_e = (set_c |set_d)
print(set_c)

Obtenemos:

{'melocoton', 'uva', 'manzana', 'pera', 'cereza', 'kiwi'}
{'melocoton', 'uva', 'manzana', 'pera', 'cereza', 'kiwi'}

INTERSECTION()

Cuando hablamos de intersección nos referimos cuando dentro de la union de dos conjuntos hay un valor o elemento que es igual y que esta en los dos conjuntos y queremos identificarlo, para ello vamos a representarlo en el siguiente ejemplo:

set_b ={'uva', 'cereza', 'melocoton'}
set_d ={'papaya', 'zanahoria,', 'banano', 'uva'}
set_c = set_b.intersection(set_d)
print(set_c)

Obtenemos:

{'uva'}

En este caso nos identifica que el elemento "uva" esta en los dos conjuntos con lo cual solamente imprime su resultado.

Ahora podemos realizar el mismo ejercicio pero esta vez vamos a utilizar el operador matemático &. Este operador matemático representa la intersección de los datos dentro de un conjunto y nos imprime su resultado.

set_b ={'uva', 'cereza', 'melocoton'}
set_d ={'papaya', 'zanahoria,', 'banano', 'uva'}
set_c = set_b.intersection(set_d)
print(set_c)
print(set_c & set_d)

Obtenemos:

{'uva'}
{'uva'}

DIFERENCE(SET).

En esta operacion nos permite realizar la operación de "diferencia" entre dos conjuntos, para ello vamos a restar entre los conjuntos y el resultado seran los datos que no estan en los dos conjuntos.

set_b ={'uva', 'cereza', 'melocoton'}
set_d ={'papaya', 'zanahoria,', 'banano', 'uva'}
set_c = set_b.difference(set_d)
print(set_c)

Obtenemos:

{'cereza', 'melocoton'}

Ahora podemos realizar el mismo ejercicio pero esta vez vamos a utilizar el operador matemático -. Este operador matemático representa la resta entre los conjuntos y nos imprime su resultado.

set_a ={'manzana', 'pera', 'kiwi'}
set_b ={'uva', 'cereza', 'melocoton'}
set_d ={'papaya', 'zanahoria,', 'banano', 'uva'}
set_c = set_b.difference(set_d)
print(set_b - set_d)

Obtenemos:

{'cereza', 'melocoton'}

DIFERENCIA SIMETRICA, en este caso la diferencia simétrica lo que busca entre los dos conjuntos es restar todos los elementos excepto los que estan en común entre los dos conjuntos, para ello vamos a realizar el siguiente ejemplo:

set_a ={'manzana', 'pera', 'kiwi'}
set_b ={'uva', 'cereza', 'melocoton'}
set_d ={'papaya', 'zanahoria,', 'banano', 'uva'}
set_c = set_b.symmetric_difference(set_d)
print(set_c)

Obtenemos:

{'melocoton', 'zanahoria,', 'banano', 'cereza', 'papaya'}

Ahora podemos realizar el mismo ejercicio con un operador matematico para elo vamos a utilizar ^, con lo cual su resultado sera el mismo.

set_a ={'manzana', 'pera', 'kiwi'}
set_b ={'uva', 'cereza', 'melocoton'}
set_d ={'papaya', 'zanahoria,', 'banano', 'uva'}
set_c = set_b.symmetric_difference(set_d)
print(set_c)
print(set_b ^ set_d)

Obtenemos:

{'melocoton', 'zanahoria,', 'banano', 'cereza', 'papaya'}
{'melocoton', 'zanahoria,', 'banano', 'cereza', 'papaya'}

Material de apoyo

LIST COMPREHENSION

La comprension de listas o List comprehension nos ayudan a tener una sintaxis mucho mas corta cuando se desea crear una nueva lista basada en los valores de una ya existente, para ello vamos a utilizar for.

Ejemplo.

Tenemos una lista basada en frutas y queremos crear una nueva lista con base a las frutas que tengan la letra a, para ello vamos a tener en cuenta el sintaxis el cual sera de la siguiente manera: _[element **for** element **in** iterable]_.

element corresponde al elemento for element in iterable corresponde al ciclo donde se extraen elementos de cualquier iterable

> iterable, es cualquier objeto de Python capaz de devolver sus miembros uno a la vez, lo que permite iterarlo en un bucle for . Los ejemplos familiares de iterables incluyen listas, tuplas y cadenas; cualquier secuencia de este tipo se puede iterar en un bucle for.

frutas = ["banano", "manzana", "limon", "kiwi", "mango", "melon"]
newlist = [element for element in frutas if "i" in element]
print(newlist)

Obtenemos:

['limon', 'kiwi']

Material de apoyo

DICTIONARY COMPREHENSION

image

Podemos generar un diccionario en base a los datos que determinemos

{key:value _for_ var _in_ iterable}

Ejemplo:

dictionary = {} for i in range(1,11): dictionary[i] = i * 2 print(dictionary)

Investigando pude encontrar que podemos incluir mas de 2 listas, en este caso voy a tener 3 listas, las cuales me contienen los siguientes datos:

names = {"pedro", "andres", "carlos"}
ages = {21, 35, 40}
countrie = {"col", "mex", "arg"}

Ahora si vamos a print podemos obtenemos el siguiente resultado:

print(set(zip(names, ages, countrie)))
{('andres', 40, 'col'), ('pedro', 21, 'arg'), ('carlos', 35, 'mex')}

Pero al momento de utilizar dictionary comprehension, encontramos que zip() nos permite comprimir 3 listas y realizar operaciones más representativas.

for names, ages, countrie in zip(names, ages, countrie):
  print(f"Su nombre es {names} tiene {ages} y vive en {countrie}")
Obtenemos:

Su nombre es andres tiene 40 y vive en col
Su nombre es carlos tiene 35 y vive en mex
Su nombre es pedro tiene 21 y vive en arg

Comparto el artículo de las funciones de zip()

Material de apoyo

DICTIONARY COMPREHENSION: CONDITION

image

La comprensión del diccionario de Python es un método para transformar un diccionario en un diccionario nuevo. Usar un if-else en la comprensión de dictados de Python es una de las formas de crear una nueva lista. Funciona como una condición para filtrar los elementos del diccionario para un nuevo diccionario.

Ejemplo

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
reemplazar = {k: ('par' if v % 2 == 0 else 'impar') for (k, v) in dict1.items()}
print(reemplazar)
Obtenemos
print(reemplazar)
{'a': 'impar', 'b': 'par', 'c': 'impar', 'd': 'par', 'e': 'impar', 'f': 'par'}

Material de Apoyo

Si queremos que nos re emplace las vocales que están en minuscula a mayuscula podemos utilizar .upper()**

text = 'Hola soy Camilo y este es un texto de prueba'
unique = { c: c.upper() for c in text if c in 'aeiou' }
print(unique)
_Obtenemos:_
{'o': 'O', 'a': 'A', 'i': 'I', 'e': 'E', 'u': 'U'}

Ahora con la misma frase vamos a contar cuantas veces se repiten las vocales, con lo cual utilizaremos .count()**

text = 'Hola soy Camilo y este es un texto de prueba'
unique_v2 = { c: text.count(c) for c in text if c in 'aeiou'}
print(unique_v2)
_Obtenemos:
{'o': 4, 'a': 3, 'i': 1, 'e': 6, 'u': 2}

**Para utilizar estos métodos de formato

LIST vs TUPLES vs SET

image

LIST Las listasson como matrices de tamaño dinámico que en pocas palabras es una colección de cosas que se almacenan entre corchetes [ ] y separadas por coma ','.

Caracteristicas

Ejemplo:

# Python3 program to demonstrate
# List

# Creating a List
List = []
print("Blank List: ")
print(List)

# Creating a List of numbers
List = [10, 20, 14]
print("\nList of numbers: ")
print(List)

# Creating a List of strings and accessing
# using index
List = ["Geeks", "For", "Geeks"]
print("\nList Items: ")
print(List[0])
print(List[2])

Producción:

Lista en blanco:
[]

Lista de números:
[10, 20, 14]

Elementos de la lista:
Frikis
Frikis

TUPLE

Las Tuplas son una colección muy parecida a una lista, ya que sus valores almacenados pueden ser de cualquier tipo y están indexados por números enteros. Sus valores están separados por 'comas', pero esto no es necesario, ya que lo mas común es encerrarlos entre paréntesis ( ), sus principales características son:

Ejemplo:

# Creating an empty Tuple
Tuple1 = ()
print("Initial empty Tuple: ")
print (Tuple1)

# Creating a Tuple with
# the use of list
list1 = [1, 2, 4, 5, 6]
print("\nTuple using List: ")
print(tuple(list1))

#Creating a Tuple
#with the use of built-in function
Tuple1 = tuple('Geeks')
print("\nTuple with the use of function: ")
print(Tuple1)

Producción:

Tupla vacía inicial:
()

Tupla usando Lista:
(1, 2, 4, 5, 6)

Tupla con el uso de la función:
('G', 'e', ​​'e', ​​'k', 's')

SET El conjunto es una colección de elementos desordenada que es iterable, mutable y no tiene elementos duplicados. Su principal ventaja al utilizar un conjunto a diferencia de una lista, es su metodo que es altamente optimizado para verificar si un elemento específico esta contenido en un conjunto. Sus principales características son:

Ejemplo:

# Python3 program to demonstrate
# Set in Python

# Creating a Set
set1 = set()
print("Initial blank Set: ")
print(set1)

# Creating a Set with
# the use of Constructor
# (Using object to Store String)
String = 'GeeksForGeeks'
set1 = set(String)
print("\nSet with the use of an Object: " )
print(set1)

# Creating a Set with
# the use of a List
set1 = set(["Geeks", "For", "Geeks"])
print("\nSet with the use of List: ")
print(set1)

Producción:

Conjunto inicial en blanco:
establecer()

Establecer con el uso de un objeto:
{'G', 's', 'e', ​​'o', 'r', 'F', 'k'}

Establecer con el uso de Lista:
{'Geeks', 'Para'}

FUNCIONES

Las Funciones para Python es un bloque de codigo que solo se activan cuando se les llama.

Puede pasar datos, conocidos como parametros a una función y una función puede devolver datos como un resultado.

Como se construye Para Python una función es invocada utilizando la palabra def

Ejemplo:

Tenemos que escribir un texto "Hola Mi nombre es Camilo" con lo cual utilizarimos print('Hola mi nombre es Camilo') pero si tenemos que escribir de nuevo tendríamos que volver a copiar la misma linea de código.

Con la funcion _def()_ se utilizaría de la siguiente manera:

def my_print():
  print('Hola Mi nombre es Camilo')
my_print()
_Produccion:_
Hola Mi nombre es Camilo

Ahora tenemos que escribir el mismo texto dos veces, para eso en print le indicamos la cantidad a repetirse.

def my_print(text):
  print(text * 2)
my_print('Hola Mi nombre es Camilo')
_Produccion:_
def my_print(text):
  print(text * 2)
my_print('Hola Mi nombre es Camilo')

Tambien podemos utilizar def() con funciones matemáticas y seria de la siguiente manera:

def suma(a, b):
  print(a + b)
suma(1, 9)
suma(10, 20)
_Produccion_
10
30

Material de apoyo

FUNCIONES: RETURN

La función return nos permite devolver el valor al finalizar su ejecución pero también el valor que devuelve de la función y la ejecución del programa continua hasta finalizar su ciclo.

Ejemplo:

def sum_whit_range(min, max):
  print(min, max)
  sum = 0
  for x in range(min, max):
    sum += x
  return sum

result = sum_whit_range(1, 10)
print(result)
result_2 = sum_whit_range(result, result + 10)
print(result_2)
_Produccion:_
1 10
45
45 55
495

Material de apoyo

PARAMETROS POR DEFECTO Y MULTIPLES RETURNS

Conreturn podemos invocar para que se llamen varios datos al mismo tiempo y utilizando una sola funcion, para ello citaremos el siguiente ejemplo:

Vamos hallar el area de un cuadrado el cual tendrá sus valores de Alto, Ancho, Profundidad y que imprima un texto que diga: "El Valor del volumen es de:" y al final compare el resultado con el esperado.

Ejemplo

def fund_volumen(length=1, width=1, depth=1):
  return 'El valor del Volumen es de: ', length * width * depth, length

text, result, length = fund_volumen(length=10)

print(text)
print(result)
print(length)
_Producción:_
El valor del Volumen es de: 
10
10

Material de apoyo

SCOPE

Scope o Alcance, es cuando una variable solo esta disponible desde donde fue construida y para ello existen dos ambitos, el local y el global.

Scope Local

Cuando una variable es construida dentro de una función pertenece al ámbito local de esa función y solo se puede usar dentro de esa función. 

def incrementar():
  x = 150
  print(x)

incrementar()
_Produccion:_
150

En este ejemplo el valor a incrementar esta dentro de la función siendo invocada por x = 150 y su resultado será 150 a esto se le llama ámbito local

_Scope Global

A diferencia del Scope Local, el Scope Global esta creada en la parte externa de la función y esta puede ser utilizada tanto de manera global como local.

y = 150
def incrementar_2():
  print(y)

print(y)
_Producción:_
150

En este caso mi valor y = 150 esta en la parte externa de la función y es invocada por la función para mostrar su resultado.

Ahora si tenemos dos variables una global y la otra local con el mismo nombre de variable, Python lo que hará es tomar los dos variables por separado siendo una de tipo global (fuera de la función) y la otra de tipo local (dentro de la función)

y = 150
def incrementar_2():
  y = 300
  print(y)

incrementar_2()
print(y)
_Producción:_
300
150

En este caso observamos que el ámbito global tiene 'y = 150' y el ámbito local tiene 'y = 300', en donde al imprimir el resultado mostrara primero el ámbito local 300 y luego mostrará el resultado del ámbito global 150

Truco

Si dentro de una variable global que fue creada esta dentro de un ámbito local, podemos utilizar global para que la variable se vuelva de ámbito global dentro de la función.

def incrementar_3():
  global x
  x = 250

incrementar_3()
print(x)
_Producción:_
250

También podemos utilizar nuestra palabra global dentro de una función para remplazar un valor de tipo local a uno global de la siguiente manera:

y = 150
def incrementar_2():
  global y
  y = 300

incrementar_2()
print(y)
_Producción:_
300

FUNCIONES ANÓNIMAS: LAMBDA Lectura de Apoyo ¿Que es lambda? Son conocidas como Funciones Anónimas o lambdas, en donde no tienen un identificador o no tienen un nombre, se puede definir su estructura de la siguiente manera: lambda argumentos: expresión, las funciones lambda pueden tener los argumentos que se requieran pero solo una linea de código o una expresión.

Sintaxis

lambda arguments : expression

Queremos incrementar el valor de una serie según la cantidad que le hayamos dado para ello tenemos el siguiente ejemplo:

def increment(x):
  return x + 1

increment_v2 = lambda x : x + 1

result = increment_v2(20)
print(result)
_Producción:_
21

La función lambda puede tomar cualquier cantidad de argumentos, pero solo puede tener una expresión.

datos_completos = lambda name, last_name, age, countrie: f'Sus datos completos son {name.title()} {last_name.title()} tiene {age} años y vive en {countrie.title()}'
text = datos_completos('camilo', 'mejia', 35, 'colombia')
print(text)
_Producción:_
Sus datos completos son Camilo Mejia tiene 35 años y vive en Colombia

Higher order function: una función dentro de otra función Una función de Orden Superior o en sus siglas HOF se le lama así solo cuando contiene otras funciones como parámetro de entrada o devuelve una función como salida, es decir que en este caso las funciones que operan a otras funciones se les denomina Higher order function.

También hay que entender que a estas Funciones de Orden Superior HOF se aplican para funciones y métodos que toman como funciones a los parámetros o devuelven una función como un resultado.

Propiedades de HOF

def increment(x):
  return x + 10

increment_v2 = lambda x: x + 10

def hof(x, func):
  return x + func(x)

hof_v2 = lambda x, func: x + func(x) + func(x)

result = hof(20, increment)
# 20 + (20 + 10)
print(result)

En este caso Observamos como utilizando la función lambda podemos continuar seguir la función.

_Produccion_
50

Ahora HOF podemos incluir en este caso un signo de operación matemático de suma y multiplicación.

def increment(x):
  return x + 10

increment_v2 = lambda x: x + 10

def hof(x, func):
  return x + func(x)

hof_v2 = lambda x, func: x + func(x) + func(x)

result = hof(20, increment)
# 20 + (20 + 10)
print(result)

result = hof_v2(20, increment_v2)
print(result)

result = hof_v2(20, lambda x: x + 2)
result = hof_v2(20, lambda x: x * 2)
_Producción:_
50
80

Material de apoyo

MAP( ) La función map () ejecuta una función especifica para cada elemento en un iterable y el elemento se envía a la función como un parámetro.

Sintaxis.

map(function, iterables)

def ingredientes(a, b):
  return a + " es a " + b

menu = list(map(ingredientes, ('carne', 'maiz', 'aguacate'), ('molida', 'tacos', 'guacamole')))

print(list(menu))
_Producción_
['carne es a molida', 'maiz es a tacos', 'aguacate es a guacamole']

FILTER La función filter(), devuelve un valor que esta siendo iterado de la cual su resultado será el valor que se esta buscando en el filter

SINTAXIS

_filter (function, iterable_

Valores.

filter: Una función que se ejecutara para cada elemento iterable iterable: Lo que se va a filtrar.

Ejercicio: Tenemos una lista de estudiantes de la cual debemos saber quienes son de Colombia y quienes son considerados mayores de edad al tener igual o mas de 18 años y cuantos son.

people = [
  {
    'name' : 'Pedro',
    'country': 'Colombia',
    'age' : 18,
    'course' : 'developer'
  },
  {
    'name' : 'Juan',
    'country': 'Perú',
    'age' : 17,
    'course' : 'UX'
  },
  {
    'name' : 'Carlos',
    'country': 'Chile',
    'age' : 31,
    'course' : 'Diseño'
  },
  {
    'name' : 'Ana Maria',
    'country': 'Colombia',
    'age' : 25,
    'course' : 'Tester'
  }
]
countrie = list(filter(lambda country: country['country'] == 'Colombia', people))
print(countrie)
print(len(countrie))
_Produccion:_
[{'name': 'Pedro', 'country': 'Colombia', 'age': 18, 'course': 'developer'}, {'name': 'Ana Maria', 'country': 'Colombia', 'age': 25, 'course': 'Tester'}]
2

Ya sabemos que hay 2 personas en nuestros cursos que son de Colombia quienes son: Pedro y Ana Maria.

adult = list(filter(lambda age: age['age'] >= 18, people))
print(adult)
print(len(adult))
_Producción:_
[{'name': 'Pedro', 'country': 'Colombia', 'age': 18, 'course': 'developer'}, {'name': 'Carlos', 'country': 'Chile', 'age': 31, 'course': 'Diseño'}, {'name': 'Ana Maria', 'country': 'Colombia', 'age': 25, 'course': 'Tester'}]
3

Con esto podemos saber que hay 3 estudiantes que son considerados mayores de edad al tener 18 años o más quienes serían: Pedro con 18 años, carlos, con 31 años y Ana Maria con 25 años.

REDUCE( ) La función reduce() se aplica cuando queremos aplicar una función en particular en sus argumentos de una lista y los reducimos a un valor esperado, para ello su definición seria "functools"

Ejemplo:

Tenemos una lista de la cual debemos conocer 3 datos, la sumatoria de sus valores, saber cual es el numero mayor y el numero menor, para ello debemos tener claro que la lista esta compuesta por los numeros del 1 al 9 en desorden.

import functools

numbers = [1,3,4,6,8,9,2,5,7]
result = functools.reduce(lambda counter, item: counter + item, numbers)

text1 = "la sumatoria es: "
print(text1 + str(result))
_Producción:_
la sumatoria es: 45
maximo = functools.reduce(lambda a, b: a if a > b else b, numbers)
text2 = "El número máximo es: "
print(text2 + str(maximo))

Producción: El numero máximo es: 9

minimo = functools.reduce(lambda a, b: a if a < b else b, numbers) text3 = "El número mínimo es: " print(text3 + str(minimo)) Producción: El número mínimo es: 1

MODULO Un modulo se puede definir que es lo mismo a una biblioteca de código. Es decir es un archivo que contiene un conjunto de funciones que se pueden aplicar.

Como crear un Módulo?

  1. Para crear un módulo debemos escribir el nombre del archivo + la extensión de python que es .py ejemplo name.py
  2. Escribimos el código que vamos a utilizar en el archivo que acabamos de nombrar.
  3. Abrimos el archivo con el cual vamos a trabajar y declaramos el modulo que le dimos el nombre por ejemplo con la extensión import, sería de la siguiente manera: import name

Codigo en module.py

def greeting(name):
  print("Hello, " + name)

Código en el archivo que vamos a trabajar exercisemodule.py

import module

module.greeting("Camilo")

Producción: Hello, Camilo

Si en nuestro modulo principal tenemos una lista con varios valores, podemos extraer un solo resultado.

module.py

people = {
  "name": "Camilo",
  "age": 35,
  "country": "Colombia"
}

_exercisemodule.py

import module

a = module.people["age"]
print(a)

Producción: 35

Importar desde un Módulo.

AL utilizar la palabra from podemos importar partes especificas del módulo principal a nuestra documento de extracción de información.

module.py

def greeting(name):
  print("Hello, " + name)

people1 = {
  "name": "Camilo",
  "age": 35,
  "country": "Colombia"
}

exercise_module.py

from module import people1

print (people1["age"])

Producció: 35

Como Construir Módulos.

Para construir módulos debemos tener en cuenta que se deben crear en la misma carpeta a lo cual utilizaremos import para ser llamada en el archivo a trabajar:

Tenemos un módulo que tiene los datos de la población de 3 paises de Sur America, los cualse vamos a crear en la carpeta app y daremos por nombre utils.py

def get_population():
  keys = ['Colombia', 'Peru', 'Argentina']
  values = [500, 250, 350]
  return keys, values

def population_by_countrie(data, country): 
  result = list(filter(lambda item: item['country'] == country, data))
  return result

Ahora creamos el archivo con nombre main.py, este archivo vamos a digitar los datos a buscar.

import utils

keys, values = utils.get_population()
print(keys, values)

data = [
  {
    'country': 'Colombia',
    'Population': 500
  },
  {
    'country': 'Peru',
    'Population': 250
  },
  {
    'country': 'Argentina',
    'Population': 350
  }
]

Ahora invocamos el módulo a utilizar y sus valores según lo que contiene country = input('Digite el país: ') result = utils.population_by_countrie(data, country) print(result)

Producción:

Digite el país: Peru
[{'country': 'Peru', 'Population': 250}]
Digite el país: Colombia
[{'country': 'Colombia', 'Population': 500}]
Digite el país: Argentina
[{'country': 'Argentina', 'Population': 350}]

MÓDULOS COMO SCRIPTS: NAME y MAIN

Cuando utilizamos name == 'main' estamos dando dualidad a cierta función para que sea ejecutada en dos archivos distintos.

Para ello debemos tener en cuenta que su uso esta catalogado de dos maneras:

  1. Se puede ejecutar el archivo como un script.
  2. Importando el codding de un archivo a otro archivo python.

Para Python, es independiente cual de las dos formas estemos utilizando el código, ya que python define una variable especial llamada __name__ la cual contiene un string y cuyo resultado dependerá de la forma en como sea usada.

Como en el ejemplo, se observa que el primer archivo que denominamos main.py.

main.py

import utils

keys, values = utils.get_population()
print(keys, values)

data = [
  {
    'country': 'Colombia',
    'Population': 500
  },
  {
    'country': 'Peru',
    'Population': 250
  },
  {
    'country': 'Argentina',
    'Population': 350
  }
]

def run():
  keys, values = utils.get_population()
  print(keys, values)

  country = input('Digite el país: ')
  result = utils.population_by_countrie(data, country)
  print(result)

if __name__ == '__main__':
  run()

Cuando ejecutamos el archivo directamente como un script nuestra variable if __name__ tomara el valor de __main__

Al ser ejecutado nuestro output será el siguiente:

Producción:

Digite el país: Peru
[{'country': 'Peru', 'Population': 250}]

Con esto podemos concluir que la función __name__ == '__main__' ayuda a que python identifique de que manera se debe ejecutar e o los módulos ó script. Material de apoyo

PAQUETES Los paquetes son las carpetas que contienen varios módulos y cada uno con una función distinta. Para ello debe tener siempre un archivo de nombre __init__.py (por lo general esta vacio, ya que así es compatible con programas python versiones anteriores a la 3), con esto le estamos indicado a python que esto se trata de un paquete y no de una carpeta.

Para acceder a los módulos de los paquetes podemos utilizar estas opciones: import nombrecarpeta.nombremodulo from nombrecarpeta import nombremodulo from nombrecarpeta.nombremodulo import def

Estos son algunos ejemplos:

Antes de realizar el ejemplo debemos tener nuestra carpeta definida con la siguiente estructura:

En nuestra carpeta pkg, creamos dos archivos: __init__.py y aritmetica.py

__init__.py Se utiliza cuando debemos utilizar paquetes en versiones anteriores a python 3 o puede contener información la cual se ejecutara siempre, para este caso le colocamos el titulo Bienvenido a la clase de Aritmetica.

aritmetica.py va a contener nuestras operaciones aritmeticas que son, suma, resta, multiplicacion y division:

def sumar(a, b):
    return a + b

def restar(a, b):
    return a - b

def mult(a, b):
    return a * b

def div(a, b):
    return a / b

Ahora en nuestro archivo principal main.py ejecutaremos los paquetes de la siguiente manera:

import nombrecarpeta.nombremodulo

import pkg.aritmetica
print(pkg.aritmetica.sumar(5,7))
print(pkg.aritmetica.restar(5,7))

Produccion:

Bienvenido a la clase de Aritmética
12
-2

from nombrecarpeta import nombremodulo

from pkg import aritmetica 
print(aritmetica.sumar(5,7))
print(aritmetica.restar(5,7))

Produccion:

Bienvenido a la clase de Aritmética
12
-2

from nombrecarpeta.nombremodulo import def

from pkg.aritmetica import sumar
print(sumar(5,7))
from pkg.aritmetica import restar
print(restar(5,7))

Produccion:

Bienvenido a la clase de Aritmética
12
-2

Manipulación de Archivos y Errores.

ITERABLES Un iterable se define como el objeto que contiene un número contable con valores y este al tener un valor puede recorrer uno a uno los elementos que la contienen como una estructura de datos y operar con ellos, pero a la vez se rigen bajo la instrucción que se le es dada, con lo cual son dependientes de la instrucción a recibir.

Los metodos de su uso son dos __iter__() y __next__() .

Veamos un ejemplo:

Tenemos una serie de frutas las cuales debemos recorrer una a una para saber cuales son las que están dentro de la lista.

fruit = ("manzana", 'pera', 'banano')
myit = iter(fruit)

print(next(myit))
print(next(myit))
print(next(myit))

Ahora vamos a imprimir el resultado una a una con print(next(myit)), con esto controlamos un iterador por print

print(next(myit))
_Producción:_
manzana
print(next(myit))
print(next(myit))
_Producción:_
manzana
pera
print(next(myit))
print(next(myit))
print(next(myit))
_Producción:_
manzana
pera
banano

También podemos utilizar los iterables como una cadena de texto que recorre un texto o una serie de números.

fruit = ("manzana")
myit = iter(fruit)

print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
print(next(myit))
_Producción:_
m
a
n
z
a
n
a

Otra forma de realizar un iterador es atraves de for() o un bucle, para ello realizaremos el siguiente ejemplo:

cars = ('chevrolet', 'volvo', 'audi', 'mazda') 
for x in cars:
  print(x)
_Produccion:_
chevrolet
volvo
audi
mazda

Con el iterador también podemos crear una secuencia de números hasta cierto valor que le determinemos.

class MyNumbers:
    def __iter__(self):
      self.a = 1
      return self

    def __next__(self):
      x = self.a
      self.a += 1
      return x

myclass = MyNumbers()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
_Producción:_
1
2
3
4
5

Ahora si queremos que la iteración se detenga en un valor determinador podemos utilizar la declaración StopIteration

class MyNumbers:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    if self.a <= 10:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration

myclass = MyNumbers()
myiter = iter(myclass)

for x in myiter:
  print(x)
_Producción:_
1
2
3
4
5
6
7
8
9
10

ERRORES O EXCEPCIONES INTEGRADAS EN PYTHON En la siguiente tabla podemos encontrar los errores o excepciones que se presentan en Python.

Exception Description
ArithmeticError Se genera cuando se produce un error en los cálculos numéricos
AssertionError Se genera cuando falla una declaración de afirmación
AttributeError Se genera cuando falla la asignación o la referencia de atributo
Exception Clase base para todas las excepciones
EOFError Se genera cuando el método input() alcanza una condición de "fin de archivo" (EOF)
FloatingPointError Se genera cuando falla un cálculo de punto flotante
GeneratorExit Se genera cuando se cierra un generador (con el método close())
ImportError Se genera cuando no existe un módulo importado
IndentationError Se genera cuando la sangría no es correcta
IndexError Se genera cuando no existe un índice de una secuencia
KeyError Se genera cuando una clave no existe en un diccionario
KeyboardInterrupt Se genera cuando el usuario presiona Ctrl+c, Ctrl+z o Eliminar
LookupError Se genera cuando no se pueden encontrar los errores generados
MemoryError Se genera cuando un programa se queda sin memoria
NameError Se genera cuando una variable no existe
NotImplementedError Se genera cuando un método abstracto requiere una clase heredada para anular el método
OSError Se genera cuando una operación relacionada con el sistema provoca un error
OverflowError Se genera cuando el resultado de un cálculo numérico es demasiado grande
ReferenceError Se genera cuando no existe un objeto de referencia débil
RuntimeError Se genera cuando ocurre un error que no pertenece a ninguna expectativa específica
StopIteration Se genera cuando el método next() de un iterador no tiene más valores
SyntaxError Se genera cuando se produce un error de sintaxis
TabError Se genera cuando la sangría consta de tabulaciones o espacios
SystemError Se genera cuando se produce un error del sistema
SystemExit Se genera cuando se llama a la función sys.exit()
TypeError Se genera cuando se combinan dos tipos diferentes
UnboundLocalError Se genera cuando se hace referencia a una variable local antes de la asignación
UnicodeError Se genera cuando se produce un problema Unicode
UnicodeEncodeError Se genera cuando se produce un problema de codificación Unicode
UnicodeDecodeError Se genera cuando se produce un problema de decodificación Unicode
UnicodeTranslateError Se genera cuando se produce un problema de traducción Unicode
ValueError Se genera cuando hay un valor incorrecto en un tipo de datos especificado
ZeroDivisionError Se genera cuando el segundo operador en una división es cero

PRUEBA & ERROR Cuando se nos presenta un error o una excepción como se le llama en python, el programa se detiene y presenta el error que se presento, pero si utilizamos la excepción try() podemos omitir ese error y continuar con el programa. Esto es de uso fundamental para que el programa no continue con su ejecución por el error y así evitar retrasos en la producción, también de su uso para determinar en los bloques de código si se nos presenta un error poder ser identificado de manera mas facil.

Para qué try sea efectivo podemos utilizar estas declaraciones:

Exception Description
try Permite probar un bloque de código en búsqueda de un error.
except Permite manejar el tipo de error en el bloque.
else Permite ejecutar el código cuando no hay ningún tipo de error en el bloque.
finally Permite ejecutar el código en el bloque, independiente en el resultado de los bloques de prueba y excepción 
try:
  print(0/0)
except ZeroDivisionError as error:
  print(error)
print('hola')
~/CalculadoraPython$ python error.py 
Traceback (most recent call last):
  File "error.py", line 1, in <module>
    print(0/0)
ZeroDivisionError: division by zero
~/CalculadoraPython$ python error.py 
division by zero
hola

LEER ARCHIVOS DE TEXTO Para realizar la lectura de un archivo tipo texto en Python debemos utilizar la función open( ), esta función nos permite abrir un archivo tipo texto en python.

f = open('./text.txt')
print(f.read())
_Producción:_
linea 1
lina 2 
linea3
linea 4
asj
hjdc
judfnvkdjnv
zujcb

la función open() devuelve un resultado con print(f.read()) de tipo texto el cual es el método rápido de lectura.

Si queremos solamente realizar la lectura de una linea de texto, debemos utilizar readline() de la siguiente manera:

f = open('./text.txt')
print(f.readline())
_Producción:_
linea 1

Tambien con for podemos recorrer el tipo texto de la siguiente manera:

f = open('./text.txt')
print(f.readline())

for l in f:
  print(l)

f.close()
_Producción:_
linea 1

lina 2 

linea3

linea 4

asj

hjdc

judfnvkdjnv

zujcb

Es de buena practica siempre cerrar el documento texto al finalizar su lectura, algunas veces python lo puede hacer de manera automática pero si lo dejas abierto, esto te evitara que te reste memoria o que realices la lectura del archivo hasta cierto punto.

Al finalizar la lectura de un archivo debe ser cerrar su lectura con f.close()

ESCRIBIR TEXTOS EN PYTHON

Para poder escribir texto en python solo debemos agregar al parámetro open( ) algunas de las siguientes reglas:

Exception Description
"a" Agregar: se agregar texto al final del texto.
"w" Escribir: Sobre escribir cualquier contenido existente en el archivo texto.

Sintaxis.

Su sintaxis es un simple y fácil de usar, solo es necesario especificar el tipo de parámetro que queremos agregar a nuestro texto.

f = open('./text.txt') o file = open('./text.txt')

Veamos cómo aplicarlo a nuestro archivo texto.

f = open('./text.txt', "a")
f.write("nueva linea de texto1\n")
f.write("nueva linea de texto2\n")
f.write("nueva linea de texto3\n")
_Producción:_
nueva linea de texto1
nueva linea de texto2
nueva linea de texto3

Ahora y quizas este comando puede ser muy util como muy peligro ya que "w" lo que realiza es eliminar todo el texto y lo sobre escribir con lo que le vayamos a ingresar por eso es de cuidado!.

Veamos como se aplicaría.

f = open('./text.txt', "w")
f.write("Uppps!! hemos sobre escrito el texto con este nuevo\n")
f.close()
_Producción:_
Uppps!! hemos sobre escrito el texto con este nuevo
Gracias a Python existen mas comandos que podemos utilizar con la función open( ) las cuales explicare a continuación: Exception Description
"r" Lectura: Abre por defecto un archivo para su lectura, genera error si este no existe.
"a" Agregar: se agregar texto al final del texto.
"w" Escribir: Sobre escribir cualquier contenido existente en el archivo texto.
"x" Crear: Crea un archivo en especifico, devuelve un error si este no es valido.
"t" texto: Valor por defecto, devuelve el resultado como tipo texto.
"b" Binario: Devuelve el valor de tipo binario (por ejemplo imágenes)
camilomejiar commented 1 year ago

set

camilomejiar commented 1 year ago

add

camilomejiar commented 1 year ago

Remover y operadores matematicos en conjuntos

camilomejiar commented 1 year ago

dictionary comprehension

camilomejiar commented 1 year ago

LIST vs TUPLES vs SET

camilomejiar commented 1 year ago

LIST vs TUPLES vs SET

camilomejiar commented 1 year ago

arreglo zen

camilomejiar commented 1 year ago

Funciones

camilomejiar commented 1 year ago

function return

camilomejiar commented 1 year ago

Parámetros por defecto y múltiples returns

camilomejiar commented 1 year ago

SCOPE

camilomejiar commented 1 year ago

lambda

camilomejiar commented 1 year ago

scope imagen

camilomejiar commented 1 year ago

Higher order function: una función dentro de otra función

camilomejiar commented 1 year ago

HOF

camilomejiar commented 1 year ago

maps

camilomejiar commented 1 year ago

filter

camilomejiar commented 1 year ago

reduce