Curso Python

Busqueda de una palabra y realizar el corte de los ":"

2006-09-30T11:35:00.000-07:00

Hola muchachos, espero que estén muy juiciosos trabajando lo del proyecto aqui les mando una "ayudita"

Estas erán las funciones que les mandé averiguar:

Con la función find en el indice retorna (-1) si no encuentra una palabra y (0) si existe

Con la función split realiza el corte de cualquier cadena, en el caso nuestro sería los ":", donde el parámetro final [0] si es antes de los dos puntos y [1] si es después

Ejemplo:
------------ archivo.txt -------------
Primera parte : Segunda parte

------------- ejemplo.py ------------
#Rodrigo Carreño
#Hecho en Mandriva Linux 2006
#Identación ---

a=open("archivo.txt","r")
l=[]
r= raw_input ("Digite la primera parte: ")
for u in a:
---l.append(u)
for n in l:
---if n.find(r)==0:
------print n.split(":")[1]
---else:
------print 'Pailas'

----------- Prueba interactiva ------------
>>>
Digite una parte : Primera parte
Segunda parte
>>>
Digite una parte : blablabla
Pailas

Programa para convertir .doc a .pdf

2006-09-27T08:30:00.000-07:00

Hola Muchachos como van??

Aqui esta uno de los muchos programas que existen para convertir el formato de Word a Acrobat Reader:

PDFCreator

Algunas imágenes de este programa:

.

.

.

.

Es obligacón de ustedes entregarme los dos manuales (Lógica y Usuario) en .pdf, no lo recibo en el formato privativo .doc!!!

Gracias y Muchos Exitos!!!

PIL - ( Pyhon Imaging Library )

2006-09-26T18:08:00.000-07:00

#imagen.py
#Codigo para cargar una imágen en Python

from PIL import Image
im = Image.open("imagen.jpg") #En directorio de imagen.py
im.show()

#Paleta.py
#Codigo que muestra la paleta de colores

from PIL import Image
import ImagePalette
palette = []
for i in range(256):
palette.extend((i, i, i))

assert len(palette) == 768

im.putpalette(palette)

Ejemplos Gráficos en Tkinter

2006-09-22T11:07:00.000-07:00

Clase 9 [ 13 - 09 -06 ]

2006-09-15T06:36:00.000-07:00

Objetivo: Enseñar las funciones más usadas para el modo gráfico en Python con la librería Tk y realizar la aplicación ventana.py con todas las herramientas gráficas vistas.

Nota:Click en las diapositivas para ampliar

Archivo Gráfico (ventana.py):

Clase 8 [ 11 - 09 -06 ]

2006-09-12T09:15:00.000-07:00

Objetivo: Realizar un programa hecho en Python con el Paradigma Orientado a Objetos
(P.O.O.) a partir de un diagrama de Clases.

click en la imágen para ampliar

Codigo:
#Hecho en WindowsXp
#Cortesía: Diana María Insuasty
#Identación: ---
----------------------- clase.py ------------------------------
class persona:
---edad=0
---nombre='' "
---estatura=0.00
---cedula=0000
---def __init__(self,e,no,es,ce):
------self.edad=e
------self.nombre=no
------self.estatura=es
------self.cedula=ce
---def caminar(self,x,y):
------print "se desplazo en ",x,y
---def respirar(self):
------pass
class estudiante(persona):
--- notas=0
--- horario='' "
--- def __init__(self,n,h):
------self.notas=n
------self.horario=h
--- def clases (self,a,b):
------return a+b
class profesor(persona):
---salario=0
---def __init__(self,sa):
------self.salario=sa
---def materias(self,f):
------l=[]
------l.append(f)
------return l
class funcionario(persona):
---cargo=''
---def __init__(self,car):
------self.cargo=car

------------ clase.py (Interactivo) -------------------

>>> p=persona(23,"Rodrigo",1.75,10255099)
>>> p.caminar(23,54)
se desplazo en 23 54
>>> e=estudiante(3.0,"nocturno")
>>> e.nombre
'' "
>>> e.nombre="jorge"
>>> e.nombre
'jorge'
>>> p.nombre
'Rodrigo'
>>> f=profesor(2000)
>>> f.salario
2000
>>> f.estatura
0.0
>>> f.estatura=1.65
>>> f.estatura
1.6499999999999999
>>> p.estatura
1.75
>>> f.materias("python")
['python']
>>> e.clases("Rodrigo", "Python")
'RodrigoPython'
>>> r=funcionario("Tesorero")
>>> r.cargo
'Tesorero'
>>> r.cedula
0
>>> r.cedula=256662588
>>> r.cedula
256662588
>>> p.cedula
10255099
>>>

