Python: Aprendiendo Python

Una guía completa de Python

👋 ¡Bienvenido a la documentación de Stackhero!

Stackhero ofrece una solución nube de Python lista para usar que proporciona una serie de beneficios, incluyendo:

  • Despliegue su aplicación en segundos con un simple git push.
  • Use su propio nombre de dominio y benefíciese de la configuración automática de certificados HTTPS para una mayor seguridad.
  • Disfrute de la tranquilidad con copias de seguridad automáticas, actualizaciones con un clic, y precios sencillos, transparentes y predecibles.
  • Obtenga un rendimiento óptimo y una seguridad robusta gracias a una VM privada y dedicada.

Ahorre tiempo y simplifique su vida: solo toma 5 minutos probar la solución de alojamiento en la nube de Python de Stackhero.

Esta guía ofrece una visión general de los conceptos y la sintaxis esenciales de Python. Sirve como un repaso rápido para desarrolladores experimentados y una introducción amigable para principiantes. Cubriendo desde tipos de datos básicos hasta características avanzadas, este resumen incluye temas como flujo de control, funciones, clases, objetos y módulos comunes. Manténgalo a mano como referencia rápida mientras trabaja en proyectos de Python. Tenga en cuenta que Python tiene un vasto ecosistema de bibliotecas y frameworks, por lo que explorar recursos y documentación adicionales le ayudará a profundizar en temas especializados.

¡Feliz programación!

Introducción a Python

Python es un lenguaje de programación versátil y de alto nivel creado por Guido van Rossum y lanzado por primera vez en 1991. Es popular por su legibilidad y simplicidad, lo que lo convierte en una excelente opción tanto para principiantes como para desarrolladores experimentados. Python se utiliza ampliamente en desarrollo web, análisis de datos, inteligencia artificial, aprendizaje automático y automatización, entre muchas otras áreas.

Algunos casos de uso comunes de Python incluyen la creación de aplicaciones web utilizando frameworks como Django o Flask, el análisis y visualización de datos con bibliotecas como pandas y matplotlib, y el desarrollo de modelos de aprendizaje automático con herramientas como TensorFlow y scikit-learn.

La extensa biblioteca estándar de Python y su próspero ecosistema de paquetes de terceros lo convierten en un lenguaje poderoso y flexible para abordar una amplia gama de tareas de programación.

Tipos de datos básicos

Los tipos de datos básicos de Python incluyen enteros (números enteros), números de punto flotante (números con decimales), booleanos (valores verdadero/falso) y cadenas (secuencias de caracteres):

  • int: Entero, por ejemplo, 42
  • float: Número de punto flotante, por ejemplo, 3.14
  • bool: Booleano, por ejemplo, True o False
  • str: Cadena, por ejemplo, "hello"

Ejemplo:

integer = 42
floating_point = 3.14
boolean = True
string = "Hello, World!"

Estructuras de datos comunes

Python proporciona varias estructuras de datos para ayudarle a organizar, almacenar y manipular datos de manera eficiente. Las más comúnmente utilizadas son listas, tuplas, diccionarios y conjuntos. Las listas y tuplas mantienen una secuencia ordenada de elementos, los diccionarios almacenan pares clave-valor, y los conjuntos almacenan elementos únicos. Cada estructura viene con una gama de métodos adaptados a casos de uso específicos.

  • Lista: my_list = [1, 2, 3, 4]
  • Tupla: my_tuple = (1, 2, 3, 4)
  • Diccionario: my_dictionary = {'key1': 'value1', 'key2': 'value2'}
  • Conjunto: my_set = {1, 2, 3, 4}

Listas

Las listas son colecciones mutables y ordenadas de elementos. Permiten duplicados y pueden contener elementos de varios tipos de datos, incluidas otras listas, tuplas, diccionarios o conjuntos. Puede agregar, actualizar y eliminar elementos fácilmente. Las listas se definen dentro de corchetes [] con elementos separados por comas.

Puntos clave sobre las listas:

  1. Mutables y ordenadas
  2. Permiten elementos duplicados
  3. Mantienen el orden en que se agregan los elementos
  4. Soportan múltiples tipos de datos
  5. Proporcionan operaciones para agregar, actualizar y eliminar elementos

Las listas se utilizan comúnmente cuando necesita una colección dinámica y redimensionable de elementos.

Ejemplos:

# Crear una lista
my_list = [1, 2, 3, 4, 5]

# Acceder a elementos
print(my_list[0])  # Salida: 1
print(my_list[-1])  # Salida: 5

