TELECOMUNICACIONES Y DESARROLLO DE SOFTWARE

lunes, 8 de agosto de 2016

¿CÓMO VISUALIZAR MAPA DE GOOGLE MAPS EN PYTHON-PYQT?

Hola a todos en esta entrada voy a visualizar mapas de Google Maps en Python-PyQT. Con la ayuda de Google Maps JavaScript API. La anterior ayuda permite visualizar mapas, insertar marcadores, eliminar marcadores.Etc..

En este caso voy a mostrar un marcador en nuestro mapa.

PASO 1: Crear la interfaz gráfica en QT. La cual consta de una forma Dialog Without Buttons y de un QWebView como se muestra a continuación:

PASO 2: Convertir la interfaz gráfica QT a PyQT. Este paso ya lo hemos hecho en una entrada anterior de este BLOG pero si no lo recuerda acá les dejo el link:

http://pythoninicios.blogspot.com.co/2016/06/convertir-de-ui-py.html

PASO 3: Escoger el tipo de mapa. Como se mencionó anteriormente se va a escoger un mapa que nos muestre un marcador, y luego copiamos el código HTML del mapa para utilizarlo en nuestro Script de Python. Google Maps JavaScript API

PASO 4: Implementar el código. Este código sólo funcionará si tienen su API KEY, la pueden obtener gratuitamente AQUÍ. Cuando obtengan la suya simplemente la reemplazan en el código donde dice API_KEY la dejé con un buena tamaño para que puedan observar donde hacen el cambio.

#!/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 web import *
from PyQt4.QtGui import QApplication
from PyQt4.QtCore import QUrl
from PyQt4.QtWebKit import QWebView

html= \
"""
<!DOCTYPE html>
<html>
  <head>
    <meta name="viewport" content="initial-scale=1.0, user-scalable=no">
    <meta charset="utf-8">
    <title>Simple markers</title>
    <style>
      html, body {
        height: 100%;
        margin: 0;
        padding: 0;
      }
      #map {
        height: 100%;
      }
    </style>
  </head>
  <body>
    <div id="map"></div>
    <script>

function initMap() {
  var myLatLng = {lat: -25.363 , lng: 131.044 };

  var map = new google.maps.Map(document.getElementById('map'), {
    zoom: 4,
    center: myLatLng
  });

  var marker = new google.maps.Marker({
    position: myLatLng,
    map: map,
    title: 'Mapa Prueba!'
  });
}

    </script>
    <script async defer
        src="https://maps.googleapis.com/maps/api/js?key=API_KEY&signed_in=true&callback=initMap"></script>
  </body>
</html>
"""     

class FormularioLogin(QtGui.QDialog):
    def __init__(self,parent=None):
        QtGui.QWidget.__init__(self,parent)
        QWebView.__init__(self)
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)
   
        
if __name__== "__main__":
    app=QtGui.QApplication(sys.argv)
    myapp = FormularioLogin()
    myapp.ui.webView.setHtml(html)
    myapp.show()
    sys.exit(app.exec_())

Después de hacer todos los pasos obtenemos lo siguiente:

Espero sea claro. Muchas gracias

sábado, 25 de junio de 2016

¿CÓMO VISUALIZAR LAS TABLAS DE UNA BASE DE DATOS MYSQL EN PYTHON?

Hola a todos en esta entrada mostraré un código para listar las tablas contenidas en una base de datos MYSQL en Python.

Este es el código el cual iré explicando, cualquier duda me la hacen saber.

import MySQLdb

conn=MySQLdb.connect('localhost','root','root123','estudiantes')
cursor=conn.cursor()
sql="SHOW TABLES;"
cursor.execute(sql)
base = cursor.fetchall() #Se extraen todas las filas de la tabla
for fila in base:
    print fila[0]

Hostname = 'localhost'
Usuario = 'root'
Contraseña = 'root123'
Nombre base de datos = 'estudiantes'

Lo primero que se debe hacer es importar la librería MySQLdb que nos va a permitir usar las bases de datos de MySQL.

Conectarse a la base de datos con:

conn = MySQLdb.connect( 'Hostname', 'Usuario', 'Contraseña', 'Nombre base de datos')

Crear un cursor que nos ayudará a realizar las operaciones necesarias con nuestra base de datos

cursor=conn.cursor()

