comment
IRC Chat
play_arrow
Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

Taller de Python #3

  • 12 Respuestas
  • 6479 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Conectado ANTRAX

  • *
  • Administrator
  • Mensajes: 5401
  • Actividad:
    41.67%
  • Reputación 31
  • ANTRAX
    • Ver Perfil
    • Underc0de
    • Email
  • Skype: underc0de.org
  • Twitter: @Underc0de
« en: Octubre 11, 2014, 11:34:57 pm »

Bienvenidos a la tercera entrega de este taller de python.

Luego de haber visto y estudiado muchos de los elementos básicos y fundamentales que cualquier programador debe conocer para poder hacer algo, hoy comenzaremos a tratar con temas más complejos, lo cual significa más herramientas para trabajar.

¡Comencemos!

Funciones

Por fin llegó el momento de hablar de este asunto tan importante. De a poco vamos viendo nuevas formas de escribir nuestro código de manera más ordenada y eficiente. Las funciones, como podrán imaginar, contribuyen a ello.

Pero, ¿qué son, concretamente, las funciones? No son más que segmentos o bloques de código bajo un nombre específico que cumplen ciertas instrucciones predefinidas, retornando siempre un valor determinado. No se asusten si no entienden nada de esta definición. Ahora veremos bien qué significa todo esto.

No sé si lo habían notado antes pero programar no es muy diferente a escribir un papel con instrucciones. Esos archivos con la extensión .py que estuvimos guardando en las entregas anteriores se asemejan mucho a los papeles que le dejamos a la abuela para saber cómo encender la pc o entrar a una página web. Vamos con un ejemplo para que quede claro.

Supongamos que queremos explicarle a la abuela cómo entrar a su cuenta de correo, a su cuenta del banco y a la página de noticias. Por suerte, nuestra abuela es bastante despierta y ya aprendió cómo encender la pc y abrir el navegador. Para lograr que la nona cumpla con su objetivo debemos ser claros y ordenados al momento de explicar los pasos a seguir.

Primero, analicemos algunos aspectos. Vamos a tener que enseñarle, como mínimo, los siguientes puntos:

-   Abrir pestañas nuevas.
-   Ingresar a una página por medio de la barra de direcciones.
-   Ingresar sus datos para acceder a las páginas que requieran credenciales.

A esto sigue la navegación propia de cada página que no viene al caso.

Como vemos, todos los pasos recién mencionados deberán ser repetidos en cada una de las páginas que mencionamos al principio (y en otras, si decidiéramos añadir más páginas).

Bien, ahora que ya tenemos una idea general de cuáles son los pasos necesarios para que la abuela ingrese a sus páginas sin inconvenientes, hagamos una lista con las instrucciones:

Ingresar a cuenta de correo:

Código: Text
  1. 1.- Identificar y clickear la barra de direcciones.
  2. 2.- Escribir “correo.com” y presionar la tecla “Enter”.
  3. 3.- Identificar formulario de usuario y escribir “usuario”.
  4. 4.- Identificar formulario de contraseña y escribir “contraseña”.
  5. 5.- Identificar botón con la etiqueta “Iniciar sesión” y clickearlo.

Ingresar a cuenta del banco:

Código: Text
  1. 1.- Identificar sector de pestañas.
  2. 2.- Clickear última pestaña (la que se encuentra vacía o con el signo +).
  3. 3.- Identificar y clickear la barra de direcciones.
  4. 4.- Escribir “banco.com” y presionar la tecla “Enter”.
  5. 5.- Identificar formulario de usuario y escribir “usuario”.
  6. 6.- Identificar formulario de contraseña y escribir “contraseña”.
  7. 7.- Identificar botón con la etiqueta “Iniciar sesión” y clickearlo.

Ingresar a página de noticias:

Código: Text
  1. 1.- Identificar sector de pestañas.
  2. 2.- Clickear última pestaña (la que se encuentra vacía o con el signo +).
  3. 3.- Identificar y clickear la barra de direcciones.
  4. 4.- Escribir “noticias.com” y presionar la tecla “Enter”.

¡Muy bien! ¡Hemos hecho un excelente trabajo! Ahora nuestra abuela podrá ingresar a estas tres páginas sin ningún tipo de inconveniente. De todas formas, hay algo que no cierra…

Seguro que alguno de ustedes se ha dado cuenta que hemos repetido unas cuantas instrucciones. No importa ahora, sólo lo hemos hecho unas dos o tres veces. No es mucho. Pero, ¿qué sucedería si tuviéramos que hacer lo mismo con otras páginas? Imagínense el tiempo que perderíamos sólo escribiendo lo mismo una y otra vez. Realmente sería mucho trabajo de más.

