Python para niños

Datos para niños Python
Desarrollador(es)
Python Software Foundation Sitio web oficial
Información general
Extensiones comunes	.py, .pyc, .pyd, .pyo, .pyw, .pyz, .pyi
Paradigma	Multiparadigma: orientado a objetos, imperativo, funcional, reflexivo
Apareció en	20 de febrero de 1991
Diseñado por	Guido van Rossum
Última versión estable	3.13.5 (11 de junio de 2025 (26 días))
Última versión en pruebas	3.14.0b2 (26 de mayo de 2025 (1 mes y 12 días))
Sistema de tipos	duck, dinámico, fuerte;
Implementaciones	CPython, IronPython, Jython, Python for S60, PyPy, ActivePython, Unladen Swallow
Dialectos	Stackless Python, RPython
Influido por	ABC, ALGOL 68, C, Haskell, Icon, Lisp, Modula-3, Perl, Smalltalk, Java
Ha influido a	Boo, Cobra, D, Falcon, Genie, Groovy, Ruby, JavaScript, Cython, Go Latino
Sistema operativo	Multiplataforma
Licencia	Python Software Foundation License

Python es un lenguaje de programación muy popular y fácil de usar. Se le llama un lenguaje de "alto nivel" porque se parece más al lenguaje humano que al de las máquinas. Su diseño busca que el código sea muy fácil de leer y entender.

Python es un lenguaje multiparadigma. Esto significa que permite diferentes estilos de programación. Por ejemplo, puedes usar la programación orientada a objetos o la programación imperativa. Es un lenguaje interpretado, lo que significa que un programa especial lo traduce a la vez que lo ejecuta. También es dinámico (los tipos de datos se verifican mientras el programa corre) y multiplataforma (funciona en diferentes sistemas operativos).

La Python Software Foundation se encarga de Python. Tiene una licencia de código abierto, lo que significa que cualquiera puede usarlo y modificarlo. Python es uno de los lenguajes de programación más usados en el mundo.

Historia de Python: ¿Cómo Nació?

Guido van Rossum, el creador de Python.

Python fue creado a finales de los años ochenta por Guido van Rossum. Él trabajaba en un centro de investigación en los Países Bajos. Quería un lenguaje que fuera el sucesor de otro llamado ABC. Este nuevo lenguaje debía poder manejar errores y comunicarse con un sistema operativo llamado Amoeba.

El nombre "Python" viene del gusto de su creador por el grupo de comediantes británicos Monty Python.

Guido van Rossum fue la persona principal que decidió el rumbo de Python por mucho tiempo. Se le conocía como el "Benevolente Dictador Vitalicio". Sin embargo, en 2018, decidió dejar ese puesto.

El 20 de febrero de 1991, van Rossum publicó el código de Python por primera vez. Ya en esa primera versión, Python tenía características importantes. Por ejemplo, podía usar "clases" (para organizar el código) y manejar errores. También tenía tipos de datos como texto, listas y diccionarios.

En 1994, se creó un foro de discusión para Python. Esto ayudó a que más personas empezaran a usar y aprender el lenguaje.

Python llegó a su versión 1.0 en enero de 1994. En esta versión se añadieron herramientas para la programación funcional. Guido van Rossum explicó que estas herramientas fueron añadidas por un programador que las echaba de menos de otro lenguaje.

Después de trabajar en el CWI, van Rossum continuó desarrollando Python en otra organización en Estados Unidos. Allí, lanzó la iniciativa "Programación de Computadoras para Todos". Su objetivo era que más personas pudieran aprender a programar. Python era perfecto para esto por su sintaxis clara y fácil de entender. Aunque el proyecto ya no está activo, Python sigue siendo un lenguaje fácil de aprender.

En el año 2000, el equipo de desarrolladores de Python se unió a una nueva empresa. Python 2.0 fue la primera versión lanzada por este nuevo equipo. Esta versión incluyó una característica importante llamada "listas por comprensión". También mejoró la forma en que el lenguaje gestiona la memoria.