Con el método execute podemos utilizar comandos SQL, en este caso le pedimos que muestre las tablas con el comando "SHOW TABLES;"

sql="SHOW TABLES;"
cursor.execute(sql)

Para terminar se crea un bucle for que recorre e imprime todos los nombres contenidos en la base de datos.

Ejecutando el programa esto retorna, en mi caso me muestra el nombre de 3 tablas de mi base de datos.

Recuerden que si tienen alguna duda, estaré atento,

miércoles, 22 de junio de 2016

¿CÓMO VISUALIZAR BASE DE DATOS MYSQL EN PyQT-PYTHON?

Hola a todos esta vez se va a exportar la información contenida en una base de datos MySQL, en la interfaz gráfica de PyQT con la ayuda de Python.

1. PASO: Crear la interfaz gráfica en QT:

Se debe crear un nuevo archivo y se escoge el Dialog without Buttons y luego create. Esta interfaz la guardé con el nombre de Base.ui

2. PASO: Insertar el Table View en nuestra ventana:

Como se observa en la imagen, se debe insertar un table View dentro de nuestra ventana Dialog y lo ajustamos al tamaño de la ventana.

3. PASO: Convertir el archivo generado en extensión .ui de QT a .py de Python:
Si aún no sabes convertir de .ui a .py dejo este enlace también hecho por mí haciendo la conversión:

http://pythoninicios.blogspot.com.co/2016/06/convertir-de-ui-py.html

Este es el código generado en esa conversión.

Base.py

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

# Form implementation generated from reading ui file 'Base.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(726, 300)
        self.tableView = QtGui.QTableView(Dialog)
        self.tableView.setGeometry(QtCore.QRect(20, 10, 691, 271))
        self.tableView.setObjectName(_fromUtf8("tableView"))

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

    def retranslateUi(self, Dialog):
        Dialog.setWindowTitle(_translate("Dialog", "Dialog", None))

4. PASO: Generar el archivo que consultará la base de datos y utilizará la interfaz gráfica:

A este archivo lo llamé prueba.py y vease lo importante de este código al importar las librerías de PyQt4 para usarlas con base de datos. ( Recuerde que este ejemplo sólo aplica para bases de datos MYSQL)

import sys
from Base import *
from PyQt4 import QtSql, QtGui

def createConnection():
    db = QtSql.QSqlDatabase.addDatabase('QMYSQL') #no se modifica.
    db.setHostName('localhost') # lo cambian por el nombre que le hayan dado al Host.
    db.setDatabaseName('red_fibra') #Lo cambian por el nombre de la base de datos.
    db.setUserName('root') #Lo cambian por el nombre de usuario de su base de datos.
    db.setPassword('root123') #Lo cambian por la contraseña de su base de datos.
    db.open()
    print (db.lastError().text())
    return True

class MyForm(QtGui.QDialog):
    def __init__(self, parent=None):
        QtGui.QWidget.__init__(self, parent)
        self.ui = Ui_Dialog()
        self.ui.setupUi(self)
        self.model = QtSql.QSqlTableModel(self)
        self.model.setTable("red3") #Nombre de la tabla que desean en su base de datos
        self.model.setEditStrategy(QtSql.QSqlTableModel.OnManualSubmit)
        self.model.select()
        self.ui.tableView.setModel(self.model)
           
if __name__ == "__main__":
    app = QtGui.QApplication(sys.argv)
    if not createConnection():
        sys.exit(1)
    myapp = MyForm()
    myapp.show()
    sys.exit(app.exec_())

Al finalizar este va a ser el resultado.

Espero les haya servido, si tienen alguna duda con gusto la resolveré.

¿CÓMO CONECTAR BASE DE DATOS MYSQL CON PYTHON?

Hola a todos voy a explicar cómo conectar una base de datos en MYSQL con Python.

Primero se debe instalar la librería de MYSQL para la versión de Python. En mi caso poseo la versión de Python 2.7.11. Y esta librería se debe importar en nuestro código.

#!/usr/bin/python
# -*- coding: utf-8 -*-

import MySQLdb

db = MySQLdb.connect('localhost', 'root','root123', 'estudiantes')
cursor = db.cursor()
cursor.execute("SELECT * FROM red")
data=cursor.fetchall()
cursor.close()

A continuación explicaré las líneas del código anterior.

import MySQLdb

Luego procedemos a realizar la conexión a la base de datos de nuestro interés

