miércoles, 30 de agosto de 2017

CALCULAR CÓDIGO DE COLORES CABLE DE FIBRA ÓPTICA EN PYTHON


Hola a todos.

Al trabajar con cables de fibra óptica, es un tema de importancia el saber identificar las fibras y saberlas ubicar. Existen estándar los cuales establecen el orden y los colores de los hilos de fibra óptica usado en tubos holgados o apretados.Este código de colores también aplica para los colores de la chaqueta del cable o buffer.

Ejercicio: Se requiere calcular el color del buffer y del hilo en un cable de fibra óptica, conociendo el número de hilo.

Solución:  Tomando como dato de ingreso el número de hilo que se desea consultar, de acuerdo al estándar TIA-598c y utilizando la versión de Python 2.7.11.
Imagen relacionada
https://www.opsol.net/zona-tecnica/fibra-optica/

Nombre del archivo: codigo_colores.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#Creado por Sneyder ramirez
#Para: http://pythoninicios.blogspot.com.co/

HILOS = ['Azul', 'Naranja', 'Verde', 'Marron', 'Gris', 'Blanco', 'Rojo', 'Negro', 'Amarillo', 'Violeta', 'Rosa', 'Turquesa',
'Azul/negro', 'Naranja/Negro', 'Verde/negro', 'Marron/negro', 'Gris/Negro', 'Blanco/Negro', 'Rojo/Negro', 'Negro/Amarillo',
'Amarillo/negro','Violeta/Negro', 'Rosa/Negro', 'Turquesa/Negro']

hilos=input ("CANTIDAD DE HILOS DE LA FIBRA:  ")
cantidad_buffer= input("CANTIDAD DE BUFFER: ")
hilos_buffer=hilos/cantidad_buffer
#print "hilos por buffer", hilos_buffer
hilo=input("INGRESE HILO A CALCULAR: ")
color_buffer=int(hilo/hilos_buffer)
color_hilo=abs(((hilos_buffer*color_buffer)-hilo)-hilos_buffer)
color_hilo1=abs(((hilos_buffer*(color_buffer+1))-hilo)-hilos_buffer)
residuo=hilo%hilos_buffer

print "EL HILO: ", hilo, "TIENE: "

if residuo == 0:
        
    print "BUFFER: ",HILOS[color_buffer-1]
    print "HILO: ",HILOS[color_hilo-1]
else:
    print "BUFFER: ",HILOS[color_buffer]
    print "HILO: ",HILOS[color_hilo1-1]

Prueba 1: Hilo 1, 65, 133 en cable de 144 hilos con 12 buffer.



Prueba 2: Hilo 3, 25, 47 en cable de 48 hilos con 8 buffer.


Se actualiza a Pyhton 3.8.2


#Creado por Sneyder ramirez
#Para: http://pythoninicios.blogspot.com.co/

HILOS = ['Azul', 'Naranja', 'Verde', 'Marron', 'Gris', 'Blanco', 'Rojo', 'Negro', 'Amarillo', 'Violeta', 'Rosa', 'Turquesa',
'Azul/negro', 'Naranja/Negro', 'Verde/negro', 'Marron/negro', 'Gris/Negro', 'Blanco/Negro', 'Rojo/Negro', 'Negro/Amarillo',
'Amarillo/negro','Violeta/Negro', 'Rosa/Negro', 'Turquesa/Negro']

hilos=int(input("CANTIDAD DE HILOS DE LA FIBRA:  "))
cantidad_buffer= int(input("CANTIDAD DE BUFFER: "))
hilos_buffer=int(hilos/cantidad_buffer)
hilo=int(input("INGRESE HILO A CALCULAR: "))
color_buffer=int(hilo/hilos_buffer)
color_hilo=abs(((hilos_buffer*color_buffer)-hilo)-hilos_buffer)
color_hilo1=abs(((hilos_buffer*(color_buffer+1))-hilo)-hilos_buffer)
residuo=hilo%hilos_buffer

print ("EL HILO: ", hilo, "TIENE: ")

if residuo==0: 
    print ("BUFFER: ",(HILOS[color_buffer-1]))
    print ("HILO: ",(HILOS[color_hilo-1]))
else:
    print ("BUFFER: ",HILOS[color_buffer])
    print ("HILO: ",HILOS[color_hilo1-1])

Y esto es todo, si tienen alguna duda, la resolveré lo más pronto posible

