Conceptos básicos de Python

Articles

Este artículo explica los conceptos básicos de Python.

YouTube Video

Ejecutando "Hello World!"

1print("Hello World!")

Variables en Python

En Python, las variables son espacios de almacenamiento con nombre para contener y usar datos e información dentro de un programa. Las variables pueden contener varios tipos de datos y ser reasignadas según sea necesario. A continuación, proporcionamos varios ejemplos de código para demostrar el uso básico de las variables en Python.

 1# 1. Assigning values to variables
 2# Integer type variable
 3age = 25
 4print("Age:", age)  # Output: Age: 25
 5
 6# Floating-point type variable
 7height = 175.5
 8print("Height:", height, "cm")  # Output: Height: 175.5 cm
 9
10# String type variable
11name = "Taro"
12print("Name:", name)  # Output: Name: Taro
13
14# Boolean type variable
15is_student = True
16print("Are you a student?", is_student)  # Output: Are you a student? True
17
18# 2. Assigning values to multiple variables simultaneously
19# You can assign multiple variables at once
20x, y, z = 5, 10, 15
21print("x =", x, ", y =", y, ", z =", z)  # Output: x = 5 , y = 10 , z = 15
22
23# 3. Updating the value of a variable
24# The value of a variable can be updated by reassignment
25age = 26
26print("Updated age:", age)  # Output: Updated age: 26
27
28# 4. Updating multiple variables at once
29# Example of swapping values between variables
30a, b = 1, 2
31a, b = b, a
32print("a =", a, ", b =", b)  # Output: a = 2 , b = 1
33
34# 5. Type conversion
35# Type conversion allows operations between different types
36count = "5"  # String "5"
37count = int(count)  # Convert to integer type
38print("Handling count as an integer:", count * 2)  # Output: Handling count as an integer: 10
39
40# Conversion to floating-point number
41pi_approx = "3.14"
42pi_approx = float(pi_approx)
43print("Approximation of pi:", pi_approx)  # Output: Approximation of pi: 3.14

Como se muestra, las variables en Python pueden usarse de manera flexible. Las variables pueden usarse sin especificar su tipo y reasignarse según sea necesario. Además, la conversión de tipos facilita el cambio entre diferentes tipos de datos.

Tipos de datos en Python

Python tiene varios tipos de datos básicos. A continuación, proporcionamos explicaciones y ejemplos de código para cada uno.

Tipo entero

El tipo entero se utiliza para manejar números enteros sin punto decimal.

1# Example of integer type
2x = 10
3print(x)        # Output: 10
4print(type(x))  # Output: <class 'int'>

Tipo de punto flotante

El tipo de punto flotante se utiliza para manejar números con punto decimal.

1# Floating Point Number Example
2y = 3.14
3print(y)        # Output: 3.14
4print(type(y))  # Output: float

Tipo de cadena

El tipo de cadena representa una secuencia de caracteres. Las cadenas pueden estar encerradas entre comillas simples ' o comillas dobles ".

1# Example of String
2s = "Hello, World!"
3print(s)        # Output: Hello, World!
4print(type(s))  # Output: <class 'str'>

Tipo Booleano

El tipo booleano tiene dos valores: verdadero (True) y falso (False).

1# Example of Boolean
2b = True
3print(b)        # Output: True
4print(type(b))  # Output: <class 'bool'>

Tipo Lista

El tipo lista es una secuencia mutable que puede almacenar múltiples elementos, y los elementos pueden ser de diferentes tipos de datos.

1# Example of List
2lst = [1, 2, 3, "four", 5.0]
3print(lst)        # Output: [1, 2, 3, 'four', 5.0]
4print(type(lst))  # Output: <class 'list'>

Tipo Tupla

Una tupla es una secuencia que puede contener múltiples elementos, y su contenido no puede ser modificado una vez creada.

1# Example of Tuple
2tup = (1, "two", 3.0)
3print(tup)        # Output: (1, 'two', 3.0)
4print(type(tup))  # Output: <class 'tuple'>

Tipo Diccionario