Entonces, ¿cómo podemos solucionar esta gran problemática? Probemos reemplazando las notas anteriores por las que siguen:

Abrir nueva pestaña:

Código: Text
  1. 1.- Identificar sector de pestañas.
  2. 2.- Clickear última pestaña (se encuentra vacía o con el signo +).

Ingresar a página (nombre de página):

Código: Text
  1. 1.- Identificar y clickear la barra de direcciones.
  2. 2.- Escribir nombre de página y presionar la tecla “Enter”.

Ingresar credenciales (usuario, contraseña):

Código: Text
  1. 1.- Identificar formulario de usuario y escribir usuario.
  2. 2.- Identificar formulario de contraseña y escribir contraseña.
  3. 3.- Identificar botón con la etiqueta “Iniciar sesión” y clickearlo.

Perfecto! Ahora sí nuestras notas son 100% funcionales. Lo que hicimos fue crear una acción o función por cada nota. Entonces, finalmente nos quedan tres notas: una para explicar cómo abrir una pestaña, otra para ingresar a una página (sirve para cualquier página, siempre y cuando se conozca su dirección) y, finalmente, una última nota para ingresar credenciales (sirve para cualquier página, siempre y cuando se conozcan el usuario y la contraseña). ¿Se entiende lo que hicimos?

Resumo un poco para los que todavía están en el aire. Al principio hicimos una nota para cada página a la que la abuela quería ingresar.

1 Nota = 1 Página

Por cada nota que hicimos tuvimos que desarrollar al menos 2 de los 3 puntos mencionados al comienzo (abrir pestañas, ingresar a la página e ingresar credenciales). Eso nos llevó a repetir instrucciones y, lo que es peor, a tener que volver a repetirlas en caso de querer hacer otra nota.

Para resolver ese problema, lo que hicimos fue crear notas que expliquen los 3 posibles pasos que debemos seguir en cualquier página, es decir, cada nota termina representando una función.

1 Nota = 1 Función

Entonces, nos quedaron 3 notas: una para abrir pestañas, otra para ingresar a una página y una última para ingresar credenciales. De esto surgen varias ventajas:

-   No repetimos instrucciones
-   Podemos aplicarlo a un número indefinido de páginas
-   Es más ordenado
-   Si tuviéramos que modificar alguna instrucción por cualquier razón, sólo lo haríamos en la nota correspondiente.

Este último punto es uno de los más importantes. Imagínense, por ejemplo, si repentinamente se cambiara el sistema de ingreso de credenciales por uno más seguro, que requiera acceso por reconocimiento de voz. En el primer sistema de notas (una nota = una página), estaríamos obligados a modificar esas instrucciones en cada una de las notas que tengamos hechas; si tuviéramos 100 páginas (100 notas) deberíamos modificarlas a todas. Qué trabajo, ¿no?

Gracias a nuestro segundo sistema, en cambio, podemos resolverlo fácilmente: buscamos la nota correspondiente al ingreso de credenciales y modificamos las instrucciones necesarias. Es decir, sólo debemos modificar una nota, y listo. Con esto ya podemos ingresar nuestras credenciales de forma correcta en cualquier página que lo solicite.


Características de las funciones

Cuando hablamos de funciones debemos distinguir dos aspectos fundamentales que pueden confundir un poco al principio: la definición y la llamada o invocación de la función.


Definición de una función

De forma genérica, podemos decir que las definiciones son fundamentales para establecer con claridad y exactitud la naturaleza de una entidad cualquiera.

La programación no es la excepción. Cada elemento integrante de un lenguaje debe ser definido de forma precisa de manera tal que podamos identificarlo y distinguirlo de las demás entidades del lenguaje.

Al definir una función, lo que hacemos es determinar con exactitud cada uno de los siguientes aspectos:

-   Nombre de la función.
-   Información que podremos brindarle a la función (son los llamados parámetros).
-   Conjunto de instrucciones que se ejecutarán al llamar a la función.
-   Valor a retornar (ya lo explicaremos).

La palabra clave para indicar que estamos por definir una función es def.

Veamos, de forma abstracta, cómo debemos definir una función:


Analicemos la imagen. En la primera línea encontramos cuatro cosas:
-   La palabra clave def.

-   El nombre de la función (esta se llama “nombre”).

