Lenguaje de alto nivel de programación interpretado cuya filosofía hace hincapié en la legibilidad de su código, multiparadigma, programación imperativa y, en menor medida, programación funcional. Es un lenguaje interpretado, dinámico y multiplataforma. En Python no se especifican los tipos de datos, que son tipados automáticamente.

En Python, para definir los diferentes bloques de código anidados, se utiliza la indentación: 1 tabulador, o 4 espacios.

Si se desea escribir una instrucción en varias líneas, se indica con el carácter \. En la línea siguiente la indentación es ignorada.

Con # Se comenta la línea partiendo del punto en donde se encuentra.
Con triple comilla ''' ... ''' Se escriben comentarios multilínea.

''' Ejemplo de comentarios
    definiendo una variable'''
i = 0 # defino la variable i  con valor 0

Las variables no se tipan:

varint = 69                 # tipo int
varfloat = 11.13            # tipo float
varstring = '¡Hola Mundo!'  # tipo string

También existen el tipo Boolean: True/False, con mayúscula la primera letra .
Una variable que no tiene un valor, es de tipo None. Atención a la mayúscula.

Para comprobar el tipo de variable, se usa la función type()

 type(var)

Las variables numéricas se pueden incrementar/decrementar:

i=0;
i+=1;  # i = i+1
i-=1;  # i = i-1

Las variables pueden ser eliminadas con la función del()

 del(var) # var es eliminada

Las variables que se declaren fuera de una función, tienen ámbito global. Las variables que se declaran en el interior de una función tienen ámbito local y sólo existen mientras se ejecute esa función. Dentro de una función se pueden usar variables globales anteponiendo global. El uso de variables globales es desaconsejable.

Para convertir las variables de un tipo a otro, se utilizan las funciones:

• Pasar a entero: int()
• Pasar a flotante: float()
• Pasar a string: str()

Estas funciones son input() y print().

Se utiliza para mostrar cadenas de carácteres. Se puede utilizar el símbolo + para concatenar cadenas. Puede mostrar un valor numérico, pero no mezclarlo con cadenas. Devuelve None.

print("¡Hola mundo!")
edad = 30
print ('Tengo '+ str(edad) + " años")

Se pueden usar indistintamente comillas simples ', o dobles “. Se usa \ como carácter de escape.

La función print() tiene dos parámetros opcionales: print(string, end, sep).

• end se refiere al carácter final de la cadena, que por defecto es el salto de línea.
• sep Si se indican varios strings (separados con ,), se indica el carácter con el que serán separados, por defecto es un espacio.

Se utiliza para introducir texto (cadenas de caracteres o strings).

print("Introduce tu edad: ")
edad = input()   # introduces el dato en la siguiente línea
nombre = input("Introduce tu nombre: ") # aparece el texto e introduces el dato a continuación, en la misma línea

Los operadores matemáticos son los habituales. Los operadores de comparación son los siguientes:

• A igual a B: A==B
• A distinto de B: A!=B
• A mayor que B: A>B
• A menor que B: A<B
• A mayor o igual que B: A>=B
• A menor o igual que B: A⇐B

Los operadores de comparación sirven para evaluar condiciones. Devuelven un valor Booleano (True o False) en función del resultado de la comparación.

Los operadores lógicos son los habituales: and, or y not.

Los operadores lógicos y booleanos suelen usarse juntos.

Declaración de if():

A=1
B=2
 
if (A==B):
    print("A igual a B")
 
elif (A > B):;
    print("A mayor que B")
 
else:
    print("A menor que B")

Declaración de while():

A=0
B=10
while(A!=B):
    A+=1
    print(A)

Si fuese necesario, se pueden usar las sentencias:

• break Sale del bcle while
• continue Pasa a la primera línea del interior del bucle while

Declaración de for():

#for i in range(10):     # i comienza en 0 hasta 9, ya que se realizan 10 repeticiones
for i in range(1,10,2):  # range(inicio, final, paso)
    print (i)            # 1 3 5 7 9

También pueeden usarse las sentencias break y continue.

El programa finaliza al finalizar la última línea de código. Si se desea provocar antes la finalización del programa, puede hacerse con ayuda de la librería sys, y su función exit().