# Agregar elementos
my_list.append(6)
print(my_list)  # Salida: [1, 2, 3, 4, 5, 6]

# Actualizar elementos
my_list[0] = 0
print(my_list)  # Salida: [0, 2, 3, 4, 5, 6]

# Eliminar elementos
del my_list[0]
print(my_list)  # Salida: [2, 3, 4, 5, 6]

Diccionarios

Los diccionarios son colecciones mutables y no ordenadas de pares clave-valor. Cada clave debe ser única, y puede usar estas claves para acceder a sus valores asociados. Al igual que las listas, los diccionarios pueden almacenar elementos de varios tipos de datos, incluidas colecciones anidadas. Se definen dentro de llaves {} con pares clave-valor separados por comas, y claves y valores separados por dos puntos.

Puntos clave sobre los diccionarios:

  1. Colección mutable y no ordenada
  2. Consisten en pares clave-valor con claves únicas
  3. Acceso a valores usando claves
  4. Almacenan varios tipos de datos

Los diccionarios son ideales para tareas donde necesita realizar búsquedas, como configuraciones o conteos de frecuencia.

Ejemplos:

# Crear un diccionario
my_dictionary = {'a': 1, 'b': 2, 'c': 3}

# Acceder a elementos
print(my_dictionary['a'])  # Salida: 1

# Agregar elementos
my_dictionary['d'] = 4
print(my_dictionary)  # Salida: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# Actualizar elementos
my_dictionary['a'] = 0
print(my_dictionary)  # Salida: {'a': 0, 'b': 2, 'c': 3, 'd': 4}

# Eliminar elementos
del my_dictionary['a']
print(my_dictionary)  # Salida: {'b': 2, 'c': 3, 'd': 4}

Tuplas

Las tuplas son colecciones inmutables y ordenadas de elementos. Funcionan de manera similar a las listas, excepto que una vez creada una tupla, sus elementos no pueden ser cambiados, añadidos o eliminados. Las tuplas se definen usando paréntesis () con elementos separados por comas.

Puntos clave sobre las tuplas:

  1. Colección inmutable y ordenada
  2. Soportan múltiples tipos de datos
  3. Estructura de tamaño fijo

Las tuplas son útiles cuando necesita una colección inmutable, o cuando desea usar la colección como clave de diccionario.

Ejemplo:

# Crear una tupla
my_tuple = (1, 2, 3, 4, 5)

# Acceder a elementos
print(my_tuple[0])  # Salida: 1
print(my_tuple[-1])  # Salida: 5

# Nota: Las tuplas son inmutables

Conjuntos

Los conjuntos son colecciones mutables y no ordenadas que almacenan elementos únicos. Eliminan automáticamente los duplicados y no mantienen un orden. Los conjuntos pueden contener elementos de varios tipos de datos, excluyendo tipos mutables como listas y diccionarios. Pueden definirse usando llaves {} o el constructor set().

Puntos clave sobre los conjuntos:

  1. Mutables y no ordenados
  2. Almacenan solo elementos únicos, eliminando automáticamente duplicados
  3. Excluyen tipos mutables (como listas y diccionarios)

Los conjuntos son ideales para pruebas de pertenencia, deduplicación y realizar operaciones de conjunto como unión, intersección y diferencia.

# Crear un conjunto
my_set = {1, 2, 3, 4, 5}

# Comprobar pertenencia
print(1 in my_set)  # Salida: True

# Agregar un elemento
my_set.add(6)
print(my_set)  # Salida: {1, 2, 3, 4, 5, 6}

# Actualizar eliminando un elemento y agregando otro
my_set.remove(1)
my_set.add(0)
print(my_set)  # Salida: {0, 2, 3, 4, 5, 6}

# Eliminar un elemento
my_set.remove(0)
print(my_set)  # Salida: {2, 3, 4, 5, 6}

Instrucciones condicionales: if, elif, else

Las instrucciones condicionales le permiten ejecutar código en función de si una condición es verdadera o falsa.

if condition1:
  # hacer algo
elif condition2:
  # hacer otra cosa
else:
  # hacer otra cosa más

Ejemplo:

x = 42

if x > 50:
  print("x es mayor que 50")
elif x < 50:
  print("x es menor que 50")
else:
  print("x es igual a 50")

Bucle for

Los bucles for iteran sobre una secuencia, como una lista o un rango, ejecutando un bloque de código para cada elemento.

Ejemplo:

for i in range(5):
  print(i)

Bucle while

Los bucles while ejecutan un bloque de código mientras una condición especificada sea verdadera.

Ejemplo:

i = 0
while i < 5:
  print(i)
  i += 1

Funciones

Las funciones encapsulan código en bloques reutilizables que pueden aceptar entradas (argumentos) y devolver salidas. Se definen usando la palabra clave def y pueden ser llamadas por su nombre.

def function_name(argument1, argument2=default_value):
  # hacer algo
  return result

Ejemplo:

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

result = add(3, 4)
print(result)  # Salida: 7

Funciones lambda

Las funciones lambda, también conocidas como funciones anónimas, son funciones concisas de una sola expresión creadas usando la palabra clave lambda. Se utilizan comúnmente para operaciones cortas, a menudo como argumentos para funciones como map(), filter(), o sorted().

lambda arguments: expression

Ejemplo:

add = lambda a, b: a + b
result = add(3, 4)
print(result)  # Salida: 7

Comprensiones de listas

Las comprensiones de listas le permiten crear listas en una sola línea legible combinando una expresión con un bucle y una condición opcional. Son excelentes para transformar o filtrar datos.

new_list = [expression for item in iterable if condition]

Ejemplo:

squares = [x * x for x in range(1, 6)]
print(squares)  # Salida: [1, 4, 9, 16, 25]

Manejo de excepciones

El manejo de excepciones permite que su programa gestione errores de ejecución de manera elegante. Python proporciona los bloques try, except, y finally para capturar y manejar excepciones, asegurando que su programa continúe o salga suavemente.

try:
    # código que puede generar una excepción
except ExceptionType as error_variable:
    # manejar la excepción
finally:
    # código a ejecutar independientemente de si ocurrió una excepción

Ejemplo:

try:
  result = 10 / 0
except ZeroDivisionError:
  print("¡No se puede dividir por cero!")

Clases y objetos

Las clases definen planos para crear objetos en programación orientada a objetos (OOP). Los objetos son instancias de una clase con atributos (datos) y métodos (funciones) que realizan tareas específicas. La OOP promueve un código estructurado, reutilizable y mantenible.

class ClassName:
  def __init__(self, attribute1, attribute2):
    self.attribute1 = attribute1
    self.attribute2 = attribute2

  def method_name(self, argument1):
    # hacer algo
    return result

Ejemplo:

class Dog:
  def __init__(self, name, age):
    self.name = name
    self.age = age

  def bark(self):
    print("Woof!")

# Crear una instancia de Dog
dog1 = Dog("Buddy", 3)
dog1.bark()  # Salida: Woof!

Importación de módulos

Los módulos son archivos separados que contienen código Python como funciones, clases o variables. Importar módulos le permite extender la funcionalidad de su programa utilizando bibliotecas y frameworks externos.

import module_name
from module_name import specific_function_or_class

Ejemplo:

import math
print(math.sqrt(16))  # Salida: 4.0

Entrada/Salida de archivos

La entrada/salida (I/O) de archivos cubre la lectura y escritura de archivos en Python. Esto es esencial al trabajar con almacenamiento y recuperación de datos.

Lectura de un archivo

with open('filename.txt', 'r') as file:
  content = file.read()

Escritura en un archivo

with open('filename.txt', 'w') as file:
  file.write('contenido a escribir en el archivo')

Gestores de contexto

Los gestores de contexto ayudan a gestionar recursos, como archivos o conexiones de red, asegurando que se adquieran y liberen correctamente. Usar un gestor de contexto asegura que su código sea más limpio y tolerante a fallos.

with resource as alias:
  # usar resource como alias

Ejemplo:

with open('file.txt', 'r') as file:
  content = file.read()
  print(content)  # Salida: Hello, World!

Decoradores

Los decoradores le permiten extender o modificar el comportamiento de funciones o clases sin cambiar su código fuente. Envueltan otra función y añaden alguna funcionalidad antes o después de que se ejecute la función envuelta.

def decorator_function(func):
  def wrapper(*args, **kwargs):
    # hacer algo antes de llamar a la función
    result = func(*args, **kwargs)
    # hacer algo después de llamar a la función
    return result
  return wrapper

@decorator_function
def my_function():
  # hacer algo

Ejemplos:

def greet_decorator(func):
  def wrapper(name):
    return "Hello, " + func(name) + "!"
  return wrapper

@greet_decorator
def get_name(name):
  return name

print(get_name("John"))  # Salida: Hello, John!

Módulo Itertools

El módulo itertools proporciona funciones para crear y trabajar con iteradores. Incluye iteradores infinitos (como count, cycle y repeat), iteradores finitos (como accumulate, chain, compress), e iteradores combinatorios (como product, permutations y combinations).