-   Entre paréntesis indicamos los parámetros.

-   Como con toda estructura de control, finalizamos con dos puntos ( : ).

Las siguientes líneas corresponden al bloque de código que se ejecutará cada vez que llamemos a la función. El bloque de código se encuentra indentado y se compone de una o más instrucciones.

La indentación, a diferencia de muchos lenguajes, representa en python no sólo un tipo de notación para mejorar la legibilidad del código sino que, además, sirve al intérprete para saber dónde comienza y dónde termina cada uno de los bloques de código. Es decir, permite establecer y entender la estructura del programa.

La indentación puede realizarse con espacios o tabuladores pero nunca con ambos. De combinarse los dos anteriores, nuestro intérprete nos informará que existe un error de indentación:


De todas formas, si bien cada programador tiene su propio estilo, por convención, la indentación debería realizarse con cuatro espacios, tal y como lo indica uno de los doce mandamientos de python:

“Indenta con cuatro espacios por nivel.
Sin tabuladores.
Si rompes este mandamiento serás lapidado en la plaza del pueblo.”


Llamada a una función

Las llamadas a función no son más que las funciones en acción, es decir, si yo tengo una función determinada, ésta no se ejecutará hasta que yo la llame.

Si prestamos atención, esto nos da una enorme ventaja al momento de programar. Si tenemos un bloque de código de varias líneas que se necesitamos ejecutar en varias ocasiones, lo que hacemos es convertirlo en función y sólo empleamos una línea por cada ejecución: la correspondiente a la llamada. Como ven, el resultado es un código muchísimo más pequeño y ordenado.

Hagamos un sencillo ejemplo. Vamos a definir dos funciones: “limpiar” y “ensuciar”. Ambas van a trabajar sobre una misma variable llamada “pisoLimpio” la cual puede almacenar uno de los dos valores booleanos True y False.


Si analizamos el código, vemos que definimos dos funciones e hicimos dos llamadas, ¿no? Sin embargo, sólo una de ellas se va a ejecutar. Miren el código, analícenlo e intenten responder cuál de ellas será. En el próximo párrafo explicamos la solución.

Muy bien, primero aclaremos algunos puntos y luego veremos que la respuesta viene sola:

- Las funciones “limpiar” y “ensuciar” modifican el valor de la variable pisoLimpio.

- La variable pisoLimpio es inicializada con el valor None. A esta altura, ya sabemos que None es, en términos booleanos, falso. Por lo tanto, podemos afirmar que, inicialmente, el piso se encuentra sucio.

- Si analizamos el bloque if – else y lo traducimos al español, nos quedaría algo así: “Si el piso no está limpio, entonces llamemos a la función limpiar. De lo contrario (si está limpio), llamemos a la función ensuciar”.

Ahora sí. Sabiendo lo antedicho, estamos en condiciones de practicar el recorrido mismo realizado por el intérprete: ya que el piso no está limpio, entonces llamemos a la función “limpiar”. Fácil, ¿no?

Ahora que ya vimos, en términos generales, cómo definir una función y cómo llamarlas, profundicemos un poco en cada uno de sus aspectos.


Desentrañando las funciones

Volvamos un poco atrás y veamos más a fondo el tema de las definiciones.

Ya vimos que al definir una función nos encontramos con varios elementos. Ya los nombramos y sabemos cómo utilizarlos pero eso no es todo. Veamos cuánto jugo podemos sacarle a cada uno de ellos y avancemos a otro nivel.

¡Comencemos!

1. Nombre. Podemos nombrar o rotular a una función como  se nos ocurra, siempre y cuando no sea una palabra clave de python (para más información: No tienes permisos para ver links. Registrate o Entra con tu cuenta) y utilicen los caracteres válidos para los identificadores: las mayúsculas y minúsculas de la A a la Z, el guion bajo y, a excepción del primer carácter, los dígitos del 0 al9.

2. Parámetros. Un parámetro es una variable que puede ser recibidapor una subrutina.

Se denomina subrutina o procedimiento a un segmento de código separado del bloque principal y que puede ser invocado en cualquier momento desde éste o desde otra subrutina.

La subrutina (en nuestro caso la función) utiliza los argumentos para alterar su comportamiento en tiempo en ejecución.

Habrán notado que primero dije parámetros y, luego, argumentos. Si bien se utilizan muchas veces como sinónimos, debemos saber que no son lo mismo. Un parámetro representa un valor que el procedimiento espera que se transfiera cuando es llamado. Un argumento representa el valor que se transfiere a un parámetro del procedimiento cuando se llama al procedimiento.