import sys
for i in range(1,10,2):  
    print (i)
    if (i>5)
        sys.exit()         

Las funciones se definen: def nombreDeLaFuncion(argumento1, argumento2, argumento_n): Para que una función retorne un valor se utiliza la sentencia return, y en ese momento finaliza la función.

def elDoble(numero):
    return numero*2

Se pueden introducir parámetros opcionales declarándolos explícitamente:

def miFuncion(argumento1='a', argumento2='b'): # El programa usará a y b si no se declaran explícitamente en la ejecución del programa
    # ...
    # ...
    return 'c' 

Como se explicó en el apartado de variables, las variables que son declaradas en el interior de la función (locales), sólo existen en la ejecución de esa función. Para indicar que una función es global, hay que anteponer la sentencia global en la declaración de la variable.

Para que un programa no finalice cuando se da un error, usamos las clausulas try y except. Puede esta dentro de una función o fuera, en la ejecución del programa principal.

def spam (divideBy)
    try:
        return 42/divideBy       # Comprueba si ocurre algún error al ejecutar esta instrucción. Podría dividir por 0
 
    except zeroDivisionError:    # zeroDivisionError es el código de error que da Python al dividir entre 0. Provocar el error permite ver el código.
        print("Error: invalid argument") #Sentencia/s a ejecutar si se produce el error. Después el programa continúa con normalidad.

Los datos secuenciales son tipos de datos que pueden guardar más de un valor. Todos ellos pueden recorrerse con bucles for y usar las sentencias in y not in para comprobar si contienen un elemento con un valor concreto. También puede conocerse el número de elementos que tienen con la función len(variableSecuencial).

Los hay de dos tipos:

• Mutables: Sus elementos pueden ser editados, eliminados o añadir más.
• Inmutables: sus elementos son fijos y no pueden tocarse, eliminarse o añadir alguno más.

También pueden ser:

• Ordenadas: Se puede acceder a sus elementos a través de un índice numérico entre corchetes NopmbreVariable[índice].
• Desordenadas: Sus elementos no están ordenados, por lo que no se puede acceder a ellos con un índice numérico.

Variable de tipo secuencial que puede almacenar variables de diferentes tipos. Las listas son mutables y ordenadas. Se definen con los valores entre corchetes. Cuando se abre [ para definir una lista, se puede hacer en varias líneas, ya que la indentación es ognorada hasta encontrar ]. Útil para ganar en claridad si se definen, por jemplo, listas anidadas.

spam=['cat', 'bat', 'rat', 'elephant']
print(spam[1])  # bat el primer elemento siempre es el índice 0 

Se pueden definir listas vacías spam=[]. También pueden estar anidadas, es decir, es posible definir listas dentro de listas.

tablero=[['A1','B1','C1'], ['A2','B2','C2'], ['A3','B3','C3']]
casillaCentral=tablero[1][1]
print(CasillaCentral)

Para acceder a un elemento de la lista se usa un índice entre corchetes. La primera posición siempre es la 0. También pueden utilizarse índices negativos, siendo el -1 la última posición de la lista.

Se pueden extraer elementos de una lista (por ejemplo para crear otra de un “pedazo” de la original) de la siguiente forma:

• lista[n:m] Devuelve los valores consecutivos desde el elemento n (inicio), al m-1(penúltimo).
• lista[:m] Devuelve desde el valor inicial hasta el valor m-1.
• lista[n:] Devuelve desde el valor n, hasta el último (incluido).

Se pueden usar los operadores + y * para concatenar y replicar los elementos, respectivamente.

• Extraer el número de elementos: len() –> len(spam)
• Eliminar elementos de una lista: del –> del spam[2]
• Comprobar si un elementos está en la lista:
  • in: 'elemento' in spam # True si se encuentra
  • not in: 'elemento' not in spam # True si NO se encuentra
• Random La biblioteca rando, tiene dos métodos para usar con listas:
  • choice: random.choice(spam) Devuelve un elemento aleatorio.
  • shuffle: random.shuffle(spam) Ordena aleatoriamente los elementos de la lista

