10 grandes razones para aprender Python

10 grandes razones para aprender Python

Python es mi lenguaje de programación favorito, y aprovechando que estamos en éste "hito" de temas de éste tipo en el blog, haré un post especial que le gustará a más de uno seguramente y sacará de dudas a otros tantos:


¿Porqué aprender Python?

1.- Porque es Fácil de aprender

A diferencia de muchos lenguajes allá afuera, Python tiene una sintaxis muy limpia y fácil de entender que es como hablarle en nuestro idioma a la máquina en lugar de tratar de entender idioma de máquina. Cualquier persona puede aprender Python fácilmente gracias a ésto y se sentirá cómodo mientras trabaja con él, aún si nunca ha programado nada en su vida.

Por otro lado, el intérprete interactivo (Python Shell) Tiene un "Debugger" bastante explicativo que prácticamente te muestra tu error cuando te equivocas, exactamente en donde está y dependiendo lo que uses para escribir tu código, casi casi la solución de cómo arreglarlo.

2.- Porque verás resultados más rápido

En Python escribes una línea de código, la guardas como un archivo ".py" y ya tienes un programa hecho. Es un lenguaje que no requiere compilación ni muchísimos pasos para empezar a sentirte como un "programador" y te permitirá desarrollar las más curiosas creaciones desde tus primeras lecciones con tan sólo el conocimiento básico. Su sintaxis es menos estricta que la de otros lenguajes (Como Java) y te permitirá hacer cosas que no son posibles en algunos de los demás, como cambiar el valor de una variable "al vuelo" dentro de tu código "nomás porque así lo deseas" (Tipado Dinámico).

Si quieres aprender un lenguaje de programación con el cual, desde el principio te veas CREANDO COSAS, entonces aprende Python.

3.- Porque puedes "especializarte" en varias cosas

Python te permite elegir "caminos" ya que dominaste lo básico del lenguaje bien a bien. ¿Te interesa la programación orientada a objetos? pues puedes volverte un Pythonista que escribe código orientado a objetos. ¿Te interesa la programación funcional? Puedes escribir python centrado en ése tipo de programación, ¿Qué tal la programación imperativa? Con Python tienes múltiples paradigmas de los cuales escoger.

4.- Porque Google lo usa y recomienda

El creador de Python, Guido Van Rossum trabaja para Google y no es de extrañarse que gracias a ésto, la mayoría de servicios de Google tengan un backend Python detrás de ellos. Google apoya activamente el uso de Python entre los programadores ya que les permite ser productivos en tiempo record y hacer cosas sorprendentes con pocas líneas de código. Encontrarás "Wrappers" Python para todas las API de Google, (o la mayoría) que hoy por hoy, dominan la web.

5.- Porque puedes crear Webapps, Desktop Apps y Shell Apps

Python es tan simple como poderoso. Si bien puedes hacer código fácilmente y crear programas en tiempo récord, ésto no significa que por éso "vayan a tener menos chiste" que los de lenguajes más complicados. Python te permite crear LO QUE TE IMAGINES. ¿Quieres hacer una aplicación web despampanante? con Python podrás hacerlo. ¿Te gustaría crear una aplicación de escritorio Multiplataforma? Con Python podrás hacerlo. ¿Qué tal un Script en "shell" para automatizar alguna tarea o proceso de tu sistema? También podrás hacerlo; Podrás hacer lo que quieras!

Como siempre les digo: Otra de las ventajas es que posiblemente algo que quieras que tu aplicación o proyecto haga, (alguna funcionalidad o cosa extra) es posible que alguien más ya la haya implementado en python y te podrás valer de su módulo para enriquecer tu código, fácil, rápido y sencillo. Con Python el límite REALMENTE va a ser tu imaginación y determinación para crear cosas.

6.- Porque puedes comenzar más rápidamente y escalar

Gracias a servicios como Google App Engine, cualquier usuario puede empezar a usar Python fácilmente en un ambiente práctico y de mundo real, haciendo (en ése caso) aplicaciones web para la nube, probando resultados, jugando con API's, resolviendo necesidades del usuario... ¿Necesitas escalar? Hacer tu código más grande? Python es TAN ESCALABLE que trabajar en ello no será un problema, al contrario, será todo un placer.