Las comillas triples se utilizan en este caso como cadena de documentación, cuya función es explicar qué hace la función. Su uso no es obligatorio pero sí se considera buena práctica. En python, además, la cadena de documentación se encuentra disponible en tiempo de ejecución como atributo de la función. En caso de emplearse, debe ser lo primero que se define en la función.

Volviendo a los parámetros, y como dijimos en la definición, éstos no son obligatorios, quedando su uso determinado por nuestras necesidades al crear una función.


Al ser python un lenguaje de tipado dinámico, no debemos preocuparnos por indicar en la definición el tipo de dato que almacenarán los parámetros. Es el mismo intérprete quien se encarga de verificar esto durante la llamada a la función.


En caso de que debamos emplear más de un parámetro en nuestra función, debemos utilizar las comas(,) para separarlos.


Ahora, ¿qué sucedería si al momento de pasar los argumentos alteramos el orden? Veamos:


La salida sería la siguiente:


Con esto comprobamos que esta forma de recibir múltiples parámetros está bien, siempre y cuando sepamos que el orden de los argumentos sea el correcto. De lo contrario, deberemos buscar una forma de imprimir bien la información, a pesar de que se altere el orden de los argumentos.

Para eso podemos utilizar las llamadas keywords y pasar argumentos como pares de clave=valor.

Veamos un ejemplo para que se entienda lo antedicho.


Otra de las características de los parámetros en python es que podemos asignarles un valor por defecto (parámetros por omisión). Esto nos sirve mucho para manejar correctamente aquellos casos en los que no se nos pasen los argumentos requeridos por la función.


Ahora, ¿qué sucedería si, al momento de definir la función, no supiéramos cuántos argumentos recibirá nuestra función en tiempo de ejecución?

Esto se resuelve con los denominados parámetros arbitrarios. Gracias a esta característica, todos los argumentos recibidos llegarán a la función en forma de tupla.


Los parámetros arbitrarios suceden siempre a los fijos y para indicar su uso se utiliza un asterisco(*) inmediatamente antes del nombre que le demos al parámetro.

Veamos a nuestra función en acción:


Pero esto no es todo. Los argumentos arbitrarios, al igual que los fijos, también se pueden pasar en forma de keywords. Para ello, debemos utilizar dos asteriscos (**) delante del nombre del parámetro. Modifiquemos la función del ejemplo anterior para ejemplificar.


Ahora veamos los resultados:


Se podría decir que lo que hemos estado haciendo hasta ahora es empaquetar varios argumentos en uno solo: varios argumentos comunes en una tupla y varios de tipo clave en un diccionario.

Python nos permite realizar el paso inverso, es decir, una descomposición de un argumento en varios, en caso de ser necesario (desempaquetado de datos).

Al igual que en los casos anteriores, esto se aplica tanto para los argumentos comunes como para los de tipo clave y la metodología es similar: agregando uno o dos asteriscos, respectivamente, al argumento que vayamos a desempaquetar.

Volvamos a la función “imprimirDatosPersonales” para entenderlo.


Ahora veamos qué sucede al pasar como argumento la variable datos:


¡Perfecto! Como vemos, funcionó a la perfección. Lo único que tuvimos que hacer fue agregar un asterisco al argumento datos.

Para seguir con el ejemplo, intentemos ahora pasar los datos en forma de clave. Para eso nos armaremos un diccionario con los pares clave: valor.


Ahora pasemos la variable datos con dos asteriscos y veamos qué sucede.


Tal como esperábamos, pudimos desempaquetar los argumentos sin ningún tipo de inconveniente. Una vez más, python nos demuestra su inmenso poder.


Retorno de datos

Como dijimos anteriormente, las funciones devuelven siempre, y como mínimo, un valor determinado.
En caso de no especificarse nada, el valor de retorno es None.


Lo expuesto en la cadena de documentación podemos comprobarlo de la siguiente manera:


Para los que no entendieron nada de lo que pasó, aquí va la explicación: la función “retornarValor” devuelve, con cada ejecución, un valor None. Aprovechando esto, lo que hicimos fue asignar ese valor a la variable “valorRetornado”. Es como decir: “Al valor retornado por la función retornarValor guardémoslo en la variable valorRetornado para luego imprimirlo en pantalla”.

Podríamos conformarnos con lo anterior pero, siendo que estamos en un taller de python, sabemos que estamos lejos de decir basta. Python nos permite retornar cualquier tipo de dato, y no sólo eso, sino que, de hecho, pueden ser múltiples si queremos.