El tipo diccionario es una colección que contiene pares clave-valor. Las claves deben ser únicas.

1# Example of Dictionary
2dct = {"one": 1, "two": 2, "three": 3}
3print(dct)        # Output: {'one': 1, 'two': 2, 'three': 3}
4print(type(dct))  # Output: <class 'dict'>

Tipo Conjunto

El tipo conjunto es una colección que contiene elementos únicos. No se pueden incluir valores duplicados.

1# Example of Set
2st = {1, 2, 2, 3}
3print(st)        # Output: {1, 2, 3}
4print(type(st))  # Output: <class 'set'>

Estos tipos de datos son fundamentales y se utilizan frecuentemente para manejar datos en Python. Al usarlos adecuadamente, puedes cumplir con varios requisitos en tus programas.

Descripción General de Python

Python es un lenguaje de programación de alto nivel desarrollado por Guido van Rossum en 1991. Su filosofía de diseño enfatiza la 'simplicidad,' 'claridad' y 'legibilidad,' lo que da como resultado un código intuitivo, fácil de escribir y fácil de leer. A continuación se presenta una descripción general de las características principales de Python.

Legibilidad y Simplicidad:
- Con una estructura clara y expresiones cercanas al lenguaje natural, es un lenguaje fácil de aprender para principiantes.
- Los bloques se definen con sangría, lo que automáticamente formatea el código y aumenta la legibilidad.
Bibliotecas y Frameworks Ricos:
- Cuenta con una rica biblioteca estándar, lo que permite realizar muchas tareas de manera sencilla.
- Existen bibliotecas y marcos especializados disponibles para diversos campos, como el cálculo numérico (NumPy), el análisis de datos (Pandas), el aprendizaje automático (scikit-learn, TensorFlow) y el desarrollo web (Django, Flask).
Versatilidad:
- Python es adecuado tanto como lenguaje de scripting como para el desarrollo de aplicaciones con todas las funciones. Se utiliza en diversas aplicaciones como aplicaciones web, aplicaciones de escritorio, cálculo científico, aprendizaje automático, análisis de datos e IoT.
Multiplataforma:
- Es independiente de la plataforma y puede ejecutarse en muchos sistemas operativos, incluidos Windows, macOS y Linux.
Código abierto y comunidad:
- Python es un proyecto de código abierto respaldado por una comunidad activa. Por esta razón, se proporcionan actualizaciones frecuentes, desarrollo de bibliotecas y soporte.
Tipado dinámico y gestión automática de memoria:
- El tipado dinámico elimina la necesidad de declarar tipos de variables, permitiendo un desarrollo más rápido.
- La recolección de basura realiza la gestión automática de la memoria, simplificando su gestión.

Con estas características, Python se utiliza ampliamente en diversos campos, incluyendo la educación, la industria y el mundo académico.

Caracteres de escape en Python

En Python, los caracteres de escape se utilizan para incluir caracteres de control específicos o caracteres con un significado especial dentro de cadenas de texto. Los caracteres de escape son símbolos especiales que se utilizan para agregar significados específicos a las cadenas de texto normales. Vamos a echar un vistazo más de cerca a los caracteres de escape en Python.

Conceptos básicos de los caracteres de escape

En Python, los caracteres de escape se definen utilizando una barra invertida (\). Los caracteres de escape indican un comportamiento específico dentro de una cadena de texto normal. Por ejemplo, \n representa una nueva línea y \t representa un espacio de tabulación.

Puedes definir una cadena que contenga caracteres de escape de la siguiente manera:.

1# Example of escape characters
2print("Hello\nWorld")  # A newline is inserted after "Hello"
3
4# Output:
5# Hello
6# World

Lista de los principales caracteres de escape

Los principales caracteres de escape utilizados en Python son los siguientes:.

