TRATAMIENTO DE CADENAS DE TEXTO EN PYTHON (PARTE I)

 Hola a todos,  en esta entrada se realizarán ejercicios con cadenas de texto. Si tienen funciones adicionales que deban ser documentadas me lo hacen saber, la idea del blog es seguir creciendo con buena información.


Concatenar: Permite unir cadenas de texto.

1 2 3 4

#CONCATENAR cadena1="python" cadena2="inicios" print cadena1 + " " + cadena2

python inicios
>>>

Repetir: Se multiplica el mensaje n veces.

1 2 3 4

#CONCATENAR #MULTIPLICAR cadena1="python " print cadena1*3

python python python
>>>

Longitud de la cadena: Número de caracteres que contiene la cadena.

1 2 3

#LONGITUD cadena1="python " print len(cadena1)

7
>>>

Encontrar: Permite encontrar una subcadena perteneciente a una cadena de caracteres, mostrando la posición donde se encuentra, en caso de no encontrarla la función retornará -1. La función se llama find.

1 2 3 4

#ENCONTRAR cadena="python " cadena1=cadena.find("n") print cadena1

 5
>>>


Minúsculas: Cambia la cadena de caracteres a minúsculas.

1 2 3

#MINUSCULAS cadena="PYTHON" print cadena.lower()

python
>>>

Mayúsculas: Cambia la cadena de caracteres a mayúscula.

1 2 3

#MAYUSCULAS cadena="python" print cadena.upper()

PYTHON
>>> 

Reemplazar: Permite reemplazar valores por otros en una cadena.

1 2 3

#REEMPLAZAR cadena="python" print cadena.replace("n","python")

pythopython
>>>

Cortar: Mostar un segmento de una cadena.

1 2 3

#CORTAR cadena="www.pythoninicios.blogspot.com" print cadena[4:17]

pythoninicios
>>>

Espero sea de ayuda.

¿CÓMO GRAFICAR EN PYTHON CON NUMPY Y MATPLOTLIB?

En construcción

Hola a todos en esta entrada vamos a utilizar las librerías Numpy y Matplotlib en Python para hacer un gráfico.

Este será un ejercicio básico, pero le estaré subiendo el nivel más adelante,  Si no sabes como instalar la librerías muy pronto dejaré un paso a paso para hacerlo, por ahora pregunten y les ayudaré.

1 2 3 4 5 6 7 8 9 10

import matplotlib.pyplot as plt import numpy as np x = np.arange(0,10,0.1) y = x*np.sin(x) plt.plot(x,y) plt.xlabel('X') plt.ylabel('Y') plt.title('PYTHONINICIOS.BLOGSPOT.COM') plt.show()

Este es el resultado:

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.

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.

¿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.

¿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.

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

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/