La manera explícita para hacer que una función retorne un dato específico es por medio de la sentencia return.

Al emplearla, la función terminará su ejecución, devolviendo el valor que le indiquemos.



Para retornar varios valores debemos hacerlo separándolos por medio de comas (,). A dichos valores los podemos recibir de dos maneras: por medio de una única variable o con tantas variables como valores a retornar existan.

Volvamos al ejemplo de los datos personales para ver cómo funciona todo esto.


Entonces, podemos recibir los datos de dos formas. Veamos ambas:



Es importante recordar que cada vez que utilizamos la sentencia return, estamos dando fin a la función. En ciertas ocasiones, vamos a necesitar devolver varios valores sin detener la función. Para eso podemos utilizar la sentencia yield, la cual retorna valores pero no interfiere en la ejecución de la función.


El resultado es, independientemente del número de valores que termine devolviendo la función, un objeto de tipo generator.


En los próximos talleres, cuando hablemos acerca de programación orientada a objetos(POO), veremos qué es un objeto. Por ahora, quedémonos con la idea de que es un tipo de dato más, tal como lo son las listas, los diccionarios, etcétera.

En cuanto al objeto generator, si analizamos su estructura, veremos que almacena cada uno de los datos en forma de nodo. Es decir, por cada dato se crea un nodo. Los nodos presentan un valor de carga (el que acaba de retornar la función) y un método next que apunta al próximo nodo (ya veremos en POO a qué nos referimos al hablar de métodos).

Sigamos con el ejemplo para entender un poco mejor el párrafo anterior.


Esa es la forma más simple de imprimir las cargas de cada nodo.

Vamos a hacerlo ahora de forma “manual” para entender mejor esto de los nodos.


Como vemos, la instancia del objeto “retornarSinParar” siempre es la misma (“datos”) pero el valor obtenido al ejecutar el método next va cambiando.

No se preocupen si no entienden nada de lo relacionado a POO. Son conceptos sencillos que los trataremos como corresponde en el taller correspondiente.

Por ahora, lo importante es que ya sabemos cómo recibir múltiples datos por medio de la sentencia yield (para no interrumpir la función) e imprimirlos por medio de un sencillo bucle for.


Codeando las notas de la abuela

Muy bien, existen muchos otros conceptos que debemos tratar en algún momento pero ya fue suficiente por hoy.
Dejemos algo de teoría para la próxima entrega y volvamos con la abuelita para poner en práctica todo lo que vimos a lo largo de este taller.

La tarea es transcribir las notas que hicimos para la abuela a puro código python.

Hasta ahora, lo único que ya sabemos es que para cumplir con este objetivo deberemos crear tres funciones: una para abrir pestañas, otra para ingresar a una página y otra para ingresar credenciales.

De más está decir que la creación de dichas funciones no intenta ser un límite sino que, por el contrario, espero que dejen volar su imaginación y codeen todo lo que se les venga a la mente.

Nos vemos en la próxima entrega con las soluciones y mucho más python para disfrutar.


No tienes permisos para ver links. Registrate o Entra con tu cuenta

« Última modificación: Octubre 11, 2014, 11:51:47 pm por ANTRAX »


Desconectado facufangio

  • *
  • Underc0der
  • Mensajes: 152
  • Actividad:
    0%
  • Reputación 0
  • < SE SIEMPRE EL MEJOR, PERO NO TE LO CREAS />
    • Ver Perfil
    • Email
« Respuesta #1 en: Octubre 11, 2014, 11:54:45 pm »
Excelente y muy completo taller WHIZ, sigue así!!!


Saludos

Desconectado fermino

  • *
  • Underc0der
  • Mensajes: 330
  • Actividad:
    0%
  • Reputación 1
  • Aprendiz de todo, maestro de nada...
    • Ver Perfil
    • In The Middle Of Knowledge
« Respuesta #2 en: Octubre 12, 2014, 05:23:12 pm »
Felicitaciones! Muy bien explicado ^^
Visita mi blog: No tienes permisos para ver links. Registrate o Entra con tu cuenta.

Desconectado blackdrake

  • *
  • Co Admin
  • Mensajes: 1914
  • Actividad:
    1.67%
  • Reputación 15
    • Ver Perfil
« Respuesta #3 en: Octubre 12, 2014, 05:24:38 pm »
Muy bueno, espero la siguiente entrega Whiz

Un saludo y van +1 para ti :D