7.- Porque viene pre-instalado en Linux y MacOS

Python es un lenguaje tan popular actualmente que sistemas como MacOS y Linux lo traen pre-instalado desde que adquieres tu computadora o instalas tu distribución según el caso. Ésto por el lado del usuario (y/o aspirante a programador) ayuda a que se instale aplicaciones python y las pruebe más directamente, (además de que si quiere se inicie más rápido en el mundo de la programación con el lenguaje) Mientras que del lado del programador, con éso ya tienes "cubierta" una cuota de mercado bastante amplia para tus "PythonApps" (que no estén especialmente "preparadas" por plataforma por ejemplo) sabiendo que los usuarios de Linux y Mac no tendrán mayor problema al tratar de usarlas.

8.- Porque es fácil instalarlo en Windows

En el caso de Windows, Python no viene Pre-instalado, pero su instalación es TAN SENCILLA que a nadie se le complicaría por nada del mundo. Basta con descargar el instalador, hacer un "Siguiente>Siguiente>Siguiente" y listo! ¿Así o más fácil?

9.- Porque existe Ninja IDE

Todo programador sabe que su mejor amigo es el bloc de notas y la consola... Pero qué pasa cuando estamos trabajando en un proyecto grande o simplemente necesitamos las cosas más fáciles? Python tiene EL MEJOR IDE que he visto en mi vida y se llama Ninja-IDE: OpenSource, Multiplataforma y Súper cómodo tanto para el usuario principiante como para el más avanzado. Conócelo y te prometo que te gustará bastante!

10.- Porque es OpenSource

Como el excelente lenguaje de programación que es, Python es de código libre, lo que te permitirá no sólo crear las mejores apps y cosas con él, sino que también INVOLUCRARTE EN SU MISMO DESARROLLO! Python es de todos y para todos, y por éso también, es que deberías usarlo y escogerlo.

Así que bueno, si tu pregunta es: ¿Porqué debería aprender Python? ya te di 10 razones... Espero que te hayan convencido o al menos, te hicieran pensar un poco, Nos vemos!



Publicado por Manuel Escudero

Factorial iterativo

FACTORIAL ITERATIVO

El siguiente ejemplo de programación es un clásico en el tema de la recursividad, sin embargo, primero lo veremos de forma iterativa y posteriormente de forma recursiva y notaremos algunos problemas con el ejemplo de recursión.

Como recordarás, el factorial de un número es la multiplicación sucesiva de la serie del 1 al número deseado. Por ejemplo:

5! = 5 X 4 X 3 X 2 X 1
5! = 120

El símbolo '!' se utiliza para denotar el factorial del número que se escribe antes de éste símbolo. Podemos observar la serie de multiplicaciones que ocasiona el factorial. Una regla importante para el factorial es: 

0! = 1

Conociendo cómo funciona el factorial, podemos pasar a la implementación del programa de forma iterativa:

#-*- coding: iso8859-1 -*-


"""
Programa que muestra el factorial de un valor entero (n!)

PROGRAMA : FactorialIterativo.py
PROGRAMADOR : Cruz Gómez Jovanny Pablo  
                exp_95
LENGUAJE : Python
FECHA : 20 de Marzo de 2012
"""


import os


#-------------------------------------------------------------
# factorial()
#-------------------------------------------------------------


def factorial(n):
  resultado = 1

  for i in range(n):
resultado *= (i + 1)

return resultado

os.system("color F0")


consulta = '1'
while(consulta != '0'):
os.system("cls")


valor = input("Ingresa un valor: ")
fact = factorial(valor)

print "\nEl factorial de ", valor, " es: ", fact

print "\nPara salir presiona 0"
consulta = raw_input("de lo contrario cualquier tecla: ")


En la función 'factorial()' se puede observar el uso del bucle 'for' para acumular las multiplicaciones. Al ejecutar el programa anterior y tomando de ejemplo 5!, tenemos:

5!

Lo mejor de utilizar el factorial de forma iterativa en Python, es que funciona para cantidades grandes (hasta enormes) y es capaz de mostrar todos los dígitos del resultado. En el caso de las calculadores científicas como la fx-991ES PLUS, el factorial máximo que puede calcular es el 69, ya que al intentar calcular 70!, la calculadora se desborda.

