- Indice
Python es un lenguaje de programación de alto nivel y de código abierto. Es conocido por su sintaxis sencilla y legible, lo que lo hace ideal para principiantes en programación.
Se destaca por su amplia biblioteca estándar y su enfoque en la legibilidad del código. Es utilizado en diversos ámbitos, como desarrollo web, análisis de datos, inteligencia artificial y automatización de tareas.
Fue creado por Guido van Rossum en 1991 y desde entonces ha ganado popularidad debido a su facilidad de uso y versatilidad.
-
Lenguaje de Propósito General: Puede ser utilizado para cualquier actividad.(Web, Aplicaciones, etc.)
-
Lenguaje de Alto Nivel: Esto lo hace más legible, ya que se parece más a un lenguaje natural.
-
Fácil de Aprender: Por la similitud con el lenguaje humano, y la gran comunidad, para resolver problemas y dudas.
-
Lenguaje de Tipado Dinámico: La variable se adapta según el tipo de dato que le pasemos. Ejemplo:
name = "LucianoGriffa"
year = 2023- Lenguaje Orientado a Objeto: Es un estilo de programación en el que trabajamos con objetos que representan entidades y tienen características y comportamientos definidos. Los objetos se crean a partir de clases y agrupan datos y funciones relacionadas. Esto facilita la organización del código, la reutilización y la flexibilidad en el desarrollo de software.
- Lenguaje Interpretado: Es un lenguaje interpretado porque ejecuta el código fuente directamente, sin necesidad de compilarlo previamente, lo que permite una mayor flexibilidad y facilidad de uso en el desarrollo y la ejecución de programas.
Para correr tu primer programa "Hello World" en Python, sigue estos pasos:
-
Abre tu editor de texto o IDE favorito y crea un nuevo archivo con la extensión
.py. Por ejemplo,helloworld.py. -
Abre el archivo y escribe el siguiente código en él:
print("Hello World")-
Guarda el archivo.
-
Abre una terminal o línea de comandos en tu sistema operativo.
-
Navega hasta el directorio donde guardaste el archivo
helloworld.pyutilizando el comando cd. -
Ejecuta el siguiente comando en la terminal para correr el programa:
python helloworld.py
- Verás que se imprime "Hello World" en la terminal.
- String - Texto
"LucianoGriffa"
'LucianoGriffa'
"""Your data is:
name: LucianoGriffa
lastname: LucianoGriffa"""
'''Your data is:
name: LucianoGriffa
lastname: LucianoGriffa'''- Int & Float - Números Enteros & Números Flotantes/Decimales
10 # Int
10.2 # Float- Boolean - Booleano
True
False- List (Lista):
list = ["LucianoGriffa", "LucianoGriffa", True, 1.80]Las listas en Python son estructuras de datos que pueden ser modificadas, lo que significa que se pueden agregar, eliminar o modificar elementos después de su creación.
- Tuple (Tupla):
tuple = ("LucianoGriffa", "LucianoGriffa", True, 1.80, "Tuple")Aquí, se define una tupla llamada tuple que contiene varios elementos. Las tuplas son similares a las listas, pero a diferencia de ellas, las tuplas son inmutables, lo que significa que no se pueden modificar después de su creación.
- Set (Conjunto):
set = {"LucianoGriffa", "LucianoGriffa LucianoGriffa", True, 1.80, "Set"}Se crea un conjunto llamado set. Los conjuntos son colecciones no ordenadas de elementos únicos. No se accede a los elementos por índice como en las listas y las tuplas. Los conjuntos no permiten elementos duplicados, por lo que si intentas agregar un elemento duplicado, no se almacenará en el conjunto.
- Dictionary (Diccionario):
dictionary = {
'name': "LucianoGriffa",
'lastname': "LucianoGriffa",
'github': "@LucianoGriffa",
'age': 17,
'duplicate_lastname': "LucianoGriffa"
}
print(dictionary['age'])Aquí, se crea un diccionario llamado dictionary que contiene pares de key: value. Los diccionarios en Python son estructuras de datos que almacenan elementos asociados a una key. Cada elemento en el diccionario se compone de una key y un value separados por dos puntos (:).
Para acceder a un valor en el diccionario, se utiliza la key correspondiente. Por ejemplo, dictionary['age'] devuelve el valor 17.
- Definición de una variable con camelCase:
fullName = "LucianoGriffa LucianoGriffa"En este caso, se define una variable llamada fullName utilizando la convención de nombres camelCase. Esto significa que la primera letra de la primera palabra está en minúscula y las primeras letras de las palabras subsiguientes están en mayúscula.
- Definición de una variable con snake_case:
full_name = "LucianoGriffa LucianoGriffa"Aquí, se define una variable llamada full_name utilizando la convención de nombres snake_case. En esta convención, todas las letras están en minúscula y las palabras se separan con guiones bajos (_).
- Concatenación con el operador +:
welcome = "Hello " + " ¿How are you?"Se realiza una concatenación de cadenas utilizando el operador +. En este caso, se concatenan las cadenas "Hello" y " ¿How are you?" y se guarda el resultado en la variable welcome.
- Concatenación con f-strings:
welcome = f"Hello {full_name} ¿How are you?"Aquí, se utiliza la sintaxis de f-strings para realizar una interpolación de cadenas. La variable full_name se inserta en la cadena utilizando llaves {} y el prefijo f. Esto permite combinar de manera fácil y legible las variables con el texto dentro de la cadena.
- Operadores de pertenencia (in / not in):
print("LucianoGriffa" in welcome) # True
print("LucianoGriffa" not in welcome) # FalseSe utilizan los operadores de pertenencia para verificar si la subcadena "LucianoGriffa" está presente en la cadena welcome. El operador in devuelve True si la subcadena se encuentra en la cadena y False en caso contrario. Por otro lado, el operador not in devuelve True si la subcadena no está presente y False si está presente.
Addition - Suma (+)
addition = 2 + 2 # Result 4Subtraction - Resta (-)
subtraction = 4 - 2 # Result: 2Multiplication - Multiplicación (*)
multiplication = 2 * 3 # Result: 6Division - División (/)
Se utiliza para dividir un valor por otro y devuelve un resultado decimal o de tipo float.
division = 10 / 5 # Result: 2.0Exponentiation - Exponenciación (**)
Se utiliza para elevar un valor a una potencia y devuelve el resultado.
exponentiation = 3 ** 5 # Result: 243Floor division - División baja (//)
Se utiliza para realizar una división entera y devuelve un resultado entero(int) redondeado hacia abajo.
floor_division = 12 // 7 # Result: 1Modulus - Módulo o Resto (%)
Se utiliza para obtener el resto de una división y devuelve el resultado.
modulus = 18 % 10 # Result: 8Equal - Igual que
x == y Not equal - Distinto de
x != yGreater than - Mayor que
x > yLess than - Menor que
x < yGreater than or equal to - Mayor que o igual que
x >= y Less than or equal to - Menor que o igual que
x <= yOperador and: Devuelve True si ambas expresiones son verdaderas, de lo contrario, devuelve False. Se puede usar & o and.
Ejemplos:
Resultado = True & True # Devolver True
Resultado2 = False and True # Devolver Falso
Resultado3 = True & False # Devolver Falso
Resultado4 = False and False # Devolver FalsoOperador or: Devuelve True si al menos una de las expresiones es verdadera, de lo contrario, devuelve False. Se puede usar | o or.
Ejemplos:
Resultado5 = True or True #Devolver True
Resultado6 = False | True #Devolver True
Resultado7 = True or False #Devolver True
Resultado8 = False | False #Devolver FalsoOperador not: Devuelve True si la expresión es falsa, y False si la expresión es verdadera. Es un operador unario, ya que solo actúa sobre una expresión.
Ejemplos:
Resultado9 = not True #Devolver Falso
Resultado10 = not False #Devolver Trueif se utiliza para ejecutar un bloque de código si una condición es verdadera.
else se utiliza para ejecutar un bloque de código cuando todas las condiciones anteriores son falsas.
elif se utiliza para evaluar múltiples condiciones y ejecutar el bloque de código correspondiente al primer elif cuya condición sea verdadera, siempre y cuando las condiciones anteriores sean falsas.
Ejemplo:
age = 20
if age < 18:
print("Eres menor de edad")
elif age >= 18 and age < 65:
print("Eres adulto")
else:
print("Eres un adulto mayor")En este ejemplo, se define una variable age con el valor de 18. Luego, se utilizan las estructuras condicionales if, elif y else para determinar en qué categoría de edad se encuentra la persona.
-
Si la edad es menor a 18, se imprimirá "Eres menor de edad".
-
Si la edad es igual o mayor a 18 y menor a 65, se imprimirá "Eres adulto".
-
Si la edad es igual o mayor a 65, se imprimirá "Eres un adulto mayor".
En este caso, como la edad es 20, se imprimirá "Eres adulto". Puedes modificar el valor de la variable age para probar diferentes resultados.
cadena = "Hola, Maquina! ¿Cómo Estás?"dir(): Muestra los atributos y métodos disponibles para un objeto.
print(dir(cadena))lower(): Convierte la cadena a minúsculas.
print(cadena.lower()) # "hola, maquina! ¿cómo estás?"upper(): Convierte la cadena a mayúsculas.
print(cadena.upper()) # "HOLA, MAQUINA! ¿CÓMO ESTÁS?"capitalize(): Convierte la primera letra de la cadena a mayúscula y el resto a minúsculas.
print(cadena.capitalize()) # "Hola, maquina! ¿cómo estás?"isalpha(): Verifica si la cadena contiene solo caracteres alfabéticos.(Únicamente A-Z)
print(cadena.isalpha()) # Falsesplit(): Divide la cadena en una lista de subcadenas utilizando un delimitador.
print(cadena.split()) # ['Hola,', 'Maquina!', '¿Cómo', 'Estás?']replace(): Reemplaza una subcadena por otra en la cadena original.
print(cadena.replace("Estás", "Hola")) # "Hola, Maquina! ¿Cómo Hola?"endswith(): Verifica si la cadena termina con una subcadena específica.
print(cadena.endswith("?")) # Truestartswith(): Verifica si la cadena comienza con una subcadena específica.
print(cadena.startswith("Hola")) # Truelen(): Devuelve la longitud (cantidad de caracteres) de la cadena.
print(len(cadena)) # 23count(): Cuenta las ocurrencias de una subcadena en la cadena.
print(cadena.count("a")) # 4isnumeric(): Verifica si la cadena contiene solo caracteres numéricos.
print(cadena.isnumeric()) # Falseindex(): Devuelve la posición de la primera aparición de una subcadena en la cadena.
print(cadena.index("Maquina")) # 6find(): Busca la primera aparición de una subcadena en la cadena y devuelve su posición (-1 si no se encuentra).
print(cadena.find("¿")) # 16lista = [1, 3, 5, 7, 9]list(): Crea una lista a partir de un objeto iterable.
nueva_lista = list("Hola") # ['H', 'o', 'l', 'a']len(): Devuelve la longitud (cantidad de elementos) de la lista.
print(len(lista)) # 5append(): Agrega un elemento al final de la lista.
lista.append(11)
print(lista) # [1, 3, 5, 7, 9, 11]insert(): Inserta un elemento en una posición específica de la lista.
lista.insert(2, 4)
print(lista) # [1, 3, 4, 5, 7, 9, 11]extend(): Agrega los elementos de otra lista al final de la lista actual.
lista.extend([13, 15])
print(lista) # [1, 3, 4, 5, 7, 9, 11, 13, 15]pop(): Elimina y devuelve el último elemento de la lista (o un elemento en una posición específica).
elemento_eliminado = lista.pop()
print(elemento_eliminado) # 15
print(lista) # [1, 3, 4, 5, 7, 9, 11, 13]remove(): Elimina la primera aparición de un elemento en la lista.
lista.remove(4)
print(lista) # [1, 3, 5, 7, 9, 11, 13]clear(): Elimina todos los elementos de la lista.
lista.clear()
print(lista) # []sort(): Ordena los elementos de la lista en orden ascendente.
otra_lista = [9, 2, 7, 4, 1]
otra_lista.sort()
print(otra_lista) # [1, 2, 4, 7, 9]reverse(): Invierte el orden de los elementos en la lista.
otra_lista.reverse()
print(otra_lista) # [9, 7, 4, 2, 1]diccionario = {"nombre": "Juan", "edad": 30, "ciudad": "Madrid"}get(): Obtiene el valor asociado a una clave, devuelve None si la clave no existe.
print(diccionario.get("nombre")) # "Juan"
print(diccionario.get("altura")) # Nonekeys(): Devuelve una lista con todas las claves del diccionario.
print(diccionario.keys()) # ["nombre", "edad", "ciudad"]clear(): Elimina todos los elementos del diccionario.
diccionario.clear()
print(diccionario) # {}pop(): Elimina y devuelve el valor asociado a una clave específica.
valor_eliminado = diccionario.pop("edad")
print(valor_eliminado) # 30
print(diccionario) # {"nombre": "Juan", "ciudad": "Madrid"}items(): Devuelve una lista de tuplas (clave, valor) de todos los elementos del diccionario.
print(diccionario.items()) # [("nombre", "Juan"), ("ciudad", "Madrid")]input() se utiliza para obtener la entrada del usuario, y los valores ingresados se tratan como cadenas de texto. Puedes convertirlos a otros tipos de datos según sea necesario, con int() y float().
Obtener una cadena de texto desde el usuario:
texto = input("Ingresa una cadena de texto: ")
print("El texto que ingresaste es:", texto)Obtener un float o número decimal desde el usuario
numero_decimal = float(input("Ingresa un número decimal: "))
print("El número decimal que ingresaste es:", numero_decimal)Obtener un int o número entero desde el usuario
number = int(input("Ingresa un número entero: "))
print("El número entero que ingresaste es:", number)Obtener varios valores en una sola línea separados por espacios y almacenarlos en una lista:
valores = input("Ingresa varios valores separados por espacios: ").split()
print("Los valores que ingresaste son:", valores)Obtener varios números en una sola línea separados por comas y almacenarlos en una lista de enteros:
numeros = [int(x) for x in input("Ingresa varios números separados por comas: ").split(",")]
print("Los números que ingresaste son:", numeros)El timing para ver los conceptos vistos en python en un curso de corrido es de 2.5hs como Mínimo, 7hs como Máximo y 4hs en Promedio. Este curso lo logro en 1.5hs.
a) Cuánta diferencia en porcentaje entre el curso actual y:
- El más rápido de otros cursos.
- El más lento de otros cursos.
- El promedio de los cursos.
Teniendo en cuenta que el crudo de los demás cursos es de 5hs y con edición lo convierten en 4hs y el crudo de este curso 3.5hs y se redujo a 1.5hs.
b) Qué porcentaje de material inservible que se reduce en:
- El promedio de los cursos.
- El curso actual (este curso).
c) Ver 10hs de este curso a cuantas de otros cursos equivalen?
Suponiendo que cada persona promedio habla 2 palabras por segundo.
a) Pedirle al usuario que diga cualquier texto real y:
- Calcular cuanto taradaría en decir esa frase.
- ¿Cuantas palabras dijo?
b) Si tarda más de 1 minuto:
- Decirle: "para flaco tampoco te pedí un testamento".
c) Cuanto tardaria Dalto en decirlo, ya que habla un 30% más rápido?
Resolución Ejercicio 1.1 Resolución Ejercicio 1.2
Primero, creamos una tupla llamada data_in_tuple con los valores "Lucas", "Dalto" y 10000000.
data_in_tuple = ("Lucas", "Dalto", 10000000) # Tuple - TuplaLuego, creamos una lista llamada data_in_list con los valores 22, "Argentina" y "Soy Dalto".
data_in_list = [22, "Argentina", "Soy Dalto"] # List - ListaDespués, desempaquetamos la tupla data_in_tuple en las variables name, lastname y subscribers. Esto significa que asignamos cada valor de la tupla a una variable individualmente.
name, lastname, subscribers = data_in_tupleDel mismo modo, desempaquetamos la lista data_in_list en las variables age, live y channel.
age, live, channel = data_in_listFinalmente, imprimimos los valores de las variables utilizando la función print() para mostrar los resultados esperados.
print(name, lastname, subscribers) # Lucas Dalto 10000000
print(age, live, channel) # 22, "Argentina", "Soy Dalto"Creamos una tupla llamada tuple_one utilizando la función tuple(). Se pasa una lista ['One', 'Two'] como argumento a la función tuple(), lo cual convierte la lista en una tupla. La tupla resultante contendrá los elementos 'One' y 'Two'.
tuple_one = tuple(['One', 'Two'])En esta linea se crea otra tupla llamada tuple_two sin utilizar paréntesis. Los elementos 'One', 'Two' y 'Three' están separados por comas. Al no usar paréntesis, Python reconoce automáticamente que se está creando una tupla.
tuple_two = 'One', 'Two', 'Three'Y por ultimo, en esta línea se crea una tupla llamada tuple_three con un solo elemento, 'One'. La coma al final indica que se trata de una tupla de un solo elemento en lugar de simplemente una cadena.
tuple_three = 'One',Luego imprimimos las tres tuplas creadas anteriormente. Los valores de tuple_one, tuple_two y tuple_three se muestran en la salida separados por comas.
print(tuple_one, tuple_two, tuple_three)Se crea un conjunto llamado set_one utilizando la función set(). Se pasa una lista ["Data One", "Data Two"] como argumento, y el conjunto resultante contendrá los elementos "Data One" y "Data Two".
set_one = set(["Data One", "Data Two"])En estas líneas, se crea un conjunto inmutable set_two utilizando la función frozenset(). Se pasa una lista ["Data One", "Data Two"] como argumento. Luego, se crea un nuevo conjunto set_three que contiene set_two, junto con los elementos "Data One" y `"Data Two"``. Así, se pone un conjunto dentro de otro conjunto.
set_two = frozenset(["Data One", "Data Two"])
set_three = {set_two, "Data One", "Data Two"}Aqui, se definen dos conjuntos: set_1 que contiene los elementos 1, 3, 5 y 7, y set_2 que contiene los elementos 1, 3 y 7.
set_1 = {1, 3, 5, 7}
set_2 = {1, 3, 7}Se comprueba si set_2 es un subconjunto de set_1. Se utiliza el método issubset() o el operador <=. El resultado se almacena en las variables resultForm1Sub y resultForm2Sub. Si set_2 es un subconjunto de set_1, el resultado será True; de lo contrario, será False.
resultForm1Sub = set_2.issubset(set_1)
resultForm2Sub = set_2 <= set_1Se verifica si set_2 es un superconjunto de set_1. Se utiliza el método issuperset() o el operador >=. El resultado se almacena en las variables resultForm1Super y resultForm2Super. Si set_2 es un superconjunto de set_1, el resultado será True; de lo contrario, será False.
resultForm1Super = set_2.issuperset(set_1)
resultForm2Super = set_2 >= set_1Y por ultimo, en estas líneas se verifica si hay números en común entre set_1 y set_2. Se utiliza el método isdisjoint() o el operador !=. El resultado se almacena en la variable resultForm1. Si los conjuntos son disjuntos y no tienen elementos en común, el resultado será True; de lo contrario, será False.
resultForm1 = set_2.isdisjoint(set_1)
resultForm1 = set_2 != set_1Se crea un diccionario llamado dictionary_one utilizando la función dict(). Se pasan pares clave-valor separados por coma para definir los elementos del diccionario. En este caso, se define la clave "name" con el valor "Lucas" y la clave "lastname" con el valor "Dalto".
dictionary_one = dict(name="Lucas", lastname="Dalto")Estas líneas muestran cómo utilizar tuplas y conjuntos inmutables como claves en un diccionario. En dictionary_two, se utiliza una tupla ("Dalto", "Lucas") como clave con el valor "Jajaj". En dictionary_three, se utiliza un conjunto inmutable frozenset(["Dalto", "Lucas"]) como clave con el valor "Jajaj". Tanto las tuplas como los conjuntos inmutables se pueden utilizar como claves de diccionario porque son objetos inmutables en Python.
dictionary_two = {("Dalto", "Lucas"): "Jajaj"}
dictionary_three = {frozenset(["Dalto", "Lucas"]): "Jajaj"}En esta línea se crea un diccionario llamado dictionary_four utilizando el método fromkeys(). Se pasa una lista ["name", "lastname"] como argumento para especificar las claves del diccionario. El valor por defecto para todas las claves es None.
dictionary_four = dict.fromkeys(["name", "lastname"])Aqui, se crea otro diccionario llamado dictionary_five utilizando el método fromkeys(). Se pasa la misma lista ["name", "lastname"] como argumento, pero en este caso se especifica el valor por defecto como "Jajaj" para todas las claves.
dictionary_five = dict.fromkeys(["name", "lastname"], "Jajaj")Iterando una lista, tupla o conjunto. (animals & numbers).
animals = ["cat", "dog", "lion", "tiger", "fish"]
for animal in animals:
print(animal)
numbers = (10, 62, 42, 58)
for number in numbers:
result = number * 10
print(result)Iterando dos o más listas, tuplas o conjuntos en un solo bucle. (animals & numbers).
for number, animal in zip(numbers, animals):
print(f"Iterating tuple 1: {number}")
print(f"Iterating list 2: {animal}")Usamos range, que es una función incorporada que se utiliza para generar una secuencia de números enteros. Puede tomar uno, dos o tres argumentos y devuelve un objeto de tipo range, que es iterable.
for num in range(5, 10):
print(num)Forma no óptima de recorrer una lista o tupla con su indice. (no funciona en conjuntos)
for num in range(len(numbers)):
print(numbers[num])Forma óptima de recorrer una lista, tupla o conjunto.
for num in enumerate(numbers):
index = num[0]
value = num[1]
print(f"The index is {index} and value is: {value}")Usando el for/else.
for number in numbers:
print(f"Value: {number}")
else:
print(f"The loop ended")Creamos un diccionario.
dictionary = {
"name": "Lucas",
"lastname":"Dalto",
"subs": 1000000
}Recorriendo el diccionario para obtener las claves.
for key in dictionary:
key
print(f"The key is: {key}")Diccionario iterativo con items() para obtener claves y valores.
for data in dictionary.items():
key = data[0]
value = data[1]
print(f"The key is: {key} and the value is: {value}")En esta línea se inicializa la variable count con el valor 0.
count = 0En este bucle while, se ejecutará repetidamente el bloque de código dentro del bucle siempre que la condición count <= 10 sea verdadera. En cada iteración del bucle, se imprime el valor actual de count y luego se incrementa en 1 utilizando el operador de asignación +=. Esto significa que se imprimirán los números del 0 al 10, ya que cuando count alcanza el valor 11, la condición se vuelve falsa y el bucle termina.
while count <= 10:
print(count)
count += 1Después del bucle, se imprime la cadena "The while loop ended". Esta línea se ejecuta después de que la condición del bucle se vuelva falsa y el bucle haya terminado su ejecución.
print("The while loop ended")Ejemplo. Tenemos una lista de numeros.
numbers = [4, 7, 43, 20]Utilizamos la funcion max() para encontrar el numero mayor de una lista.
number_most_largest = max(numbers)Utilizamos la funcion min() para encontrar el numero menor de una lista.
number_most_smallest = min(numbers)Redondeo a 6 decimales. Con round().
number = round(12.3456, 2) # round(number, decimal quantity)Retorna False -> 0, vacio, False, None \ True -> distinto a 0, True, cadena, datos no vacio. Con bool()
result_bool = bool(2)Retorna True, si todos los valores son verdaderos. Con all()
result_all = all([234, "True", [23654]])Con sum(), podemos sumar todos los valores de un iterable.
total_sum = sum(numbers)Cuando se trata de funciones regulares en Python, el parámetro *args se utiliza para pasar un número variable de argumentos posicionales a una función. La convención es usar el nombre args (aunque puede tener cualquier otro nombre) precedido por un asterisco (*) para indicar que se trata de una lista de argumentos.
Aquí tienes un ejemplo de cómo utilizar *args en una función:
def sumar(*args):
total = 0
for num in args:
total += num
return total
resultado = sumar(1, 2, 3, 4, 5)
print(resultado) # Salida: 15En este ejemplo, la función sumar recibe un número variable de argumentos posicionales a través del parámetro *args. Dentro de la función, se itera sobre los elementos de args y se suma cada número al total. Finalmente, se devuelve el resultado.
Cuando se llama a la función sumar con los valores 1, 2, 3, 4, 5, todos esos valores se agrupan en una tupla y se asignan a args. Luego, la función realiza la suma de todos los elementos de la tupla y devuelve el resultado, que es 15.
El uso de *args permite flexibilidad al definir funciones que pueden aceptar diferentes cantidades de argumentos posicionales. Esto puede ser útil cuando no se sabe de antemano cuántos argumentos se pasarán a la función.
En Python, una función lambda es una función anónima, lo que significa que no se le asigna un nombre como una función regular definida con def. En cambio, se crea utilizando la palabra clave lambda. A diferencia de las funciones regulares, las funciones lambda pueden ser definidas en una sola línea y son útiles para tareas sencillas y expresiones pequeñas.
La sintaxis básica de una función lambda es la siguiente:
lambda argumentos: expresión- argumentos: son los parámetros de entrada de la función
lambda. - expresión: es la operación o cálculo que se realiza en la función
lambday se devuelve como resultado.
Aquí hay un ejemplo de una función lambda que suma dos números:
add = lambda x, y: x + y
resultado = add(3, 5)
print(resultado) # Salida: 8En este ejemplo, se crea una función lambda llamada add que toma dos argumentos x e y y devuelve la suma de ambos. Luego, se llama a la función add pasando los valores 3 y 5, y se almacena el resultado en la variable resultado. Finalmente, se imprime el resultado, que es 8.
Las funciones lambda son especialmente útiles cuando se necesitan funciones pequeñas y simples, como en el caso de operaciones matemáticas básicas, filtrado de listas o transformaciones simples de datos. Se pueden utilizar junto con otras funciones de orden superior, como map, filter y reduce, para realizar operaciones rápidas y concisas en colecciones de datos.
Hoy falto el profesor de clase y los chicos se organizaron para armar la suya propia.
1 Alumno va a ser el profesor. 1 Alumno va a ser su asistente.
a) Pedir el nombre y la edad de los compañeros que vinieron hoy a clase y ordenar los datos de menor a mayor.
b) El mayor de la clase es el profesor y el menor es el asistente: ¿Quién es quien?.
Crea una funcion que cuando le pasemos un numero, nos de numeros primos hasta llegar al numero ingresado.
Hacer una sucesion de Fibonacci.
Resolución Ejercicio 2.1 Resolución Ejercicio 2.2 Resolución Ejercicio 2.3
En Python, un módulo es un archivo que contiene definiciones de variables, funciones y clases que se pueden utilizar en otros programas. Los módulos se utilizan para organizar y reutilizar código en proyectos más grandes. Proporcionan una forma de dividir y estructurar el código en unidades lógicas y promueven la modularidad y la reutilización.
Los módulos en Python se usan para:
-
Organizar el código: Los módulos permiten agrupar funciones, variables y clases relacionadas en un solo archivo, lo que facilita la navegación y la comprensión del código.
-
Reutilizar código: Los módulos se pueden importar y utilizar en diferentes programas, lo que evita la duplicación de código y promueve la eficiencia y el mantenimiento.
-
Compartir funcionalidades: Los módulos pueden ser compartidos entre diferentes programadores o proyectos, lo que permite colaborar y utilizar bibliotecas externas para ampliar las capacidades de Python.
Existen diferentes tipos de módulos en Python:
-
Módulos estándar: Son módulos que vienen incluidos en la instalación de Python. Proporcionan funcionalidades básicas y amplias, como manejo de archivos, matemáticas, acceso a la red, etc. Algunos ejemplos de módulos estándar son
os,math,random,datetime, entre otros. -
Módulos de terceros: Son módulos desarrollados por la comunidad de Python que no están incluidos en la instalación estándar. Estos módulos se pueden descargar e instalar utilizando administradores de paquetes, como
pip. Ejemplos de módulos de terceros populares sonnumpy,pandas,requests,matplotlib, entre otros. -
Módulos personalizados: Son módulos creados por el propio usuario para encapsular código personalizado. Estos módulos pueden ser archivos Python creados por el programador para agrupar funciones, clases y variables relacionadas en un proyecto específico.
Para utilizar un módulo en Python, se utiliza la declaración import seguida del nombre del módulo. Por ejemplo:
import math
resultado = math.sqrt(25)
print(resultado) # Salida: 5.0En este ejemplo, se importa el módulo math y se utiliza la función sqrt() del módulo para calcular la raíz cuadrada de 25. Luego se imprime el resultado.
En Python, un paquete es una forma de organizar y estructurar módulos relacionados. Un paquete es simplemente una carpeta (directorio) que contiene uno o más archivos de Python (módulos) y un archivo especial llamado __init__.py. El archivo __init__.py indica que la carpeta es un paquete y puede contener código de inicialización u otra lógica relacionada con el paquete.
Los paquetes se utilizan para agrupar y organizar módulos relacionados de manera lógica. Proporcionan una forma de crear una jerarquía de módulos para proyectos más grandes y complejos.
Aquí tienes un ejemplo de cómo se puede organizar un paquete en Python:
Supongamos que tienes una carpeta llamada mi_paquete que contiene los siguientes archivos:
mi_paquete/
__init__.py
modulo1.py
modulo2.pyEl archivo __init__.py indica que la carpeta mi_paquete es un paquete. Este archivo puede estar vacío o puede contener código de inicialización o configuración del paquete.
Los archivos modulo1.py y modulo2.py son módulos dentro del paquete mi_paquete. Estos archivos pueden contener funciones, clases u otras definiciones de Python relacionadas.
Para utilizar los módulos dentro del paquete, se puede utilizar la declaración import de la siguiente manera:
import mi_paquete.modulo1
import mi_paquete.modulo2Los archivos de texto (.txt) en Python se utilizan para almacenar y leer datos en formato de texto plano. Pueden contener cualquier tipo de información legible por humanos, como texto, números y símbolos.
Para trabajar con archivos de texto en Python, puedes seguir los siguientes pasos:
Abrir un archivo: Puedes abrir un archivo utilizando la función open(). Es recomendable utilizar el enfoque de with para asegurarse de que el archivo se cierre correctamente una vez que hayas terminado de trabajar con él. Aquí tienes un ejemplo:
with open("TXT_Archives/notes.txt", encoding="UTF-8") as archive:
# Código para trabajar con el archivoPara leer un archivo TXT, hay varias formas en Python:
read(): Lee todo el contenido del archivo y lo devuelve como una cadena.readlines(): Lee todas las líneas del archivo y devuelve una lista donde cada elemento es una línea del archivo.readline([size]): Lee una línea completa del archivo. Puedes proporcionar un argumento opcional size para especificar la cantidad de caracteres a leer.
Aquí tienes un ejemplo de lectura de archivo:
with open("TXT_Archives/notes.txt", encoding="UTF-8") as archive:
content = archive.read() # Leer archivo completo
lines = archive.readlines() # Leer archivo línea por línea
line = archive.readline(2) # Leer una línea específicaEscribir en un archivo: Puedes escribir en un archivo utilizando los métodos write() y writelines():
write(texto): Escribe el contenido proporcionado como argumento en el archivo.writelines(lista): Escribe una lista de cadenas en el archivo, donde cada cadena representa una línea.
Aquí tienes un ejemplo de escritura en un archivo:
with open("TXT_Archives/notes.txt", 'w', encoding="UTF-8") as archive:
archive.write('YouTuber: Soy Dalto. Llamado Lucas Dalto. \n') # Sobreescribe el archivo
archive.writelines(['El Youtuber:', '\n', '- Soy Dalto']) # No sobreescribe el archivo
for i in range(5):
archive.writelines(f"\nLinea {i+1} agregada.")Recuerda que al utilizar with open(), no es necesario cerrar el archivo explícitamente, ya que se cerrará automáticamente al finalizar el bloque with.
CSV (Comma Separated Values) es un formato de archivo ampliamente utilizado para almacenar datos tabulares en forma de texto plano. En Python, puedes trabajar con archivos CSV utilizando la biblioteca csv o la biblioteca pandas.
Aquí hay una descripción de algunas operaciones comunes en archivos CSV utilizando ambas bibliotecas:
Leer un archivo CSV con la biblioteca csv:
import csv
with open('CSV_Archives/data.csv') as archive:
reader = csv.reader(archive)
for row in reader:
print(row)Leer un archivo CSV con la biblioteca pandas:
import pandas as pd
archive = pd.read_csv("CSV_Archives/data.csv", names=["name", "lastname", "age"])Manipulación de datos con la biblioteca pandas:
- Cambiar el tipo de datos de una columna:
archive['age'] = archive['age'].astype(str)- Obtener datos de una columna específica:
names = archive["name"]- Ordenar el dataframe por una columna:
sort_archive = archive.sort_values("age")
sort_archive = archive.sort_values("age", ascending=False)- Concatenar dos dataframes:
concat_archive = pd.concat([archive, archive2])- Reemplazar valores en una columna:
archive['lastname'].replace("Dalto", "Maestro", inplace=True)- Eliminar filas con datos faltantes:
archive = archive.dropna()- Exportar el dataframe limpio a un nuevo archivo CSV:
archive.to_csv("CSV_Archives/clean_data.csv")- Acceder a las primeras y últimas filas del dataframe:
primeras_filas = archive.head(3)
ultimas_filas = archive.tail(3)- Obtener la forma (número de filas y columnas) del dataframe:
filas_totales, columnas_totales = archive.shape- Obtener información estadística del dataframe:
archive_info = archive.describe()- Acceder a elementos específicos del dataframe:
elemento_especifico_loc = archive.loc[1, "age"]
elemento_especifico_iloc = archive.iloc[2, 2]- Acceder a columnas específicas del dataframe:
apellidos_loc = archive.loc[:, "lastname"]
apellidos = archive.iloc[:, 1]- Acceder a filas específicas del dataframe:
fila_3 = archive.loc[2, :]
fila_3 = archive.iloc[2, :]Trabajar con gráficos en Python te permite visualizar y presentar datos de manera efectiva. Hay varias bibliotecas populares que puedes utilizar, como Matplotlib, Seaborn y Plotly. A continuación, te mostraré una breve descripción y un ejemplo utilizando la biblioteca Matplotlib.
Matplotlib: Matplotlib es una biblioteca ampliamente utilizada para la visualización de datos en Python. Proporciona una amplia variedad de funciones y estilos para crear diferentes tipos de gráficos, como gráficos de líneas, gráficos de barras, gráficos de dispersión, gráficos de torta, histogramas, entre otros.
Aquí hay un ejemplo básico de cómo crear un gráfico de líneas utilizando Matplotlib:
import matplotlib.pyplot as plt
# Datos
x = [1, 2, 3, 4, 5]
y = [2, 4, 6, 8, 10]
# Crear el gráfico
plt.plot(x, y)
# Agregar etiquetas y título
plt.xlabel('Eje X')
plt.ylabel('Eje Y')
plt.title('Gráfico de Líneas')
# Mostrar el gráfico
plt.show()En este ejemplo, primero importamos la biblioteca Matplotlib como plt. Luego, definimos los datos para el eje x e y en las listas x y y. A continuación, utilizamos plt.plot() para crear el gráfico de líneas con los datos proporcionados. Luego, agregamos etiquetas para los ejes x e y con plt.xlabel() y plt.ylabel(), respectivamente. También añadimos un título al gráfico utilizando plt.title(). Finalmente, llamamos a plt.show() para mostrar el gráfico en una ventana emergente.
Esta es solo una introducción básica a la visualización de gráficos con Matplotlib. La biblioteca ofrece muchas más opciones y personalizaciones para adaptarse a tus necesidades específicas. Puedes explorar su documentación oficial para aprender más sobre cómo crear diferentes tipos de gráficos y ajustar su apariencia según tus preferencias.
Recuerda que también puedes utilizar otras bibliotecas, como Seaborn y Plotly, que proporcionan funcionalidades adicionales y estilos predefinidos para la visualización de datos.
Las excepciones en Python son eventos que ocurren durante la ejecución de un programa y pueden interrumpir el flujo normal del mismo. Las excepciones permiten manejar errores y situaciones excepcionales de manera controlada. Python proporciona una serie de excepciones integradas, y también puedes crear tus propias excepciones personalizadas.
Aquí tienes una descripción y ejemplos de cómo trabajar con excepciones en Python:
- Bloque
try-except: Puedes utilizar un bloquetry-exceptpara capturar y manejar excepciones específicas. El código que puede generar una excepción se coloca dentro del bloquetry, y el código de manejo de excepciones se coloca dentro de uno o varios bloquesexcept.
try:
# Código que puede generar una excepción
resultado = 10 / 0 # División por cero
except ZeroDivisionError:
# Código para manejar la excepción ZeroDivisionError
print("Error: División por cero")En este ejemplo, el bloque try intenta realizar una operación de división por cero, lo cual generará la excepción ZeroDivisionError. El bloque except captura esta excepción específica y muestra un mensaje de error.
- Bloque
try-except-except: Puedes manejar múltiples excepciones utilizando varios bloques except.
try:
# Código que puede generar excepciones
resultado = int("abc") # Conversión de una cadena no numérica a entero
resultado = 10 / 0 # División por cero
except ValueError:
# Código para manejar la excepción ValueError
print("Error: Valor no numérico")
except ZeroDivisionError:
# Código para manejar la excepción ZeroDivisionError
print("Error: División por cero")En este ejemplo, el bloque try intenta realizar una conversión de una cadena no numérica a entero, lo cual generará la excepción ValueError. Si se produce esta excepción, el primer bloque except captura y maneja el error. Si se genera una excepción de división por cero, el segundo bloque except se encargará de manejarla.
- Bloque
try-except-finally: Puedes utilizar un bloquefinallypara ejecutar un código sin importar si se produce una excepción o no.
try:
# Código que puede generar una excepción
resultado = 10 / 2
except ZeroDivisionError:
# Código para manejar la excepción ZeroDivisionError
print("Error: División por cero")
finally:
# Código que se ejecuta siempre, haya o no una excepción
print("Fin del programa")En este ejemplo, el bloque try realiza una operación de división válida. Si no se produce ninguna excepción, el bloque finally se ejecutará después del bloque try-except.
- Excepciones personalizadas: Puedes crear tus propias excepciones personalizadas heredando de la clase base Exception o de una excepción existente.
class MiExcepcion(Exception):
pass
def lanzar_excepcion():
raise MiExcepcion("Este es un mensaje de excepción personalizada")
try:
lanzar_excepcion()
except MiExcepcion as e:
print("Error personalizado:", str(e))En este ejemplo, se define la clase MiExcepcion que hereda de la clase base Exception. Luego, se crea una función llamada lanzar_excepcion() que utiliza la declaración raise para generar la excepción personalizada MiExcepcion con un mensaje específico.
Dentro del bloque try-except, se llama a la función lanzar_excepcion(). Si se produce la excepción MiExcepcion, se captura en el bloque except y se muestra un mensaje personalizado utilizando print().
Recuerda que el uso de excepciones personalizadas te permite definir y manejar errores específicos de tu aplicación, brindando un control más preciso sobre las situaciones excepcionales que pueden surgir durante la ejecución del código.
Las expresiones regulares (también conocidas como regex) son patrones utilizados para buscar y manipular texto de manera eficiente. Python ofrece el módulo re que proporciona funciones y métodos para trabajar con expresiones regulares. Aquí tienes una descripción y ejemplos de cómo utilizar expresiones regulares en Python:
- Coincidencia básica:
import re
texto = "Hola, este es un ejemplo de texto."
# Buscar una coincidencia de patrón
patron = r"ejemplo"
coincidencia = re.search(patron, texto)
if coincidencia:
print("Se encontró una coincidencia:", coincidencia.group())
else:
print("No se encontró ninguna coincidencia.")En este ejemplo, utilizamos re.search() para buscar la primera ocurrencia del patrón "ejemplo" en el texto. Si se encuentra una coincidencia, se imprime el resultado utilizando coincidencia.group(). Si no se encuentra ninguna coincidencia, se muestra un mensaje indicando que no se encontró ninguna coincidencia.
- Búsqueda y sustitución:
import re
texto = "Hola, este es un ejemplo de texto."
# Buscar y reemplazar un patrón
patron = r"ejemplo"
reemplazo = "demo"
nuevo_texto = re.sub(patron, reemplazo, texto)
print("Texto original:", texto)
print("Texto modificado:", nuevo_texto)En este ejemplo, utilizamos re.sub() para buscar todas las ocurrencias del patrón "ejemplo" en el texto y reemplazarlas con la palabra "demo". El resultado se guarda en nuevo_texto y se muestra tanto el texto original como el modificado.
- División de texto:
import re
texto = "Hola, este es un ejemplo de texto."
# Dividir el texto en palabras
palabras = re.split(r"\W+", texto)
print("Palabras:", palabras)En este ejemplo, utilizamos re.split() para dividir el texto en palabras utilizando el patrón \W+ que coincide con uno o más caracteres que no son letras, números ni guiones bajos. El resultado se almacena en palabras y se imprime la lista de palabras.
Estos son solo ejemplos básicos para ilustrar el uso de expresiones regulares en Python. Puedes explorar más funcionalidades y patrones avanzados en la documentación oficial del módulo re. Las expresiones regulares ofrecen un poderoso conjunto de herramientas para manipular y analizar texto de manera flexible y eficiente en Python.
El análisis de expresiones regulares implica desglosar una expresión regular en sus componentes individuales y comprender el significado y la funcionalidad de cada uno de ellos. Aquí tienes una descripción de los principales elementos utilizados en las expresiones regulares:
-
Literales: Los literales son caracteres simples que coinciden exactamente con ellos mismos. Por ejemplo, el literal a coincidirá con la letra "a" en un texto.
-
Metacaracteres: Los metacaracteres son caracteres con un significado especial en las expresiones regulares. Algunos metacaracteres comunes incluyen:
.(punto): Coincide con cualquier carácter excepto un salto de línea.^(circunflejo): Coincide con el comienzo de una línea.$(signo de dólar): Coincide con el final de una línea.*(asterisco): Coincide con cero o más repeticiones del elemento anterior.+(signo más): Coincide con una o más repeticiones del elemento anterior.?(signo de interrogación): Coincide con cero o una repetición del elemento anterior.\(barra invertida): Se utiliza para escapar metacaracteres y tratarlos como literales.
-
Conjuntos de caracteres: Los conjuntos de caracteres se representan entre corchetes
[ ]y permiten especificar un conjunto de caracteres posibles en un punto determinado de la coincidencia. Por ejemplo,[aeiou]coincide con cualquier vocal. -
Cuantificadores: Los cuantificadores se utilizan para especificar la cantidad de repeticiones de un elemento. Algunos cuantificadores comunes son:
{n}: Coincide exactamente con n repeticiones del elemento anterior.{n,}: Coincide con al menos n repeticiones del elemento anterior.{n,m}: Coincide con entre n y m repeticiones del elemento anterior.
-
Grupos y capturas: Los grupos se representan entre paréntesis
( )y permiten agrupar elementos juntos y aplicar operaciones a todo el grupo. Los grupos también pueden utilizarse para capturar partes específicas de una coincidencia. Por ejemplo,(\d{2})-(\d{2})-(\d{4})capturará una fecha en formatoDD-MM-YYYYy permitirá acceder a los valores de día, mes y año por separado.
Estos son solo algunos elementos básicos en el análisis de expresiones regulares. Las expresiones regulares pueden volverse mucho más complejas y poderosas al combinar múltiples elementos y aprovechar todas las funcionalidades que ofrecen.
Otro Ejemplo:
import re
# Expresión regular para buscar direcciones de correo electrónico
patron = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b"
# Texto de ejemplo
texto = "Contacta conmigo en info@example.com o support@example.org"
# Buscar todas las coincidencias de direcciones de correo electrónico
coincidencias = re.findall(patron, texto)
# Imprimir las direcciones de correo electrónico encontradas
print("Direcciones de correo electrónico encontradas:")
for correo in coincidencias:
print(correo)En este ejemplo, utilizamos una expresión regular para buscar direcciones de correo electrónico en un texto. El patrón utilizado r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b" busca una combinación de caracteres que coincida con el formato de una dirección de correo electrónico.
Luego, utilizamos re.findall() para buscar todas las coincidencias de direcciones de correo electrónico en el texto. Este método devuelve una lista con todas las coincidencias encontradas.
Finalmente, recorremos la lista de coincidencias e imprimimos cada dirección de correo electrónico encontrada.