Proyectos Python

2006-09-08T11:13:00.000-07:00

Esta es la lista de los proyectos con una descripción general de cada uno de estos, que se deben entregar el 25 de Septiembre de "este año".

Nota:
1- El codigo en Python solo se recibe con el paradigma Orientado a Objetos (P.O.O.) y en forma modular.
2- Las pruebas se realizarán en modo interactivo.

Proyecto 1:
Busca Minas
Integrante(s):
Jesús Benavides
Julián Narvaes
¿En que consiste?
Se manejan 4 Listas de Niveles, las cuales tienen
coordenadas en (x,y) de un tablero que varía
su tañano por cada nivel y su número de minas.
Por el momento el tablero es imaginário (sin modo
gáfico).
Indica cuando se ha caído en una mina, que puntaje
lleva por no tocar las minas y cuantas coordenadas
de casillas se han descubierto.

-----

Proyecto 2:
Cajero Automático
Integrante(s):
Eliana Patricia Benavides
Ana María Fernandes
¿En que consiste?
Se manejan dos estructuras de datos Cola (Usuarios)
y Lista (6 transacciones del cajero). Simula a 3
personas que se encuentran haciendo fila en la
entrada de un cajero automático y seleccionan
aleatoreamente una de las 6 transacciones que
permite el sistema.
Adicionalmente, facilita el ingreso de mas usuarios.

-----

Proyecto 3:
Compara Archivos (Manejo de Archivos)
Integrante(s):
Gustavo Berrio
Juan Pablo Solis
¿En que consiste?
Se involucran dos archivos diferentes, ejmpl(a.txt
y b.txt), el programa indica cuantas coincidencias
hay en los dos archivos, si son iguales y si no
tienen ninguna relación de palabras.

-----

Proyecto 4:
Ayuda Python (Manejo de Archivos)
Integrante(s):
Regnier Calambas
¿En que consiste?
Maneja un archivo de aydua, donde se encuentran
almacenados 50 funciones y desiciones en Python
con su respectiva descripción.
El usuario puede seleccionar cualquiera de estos
comandos y se visualizará su ayuda en español.

-----

Proyecto 5:
Traductor Ingles - Español o Español - Ingles

(Manejo de Archivos - descargar palabras.txt)
Integrante(s):
Sandra Milena Checa
Blanca Heliana Ravelo
¿En que consiste?
Utilizando el archivo (palabras.txt), el usuario
puede escribir una palabra en ingles y se mostrará
su significado en español o viceversa.

-----

Proyecto 6:
Areas y Volúmenes
Integrante(s):
Julián Andres Guañarita
¿En que consiste?
El usuario puede seleccionar cualquier tipo de
figura y según las dimensiones que se le especifique
calculara su Area y su Volúmen.
Solo debe pedir las medidas necesarias y opcional
su dibujo de la figura (si se alcanza a ver modo
gráfico)

-----

Proyecto 7:
Diccionario (Significados en Español)

(Manejo de Archivos - descargar palabras.txt)
Integrante(s):
Juan Manuel León
Lina Molina
¿En que consiste?
Utilizando el archivo (palabras.txt), el usuario
puede escribir una palabra español y se visualizará
su significado.
Los significados de las palabras en español se
pueden encontrar en:
www.wikipedia.org

-----

Proyecto 8:
Busqueda de Palabras (Manejo de Archivos)
Integrante(s):
Luis Felipe Meneses
Fredy Machado
¿En que consiste?
El programa busca una palabra en un archivo cualquiera
ejmpl(a.txt), indicando cuantas veces se encuentran
repetidas y la posición exacta donde estan ejemplo:
dos veces esta "Cabeza":
* (linea 3, columna 5).
* (linea 30, columna 10)

-----

Proyecto 9:
Completa Palabras

(Manejo de Archivos - descargar palabras.txt)
Integrante(s):
Juan Pablo Machado
Milton Felipe Pino
¿En que consiste?
Usando el archivo (palabras.txt), selecciona la parte
en español y le ayuda al usuario a formar una
palabra completa mostrando las alternativas despúes
de la 3era letra ejempl:
>>>cab
cabeza (1)
caballo (2)
cabello (3)
...

-----

