Python / Parametros de ingreso

Bienvenidos sean a este post, hoy veremos como se pueden pasar valores a traves de los argumentos de las funciones.

Hemos visto en este post cuando hablamos de una funcion que recibia un valor y despues lo procesabamos entre distintos condicionales, es decir que una funcion puede recibir o no un valor para poder procesarlo, veamos tres puntos claves sobre este tipo de dato:

• El argumento informado solo afecta a una variable local de la funcion
• Asignar un objeto a un argumento interno de una funcion interna no afecta al llamador
• Modificar el argumento de un objeto mutable en una funcion afecta al llamador

Con esto comentado podemos pasar a hablar sobre los casos que representan a los tres puntos que mencionamos, veamos el primer caso que representa el pasaje de argumentos directamente.

Esta es la forma mas basica y que ya hemos visto en posts anteriores, para entender el concepto vamos a definir primero la funcion como se ve a continuacion:

>>> def funcion(y) :
...     print(y)
...

Con nuestra funcion creada hagamos lo siguiente para verificarlo:

>>> x = 3
>>> funcion(x)
3
>>>

Creamos una nuevo nombre llamado x y le asignaremos el valor de 3, si se lo pasamos a la funcion esta nos devolvera el valor que le pasamos porque como dijimos antes los valores informados de esta forma solo afectan a los nombres locales de la funcion, por lo tanto el nombre como el nombre de la funcion no poseen el valor de x sino que tienen una referencia que apunta al valor almacenado en el espacio de memoria del nombre x, veamos el siguiente tipo.

El siguiente caso es cuando el argumento pasado no afecta al llamador, veamos el siguiente ejemplo:

>>> def funcion(y) :
...     x = 7
... 
>>> x = 3
>>> funcion(x)
>>> print(x)
3
>>>

En este caso definimos nuevamente a funcion pero esta vez no para mostrar el valor recibido sino para que modifique el valor de x, luego definimos un x de tipo global, llamamos a la funcion y mostramos el valor de x pero vemos que nos devolvio el valor global y no el de la funcion, esto es debido a lo hablado siempre, como la x de la funcion es local muere cuando se termina la misma y a su vez no puede modificar a estos, es decir que una variable dentro de una funcion no puede modificar una variable global o desde donde se la llamo, veamos el siguiente caso.

Esta situacion es cuando modificamos un tipo mutable si afecta al llamador, para entenderlo veamos el siguiente ejemplo:

>>> x = [1, 2, 3]
>>> def funcion(y) :
...     x[1] = 13
... 
>>> funcion(x)
>>> print(x)
[1, 13, 3]
>>>

En este codigo primero creamos una lista, definimos nuevamente a funcion para que modifique la segunda posicion de la lista, llamamos a la funcion e imprimimos el valor de x, y ohhh sorpresa se modifico la posicion solicitada, esto quiere decir que los tipos mutables que esten en el llamador pueden ser modificados, vamos a ver un tema con respecto a esto:

>>> x = [1, 2, 3]
>>> def funcion(x) :
...     x[1] = 13
...     x = "otras cosas"
... 
>>> funcion(x)
>>> print(x)
[1, 13, 3]
>>>

Esto es muy similar al caso anterior pero ahora tenemos una variable local llamada x que no afecta al resto porque es solamente local aunque no es una practica recomendable porque dos variables que se llamen iguales puede ser confuso y se debe evitar esto pero esto sirve de ejemplo, con esto cubrimos los tres puntos claves a los cuales debemos prestar atencion al momento de crear funciones, nuestro siguiente tema es como podemos pasar la informacion para ello veamos las opciones disponibles:

• Posicionales
• Palabras claves
• Posicional variable
• Palabra clave variable
• Palabra clave solo

La primera opcion es la mas habitual, se pueden pasar todos los argumentos que se necesiten y los mismos seran separados por comas, veamos el siguiente ejemplo:

>>> def funcion(a, b, c) :
...     print(a, b, c)
... 
>>> funcion(1,2,3)
1 2 3
>>>

Como pueden ver los valores que pasamos se asignan a cada variable que establecimos como argumentos, asi como lo pasamos lo recibe y lo procesa, pasemos al siguiente tipo como son las palabras clave:

>>> def funcion(a, b, c) :
...     print(a, b, c)
... 
>>> funcion(c=3, a=1, b=2)
1 2 3
>>>

La funcion sigue siendo la misma pero al momento de pasarlo le decimos cual valor va a cual variable, por lo tanto la funcion al recibirlo asigna los valores dependiendo a quien se lo asignamos y no por el orden que lo informamos, vean como obtenemos la misma salida pero esta forma de trabajar tambien nos da una opcion como es el valor predeterminado, modifiquemos el caso anterior de la siguiente forma:

>>> def funcion(a, b, c=4) :
...     print(a,b,c)
... 
>>> funcion(1, 2)
1 2 4
>>>

Esta vez en la funcion cuando definimos a las variables de los argumentos a una le asignamos un valor por medio de un igual (=), esto se denomina valor predeterminado y le dice al lenguaje que en caso de no recibir un dato para este argumento le asigne ese valor, vean como al llamarlo solo pasamos dos valores y en lugar de devolver un error nos devuelve los dos valores informados y el ultimo dato es el predeterminado, nuestro siguiente caso es el de las posiciones variables, para entenderlo mejor usaremos el siguiente ejemplo:

>>> def minimo(*n) :
...     if n:
...             mn = n[0]
...             for valor in n[1:] :
...                     if valor < mn:
...                             mn = valor
...             print(mn)
... 
>>>

