Un soufflé es un plato de huevo al horno que se originó en Francia en el siglo XVIII. El proceso de hacer un soufflé francés elegante y delicioso es complejo, y en el pasado, generalmente solo lo preparaban chefs profesionales de pastelería franceses. Sin embargo, con las mezclas de soufflé prefabricadas ahora ampliamente disponibles en los supermercados, este clásico plato francés ha encontrado su camino en las cocinas de innumerables hogares.
Python es como las mezclas de soufflé prefabricadas en programación. Muchos estudios han demostrado constantemente que Python es el lenguaje de programación más popular entre los desarrolladores, y esta ventaja continuará expandiéndose en 2025. Python se destaca en comparación con lenguajes como C, C ++, Java y Julia porque es altamente legible y expresivo, flexible y flexible y flexible y flexible. dinámico, amigable para principiantes pero poderoso. Estas características hacen que Python sea el lenguaje de programación más adecuado para las personas, incluso sin conceptos básicos de programación. Las siguientes características distinguen a Python de otros lenguajes de programación:
- Tipificación dinámica
- Enumere las comprensiones
- Generadores
- Paso de argumento y mutabilidad
Estas características revelan PitónLa naturaleza intrínseca como lenguaje de programación. Sin este conocimiento, nunca entenderás realmente a Python. En el artículo de hoy, elaboraré cómo Python se destaca sobre otros lenguajes de programación a través de estas características.
Tipificación dinámica
Para la mayoría de los lenguajes de programación como Java o C ++, se requieren declaraciones de tipo de datos explícitos. Pero cuando se trata de Python, no tiene que declarar el tipo de variable cuando crea una. Esta característica en Python se llama tipificación dinámica, lo que hace que Python sea flexible y fácil de usar.
Enumere las comprensiones
Las comprensiones de la lista se utilizan para generar listas de otras listas aplicando funciones a cada elemento en la lista. Proporcionan una forma concisa de aplicar bucles y condiciones opcionales en una lista.
Por ejemplo, si desea crear una lista de cuadrados para números pares entre 0 y 9, puede usar JavaScript, un bucle regular en la comprensión de la lista de Python y Python para lograr el mismo objetivo.
Javascript
let squares = Array.from({ length: 10 }, (_, x) => x) // Create array [0, 1, 2, ..., 9]
.filter(x => x % 2 === 0) // Filter even numbers
.map(x => x ** 2); // Square each number
console.log(squares); // Output: [0, 4, 16, 36, 64]Bucle regular en Python
squares = []
for x in range(10):
if x % 2 == 0:
squares.append(x**2)
print(squares) Comprensión de la lista de Python
squares = [x**2 for x in range(10) if x % 2 == 0]print(squares) Las tres secciones de código anteriores generan la misma lista [0, 4, 16, 36, 64]pero la comprensión de la lista de Python es la más elegante porque la sintaxis es concisa y expresa claramente la intención, mientras que la función de Python es más detallada y requiere una inicialización y agregada explícitas. La sintaxis de JavaScript es la menos elegante y legible porque requiere métodos de encadenamiento para usar la matriz. Desde el filtro y el mapa. Tanto la función de Python como la función JavaScript no son intuitivas y no se pueden leer como un lenguaje natural como lo hace la comprensión de la lista de Python.
Generador
Los generadores en Python son un tipo especial de iterador que permite a los desarrolladores iterar sobre una secuencia de valores sin almacenarlos todos en la memoria a la vez. Se crean con la palabra clave de rendimiento. Otros lenguajes de programación como C ++ y Java, aunque ofrecen una funcionalidad similar, no tienen una palabra clave de rendimiento incorporada de la misma manera simple e integrada. Aquí hay varias ventajas clave que hacen Generadores de pitón único:
- Eficiencia de memoria: Los generadores producen un valor a la vez para que solo calculen y mantengan un elemento en la memoria en cualquier momento dado. Esto contrasta con, por ejemplo, una lista en Python, que almacena todos los elementos de la memoria.
- Evaluación perezosa: Los generadores permiten que Python calcule los valores solo según sea necesario. Este cálculo “perezoso” da como resultado mejoras significativas de rendimiento cuando se trata de secuencias grandes o potencialmente infinitas.
- Sintaxis simple: Esta podría ser la razón más importante por la cual los desarrolladores eligen usar generadores porque pueden convertir fácilmente una función regular en un generador sin tener que administrar el estado explícitamente.
def fibonacci():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
fib = fibonacci()
for _ in range(100):
print(next(fib))El ejemplo anterior muestra cómo usar la palabra clave de rendimiento al crear una secuencia. Para el uso de la memoria y la diferencia de tiempo entre el código con y sin generadores, la generación de 100 números de Fibonacci difícilmente puede ver diferencias. Pero cuando se trata de 100 millones de números en la práctica, es mejor que use generadores porque una lista de 100 millones de números podría forzar fácilmente muchos recursos del sistema.
Paso de argumento y mutabilidad
En Python, realmente no asignamos valores a variables; En cambio, unimos variables a los objetos. El resultado de tal acción depende de si el objeto es mutable o inmutable. Si un objeto es mutable, los cambios realizados dentro de la función afectarán el objeto original.
def modify_list(lst):
lst.append(4)
my_list = [1, 2, 3]
modify_list(my_list)
print(my_list) # Output: [1, 2, 3, 4]En el ejemplo anterior, nos gustaría agregar ‘4’ a la lista my_list que es [1,2,3]. Debido a que las listas son mutables, la operación de agregar comportamiento cambia la lista original my_list sin crear una copia.
Sin embargo, los objetos inmutables, como enteros, flotadores, cuerdas, tuplas y congelensets, no pueden cambiarse después de la creación. Por lo tanto, cualquier modificación da como resultado un nuevo objeto. En el ejemplo a continuación, debido a que los enteros son inmutables, la función crea un nuevo entero en lugar de modificar la variable original.
def modify_number(n):
n += 10
return n
a = 5
new_a = modify_number(a)
print(a) # Output: 5
print(new_a) # Output: 15El argumento de Python a veces se describe como “referencia de paso por objeto” o “pase por asignación”. Esto hace que Python sea único porque Python pase las referencias de manera uniforme (transferencia de aprobación por objeto), mientras que otros idiomas deben diferenciarse explícitamente entre el paso por valor y el paso por referencia. El enfoque uniforme de Python es simple pero poderoso. Evita la necesidad de punteros explícitos o parámetros de referencia, pero requiere que los desarrolladores tengan en cuenta los objetos mutables.
Con el argumento de Python pasando y la mutabilidad, podemos disfrutar de los siguientes beneficios en la codificación:
- Eficiencia de memoria: Guarde la memoria pasando referencias en lugar de hacer copias completas de los objetos. Esto beneficia especialmente al desarrollo del código con grandes estructuras de datos.
- Actuación: Evita copias innecesarias y, por lo tanto, mejora el rendimiento general de codificación.
- Flexibilidad: Esta característica proporciona conveniencia para actualizar la estructura de datos porque los desarrolladores no necesitan elegir explícitamente entre el valor de paso y el paso por referencia.
Sin embargo, esta característica de Python obliga a los desarrolladores a elegir cuidadosamente entre tipos de datos mutables e inmutables y también trae una depuración más compleja.
Entonces, ¿Python es realmente simple?
La popularidad de Python resulta de su simplicidad, eficiencia de la memoria, alto rendimiento y amigos para principiantes. También es un lenguaje de programación que más se parece al lenguaje natural de un humano, por lo que incluso las personas que no han recibido capacitación de programación sistemática y holística aún pueden entenderlo. Estas características hacen de Python una mejor opción entre empresas, institutos académicos y organizaciones gubernamentales.
Por ejemplo, cuando nos gustaría filtrar las órdenes “completadas” con cantidades superiores a 200, y actualizar un informe de resumen mutable (un diccionario) con el recuento total y la suma de los montos para una compañía de comercio electrónico, podemos usar comprensión de la lista Para crear una lista de pedidos que cumplan con nuestros criterios, omita la declaración de tipos variables y hacer cambios en el diccionario original con pase por asignación.
import random
import time
def order_stream(num_orders):
"""
A generator that yields a stream of orders.
Each order is a dictionary with dynamic types:
- 'order_id': str
- 'amount': float
- 'status': str (randomly chosen among 'completed', 'pending', 'cancelled')
"""
for i in range(num_orders):
order = {
"order_id": f"ORD{i+1}",
"amount": round(random.uniform(10.0, 500.0), 2),
"status": random.choice(["completed", "pending", "cancelled"])
}
yield order
time.sleep(0.001) # simulate delay
def update_summary(report, orders):
"""
Updates the mutable summary report dictionary in-place.
For each order in the list, it increments the count and adds the order's amount.
"""
for order in orders:
report["count"] += 1
report["total_amount"] += order["amount"]
# Create a mutable summary report dictionary.
summary_report = {"count": 0, "total_amount": 0.0}
# Use a generator to stream 10,000 orders.
orders_gen = order_stream(10000)
# Use a list comprehension to filter orders that are 'completed' and have amount > 200.
high_value_completed_orders = [order for order in orders_gen
if order["status"] == "completed" and order["amount"] > 200]
# Update the summary report using our mutable dictionary.
update_summary(summary_report, high_value_completed_orders)
print("Summary Report for High-Value Completed Orders:")
print(summary_report)Si nos gustaría lograr el mismo objetivo con Java, ya que Java carece de generadores incorporados y comprensiones de lista, tenemos que generar una lista de pedidos, luego filtrar y actualizar un resumen usando bucles explícitos y, por lo tanto, hacer que el código sea más complejo , menos legible y más difícil de mantener.
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
class Order {
public String orderId;
public double amount;
public String status;
public Order(String orderId, double amount, String status) {
this.orderId = orderId;
this.amount = amount;
this.status = status;
}
@Override
public String toString() {
return String.format("{orderId:%s, amount:%.2f, status:%s}", orderId, amount, status);
}
}
public class OrderProcessor {
// Generates a list of orders.
public static List<Order> generateOrders(int numOrders) {
List<Order> orders = new ArrayList<>();
String[] statuses = {"completed", "pending", "cancelled"};
Random rand = new Random();
for (int i = 0; i < numOrders; i++) {
String orderId = "ORD" + (i + 1);
double amount = Math.round(ThreadLocalRandom.current().nextDouble(10.0, 500.0) * 100.0) / 100.0;
String status = statuses[rand.nextInt(statuses.length)];
orders.add(new Order(orderId, amount, status));
}
return orders;
}
// Filters orders based on criteria.
public static List<Order> filterHighValueCompletedOrders(List<Order> orders) {
List<Order> filtered = new ArrayList<>();
for (Order order : orders) {
if ("completed".equals(order.status) && order.amount > 200) {
filtered.add(order);
}
}
return filtered;
}
// Updates a mutable summary Map with the count and total amount.
public static void updateSummary(Map<String, Object> summary, List<Order> orders) {
int count = 0;
double totalAmount = 0.0;
for (Order order : orders) {
count++;
totalAmount += order.amount;
}
summary.put("count", count);
summary.put("total_amount", totalAmount);
}
public static void main(String[] args) {
// Generate orders.
List<Order> orders = generateOrders(10000);
// Filter orders.
List<Order> highValueCompletedOrders = filterHighValueCompletedOrders(orders);
// Create a mutable summary map.
Map<String, Object> summaryReport = new HashMap<>();
summaryReport.put("count", 0);
summaryReport.put("total_amount", 0.0);
// Update the summary report.
updateSummary(summaryReport, highValueCompletedOrders);
System.out.println("Summary Report for High-Value Completed Orders:");
System.out.println(summaryReport);
}
}Conclusión
Equipado con características de mecanografía dinámica, comprensiones de lista, generadores y su enfoque para el paso de los argumentos y la mutabilidad, Python se hace una codificación simplificada al tiempo que mejora la eficiencia y el rendimiento de la memoria. Como resultado, Python se ha convertido en el lenguaje de programación ideal para los autoaprendedores.
¡Gracias por leer!