Más tarde, la licencia de Python se hizo compatible con otras licencias de software libre. Esto permitió que más personas pudieran usar Python en sus proyectos. En 2001, se creó la Python Software Foundation (PSF). Esta organización sin fines de lucro se encarga de dirigir el proyecto Python.

Python 2.7.x, la última versión de la serie Python 2, dejó de recibir soporte el 1 de enero de 2020. Esto significa que ya no se publican actualizaciones de seguridad para ella. Ahora, solo las versiones de Python 3.6.x y posteriores tienen soporte.

Con Python 3.5, se añadió soporte para la programación asíncrona. Esto es útil para aplicaciones que necesitan ser muy rápidas, como los servidores web.

¿Qué Novedades Traen las Últimas Versiones de Python 3?

Las versiones recientes de Python 3.x han traído muchas mejoras:

Python 3.6 (2016)

• Cadenas formateadas (f-strings): Una forma más sencilla de incluir variables en el texto.
• Guiones bajos en números: Ayuda a leer números grandes, como 1_000_000.
• Anotaciones de variables: Permite indicar qué tipo de datos se espera en una variable.
• Generadores asíncronos: Hacen que el código asíncrono sea más claro.

Python 3.7 (2018)

• Módulo dataclasses: Facilita la creación de clases que solo guardan datos.
• Módulo contextvars: Útil para manejar variables en programas asíncronos.
• Mejoras en asyncio: Más funciones y optimizaciones para la programación asíncrona.

Python 3.8 (2019)

• Operador de asignación (:=): Permite asignar valores a variables dentro de una expresión.
• Parámetros posicionales-only: Permite que algunas funciones solo acepten argumentos en un orden específico.

Python 3.9 (2020)

• Operadores para diccionarios: Nuevas formas de combinar y actualizar diccionarios.
• Soporte para tipos genéricos: Simplifica la especificación de tipos en listas o diccionarios.

Python 3.10 (2021)

• Estructuras `match` y `case`: Una forma avanzada de comparar valores y ejecutar código según el caso.
• Mensajes de error mejorados: Ayudan a encontrar y corregir errores más fácilmente.

Python 3.11 (2022)

• Mayor rendimiento: Python 3.11 es mucho más rápido que las versiones anteriores.
• Grupos de excepciones: Permite manejar varios tipos de errores al mismo tiempo.
• Módulo tomllib: Añade soporte para leer archivos TOML.
• Rastreos de errores más precisos: Indican el lugar exacto donde ocurrió un error.

Hoy en día, Python se usa mucho en campos como la inteligencia artificial y el machine learning (aprendizaje automático).

¿Qué Hace a Python Especial?

Python es un lenguaje multiparadigma. Esto significa que no te obliga a programar de una sola manera. Puedes usar diferentes estilos, como la programación orientada a objetos o la programación imperativa.

Python gestiona la memoria de forma automática. También es fácil de extender. Puedes añadirle nuevas partes escritas en otros lenguajes como C o C++. Esto hace que Python sea muy flexible.

La Filosofía de Python: "Lo Pythónico"

Los usuarios de Python a menudo hablan de su filosofía. Es similar a la filosofía de Unix, que busca la simplicidad y la claridad. El código que sigue estos principios se considera "pythónico". Estos principios fueron escritos por el desarrollador Tim Peters en un texto llamado "El Zen de Python":

• Bello es mejor que feo.
• Explícito es mejor que implícito.
• Simple es mejor que complejo.
• Complejo es mejor que complicado.
• La legibilidad cuenta.
• Debería haber una —y preferiblemente solo una— manera obvia de hacerlo.
• Ahora es mejor que nunca.

Tim Peters, El Zen de Python

Desde la versión 2.1.2, Python incluye estos puntos. Puedes verlos si escribes `import this` en el intérprete de Python.

Python es parte de la pila de software LAMP.

Modo Interactivo de Python

El programa principal de Python tiene un "modo interactivo". Aquí puedes escribir instrucciones una por una y ver el resultado al instante. Es como un intérprete de comandos. Esto es muy útil para aprender el lenguaje o para probar pequeñas partes de código.

