Introduccion a la programacion en Python

Python es un lenguaje de scripting independiente de plataforma y orientado a objetos, preparado para realizar cualquier tipo de programa, desde aplicaciones Windows a servidores de red o incluso, páginas web. Es un lenguaje interpretado, lo que significa que no se necesita compilar el código fuente para poder ejecutarlo, lo que ofrece ventajas como la rapidez de desarrollo e inconvenientes como una menor velocidad.

Historia

Python fue creado a finales de los ochenta por Guido van Rossum en CWI en los Países Bajos como un sucesor del lenguaje de programación ABC, capaz de manejar excepciones e interactuar con el sistema operativo Amoeba.

Van Rossum es el principal autor de Python, y su continuo rol central en decidir la dirección de Python es reconocido, refiriéndose a él como Benevolente dictador vitalicio o Benevolent Dictator for Life (BDFL).

En el año 2000, el principal equipo de desarrolladores de Python se cambió a BeOpen.com para formar el equipo BeOpen PythonLabs. CNRI pidió que la versión 1.6 fuera pública, continuando su desarrollo hasta que el equipo de desarrollo abandonó CNRI; su programa de lanzamiento y el de la versión 2.0 tenían una significativa cantidad de traslapo. Python 2.0 fue el primer y único lanzamiento de BeOpen.com. Después que Python 2.0 fuera publicado por BeOpen.com, Guido van Rossum y los otros desarrolladores PythonLabs se unieron en Digital Creations.

Posterior a este doble lanzamiento, y después que van Rossum dejó CNRI para trabajar con desarrolladores de software comercial, quedó claro que la opción de usar Python con software disponible bajo GPL era muy deseable. La licencia usada entonces, la Python License, incluía una cláusula estipulando que la licencia estaba gobernada por el estado de Virginia, por lo que, bajo la óptica de los abogados de Free Software Foundation (FSF), se hacía incompatible con GNU GPL. CNRI y FSF se relacionaron para cambiar la licencia de software libre de Python para hacerla compatible con GPL. En el año 2001, van Rossum fue premiado con FSF Award for the Advancement of Free Software.

Sintaxis

Python es uno de los lenguajes de programación mas flexibles que puedes aprender, debido a que su forma de escribir no es compleja, no es necesario agregar ";" al final de cada linea de código, si quieres agregar un comentario basta con agregar un "#" antes del comentario.

>>> myvar = 3
>>> myvar += 2
>>> myvar
5
>>> myvar -= 1
>>> myvar
4
"""Este es un  comentario de multilineas,

por lo que puede ser tan grande como lo desee"""
>>> mystring = "Hello"
>>> mystring += " world."
>>> print(mystring)

Tipos de Datos

Las estructuras de datos disponibles en python son listas, tuplas y diccionarios. Estos están disponibles en la biblioteca de Python Las listas son como matrices unidimensionales (pero también puede tener listas de otras listas), los diccionarios son matrices asociativas (también conocidas como tablas hash) y las tuplas son matrices unidimensionales inmutables (las “matrices” de Python pueden ser de cualquier tipo, por lo que puede mezcla, por ejemplo, enteros, cadenas, etc. en listas / diccionarios / tuplas). El índice del primer elemento en todos los tipos de matriz es 0. Los números negativos cuentan desde el final hasta el principio, -1 es el último elemento. Las variables pueden apuntar a funciones. El uso es el siguiente:

>>> sample = [1, ["another", "list"], ("a", "tuple")]
>>> mylist = ["List item 1", 2, 3.14]
>>> mylist[0] = "List item 1 again" # Estamos cambiando el elemento.
>>> mylist[-1] = 3.21 # Aqui hacemos referencia del ultimo elemento.
>>> mydict = {"Key 1": "Value 1", 2: 3, "pi": 3.14}
>>> mydict["pi"] = 3.15 # De esta forma le cambiamos el valor a un diccionario.
>>> mytuple = (1, 2, 3)
>>> myfunction = len
>>> print(myfunction(mylist))
3

Puede acceder a los rangos de matriz utilizando dos puntos (:). Dejar el índice de inicio vacío asume el primer elemento, y el índice final supone el último elemento. La indexación es inclusiva-exclusiva, por lo que al especificar [2:10] se devolverán los elemento [2] (el tercer elemento, debido a la indexación 0) a [9] (el décimo elemento), inclusive (8 elementos). Los índices negativos cuentan desde el último elemento hacia atrás (por lo tanto, -1 es el último elemento) así:

 >>> mylist = ["List item 1", 2, 3.14]  

>>> print(mylist[:])
['List item 1', 2, 3.1400000000000001]

