Introducción a Python
Contents
Agradecimientos
En la red hay muchos y muy buenos manuales de Python, en la introducción ya recomendamos algunos y estas notas le deben mucho a ellos. En esta sección solo veremos los elementos mínimos de Python para poder continuar con nuestro aprendizaje de macros en AOO. Empecemos.
Python tiene una sintaxis muy sencilla pero el interprete, es decir, el programa que se encarga de validar y ejecutar nuestro código es muy estricto, recuerda bien esto, es muy estricto. Los espacios, los tabuladores y hasta los nombres que asignamos, pueden tener repercusión en la ejecución de nuestro código, también pueden ser fuente de múltiples frustraciones que deseamos se reduzcan con estas notas.
Reiteramos, Python es muy estricto en su sintaxis, por ello y por otras buenas razones, Python cuenta con una guía de estilo de programación, que, en mayor medida, intentamos seguir la mayoría de los pythonistas, esta guía se le llama PEP8 y fue escrita, entre otros, por el mismo autor de Python, Guido van Rossum, tenemos una excelente traducción de nuestro amigo; Raúl González Duque, el autor del libro ya mencionado Python para todos, que puedes ver aquí: http://mundogeek.net/traducciones/guia-estilo-python.htm
Declarando y llamando macros
La estructura básica para una macro es.
def nombre_de_la_macro(): # Instrucciones de nuestra macro return
En el tema anterior ya vimos como llamar a otras macros, repasemoslo aquí.
def inicio(): solicitar_datos() procesar_datos() mostrar_info() print ('Fin') return def solicitar_datos(): return def procesar_datos(): return def mostrar_info(): return
Es muy importante que respetes la indentación de las líneas, más adelante veremos que importantes son. ¿Recuerdas que comentamos que Python es muy estricto?, comprobemoslo.
import uno def pruebas(): macro03 return def macro03(): return
¿Ya lo notaste? nos falto poner los paréntesis al llamar la macro. Veamos otra.
import uno def pruebas(): macro03() return def macro03() return
Ahora si, AOO nos muestra un mensaje de error. Observa como nos indica el archivo y la línea donde esta el error. En este caso, nos faltaron los dos puntos al final de la declaración de la macro. Lo repetiremos muchas veces: Python es muy estricto
Variables - Tipos básicos
No es necesario declarar el tipo de dato que contendrá una variable en Python, a esta característica se le llama: tipado dinámico. Ejemplos:
import uno def pruebas(): variables() return def variables(): texto = 'Soy un texto' numero_entero = 10 numero_flotante = 3.1416 booleanos = True # o False return
Para saber el tipo de valor que contiene una variable, usamos la función type.
def variables(): texto = 'Soy un texto' numero_entero = 10 numero_flotante = 3.1416 booleanos = True # o False print (type(texto)) print (type(numero_entero)) print (type(numero_flotante)) print (type(booleanos)) return
Cuidado, el que no necesites declarar el tipo de variable, no significa que puedas usarlas cuando quieras, recuerda, solo puedes usar variables asignadas previamente, la siguiente macro te tiene que dar un error.
def variables(): t = 'Hola mundo' print (t) print (s) return
Variables - Colecciones
Estos tipos de variables permiten almacenar más de un valor.
Listas
La lista es un tipo de colección ordenada. Sería equivalente a lo que en otros lenguajes se conoce por arrays, o vectores. Las listas pueden contener cualquier tipo de dato: números, cadenas, booleanos, ... y también listas, para crear una lista, se usan los corchetes y sus elementos separados por comas.
def variables(): # lista de número enteros mi_lista1 = [1, 2, 3, 4] # lista de cadenas mi_lista2 = ['Noemi', 'Paola', 'Claudia'] # lista mixta mi_lista3 = [10, 'Alejandra', 3.14, True, [9, 8, 7]] return
Observa que en la ultima lista, su ultimo elemento es otra lista. Más abajo mira algunas de las operaciones que podemos hacer con las listas. Para hacer referencia a un elementos de la lista, usamos su indice o posición, este, siempre empieza en cero.
print (mi_lista3[1])
Puedes modificar cualquier elemento de la lista.
mi_lista3[2] = 3.1416 print (mi_lista3)
Puedes realizar las siguiente operaciones con las listas.
# agregar un elemento al final mi_lista.append(10) print (mi_lista) # extender la lista con otra secuencia mi_lista.extend([100,200,300]) print (mi_lista) # borra un elemento mi_lista.remove(200) print (mi_lista) # insertar un elemento en la posición determinada mi_lista.insert(4, 500) print (mi_lista)
Tuplas
Son muy parecidas a las listas, se diferencian en su forma de crearse y en que son inmutables, es decir, no puede modificar sus elementos como en las listas. Para crear una tupla, usamos los paréntesis, si creas una tupla de un solo elemento, es importante uses la coma para crearla.
mi_tupla1 = ('Un solo elemento',) mi_tupla2 = (12, 13, 14) mi_tupla3 = (10, 'Estela', False, (1,3,5))
Observa que de nuevo en la ultima tupla, en su ultimo elemento, tenemos una tupla.
Diccionarios
Los diccionarios, también llamados matrices asociativas, son colecciones que relacionan una clave y un valor, para crearlos se usan las llaves de la siguiente manera.
peliculas = {'Vivir': 'Akira Kurosawa', 'El Gran Pez': 'Tim Burton', 'Amores Perros': 'Alejandro González Iñárritu'}
El primer valor se trata de la clave y el segundo del valor asociado a la clave. Como clave podemos utilizar cualquier valor inmutable: podríamos usar números, cadenas, booleanos, tuplas, ... pero no listas o diccionarios, dado que son mutables. La diferencia principal entre los diccionarios y las listas o las tuplas es que a los valores almacenados en un diccionario se les accede no por su índice, porque de hecho no tienen orden, sino por su clave.
print (peliculas['Vivir'])
Puedes usar esta misma clave para cambiar su valor.
peliculas['Vivir'] = 'Zhang Yimou'
Variables - Secuencias
Las listas, las tuplas y las cadenas de texto, son secuencias por que se puede acceder a sus elementos a través de in índice, no son los únicos en Python. Entre sus características están.
- No es necesario conocer cuantos elementos contendrá la secuencia.
- Pueden guardar cualquier tipo de objeto.
- No hay limite para la cantidad de elementos que guardará.
Para acceder a cualquier elemento de la secuencia, usamos un índice.
def secuencias(): mi_lista = [5, 9, 12, 1, 56] mi_tupla = (23, 89, 12, 56, 23) mi_cadena = 'Python es facil y divertido' print (mi_lista[0]) print (mi_tupla[1]) print (mi_cadena[2]) return
Si intentas usar un índice inexistente, el interprete te mostrará un error. También puedes usar índices negativos, con lo cual la cuenta empezará desde el ultimo elemento.
def secuencias(): print (mi_lista[-1]) print (mi_tupla[-2]) print (mi_cadena[-3])
Puedes usar funciones comunes a las secuencias, como contar su número de elementos, obtener el máximo o el mínimo.
print (len(mi_lista)) print (len(mi_tupla)) print (len(mi_cadena)) print (max(mi_lista)) print (max(mi_tupla)) print (max(mi_cadena)) print (min(mi_lista)) print (min(mi_tupla)) print (min(mi_cadena))
Puedes conocer el índice del primer elemento encontrado.
print (mi_lista.index(12)) print (mi_tupla.index(56)) print (mi_cadena.index('d'))
Puedes conocer el número de veces que aparece un elemento.
print (mi_lista.count(9)) print (mi_tupla.count(89)) print (mi_cadena.count('o'))
Puedes ordenar los elementos, para ello, usamos la función sorted.
print (sorted(mi_lista)) print (sorted(mi_tupla)) print (sorted(mi_cadena))
Puedes devolver solo una parte de la secuencia, a esta operación se le llama slices y se usan índices enteros (pueden ser positivos o negativos) de la forma [x:y:z], donde:
- x = elemento inicial.
- y = elemento final, cuidado, la posición y no es devuelta, por lo que el fin real es y-1.
- z = salto entre elementos, de forma predeterminada z = 1.
print (mi_cadena[7:15:1]) print (mi_cadena[0:20:2]) print (mi_cadena[-1:-10:-1])
Se pueden omitir los argumentos.
# devolvemos los primeros diez print (mi_cadena[:10]) # devolvemos los últimos diez print (mi_cadena[-10:]) # mira que divertido print (mi_cadena[::-1])
Podemos saber si un elemento pertenece a una secuencia con el operador in.
print (12 in mi_lista) print (100 in mi_tupla) print ('es' in mi_cadena)
Puedes sumar dos secuencias, con la única condición de que sean del mismo tipo, en el siguiente ejemplo, la ultima línea te dará un error.
print (mi_lista + ['a', 'b', 'c']) print (mi_tupla + ('x', 'y', False)) print (mi_cadena + (5, 10, 20))
Puedes multiplicar una secuencia por un entero, recuerda que la multiplicación es una suma abreviada.
print (['a', 'b', 'c'] * 3) print (('x', 'y') * 4) print ('adios' * 5)
Conversión del tipo de la variable
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, a esta característica se le llama fuertemente tipado. Para convertir variables de un tipo a otro usamos las siguientes funciones.
# convertimos un entero en cadena mi_entero = 100 print (type(mi_entero)) mi_entero = str(mi_entero) print (type(mi_entero)) # convertimos un flotante en cadena mi_numero = 3.14 print (type(mi_numero)) mi_numero = str(mi_numero) print (type(mi_numero)) # convertimos una cadena, en entero y luego el entero en flotante mi_cadena = '1000' print (type(mi_cadena)) mi_cadena = int(mi_cadena) print (type(mi_cadena)) mi_cadena = float(mi_cadena) print (type(mi_cadena)) # convertimos una cadena (secuencia) en una lista, luego la lista en tupla # y al final de nuevo en cadena, CUIDADO con la ultima conversión. mi_cadena = 'Hola Mundo' print (type(mi_cadena)) mi_cadena = list(mi_cadena) print (type(mi_cadena)) mi_cadena = tuple(mi_cadena) print (type(mi_cadena)) mi_cadena = str(mi_cadena) print (type(mi_cadena))
Operadores
Los operadores aritméticos son los siguientes:
# suma t = 10 + 20 # resta r = 100 - 45 # multiplicación m = 34 * 45 # exponenciación e = 2 ** 6 # división d = 50.5 / 2 # división entera de = 3.5 / 2 # modulo, resto de una división mo = 7 % 2 print (t, r, m, e, d, de, mo)
Los operadores de relación y booleanos son los siguientes.
# igualdad r = 10 == 10 print (r) r = 10 == 20 print (r) # diferencia r = 'A' != 'A' print (r) r = 'A' != 'B' print (r) # menor que r = 10 < 20 print (r) r = 10 < 5 print (r) # mayor que r = 20 > 5 print (r) r = 10 > 100 print (r) print '\n' # and r = True and True print (r) r = True and False print (r) r = False and True print (r) r = False and False print (r) # or r = True or True print (r) r = True or False print (r) r = False or True print (r) r = False or False print (r) # negación r = not False print (r) r = not True print (r)
Bucles
Para ejecutar una fragmento de código varias veces, usamos los bucles. La estructura for...in y la estructura while. Lo decimos una vez más; Python es muy estricto, y en el caso de los bucles lo podrás notar, pues el bloque de estas estructuras quedan delimitados por la indentación del código, no se usan paréntesis o llaves como en otros lenguajes, simplemente la sangría de las líneas es lo que determina la pertenencia y la validez de una estructura.