Python¶
Python es un lenguaje de programación interpretado y de alto nivel. Fue creado por Guido van Rossum y lanzado por primera vez en 1991. Python se destaca por su legibilidad y sintaxis clara, lo que lo hace ideal tanto para principiantes como para programadores experimentados.
Una de las características más destacadas de Python es su filosofía de diseño, que enfatiza la legibilidad del código y la facilidad de uso. El lenguaje utiliza una sintaxis limpia y utiliza el espaciado en blanco de manera significativa para estructurar el código, lo que lo hace fácil de leer y entender.
Nota: Para profundizar en conceptos básicos de Python, se recomienda estudiar del curso Introducción a Python.
# imprimir "Hola Mundo!"
print("Hola Mundo!");
Hola Mundo!
Variables¶
Una variable es una ubicación con nombre utilizada para almacenar datos en la memoria. Aquí hay un ejemplo:
# crear e imprimir variables
a = 5
print("a =", 5)
a = "cinco"
print("a =", a)
a = 5 a = cinco
Operadores básico¶
Los operadores son símbolos especiales que realizan operaciones en operandos (variables y valores). Hablemos de operadores aritméticos y de asignación en esta parte.
# operaciones basicas
x = 14
y = 4
# suma
print('x + y =', x+y) # Output: x + y = 18
# resta
print('x - y =', x-y) # Output: x - y = 10
# multiplicacion
print('x * y =', x*y) # Output: x * y = 56
# division
print('x / y =', x/y) # Output: x / y = 3.5
# cuociente
print('x // y =', x//y) # Output: x // y = 3
# resto
print('x % y =', x%y) # Output: x % y = 2
x + y = 18 x - y = 10 x * y = 56 x / y = 3.5 x // y = 3 x % y = 2
Operadores de asignación¶
Los operadores de asignación se utilizan para asignar valores a las variables. Ya has visto el uso de = operator. Probemos algunos operadores de asignación más.
# operadores de asignacion
x = 5
# x += 5 ----> x = x + 5
x +=5
print(x) # Output: 10
# x /= 5 ----> x = x / 5
x /= 5
print(x) # Output: 2.0
10 2.0
Inputs por el usuario¶
En Python, puede usar la función input() para tomar la entrada del usuario. Por ejemplo:
# inputs por el usuario
inputString = input('Escriba una oracion:')
print('Su oracion es:', inputString)
# correcto
num_int = 123 # integer type
num_flo = 1.23 # float type
num_new = num_int + num_flo
print("Valor de num_new:",num_new)
print("tipo de datos de num_new:",type(num_new))
Valor de num_new: 124.23 tipo de datos de num_new: <class 'float'>
# incorrecto
num_int = 123 # int type
num_str = "456" # str type
print(num_int+num_str)
--------------------------------------------------------------------------- TypeError Traceback (most recent call last) Input In [6], in <cell line: 5>() 2 num_int = 123 # int type 3 num_str = "456" # str type ----> 5 print(num_int+num_str) TypeError: unsupported operand type(s) for +: 'int' and 'str'
Explícito¶
num_int = 123 # int type
num_str = "456" # str type
# explicitly converted to int type
num_str = int(num_str)
print(num_int+num_str)
Python tipos numéricos¶
Python admite enteros, números de coma flotante y números complejos. Se definen como int, float y clase compleja en Python. Además de eso, los booleanos: verdadero y falso son un subtipo de enteros.
print(type(5))
# Output: <class>
print(type(5.0))
# <class>
c = 5 + 3j
print(type(c))
<class 'int'> <class 'float'> <class 'complex'>
Manejo de excepciones de Python¶
Los errores que se producen en tiempo de ejecución se denominan excepciones. Ocurren, por ejemplo, cuando un archivo que intentamos abrir no existe FileNotFoundError, dividiendo un número por cero ZeroDivisionError, etc.
Si no se manejan las excepciones, se escupe un mensaje de error y nuestro programa se detiene repentinamente e inesperadamente.
En Python, las excepciones se pueden manejar usando la declaración try. Cuando se detectan excepciones, depende de usted qué operador realizar.
# importar modulo sys
import sys
lista_random = ['a', 0, 2]
for elemento in lista_random:
try:
print("La entrada es ", elemento)
r = 1/int(elemento)
break
except:
print("Oops! ocurrio un",sys.exc_info()[0])
print("Siguiente entrada.")
print()
print("El reciproco de",elemento,"es",r)
La entrada es a Oops! ocurrio un <class 'ValueError'> Siguiente entrada. La entrada es 0 Oops! ocurrio un <class 'ZeroDivisionError'> Siguiente entrada. La entrada es 2 El reciproco de 2 es 0.5
Algunas Excepciones Comunes
- NameError: Esta excepción es levantada cuando el programa no puede encontrar un nombre local o global. El nombre que podría no ser encontrado está incluido en el mensaje de error.
- TypeError: Esta excepción es levantada cuando una función se le pasa un objeto del tipo inapropiado como su argumento. Más detalles sobre el tipo incorrecto son proporcionados en el mensaje de error.
- ValueError: Esta excepción ocurre cuando un argumento de función tiene el tipo correcto pero un valor inapropiado.
- NotImplementedError: Esta excepción es levantada cuando se supone que un objeto apoye una operación pero no ha sido implementado aún. No deberías usar este error cuando la función dada no deba apoyar al tipo de argumento de entrada. En esas situaciones, levantar una excepción TypeError es más apropiado.
- ZeroDivisionError: Esta excepción es levantada cuando proporcionas el segundo argumento para una operación de división o módulo como cero.
- FileNotFoundError: Esta excepción es levantada cuando el archivo o diccionario que el programa solicitó no existe.
Aserciones en python¶
Las aserciones son expresiones booleanas que comprueban si las condiciones devuelven verdaderas o no. Si es cierto, el programa no hace nada y pasa a la siguiente línea de código. Sin embargo, si es falso, el programa se detiene y arroja un error.
Las aserciones son importantes al momento de realizar tests unitarios o asegurar que un resultado siempre sea el mismo.
# definir funcion
def suma(x,y):
return x+y
# ejemplo correcto
assert suma(1,1)==2, "ejemplo invalido"
# ejemplo incorrecto
assert suma(1,1)==3, "ejemplo invalido"
--------------------------------------------------------------------------- AssertionError Traceback (most recent call last) Input In [11], in <cell line: 2>() 1 # ejemplo incorrecto ----> 2 assert suma(1,1)==3, "ejemplo invalido" AssertionError: ejemplo invalido
Estructura de datos¶
Listas¶
Se crea una lista colocando todos los elementos (elementos) dentro de un corchete [] separados por comas.
# lista vacia
lista = []
# lista de enteros
lista = [1, 2, 3]
# lista mixta
lista = [1, "hola", 3.4]
También, se pueden acceder a cada uno de sus eleentos
numeros = ["uno", "dos", "tres", "cuatro"]
# acceder al primer elemento
print(numeros[0])
# acceder al cuarto elemento
print(numeros[1:3])
uno ['dos', 'tres']
Tuplas¶
La tupla es similar a una lista, excepto que no puede cambiar los elementos de una tupla una vez que está definida. Mientras que en una lista, los elementos se pueden modificar.
numeros = ("uno", "dos", "tres", "cuatro")
print(numeros)
('uno', 'dos', 'tres', 'cuatro')
numeros = ("uno", "dos", "tres", "cuatro")
print(numeros[1]) #Output: dos
print(numeros[3]) #Output: cuatro
print(numeros[-1]) # Output: cuatro
dos cuatro cuatro
Conjuntos¶
Un conjunto es una colección desordenada de elementos donde cada elemento es único (sin duplicados).
# conjunto de enteros
conjunto = {1, 2, 3}
print(conjunto)
# conjunto mixto
conjunto = {1.0, "hola", (1, 2, 3)}
print(conjunto)
{1, 2, 3}
{1.0, (1, 2, 3), 'hola'}
# conjunto de enteros
conjunto = {1, 2, 3}
conjunto.add(4)
print(conjunto) # Output: {1, 2, 3, 4}
conjunto.add(2)
print(conjunto) # Output: {1, 2, 3, 4}
conjunto.update([3, 4, 5])
print(conjunto) # Output: {1, 2, 3, 4, 5}
conjunto.remove(4)
print(conjunto) # Output: {1, 2, 3, 5}
{1, 2, 3, 4}
{1, 2, 3, 4}
{1, 2, 3, 4, 5}
{1, 2, 3, 5}
Diccionarios¶
Los diccionarios en Python son un tipo de estructuras de datos que permite guardar un conjunto no ordenado de pares clave-valor, siendo las claves únicas dentro de un mismo diccionario (es decir que no pueden existir dos elementos con una misma clave)
# diccionario vacio
dct = {}
# diccionario de enteros
dct = {1: 'apple', 2: 'ball'}
# diccionario dde llaves mixtas
dct = {'name': 'John', 1: [2, 4, 3]}
dct = {'nombre':'Jack', 'edad': 26, 'salario': 4534.2}
print(dct['edad']) # Output: 26
26
dct = {'nombre':'Jack', 'edad': 26}
# cambiar edad
dct['edad'] = 36
print(dct) # Output: {'name': 'Jack', 'age': 36}
# adherir llave salario
dct['salario'] = 4342.4
print(dct) # Output: {'name': 'Jack', 'age': 36, 'salary': 4342.4}
# borrar llave edad
del dct['edad']
print(dct) # Output: {'name': 'Jack', 'salary': 4342.4}
# borrar diccionario
del dct
{'nombre': 'Jack', 'edad': 36}
{'nombre': 'Jack', 'edad': 36, 'salario': 4342.4}
{'nombre': 'Jack', 'salario': 4342.4}
Python range()¶
range() devuelve una secuencia inmutable de números entre el entero de inicio dado al entero de parada.
print(range(1, 10)) # Output: range(1, 10)
range(1, 10)
El resultado es iterable y puede convertirlo en list, tuple, set, etc. Por ejemplo:
numeros = range(1, 6)
print(list(numeros)) # Output: [1, 2, 3, 4, 5]
print(tuple(numeros)) # Output: (1, 2, 3, 4, 5)
print(set(numeros)) # Output: {1, 2, 3, 4, 5}
# Output: {1: 99, 2: 99, 3: 99, 4: 99, 5: 99}
print(dict.fromkeys(numeros, 99))
[1, 2, 3, 4, 5]
(1, 2, 3, 4, 5)
{1, 2, 3, 4, 5}
{1: 99, 2: 99, 3: 99, 4: 99, 5: 99}
Hemos omitido el parámetro de step opcional para range() en los ejemplos anteriores. Cuando se omite, el paso predeterminado es 1. Probemos algunos ejemplos con el parámetro de paso.
numero1 = range(1, 6 , 1)
print(list(numero1)) # Output: [1, 2, 3, 4, 5]
numero2 = range(1, 6, 2)
print(list(numero2)) # Output: [1, 3, 5]
numero3 = range(5, 0, -1)
print(list(numero3)) # Output: [5, 4, 3, 2, 1]
[1, 2, 3, 4, 5] [1, 3, 5] [5, 4, 3, 2, 1]
num = -1
if num > 0:
print("numero positivo")
elif num == 0:
print("cero")
else:
print("numero negativo")
# Output: numero negativo
numero negativo
Puede haber cero o más partes elif, y la parte else es opcional. La mayoría de los lenguajes de programación usan {} para especificar el bloque de código. Python usa sangría.
Un bloque de código comienza con sangría y termina con la primera línea sin sangría. La cantidad de sangría depende de usted, pero debe ser consistente a lo largo de ese bloque. En general, se utilizan cuatro espacios en blanco para la sangría y se prefieren a las pestañas.
Probemos con otro ejemplo:
if False:
print("Hola")
print("mundo")
print("!!!")
# Output: !!!
!!!
While Loop¶
Al igual que la mayoría de los lenguajes de programación, el loop se usa para iterar sobre un bloque de código siempre que la expresión de prueba (condición) sea verdadera. Aquí hay un ejemplo para encontrar la suma de números naturales:
n = 100
# inicializar contador
sum = 0
i = 1
while i <= n:
sum = sum + i
i = i+1 # actualizar contador
print("La suma es", sum)
# Output: La suma es
La suma es 5050
For Loop¶
En Python, for loop se usa para iterar sobre una secuencia (lista, tupla, cadena) u otros objetos iterables. Iterar sobre una secuencia se llama transversal.
Aquí hay un ejemplo para encontrar la suma de todos los números almacenados en una lista.
numbers = [6, 5, 3, 8, 4, 2]
sum = 0
# iterar sobre la lista
for val in numbers:
sum = sum+val
print("La suma es", sum) # Output: La suma es 28
La suma es 28
Break¶
La declaración break termina el ciclo que lo contiene. El control del programa fluye a la declaración inmediatamente después del cuerpo del bucle. Por ejemplo:
for val in "string":
if val == "r":
break
print(val)
print("Fin")
s t Fin
Continue¶
La instrucción continue se usa para omitir el resto del código dentro de un bucle solo para la iteración actual. El bucle no termina pero continúa con la siguiente iteración. Por ejemplo:
for val in "string":
if val == "r":
continue
print(val)
print("Fin")
s t i n g Fin
Pass¶
Supongamos que tiene un bucle o una función que aún no está implementada, pero desea implementarla en el futuro. No pueden tener un cuerpo vacío. El intérprete se quejaría. Por lo tanto, utiliza la instrucción pass para construir un cuerpo que no hace nada.
sequence = {'p', 'a', 's', 's'}
for val in sequence:
pass
Funciones¶
Una función es un grupo de declaraciones relacionadas que realizan una tarea específica. Utiliza la palabra clave def para crear funciones en Python.
def imprimir_lineas():
print("linea 1")
print("linea 2")
# llamar funcion
imprimir_lineas()
linea 1 linea 2
Una función puede aceptar argumentos.
def sumar(a, b):
sum = a + b
return sum
resultado = sumar(4, 5)
print(resultado)
# Output: 9
9
Recursion¶
Una función que se llama a sí misma se conoce como función recursiva y este proceso se llama recursividad. Cada función recursiva debe tener una condición base que detenga la recursividad o, de lo contrario, la función se llama a sí misma infinitamente.
# funcion factorial (recursivo)
def factorial(x):
if x == 1:
return 1
else:
return (x * factorial(x-1))
num = 6
print("El factorial de ", num, "es", factorial(num))
# Output: El factorial de 6 es 720
El factorial de 6 es 720
Lambda¶
En Python, puede definir funciones sin nombre. Estas funciones se denominan lambda o función anónima. Para crear una función lambda, se utiliza la palabra clave lambda.
cuadrado = lambda x: x ** 2
print(cuadrado(5))
# Output: 25
25
Módulos¶
Los módulos se refieren a un archivo que contiene declaraciones y definiciones de Python. Un archivo que contiene código Python, por ejemplo: modulo_01.py, se llama módulo y su nombre de módulo sería un ejemplo.
Permítanos crearlo y guardarlo como modulo_01.py.
%%writefile modulo_01.py
def sumar(a, b):
return a + b
Overwriting modulo_01.py
Para usar este módulo, usamos la palabra clave import.
# importar modulo
import modulo_01
# acceder a las funciones del modulo
modulo_01.sumar(4, 5.5)
9.5
También se pueden exportar módulos nativos de python.
import math
resultado = math.log2(5) # retorna logaritmo base 2
print(resultado) # Output: 2.321928094887362
2.321928094887362
Python tiene una tonelada de módulos estándar fácilmente disponibles para su uso. Por ejemplo:
from math import pi
print("El valor de pi es", pi)
# Output: The value of pi is 3.141592653589793
El valor de pi es 3.141592653589793
Programación orientada a objetos (OOP)¶
Todo en Python es un objeto que incluye enteros, flotantes, funciones, clases y Ninguno. No nos centremos en por qué todo en Python es un objeto. Para eso, visite esta página. Más bien, esta sección se enfoca en crear sus propias clases y objetos.
Clase y objetos¶
El objeto es simplemente una colección de datos (variables) y métodos (funciones) que actúan sobre los datos. Y, la clase es un modelo para el objeto.
Tan pronto como defina una clase, se crea un nuevo objeto de clase con el mismo nombre. Este objeto de clase nos permite acceder a los diferentes atributos, así como crear instancias de nuevos objetos de esa clase.
class Mi_clase:
"Esta es mi clase"
a = 10
def func(self):
print('hola')
# Output: 10
print(Mi_clase.a)
# Output: <function 0x0000000003079bf8="" at="" myclass.func="">
print(Mi_clase.func)
# Output: 'Esta es mi clase'
print(Mi_clase.__doc__)
10 <function Mi_clase.func at 0x10643dca0> Esta es mi clase
Es posible que haya notado el parámetro self en la definición de la función dentro de la clase, pero llamamos al método simplemente como ob.func() sin ningún argumento. Aún funcionó.
Esto se debe a que, cada vez que un objeto llama a su método, el objeto mismo se pasa como primer argumento. Entonces, ob.func() se traduce en Mi_clase.func(ob).
Creando objetos¶
También puede crear objetos de la clase usted mismo.
class Mi_clase:
"Esta es mi clase"
a = 10
def func(self):
print('hola')
obj1 = Mi_clase()
print(obj1.a) # Output: 10
obj2 = Mi_clase()
print(obj1.a + 5) # Output: 15
10 15
Constructores de Python¶
En Python, un método con el nombre init () es un constructor. Este método se llama automáticamente cuando se instancia un objeto.
class NumerosComplejos:
def __init__(self,r = 0,i = 0): # constructor
self.real = r
self.imag = i
def obtener_datos(self):
print("{0}+{1}j".format(self.real,self.imag))
c1 = NumerosComplejos(2,3) # crear el objeto NumerosComplejos
c1.obtener_datos() # Output: 2+3j
c2 = NumerosComplejos() # crear un nuevo objeto NumerosComplejos
c2.obtener_datos() # Output: 0+0j
2+3j 0+0j
Herencia de Python¶
La herencia se refiere a definir una nueva clase con poca o ninguna modificación a una clase existente. Tomemos un ejemplo:
class Mamifero:
def caracteristicas(self):
print ('Mamífero es un animal de sangre caliente')
Derivemos una nueva clase Perro de esta clase Mamifero.
class Mamifero:
def caracteristicas_mamifero(self):
print ('Mamífero es un animal de sangre caliente')
class Perro(Mamifero):
def caracteristicas_perro(self):
print('El perro ladra')
d = Perro()
d.caracteristicas_perro()
d.caracteristicas_mamifero()
El perro ladra Mamífero es un animal de sangre caliente
Decoradores¶
Python tiene una característica interesante llamada decoradores para agregar funcionalidad a un código existente. Esto también se llama metaprogramación ya que una parte del programa intenta modificar otra parte del programa en tiempo de compilación.
def debug(f):
def nueva_funcion(a, b):
print("La funcion Sumar es llamada!!!")
return f(a, b)
return nueva_funcion
@debug # decorador
def Sumar(a, b):
return a + b
print(Sumar(7, 5))
La funcion Sumar es llamada!!! 12