Ejemplo:

import itertools

for i in itertools.count(5, 5):
  if i > 20:
    break
  print(i)  # Salida: 5, 10, 15, 20

Módulo Collections

El módulo collections ofrece tipos de contenedores especializados que pueden mejorar sus programas.

from collections import namedtuple, defaultdict, Counter, deque

Ejemplos:

from collections import namedtuple, deque, Counter, OrderedDict, defaultdict

# namedtuple
Person = namedtuple('Person', 'name age')
person1 = Person("Alice", 30)
print(person1.name, person1.age)  # Salida: Alice 30

# deque
dq = deque([1, 2, 3, 4, 5])
dq.append(6)
dq.appendleft(0)
print(dq)  # Salida: deque([0, 1, 2, 3, 4, 5, 6])

# Counter
count = Counter("hello world")
print(count)  # Salida: Counter({'l': 3, 'o': 2, 'h': 1, 'e': 1, ' ': 1, 'w': 1, 'r': 1, 'd': 1})

# OrderedDict
od = OrderedDict()
od['a'] = 1
od['b'] = 2
od['c'] = 3
print(od)  # Salida: OrderedDict([('a', 1), ('b', 2), ('c', 3)])

# defaultdict
dd = defaultdict(int)
dd['a'] += 1
dd['b'] += 2
print(dd)  # Salida: defaultdict(<class 'int'>, {'a': 1, 'b': 2})

Expresiones regulares

Las expresiones regulares permiten un procesamiento y manipulación de texto potentes. El módulo re proporciona funciones como match, search, findall, finditer, split y sub.

Ejemplo:

import re

pattern = r'\d+'
result = re.findall(pattern, "There are 10 cats and 5 dogs.")
print(result)  # Salida: ['10', '5']

Fechas y horas

Trabajar con fechas y horas es un requisito común, especialmente para análisis de datos o tareas de programación. El módulo datetime proporciona clases y funciones para trabajar con fechas, horas e intervalos.

import datetime

# datetime, date, time, timedelta, timezone

Ejemplos:

from datetime import datetime, timedelta

# Fecha y hora actuales
current_time = datetime.now()
print("Fecha y hora actuales:", current_time)

# Fecha y hora personalizadas
custom_date = datetime(2022, 12, 31, 23, 59, 59)
print("Fecha y hora personalizadas:", custom_date)

# Convertir cadena a datetime
date_str = "2023-01-01 00:00:00"
date_obj = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
print("Cadena a datetime:", date_obj)

# Convertir datetime a cadena
date_str2 = date_obj.strftime("%Y-%m-%d %H:%M:%S")
print("Datetime a cadena:", date_str2)

# Aritmética de fechas y horas
one_day = timedelta(days=1)
yesterday = current_time - one_day
tomorrow = current_time + one_day
print("Ayer:", yesterday)
print("Mañana:", tomorrow)

Corte de listas

El corte de listas le permite extraer una porción de una lista u otro tipo de secuencia especificando valores de inicio, fin y paso opcional. Esta característica es muy útil para extraer sub-secuencias.

my_list[start:end:step]

Ejemplo:

my_list = [0, 1, 2, 3, 4, 5]
sub_list = my_list[1:4]
print(sub_list)  # Salida: [1, 2, 3]

Formateo de cadenas

El formateo de cadenas es el proceso de combinar texto estático con valores dinámicos. Python ofrece varios métodos de formateo, incluyendo el formateo con %, el método str.format(), y las f-strings (Python 3.6+), que le permiten generar fácilmente cadenas formateadas.

Formateo con %

print("Hello, %s" % name)

str.format

print("Hello, {}".format(name))

f-strings (Python 3.6+)

print(f"Hello, {name}")

Ejemplo:

name = "John"
age = 30
formatted_string = f"My name is {name} and I am {age} years old."
print(formatted_string)  # Salida: My name is John and I am 30 years old.

Argumentos de línea de comandos

Los argumentos de línea de comandos le permiten pasar valores de entrada a un script de Python al ejecutarlo desde la línea de comandos. La lista sys.argv proporciona acceso a estos argumentos, facilitando su análisis y uso dentro de su script.

import sys

arguments = sys.argv

Ejemplo:

# Guarde este código en un archivo llamado "cmd_args.py"
# Ejecute con: python cmd_args.py Alice
# Salida esperada: Hello, Alice!
import sys

if len(sys.argv) > 1:
  print(f"Hello, {sys.argv[1]}!")
else:
  print("No se proporcionaron argumentos.")

Other articles for Python