Es habitual usar un bucle for para recorrer los elementos de una lista con el índice de sus elementos. Es posible asignar a variables los valores de los elementos de una lista. Ojo, no se pasan por referencia, si se modifica el elemento, la variable continúa con el primer valor.

cat = ['fat', 'gray', 'loud']
size, color, disposition = cat
 
print ("Size:", size)                # Size: fat
cat[1]='black'           
print ("Color:", color)              # Color: grey
print ("Disposition:", disposition)  # Disposition: loud

Un bucle for también puede devolver 2 valores: índice de elementos y su contenido usando la función enumerate(), en lugar de range()

for index,item in enumerate(lista)

Las listas son realmente un tipo de objetos que tienen sus propios métodos, que permiten realizar diversas acciones con ellas:

• Encontrar elemento: index() lista.index(elemento). Devuelve el índice en el que ese elemento aparece por primera vez.

• Añadir elemento:
  • append() lista.append(elemento). Añade el elemento al final de la lista.
  • insert() lista.inseert(índice, elemento). Añade el elemento en la posición indicada, desplazando el resto una posición.

• Eliminar elementos:
  • remove() lista.remove(valor). Elimina el elemento la primera vez que aparece.
  • del() lista.del(índice). Elimina el elemento que se encuentra en el índice indicado.

• Ordenar elementos:
  • sort() lista.sort(reverse=False). Si la lista es numérica ordena de menor a mayor, y si son strings, ordena por orden alfabético. Si se declara reverse=True, el orden se hace a la inversa. Da error si aparecen mezclados tipos de datos.
  • reverse() lista.reverse(). Ordena los elementos al revés de como se encuentran.

Al copiar listas lista1 = lista2 ¡se copia la referencia, no la lista! Al contrario que pasa con los tipos de datos inmutables, al copiar dos listas, ambas apuntan a la misma dirección de memoria, lo que provoca que si se modifica una ¡afecta también a la otra!

spam=[0, 1, 2, 3, 4, 5]
cheese = spam
cheese[1] = 'Hello'
print(spam)          # [0,'Hello', 2, 3, 4, 5]

La función id() la posición de memoria que ocupa la variable que s epasa como agumento. Como depende de la memoria libre del sistema, cada vez que se ejecuta el programa, ésta será diferente.

Python tiene un recolector de basura automático, o automatic garbage collector que elimina de memoria las variables que ya no se van a usar en el programa, evitando una fuente común de problemas, como le ocurre por ejemplo a C.

Para evitar que por error modifiquemos el valor del elemento de una lista al pasarlo a una variable, tenemos la función copy() de la biblioteca copy.

import copy
 
cheese = copy.copy(spam)      # Copiamos spam en cheese, sin peligro de modificar spam
cheese = copy.deepcopy(spam)  # Usamos deepcopy() cuando la lista a copiar contiene otras listas

Las tuplas son un tipo de datos secuencial inmutable que por lo demás, funciona del mismo modo que una lista. Se define entre paréntesis en lugar de corchetes, y si tiene un único valor, a continuación de éste se pone una , para no confundirlo con una función.

Para convertir el tipo de dato:

• Convertir tupla en lista: list()
• Convertir lista en tupla: tuple()

Tipo de datos secuencial, desordenado y mutable, en la que cada elemento está formado por una pareja de clave (en lugar de índice) y valor.

Los diccionarios se definen con {}, y se separa cada pareja con :.

myCat={'size':'fat', 'color':'grey', 'age':5}
print myCat['size']  # 'fat'

Aunque a partir de Python 3.7 los diccionarios mantienen el orden en el que se introducen los elementos, no es así en versiones anteriores, y tratándose de un tipo de datos desordenado, para evitar problemas es mejor obviar esto y no tenerlo en cuenta.

Por tratarse de un tipo de datos desordenado, no es posible recorrerlas con un bucle for con range() usando un índice.

Algunos métodos útiles para extraer información:

• keys(): Devuelve las claves del diccionario, tipo dict_keys.
• values(): Devuelve los valores del diccionario, tipo dict_values.
• items(): Devuelve los pares clave-valor del diccionario, tipo dict_items.

Estos métodos (que NO devuelven elementos tipo lista) pueden usarse con un bucle for para extraer información de los elementos de un diccionario:

myCat={'size':'fat', 'color':'grey', 'age':5}
for v in myCat.keys()
    # ...  # v toma el valor de las claves

También se pueden usar las sentencias in y not in con los diccionarios.

Otro método para obtener información de un dato tipo diccionario es get(key Clave a buscar, Value valor a devolver si no la encuentra)

Para introducir una nueva pareja en un diccionario, si no se sabe si existe la clave, se utiliza el método setdefault(key Clave , Value Valor). Si la clave ya existe, la función no hace nada.

Para mostrar el contenido de un diccionario se puede usar la función pprint de la biblioteca pprint (Pretty Print):

import pprint
myCat={'size':'fat', 'color':'grey', 'age':5}
pprint.pprint(myCat)
    # ...    # Muestra en cada línea la pareja clave valor

También es posible anidar diccionarios:

allGests = {'Alice':  {'apples':5, 'pretzels':12},
            'Bob'  :  {'ham':3,    'apples':2   },
            'Coral':  {'cups':3,   'cakes':1    }}
 
# Un ejemplo de cómo recorrer un Diccionario con otros diccionarios anidados:
def totalBrought(guests, item):
    numBrought = 0
    for k,v in guests.items():
        numbrought=numbrought + v.get(item,0)
    return numbrought

Tipo de dato mutable, a los que se puede acceder a sus elementos, carácter a carácter, del mismo modo que se hace con otros tipos de elementos, como las listas. También se denominan cadenas de caracteres.

Se pueden definir con comillas simples '…', o dobles “…“. Dentro de las comillas dobles, las comillas simples pueden formar parte de la cadena sin necesidad de caracter de escape.

Caracteres de escape:

• \' comillas simples
• \” comillas dobles
• \t tabulación
• \n nueva línea
• \\ barra invertida

Si un string se encuentra definido entre triples comillas simples '*…', se pueden introducir saltos de línea sin necesidad de usar caracteres de escape. Tampoco es necesario usar otros.

Otro modo de declarar strings que se mostrarán tal y como se escriben, sin necesidad de declarar caracteres de escape es usando raw strings. Basta con poner r delante del string r'…'.

Permite el uso de las sentencias in y not in. Se puede usar string interpolation con %s para insertar otros strings.

name = 'Al'
age =4000
'Hello, my name is %s, and I am %s years', %(name, age)

Desde Python 3.6 existen f-strings, similar a string interpolation:

name = 'Al'
age =4000
f'Hello, my name is {name}, and I am {years+1}'

• upper() Pasar a mayúsculas.
• lower() Pasar a minúsculas.

• isupper() Devuelve True si todos los caracteres son letras mayúsculas.
• islower() Devuelve True si todos los caracteres son letras minúsculas.
• isalpha() Devuelve True si el string no está vacío y está formado sólo por letras.
• isalnum() Devuelve True si el string no está vacío y está formado sólo por número y letras.
• isdecimal() Devuelve True si el string no está vacío y está formado sólo por números.
• isspace() Devuelve True si el string no está vacío y está formado sólo por espacios, tabuladores y saltos de línea.
• istitle() Devuelve True si el string no está vacío y está formado sólo por letras, estando la primera en mayúscula.

• startswith(…) True si empieza con la cadena pasada como argumento.
• endswith(…) True si finaliza con la cadena pasada como argumento.

• Con el operador +.
• Concatenando strings con un caracter indicado, a través de la función join(). concatenador.join(['string1', 'string2', 'stringn'])

• split() Devuelve una lista de cadenas correspondientes a separar la cadena objeto tomando los espacios como carácter separador. Se puede introducir como argumento opcional otro caracter separador diferente. Añ igualquie ocurre con el espacio, el carácter delimitador es eliminado al separar las cadenas.
• Módulo paperclip. El módulo paperclip nos permite trabajar con el portapapeles del Sistema Operativo. No viene por defecto con Python, hay que instalarlo a drede. 2 funciones:
  • pyperclip.copy(string) Copia al portapapeles.
  • pyperclip.paste(string) Pega desde el portapapeles.