Existen otros programas como IDLE o IPython que mejoran este modo interactivo. Añaden funciones como el autocompletado de código y el coloreado de la sintaxis.

Ejemplo del modo interactivo:

>>>  1 + 1
     2
>>>  a = range(10)
>>>  print(list(a))
     [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Elementos del Lenguaje y Sintaxis

Python está diseñado para ser fácil de leer. Su formato es muy ordenado. A menudo usa palabras en inglés en lugar de símbolos. Por ejemplo, los operadores lógicos `!` (no), `||` (o) y `&&` (y) en Python se escriben `not`, `or` y `and`.

A diferencia de otros lenguajes, Python no usa corchetes `{}` para agrupar bloques de código. En su lugar, usa la sangría (espacios o tabuladores) al principio de cada línea. Es importante usar la sangría correctamente, ya que Python la usa para entender la estructura del código.

int factorial(int x)
{
    if (x < 0 || x % 1 != 0) {
        printf("x debe ser un numero entero mayor o igual a 0");
        return -1; // Error
    }
    if (x == 0) {
        return 1;
    }
    return x * factorial(x - 1);
}

def factorial(x):
    assert x >= 0 and x % 1 == 0, "x debe ser un entero mayor o igual a 0."
    if x == 0:
        return 1
    else:
        return x * factorial(x - 1)

Cada instrucción en Python debe ir en una sola línea. Si una instrucción es muy larga, puedes dividirla en varias líneas usando una barra invertida `\` al final de la línea.

Estas instrucciones son equivalentes:

  lista = ['valor 1', 'valor 2', 'valor 3']
  cadena = 'Esto es una cadena bastante larga'

  lista = ['valor 1', 'valor 2' \
          , 'valor 3']
  cadena = 'Esto es una cadena ' \
           'bastante larga'

Comentarios: Notas en tu Código

Puedes añadir comentarios a tu código para explicar lo que hace. Los comentarios no son leídos por el programa, solo son para que los humanos entiendan mejor.

Hay dos formas de hacer comentarios:

• Para comentarios largos, usa tres apóstrofos al principio y al final: ` comentario `.
• Para comentarios de una sola línea, usa el símbolo `#`: `# Esto es un comentario`.

'''
Comentario más largo en una línea en Python
'''
print("Hola mundo")  # También es posible añadir un comentario al final de una línea de código

Variables: Guardando Información

Las variables en Python se definen de forma dinámica. Esto significa que no necesitas decir qué tipo de información guardarán (números, texto, etc.) de antemano. Una variable puede guardar un número y luego, más tarde, guardar un texto. Para asignar un valor a una variable, se usa el símbolo `=`.

x = 1
x = "texto"  # Esto es posible porque los tipos son asignados dinámicamente

Los nombres de las variables pueden contener letras y números, pero deben empezar con una letra. Hay 35 palabras que Python tiene reservadas para su propio uso y no pueden ser nombres de variables:

A partir de Python 3.10, también existen "palabras clave suaves". Estas son palabras que son reservadas en algunos casos, pero que normalmente puedes usar como nombres de variables. Son `match`, `case` y `_`.

Tipos de Datos: ¿Qué Tipo de Información Guardas?

Jerarquía de los tipos básicos en Python 3.

Python maneja diferentes tipos de datos. Aquí tienes algunos de los más comunes:

• Mutable: Significa que su contenido se puede cambiar después de crearlo.
• Inmutable: Significa que su contenido no se puede cambiar después de crearlo.

Condicionales: Tomando Decisiones

Una sentencia condicional permite que tu programa tome decisiones. Ejecuta un bloque de código solo si se cumple una condición. Se usa la palabra clave `if`. Si hay más condiciones, se usa `elif`. Si ninguna condición se cumple, se ejecuta el bloque `else` (si existe).

>>> verdadero = True
>>> if verdadero:  # No es necesario poner "verdadero == True"
...     print("Verdadero")
... else:
...     print("Falso")
...
    Verdadero
>>> lenguaje = "Python"
>>> if lenguaje == "C":  # lenguaje no es "C", por lo que este bloque se obviará y evaluará la siguiente condición
...     print("Lenguaje de programación: C")
... elif lenguaje == "Python":  # Se pueden añadir tantos bloques "elif" como se quiera
...     print("Lenguaje de programación: Python")
... else:  # En caso de que ninguna de las anteriores condiciones fuera cierta, se ejecutaría este bloque
...     print("Lenguaje de programación: indefinido")
...
    Lenguaje de programación: Python
>>> if verdadero and lenguaje == "Python":  # Uso de "and" para comprobar que ambas condiciones son verdaderas
...     print("Verdadero y Lenguaje de programación: Python")
...
    Verdadero y Lenguaje de programación: Python

Bucle `for`: Repitiendo Tareas

El bucle `for` te permite recorrer elementos de una lista, tupla o cadena. Por cada elemento, ejecuta un bloque de código. Se define con `for`, seguido de un nombre de variable, `in`, y el objeto que quieres recorrer.

>>> lista = ["a", "b", "c"]
>>> for i in lista:  # Recorremos una lista
...     print(i)
...
    a
    b
    c
>>> cadena = "abcdef"
>>> for i in cadena:  # Recorremos una cadena
...     print(i, end=', ')  # Añadiendo end=', ' al final hacemos que no introduzca un salto de línea, sino una coma y un espacio
...
    a, b, c, d, e, f,

Bucle `while`: Repitiendo Mientras una Condición Sea Verdadera

El bucle `while` repite un bloque de código mientras una condición sea verdadera. Se define con `while`, seguido de la condición.

>>> numero = 0
>>> while numero < 10:
...     print(numero, end=" ")
...     numero += 1  # Es importante cambiar la variable de control para que el bucle no sea infinito
...
    0 1 2 3 4 5 6 7 8 9

Listas y Tuplas: Colecciones de Elementos

• Las listas se crean con corchetes `[]`. Las tuplas se crean con paréntesis `()`.
• Ambas pueden guardar elementos de diferentes tipos.
• Puedes acceder a los elementos usando un número de índice (empezando por 0). Los índices negativos cuentan desde el final.
• Las listas son mutables (puedes cambiar su contenido). Las tuplas son inmutables (no puedes cambiar su contenido una vez creadas).

Listas

>>> lista = ["abc", 42, 3.1415]
>>> lista[0]  # Acceder al primer elemento
    'abc'
>>> lista[-1]  # Acceder al último elemento
    3.1415
>>> lista.append(True)  # Añadir un elemento al final
>>> lista
    ['abc', 42, 3.1415, True]
>>> del lista[3]  # Borrar un elemento
>>> lista[0] = "xyz"  # Cambiar el valor del primer elemento
>>> lista[0:2]  # Mostrar elementos del índice 0 al 1
    ['xyz', 42]
>>> lista_anidada = [lista, [True, 42]] # Puedes tener listas dentro de listas
>>> lista_anidada
    [['xyz', 42, 3.1415], [True, 42]]
>>> lista_anidada[1][0]  # Acceder a un elemento de una lista anidada
    True

Tuplas

>>> tupla = ("abc", 42, 3.1415)
>>> tupla[0]  # Acceder al primer elemento
    'abc'
>>> del tupla[0]  # No puedes borrar elementos de una tupla (dará un error)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'tuple' object doesn't support item deletion
>>> tupla[0] = "xyz"  # No puedes cambiar elementos de una tupla (dará un error)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: 'tuple' object does not support item assignment
>>> tupla[0:2]  # Mostrar elementos del índice 0 al 1
    ('abc', 42)
>>> tupla_anidada = (tupla, (True, 3.1415))  # Puedes tener tuplas dentro de tuplas
>>> 1, 2, 3, "abc"  # Esto también es una tupla
    (1, 2, 3, 'abc')
>>> (1)  # Esto NO es una tupla, es solo el número 1
    1
>>> (1,)  # Esto SÍ es una tupla de un solo elemento (nota la coma)
    (1,)

Diccionarios: Guardando Información con Nombres

• Los diccionarios se crean con llaves `{}`. Guardan pares de `clave:valor`.
• Son mutables (puedes cambiar sus valores).
• Las claves deben ser inmutables (no pueden ser listas o diccionarios).
• Los valores pueden ser de cualquier tipo.

>>> diccionario = {"cadena": "abc", "numero": 42, "lista": [True, 42]}  # Diccionario con diferentes tipos de valores
>>> diccionario["cadena"]  # Acceder a un valor usando su clave
    'abc'
>>> diccionario["lista"][0]  # Acceder a un elemento de una lista dentro de un diccionario
    True
>>> diccionario["cadena"] = "xyz"  # Cambiar el valor de una clave
>>> diccionario["cadena"]
    'xyz'
>>> diccionario["decimal"] = 3.1415927  # Añadir un nuevo par clave:valor
>>> diccionario["decimal"]
    3.1415927
>>> diccionario_mixto = {"tupla": (True, 3.1415), "diccionario": diccionario}  # Un valor puede ser otro diccionario
>>> diccionario_mixto["diccionario"]["lista"][1]  # Acceder a un elemento dentro de un diccionario anidado
    42
>>> diccionario = {("abc",): 42}  # Una tupla puede ser una clave (es inmutable)
>>> diccionario = {["abc"]: 42}  # Una lista NO puede ser una clave (es mutable, dará un error)
    Traceback (most recent call last):
       File "<stdin>", line 1, in <module>
     TypeError: unhashable type: 'list'

Sentencia `match-case`: Decisiones Avanzadas

Python 3.10 introdujo la estructura `match-case`, también conocida como "Structural Pattern Matching". Es una forma más potente de tomar decisiones que el `if-elif-else` tradicional.

match variable:
        case condicion:
                # codigo
        case condicion:
                # codigo
        case condicion:
                # codigo
        case _:
                # codigo

Esta función no solo compara valores, sino que también puede verificar el tipo de un objeto y sus características. Puede incluso "desempaquetar" datos de secuencias.

En este ejemplo, se comprueban las características de un objeto `Punto`. Si no se cumple que `x = 10` y `y = 40`, se pasa a la siguiente condición.

from dataclasses import dataclass

@dataclass
class Punto:
        x: int
        y: int

coordenada = Punto(10, 34)

match coordenada:
        case Punto(x=10, y=40):  # si los atributos "x" e "y" tienen el valor especificado
                print("Coordenada 10, 40")
        case Punto():  # si es una instancia de Punto
                print("es un punto")
        case _:  # si ninguna condición se cumple
                print("No es un punto")

Para versiones anteriores de Python, se pueden usar `if`, `elif`, `else` o diccionarios para lograr efectos similares.

Usando `if`, `elif`, `else`

>>> if condicion1:
...     hacer1
>>> elif condicion2:
...     hacer2
>>> elif condicion3:
...     hacer3
>>> else:
...     hacer

Un ejemplo práctico:

>>> def calculo(op, a, b):
...     if op == 'sum':
...          return a + b
...     elif op == 'rest':
...          return a - b
...     elif op == 'mult':
...         return a * b
...     elif op == 'div':
...         return a / b
...     else:
...          return None
>>>
>>> print(calculo('sum',3,4))
    7

Usando Diccionarios para Decisiones

Puedes usar un diccionario para elegir una acción. Esto es útil si tienes muchas opciones.

>>> def calculo(op, a, b):
...     return {
...         'sum': lambda: a + b,
...         'rest': lambda: a - b,
...         'mult': lambda: a * b,
...         'div': lambda: a/b
...     }.get(op, lambda: None)()
>>>
>>> print(calculo('sum',3,4))
    7

En este caso, el diccionario guarda funciones. Cuando se llama a `.get()`, se obtiene la función deseada y se ejecuta.

Conjuntos: Colecciones sin Duplicados

• Los conjuntos se crean con `set(items)`. No guardan el orden y no permiten elementos repetidos.
• Son útiles para quitar duplicados o para operaciones matemáticas como la intersección (elementos comunes) o la unión (todos los elementos).

>>> conjunto_inmutable = frozenset(["a", "b", "a"])  # Conjunto que no se puede cambiar
>>> conjunto_inmutable
    frozenset(['a', 'b'])
>>> conjunto1 = set(["a", "b", "a"])  # Primer conjunto que sí se puede cambiar
>>> conjunto1
    set(['a', 'b'])
>>> conjunto2 = set(["a", "b", "c", "d"])  # Segundo conjunto que sí se puede cambiar
>>> conjunto2
    set(['a', 'c', 'b', 'd'])  # Los conjuntos no mantienen el orden
>>> conjunto1 & conjunto2  # Intersección (elementos en ambos)
    set(['a', 'b'])
>>> conjunto1 | conjunto2  # Unión (todos los elementos)
    set(['a', 'c', 'b', 'd'])
>>> conjunto1 - conjunto2  # Diferencia (elementos en conjunto1 pero no en conjunto2)
    set([])
>>> conjunto2 - conjunto1  # Diferencia (elementos en conjunto2 pero no en conjunto1)
    set(['c', 'd'])
>>> conjunto1 ^ conjunto2  # Diferencia simétrica (elementos que están en uno o en otro, pero no en ambos)
    set(['c', 'd'])

Listas por Comprensión: Creando Listas de Forma Rápida

Una "lista por comprensión" es una forma corta de crear listas. Es muy útil para generar listas basadas en otras listas o rangos.

>>> range(5)  # La función range crea una secuencia de números del 0 al 4
    [0, 1, 2, 3, 4]
>>> [i * i for i in range(5)]  # Por cada número, lo multiplica por sí mismo y lo añade a la nueva lista
    [0, 1, 4, 9, 16]
>>> lista = [(i, i + 2) for i in range(5)]
>>> lista
    [(0, 2), (1, 3), (2, 4), (3, 5), (4, 6)]

Funciones: Bloques de Código Reutilizables

• Las funciones se definen con la palabra clave `def`. Sirven para agrupar código que quieres usar varias veces.
• Pueden recibir "parámetros" (información de entrada) y devolver un "valor" (resultado) con la instrucción `return`.
• `*args` permite que una función reciba un número variable de argumentos.
• `**kwargs` permite que una función reciba un número variable de argumentos con nombre.

`def`:

>>> def suma(x, y=2):
...     return x + y  # Devuelve la suma de x e y
...
>>> suma(4)  # y usa su valor predeterminado (2)
    6
>>> suma(4, 10)  # y usa el nuevo valor (10)
    14

`*args`:

>>> def suma(*args):
...    resultado = 0
...    # Recorre todos los argumentos que se le pasen
...    for num in args:
...        resultado += num #  Suma todos los argumentos
...    return resultado  # Devuelve el resultado de la suma
...
>>> suma(2, 4)
    6
>>> suma(1, 3, 5, 7, 9)  # Puedes pasarle cualquier cantidad de números
    25

`**kwargs`:

def suma(**kwargs):
...    resultado = 0
...    # Recorre el diccionario de argumentos con nombre
...    for key, value in kwargs.items():
...        resultado += value  # Suma todos los valores
...    return resultado
...
>>> suma(x=1, y=3)
    4
>>> suma(x=2, y=4, z=6)  # Puedes pasarle cualquier cantidad de argumentos con nombre
    12

`lambda`:

>>> suma = lambda x, y=2: x + y
>>> suma(4)
    6
>>> suma(4, 10)
    14

Clases: Creando tus Propios Tipos de Objetos

• Las clases se definen con la palabra clave `class`. Son como "moldes" para crear objetos.
• Un método en una clase es como una función. Un atributo es como una variable.
• `__init__` es un método especial que se ejecuta cuando creas un objeto de esa clase. Se usa para configurar los atributos iniciales.
• Los atributos que quieres que sean accesibles desde fuera de la clase deben llevar `self.` delante del nombre.

>>> class Persona():
...     def __init__(self, nombre, edad):
...         self.nombre = nombre  # Un atributo para el nombre
...         self.edad = edad  # Otro atributo para la edad
...     def mostrar_edad(self):  # Un método para mostrar la edad
...         print(self.edad)
...     def modificar_edad(self, edad):  # Un método para cambiar la edad de forma controlada
...         if 0 > edad < 150:  # Comprueba que la edad sea razonable
...             return False
...         else:
...             self.edad = edad  # Cambia la edad
...
>>> p = Persona('Alicia', 20)  # Creamos un objeto "Persona" llamado p
>>> p.nombre  # Accedemos al nombre del objeto
    'Alicia'
>>> p.nombre = 'Andrea'  # Cambiamos el nombre
>>> p.nombre
    'Andrea'
>>> p.mostrar_edad()  # Llamamos al método para mostrar la edad
    20
>>> p.modificar_edad(21)  # Cambiamos la edad usando el método
>>> p.mostrar_edad()
    21

Módulos: Añadiendo Funcionalidades a Python

Python puede hacer muchas cosas gracias a los módulos. Un módulo es un conjunto de funciones y clases que te ayudan a realizar tareas específicas. Por ejemplo, el módulo `tkinter` te permite crear ventanas y botones. El módulo `os` te ayuda a interactuar con el sistema operativo.

Para usar un módulo, solo tienes que escribir `import` seguido del nombre del módulo.

Instalación de Módulos con Pip

La herramienta `Pip` te ayuda a instalar y gestionar módulos de Python. Viene incluida con la mayoría de las instalaciones de Python. Con Pip puedes:

• Instalar módulos.
• Instalar versiones específicas de módulos.
• Desinstalar módulos.
• Actualizar módulos.

Interfaz al Sistema Operativo

El módulo `os` te permite interactuar con el sistema operativo:

>>> import os
>>> os.name  # Devuelve el nombre del sistema operativo (por ejemplo, 'posix' para Linux/macOS, 'nt' para Windows)
    'posix'
>>> os.mkdir("/tmp/ejemplo")  # Crea una carpeta en la ruta especificada

Para tareas de manejo de archivos más avanzadas, el módulo `shutil` es útil:

>>> import shutil
>>> shutil.copyfile('datos.db', 'informacion.db') # Copia un archivo
    'informacion.db'
>>> shutil.move('/build/programas', 'dir_progs') # Mueve un archivo o carpeta
    'dir_progs'

Búsqueda de Archivos con Comodines

El módulo `glob` te ayuda a encontrar archivos usando patrones (como los comodines `*` o `?`):

>>> import glob
>>> glob.glob('*.py') # Busca todos los archivos que terminan en .py
    ['numeros.py', 'ejemplo.py', 'ejemplo2.py']

Argumentos de Línea de Comandos

Cuando ejecutas un programa Python desde la línea de comandos, puedes pasarle información. Esta información se guarda en el módulo `sys`:

>>> import sys
>>> print(sys.argv) # Muestra los argumentos pasados al programa
    ['demostracion.py', 'uno', 'dos', 'tres']

Matemáticas

El módulo `math` te da acceso a funciones matemáticas avanzadas:

>>> import math
>>> math.cos(math.pi / 3) # Calcula el coseno de pi/3
    0.494888338963
>>> math.log(1024, 2) # Calcula el logaritmo de 1024 en base 2
    10.0

El módulo `random` se usa para generar números o selecciones al azar:

>>> import random
>>> random.choice(['durazno', 'manzana', 'frutilla']) # Elige un elemento al azar de una lista
    'durazno'
>>> random.sample(range(100), 10)   # Elige 10 números al azar del 0 al 99 sin repetir
    [30, 23, 17, 24, 8, 81, 41, 80, 28, 13]
>>> random.random()  # Un número decimal al azar entre 0 y 1
    0.23370387692726126
>>> random.randrange(6)  # Un número entero al azar entre 0 y 5
    3

El módulo `statistics` te ayuda con cálculos estadísticos básicos:

>>> import statistics
>>> datos = [1.75, 2.75, 1.25, 0.5, 0.25, 1.25, 3.5]
>>> statistics.mean(datos) # Calcula la media (promedio)
    1.6071428571428572
>>> statistics.median(datos) # Calcula la mediana (el valor central)
    1.25
>>> statistics.variance(datos) # Calcula la varianza
    1.3720238095238095

Fechas y Horas

Los módulos `time` y `datetime` te permiten trabajar con fechas y horas:

>>> from datetime import datetime
>>> import time
>>> datetime.now().isoformat()  # Devuelve la fecha y hora actual en un formato estándar
    '2010-08-10T18:01:17.900401'
>>> datetime.now().strftime("%Y-%m-%d %H:%M:%S")  # Devuelve la fecha y hora actual con un formato personalizado
    '2010-08-10 18:01:17'
>>> time.strftime("%Y-%m-%d %H:%M:%S")  # Otro método para obtener la fecha y hora formateada
    '2010-08-10 18:01:17'

Módulo Turtle: Dibujando con una Tortuga

El módulo `turtle` te permite dibujar gráficos usando una "tortuga" virtual que se mueve por la pantalla:

>>> import turtle
>>> turtle.pensize(2) # Establece el grosor del lápiz
>>> turtle.left(120) # Gira la tortuga 120 grados a la izquierda
>>> turtle.forward(100) # Mueve la tortuga 100 unidades hacia adelante

Sistema de Objetos: Todo es un Objeto

En Python, casi todo es un objeto. Esto significa que incluso las clases son objetos. Los objetos tienen sus propias características (atributos) y acciones que pueden realizar (métodos). Python también permite la herencia múltiple (una clase puede heredar de varias) y el polimorfismo (objetos de diferentes clases pueden responder al mismo método de diferentes maneras).

>>> cadena = "abc"  # Una cadena es un objeto de tipo "str"
>>> cadena.upper()  # Como es un objeto, tiene métodos como .upper() para convertir a mayúsculas
    'ABC'
>>> lista = [True, 3.1415]  # Una lista es un objeto de tipo "list"
>>> lista.append(42)  # Las listas también tienen sus propios métodos, como .append() para añadir elementos
>>> lista
    [True, 3.1415, 42]

Biblioteca Estándar: "Pilas Incluidas"

Python tiene una biblioteca estándar muy grande. Esto significa que viene con muchas herramientas listas para usar. Se dice que Python viene con "pilas incluidas" porque no necesitas buscar muchas cosas por separado. Los módulos de la biblioteca estándar se pueden combinar con módulos que tú mismo crees o que estén escritos en otros lenguajes como C o C++. Gracias a esto, Python es un lenguaje muy potente y fácil de usar.

Implementaciones de Python

Existen diferentes versiones o "implementaciones" del lenguaje Python:

• CPython: Es la versión original y la más común.
• IronPython: Una versión de Python que funciona con la plataforma .NET.
• Jython: Una versión de Python escrita en Java.
• PyPy: Una implementación de Python escrita en Python, que a menudo es más rápida.

Novedades Importantes en la Historia de Python

A lo largo de su historia, Python ha tenido algunos momentos clave:

• El 13 de febrero de 2009, se lanzó una nueva versión importante llamada "Python 3000" o "Py3K". Esta versión trajo muchos cambios que hicieron que el código de versiones anteriores tuviera que ser actualizado. Para ayudar con esto, se creó una herramienta llamada `2to3` que intentaba traducir el código automáticamente.
• Desde mayo de 2019, el sistema operativo Windows 10 facilita la instalación de Python y sus herramientas.

Galería de imágenes

• 

  Polígonos regulares y estrellas dibujados con el módulo Turtle.

Véase también

En inglés: Python (programming language) Facts for Kids