TELECOMUNICACIONES Y DESARROLLO DE SOFTWARE

martes, 3 de enero de 2017

HISTORIA DE PYTHON

¿HISTORIA DE PYTHON?

Este lenguaje de programación fue creado a principios de los años 90 por Guido Van Rossum inspirado en un grupo de cómicos ingleses "Monty Python". Este lenguaje de programación es similar a Perl pero este posee una sintaxis más limpia y el código es más legible.

Este es un lenguaje interpretado o de Script, con tipado dinámico, fuertemente tipado, multiplataforma y orientado a objetos.

Lenguaje interpretado o de Script: Se ejecuta utilizando un programa intermedio llamado intérprete, en lugar de compilar el código a lenguaje máquina que pueda comprender y ejecutar directa mente una computadora (lenguajes compilados).

La ventaja de los lenguajes compilados es que su ejecución es más rápida. Sin embargo los lenguajes interpretados son más flexibles y más portables.

Python tiene, no obstante, muchas de las características de los lenguajes compilados, por lo que se podría decir que essemi interpretado. En Python, como en Java y muchos otros lenguajes, el código fuente se traduce a un pseudo código máquina intermedio llamado bytecode la primera vez que se ejecuta, generando archivos .pyc o .pyo (bytecode optimizado), que son los que se ejecutarán en sucesivas ocasiones.

Tipado Dinámico: La característica de tipado dinámico se refiere a que no es necesario declarar el tipo de dato que va a contener una determinada variable, sino que su tipo se determinará en tiempo de ejecución según el tipo del valor al que se asigne, y el tipo de esta variable puede cambiar si se
le asigna un valor de otro tipo.

Fuertemente tipado: No se permite tratar a una variable como si fuera de un tipo distinto al que tiene, es necesario convertir de forma explícita dicha variable al nuevo tipo previamente. Por ejemplo, si tenemos una variable que contiene un texto (variable de tipo cadena o string) no podremos tratarla como un número (sumar la cadena “9” y el número 8). En otros lenguajes el tipo de la variable cambiaría para adaptarse al comportamiento esperado, aunque esto es más propenso a errores.

Multiplataforma: El intérprete de Python está disponible en multitud de plataformas (UNIX, Solaris, Linux, DOS, Windows, OS/2, Mac OS, etc.) por lo que si no utilizamos librerías específicas de cada plataforma nuestro programa podrá correr en todos estos sistemas sin grandes cambios.

Orientada a objetos: La orientación a objetos es un paradigma de programación en el que los conceptos del mundo real relevantes para nuestro problema se trasladan a clases y objetos en nuestro programa. La ejecución del programa consiste en una serie de interacciones entre los objetos. Python también permite la programación imperativa, programación funcional y programación orientada a aspectos

Información tomada de: Python Para Todos (Raúl Gonzalez Duque)
http://mundogeek.net/tutorial-python/

jueves, 22 de diciembre de 2016

VALIDAR USUARIO Y CONTRASEÑA EN PYTHON (2 FORMA: CLASES)

Hola esta es otra forma de realizar el ejercicio utilizando clases y gracias al usuario Sergabrod, quien colaboró para realizar el ejercicio de otra forma. Volveré a poner los enunciados.

También puedes ver la primera solución acá (1ra forma)

Este ejercicio lo tomé de la página: http://librosweb.es/libro/python/capitulo_6/ejercicios.html

1. MÓDULO USUARIO.(usuario)

Crear un módulo para validación de nombres de usuarios. Dicho módulo, deberá cumplir con los siguientes criterios de aceptación:

1.1 El nombre de usuario debe contener un mínimo de 6 caracteres y un máximo de 12.
1.2 El nombre de usuario debe ser alfanumérico.
1.3 Nombre de usuario con menos de 6 caracteres, retorna el mensaje "El nombre de usuario debe contener al menos 6 caracteres".
1.4 Nombre de usuario con más de 12 caracteres, retorna el mensaje "El nombre de usuario no puede contener más de 12 caracteres".
1.5 Nombre de usuario con caracteres distintos a los alfanuméricos, retorna el mensaje "El nombre de usuario puede contener solo letras y números".
1.6 Nombre de usuario válido, retorna True.

class usuario_validar():
    
    errors=[]
    
    def longitud(self,username):
        if len(username)<6:
            self.errors.append('El nombre de usuario debe contener al menos 6 caracteres')
            return False

        elif len(username)>12:
            self.errors.append('El nombre de usuario debe contener maximo 12 caracteres')
            return False

        else:
            return True
    
    def alfanumerico(self,username):
        if username.isalnum()==False:
            self.errors.append('El nombre de usuario puede contener solo letras y numeros')
            return False
        else:
            return True

    def validar_usuario(self,username):
        valido=self.longitud(username) and self.alfanumerico(username)
        return valido