• partition() Se pasa como argumento el carácter o cadena desde la que se dividirá el string objeto. Uno de los strings será el propio argumento la primera vez que aparece. Si no encvuentra la cadena pasada como argumento, devuelve 3 strings, el primero con la cadena objeto completa y los otros dos vacíos. Pueden asignarse a varias variables varias cadenas de una vez.

before, sep, after = 'Hello World!'.partition(' ')
# before = 'Hello'
# sep = ' '
# after = 'World!'

• rjust(n, m) Número total de espacios, contando la cadena objeto. Los espacios de más se rellenan con el caracter m (o espacios, si no se especifica), por la izquierda.
• ljust(n, m) Número total de espacios, contando la cadena objeto. Los espacios de más se rellenan con el caracter m (o espacios, si no se especifica), por la derecha.
• center(n, m) Número total de espacios, contando la cadena objeto. Los espacios de más se rellenan con el caracter m (o espacios, si no se especifica). Se deja a la cadena objeto centrada.

• strip() Se eliminan espacios en blanco por delante y por detrás.
• lstrip() Se eliminan espacios en blanco por delante.
• rstrip() Se eliminan espacios en blanco por detrás.

Se les puede pasar un argumento que será tomado como el carácter a eliminar, en lugar de los espacios. Si se indica una cadena, no buscará la cadena para eliminarla, si no los caracteres que la componen de forma individual.

• ord() Para obtener el UNICODE del carácter que se pasa como argumento.
• chr() Para obtener el carácter del código UNICODE que se pasa como argumento.

A través de expresiones regulares, se buscan patrones de texto. Las expresiones regulares son comúnmente llamadas regexes.
Las funciones regex se encuentran en la biblioteca de python re.

Las expresiones regulares pueden llegar a ser muy largas y complejas. se pueden usar las triples comillas simples '''…''' para poner la expresión en varias líneas, de modo que se pueda ir comentando con #. Para que compile ignore espacios y # dentro de la expresión, se mete como segundo argumente re.VERBOSE

Para crar patrones, tenemos las siguientes claves:

• \d Dígitos de 0 a 9.
• \D Carácter que no es de 0 a 9.
• \w Cualquier letra, número o _.
• \W Carácter que no es ninguna letra, número, ni _.
• \s Cualquier espacio, tabulación o carácter nueva línea.
• \S Carácter que no es espacio, tabulación o carácter nueva línea.

• ? match ninguna o una vez el grupo precedente.
• * match ninguna o más veces el grupo precedente.
• + match una o más veces el grupo precedente.
• {n} match exactamente n veces el grupo precedente.
• {n,} match n veces o más el grupo precedente.
• {,m} match de 0 a m veces el grupo precedente.
• {n,m} match de n a m veces el grupo precedente.
• {n,m}? ó *? ó +? match de la cadena más corta coincidente, o non greedy. Las expresiones regulares por lo general son greedy, es decir, hace match la cadena más larga coincidente.
• ^spam La cadena debe comenzar por spam para hacer match.
• spam$ La cadena debe terminar por spam para hacer match.
• . Match cualquier carácter salvo nueva línea. .* Hace match cualquier string salvo el carácter nueva línea. Para que . también reconozca nueva línea, se pasa como segundo argumento a compile() re.DOTALL: newLineRegex=re.compile('.*',re.DOTALL).
• [abc] Match cualquier carácter de entre los corchetes.
• [^abc] Match cualquier carácter que no sea ninguno de los que se encuentran entre los corchetes.

En los carácteres entre corchetes se puede indicar varios caracteres seguidos según su código UNICODE, ejemplo: 0-9, a-z, A-Z, etc. Además, entre los corchetes no se utilizan escapes, todo lo que se ponga es tenido en cuenta automáticamente.

Para buscar en una cadena un patrón, debemos indicar dicho patrón como tipo de datos regex, para lo que se utilia la función compile(): patron=re.compile(r'Expresión regular') # La r indica que se trata de una expresión regular.

Para obviar mayúsculas y minúsculas se pasa a compile() como segundo argumento re.IGNORECASE o re.I.

Para buscar coincidencias se utiliza la función search(): coincidencia=patron.search(String donde buscar). La función search retorna un dato tipo match.