Host: 'localhost'
Usuario: 'root'
Contraseña: 'root123'
Nombre de la base de datos: 'estudiantes'

db = MySQLdb.connect('localhost', 'root','root123', 'estudiantes')

Luego de establecer la conexión se procede a la creación de un cursor que nos ayudará a realizar las operaciones necesarias con nuestra base de datos.

cursor = db.cursor()

Luego usamos el método execute para poder ejecutar comandos SQL.
*red es una tabla creada en la base de datos estudiantes.

cursor.execute("SELECT * FROM red")

con data = cursor.fetchone(): se extrae una sola fila de la tabla.
con data = cursor.fetchall(): se extraen todas las filas de la tabla.

Dependiendo de lo que se vaya a extraer de la table se escoge el data.

data = cursor.fetchone()
data = cursor.fetchall()

y finalmente para desconectarnos de la base de datos.

cursor.close()

jueves, 16 de junio de 2016

CONVERTIR DE LA INTERFAZ GRÁFICA PYQT4 (.ui) A PYTHON (.py)

Hola a todos, hoy voy a compartir cómo realizar la conversión de una interfaz gráfica realizada con PyQt4 que me genera un archivo .ui a un .py ( Extensión de python)

Digamos que el archivo generado en PyQt4 se llama prueba.ui

Al guardarlo queda guardado en la siguiente ruta por defecto:

C:\Python34\Lib\site-packages\PyQt4

Luego ejecutamos el símbolo del sistema cmd y buscamos en la carpeta donde instalamos el archivo prueba.ui ó para mayor facilidad estando en la carpeta donde se ubica el archivo que necesitamos hacemos lo denla siguiente imagen:

Después de copiar cmd pulsa la tecla enter y te abrirá el símbolo del sistema en la ubicación.

Estando en la carpeta donde se encuentra sólo basta con ejecutar el comando:

pyuic4 prueba.ui -o prueba.py

Si no queda igual que en la imagen es porque hay problemas en la conversión, si tienen alguna duda me escriben y la responderé en la mayor brevedad.

Aplicando este tema realicé varios ejercicios en mi BLOG acá les dejo en enlace de uno:

http://pythoninicios.blogspot.com.co/2016/06/validar-usuario-y-contrasena-en-python.html

Muchas gracias.

VALIDAR USUARIO Y CONTRASEÑA EN PYTHON Y PYQT4

Hola a todos voy a realizar un ejercicio que veo que consultan mucho en el BLOG, consta de pasarlo a PyQt4.

http://pythoninicios.blogspot.com.co/2015/09/validar-usuario-y-contrasena-en-python.html

Es ejercicio también lo modifiqué y digamos que lo reduje en comparación con el descrito en el enlace.

La siguiente imagen corresponde a la ventana inicial que nos mostrará el programa.

Este es el código generado para obtener la ventana de la imagen anterior se llama prueba.py, convertida de .ui a .py. En el BLOG también enseñaré a realizar esta conversión y lo explicaré pronto. Dejaré el enlace en poco tiempo.

prueba.py

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