Conectado Gabriela

  • *
  • Co Admin
  • Mensajes: 875
  • Actividad:
    5%
  • Reputación 15
    • Ver Perfil
    • Email
« Respuesta #4 en: Octubre 12, 2014, 05:32:26 pm »
Qué decirte WhiZ, que no te haya dicho...

La forma como formulaste el taller, me encantó. Es pedagógica.

Gracias por el esfuerzo.

Besillo.

G.

 

Desconectado WhiZ

  • *
  • Underc0der
  • Mensajes: 395
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
« Respuesta #5 en: Octubre 31, 2014, 09:00:35 am »
RESOLUCIÓN DE PRÁCTICAS

Hola gente! Aquí les dejo un videotutorial que hice explicando cómo resolver las prácticas de esta tercera entrega. Hay muchas cosas que podría haber explicado mientras hacía el video pero se me hacía muy largo, por eso decidí explicarlo codeando.





Hay algunas cosas que utilizo en el video que todavía no fueron explicadas en los talleres (por ej., el manejo de errores); lo dejo para que investiguen jeje. Al final del video les dejo más tarea. Traten de hacerlo que, al aprender un lenguaje, nada ayuda más que la práctica.

Cualquier duda o pregunta que quieran hacer, pueden hacerlo en este mismo post.

Espero que les guste!

P.D.: Aquí les dejo el código...

Código: Python
  1. # -*- coding: utf-8 -*-
  2.  
  3. ### GENERAL ###
  4.  
  5. PESTANIAS = {
  6.     0 : "http://underc0de.org",
  7.     1 : "+",
  8. }
  9.  
  10. NAVBAR = None
  11.  
  12. LOGIN_FORM = {
  13.     "user" : "",
  14.     "passwd" : "",
  15.     "iniciar sesión" : False,
  16. }
  17.  
  18. AREA_DE_TRABAJO = {
  19.     "header" : LOGIN_FORM,
  20.     "nav" : ["inicio", "noticias", "contacto"],
  21.     "section" : {"article1":"", "article2":""},
  22.     "footer" : "",
  23. }
  24.  
  25. NAVEGADOR = [
  26.     "barra de título",
  27.     "barra de menú",
  28.     "barra de herramientas",
  29.     PESTANIAS,
  30.     NAVBAR,
  31.     AREA_DE_TRABAJO,
  32.     "barra de estado",
  33. ]
  34.  
  35. ### NUEVAS PESTAÑAS ###
  36.  
  37. def abrirNuevaPestania():
  38.     # identificamos sector de pestañas
  39.     print " [*] Identificando sector de pestañas"
  40.     pestanias = identificarPestanias()
  41.     if not pestanias:
  42.         print " [!] Error"
  43.         return
  44.     print " [+] OK"
  45.  
  46.     # clickeamos última pestaña
  47.     print " [*] Clickeando última pestaña"
  48.     pestanias = clickearUltimaPestania(pestanias)
  49.     if type(pestanias) is not dict:
  50.         print " [!] Error: %s" % pestanias
  51.         return
  52.     global PESTANIAS
  53.     PESTANIAS = pestanias
  54.     print " [+] OK"
  55.  
  56. def identificarPestanias():
  57.     for elemento in NAVEGADOR:
  58.         if elemento is PESTANIAS:
  59.             return PESTANIAS
  60.     return None
  61.  
  62. def clickearUltimaPestania(pestanias):
  63.     try:
  64.         numPestanias = len(pestanias)
  65.         if numPestanias == 0:
  66.             raise Exception("No hay pestañas disponibles")
  67.         pestanias[numPestanias-1], pestanias[numPestanias] = "about:blank", "+"
  68.         return pestanias
  69.     except Exception as e:
  70.         return e.message
  71.  
  72. ### NUEVA PÁGINA ###
  73.  
  74. def abrirPagina(pagina):
  75.     # identificamos barra de direcciones
  76.     print " [*] Identificando barra de navegación"
  77.     navbar = identificarNavBar()
  78.     if not navbar:
  79.         print " [!] Error"
  80.         return
  81.     print " [+] OK"
  82.  
  83.     # ingresamos url
  84.     print " [*] Ingresando URL"
  85.     try:
  86.         global NAVBAR
  87.         NAVBAR = pagina
  88.         print " [+] OK"
  89.     except Exception as e:
  90.         print " [!] Error:", e
  91.         return
  92.  
  93. def identificarNavBar():
  94.     for elemento in NAVEGADOR:
  95.         if elemento is NAVBAR:
  96.             return True
  97.     return False
  98.  
  99. ### INGRESAR CREDENCIALES ###
  100.  
  101. def ingresarCredenciales(user, passwd):
  102.     # identificando login form
  103.     print " [*] Identificando login form"
  104.     form  = AREA_DE_TRABAJO.get("header")
  105.     if not form:
  106.         print " [!] Error"
  107.         return
  108.     print " [+] OK"
  109.  
  110.     # ingresando credenciales
  111.     print " [+] Ingresando credenciales"
  112.     try:
  113.         form["user"], form["passwd"] = user, passwd
  114.         print " [+] OK"
  115.     except Exception as e:
  116.         print " [!] Error:", e
  117.         return
  118.  
  119.     # clickeando botón 'Iniciar sesión'
  120.     print " [*] Clickeando botón 'Iniciar sesión'"
  121.     try:
  122.         form["iniciar sesión"] = True
  123.         print " [+] OK"
  124.     except Exception as e:
  125.         print " [!] Error:", e
  126.         return
  127.  
  128.  
  129. if __name__ == "__main__":
  130.     # Aquí hagan el menú ;)