Proyecto 10:
Super Calculadora
Integrante(s):
Diana María Insuasty
¿En que consiste?
Utilizando la librería de Python math, realiza todas
las operaciones de las funciones que ofrece esta
librería.
Desde suma hasta arcotangente hiperbólica.
Por el momento solo realiza estas operaciones, si hay
tiempo para explicar lo del modo gráfico, también
tendría la opción de mostrar las gráficas de las
funciones.

-----

Proyecto 11:
Ahorcado
Integrante(s):
Olga Lucia Zuñiga
¿En que consiste?
Usando 3 Listas de niveles, este juego almacena 70
palabras de diferentes longitudes, oportunidades de
acertar y puntuación.
Si se alcanza a explicar gráficos en python tendría
el dibujo de la persona a la que están ahorcando.

-----

Proyecto 12:
Refranes (Manejo de Archivos)
Integrante(s):
Arnulfo Vidal
¿En que consiste?
Usando un archivo ejempl(a.txt donde se encuentran
50 refranes, el usuario digita la primera parte del
refrán y con la busqueda del archivo completa la
oración, ejempl:

>>> A caballo regalado
No se le mira el comillo

Clase 7 [ 06 - 09 -06 ]

2006-09-08T08:02:00.000-07:00

Objetivo: Realizar pequeños programas Orientados a objetos: Clases, Herencia, Polimorfismo, Encapsulamiento....

Complementar los proyectos con el concepto y manejo de archivos: Lectura, escritura y adición.

**************** Programa 1 ********************
------------------ Proyecto.py ------------------------
#Programa para la selección de proyectos en Python
#--- Identación

print "*** Programa para la seleccion de Proyectos ***"
while True:
--- a=int(raw_input("1 o 2 personas: "))
---if a==1:
------L1=["Moneda(10)","Ahorcado(70)","Ayuda Python(50)","Chat(70)","Super ------Calculadora","Refranes(50)","Ordena todo","Areas y Volumenes"]
------i=int(raw_input("Numero del (0-7): "))
------print L1[i]
------print "--------------------------------------------------------------"
--- if a==2:
------ L2=["Cajero(6)","Completa palabras(archv3), "Traductor(archv)",
------"Diccionario(archv)","Busca minas","Compara archivos","Sintaxis ------interativo","Busqueda palabras(posiciones)"]
------j=int(raw_input("Numero del (0-7): "))
------print L2[j]
------print "--------------------------------------------------------------"

**************** Programa 2 ********************
------------------ archivo.txt ------------------------
Casa
Caballo
Cabeza
Moto
Perro
------------------ Lectura.py ------------------------
#Programa para la lectura de un archivo en Python
#--- Identación

f=open("archivo.txt","r")
for i in f:
---print i
------------ Lectura.py (Interactivo) -----------------
Casa
Caballo
Cabeza
Moto
Perro

**************** Programa 3 ********************
------------------ Escritura.py ------------------------
# Programa para crear y escribir en un archivo
#--- Identación

f=open("prueba.txt","w")
a=raw_input("Digite lo que sea: ")
f.write(a)

------------ Escritura.py (Interactivo) -----------------
>>>Digite lo que sea: Prueba de almacenamiento en python

----------------------- prueba.txt ---------------------
Prueba de almacenamiento en python

**************** Programa 4 ********************
-------------------- archivo2.txt ---------------------
Casa
Perro
Caballo
Mesa
Sobre
Ladrillo
------------------ Almacena.py --------------------------
#Programa para guardar un archivo en una lista de Python
#--- Identación

f=open("archivo2.txt","r")
L=[]
for i in f:
---L.append(i)

-------------- Almacena.py (Interactivo) -----------------
>>> L
['Casa\n', 'Perro\n', 'Caballo\n', 'Mesa\n', 'Sobre\n', 'Ladrillo']

**************** Programa 5 ********************
------------------ Clase.py ------------------------
#Programa para crear una clase simple en Python
#--- Identación

class MiClase:
---"Simple clase de ejemplo"
---i = 12345
---def f(self):
------return 'hola, mundo'
-------------- Clase(Interactivo.py) ----------------
>>> d=MiClase()
>>> d.f()
'hola, mundo'

****************** Programa 6 ************************
------------------ Complejo.py -----------------------------
#Programa para crear una clase con constructor parametrizado
#Uso de la función self "yo mismo"
#--- Identación

class Complejo:
---def __init__(self, parteReal, parteImaginaria):
------self.r = parteReal
------self.i = parteImaginaria
---------------- Complejo.py (Interactivo)---------------------
>>> x = Complejo(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)

Clase 6 [ 04 - 09 - 06 ]

2006-09-04T21:07:00.000-07:00

Clase 5 [ 30 - 08 - 06 ]

2006-09-04T21:06:00.000-07:00

Objetivo: Reforzar los conceptos de las estructuras de desición y asociar los la estructura de las funciones aplicadas al lenguaje de Python.

Codigo:
#Identacion ---
********************* Programa 1 ************************
/////////////////// Semana.py ///////////////////////////

a=int(raw_input("Digite el dia de la semana:"))
if a==1:
---print "Hoy es Lunes"
elif a==2:
---print "Hoy es Martes"
elif a==3:
---print "Hoy es Miercoles"
elif a==4:
---print "Hoy es Jueves"
elif a==5:
---print "Hoy es Viernes"
elif a==6:
---print "Hoy es Sabado"
elif a==7:
---print "Hoy es Domingo"
else:
---print "El dia no corresponde a ninguna semana"

/////////////// Modo iterativo semana.py ///////////////
>>>
Digite el dia de la semana:5
Hoy es Viernes
>>> ================ RESTART ==========================
>>>
Digite el dia de la semana:7
Hoy es Domingo
>>> ================ RESTART ==========================
>>>
>>> Digite el dia de la semana:32
El dia no corresponde a ninguna semana

Nota:La palabra clave def introduce una definición de función. Debe ir seguida del nombre de la función y la lista entre paréntesis de los parámetros formales. Las sentencias que forman el cuerpo de la función empiezan en la siguiente línea y deben ir sangradas. La primera sentencia del cuerpo de la función puede ser una constante de cadena: esta cadena es la documentación de la función o docstring

********************* Programa 2 ************************
///////////////////// calculadora.py ///////////////////

import math

def sumar(a,b):
---return a+b
def restar(a,b):
---return a-b
def multiplicar(a,b):
---return a*b
def dividir(a,b):
---return a/b
def raiz(a):
---return math.sqrt(a)
def seno(a):
---return math.sin(a)
def coseno(a):
---return math.cos(a)

////////// Modo iterativo calculadora.py /////////////

>>> a=float(raw_input("Digite a: "))
Digite a: 12
>>> b=float(raw_input("Digite b: "))
Digite b: 2
>>> sumar(a,b)
14.0
>>> restar(a,b)
10.0
>>> multiplicar(a,b)
24.0
>>> dividir(a,b)
6.0
>>> raiz(a)
3.4641016151377544
>>> seno(a)
-0.53657291800043494
>>> coseno(a)
0.84385395873249214

********************* Programa 2 ************************
///////////////////// fibonacci.py ///////////////////

def fib(n): # escribir la serie Fibonacci hasta n
---"""Escribir la serie Fibonacci hasta n."""
---a, b = 0, 1
---while b < n:
------print b,
------a, b = b, a+b

////////// Modo iterativo fibonacci.py /////////////

>>> fib.__doc__ #Recuperación de la documentación
'Escribir la serie Fibonacci hasta n.'
>>>
>>> fib(200)
1 1 2 3 5 8 13 21 34 55 89 144
>>> fib

>>>

Clase 4 [ 28 - 08 - 06 ]

2006-09-03T08:05:00.000-07:00

Objetivo: Reforzar en forma modular las sentencias if, for, while para que el estudiante pueda solucionar algunos problemas de programación.

Preguntas Quiz:
1) Realizar en forma modular la calculadora con las siguientes operaciones básicas:
-Suma
-Resta
-Multiplicación
-División
-Raiz Cuadrada
-Seno
-Coseno
Nota: Los datos deben pedirselo al usuario.