Para obtener el string del tecto coincidente con el patrón coincidencia.group().

Se puede agrupar resultados concretos de regex indicándolos con (…) en la expresión regular. Después podemos recuperarlos independientemente con group(n). donde n es el número de grupo. Si el número de grupo es 0, devuelve todas las coincidencias.

Con |, se pueden indicar varias posibilidades de coincidencia, del mismo modo que un OR lógico.

El método findall() devuelve una lista de strings con todos los matches.

Con el método sub(), se pueden sustituir las coincidencias. Se puede trabajar con el método sub() de dos formas:

1. A partir del patrón especificado anteriormente:
   patron.sub(string_que_sustituirá, string_donde buscará_coincidencias_para sustituir):

   nameRegex=re.compile(r'Agent\w+')
   nameRegex.sub('CENSORED', 'Agent Alice gave the secret document to Agent Bob.')
   # Sustituye "Agent Alice" y "Agent Bob" en la cadena por "CENSORED" 

2. Especificando el patrón en la propia función sub
   re.sub(patron, string_que_sustituirá_o_funcion, string_donde buscará_coincidencias_para sustituir, count=0, flags=0)\\donde se puede incluir una función (sin paréntesis) en la que se pasa el valor coincidente (tipo Match) y debe retornar el string por el que sustituir. count puede limitar el número de coincidencias a sustituir, y flags puede tomar el valor re.IGNORECASE para no diferenciar entre mayúsculas y minúsculas. Ejemplo:

   def dashrepl(matchobj):
   ...     if matchobj.group(0) == '-': return ' '
   ...     else: return '-'
   >>> re.sub('-{1,2}', dashrepl, 'pro----gram-files')
   'pro--gram files'
   >>> re.sub(r'\sAND\s', ' & ', 'Baked Beans And Spam', flags=re.IGNORECASE)
   'Baked Beans & Spam'

Se usa la biblioteca pyinputplus, que no viene con python, por lo que es necesario instalarla.

pip install --user pyinputplus
import pyinputplus as pyip # Se le puede definir un alias para no tener que escribir todo el nombre cada vez que se llama a uno de sus métodos.

Algunos de sus métodos:

• inputstr() Como input(), con las características de la biblioteca. Se puede indicar una función de validación personalizada.
• inputNum() Permite introducir un número y retorna un dato tipo int o float.
• inputChoice() Asegura que se introduce una de las opciones definidas.
• inputMenu() Asegura que se introduce una de las opciones definidas, que se encuentran ordenadas con letras o números.
• inputDatetime() Asegura que se introducce una fecha y hora.
• inputYesNo() Sobran las palabras.
• inputBool() Comprueba True o False. Devuelve otro booleano.
• inputEmail() Pues eso.
• inputFilepath() Asegura que se introduce una dirección y nombre de archivo válida, y opcionalmente comprueba si existe.
• inputPassword() Sin mostrar en pantalla los caracteres que se pulsan. Por defecto son sustituidos por *.

Las funciones inputNum(), inputInt() e inputFloat() aceptan una serie de argumentos (el primero es el texto a validar):

• min Número mínimo permitido.
• max Número máximo permitido.
• greatherThan Número mínimo permitido sin tenerlo en cuenta.
• lessThan Número máximo permitido sin contar el indicado.
• blank=True/False Permitir o no espacios en blanco.

Se puede limitar el número de intentos si se introduce el dato de forma errónea, ya que en caso de no hacerlo, lo seguiría pidiendo indefinidamente. Se puede hacer con los argumentos opcionales:

• limit=n Número de intentos. Genera un error RetryLimitException
• timeout=m Número de segundos máximo para introducir un dato válido. Genera un error TimeoutException

Se manejan con Try-Except.

Si se indica el argumento default:…, la cadena puesta a continuación se mostrará al sobrepasar el número de intentos o el tiempo de contestación.

Se pueden pasar regex con los argumentos:

• allowRegexes=[r'…', r'…', r'…'] Se indican los que la función no tenga permitidos, para poderlos introducir.
• blockRegexes=[r'…', r'…', r'…'] Limita incluso los que la función tenga permitidos.

allowRegexes sobreescribe a block si se especifican ambos y se pisan.