\\: Representa una barra invertida en sí misma.
\': Incluye una comilla simple en una cadena.
\": Incluye una comilla doble en una cadena.
\n: Nueva línea
\t: Tabulación
\r: Retorno de carro
\b: Retroceso
\f: Avance de página
\a: Sonido de alerta (campana)
\v: Tabulación vertical
\N{name}: Carácter por nombre en la base de datos Unicode
\uXXXX: Carácter Unicode de 16 bits (especificado con 4 dígitos hexadecimales)
\UXXXXXXXX: Carácter Unicode de 32 bits (especificado con 8 dígitos hexadecimales)
\xXX: Carácter especificado en hexadecimal

Ejemplos de caracteres de escape comúnmente utilizados

Aquí hay algunos ejemplos específicos de cómo usar caracteres de escape.

Comillas dobles y comillas simples

Para incluir comillas dobles o comillas simples dentro de una cadena, utiliza caracteres de escape.

 1# String containing double quotes
 2quote = "He said, \"Python is amazing!\""
 3print(quote)
 4
 5# String containing single quotes
 6single_quote = 'It\'s a beautiful day!'
 7print(single_quote)
 8
 9# Output:
10# He said, "Python is amazing!"
11# It's a beautiful day!

Saltos de línea y tabulaciones

Los saltos de línea y tabulaciones se utilizan comúnmente para dar formato al texto.

 1# Example using newline
 2multiline_text = "First line\nSecond line"
 3print(multiline_text)
 4
 5# Example using tab
 6tabbed_text = "Column1\tColumn2\tColumn3"
 7print(tabbed_text)
 8
 9# Output:
10# First line
11# Second line
12# Column1	Column2	Column3

Caracteres de escape Unicode

En Python, los caracteres Unicode se representan utilizando \u o \U. Esto es particularmente útil al manejar caracteres no ingleses.

1# Example of Unicode escape
2japanese_text = "\u3053\u3093\u306B\u3061\u306F"  # Hello in Japanese
3print(japanese_text)
4# Output:
5# こんにちは(Hello in Japanese)

Precauciones con caracteres de escape especiales

Hay algunas precauciones a tener en cuenta al usar caracteres de escape.

Cadenas crudas: Si deseas mostrar cadenas que contienen barras invertidas tal cual, puedes usar cadenas crudas. Las cadenas crudas se especifican agregando un prefijo r a la cadena.

1raw_string = r"C:\Users\name\Documents"
2print(raw_string)
3# Output:
4# C:\Users\name\Documents

En las cadenas crudas, la barra invertida no se interpreta como un carácter de escape y se muestra tal cual.

Uso de Unicode: Al usar caracteres de escape Unicode, asegúrate de que los códigos hexadecimales especificados sean correctos. Las especificaciones incorrectas resultarán en una visualización incorrecta de caracteres.

Escapando barras invertidas

Para incluir una barra invertida en una cadena, usa barras invertidas dobles.

1# Example containing backslash
2path = "C:\\Program Files\\Python"
3print(path)
4# Output:
5# C:\Program Files\Python

Ejemplo avanzado: Formateo de cadenas complejo

También es posible combinar caracteres de escape para formatear cadenas complejas.

 1# Example of formatting a message
 2message = "Dear User,\n\n\tThank you for your inquiry.\n\tWe will get back to you shortly.\n\nBest Regards,\nCustomer Support"
 3print(message)
 4# Output:
 5# Dear User,
 6#
 7#     Thank you for your inquiry.
 8#     We will get back to you shortly.
 9#
10#     Best Regards,
11#     Customer Support

Resumen

Los caracteres de escape de Python son una herramienta poderosa para incluir caracteres de control específicos o caracteres especiales dentro de cadenas. Entender cómo usarlos y aplicarlos adecuadamente según sea necesario permite un procesamiento más flexible de cadenas.

Versiones de Python

Repasemos brevemente las principales versiones de Python y sus características.

Python 1.0 (1994)

1# Simple code that works in Python 1.0
2def greet(name):
3    print "Hello, " + name  # print was a statement
4
5greet("World")

La primera versión oficial. Se establecieron la sintaxis básica y la biblioteca estándar de Python.

Python 2.0 (2000)

1# List comprehension
2squares = [x * x for x in range(5)]
3print squares
4
5# Unicode string (u"...")
6greet = u"Hello"
7print greet