2) Relizar una lista con 4 tipos de datos diferentes [Entero, Real, Complejo, Cadena]
Nota: Los datos deben pedirselo al usuario.

Solución Quiz:
Codigo:
>>> #----------------------------------------------------------------------------
#Hecho en Mandriva Linux 2006
#versión IDLE 1.1.1
#Identación --
1)
import math
s=raw_input("Digite que operación desea realizar Suma, Resta, Multiplicacion, Division, Raiz Cuadrada, Seno, Coseno":)
if s=="Suma":
-- a=int(raw_input("Digite el primer valor:"))
-- b=int(raw_input("Digite el segundo valor:"))
-- print "El resultado de la Suma es:", a+b
if s=="Resta":
-- a=int(raw_input("Digite el primer valor:"))
-- b=int(raw_input("Digite el segundo valor:"))
-- print "El resultado de la Resta es:", a-b
if s=="Multiplicacion":
-- a=int(raw_input("Digite el primer valor:"))
-- b=int(raw_input("Digite el segundo valor:"))
-- print "El resultado de la Multiplicación es:", a*b
if s=="Division":
-- a=float(raw_input("Digite el primer valor:"))
-- b=float(raw_input("Digite el segundo valor:"))
-- print "El resultado de la División es:", a/b
if s=="Raiz Cuadrada":
-- a=int(raw_input("Digite el valor:"))
-- print "El resultado de la Raíz Cuadrada es:", math.sqrt(a)
if s=="Seno":
-- a=int(raw_input("Digite el valor:"))
-- print "El resultado del Seno es:", math.sin(a)
if s=="Coseno":
-- a=int(raw_input("Digite el valor:"))
-- print "El resultado del Coseno es:", math.cos(a)