El resultado que la fx-991ES PLUS muestra para 69! es:

Resultado de 69! con la fx-991 ES PLUS

El resultado en la calculadora es mostrado con la notación científica. Ahora bien, si probamos nuestro programa para 69! nos muestra: 

Resultado de 69! con el programa FactorialIterativo.py

Podemos observar exactamente el mismo resultado; la diferencia, es que Python muestra todos los dígitos de la operación.

NOTA:
Para el caso de utilizar el factorial en otro lenguaje
de programación como C/C++ o Java, tendremos
un problema de desbordamiento similar al que de 
calculadora debido a los tipos de datos que manejan.
Python es una poderosa calculadora =)

Ahora probemos algo más fuerte, algo que la calculadora científica no es capaz de calcular. ¿Qué les parece 1000! ? Veamos si Python es capaz de resolverlo:

Resultado de 1000!

Wooow! Python es capaz de resolver 1000!. Ahora probemos algo aún más fuerte =D

23525!

Resultado de 23525!

Vaya, parece que tenemos un problema y es que NO SABEMOS QUÉ HACER CON TANTO NÚMERO QUE ARROJÓ PYTHON =D y es que parece que el resultado no tiene fin jeje

Finalmente podemos concluir que Python funciona como una potente calculadora que es capaz de resolver factoriales de números muy grandes y arrojar resultados gigantescos.


Bisección

MÉTODO DE BISECCIÓN CON PYTHON

A continuación se muestra la implementación del método numérico de bisección, el cual toma dos intervalos iniciales y los va dividiendo respecto al polinomio ingresado para encontrar una solución para dicho polinomio.

#--------------------------------------------------------------
#   Programa que utiliza el metodo de Biseccion para el calculo
#   de raices de un polinomio de n grado
#
#   PROGRAMA        :       Biseccion.py
#   PROGRAMADOR     :       Cruz Gomez Jovanny Pablo
#   LENGUAJE        :       Python
#   FECHA           :       03 de Marzo de 2012
#---------------------------------------------------------------


import os       
import math


#---------------------------------------------------------------
# Funcion que muestra el titulo del programa
#---------------------------------------------------------------
def titulo():
    os.system("CLS")
    print "Metodo de biseccion\n"


#---------------------------------------------------------------
# Funcion que evalua f(x) con el metodo de Horner
#---------------------------------------------------------------
def f(coeficientes, grado, valor):
    resultado = coeficientes[0]
    i = 1


    while(i <= grado):
        resultado = (resultado * valor) + coeficientes[i]
        i += 1


    return resultado
    
#---------------------------------------------------------------
# FUNCION QUE CALCULA Mx
#---------------------------------------------------------------
def Mx(a, b):
    return (a + b) / 2


#---------------------------------------------------------------
# METODO DE BISECCION
#---------------------------------------------------------------
def biseccion(coeficientes, grado, iInicial, iFinal):
    a = iInicial
    b = iFinal
    nIteraciones = math.ceil((math.log(b - a) - math.log(0.00001)) / math.log(2))


    titulo()


    print "{0}\t{1}\t{2}\t{3}\t{4}".format('n', 'a', 'b', 'Mx', 'f(Mx)f(a)')


    i = 1
    while(i <= nIteraciones):
        x = Mx(a, b)
        Fx = f(coeficientes, grado, x)
        Fa = f(coeficientes, grado, a)


        condicion = Fx * Fa


        print i, "\t{:.4}\t{:.4}\t{:.4}\t{:.4}".format(a, b, x, condicion)


        if(condicion > 0):
            a = x
        elif(condicion < 0):
            b = x
        else:
            x = x


        i += 1
    print "\nLa raiz encontrada es: {0}\n".format(x)


#---------------------------------------------------------------
#Programa principal
#---------------------------------------------------------------