# Form implementation generated from reading ui file 'prueba.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_MainWindow(object):
    def setupUi(self, MainWindow):
        MainWindow.setObjectName(_fromUtf8("MainWindow"))
        MainWindow.resize(568, 189)
        self.centralwidget = QtGui.QWidget(MainWindow)
        self.centralwidget.setObjectName(_fromUtf8("centralwidget"))
        self.gridLayout = QtGui.QGridLayout(self.centralwidget)
        self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
        self.label_USUARIO = QtGui.QLabel(self.centralwidget)
        self.label_USUARIO.setObjectName(_fromUtf8("label_USUARIO"))
        self.gridLayout.addWidget(self.label_USUARIO, 0, 0, 1, 1)
        self.lineEdit_USUARIO = QtGui.QLineEdit(self.centralwidget)
        self.lineEdit_USUARIO.setObjectName(_fromUtf8("lineEdit_USUARIO"))
        self.gridLayout.addWidget(self.lineEdit_USUARIO, 0, 1, 1, 1)
        self.pushButton_ACEPUSER = QtGui.QPushButton(self.centralwidget)
        self.pushButton_ACEPUSER.setObjectName(_fromUtf8("pushButton_ACEPUSER"))
        self.gridLayout.addWidget(self.pushButton_ACEPUSER, 0, 2, 1, 1)
        self.label_MSJUSER = QtGui.QLabel(self.centralwidget)
        self.label_MSJUSER.setText(_fromUtf8(""))
        self.label_MSJUSER.setObjectName(_fromUtf8("label_MSJUSER"))
        self.gridLayout.addWidget(self.label_MSJUSER, 1, 0, 1, 3)
        self.label_PASSWORD = QtGui.QLabel(self.centralwidget)
        self.label_PASSWORD.setObjectName(_fromUtf8("label_PASSWORD"))
        self.gridLayout.addWidget(self.label_PASSWORD, 2, 0, 1, 1)
        self.lineEdit_PASSWORD = QtGui.QLineEdit(self.centralwidget)
        self.lineEdit_PASSWORD.setObjectName(_fromUtf8("lineEdit_PASSWORD"))
        self.gridLayout.addWidget(self.lineEdit_PASSWORD, 2, 1, 1, 1)
        self.pushButton_ACEPPASS = QtGui.QPushButton(self.centralwidget)
        self.pushButton_ACEPPASS.setObjectName(_fromUtf8("pushButton_ACEPPASS"))
        self.gridLayout.addWidget(self.pushButton_ACEPPASS, 2, 2, 1, 1)
        self.label_MSJPASS = QtGui.QLabel(self.centralwidget)
        self.label_MSJPASS.setText(_fromUtf8(""))
        self.label_MSJPASS.setObjectName(_fromUtf8("label_MSJPASS"))
        self.gridLayout.addWidget(self.label_MSJPASS, 3, 0, 1, 3)
        MainWindow.setCentralWidget(self.centralwidget)
        self.menubar = QtGui.QMenuBar(MainWindow)
        self.menubar.setGeometry(QtCore.QRect(0, 0, 568, 21))
        self.menubar.setObjectName(_fromUtf8("menubar"))
        MainWindow.setMenuBar(self.menubar)
        self.statusbar = QtGui.QStatusBar(MainWindow)
        self.statusbar.setObjectName(_fromUtf8("statusbar"))
        MainWindow.setStatusBar(self.statusbar)

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

    def retranslateUi(self, MainWindow):
        MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow", None))
        self.label_USUARIO.setText(_translate("MainWindow", "USUARIO:", None))
        self.pushButton_ACEPUSER.setText(_translate("MainWindow", "ACEPTAR", None))
        self.label_PASSWORD.setText(_translate("MainWindow", "PASSWORD:", None))
        self.pushButton_ACEPPASS.setText(_translate("MainWindow", "ACEPTAR", None))

El siguiente código se llama validador.py y llama a prueba.py para invocar la interfaz gráfica.

validador.py

import sys

from prueba import *