2. MÓDULO PASSWORD.(password)

Crear un módulo para validación de contraseñas. Dicho módulo, deberá cumplir con los siguientes criterios de aceptación:
2.1 La contraseña debe contener un mínimo de 8 caracteres.
2.2 Una contraseña debe contener letras minúsculas, mayúsculas, números y al menos 1 carácter no alfanumérico.
2.3 La contraseña no puede contener espacios en blanco.
2.4 Contraseña válida, retorna True.
2.5 Contraseña no válida, retorna el mensaje "La contraseña elegida no es segura".

class password_validar():

    errors=[]

    def longitud(self, passw):
        if len(passw) < 8:
            self.errors.append('La contrasena debe tener al menos 8 caracteres')
            return False
        else:
            return True

    def minuscula(self, passw):
        letras_minuscula=False
        for carac in passw:
            if carac.islower()==True:
                letras_minuscula=True
        if not letras_minuscula:
            self.errors.append('La contrasena debe tener al menos una minuscula')
            return False
        else:
            return True

    def mayuscula(self, passw):
        letras_mayuscula=False
        for carac in passw:
            if carac.isupper()==True:
                letras_mayuscula=True
        if not letras_mayuscula:
            self.errors.append('La contrasena debe tener al menos una mayuscula')
            return False
        else:
            return True

    def numero(self, passw):
        num=False
        for carac in passw:
            if carac.isdigit()== True:
                num=True

        if not num:
            self.errors.append('La contrasena debe tener al menos un numero')
            return False
        else:
            return True

    def no_alfanumerico(self, passw):
        if passw.isalnum()==True:
            self.errors.append('La contrasena debe tener al menos un caracter no alfanumerico')
            return False
        else:
            return True

    def espacios(self, passw):
        if passw.count(" ")> 0:
            self.errors.append('La contrasena no puede contener espacios en blanco')
            return False
        else:
            return True

    def validar_password(self,passw):
        valido=self.longitud(passw) and self.minuscula(passw) and self.mayuscula(passw) and self.numero(passw) and self.no_alfanumerico(passw) and self.espacios(passw)
        return valido

3. MÓDULO VALIDADOR.(login)

Crear un módulo que solicite al usuario el ingreso de un nombre de usuario y contraseña y que los valide utilizando los módulos generados en los dos ejercicios anteriores. Solución módulo validador.

# -*- coding: utf-8 -*-

import usuario  as uv
import password as pv

user_validator = uv.usuario_validar()
pass_validator = pv.password_validar()

correcto= False

while correcto==False:
    nombre = raw_input('Ingrese su nombre de usuario: ')
    if not user_validator.validar_usuario(nombre):
        for error in user_validator.errors:
            print error
            correcto=False
            user_validator.errors.remove(error)           
    else:
        correcto=True
            
while correcto==True:        
    passwd = raw_input('Ingrese su contraseña: ')
    if not pass_validator.validar_password(passwd):
        for error in pass_validator.errors:
            print error
            correcto=True
            pass_validator.errors.remove(error)
    else:
        correcto=False

Video prueba:

Si tienen alguna duda con gusto la puedo aclarar.

sábado, 17 de septiembre de 2016

COMANDOS BÁSICOS MYSQL PARA PYTHON

MANEJO BASES DE DATOS MYSQL.

Crear base de datos MySQL Workbench 6.3

CREAR BASE DE DATOS.
ELIMINAR BASE DE DATOS.
MOSTRAR BASES DE DATOS.
USAR BASE DE DATOS.
CREAR TABLAS.
MOSTRAR TABLAS DE UNA BASE DE DATOS.
AGREGAR DATOS A LA TABLA.
MOSTRAR DATOS RELATIVOS DE LA TABLA.
MOSTRAR REGISTRO DE LA TABLA.
ELIMINAR DATOS DE LA TABLA.
ACTUALIZAR O MODIFICAR DATOS DE LA TABLA.
BUSQUEDA DE DATOS EN LA TABLA.
ACTUALIZAR DATOS CON ARITMÉTICA DE LA TABLA.
CAMBIAR EL NOMBRE DE LA TABLA
ELIMINAR TABLA O TABLAS.
ELIMINAR LOS REGSTROS DE LAS TABLAS.S.

Comandos:

CREAR BASE DE DATOS:

CREATE DATABASE prueba;

ELIMINAR BASE DE DATOS:

DROP DATABASE prueba;

MOSTRAR BASES DE DATOS CREADAS:

SHOW DATABASES;

USAR UNA BASE DE DATOS:

USE prueba;

CREAR TABLAS:

CREATE TABLE ejercicio (id_elemento INT auto_increment ,
Item VARCHAR(20) NOT NULL,
Cantidad INT(10) default NULL,
Precio float(20) default NULL,
constraint pk_id_elemento primary key (id_elemento)
);