consulta = '1'
while(consulta != '0'):
    os.system("COLOR F0")
    titulo()


    grado = int(raw_input("Grado de ecuacion: "))   
    print                                                  
    iInicial = float(raw_input("Intervalo inicial: "))      
    iFinal = float(raw_input("Intervalo final: "))         


    titulo()


    coeficientes = []       


    i = grado
    while(i >= 0):                                              
        cof = float(raw_input("Ingresa x^{0}: ".format(i)))     
        coeficientes.append(cof)                                
        i -= 1                                                   


    biseccion(coeficientes, grado, iInicial, iFinal)


    print
    consulta = raw_input("Para salir presiona 0, sino otra tecla: ")






El programa anterior puede ser probado con el polinomio:


Polinomio de ejemplo

Donde podemos observar que el grado es 3 (grado = 3). La siguiente imagen muestra la gráfica del polinomio anterior:

Gráfica del polinomio


En la gráfica podemos observar que existe una raíz entre 1 y 2, por lo que el programa de 'Bisección.py' pide al usuario ingresar 2 intervalos; para éste polinomio, los intervalos que tomaremos serán 1 y 2 ya que suponemos que ahí existe una solución.

Inserción del grado de la ecuación y los intervalos

Después de dar ingresar el grado de la ecuación, procedemos a ingresar los coeficientes del polinomio tomado de ejemplo:

Inserción de coeficientes del polinomio

Finalmente es mostrada la tabla de iteraciones y la raíz del polinomio ingresado:

Tabla de resultados para la raíz del polinomio

Podemos concluir que la raíz se encuentra en el punto 1.36522674561. Para comprobar este resultado podemos ir nuevamente a la gráfica y realizar un zoom en el área de la raíz:


Aproximación gráfica de la raíz

Entonces se puede confirmar que el programa funciona correctamente, ya que al realizar un zoom en la gráfica muy cerca de la raíz, observamos la aproximación (en la gráfica la raíz está cerca de 1.3652) que tiene una precisión menos significativa a la que el programa nos mostró.

Cabe mencionar que el programa funciona para cualquier polinomio de n grado.
Los reto a probarlo con un polinomio de grado 20, 30, 50 o cualquier grado =P

Hasta la próxima!


IDE para Python

PROGRAMACIÓN UTILIZANDO UNA IDE PARA PYTHON

Muy bien, es hora de avanzar en el largo camino que nos queda por aprender, así que comencemos a crear aplicaciones Python utilizando una IDE.

IDE (Integrated Development Enviroment - Entorno de Desarrollo integrado) es una interfaz gráfica que se utiliza para la programación de aplicaciones en un lenguaje de programación en específico. Existen muchos y muy variados, pero para el caso que nos concierne, nos enfocaremos en uno solo: la IDLE de Python. IDLE es una IDE que Python proporciona a sus desarrolladores en la cual se puede crear, editar, compilar y correr aplicaciones para éste lenguaje.

Para descargar el conjunto de aplicaciones necesarias, vamos a la página de ActivePython:


ActivePython contiene la IDLE que necesitamos para crear nuestras aplicaciones =)
Para descargar ActivePython podemos seleccionar la opción que se adecue a nuestro Sistema Operativo. Para el caso de Ubuntu se puede obtener la IDLE mediante el centro de software Ubuntu.

Página de descargas de ActivePython

Cuando termine de descargar el archivo y se instale, podemos acceder a ello desde el menú de inicio (en el caso de Windows):

Acceso a la IDLE desde el menú Inicio


Al abrir la IDLE lo primero que nos mostrará será una ventana similar a la que usamos desde el CMD, en este caso en blanco más grande, es la shell de la IDLE:

Shell de la IDLE

Para escribir nuestras aplicaciones utilizando la IDLE, vamos a file -> New Window lo cual nos abrirá la ventana donde escribiremos las aplicaciones que serán ejecutadas posteriormente en la shell =D:

Ejemplo de aplicación desde la IDLE

Ahora, después de escribir algún código, debemos guardarlo con la extensión ".py", por ejemplo:

Horner.py
Saludos.py
Suma.py

Para ejecutar las aplicaciones basta con presionar la tecla 'F5'.

Hasta la próxima =D



Conversión de tipo de datos

CONVERSIÓN DE TIPO DE DATOS