2)
a=int(raw_input("Digite un valor entero:"))
b=float(raw_input("Digite un valor Real:"))
c=int(raw_input("Digite el valor entero del número complejo:"))
d=int(raw_input("Digite el valor imaginário del número complejo:"))
e=raw_input("Digite una cadena:")
L=[a, b, complex(c,d), e]
>>> #----------------------------------------------------------------------------

x = int(raw_input("Introduce un número entero: "))
if x < style="font-family: monospace;">
x = 0
-- print 'Negativo cambiado a cero'
elif x == 0:
-- print 'Cero'
elif x == 1:
-- print 'Uno'
else:
-- print 'Más'
>>> #----------------------------------------------------------------------------

x = int(raw_input("Introduce un número entero: "))
if x < style="font-family: monospace;">
x = 0
-- print 'Negativo cambiado a cero'
elif x == 0:
-- print 'Cero'
elif x == 1:
-- print 'Uno'
else:
-- print 'Más'
>>> #----------------------------------------------------------------------------

#Medir algunas cadenas:
a = ['gato', 'ventana', 'defenestrar']
for x in a:
-- print x, len(x)
. . .
gato 4
ventana 7
defenestrar 11

Clase 3 [ 23 - 08 - 06 ]

2006-08-24T08:33:00.000-07:00

Objetivo: En esta primera parte, manejar algunos conceptos, operaciones básicas de la Estructura de Datos "Lista" y aplicarlos en Python.
Finalmente, otras operaciones matemáticas, dejar la libre opción de verificar el codigo en forma interactiva y realizar pequeños programas modulares