Saludos!
WhiZ

« Última modificación: Octubre 31, 2014, 09:24:16 am por WhiZ »


Desconectado alexander1712

  • *
  • Underc0der
  • Mensajes: 850
  • Actividad:
    0%
  • Reputación -2
    • Ver Perfil
    • El blog del programador
    • Email
« Respuesta #6 en: Noviembre 18, 2014, 03:15:56 am »
tengo una pregunta, si escribir cuatro espacios representa presionar cuatro veces la barra espaciadora por linea y asumiendo que no hablamos de una estructura dentro de otra (sino sería 8 en caso de dos, 12 en caso de 3 estructuras anidadas, etc.), y un tabulador es solo presionar una, ¿por qué razón es más conveniente utilizar cuatro espacios?, es como si yo dijera, vamos a usar 13 espacios para cada marcar lo que corresponde a cada estructura.

En ves de hacerlo rápido, parece que a los programadores de python les gusta presionar teclas por presionar teclas xD

saludos!

Desconectado Y3K

  • *
  • Underc0der
  • Mensajes: 173
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
« Respuesta #7 en: Noviembre 18, 2014, 03:28:57 am »
No tienes permisos para ver links. Registrate o Entra con tu cuenta
tengo una pregunta, si escribir cuatro espacios representa presionar cuatro veces la barra espaciadora por linea y asumiendo que no hablamos de una estructura dentro de otra (sino sería 8 en caso de dos, 12 en caso de 3 estructuras anidadas, etc.), y un tabulador es solo presionar una, ¿por qué razón es más conveniente utilizar cuatro espacios?, es como si yo dijera, vamos a usar 13 espacios para cada marcar lo que corresponde a cada estructura.

En ves de hacerlo rápido, parece que a los programadores de python les gusta presionar teclas por presionar teclas xD

saludos!

Es código limpio y bien estructurado. ¿Por qué usar estpacios en lugar de tabulador? Me sorprende que tú lo preguntes pero te lo explico: El tabulador cuenta como un solo caracter, ésto puede crear (y lo hace) incongruencias al abrir un script en diferentes editores ya que algunos están configurados para representar el caracter tabulador como 2, 4 u 8 espacios usualmente. Al usar espacios y ya que prácticamente todos los editores usan fuentes monospace se asegura una uniformidad en la estructura de los scripts.

Además, si nos gustara "presionar teclas por presionar teclas" usaríamos PHP, C o algún lenguaje donde todo va delimitado por llaves, sin contar que se puede estructurar de una manera muy sucia y poco legíble.

Saludos.

PD: Como dato curioso, Python no te obliga a usar espacios, puedes usar tabuladores si gustas (mientras sea consistente en tu script), sólo que los que sabemos programar tendemos usar convenciones bien establecidas que nos dan uniformidad, legibilidad y buena estructura.

PPD: En caso de que no lo sepas, prácticamente todos los editores de texto se pueden configurar para insertar N cantidad de espacios al presionar Tab, así que no, no estamos apretando "espacio espacio espacio espacio" cada que hacemos un loop...
« Última modificación: Noviembre 18, 2014, 03:35:41 am por Y3K »

Desconectado gomuNoob

  • *
  • Underc0der
  • Mensajes: 6
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
    • Email