MOSTRAR TABLAS EN UNA BASE DE DATOS:

SHOW TABLES;

AGREGAR DATOS A LA TABLA:

INSERT ejercicio (Articulo, Cantidad, Precio)

VALUES (‘Borrador’, 2, 230);

INSERT ejercicio (Articulo, Cantidad, Precio)

VALUES (‘Cuaderno’, 12, 1350);

INSERT ejercicio (Articulo, Cantidad, Precio)

VALUES (‘Lápiz’, 30, 500);

INSERT ejercicio (Articulo, Cantidad, Precio)

VALUES (‘Lapicero’, 40, 900);

MUESTRA DATOS RELATIVOS DE LA TABLA:

SHOW COLUMNS FROM ejercicio;

MOSTRAR LOS REGISTROS QUE ESTÁN EN LA TABLA

SELECT * FROM ejercicio;

ELIMINAR DATOS DE LAS TABLAS.

DELETE FROM ejercicio WHERE Item = 'Lapicero' AND id_elemento = 4

ACTUALIZAR O MODIFICAR DATOS DE LA TABLA

UPDATE ejercicio SET Cantidad = 35

WHERE Item = 'Borrador';

BUSQUEDA DE DATOS

SELECT * FROM ejercicio WHERE Item='Lápiz'

ACTUALIZAR DATOS DE LA TABLA CON ARITMÉTICA

UPDATE ejercicio SET Cantidad = Cantidad -1

WHERE Item = 'Lápiz' AND id_elemento = 3;

CAMBIAR NOMBRE DE TABLA

RENAME TABLE ejercicio TO EJERCICIO_FINAL

ALTER TABLE ejercicio_final RENAME ejercicio

ELIMINAR TABLA O TABLAS

DROP TABLE IF EXISTS prueba, prueba1, prueba2…etc

ELIMINAR TODOS LOS REGISTROS DE LA TABLA.

TRUNCATE TABLE ejercicio;

jueves, 11 de agosto de 2016

¿CÓMO MOSTRAR EL CÓDIGO HTML DE UNA PÁGINA WEB CON PYTHON?

Hola en esta entrada voy a mostrar un código que permite obtener el código HTML de cualquier página el Python.

En este caso se obtiene el código HTML de la página www.google.com

import sys
from PyQt4.QtGui import QApplication
from PyQt4.QtCore import QUrl
from PyQt4.QtWebKit import QWebView


class Browser(QWebView):
    def __init__(self):
        QWebView.__init__(self)
        self.loadFinished.connect(self._result_available)

    def _result_available(self, ok):
        frame = self.page().mainFrame()
        print unicode(frame.toHtml()).encode('utf-8')

if __name__ == '__main__':
    app = QApplication(sys.argv)
    view = Browser()
    view.load(QUrl('http://www.google.com'))
    app.exec_()

Al ejecutar el código, obtenemos:

Es todo. Muchas gracias.

¿CÓMO CREAR SUBVENTANAS EN PYTHON-PYQT?

Hola en esta entrada explicaré una forma en utilizar subventanas en PyQT utilizando otras interfaces gráficas independientes, en este caso crearé 3 interfaces gráficas diferentes. Utilizaré ejercicios que ya he usado previamente y que también los puede encontrar en el BLOG.

PASO 1: Crear la primera interfaz gráfica y convertir de .ui a .py. Esta interfaz es para escoger si quiero ver un mapa o una imágen.

Se hace la conversión del archivo ejemplo.ui a ejemplo.py
ejemplo.py

# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'ejemplo.ui'
#
# Created by: PyQt4 UI code generator 4.11.4
#
# WARNING! All changes made in this file will be lost!

from PyQt4 import QtCore, QtGui

try:
    _fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
    def _fromUtf8(s):
        return s

try:
    _encoding = QtGui.QApplication.UnicodeUTF8
    def _translate(context, text, disambig):
        return QtGui.QApplication.translate(context, text, disambig, _encoding)
except AttributeError:
    def _translate(context, text, disambig):
        return QtGui.QApplication.translate(context, text, disambig)

class Ui_Dialog(object):
    def setupUi(self, Dialog):
        Dialog.setObjectName(_fromUtf8("Dialog"))
        Dialog.resize(233, 129)
        self.pushButton = QtGui.QPushButton(Dialog)
        self.pushButton.setGeometry(QtCore.QRect(40, 30, 141, 23))
        self.pushButton.setObjectName(_fromUtf8("pushButton"))
        self.pushButton_2 = QtGui.QPushButton(Dialog)
        self.pushButton_2.setGeometry(QtCore.QRect(40, 60, 141, 23))
        self.pushButton_2.setObjectName(_fromUtf8("pushButton_2"))

        self.retranslateUi(Dialog)
        QtCore.QMetaObject.connectSlotsByName(Dialog)

    def retranslateUi(self, Dialog):
        Dialog.setWindowTitle(_translate("Dialog", "Dialog", None))
        self.pushButton.setText(_translate("Dialog", "MAPA", None))
        self.pushButton_2.setText(_translate("Dialog", "IMAGEN", None))