Codigo:
#Hecho en Mandriva Linux 2006
#versión IDLE 1.1.1
>>> a=["casa",4.5,4566,complex(2,3)] #Creo una lista con diferentes tipos de datos
>>> a #Verifico la información de los elementos de la lista
['casa', 4.5, 4566, (2+3j)]
>>> a[2] #Puedo revisar cualqier posición de la lista
4566
>>> a[0] #Para el recorrido el subindice va de (0..n)
'casa'
>>> a[:2] #Puedo adqirir los dos primeros elementos de la lista, su recorrido es diferente va (1..n)
['casa', 4.5]
>>> a[2:] #Adquiero los dos ultimos elementos (n-1..n)
[4566, (2+3j)]
>>> a[2:]+a[:2]
[4566, (2+3j), 'casa', 4.5]
>>> a[2:]+a[:2] #Puedo adquirir todos los elementos de la lista usando las dos operaciones anteriores
[4566, (2+3j), 'casa', 4.5]
>>> #Observe que hasta el momento la lista se comporta o puede funcionar análogamente como una cadena de caracteres y puede ser aplicada también a vectores
>>> len(a) #Con la función len adquiero la longitud de la lista
4
>>> a
['casa', 4.5, 4566, (2+3j)]
>>> a[2]=a[2]+1000 #Puedo aumentar los valores enteros sumando alguna cantidad a la posición deseada
>>> a
['casa', 4.5, 5566, (2+3j)]
>>> a[0]="Mi "+a[0] #De igual forma aumentarle frases a las cadenas de caracteres
>>> a
['Mi casa', 4.5, 5566, (2+3j)]
>>> b=["Perro"] #Una forma de adicionar mas elementos a la lista: es creando otra y luego aplicar la operación suma (+)
>>> a=a+b
>>> a
['Mi casa', 4.5, 5566, (2+3j), 'Perro']
>>> a[2]="Google" #Puedo reemplazar algún valor de la lista
>>> a
['Mi casa', 4.5, 'Google', (2+3j), 'Perro']
>>> s=raw_input("Digite su nombre:") #Con la función raw_input puedo pedir cadenas de caracteres por teclado
Digite su nombre:Rodrigo
>>> s
'Rodrigo'
>>> i=int(raw_input("Digite su edad:")) #Usando la misma función, pero encerrandola entre int(s) convierto la cadena que capture por teclado a entero
Digite su edad:23
>>> i
23
>>> f=float(raw_input("Digite su estatura:")) #De forma análoga un valor real float(s)
Digite su estatura:1.78
>>> f
1.78
>>> import math #Podemos utilizar la librería Matemática para realizar operaciones trigonométricas
>>> dir(math)
['__doc__', '__file__', '__name__', 'acos', 'asin', 'atan', 'atan2', 'ceil', 'cos', 'cosh', 'degrees', 'e', 'exp', 'fabs', 'floor', 'fmod', 'frexp', 'hypot', 'ldexp', 'log', 'log10', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh']
>>> math.sqrt(9) #Ejemplo de raíz cuadrada
3.0
>>> math.pi #Valor de pi
3.1415926535897931
>>> math.cos(10) #Coseno de 10
-0.83907152907645244
>>> math.sin(10) #Seno de 10 (etc, etc, etc) Todas las posibilidades que nos muestra la función dir(math)

Clase 2 [ 16 - 08 - 06 ]

2006-08-22T15:32:00.002-07:00

Objetivo: Usar algunas funciones Matemáticas, adicionalmente aplicar operaciones entre cadenas y por último una pequeña introducción a la forma modular de Python mediante sintáxis hechas en forma interactiva

Codigo:
#Hecho en Windows Xp
#versión IDLE 1.1.3
>>> import sys
>>> sys.argv[0] #Argumento de entrada
''
>>> #Tipos de codificación para la entrada de valores
>>> #-*-coding: codificación -*-
>>> #-*-coding: iso-8859-15 -*-
>>> #-*-coding: utf-8 -*-
>>> 2+4
6
>>> 7/3 #La divisón entera redondea hacia abajo
2
>>> 7.0/3.0 #Forma de obtener la división exacta
2.3333333333333335
>>> 7/-3 #Otro ejemplo de división redondeada
-3
>>> ancho=20 #Operaciones aritméticas con Python
>>> alto=5*9
>>> ancho*alto
900
>>> x=y=z=500 #Asignación de 500 a Múltiples variables
>>> x
500
>>> y
500
>>> z
500
>>> 3*2.56 #Operación entre enteros y reales
7.6799999999999997
>>> 1j*1J #El manejo de los números complejos puede ser con j o J
(-1+0j)
>>> (5+6j) #Ejemplo de un número real (5) con un complejo 6
(5+6j)
>>> complex(5,6) #Otra forma de representar el ejemplo anterior con la funcion complex
(5+6j)
>>> 1j*complex(0,1) #Operación combinando las dos formas de representar números complejos
(-1+0j)
>>> a=1.5+0.5j #Extración de la parte real e imaginaria a la variable a
>>> a.real
1.5
>>> a.imag
0.5
>>> #----------------------------------------------------------------------------
>>> # Conversion de diferentes tipos de datos
>>> a=3
>>> a
3
>>> float(a)
3.0
>>> long(a)
3L
>>> c=3.0+4.0j #Asignación de un número complejo a la variable c
>>> c
(3+4j)
>>> float(c) #No es posible la conversión directa de complejo a real

Traceback (most recent call last):
File "", line 1, in -toplevel-
float(c)
TypeError: can't convert complex to float; use abs(z)
>>> #Se usa la función abs para hacer la conversión
>>> abs(c) #Internamente hace la operación sqrt[c.real**2 + c.imag**2]
5.0
>>> #----------------------------------------------------------------------------
>>> _ #La linea baja o "underscroll" muestra el último valor que se imprimió por el IDLE
5.0
>>> # Otras operaciones numéricas con "underscroll" ( _ )
>>> iva=12.5/100
>>> precio = 100.50
>>> precio*iva
12.5625
>>> precio +_
113.0625
>>> round(_,2) #Uso de la función round (redondear)
113.06
>>> a=_ #El IDLE de Python permite la asignación de "underscroll" ( _ ) a una variable pero no es conveniente hacerlo
>>> a
113.06
>>> #----------------------------------------------------------------------------
>>> # Cadenas de caracteres
>>> texto="Hola mundo cruel" #Asignar una cadena a una variable
>>> texto #Verificación del almacenamiento de la cadena
'Hola mundo cruel'
>>> a='hola' #Asignación de cadenas a variables
>>> b=' '
>>> c='cruel'
>>> d='mundo'
>>> e=a+b+d+b+c #Concatenación de varias variables
>>> e #Verificar la concatenación
'hola mundo cruel'
>>> a*9 #Se pueden relaizar combinaciones de variables de cadena con el operador por ( * ) para obtener la repetición horizontal de la cadena de caracteres
'holaholaholaholaholaholaholaholahola'
>>> import string
>>> "cad""ena" Concatenación de dos cadenas en pantalla
'cadena'
>>> "cad".strip()+"ena" Otra forma usando la función strip()
'cadena'
>>> _ #El uso de "underscroll" ( _ ) para mostrar la última cadena en pantalla
'cadena'
>>> h="palabras"
>>> h[2] #Muestra la letra de una cadena en la posición 2 esto lo recorre de [0..n]
'l'
>>> h[2:6] #Muestra un fragmento de una cadena desde la posición 2 hasta una anterior a la 6
'labr'
>>> h[:2] #Muestra las dos primeras letras de la palabra
'pa'
>>> h[2:] #Muestra la subcadena de las dos primeras letras en adelante
'labras'
>>> h[:2]+h[2:] #Uso de la concatenación con las dos elementos anteriormente mostrados
'palabras'

Clase 1 [ 14 - 08 - 06 ]

2006-08-22T08:43:00.000-07:00

Objetivo: Mostrar al estudiante el IDLE de Python en modo interactivo y probar muy rápidamente todas las posibilidades que tiene este lenguaje.

Codigo:
#Hecho en Mandriva Linux 2006
#versión IDLE 1.1.1
>>> #Comentarios en Python
>>> #ctrl+d (Salida del IDLE)
>>> Variable="a" #Asignación directa de una cadena 'a' para una variable
>>> print Variable #Impresión de la cadena
a
>>> Variable='b' #Asignación de otro dato para la variable pero con comilla simple
>>> print Variable #La Variable ahora toma el valor de 'b'
b
>>> pow(5,3) #Funciones (En este caso 5 elevado al cubo)
125
>>> 5**3 #Otra forma de elevar al cubo al valor de 5
125
>>> import sys #Forma de llamar librerias adicionales a las tradicionales
>>> #----------------------------------------------------------------------------
>>> #Verificación de algunas sentencias en Python, si el IDLE le asigna un color tiene muchas posibilidades de ser usada
>>> while #Verificación de la sentencia while (Existe)
>>> for #Verificación de la sentencia for (Existe)
>>> if #Verificación de la sentencia if (Existe)
>>> case #Verificación de la sentencia case (Sola no hace nada)
>>> break #Verificación de la sentencia break (Existe)
>>> reload #Verificación de la sentencia reload (Existe)
>>> try #Verificación de la sentencia try (Existe)
>>> do #Verificación de la sentencia do (Sola no hace nada)
>>> #----------------------------------------------------------------------------
>>> 8 #Cualquier número puede ser visto en pantalla solo con enter
8
>>> 'hola' #De manera análoga una cadena
'hola'
>>> "hola" #En este caso con comillas dobles
'hola'
>>> 5.89 #La forma de representación de un valor real en Python
5.8899999999999997
>>> 555555555555555555555555555 #Representacion de un valor largo (long)
555555555555555555555555555L
>>> package #No existe
>>> open #Existe
>>> #En modo interativo, cada linea es verificada antes de ser ejecutada y sus instrucciones de esta forma no son almacenadas
>>> dir #prueba de la funcion dir, se deben escribir paréntesis

>>> dir() #Forma correcta de probar la función dir
['Variable', '__builtins__', '__doc__', '__name__', 'sys']
>>> #Forma de verificar que metodos se pueden aplicar a la Variable con dir
>>> dir(Variable)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__str__', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'replace', 'rfind', 'rindex', 'rjust', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
>>> __name__ #Forma de verificar la función en la que se está trabajando
'__main__'
>>> #Uso de Tkinter para Gráficos GUI
>>> from Tkinter import * #Importar
>>> w = Button(text="colmayor", command='exit') #Creación del boton
>>> w.pack() #Empaquetamiento del Botón asignado a w
>>> w.mainloop() #Ciclo de la funcion main (Principal)

# ------------ Gráfico

>>> help(pow) #Prueba de la función help (ayuda)
Help on built-in function pow in module __builtin__:

pow(...)
pow(x, y[, z]) -> number

With two arguments, equivalent to x**y. With three arguments,
equivalent to (x**y) % z, but may be more efficient (e.g. for longs).

>>> s="abcdefghijk" #Prueba de la función len (longitud)
>>> len(s)
11
>>> #----------------------------------------------------------------------------
>>> #Verificación de algunas variables en Python, si el IDLE le asigna un color pueden ser usadas
>>> int #Entero

>>> long #Longitud larga

>>> float #Real

>>> complex #Complejo

>>> #----------------------------------------------------------------------------

Nota: Algunas instrucciónes descritas anteriormente, el IDLE de Python reporta error porque su sintáxis no es completa, debido a que el único objetivo de esta clase era la de identificar los colores, algunas variables y las funciones que se pueden utilizar.

Contenido del Curso

2006-08-15T06:15:00.000-07:00

NOMBRE DEL SEMINARIO
SEMINARIO DE PROGRAMACION EN PYTHON

Tipo de Seminario: Teórico y Práctico
Intensidad Horaria: 6 Horas Semanales / 96 Horas Semestrales
Requisitos para cursarlo: Algoritmos y Programación Orientada a Objetos

JUSTIFICACIÓN

La programación ágil demanda nuevos lenguajes en el desarrollo de software, donde estos involucren excelentes soluciones que tengan una gran aceptación en las empresas que exijan aplicaciones en muy corto tiempo, donde el tecnólogo se pueda desenvolver en el ámbito de la solución del problema y mantener en un segundo plano la sintáxis del lenguaje.

Con Python, el estudiante puede cumplir satisfactoriamente infinidad de demandas que surgen en la solución de aplicaciones para muchas compañías que soliciten un procedimiento informático.

OBJETIVO GENERAL

Familiarizar al estudiante con los conceptos básicos de la programación en el lenguaje de Python y su IDLE. Proporcionar las suficientes herramientas para el desarrollo de pequeñas o grandes aplicaciones.

OBJETIVOS ESPECIFICOS

Ayudar al estudiante a realizar de dos a diez veces más rápido las mismas cosas que se hacen en C, C#, C++, Java, Perl, VisualBasic y otros.
Enseñar con Python todas las formas de desarrollo de software, tanto como lenguaje de desarrollo primario, así como complemento para otros lenguajes y herramientas.

CONTENIDO TEMÁTICO

1. Introducción a Python

¿Qué es python?
¿Cómo aprender sobre Python?
Exploración del entorno IDLE
Un vistazo al intérprete de Python
"Hola Mundo" en Python

2. Elementos básicos del lenguaje

Expresiones y sentencias
Variables
Tipos de datos
Operadores
Comentarios
Identación
Ejemplo de uso de python como una calculadora

3. Herramientas de control de flujo

Construcciones if, else y elif
Sentencias for
Sentencias while
Construcciones con break, continue y else en bucles

4. Funciones

Definición de funciones
Valores por omisión en los argumentos
Argumentos por clave
Cadenas de documentación

5. Estructuras de datos

Listas, colas y pilas
Herramientas de programación funcional
Listas autodefinidas.

6. Clases y Objetos

Introducción a las clases
Unas palabras sobre la terminología
Ámbitos y espacios nominales en Python
Sintaxis de definición de clases
Objetos clase

7. Módulos

Introducción a los módulos
Módulos estándar
La función dir()
Introducción a los paquetes.

8. Librerías Gráficas de Python

Manejo de entornos gráficos en Python
Interfaces portables.

METODOLOGÍA

El curso combina la teoría y la práctica a través de clases magistrales, lecturas complementarias, libros electrónicos, trabajos en grupo, análisis de algoritmos, ejercicios de aplicación y un proyecto final desarrollado en Python.

BIBLIOGRAFÍA

Bruce Eckel, Thinking in Python, MindView. 2002.
Mark Lutz, David Ascher. Learning Python. O'Reilly. 1999.
Alex Martelli, David Ascher. Python Cookbook. O'Reilly. 2002.
Alex Martelli. Python in a Nutshell. O'Reilly. 2003.

Lecturas Complementarias:

Documentación oficial de Python, http://www.python.org/doc/
Documentación en español, http://pyspanishdoc.sourceforge.net/

Bienvenidos al Curso

2006-08-15T05:42:00.000-07:00

Hola pupilos!!!

Espero que este seminario optativo se desarrolle de la mejor manera posible, que tengan muchas inquietudes y ganas de aprender sobre este joven lenguaje de programación.

Quiero en este blog plasmar todas las actividades y experiencias que se van a tener los Lunes y Miercoles de 6:00 pm a 9:00 pm, horario planificado previamente con la decanatura de ingeniería del Colegio Mayor del Cauca

También espero recibir sus comentarios y sugerencias a mi correno electronico o por medio de este blog (parte inferior derecha: comments).

Gracias.