En una próxima entrada se va a realizar el ejercicio con interfaz gráfica PyQT, utilizando nuevas herramientas de diseño de QT Designer. La prueba en video más adelante.

Gracias.
By a la/s No hay comentarios.:

viernes, 19 de mayo de 2017

¿CÓMO CREAR VENTANAS EMERGENTES EN PYTHON-PYQT? FORMA II


En una entrada pasada se realizó un ejercicio el cuál permitía la visualización de una ventana emergente creada desde el código, esta vez la ventana emergente se hará desde QT. Si desean ver el ejercicio anterior acá dejo el link.

La ventana principal está dada por el siguiente código:

ppal.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'ppal.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(362, 178)
        self.splitter = QtGui.QSplitter(Dialog)
        self.splitter.setGeometry(QtCore.QRect(70, 40, 221, 81))
        self.splitter.setOrientation(QtCore.Qt.Vertical)
        self.splitter.setObjectName(_fromUtf8("splitter"))
        self.label = QtGui.QLabel(self.splitter)
        self.label.setObjectName(_fromUtf8("label"))
        self.lineEdit = QtGui.QLineEdit(self.splitter)
        self.lineEdit.setObjectName(_fromUtf8("lineEdit"))
        self.pushButton = QtGui.QPushButton(self.splitter)
        self.pushButton.setObjectName(_fromUtf8("pushButton"))

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

    def retranslateUi(self, Dialog):
        Dialog.setWindowTitle(_translate("Dialog", "Dialog", None))
        self.label.setText(_translate("Dialog", "INGRESE SU NOMBRE:", None))
        self.pushButton.setText(_translate("Dialog", "OK", None))

La ventana emergente tendrá la siguiente característica: Un botón OK, que cerrará la ventana, y un cuadro de texto que mostrará lo que se ingresó en la ventana Principal.

second.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'second.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(224, 108)
        self.pushButton = QtGui.QPushButton(Dialog)
        self.pushButton.setGeometry(QtCore.QRect(70, 60, 75, 23))
        self.pushButton.setObjectName(_fromUtf8("pushButton"))
        self.label = QtGui.QLabel(Dialog)
        self.label.setGeometry(QtCore.QRect(20, 20, 191, 21))
        self.label.setText(_fromUtf8(""))
        self.label.setObjectName(_fromUtf8("label"))

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

    def retranslateUi(self, Dialog):
        Dialog.setWindowTitle(_translate("Dialog", "Dialog", None))
        self.pushButton.setText(_translate("Dialog", "OK", None))
  
Ahora tenemos el código que ejecuta todo el ejercicio.




Espero este ejercicio les ayude y si tienen alguna duda con gusto la resolveré.

Saludos.
By a la/s No hay comentarios.:

miércoles, 17 de mayo de 2017

¿CÓMO CREAR VENTANAS EMERGENTES EN PYTHON-PYQT? FORMA I


Ejercicio en Construcción:

Hola a todos, esta vez mostraré un ejemplo para crear ventana emergente, en la que nos mostrará un aviso.

Este ejercicio se hará tomando una ventana creada en QT como la aplicación principal, y la ventana emergente será una creada desde la consola.

PASO 1: Crear la interfaz gráfica.


Este es el código creado para la ventana principal.


ppal.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# -*- coding: utf-8 -*-

# Form implementation generated from reading ui file 'ppal.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(362, 178)
        self.splitter = QtGui.QSplitter(Dialog)
        self.splitter.setGeometry(QtCore.QRect(70, 40, 221, 81))
        self.splitter.setOrientation(QtCore.Qt.Vertical)
        self.splitter.setObjectName(_fromUtf8("splitter"))
        self.label = QtGui.QLabel(self.splitter)
        self.label.setObjectName(_fromUtf8("label"))
        self.lineEdit = QtGui.QLineEdit(self.splitter)
        self.lineEdit.setObjectName(_fromUtf8("lineEdit"))
        self.pushButton = QtGui.QPushButton(self.splitter)
        self.pushButton.setObjectName(_fromUtf8("pushButton"))

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

    def retranslateUi(self, Dialog):
        Dialog.setWindowTitle(_translate("Dialog", "Dialog", None))
        self.label.setText(_translate("Dialog", "INGRESE SU NOMBRE:", None))
        self.pushButton.setText(_translate("Dialog", "OK", None))