« Respuesta #8 en: Febrero 20, 2015, 01:12:37 am »
Buenas, he tenido algunos problemas siguiendo el curso en mi tablet con QPython, en la parte de retorno de valores he puedo el codigo tal cual en el editor, pero cuando lo ejecuto pasa esto:

sin embargo, si lo escribo en la consola linea por linea si que funciona Si me pudieran ayudar con esto les agradeceria mucho.

saludos y gracias!

Desconectado WhiZ

  • *
  • Underc0der
  • Mensajes: 395
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
« Respuesta #9 en: Febrero 21, 2015, 06:38:11 pm »
Hola gomuNoob! Por lo que se aprecia en la imagen, el error radica en que el código es tomado como un comando para ejecutar con /system/bin/sh. Para que el código funcione, debes hacer que el mismo sea ejecutado por el intérprete de python (tal y como hiciste en la segunda imagen).

La verdad que no estoy seguro acerca de cuál es tu duda. Cualquier cosa, no dudes en comentar y vemos.

Saludos!
WhiZ


Desconectado gomuNoob

  • *
  • Underc0der
  • Mensajes: 6
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
    • Email
« Respuesta #10 en: Febrero 22, 2015, 12:16:41 am »
No tienes permisos para ver links. Registrate o Entra con tu cuenta
Hola gomuNoob! Por lo que se aprecia en la imagen, el error radica en que el código es tomado como un comando para ejecutar con /system/bin/sh. Para que el código funcione, debes hacer que el mismo sea ejecutado por el intérprete de python (tal y como hiciste en la segunda imagen).

La verdad que no estoy seguro acerca de cuál es tu duda. Cualquier cosa, no dudes en comentar y vemos.

Saludos!
WhiZ

Hola WhiZ, gracias por responder,  lo siento por hacerte perder el tiempo con mi pregunta tan tonta, pero no tenia ni idea de le que hacia, ahora que me puse a ver videos y tal veo que fue una tonteria.

Muchas gracias y saludos :D

Desconectado la_muerte_blanca

  • *
  • Underc0der
  • Mensajes: 62
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
« Respuesta #11 en: Abril 18, 2015, 05:23:32 pm »

Hola a todos,tengo una pequeña duda en esta parte:
None es falso,por lo tanto en el if no significaría que si pisolimpiuo es verdadero limpiarlo y el else:si es sucio ensuciarlo?
Me estoy confundiendo en esta parte,gracias

Desconectado blackdrake

  • *
  • Co Admin
  • Mensajes: 1914
  • Actividad:
    1.67%
  • Reputación 15
    • Ver Perfil
« Respuesta #12 en: Abril 18, 2015, 05:25:32 pm »
No tienes permisos para ver links. Registrate o Entra con tu cuenta

Hola a todos,tengo una pequeña duda en esta parte:
None es falso,por lo tanto en el if no significaría que si pisolimpiuo es verdadero limpiarlo y el else:si es sucio ensuciarlo?
Me estoy confundiendo en esta parte,gracias

Yo lo veo de esta manera (a ver si consigo explicártelo):

pisoLimpio = false

if not(false) --> if true --> Limpiamos el piso (por lo que si está sucio, se limpia).

De lo contrario si:

pisoLimpio = true

if not(true) --> if false --> Ensuciamos el piso (por lo que si está limpio, se ensucia).

Saludos.

EDITO: Duda solucionada por IRC
« Última modificación: Abril 18, 2015, 05:31:47 pm por blackdrake »



 

¿Te gustó el post? COMPARTILO!



Taller de pentesting con Kali Linux - Parte I

Iniciado por ANTRAX

Respuestas: 57
Vistas: 33454
Último mensaje Octubre 26, 2018, 11:01:57 am
por octopus
Taller de Pentesting con Kali Linux #2

Iniciado por ANTRAX

Respuestas: 32
Vistas: 22519
Último mensaje Noviembre 10, 2017, 07:40:18 am
por Brittsman97
Taller de Seguridad Wireless #3

Iniciado por ANTRAX

Respuestas: 14
Vistas: 8247
Último mensaje Septiembre 28, 2014, 12:25:27 am
por Gabriela
Taller de Seguridad Wireless #5

Iniciado por ANTRAX

Respuestas: 17
Vistas: 8318
Último mensaje Mayo 21, 2018, 11:15:37 pm
por K1llj0y
Taller Programación en Ruby #1

Iniciado por ANTRAX

Respuestas: 8
Vistas: 5156
Último mensaje Julio 12, 2016, 11:06:52 pm
por m86d19o