Se añadieron características importantes, como las comprensiones de listas, la recolección completa de basura y el inicio del soporte para Unicode. Python 2 se utilizó durante mucho tiempo, pero su soporte terminó en 2020.

Python 3.0 (2008)

1# print is now a function
2print("Hello, world!")
3
4# Unicode text is handled natively
5message = "Hello"
6print(message)

Una actualización importante sin compatibilidad retroactiva. print se convirtió en una función, Unicode pasó a ser el tipo de cadena predeterminado y los enteros se unificaron, mejorando enormemente la consistencia y la usabilidad de Python. La serie Python 3.x es la versión principal actual.

Python 3.5 (2015)

1import asyncio
2
3async def say_hello():
4    await asyncio.sleep(1)
5    print("Hello, async world!")
6
7asyncio.run(say_hello())

Se introdujo la sintaxis async/await, haciendo que la programación asíncrona sea más sencilla de escribir.

Python 3.6 (2016)

1name = "Alice"
2age = 30
3print(f"{name} is {age} years old.")  # f-string makes formatting simple

Se añadieron las Literales de cadena formateadas (f-strings), haciendo el formateo de cadenas más práctico. Además, se ampliaron las anotaciones de tipos.

Python 3.7 (2018)

1from dataclasses import dataclass
2
3@dataclass
4class Person:
5    name: str
6    age: int
7
8p = Person("Bob", 25)
9print(p)

Se introdujeron las Dataclasses, facilitando la definición de clases similares a estructuras. El soporte para async/await también se mejoró.

Python 3.8 (2019)

1# Assignment inside an expression
2if (n := len("hello")) > 3:
3    print(f"Length is {n}")

Se añadió el Operador Walrus (:=), permitiendo el uso de expresiones de asignación. También se introdujeron los parámetros solo posicionales, mejorando la flexibilidad en los argumentos de las funciones.

Python 3.9 (2020)

1a = {"x": 1}
2b = {"y": 2}
3c = a | b  # merge two dicts
4print(c)   # {'x': 1, 'y': 2}

Se realizaron mejoras en las anotaciones de tipo y se añadió un operador de unión (|) para listas y diccionarios. También se reorganizó la biblioteca estándar.

Python 3.10 (2021)

 1def handle(value):
 2    match value:
 3        case 1:
 4            return "One"
 5        case 2:
 6            return "Two"
 7        case _:
 8            return "Other"
 9
10print(handle(2))

Se añadió el Pattern matching, permitiendo declaraciones condicionales más potentes. Los mensajes de error se mejoraron, y el sistema de tipos se fortaleció aún más.

Python 3.11 (2022)

1# Improved performance (up to 25% faster in general)
2# More informative error messages
3try:
4    eval("1/0")
5except ZeroDivisionError as e:
6    print(f"Caught an error: {e}")

Se realizaron **mejoras significativas en el rendimiento**, resultando en una ejecución más rápida en comparación con versiones anteriores. Además, se mejoraron el manejo de excepciones y la comprobación de tipos.

Python 3.12 (2023)

 1# Automatically shows exception chains with detailed traceback
 2def f():
 3    raise ValueError("Something went wrong")
 4
 5def g():
 6    try:
 7        f()
 8    except Exception:
 9        raise RuntimeError("Higher level error")  # Automatically chained
10
11try:
12    g()
13except Exception as e:
14    import traceback
15    traceback.print_exception(type(e), e, e.__traceback__)

Los mensajes de error se han mejorado aún más y se ha incrementado el rendimiento. Además, el encadenamiento de excepciones se muestra automáticamente, permitiendo una depuración más detallada. También se han añadido nuevas características de sintaxis y mejoras en la biblioteca estándar, aumentando la productividad de los desarrolladores.

La serie Python 3.x continúa evolucionando, con las versiones más recientes mejorando el rendimiento, el sistema de tipos y añadiendo nuevas características.

Puedes seguir el artículo anterior utilizando Visual Studio Code en nuestro canal de YouTube. Por favor, también revisa nuestro canal de YouTube.