PASO 2: Crear el archivo ejecutable.

ejecutable.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
import sys
from ppal import *
from PyQt4.QtCore import *
from PyQt4.QtGui import *


class EMERGENTE(QtGui.QWidget):
    def __init__(self,name=None):
        super(EMERGENTE, self).__init__()
        self.name = name
        btn1 = QtGui.QLabel("%s" % self.name,self)
        btn1.move(50, 50)
        contenedor = QVBoxLayout()
        self.setLayout(contenedor)
        btnsalir=QPushButton("salir", None)
        contenedor.addWidget(btnsalir)
        btnsalir.move(50, 50)
        self.connect(btnsalir, SIGNAL("clicked()"), self.salir)
        self.setGeometry(500, 300, 250, 180)
        self.setWindowTitle('EMERGENTE')
        self.show()
        
    def salir(self):
        self.close()

class PRINCIPAL(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.aceptar)
        self.children = []
        self.setWindowTitle('VENTANA PRINCIPAL')
        self.show()

    def aceptar(self):
        name=self.ui.lineEdit.text()
        child= EMERGENTE(name)
        self.children.append(child)
       
 
if __name__ == '__main__':
    app=QtGui.QApplication(sys.argv)
    myapp = PRINCIPAL()
    myapp.show()
    sys.exit(app.exec_())

Resultados: Como se puede observar, al ingresar en el espacio Nombre, se abrirá una ventana emergente que mostrará la linea de texto ingresada en la ventana principal.

 Espero haya sido útil el ejercicio, y cualquier duda que tengan con gusto la resolveré.

Este ejercicio también lo voy a realizar utilizando una ventana emergente pero creada en QT. Pronto avisaré cuando esté realizada.

Salu2.
By a la/s 1 comentario:

sábado, 13 de mayo de 2017

EJERCICIO DE ENCRIPTACIÓN

Buenas tardes.

Hace poco en una entrevista de trabajo me pidieron encontrar lo siguiente:


1
2
3
4
5
6
7
def encrypt(text):
total_sum = 0
total_cnt = 0
for c in text:
                total_cnt += 1
                total_sum += ord(c)**total_cnt
return total_cnt, total_sum


El código encripta una palabra, el objetivo es descifrar que palabra se ingresó con una salida dada.

Explicación del código:
Si se codifica la palabra "HOLA", La codificación de esta palabra viene dada por: ord(H)+ord(O)^2+ord(L)^3+ord(A)^4.
La función ord() devuelve el valor ASCII de un caracter.
ord(H)= 72
ord(O)^2=(79)^2 =6241
ord(L)^3=(76)^3=438976
ord(A)^4= (65)^4=17850625
HOLA=18295914

>>encrypt('HOLA')

(4,18295914)

¿Cuándo la función devuelve (4, 37348960), cual ha sido el valor del parámetro “text” ? (es mayúscula).

 Se realiza el siguiente Script.


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
def decrypt(total_cnt, total_sum):
    a=0
    b=0
    c=0
    d=0

    A=a
    B=b**2
    C=c**3
    D=d**4

    for d in range(78,91):
        A=a
        B=b**2
        C=c**3
        D=d**4


        if A+B+C+D ==total_sum:
            print chr(a), chr(b), chr(c), chr(d)

        for c in range(69,91):
            A=a
            B=b**2
            C=c**3
            D=d**4

            if A+B+C+D ==total_sum:
                print chr(a), chr(b), chr(c), chr(d)

            for b in range(73,91):
                A=a
                B=b**2
                C=c**3
                D=d**4
                    
                if A+B+C+D ==total_sum:
                    print chr(a), chr(b), chr(c), chr(d)


                for a in range(50,91):
                    A=a
                    B=b**2
                    C=c**3
                    D=d**4
                    
                    if A+B+C+D ==total_sum:
                        print chr(a), chr(b), chr(c), chr(d)
                    
                    print A+B+C+D, A,B,C,D,a,b,c,d

y como resultado,  la palabra ingresada fue: B I E N






By a la/s No hay comentarios.:
Etiquetas: ,

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/
By a la/s No hay comentarios.:
Etiquetas: ,

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.


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
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".


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
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.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# -*- 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.

By a la/s 8 comentarios:
Etiquetas: , ,

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;



By a la/s No hay comentarios.:
Suscribirse a: Entradas (Atom)