>>> print(mylist[0:2])
['List item 1', 2]

>>> print(mylist[-3:-1])
['List item 1', 2]

>>> print(mylist[1:])
[2, 3.14]

>>> print(mylist[::2])
['List item 1', 3.14]

Cadenas 

Las cadenas pueden usar comillas simples o dobles, y puede tener comillas de un tipo dentro de una cadena que usa el otro tipo (es decir, "Él dijo 'hola'" es válido). Las cadenas multilínea se incluyen entre _triple comillas dobles (o simples) ("" "). Las cadenas de Python siempre son Unicode, pero hay otro tipo de cadena que es bytes puros. Estos se denominan secuencias de bytes y se representan con el prefijo b, por ejemplo, b'Hello \ xce \ xb1 '. . Para llenar una cadena con valores, use el operador % (módulo) y una tupla. Cada %s se reemplaza con un elemento de la tupla, de izquierda a derecha, y también puede usar sustituciones de diccionarios, como: 

>>> print("Name: %s\
Number: %s\
String: %s" % (myclass.name, 3, 3 * "-"))
Name: Stavros
Number: 3
String: ---

strString = """This is
a multiline
string."""

# WARNING: Watch out for the trailing s in "%(key)s".
>>> print("This %(verb)s a %(noun)s." % {"noun": "test", "verb": "is"})
This is a test.

>>> name = "Stavros"
>>> "Hello, {}!".format(name)
Hello, Stavros!
>>> print(f"Hello, {name}!")
Hello, Stavros!

Declaraciones de control de flujo

Las declaraciones de control de flujo son if, for y while. No hay switch; en su lugar, usa if. Utilice para enumerar a través de miembros de una lista. Para obtener una lista de números, use el rango (<número>). La sintaxis de estas declaraciones es:

rangelist = range(10)
>>> print(rangelist)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

    for number in rangelist:
        # revisa si el numero es uno de los que esta en la tupla
        if number in (3, 4, 7, 9):
            # "Break" para poder parar el bucle aqui
            # no ejecutara lo de la condicion "else"
            break
        else:
            # "Continue" para que el bucle continune
            continue
    else:
        # el "else" es opcional, es por si no se cumple lo que esta en el bucle "for"
        # y se ejecutara si no hay un "break" dentro del bucle.
        pass # no hara nada
    if rangelist[1] == 2:
        print("The second item (lists are 0-based) is 2")
    elif rangelist[1] == 3:
        print("The second item (lists are 0-based) is 3")
    else:
        print("Dunno")
    while rangelist[1] == 1:
        pass

Funciones
Las funciones se declaran con la palabra clave "def". Los argumentos opcionales se establecen en la declaración de función después de los argumentos obligatorios al asignárselas un valor predeterminado. Para los argumentos con nombre, al nombre del argumento se le asigna un valor. Las funciones pueden devolver una tupla (y al desempaquetar la tupla, puede devolver múltiples valores de manera efectiva). Las funciones Lambda son funciones que se componen de una sola declaración. Los parámetros se pasan por referencia. Por ejemplo:

# Es igual que esta funcion, def funcvar(x): return x + 1
funcvar = lambda x: x + 1
>>> print(funcvar(1))
2


def passing_example(a_list, an_int=2, a_string="A default string"):
    a_list.append("A new item")
    an_int = 4
    return a_list, an_int, a_string

>>> my_list = [1, 2, 3]
>>> my_int = 10
>>> print(passing_example(my_list, my_int))
([1, 2, 3, 'A new item'], 4, "A default string")
>>> my_list
[1, 2, 3, 'A new item']
>>> my_int
10

Clases

Python admite una forma limitada de herencia múltiple en clases. Las variables y los métodos privados se pueden declarar agregando al menos dos guiones bajos y, a lo mas, uno al final (por ejemplo, __spam). También podemos vincular nombres arbitrarios a instancias de clase. Un ejemplo sigue :

 class MyClass(object):
    common = 10
    def __init__(self):
        self.myvariable = 3
    def myfunction(self, arg1, arg2):
        return self.myvariable

>>> classinstance = MyClass()
>>> classinstance.myfunction(1, 2)
3

>>> classinstance2 = MyClass()
>>> classinstance.common
10
>>> classinstance2.common
10

Versiones

Python cuenta con dos versiones la versión 2.7 (legendaria) y la versión 3.7 (nueva, moderna y sencilla). El pasar de una versión a otra no es complicado. pero el aprender la sintaxis y la forma en que python 3 trabaja nos ayudara a que cualquier proyecto que realicemos sea capaz de correr en cualquier versión superior a 3.