class Miformulario(QtGui.QMainWindow):
    def __init__(self,parent=None):
        QtGui.QMainWindow.__init__(self,parent)
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        QtCore.QObject.connect(self.ui.pushButton_ACEPUSER, QtCore.SIGNAL('clicked()'), self.mensaje_usuario)
        QtCore.QObject.connect(self.ui.pushButton_ACEPPASS, QtCore.SIGNAL('clicked()'), self.mensaje_password)

    def mensaje_usuario(self):

        long=len(self.ui.lineEdit_USUARIO.text())
        y=self.ui.lineEdit_USUARIO.text().isalnum()
        
        if y==False:
            self.ui.label_MSJUSER.setText("El nombre de usuario puede contener solo letras y números")
            self.ui.lineEdit_USUARIO.clear() #Borra el campo donde se escribe la contraseña
        if long < 6: 
            self.ui.label_MSJUSER.setText("El nombre de usuario debe contener al menos 6 caracteres")
            self.ui.lineEdit_USUARIO.clear() #Borra el campo donde se escribe la contraseña
        if long > 12: 
            self.ui.label_MSJUSER.setText("El nombre de usuario no puede contener más de 12 caracteres")
            self.ui.lineEdit_USUARIO.clear() #Borra el campo donde se escribe la contraseña
        if long >5 and long <13 and y ==True:
            self.ui.label_MSJUSER.setText("Usuario creado correctamente")
            

    def mensaje_password(self):
            
        user=False  #variable de inicialización para identificar espacios
        validar=False #variable de inicialización para identificar número de caracteres
        long=len(self.ui.lineEdit_PASSWORD.text()) #Calcula la longitud de la contraseña
        y=self.ui.lineEdit_PASSWORD.text().isalnum()#True si es alfanumérica, False si no lo es.(Nos interesa que sea False)
        mayuscula=False #variable iniciliazción para contar las letras mayúsculas
        minuscula=False #variable iniciliazción para contar las letras minúsculas
        numeros=False #variable iniciliazción para contar los números
        correcto=True

        for carac in self.ui.lineEdit_PASSWORD.text(): #ciclo for que recorre caracter por caracter en la contraseña

            if carac.isspace()==True: #Saber si el caracter es un espacio
                user=True #si encuentra un espacio se cambia el valor a True

            if carac.isupper()== True: #saber si hay mayuscula
                    mayuscula=True #Si encuentra al menos una Mayuscula cambia a True
                
            if carac.islower()== True: #saber si hay minúsculas
                    minuscula=True #Si encuentra al menos una minúscula cambia a True
                
            if carac.isdigit()== True: #saber si hay números
                    numeros=True #Si encuentra al menos un número cambia a True

        if user==True: #este valor indica que encontró un espacio
            self.ui.label_MSJPASS.setText("La contraseña no puede contener espacios")
            self.ui.lineEdit_PASSWORD.clear() #Borra el campo donde se escribe la contraseña
            
        else:
            validar=True #se escoge con el fin de garantizar que no hay espacios
            #y pasar al número mínimo de caracteres que contiene la contraseña
            
                       
        if long <8 and validar==True: #Se garantiza que la contraseña posea mínimo 8 caracteres sin espacios.
            self.ui.label_MSJPASS.setText("Mínimo 8 caracteres")
            self.ui.lineEdit_PASSWORD.clear() #Borra el campo donde se escribe la contraseña
            validar=False


        if mayuscula==True and minuscula==True and numeros==True and y==False and validar==True:  
            self.ui.label_MSJPASS.setText("La contraseña es correcta")
        else:
            correcto=False #Quiere decir que no cumple al menos uno de los requisitos

        if correcto==False and validar==True: #No cumpla al menos un requisito, no contiene espacios y es mayor o igual a 8 caracteres.
            self.ui.lineEdit_PASSWORD.clear()
            self.ui.label_MSJPASS.setText("La contraseña elegida no es segura: debe contener letras minúsculas, mayúsculas, números y al menos 1 carácter no alfanumérico")

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

Este es un ejemplo cuando se cumplen todas las condiciones requeridas por el ejercicio.

Muchas Gracias, cualquier duda o sugerencia me dejan el mensaje.

martes, 7 de junio de 2016

PYTHON VARIOS: CONTADOR DE VOCALES, ESTADO DEL AGUA.

1. CONTADOR DE VOCALES.

2. ESTADO DEL AGUA.

1. CONTADOR DE VOCALES

Hola en este ejercicio vamos a contar el número de vocales que contiene una palabra:

El código debe mostrar las vocales que contiene la palabra y el número de vocales contenido en la palabra:

def contador_vocales(s):

    cont=0
    hay=True

    
    for caracter in s:
        if caracter in 'aeiouAEIOU':
            
            cont=cont+1
            
            print(caracter)
        
    print('Hay: ',cont,'Vocales en: ',s)

2. ESTADO DEL AGUA

El siguiente código calcula el estado del agua dependiendo la temperatura ingresada:

Si la temperatura es menor a cero(0), imprimirá que es estado es Sólido.

Si la temperatura es mayor o igual a cero(0) y menor a 96, imprimirá que es estado Líquido.

En caso que no cumpla con los anteriores imprimirá que está en estado Gaseoso.

def estado_del_agua():
    '''(number)->str
    Devuelve el estado del agua, dependiendo la temperatura ingresada

    >>> estado_del_agua()
    Ingrese la temperatura: 50
    El estado del agua es Liquido.

    >>> estado_del_agua()
    Ingrese la temperatura: 100
    El estado del agua es Solido.
    '''

    Temperatura=int(input('Ingrese la temperatura: '))

    if Temperatura < 0:
        print('El estado del agua es Solido.')

    elif Temperatura >= 0 and Temperatura < 96:
        print('El estado del agua es Liquido.')

    else:
        print('El estado del agua es gaseoso.')

Si tienen ejercicios de este tipo que quieran que resuelva me lo dejan en la sección de preguntas de esta entrada