Fundamentos de Programación y Python
¿Por qué aprender Python?
Introducción a Python
Conceptos Básicos de Programación
Práctica: Te doy la bienvenida a los ejercicios interactivos
Manipulación de Cadenas de Texto en Python
Enteros, Flotantes y Booleanos
Todo lo que Debes Saber sobre print en Python
Operaciones Matemáticas en Python
Operaciones de Entrada/Salida en Consola
Colección y Procesamiento de Datos en Python
Listas
Método slice
Listas de más dimensiones y Tuplas
Aplicación de Matrices
Diccionarios
Comprehension Lists en Python (CLASE NUEVA)
Control de Flujo en Python
Estructuras condicionales
Bucles y Control de Iteraciones
Generadores e Iteradores
Funciones y Manejo de Excepciones en Python
Uso de Funciones en Python
Funciones Lambda y Programación Funcional en Python
¿Cómo realizar una función recursiva en Python?
Manejo de Excepciones y Uso de Pass (CLASE NUEVA)
Programación Orientada a Objetos en Python
Fundamentos de Programación Orientada a Objetos en Python
Ejercicio Biblioteca con POO
Herencia en POO con Python
Objetos heredados
Los 4 pilares de la programacion orientada a objetos
Uso de super() en Python (CLASE NUEVA)
Superando los Fundamentos de Programación Orientada a Objetos en Python
Lectura y escritura de archivos
Manejo de Archivos .TXT (CLASE NUEVA)
Manejo de Archivos CSV (CLASE NUEVA)
Manejo de Archivos JSON (CLASE NUEVA)
Biblioteca estándar de Python
Biblioteca estándar en Python (CLASE NUEVA)
Librería Os, Math y Random (CLASE NUEVA)
Librería Statistics y Análisis Estadístico (CLASE NUEVA)
Proyecto final: Guerra naval
Conceptos avanzados de Python
Recapitulación de lo aprendido hasta ahora
Escribir código Pythonico y profesional
Comentarios y Docstrings en Python
Scope y closures: variables locales y globales
Anotaciones de tipo
Validación de tipos en métodos
Librería Collections y Enumeraciones
Decoradores
Decoradores en Python
Decoradores anidados y con parámetros
Uso de Decoradores en clases y métodos
Métodos y estructura de clases en Python
Métodos mágicos
Sobrecarga de operadores
Implementación de `if __name__ == "__main__":`
Metaprogramación en Python
Uso de *args y **kwargs
Métodos privados y protegidos
Gestión avanzada de propiedades
Métodos estáticos y de clase avanzados
Programación concurrente y asíncrona
Introducción a la concurrencia y paralelismo
Threading y multiprocessing en Python
Asincronismo con asyncio
Asincronismo y concurrencia
Creación de módulos y paquetes
Creación de módulos en Python
Gestión de paquetes
Publicación de paquetes en PyPI
Proyecto final
Implementación de un sistema completo
Implementación de un Sistema Completo
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Comprehension Lists en Python (CLASE NUEVA)
15/63Recursos
Fe de erratas
Durante la clase, en una parte del contenido escribimos mal la fórmula para convertir de grados Celsius a Fahrenheit.
Error:
°F = (°C × 1.8) * 32
Corrección:
°F = (°C × 1.8) + 32
El signo correcto es +, no *. Gracias por la comprensión y nos disculpamos por la confusión. 🌡️✨
Una Comprehension List es una forma concisa de crear listas en Python, pues permite generar listas nuevas transformando cada elemento de una colección existente o creando elementos a partir de un rango. La sintaxis es compacta y directa, lo que facilita la comprensión del propósito de tu código de un vistazo.
La estructura básica de una Comprehension List es:
[expresión for elemento in iterable if condición]
Que se traduce a: “Crea una nueva lista evaluando nueva_expresión para cada elemento en el iterable.”
Ejercicios:
-
Doble de los Números
Dada una lista de números[1, 2, 3, 4, 5], crea una nueva lista que contenga el doble de cada número usando una List Comprehension. -
Filtrar y Transformar en un Solo Paso
Tienes una lista de palabras["sol", "mar", "montaña", "rio", "estrella"]y quieres obtener una nueva lista con las palabras que tengan más de 3 letras y estén en mayúsculas. -
Crear un Diccionario con List Comprehension
Tienes dos listas, una de claves["nombre", "edad", "ocupación"]y otra de valores["Juan", 30, "Ingeniero"]. Crea un diccionario combinando ambas listas usando una List Comprehension. -
Anidación de List Comprehensions
Dada una lista de listas (una matriz):pythonCopiar código matriz = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ]Calcula la matriz traspuesta utilizando una List Comprehension anidada.
-
Extraer Información de una Lista de Diccionarios
Dada una lista de diccionarios que representan personas:pythonCopiar código personas = [ {"nombre": "Juan", "edad": 25, "ciudad": "Madrid"}, {"nombre": "Ana", "edad": 32, "ciudad": "Madrid"}, {"nombre": "Pedro", "edad": 35, "ciudad": "Barcelona"}, {"nombre": "Laura", "edad": 40, "ciudad": "Madrid"} ]Extrae una lista de nombres de personas que viven en “Madrid” y tienen más de 30 años.
-
List Comprehension con un
else
Dada una lista de números[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], crea una nueva lista multiplicando por 2 los números pares y dejando los impares como están.
Soluciones
-
Doble de los Números
pythonCopiar código numeros = [1, 2, 3, 4, 5] dobles = [x * 2 for x in numeros] print("Dobles:", dobles) -
Filtrar y Transformar en un Solo Paso
pythonCopiar código palabras = ["sol", "mar", "montaña", "rio", "estrella"] palabras_filtradas = [palabra.upper() for palabra in palabras if len(palabra) > 3] print("Palabras filtradas y en mayúsculas:", palabras_filtradas) -
Crear un Diccionario con List Comprehension
pythonCopiar código claves = ["nombre", "edad", "ocupación"] valores = ["Juan", 30, "Ingeniero"] diccionario = {claves[i]: valores[i] for i in range(len(claves))} print("Diccionario creado:", diccionario) -
Anidación de List Comprehensions
pythonCopiar código matriz = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ] transpuesta_comprehension = [[fila[i] for fila in matriz] for i in range(len(matriz[0]))] print("Transpuesta con List Comprehension:", transpuesta_comprehension) -
Extraer Información de una Lista de Diccionarios
pythonCopiar código personas = [ {"nombre": "Juan", "edad": 25, "ciudad": "Madrid"}, {"nombre": "Ana", "edad": 32, "ciudad": "Madrid"}, {"nombre": "Pedro", "edad": 35, "ciudad": "Barcelona"}, {"nombre": "Laura", "edad": 40, "ciudad": "Madrid"} ] nombres_madrid = [persona["nombre"] for persona in personas if persona["ciudad"] == "Madrid" and persona["edad"] > 30] print("Nombres de personas en Madrid mayores de 30 años:", nombres_madrid -
List Comprehension con un
elsepythonCopiar código numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] transformados = [x * 2 if x % 2 == 0 else x for x in numeros] print("Números transformados:", transformados)
Las Comprehension Lists en Python son una herramienta poderosa y versátil que permite escribir código más limpio y eficiente. Al dominar su uso, puedes realizar transformaciones y filtrados de datos de manera más concisa, lo que no solo mejora la legibilidad del código, sino que también puede optimizar su rendimiento.
Practicar con ejemplos como los presentados te ayudará a integrar esta técnica en tus proyectos de programación diaria, facilitando la manipulación de colecciones de datos de manera elegante y efectiva.
Aportes 122
Preguntas 10
Ordenar por:
excelente clase cada vez me gusta mas python y veo el potencial que tiene.
un solo detalle la formula de los celcius a fahrenheit deberia ser :
`fahrenheit = [(temp * 9 / 5) + 32 for temp in celsius]`
en lugar de multiplicar por 32 deberia sumar. :)
Para ver un poco mejor y entender el código de Transposed:
```python
# este es el código sin usar Comprehensions Lists
transposed = []
for i in range(len(matrix[0])):
print(i)
transposed_row = []
for row in matrix:
print(transposed_row)
transposed_row.append(row[i])
transposed.append(transposed_row)
print(transposed_row)
print(transposed)
# Resultado:
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
0
[]
[1]
[1, 4]
[1, 4, 7]
1
[]
[2]
[2, 5]
[2, 5, 8]
2
[]
[3]
[3, 6]
[3, 6, 9]
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
```
También pueden usar Numpy:
<https://github.com/iecgerman/python-numpy-pandas/blob/master/clase08.ipynb>
pero siempre es bueno tratar de entender la lógica como como llegamos a algo.
Hola!
Comparto la solución de los ejercicios propuestos 🚀
🟢 **Cómo utilizar Dictionary Comprehension**
Aprendiste cómo utilizar comprehension lists, pero también lo puedes realizar con diccionarios en Python.
Las dictionary comprehensions son una **forma elegante y compacta de crear diccionarios**.
La estructura es la siguiente:
```python
{key:value for value in iterable if condition}
```
Por ejemplo:
```python
{ i: i**3 for i in range(1,20) if i % 3 != 0 }
#Resultado:
#{1: 1, 2: 8, 4: 64, 5: 125, 7: 343,
# 8: 512, 10: 1000, 11: 1331, 13: 2197,
# 14: 2744, 16: 4096, 17: 4913, 19: 6859}
```
De esta manera puedes crear comprehensions de otras estructuras de Python como tuplas y sets, siempre y cuando tengas en cuenta **cómo funciona su estructura**.
¡Nunca pares de aprender! 🚀🚀
Con cariño pero aprendo mas de los comentarios q de la clase
Al usar matrix\[0], se refiere al conjunto de datos en la posición 0: \[1, 2, 3] se hace una iteración desde 0 hasta 2, es decir, len(matrix\[0]) = 3. Esto se hace repetir el proceso por cada fila 3 veces cambiando de columna:
fila 1, columna 1 = 1
fila 2, columna 1 = 4
fila 3, columna 1 = 7
transpuesto = \[1,4,7]
fila 1, columna 2 = 2
fila 2, columna 2 = 5
fila 3, columna 2 = 8
transpuesto = \[2,5,8]
fila 1, columna 3 = 3
fila 2, columna 3 = 6
fila 3, columna 3 = 9
transpuesto = \[3,6,9]
Que excelentes clases!!!!!!
Me gusta la clase, es buena, pero siento que van demasiado aceleradas en este tema y no todas las personas manejan una lógica tan buena como para comprender todo el funcionamiento de las estructuras que se plantean en esta clase… sería bueno extender un poco más el tema de las comprehension list a fin de que el estudiante realmente entienda el uso de sus sentencias
hola , siendo sincero considero que para ser un curso básico introductorio, dan muchos elementos por hecho, creo que seria mejor que explicara mejor los elementos básicos
Esta clase debería estar después de la explicación de bucles y condicionales, aquí puede confundir muchísimo o por lo menos así me paso :(
Muy buena clase, pero fuera un principiante esta clase no la entendería primero debería aprender condicionales y bucles, después esta clase. El orden es fundamental.
Deberían revisar bien el orden de las clases. Se supone que si es un curso básico no entiendo por que salta a temas que antes no se han mencionado, haciendo hincapié de que uno conoce las formulas, como por ejemplo con el tema de los rangos.
No logro leer / interpretar de una forma lógica el código de la transposición en la comprehesion List. Alquien me puede ayudar? Gracias.
Por lo visto esta es una clase recientemente añadida. El problema es que esta clase está mal ubicada dentro del orden de las clases ya que presentan cosas avanzadas que hasta el momento no se han visto.
En mi caso, me generó confusión y me costó trabajo por entender el proceso por la misma razón que son cosas avanzas que no he visto en clase.
Así que desearía corrijan el orden de este vídeo para que los nuevos usuarios como yo, no nos sintamos perdidos. Gracias.
no entiendo que es append, ni leyendo ese documento en los recursos.
The list data type has some more methods. Here are all of the methods of list objects:
list.append(*x*)
Add an item to the end of the list. Similar to `a[len(a):] = [x]`.
en que momento de los videos hemos visto esto o se ha aclarado esto? me parece que con la transpuesta como que viajamos luz en el curso, sin entender varios conceptos.
Me perdí desde la parte de transponer, se omiten muchas cosas teóricas como explicar como funciona la operación. Me hace acordar cuando estaba en la universidad y un profesor no explicaba la resolución de una integral y la clase era para enseñar a integrar. Estoy que me ayudo con chat gpt y los comentarios.
Estaba perdido en esta clase, **hasta que usé la siguiente explicación para orientarme**🎯**:**
### **📌 Desglose**
```js
1️⃣ for row in matrix
```
* **Crea la variable** `row` y la usa para recorrer **cada fila** de la matriz original.
* **Se ejecuta sobre** `matrix` gracias a `in matrix`.
* Esto significa que `row` representa una **lista (una fila de la matriz)** en cada iteración.
```js
2️⃣ row[i]
```
* `i` **es un índice** que se obtiene de `for i in range(len(matrix[0]))`.
* `row[i]` **extrae el valor en la posición** `i` de cada fila.
* Como `i` representa las **columnas**, al iterar sobre todas las filas **recolectamos una columna completa**.
```js
3️⃣ for i in range(len(matrix[0]))
```
* **Define cuántas veces se ejecuta el código**, asegurando que `i` recorra todas las **columnas**.
* **Usa** `len(matrix[0])` **en lugar de** `len(matrix)` porque:
* `len(matrix)` → nos daría el número de **filas**.
* `len(matrix[0])` → nos da el número de **columnas** (porque `matrix[0]` es la primera fila y contiene todos los elementos de una columna).
📌 Espero que le sirva a algún compañero y no se rinda sino que continúe avanzando.😃
Deben mover este video, aun no se ha explicado ciclos ni rangos ni nada de eso, si alguien esta iniciando como esperan entienda?
para mayor rapidez utilicen cls para limpiar en lugar de clear
no logro entender como compila el programa en el ejercicio de traspuesta, me confundo mucho.
Curiosamente para poder terminar el proyecto de batalla naval tuve que aprender List Comprehension y ahora sale la clase, gg.
Saludos, buena clase.
Eyyy!! Salta este video y míralo después del video #17
# Usamos zip() para unir cada clave con su valor correspondiente en pares. Luego, con una list comprehension, convertimos esos pares en un diccionario.
`list_keys = ["nombre", "edad", "ocupación"]`
`list_values = ["Juan", 30, "Ingeniero"]`
`diccionario = {key:value for key,value in zip(list_keys, list_values)}`
La función `zip` en Python combina elementos de dos o más iterables (listas, tuplas, etc.) en tuplas, emparejándolos según su posición. Se usa para iterar en paralelo sobre múltiples secuencias o agrupar datos relacionados.
En el ejemplo de la matriz traspuesta se puede decir que la instrucción fue la siguiente:
Para cada posición de columna `(i)` de la matriz original**** `(in range(len(matrix[0])))`**,** crea una nueva fila en la matriz transpuesta con los valores que están en esa columna `([row[i] for row in matrix])`
Que es como decir:
1. Por cada columna de la matriz original:
2. Junta los elementos de esa columna (sacándolos fila por fila) para formar una fila de la matriz transpuesta.
Es muy util el tema para eficientar el código pero parce que la clase es más reciente y la posicionarón mal ya que ocupa conceptos que no se han visto
**Dictionary Comprehension en Python**
Las **dictionary comprehensions** son una forma concisa y eficiente de crear diccionarios en Python. Siguen una sintaxis similar a las list comprehensions.
**Estructura:**
{clave: valor for elemento in iterable if condición}
* `clave: valor`**:** Define el par clave-valor que se agregará al diccionario.
* `for elemento in iterable`**:** Itera sobre un objeto iterable (lista, tupla, rango, etc.).
* `if condición` **(opcional):** Filtra los elementos del iterable según una condición.
**Ejemplo:**
```js
{i: i**3 for i in range(1, 20) if i % 3 != 0}
```
Este código crea un diccionario donde:
* Las **claves** son números del 1 al 19 que no son divisibles entre 3.
* Los **valores** son los cubos de esas claves.
**Resultado:**
```js
{1: 1, 2: 8, 4: 64, 5: 125, 7: 343, 8: 512, 10: 1000, 11: 1331, 13: 2197, 14: 2744, 16: 4096, 17: 4913, 19: 6859}
```
**En resumen:** Las dictionary comprehensions te permiten crear diccionarios de forma compacta y expresiva, iterando sobre un iterable y aplicando una condición opcional. También se pueden generar comprehensions para tuplas y sets, respetando la sintaxis de cada estructura.
Gracias por esos TIPS como lo es limpiar pantalla de Visual Studio Code con CLEAR.
También se puede usar uno abreviado que es CLS.
Gente, el ejercicio 4, aunque fue explicado por la profe no logro comprenderlo. Alguien podría adaptarse a mi nivel y explicármelo de manera más sencilla por favor? :D
El orden del for - if en las comprehension list si importa!!
1. for - if (filtrado)
2. if, else - for (transformación)
1 Cuando el `if` aparece **después del** `for`, actúa como un filtro: solo se incluyen los elementos que cumplen la condición. El `else` no puede usarse en esta posición.
2 Cuando el `if-else` aparece **antes del** `for`, actúa como una transformación: modifica el valor resultante de cada elemento según la condición.
```python
# Filtrado
filtrado = [persona["nombre"] for persona in personas if persona["edad"] > 30]
# Transformación
transformacion = [persona["edad"] if persona["edad"] > 30 else "Joven" for persona in personas]
print(filtrado) # ["Ana", "Pedro", "Laura"]
print(transformacion) # ["Joven", 32, 35, 40]
```# Filtrado
filtrado = \[persona\["nombre"] for persona in personas if persona\["edad"] > 30]
\# Transformación
transformacion = \[persona\["edad"] if persona\["edad"] > 30 else "Joven" for persona in personas]
print(filtrado) # \["Ana", "Pedro", "Laura"]
print(transformacion) # \["Joven", 32, 35, 40]
Recordemos que la función `range()` en Python genera una secuencia de números enteros y se utiliza comúnmente en bucles como `for`.
Se puede personalizar la secuencia especificando un inicio, un final y un paso. Si el paso no se especifica, se usa 1 por defecto.
Algo importante a destacar es que la secuencia de números devueltos es cerrada al inicio pero abierta al final, es decir, el valor inicial forma parte de la secuencia pero el final no, quedándose uno antes.
Por ejemplo:
range(0,10) regresa:
(0,1,2,3,4,5,6,7,8,9)
range(0,1) regresa:
(0)
range(1,11,2) regresa:
(1,3,5,7,9)
Muy buena explicación y la clase fue muy entretenida.
Sin duda Carla es muy buena.
En el transcript se menciona que al final de la clase se dejarán ejercicios en la descripción para que puedas aplicarlos y comprender mejor el concepto de comprehension lists. Si no los encuentras, revisa la sección de recursos o materiales complementarios del curso en la plataforma de Platzi, donde suelen estar disponibles los ejercicios adicionales.
Vamos a desglosar esta línea de código que realiza una transposición de matriz. La transposición significa convertir las filas en columnas y viceversa.
Supongamos que tenemos esta matriz:
```python
matrix = \[
\[1, 2, 3],
\[4, 5, 6]
]
```
Vamos paso a paso:
1\. `len(matrix\[0])`:
\- Obtiene la longitud de la primera fila de la matriz
\- En nuestro ejemplo sería 3 (porque hay 3 columnas)
2\. `range(len(matrix\[0]))`:
\- Crea una secuencia de números de 0 hasta la longitud de la primera fila
\- En nuestro ejemplo: 0, 1, 2
3\. `row\[i] for row in matrix`:
\- Para cada fila (`row`) en la matriz
\- Toma el elemento en la posición `i`
\- Esto forma una nueva columna
4\. `\[row\[i] for row in matrix] for i in range(len(matrix\[0]))`:
\- Crea una nueva lista para cada `i`
\- Cada lista nueva será una fila en la matriz transpuesta
El resultado final sería:
```python
\# Matriz original:
\[
\[1, 2, 3],
\[4, 5, 6]
]
\# Matriz transpuesta:
\[
\[1, 4], # Primera columna original → primera fila
\[2, 5], # Segunda columna original → segunda fila
\[3, 6] # Tercera columna original → tercera fila
]
```
Es una forma compacta de escribir lo que tradicionalmente se haría con bucles anidados:
```python
transposed = \[]
for i in range(len(matrix\[0])):
nueva\_fila = \[]
for row in matrix:
nueva\_fila.append(row\[i])
transposed.append(nueva\_fila)
```
Muy interesante alternativa para usos de for y de las listas.
Les pego la parte de la transposicion con los nombres de las varaibles cambiados. A mi me ayuda a entender mejor el flujo.
```python
# TRANSPOSICION DE UNA MATRIZ
matriz = [[1,2,3],
[4,5,6],
[7,8,9]]
#codigo en comprehension list equivalente a ALFA
transpuesta_1 = [[fila[columna] for fila in matriz] for columna in range(len(matriz[0]))]
print(matriz)
print(transpuesta_1)
# ALFA:
transpuesta_2 = []
for columna in range(len(matriz[0])):
fila_transpuesta = []
for fila in matriz:
fila_transpuesta.append(fila[columna])
transpuesta_2.append(fila_transpuesta)
print(transpuesta_2)
```
comprenshions list o "compreHEnsion list". ? gg
El rango establecido en `range(1, 11)` incluye el número 1 pero excluye el 11. Esto significa que solo generará números del 1 al 10. La función `range` en Python tiene un límite superior exclusivo, lo que explica por qué el 11 no se eleva al cuadrado. Para incluir el 11, deberías usar `range(1, 12)`.
Python tiene comprehensions para **listas, conjuntos, diccionarios y generadores**. Se llaman:
✅ **List Comprehension** → Para crear listas `[]`
✅ **Set Comprehension** → Para crear conjuntos `{}`
✅ **Dictionary Comprehension** → Para crear diccionarios `{clave: valor}`
✅ **Generator Comprehension** → Para crear generadores `()`
**¿Cuál usar?**
* **List Comprehension** → Si necesitas todos los valores de inmediato.
* **Set Comprehension** → Si necesitas valores únicos.
* **Dictionary Comprehension** → Si necesitas pares clave-valor.
* **Generator Comprehension** → Si quieres ahorrar memoria.
Concuerdo, está clase está mal posicionada en el orden de cursos (o no está muy bien explicada). Yo hablé con Chat GPT para entender mejor 🤣
Para crear un `dictionary comprehension` donde las llaves sean los valores del primer diccionario y los valores sean sus llaves, puedes hacerlo de la siguiente manera:
```python
# Diccionario original
original_dict = {'a': 1, 'b': 2, 'c': 3}
# Dictionary comprehension
new_dict = {value: key for key, value in original_dict.items()}
print(new_dict)
```
Esto generará un nuevo diccionario `new_dict` que invertirá las llaves y valores del `original_dict`.
I didn't understand the use of %, is for division, So, Talking with GTP explained me this:
Breaking Down the Code:
`evens = [x for x in range(1, 21) if x % 2 == 0`]
* `range(1, 21)`: Generates numbers from `1` to `20` (21 is not included).
* `x % 2 == 0`: Checks if `x` is divisible by `2`. If the remainder is `0`, the number is even.
* The list comprehension collects only those `x` values that satisfy the condition.
#### Example Breakdown:
Let's manually check some values:
`x` `x % 2` `x % 2 == 0`
1 1 False
2 0 True
3 1 False
4 0 True
So the final list `evens` will be:
pythonCopyEdit`[2, 4, 6, 8, 10, 12, 14, 16, 18, 20`]
🚀
Hola. Para imprimir la matriz original y la transpuesta y que se vea de forma gráfica como una matriz se pueden utilizar:
`[print(filas) for filas in matrix]`
`[print(filas) for filas in transposed]`
Si me hubieran preguntado como transponer una matriz, antes de conocer "Comprehension List" hubiera escrito algo como:
matriz = \[\[1,2,3], \[4,5,6], \[7,8,9]]
print(matriz)
transpuesta = matriz\[:]\[:]
for i in range(len(matriz)):
for j in range(len(matriz\[0])):
transpuesta\[i]\[j] = matriz\[j]\[i]
print(transpuesta)
print(matriz)
lamentablemente, no se realiza correctamente el slice en el caso de una matriz y ambas quedan apuntando al mismo sector de memoria.
otra forma del primer ejercicio sería:
doble = \[x\*2 for x in range(1,6)]
print(doble)
Estaba algo confundido con la estructura de los codigos en los ejercicios, pero indagando un poco, veo que depende de que se pretenda hacer en el. Me explico con los ejercicios:
Por ejemplo:
```python
list5 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
multeven = [num*2 if num%2==0 else num for num in list5]list5 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(multeven)
```La estructura del codigo es:
\[nuevo\_valor if condicion else otro\_valor for item in lista]
Pero en otro caso:
```python
personas = [
{"nombre": "Juan", "edad": 25, "ciudad": "Madrid"},
{"nombre": "Ana", "edad": 32, "ciudad": "Madrid"},
{"nombre": "Pedro", "edad": 35, "ciudad": "Barcelona"},
{"nombre": "Laura", "edad": 40, "ciudad": "Madrid"}
]
Mad_30 = [per["nombre"] for per in personas if per["ciudad"] == 'Madrid' and per["edad"] > 30 ]
print(Mad_30)
```La estructura seria:
\[item for item in lista if condicion]
Esta diferencia viene a darse, en general, si queremos modificar cada elemento de una lista o si se quiere es filtrar elementos.
Si necesitas modificar cada elemento usa: \[nuevo\_valor if condicion else otro\_valor for item in lista]
Si necesitas filtrar elementos usa: \[item for item in lista if condicion]
Incluso se pueden combinar ambos asi:
Multiplicar por dos solo los pares mayores a 5:
```python
list5 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
multeven = [num * 2 if num % 2 == 0 else num for num in list5 if num > 5]
print(multeven)
```
Estaba algo confundido con la estructura de los codigos en los ejercicios, pero indagando un poco, veo que depende de que se pretenda hacer en el.
Por ejemplo:
```js
list5 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
multeven = [num*2 if num%2==0 else num for num in list5]
```La estructura del codigo es:
\[nueva\_valor if condicion else otro\_valor for item in lista]
Pero en el caso de
```js
personas = [
{"nombre": "Juan", "edad": 25, "ciudad": "Madrid"},
{"nombre": "Ana", "edad": 32, "ciudad": "Madrid"},
{"nombre": "Pedro", "edad": 35, "ciudad": "Barcelona"},
{"nombre": "Laura", "edad": 40, "ciudad": "Madrid"}
]
Mad_30 = [per["nombre"] for per in personas if per["ciudad"] == 'Madrid' and per["edad"] > 30 ]
```La estructura es:
\[item for item in lista if condicion]
Esta diferencia viene a darse, en general, si queremos modificar cada elemento de una lista o si se quiere es filtrar elementos.
Si necesitas **modificar cada elemento**, usa `[nuevo_valor if condicion else otro_valor for item in lista]`.
Si solo quieres **filtrar elementos**, usa `[item for item in lista if condicion]`.
Incluso se pueden combinar ambos asi:
### **Multiplicar por 2 solo los pares mayores a 5**
```js
list5 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
multeven = [num * 2 if num % 2 == 0 else num for num in list5 if num > 5]
print(multeven)
```
```python
transpoded = []
for i in range(len(matrix[0])):
transposed_row = []
for row in matrix:
transposed_row.append(row[i])
print(transposed)
```En la ecuacion primero encuentro i, y eso lo hago con la longitud de la primera lista de matrix, luego creo una lista vacia que es tranposed\_row. Luego creo un for internoi el cual se encarga de iterar cada lista de la matriz , luego en el append le agrego row\[i] a la lista vacia, y finalmente le agrego a la lista transposed la lista transposed\_row
asi obtenemos los numeros impares entre 1 y 20
impares = \[x for x in range(1,21) if x%2 != 0]
Yo lo hice un poco diferente a la solución propuesta:
`palabras = ["sol", "mar", "montaña", "rio", "estrella"]`
`masdetres = [] `
`for x in palabras:`
` if len(x) > 3 and x.isupper(): masdetres.append(x)`
`print(masdetres)`
\#Hallar numeros paresevens = \[x for x in range(1,20) if x%2 ==0]print(evens)
Se podria incluso crear un diccionario de conversiones de celcius y fahrenheit usando zip:
```js
celsius = [x for x in range(10,50,10)] #10, 20, 30, 40
fahrenheit = [(temp * 9/5)+32 for temp in celsius]
print("Temperatura en Celcius: ", celsius)
print("Temperatura en Fahrenheit: ", fahrenheit)
conversion = {c: f for c, f in zip(celsius, fahrenheit)}
print("Tabla de conversion:", conversion)
```celsius = \[x for x in range(10,50,10)] #10, 20, 30, 40fahrenheit = \[(temp \* 9/5)+32 for temp in celsius]
print("Temperatura en Celcius: ", celsius)print("Temperatura en Fahrenheit: ", fahrenheit)
conversion = {c: f for c, f in zip(celsius, fahrenheit)}print("Tabla de conversion:", conversion)
`# 1. Doble de los numeros`
`numeros = [1,2,3,4,5]`
`nuevaLista = [x**2 for x in numeros]`
`print(nuevaLista) #[1, 4, 9, 16, 25]`
`# 2. Filtrar y Transformar en un Solo Paso`
`palabras = ["sol", "mar", "montaña", "rio", "estrella"]`
`nuevaLista = [word.upper() for word in palabras if len(word) > 3]`
`print(nuevaLista) #['MONTAÑA', 'ESTRELLA']`
`# 3. Crear un Diccionario con List Comprehension`
`claves = ["nombre", "edad", "ocupación"]`
`valores = ["Juan", 30, "Ingeniero"]`
`nuevoDiccionario = {claves[i]: valores[i] for i in range(len(claves))}`
`print(nuevoDiccionario) # {'nombre': 'Juan', 'edad': 30, 'ocupación': 'Ingeniero'}`
`# 4. Anidación de List Comprehensions`
`matriz = [`
` [1, 2, 3],`
` [4, 5, 6],`
` [7, 8, 9]`
`]`
`nuevaMatriz = [[row[i] for row in matriz]for i in range(len(matriz[0]))]`
`print(nuevaMatriz) # [[1, 4, 7], [2, 5, 8], [3, 6, 9]]`
`# 5.Extraer Información de una Lista de Diccionarios`
`personas = [`
` {"nombre": "Juan", "edad": 25, "ciudad": "Madrid"},`
` {"nombre": "Ana", "edad": 32, "ciudad": "Madrid"},`
` {"nombre": "Pedro", "edad": 35, "ciudad": "Barcelona"},`
` {"nombre": "Laura", "edad": 40, "ciudad": "Madrid"}`
`]`
`informacion = [persona for persona in personas if persona['ciudad'] == "Madrid" and persona["edad"] > 30] `
`print(informacion) `
`#[{'nombre': 'Ana', 'edad': 32, 'ciudad': 'Madrid'}, {'nombre': 'Laura', 'edad': 40, 'ciudad': 'Madrid'}]`
`# 6.List Comprehension con un else`
`numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`
`nuevosNumeros = [numero * 2 if numero % 2 == 0 else numero for numero in numeros]`
`print(nuevosNumeros) #[1, 4, 3, 8, 5, 12, 7, 16, 9, 20]`
Wow despues de darle mente a la clase me di cuenta que la lista de transposed no es nada mas que una lista hecha con ciclos anidados, pero de una manera mas sencilla y legible.
La música del fondo esta demasiado fuerte @-@
Yo he logrado entender haciendo un desglose completo, si alguien necesita entender esto, solo léelo con calma.
Primero, recuerda que una matriz en Python es en realidad una lista, cuyos elementos son otras "sublistas". Con esta idea en mente, analicemos el código desde atrás hacia adelante, comenzando con el segundo for.
Este for solo define el rango, indicando que i puede iterar en un rango determinado. Dicho rango es la longitud del primer elemento (podría ser cualquiera) de la lista matriz. Este primer elemento es otra lista, por lo que el rango es la longitud de la sublista en la primera posición de la macrolista matriz. Recuerda que el índice 0 indica la primera posición en este caso.
Así, el rango es (0,1,2), lo que significa que el for solo establece que i tomará los valores 0, luego 1 y finalmente 2. Solo ten en mente eso de esta parte del codigo.
Ahora que sé qué valores puede tomar i, paso al primer for. Este indica "para cada fila en matriz", pero en realidad, las filas son listas dentro de la macrolista matriz. Entonces, para cada sublista en la macrolista, se ejecuta una acción. Ahora definiremos la accion con la primera parte del codigo.
Finalmente la instrucción, toma el elemento en la posición i de cada fila.
Dado que ya sabemos qué valores puede tomar i, el código en conjunto dice algo como:
crea la matrix transpuesta asi: "Toma el elemento i para cada sublista en matriz, donde i primero es 0, luego 1 y después 2."
Para i = 0, el código crea el primer elemento(Es decir primera sublista) de la matriz transpuesta (macrolista) tomando el elemento en la posición 0 de cada sublista en la macrolista matriz.
Luego, cuando termina, reemplaza i por 1 y repite el proceso.
Finalmente, asigna i = 2 y vuelve a hacer lo mismo.
Así se construye la matriz transpuesta, espero sea claro.
```python
# List comprehension for temperature conversion
celsius = [0, 10, 20, 30, 40] # Temperatures in Celsius
fahrenheit = [(9/5)*temp + 32 for temp in celsius] # Conversion to Fahrenheit
print("Temperature in Fahrenheit:", fahrenheit)
```
para impares
odds = \[x for x in range(1, 21) if x % 2 != 0]
print(odds)
Lo siento, no le entendi a la profesora asi que le pregunte a Gemini
evens = \[x for x in range (1,21) if x%2 ==0]
print(evens)
Este código en Python utiliza una **comprensión de listas** para crear una lista llamada `evens` que contiene todos los números pares entre 1 y 20.
**Explicación:**
1. `range(1,21)`**:** Esta parte crea un objeto iterable que genera una secuencia de números enteros desde 1 hasta 20 (excluyendo el 21).
2. `for x in range(1,21)`**:** Este bucle `for` itera sobre cada número (`x`) generado por `range(1,21)`.
3. `if x%2 == 0`**:** Esta condición verifica si el número actual (`x`) es divisible por 2. El operador `%` (módulo) devuelve el resto de la división. Si el resto de la división de `x` entre 2 es 0, significa que `x` es un número par.
4. `[x for x in range (1,21) if x%2 ==0]`**:** Esta parte es la comprensión de listas. Crea una nueva lista (`evens`) donde solo se incluyen los valores de `x` que cumplen con la condición `x%2 == 0`.
5. `print(evens)`**:** Finalmente, esta línea imprime la lista `evens` en la consola, mostrando los números pares que fueron seleccionados.
**En resumen:**
Este código crea una lista de números pares del 1 al 20 de manera concisa y eficiente utilizando una comprensión de listas.
**La salida de este código sería:**
`[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]`
Esta es la formula correcta:
```python
celsius = [0, 10, 20 ,30, 40]
fahrenheit = [(temp * 9/5) + 32 for temp in celsius]
print("Temperatura en F:", fahrenheit)
```
Es un lenguaje super sencillo de entender, lo que se conoce como alto nivel. Pienso que son muchísimas las posibilidades y lo que se puede hacer con el.
Dude, los ejemplos tipo "vamos a aprender a sumar", "ahora vamos a aprender a restar"... "ahora vamos a sacar derivadas".
Hola, no es el primer comentario y veo que no soy el único con el mismo problema: Pasan de ejemplos básicos a ejemplos muy estructurados donde es difícil seguir la línea, por favor tengan presente esto.
Gracias!
La estructura de una **list comprehension** es esta:
pythonCopyEdit`[nueva_expresión for item in iterable if` condición]
#### Partes:
* **nueva\_expresión**: Lo que quieres incluir en la nueva lista. En este caso, es `estudiante["nombre"]`, es decir, el valor que deseas extraer.
* **item**: Un nombre temporal para cada elemento que recorrerás en el `iterable` (en tu caso, cada `estudiante` en la lista `estudiantes`).
* **iterable**: Es la lista o colección que vas a recorrer (en este caso, `estudiantes`).
* **condición** (opcional): El filtro que solo incluye los elementos que cumplen la condición. En tu caso, las personas con más de 18 años y que tengan una nota superior o igual a 7.
el segundo me quedó así:personas = \[ {"nombre": "Juan", "edad": 25, "ciudad": "Madrid"}, {"nombre": "Ana", "edad": 32, "ciudad": "Madrid"}, {"nombre": "Pedro", "edad": 35, "ciudad": "Barcelona"}, {"nombre": "Laura", "edad": 40, "ciudad": "Madrid"}]fromMadrid = \[]for persona in personas: if persona\["ciudad"] == "Madrid" and persona\["edad"] >= 30: fromMadrid.append(persona\["nombre"]) print(fromMadrid)
```js
personas = [
{"nombre": "Juan", "edad": 25, "ciudad": "Madrid"},
{"nombre": "Ana", "edad": 32, "ciudad": "Madrid"},
{"nombre": "Pedro", "edad": 35, "ciudad": "Barcelona"},
{"nombre": "Laura", "edad": 40, "ciudad": "Madrid"}
]
fromMadrid = []
for persona in personas:
if persona["ciudad"] == "Madrid" and persona["edad"] >= 30:
fromMadrid.append(persona["nombre"])
print(fromMadrid)
```
o celsius no son 0 fahrenheits, lo correcto es
(9/5) \* temp + 32) for temp in celsius
Aquí mi reporte Joaquín
La profesora Carla es excelente, de este curso me ha gustado mucho la forma de explicar es clara.
Presento una forma para crear las temperaturas en Celsius de 0° a 100° usando `range()` , posteriormente, uso **Comprehension List** para convertir de celsius a Fahrenheit. El ciclo `for` lo usé para imprimir los elementos correspondientes de cada temperatura.
```python
celsius = list(range(10,110,10))
farenheit = [int(temp*9/5 + 32) for temp in celsius]
"""
print(f"temperatura en celcius:{celsius}")
print(f"temperatura en Farengeit:{farenheit}")
"""
print("\nTemperaturas individuales:")
for x in range(len(celsius)):
print(f"Temperatura en Celsius: {celsius[x]}, Temperatura en Fahrenheit: {farenheit[x]}")
```
En el contexto de las comprehension lists, el `i` en `row[i]` proviene de la iteración sobre el rango de índices de la matriz. Este índice `i` representa la posición de la fila que estás accediendo en la matriz. Cuando usas `for i in range(len(matriz))`, `i` tomará valores desde 0 hasta el tamaño de la matriz menos uno, permitiendo acceder a cada fila. Así, `row[i]` se refiere a la fila en la posición `i` dentro de la matriz.
Comparto las soluciones de los ejercicios:
`#Ejercicio 1``numeros = [1, 2, 3, 4, 5]`
`dobles = [x*2 for x in numeros]print(numeros)print(dobles)`
`#Ejercicio 2``palabras = ["sol", "mar", "montaña", "rio", "estrella"]`
`filtro_palabras = [x.upper() for x in palabras if len(x) > 3]`
`print(palabras)print(filtro_palabras)`
`#Ejercicio 3``claves = ["nombre", "edad", "ocupación"]valores = ["Juan", 30, "Ingeniero"]`
`persona = {claves[x]:valores[x] for x in range(len(claves))}print(persona.keys())`
`# Ejercicio 5``personas = [ {"nombre": "Juan", "edad": 25, "ciudad": "Madrid"}, {"nombre": "Ana", "edad": 32, "ciudad": "Madrid"}, {"nombre": "Pedro", "edad": 35, "ciudad": "Barcelona"}, {"nombre": "Laura", "edad": 40, "ciudad": "Madrid"}]`
`madrid_mayores_30 = [x["nombre"] for x in personas if x["edad"] > 30 and x["ciudad"] == "Madrid"]`
`print(madrid_mayores_30)`
un comando agragado a mi lista clear
Sí sería bueno revisar la estructura antes de subir la clase nueva, aplican un for antes de explicar estructuras de datos.
También en que expresion y condicion o es spanglish o no llevan tilde, minuto 1:10
Hola, me gustaría compartir que intente hacer los ejercicio de los recursos y aprendí a usar zip(), donde lo plantee de la siguiente manera:
```js
Claves= ["nombre", "edad", "ocupación"]
Valores= ["Juan", 30, "Ingeniero"]
nuevo_diccionario = {clave: valor for clave, valor in zip(Claves, Valores)}
print(nuevo_diccionario)
```Espero les sirva zip() lo use en este caso para combinar la lista y crear el diccionario.
muy buena clase. Sin embargo, me gustaría saber para el ultimo bloque de codigo en que momento se le envía informacion a transposed ya que esta la veo vacía y se esta imprimiento la de comprenhesion list la que se creo inicialmente, realmente se le esta metindo info es a transposed\_row.
hola profe, mira aqui mando la captura de los ejercicios que dejaste, los pude hacer un poco dificil pero lo logre. excelente enseñanzas
A diferencia de la mayoria de los comentarios
!!!NO ENTENDI!!!!. la parte de la matrix
En que momento del codigo le dice que cambie la posicion de las columnas a las filas.
porque segun leo y trato de entender , dice algo como
**row\[i]** (fila con posicion i y porque i y no usa x, tiene algo que ver??)
**for row in matrix** (por cada fila en la matrix, osea que revise las 3 filas)
**for i in range** (aca va a definir el rango de i)
**len(matrix)** = le pregunta algo a la matrix, pero que le pregunta
ademas no entiendo la estructura de la linea de codigo, no se supone que python al momento de ejecutar ejecuta en orden de arriba para abajo y de izquierda a derecha, entonces al momento de ejecutar en la linea de codigo primero pone **row\[i]** pero despues define que es row. ademas en que momento le dice que transponga lineas por columnas
no me den palo soy nuevo en esto
El rango en Python, definido por `range(1, 11)`, genera números del 1 al 10, excluyendo el 11. Por lo tanto, al calcular los cuadrados, solo obtienes resultados hasta el 10. Para incluir el 11, deberías usar `range(1, 12)`. Así, la expresión quedaría `for x in range(1, 12)`, lo que te permitirá calcular el cuadrado de 11 también.
aquí dejare mis respuestas a estos ejericios propuestos en esta clase
Siento que esta clase iba un poco mas adelante. Pero estuvo buena.
Realmente interesante...
Lo de la matriz como último ejemplo, si que ha sido denso de aprender
Las comprehension lists en Python permiten crear listas de forma concisa y eficiente. Aquí tienes algunos ejemplos:
1. **Cuadrados de números**:
```python
cuadrados = [x**2 for x in range(1, 11)]
```
2. **Filtrar números pares**:
```python
pares = [x for x in range(1, 21) if x % 2 == 0]
```
3. **Conversión de Celsius a Fahrenheit**:
```python
celsius = [0, 10, 20, 30, 40]
fahrenheit = [(temp * 9/5) + 32 for temp in celsius]
```
4. **Transpuesta de una matriz**:
```python
matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transpuesta = [[fila[i] for fila in matriz] for i in range(len(matriz[0]))]
```
Estos ejemplos reflejan cómo simplificar el código y hacerlo más legible.
Para alguien que no sabe aun que es un condicional ni un rango, esta clase deberia estar un poco mas abajo, muy bien explicado pero suponen que sus estudiantes ya tienen los conceptos de condicionales que aun noven del curso.
El ejercicio que comentas utiliza una comprensión de listas para filtrar elementos de la lista `palabras`. En tu caso, `seleccion` tomará solo aquellas palabras que tengan más de 3 caracteres y que estén completamente en mayúsculas. Así, la salida de tu código será:
```python
["MONTAÑA", "RIO"]
```
Tu interpretación es correcta. Este uso de comprensión de listas es eficiente y mejora la legibilidad del código. ¡Continúa practicando y explorando más sobre Python!
La transposición de una matriz consiste en intercambiar sus filas con sus columnas. Por ejemplo, si tienes una matriz:
```
1 2 3
4 5 6
7 8 9
```
Su transpuesta sería:
```
1 4 7
2 5 8
3 6 9
```
En Python, puedes lograr esto usando una **comprehension list**. En el contexto de la clase, se explicó cómo hacerlo de manera concisa. Si tienes dudas de cómo implementarlo, revisa el uso de `for` dentro de la comprensión para iterar sobre las filas y columnas.
¿Por qué se usa i?
La letra i se utiliza frecuentemente como una abreviatura de "índice" (index). Esto es una práctica común, aunque no obligatoria. Por claridad, se puede usar un nombre más descriptivo según el contexto.
Ejemplo:
for i in range(5):
print(i)
¿Por qué se usa i?
La letra i se utiliza frecuentemente como una abreviatura de "índice" (index). Esto es una práctica común, aunque no obligatoria. Por claridad, se puede usar un nombre más descriptivo según el contexto.
clear en terminal limpia la terminal
Iba tan bien, que acá me estanque :(
```js
personas = [
{"nombre": "Juan", "edad": 25, "ciudad": "Madrid"},
{"nombre": "Ana", "edad": 32, "ciudad": "Madrid"},
{"nombre": "Pedro", "edad": 35, "ciudad": "Barcelona"},
{"nombre": "Laura", "edad": 40, "ciudad": "Madrid"}
]
newPersonList = [person for person in personas if person["ciudad"] == "Madrid" and person["edad"] >= 30]
print(newPersonList)
```por si alguien lo necesita la solucion al quinto ejercicio.
También es posible escribir condicionales `if x else y:` completos. Con el ejemplo sería:
`pares = [x if x%2 == 0 else "no par" for x in range(1, 11)]`
Se pondrían solo los pares en formato de número, y los que no cumplan, en su posición aparecerá el texto `"no par"`.
`['no par', 2, 'no par', 4, 'no par', 6, 'no par', 8, 'no par', 10]`
Las list comprehensions en Python son una forma concisa y eficiente de crear listas. En el ejemplo de la clase, tienes una lista de valores Celsius. La transformación a Fahrenheit ocurre dentro de la comprensión de listas así:
```python
fahrenheit = [(temp * 9/5) + 32 for temp in celsius]
```
Internamente, Python itera sobre cada elemento de `celsius`, aplica la fórmula de conversión y construye una nueva lista. Esto reduce la necesidad de bucles explícitos, haciendo el código más legible y eficiente. Utiliza un solo bucle en una línea, que es uno de los beneficios de las comprehensions.
Buuuuuuaaahjjj, esto es otro nivel de manejo de datos :o
La música me estresa jajajaja pero buena lección Carli!
hola, no entiendo del todo el paso a paso de la transpuesta de la matriz, entiendo el que hace, pero cno el como. alguien me podria aclarar esto? corrri unos codigos para ver diferencias y el que me dejo mas intrigado fue la diferencia entre este
```python
transpose1=[row[i]for row in matrix for i in range(len(matrix[0]))]
print(transpose1)
#[1, 2, 3, 0, 4, 5, 6, 0, 7, 8, 9, 0]
transpose2=[[row[i]for row in matrix] for i in range(len(matrix[0]))]
print(transpose2)
#[[1, 4, 7], [2, 5, 8], [3, 6, 9], [0, 0, 0]]
```
Para que se entienda mejor el ejercicio de transponer con for, le puse print y así podran ir viendo como i y row van aumentando y de doonde toma los datos para transponer.
```js
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transponer = []
for i in range(len(matrix[0])):
print("Inicia i: ", i)
transponer_row = []
for row in matrix:
print("Inicia row: ", row)
print(row[i])
transponer_row.append(row[i])
print(transponer_row)
transponer.append(transponer_row)
print(transponer)
print(transponer)
```matrix = \[\[1, 2, 3], \[4, 5, 6], \[7, 8, 9]]transponer = \[]
for i in range(len(matrix\[0])): print("Inicia i: ", i) transponer\_row = \[] for row in matrix: print("Inicia row: ", row) print(row\[i]) transponer\_row.append(row\[i]) print(transponer\_row) transponer.append(transponer\_row) print(transponer)print(transponer)
Hola, me tengo una duda,, contexto
tenemos una matriz de 3x3
```js
vmatrix_base = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
```Porque el rango da el mismo resultado de esta forma
```js
print(range(len(vmatrix_base[0])), range(len(vmatrix_base)))
```range(0, 3) range(0, 3)
entiendo que obtiene el rango (tamaño) de un vector y el rango de la matriz en si, pero llega a confundir, creo que la función range debería tener algo mas para que indique el tipo, o le estoy pidiendo mucho a python, jajaja o ya estoy delirando.
El otro día tenia que hacer este simple ejercicio, no se que me paso simplemente me pasme por 15 minutos como un noob
"Dar como resultado un arreglo con los números impares con dos números X y Y tomándolos como un rango en PHP"
Solución en PHP ahora que entendí todo con Python:
```js
izq = $izq;
$this->der = $der;
}
public function impares(){
$arr = array();
$izq = $this->izq;
$der = $this->der;
for($i = $izq; $i < $der+1; $i++){
if($i%2 != 0)
array_push($arr, $i);
}
return $arr;
}
}
$obj = new Impares(1, 21);
print_r($obj->impares());
```**Solució**def impares(izq, der): impares = \[x for x in range(izq, der+1) if x%2 != 0] return impares
print(impares(int(input("Escriba el limite izquierdo: ")), int(input("Escriba el limite derecho: "))))**n con Python:**
```js
def impares(izq, der):
impares = [x for x in range(izq, der+1) if x%2 != 0]
return impares
print(impares(int(input("Escriba el limite izquierdo: ")), int(input("Escriba el limite derecho: "))))
```**<u>AHORA ENTIENDO POR QUE A LA GENTE LE GUSTA PYTHON</u>**
para los impares
odd = \[ x for x in range (1,21) if x%2 !=0]
print (odd)
alguien podría explicarme por qué mi código no imprime el transposed en código largo? no veo el error
```python
matrix = [[1,2,3],
[4,5,6],
[7,8,9]]
transposed = [[row[i] for row in matrix] for i in range(len(matrix[0]))]
print(matrix)
#print(transposed)
transposed = []
for i in range(len(matrix[0])):
trasnposed_row = []
for row in matrix:
trasnposed_row.append(row[i])
trasnposed_row.append(trasnposed_row)
print(transposed)
```
```js
# crea una nueva lista multiplicando por 2 los números pares y dejando los impares como están.
matraca = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(matraca)
pares = [m * 2 if m % 2 == 0 else m for m in matraca]
print(f"Los pares se multiplican por 2 y los impares quedaran igual \n{pares}")
```# crea una nueva lista multiplicando por 2 los números pares y dejando los impares como están.
matraca = \[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(matraca)
pares = \[m \* 2 if m % 2 == 0 else m for m in matraca]
print(f"Los pares se multiplican por 2 y los impares quedaran igual \n{pares}")
`# crea una nueva lista multiplicando por 2 los números pares y dejando los impares como están.`
`matraca = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`
`print(matraca)`
`pares = [m * 2 if m % 2 == 0 else m for m in matraca]`
`print(f"Los pares se multiplican por 2 y los impares quedaran igual \n{pares}")`
Python entiende que `temp` son los valores en Celsius a través del contexto en el que se define. En el ejemplo de comprensión de listas, `temp` se utiliza como el iterador en el bucle `for`, que recorre cada elemento de la lista de Celsius. Así, cada valor se asigna a `temp` durante la iteración, aplicando la fórmula de conversión a Fahrenheit. El uso del `for` y la estructura de la comprensión de listas permiten que Python asocie directamente `temp` con los elementos de la lista original.
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?