Clase 3 [ 23 - 08 - 06 ]

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 ]

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 ]

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

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

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.