En capítulos anteriores mencionaba que en Python no existe la necesidad de declarar las variables con un tipo de dato en específico ya que Python trabaja de un modo "genérico" y procesa las variables con el tipo de dato con el que se encuentren. Sin embargo, la conversión de tipo de datos se utiliza frecuentemente con la entrada de datos, es decir, cuando utilizamos la función 'raw_input()'. Recordemos que 'raw_input()' asigna a cierta variable una cadena que el usuario ingresó, así, si el usuario ingresa 123, Python lo interpreta como una cadena de caracteres que tienen los símbolos '1', '2' y '3' y en realidad habría ingresado la cadena "123".

Python cuenta con la conversión de tipo de datos (comúnmente llamada cast o casting) para especificar explícitamente el tipo de dato con el que deseamos trabajar. 

Para hacer castings en la entrada de datos, debemos colocar el tipo de dato que deseemos manejar (int, str, float, etc) y entre paréntesis la variable que va a ser convertida.

1. >>> var1 = 52
2. >>> float(var1)
3. 52.0
4. >>> var2 = 152.02
5. >>> var3 = str(var2)
6. >>> var3
7. '152.02'
8. print var3
9. 152.02

En en ejemplo anterior se declara la variable 'var1' y se le asigna el valor entero 52. En la línea dos el entero que contiene 'var1' se convierte a flotante con la instrucción 'float(var1)' y se muestra el resultado de la conversión. En la línea 4 se declara 'var2' con un valor de 152.02 (un flotante) para posteriormente ser convertido a una cadena con 'str(var2)' y esa cadena asignarla a 'var3'. El contenido de 'var3' es mostrado en la línea 7 entre comillas simples, esto se debe a que cuando omitimos la palabra print, se muestra el contenido de las variables pero especificando si son de tipo numérico o de cadenas de caracteres, en éste caso 'var3' es un string, por esta razón la salida es entre comillas simples. Sin embargo, cuando colocamos la palabra print, se muestran los datos de forma normal (sin comillas simples).

NOTA:
Para imprimir variables, en ocasiones podemos
solamente escribir la variable sin la palabra 'print'
Experimenta para saber cuál es la diferencia.

Ahora bien, para poder ingresar los datos a alguna variable con 'raw_input()' se realiza la misma operación, como sigue:

1. >>> var1 = int(raw_input("Ingresa un entero: "))
2. Ingresa un entero: 123
3. >>> var2 = int(raw_input("Ingresa otro entero: "))
4. Ingresa otro entero: 12.36
5. >>> var3 = str("Ingresa un valor decimal: ")
6. Ingresa un valor decimal: 152.36
7. >>> var4 = float(var3)
8. >>> print var1, var2, var3, var4
9. 123 12 152.36 152.36

En la linea uno se pide ingresar un entero, para lo cual ya definimos en que verdad esa variable va a ser un entero con el casting que realizamos con 'int(raw_input())'. En la línea se pide ingresa nuevamente un entero, pero el usuario ingresó un valor decimal, pero Python de todos modos lo toma como entero, y lo hace eliminando los decimales y quedándose únicamente con el valor entero. Para el caso de 'var3' se pide ingresar un valor decimal, pero Python lo tomará como una cadena explícitamente, ahora bien, en la línea 7 decimos que 'var4' va a contener el valor de 'var3' pero convertido a float. Finalmente los datos son mostrados en pantalla. Se pide experimentar el tipo de dato que son con la función 'type()'.


Ingreso de datos

INGRESO DE DATOS EN PYTHON

En Python se pueden ingresar datos desde la consola por medio de la instrucción 'raw_input()', la cual pedirá al usuario ingresar cierto valor por medio de un mensaje de ingreso. Generalmente esta función se asigna a una variable ya que 'raw_input()' contiene la información ingresada por el usuario. Así que en realidad a la variable le asignamos el contenido ingresado por el usuario.

nombre = raw_input("Ingresa tu nombre: ")

Al analizar la sentencia anterior tenemos ciertos criterios "desconocidos". Podemos observar una cadena de caracteres "Ingresa tu nombre: " la cual es el mensaje de ingreso de datos y debe ir dentro de los paréntesis de 'raw_input()' ya que es un parámetro de esta función. El término parámetro lo veremos más adelante en el capítulo dedicado a las funciones.