En este caso vamos a crear una nueva funcion para obtener el valor minimo de todos los informados, si observan cuando recibe el argumento usamos un asterisco (*), esto le dice al sistema que los argumentos son variables y no esta definido la cantidad de los mismos, despues chequeamos si n (los argumentos recibidos) existen, es decir que son distintos de nada, si es verdad procede a guardar en mn el primero valor que tenemos informado, despues tenemos un bucle for donde usaremos a valor para almacenar el numero informado y despues comenzaremos desde la posicion 1 (la segunda posicion) hasta el final de los informados, dentro tenemos un condicional donde verifica si valor es menor al almacenado en mn si es verdad procede a reemplazarlo, una vez terminado el ciclo lo muestra en pantalla, veamos como trabaja con los siguientes datos:

>>> minimo(1,3,-7,9)
-7
>>> minimo(1,3,2,4)
1
>>> minimo()
>>>

Como pueden ver si le pasamos una serie de valores nos devuelve el valor mas chico siempre y sino informamos ninguno nos devuelve en blanco y no provoca ningun error, esto gracias al condicional, con esto comentado podemos pasar al siguiente caso como son las palabras claves variables, para este caso en particular vamos a generar un archivo llamado argumentos.py y le agregaremos el siguiente codigo:

argumentos.py

def conectar(**opciones) :
	param_con = {
		'host' : opciones.get('host','127.0.0.1'),
		'puerto' : opciones.get('port',5432),
		'usuario' : opciones.get('usuario',''),
		'clave' : opciones.get('clave',''),
	}

	print(param_con)

conectar()
conectar(host='127.0.0.42',puerto=5433)
conectar(puerto=5431, usuario='tinchicus', clave='clave123')

En este caso las palabras clave variables son muy similar al caso anterior pero en lugar de usar un asterisco utiliza dos asteriscos (**), luego definimos un diccionario y por medio de get obtenemos los valores y les pasamos valores predeterminados, en este caso usaremos cuatro datos:

• host
• puerto
• usuario
• clave

Una vez obtenidos los datos y asignados en param_con procedemos a mostrarlo en pantalla, con esto tenemos la funcion definida nuestro siguiente paso sera llamar a la funcion conectar sin ningun parametro, y luego la llamaremos dos veces y con distintos parametros, si observan esta vez pasamos las palabras clave que se relacionan con los argumentos que debemos asignar en param_con (parametros de conexion) y son los que buscaran los get de cada dato, con esto concluimos el archivo pasemos a probarlo a ver que sucede:

tinchicus@dbn001vrt:~/python$ python3 argumentos.py 
{'host': '127.0.0.1', 'puerto': 5432, 'usuario': '', 'clave': ''}
{'host': '127.0.0.42', 'puerto': 5432, 'usuario': '', 'clave': ''}
{'host': '127.0.0.1', 'puerto': 5432, 'usuario': 'tinchicus', 'clave': 'clave123'}
tinchicus@dbn001vrt:~/python$

Vean como al no encontrar los datos informados procedio a reemplazarlos con los valores predeterminados que pasamos en cada get, para nuestro ultimo caso veamos el siguiente ejemplo primero:

>>> def spc(*a, c) :
...     print(a, c)
... 
>>>

En este caso hablamos de solo palabra clave, este se implemento a partir de la version 3 y en este caso si observan utilizamos las de argumentos variables y la que sera de palabra clave la aplicaremos a la c, en caso de estar bien creada nos mostrara los datos enviados, veamos un ejemplo:

>>> spc(1, 2, 3, c=13)
(1, 2, 3) 13
>>>

En este caso los valores 1, 2 y 3 seran asignados al argumento a y despues tenemos a c=13 y permitira a nuestra funcion correr con exito como vemos en la salida, observen que nos genero una lista de los tres primeros numeros y nos separo el 13 de la c, vamos a ver como funciona con el siguiente ejemplo:

>>> spc(3, 13)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: spc() missing 1 required keyword-only argument: 'c'
>>>

Nos devolvio un error porque si lo ven nos informa que debemos pasar un argumento de palabra clave y en este caso es c, veamos otro ejemplo creando la siguiente funcion:

>>> def spc2(a, b=42, *, c) :
...     print(a, b, c)
... 
>>>

Esta es una funcion particular porque tenemos tres argumentos:

• a, un argumento de asignacion
• b, un argumento de palabra clave y con un valor predeterminado
• c, sera nuestra palabra clave sola

Esto es debido al asterisco (*) seguido de la coma, con esto definimos a cual sera la palabra clave sola, vamos a probarlo:

>>> spc2(3,c=13)
3 42 13
>>>

Observen que pasamos dos valores, como el segundo dato esta asignado en c toma que el primer valor sera para a y para b usa el valor predeterminado, vean la salida, ahora vamos a probar sin la palabra clave:

>>> spc2(3, 23)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: spc2() missing 1 required keyword-only argument: 'c'
>>>

Nos ocurre el mismo error que vimos antes y si probamos lo siguiente nos devolvera un error:

>>> spc2(3, b=15, 23)
  File "<stdin>", line 1
SyntaxError: positional argument follows keyword argument
>>>

En este caso encuentra la palabra clave pero como no es la que definimos nos devuelve otro error, hasta aqui cubrimos lo basico de parametros de ingreso pero continuaremos en el siguiente post.

En resumen, hoy hemos visto las distintas formas de como ingresar parametros en los argumentos, hemos hablado sobre las tres puntos claves de como afectamos a la funcion con nuestros ingresos y despues vimos como son las cinco formas de pasar valores a traves de los argumentos de las funciones, espero les haya sido util sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.