Pensamiento Computacional · Unidad 2 — Datos, expresiones y funciones
Funciones
Una función es un bloque con nombre que recibe datos y devuelve un resultado. return entrega el valor; print sólo lo muestra. No son lo mismo.
La explicación
Definir y llamar
return n * 2
resultado = doble(5) # llamada → resultado vale 10
defabre la definición; los dos puntos y la indentación marcan el cuerpo.nes el parámetro: el nombre que usa la función para lo que reciba.- El
5de la llamada es el argumento: el valor concreto. - Definir no ejecuta nada. El cuerpo corre recién cuando la llamás.
return contra print — la distinción que más se pregunta
print muestra. El valor aparece en pantalla y se pierde.return entrega. El valor vuelve a quien llamó y se puede usar.Una función con
print y sin return devuelve None.
Por eso esto falla:
print(n * 2) # muestra pero no devuelve
x = doble(5) # imprime 10
print(x + 1) # error: None + 1
return; si dice
"mostrar" o "imprimir", va print. Y en la duda, return: el que llama
siempre puede imprimir después, pero no puede recuperar lo que sólo se mostró.
return corta la función
En cuanto se ejecuta un return, la función termina. Lo que venga después no corre:
if n > 0:
return "positivo"
return "no positivo" # sólo llega acá si n no era > 0
Varios parámetros, y devolver varias cosas
return a // b, a % b
c, r = dividir(7, 2) # c vale 3, r vale 1
El orden de los argumentos importa: dividir(7, 2) no es lo mismo que
dividir(2, 7).
Por qué conviene usarlas
Una función se escribe una vez y se usa muchas. Si hay un error, se arregla en un solo lugar.
Y sobre todo: le pone nombre a una idea. es_capicua(palabra) se entiende sin
leer el cuerpo; las cinco líneas sueltas que hacen lo mismo, no.
Una función tiene que recibir un número y devolver su valor absoluto. ¿Cuál de estas dos versiones sirve, y por qué?
Versión A:
if n < 0:
print(-n)
else:
print(n)
Versión B:
if n < 0:
return -n
return n
Las dos "funcionan" si sólo las mirás correr, porque absoluto(-5) hace
aparecer un 5 en pantalla en los dos casos. La diferencia aparece al querer usar el resultado:
Con la versión A eso es None + None → error. Con la B da 8.
else: si n era
negativo, el return ya cortó la función y nunca se llega a la última línea. Es un
patrón muy común y hace el código más plano.
El control: probá print(absoluto(-5) + 1). Si tira
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int', te faltó
un return. Ese mensaje con NoneType casi siempre significa eso.
Una función tiene que calcular el IVA (21%) de un precio. ¿Cuál de estas dos versiones sirve y por qué? def iva_a(p): print(p * 0.21) · def iva_b(p): return p * 0.21
Las dos "funcionan" si uno las prueba sueltas en la consola: las dos muestran 21.0 al llamarlas con 100. La diferencia aparece recién cuando se quiere usar el resultado.
Qué hace cada una, con precisión:
iva_b(100) → no escribe nada y devuelve 21.0
Toda función que no tiene return devuelve None, que es el valor "nada". No es cero ni es un texto vacío: es un objeto que no se puede sumar, multiplicar ni comparar con números.
La prueba que separa a las dos:
# TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'
El mensaje de error es literalmente "unsupported operand type(s) for +: 'NoneType' and 'int'", y traducido dice: estás tratando de sumarle 100 a nada. Cuando aparece un error que menciona NoneType, casi siempre es esto: una función que imprime en vez de devolver.
Con la segunda versión, en cambio, el resultado se puede usar:
La regla práctica, que resuelve el 90 % de los casos:
una función que MUESTRA algo → print
y casi nunca las dos cosas a la vez
Por qué "casi nunca las dos". Una función que calcula y además imprime es imposible de reutilizar en silencio: si querés usarla adentro de un ciclo de mil vueltas, te llena la pantalla. Conviene que calcule y que quien la llama decida si mostrar el resultado.
La versión completa, separando las dos responsabilidades:
return precio * 0.21
precio = 100
print("IVA:", iva(precio))
print("Total:", precio + iva(precio))
Un detalle que aparece en los parciales: return corta la función en el acto. Lo que esté escrito después de un return que se ejecuta no corre nunca. Eso se usa a favor para salir temprano de un ciclo, pero también explica por qué a veces "la segunda mitad de la función no hace nada".
Cómo detectarlo cuando el programa no anda: si una variable termina valiendo None sin motivo, hay que ir a la función que la produjo y buscar si tiene return. Es lo primero que conviene mirar.
Dónde se pierde el punto: contestar "las dos sirven, es lo mismo". Se ven iguales al probarlas y no lo son: una devuelve un número y la otra devuelve nada. El ejercicio pide justamente notar esa diferencia.
Dónde se cae la mayoría
- Usar print donde el enunciado pedía return, y que la función devuelva None.
- Esperar que el cuerpo se ejecute al definir la función. Corre recién en la llamada.
- Olvidar los dos puntos del def, o no indentar el cuerpo.
Hasta acá la explicación. La práctica es la otra mitad: 8 ejercicios de este tema, en cuatro niveles, que no te dicen sólo si está bien al final sino que te corrigen en cada paso y te explican por qué. Y uno para escribir el programa vos, que se prueba ejecutándolo en Python ahí mismo, en el navegador. Además trae una animación que muestra la idea en movimiento.
Practicar Funciones →Dónde entra este tema en el parcial
- Primer parcial — Completar: buscar con un while20 puntos · resuelto paso a paso
- Primer parcial — Completar: armar una lista nueva20 puntos · resuelto paso a paso
- Primer parcial — Encontrar los errores y explicarlos30 puntos · resuelto paso a paso
- Segundo parcial — Encontrar y explicar los errores30 puntos · resuelto paso a paso
Los otros temas de la unidad 2
Datos, expresiones y funciones