En el momento en el que el intérprete llega a la instrucción anterior, muestra el mensaje "Ingresa tu nombre: " y espera a que el usuario ingrese algún dato.

1. >>> nombre = raw_input("Ingresa tu nombre: ")
2. Ingresa tu nombre: Jovanny
3. >>> print nombre
4. Jovanny

En la línea 1 se realiza la asignación de la función 'raw_input()' a la variable nombre. Cuando se ejecuta esta instrucción, se muestra el mensaje en la línea 2 y se espera a que se ingrese algún dato, en este caso se ingresó "Jovanny". En la línea 3 se pide imprimir la variable 'nombre', la cual ocasiona la salida del contenido de la variable que es "Jovanny".

Demostración de 'raw_input()'


Con lo anterior visto, ¿Qué tipo de dato por defecto usa 'raw_input()' para asignarlo a cualquier variable?

La respuesta es que 'raw_input()' siempre utiliza como tipo de dato una cadena de caracteres "string", lo cual ocasiona que si se ingresa un número con esta función, el dato se guardará como string y no como entero. Para comprobarlo utilizaremos la función 'type()'.

1.    >>> valor1 = raw_input("Valor1: ")
2.    Valor1: 25
3.  >>> valor2 = raw_input("Valor2: ")
4.     Valor2 = 156.254
5.  >>> lenguaje = raw_input("Lenguaje: ")
6.     Lenguaje: Python
7.  >>> print valor1, valor2, lenguaje
8.    25 156.254 Python
9.  >>> type(valor1)
10.   <type 'str'>
11.    >>> type(valor2)
12.    <type 'str'>
13.    >>> type(lenguaje)
14.    <type 'str'>

Como se puede notar, de las líneas 1 - 6, se pide ingresar datos, dos valores numéricos y el nombre de cualquier lenguaje. Se puede imaginar que Python los guarda como entero y de punto flotante respectivamente, pero en realidad los asigna a cada variable como tipo string ya que así funciona la instrucción 'raw_input()'. Lo anterior se puede comprobar al utilizar la función 'type()' a la cual le ingresamos el nombre de la variable a analizar dentro de los paréntesis, al escribirlo Python nos indica que las 3 variables son de tipo 'str', es decir, string.

Uso de 'raw_input()'


El tema de conversiones de tipo de dato se verá en el siguiente capítulo.




Variables

VARIABLES

Bien, es momento de comenzar con algo de programación dentro del intérprete de Python.

En esta primera parte del curso, revisaremos los aspectos generales de las variables en Python. 

DEFINICIÓN DE VARIABLE

Una variable es una localidad de memoria que la computadora reserva para almacenar datos ingresados por el usuario. El término variable se utiliza para afirmar que el uso de esa localidad de memoria va a "variar" dependiendo de los datos que vayan a ser ingresados en ella. Al ingresar un nuevo dato dentro de la localidad, los datos anteriores se perderán.

DECLARACIÓN DE VARIABLES EN PYTHON

Si se tiene experiencia en otros lenguajes de programación como C/C++ o Java, recordaremos que para declarar una variable en alguno de estos lenguajes, se tenía que especificar el tipo de dato que la memoria iba a almacenar:

int valor1;           //Se declara una variable que almacenará un entero
float cociente;     //Se declara una variable que almacenará un número de punto flotante

En Python no es necesario especificar el tipo de dato que se manejará, ya que es, de cierto modo, "genérico". Claro que existen algunas excepciones para las variables como veremos más adelante.

Generalmente declaramos una variable cuando esté lista para usarse y no desde el principio del programa (en el caso de otros lenguajes de programación). Algunos ejemplos de las variables en Python son:

NOTA IMPORTANTÍSIMA:
En Python las instrucciones  no se separan 
por medio de punto y coma(';'), basta con 
dar un salto de línea.

valor1 = 15                           #Se declara una variable que almacenará el número 15 (un entero)
cociente = 3.2587                 #Se declara una variable que almacenará el número 3.2587 (un punto flotante)
nombre = "Jovanny"            #Se declara una variable que almacenará la cadena "Jovanny" (un string)

En las anteriores declaraciones de variables se puede notar el uso del operador ' = ' conocido como el operador de asignación y se lee:

valor1 = 15      #A la variable 'valor1' asígnale el valor 15


También se puede notar el carácter "#"  el cual se utiliza para añadir comentarios de línea al archivo del programa.

Como ejemplo de programación, escribiré un programa que realice la multiplicación de 3 números y se muestre el resultado:

>>> valor1 = 5
>>> valor2 = 47
>>> valor3 = 1256
>>> producto = valor1 * valor2 * valor3
>>> print producto
295160

Demostración del uso de variables en Python



Descarga e instalación de Python

Descarga e instalación de Python


Antes de comenzar el curso de programación en Python, es necesario descargar el interprete de del lenguaje de programación. Para ello vamos a la sección de descargas en la página oficial de Python:


Al ingresar, se puede observar que existen versiones para Windows, Linux y Mac, ya que Python es un lenguaje multiplataforma y lo mejor de todo es OpenSource.

El archivo que debemos descargar es el que lleva por nombre:

Python 2.7.2 Windows Installer (Windows binary -- does not include source)
(para Windows)

Al descargarlo e instalarlo, ya podremos iniciar con la introducción a Python.
Con esto que acabamos de descargar seremos capaces de aprender cómo dar instrucciones a Python a través de su interprete (por medio de la consola). Posteriormente descargaremos un IDE para poder guardar nuestros archivos de forma permanente y poder interpretar y correr nuestras aplicaciones desde él.


Ingresar al intérprete por medio de la consola

Una vez que ya descarguemos Python, vamos a la consola: (tecla Windows + R >> cmd ), donde nos abrirá la siguiente ventana: 

Ventana del CMD

Para "activar" Python desde el cmd, debemos ir al directorio donde se instaló Python, este directorio es: 

C:\Python27

Para acceder a ese directorio desde la consola, debemos escribir: 
cd \
cd Python27

Y finalmente, para "activar" Python, basta con escribir dentro de ese directorio: 

python

Con lo que ya estaremos dentro del intérprete, ahora ya podremos programar desde el cmd =)

"Activación" de Python

Después de realizar las acciones antes mencionadas, ya podremos acceder a Python desde cualquier directorio del cmd, sólo bastará abrir el cmd y escribir Python para acceder a ello.

Como se pude ver en la imagen de arriba, después de escribir Python en la consola aparecen palabras que nos indican la versión de Python que estamos usando y algunas otras cosas. Lo más importante por observar es la última línea (>>>) la cuál se llama "prompt" y es donde Python espera nuestras instrucciones. Ahora vamos a hacer un pequeño ejemplo de programación en Python.

>>> print "Adios mundo, Hola Python!!!"
Adios mundo, Hola Python

Como podemos apreciar, Python no requiere de ninguna librería para poder escribir un mensaje en la consola, basta con poner la palabra print seguido del mensaje entre comillas. En el ejemplo coloqué la instrucción y debajo la salida. En la consola veríamos: 

Primer programa en Python



¡Bienvenidos!

Saludos a todos,

El propósito de un blog relacionado con la programación en el lenguaje Python, es fomentar la tecnología a través de otros medios para la creación de aplicaciones que pueden ser utilizadas por todas las personas.

Este lenguaje de programación tiene ciertas características, las cuales lo hacen fácil y divertido de aprender. Si se desea comenzar a aprender programación, Python es el lenguaje ideal para iniciar a pensar como un programador profesional debido a su sintaxis clara y precisa, además de la facilidad que proporciona para programar con gráficos.

Python fue considerado como el lenguaje más utilizado por programadores de todo el mundo en 2011; con esto se puede verificar el poder que tiene Python en la tecnología.

Otro de los propósitos del blog es dar a conocer las características elementales del lenguaje para aprender a programar en él, es decir, el blog pretende enseñar a programar en el lenguaje Python para la solución de problemas cotidianos. El curso va dirigido a programadores experimentados como a los principiantes en Python.

Espero ser de gran ayuda para todos Ustedes!



ÍNDICE

  1. Descarga e instalación de Python
  2. Variables en Python
  3. Ingreso de datos
  4. Conversión de tipo de datos
  5. Programación en Python utilizando una IDE

EJEMPLOS DE PROGRAMACIÓN


Visitas