PASO 2: La segunda interfaz gráfica la vamos a tomar de un ejercicio que se hizo anteriormente en el blog (míralo acá: Es el PASO 1). Pero esta vez vamos a modificar el código para activar el botón REGRESAR. Además se debe importar la función de browser que también se encuentra en el ejercicio del link de este paso.

codigo_mapa.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
'''
Código creado por: Gibson Sneyder Ramírez Moreno
correo: sramirez.udea@gmail.com
http://pythoninicios.blogspot.com.co/
'''
import sys
from mapa import *
from PyQt4.QtGui import QApplication
from PyQt4.QtCore import QUrl
from PyQt4.QtWebKit import QWebView
import browser
import subventanas

class showmap(QtGui.QDialog):
    def __init__(self,parent=None):
        QtGui.QWidget.__init__(self,parent)
        QWebView.__init__(self)
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)
              
        QtCore.QObject.connect(self.ui.pushButton, QtCore.SIGNAL('clicked()'),self.calcular)
        QtCore.QObject.connect(self.ui.pushButton_3, QtCore.SIGNAL('clicked()'),self.regresar)
        QtCore.QObject.connect(self.ui.pushButton_2, QtCore.SIGNAL('clicked()'),self.salir)

    def calcular(self):
        latitud=self.ui.lineEdit.text()
        longitud=self.ui.lineEdit_2.text()
        html=browser.localizacion(latitud,longitud)
        self.ui.webView.setHtml(html)
        
    def regresar(self):
        self.close()
        atras=subventanas.sunw().exec_()
        
        
    def salir(self):
        self.close()
        
if __name__== "__main__":
    app=QtGui.QApplication(sys.argv)
    myapp = showmap()
    myapp.show()
    sys.exit(app.exec_())

PASO 3: Crear la tercera interfaz gráfica y convertir de .ui a .py. Esta interfaz es el ejercicio que permite visualizar imagenes en PYQT que también se hizo anteriormente (míralo acá Es el PASO 1). Pero esta vez vamos a modificar el código para activar el botón REGRESAR.

codigo_foto.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
'''
Código creado por: Gibson Sneyder Ramírez Moreno
correo: sramirez.udea@gmail.com
http://pythoninicios.blogspot.com.co/
'''
import sys
from foto import *
from PyQt4.QtGui import QApplication
from PyQt4.QtCore import QUrl
from PyQt4.QtWebKit import QWebView
import subventanas


class showmap(QtGui.QDialog):
    def __init__(self,parent=None):
        QtGui.QWidget.__init__(self,parent)
        QWebView.__init__(self)
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)
              
        QtCore.QObject.connect(self.ui.pushButton, QtCore.SIGNAL('clicked()'),self.mostrar)
        QtCore.QObject.connect(self.ui.pushButton_3, QtCore.SIGNAL('clicked()'),self.regresar)
        QtCore.QObject.connect(self.ui.pushButton_2, QtCore.SIGNAL('clicked()'),self.salir)

    def mostrar(self):
        imagen=self.ui.lineEdit.text()
        self.ui.webView.load(QUrl(imagen))
        
    def regresar(self):
        self.close()
        atras=subventanas.sunw().exec_()
        
        
    def salir(self):
        self.close()
        
if __name__== "__main__":
    app=QtGui.QApplication(sys.argv)
    myapp = showmap()
    myapp.show()
    sys.exit(app.exec_())

PASO 4: Crear el archivo ejecutable.
subventanas.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
'''
Código creado por: Gibson Sneyder Ramírez Moreno
correo: sramirez.udea@gmail.com
http://pythoninicios.blogspot.com.co/
'''
import sys
from ejemplo import *
import codigo_mapa
import codigo_foto

class sunw(QtGui.QDialog):
    def __init__(self,parent=None):
        QtGui.QWidget.__init__(self,parent)
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)
        QtCore.QObject.connect(self.ui.pushButton, QtCore.SIGNAL('clicked()'),self.mapa)
        QtCore.QObject.connect(self.ui.pushButton_2, QtCore.SIGNAL('clicked()'),self.imagen)
    
    def mapa(self):
        self.close()
        ventana_mapa=codigo_mapa.showmap().exec_()
       

    def imagen(self):
        self.close()
        ventana_image=codigo_foto.showmap().exec_()
        

if __name__== "__main__":
    app=QtGui.QApplication(sys.argv)
    myapp = sunw()
    myapp.show()
    sys.exit(app.exec_())

Para esta entrada voy a mostrar un video para mostrar su funcionamiento. Muchas gracias. Alguna duda estaré atento.