Enciclopedia Galáctica

Esta página es de solo lectura. Puedes ver la fuente pero no puedes cambiarla. Pregunta a tu administrador si crees que esto es incorrecto.
====== Conceptos básicos Python ======
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.
===== Comentarios =====
Con **#** Se comenta la línea partiendo del punto en donde se encuentra.\\
Con triple comilla **%%''' ... '''%%** Se escriben comentarios multilínea.
<code python>
''' Ejemplo de comentarios
    definiendo una variable'''
i = 0 # defino la variable i  con valor 0
</code>

===== Variables =====
==== Declaración y tipos ====
Las variables no se tipan:
<code python>
varint = 69                 # tipo int
varfloat = 11.13            # tipo float
varstring = '¡Hola Mundo!'  # tipo string
</code>

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()**
<code python> type(var)</code>


==== Manejo y ámbito de variables ====
Las variables numéricas se pueden incrementar/decrementar:
<code python>
i=0;
i+=1;  # i = i+1
i-=1;  # i = i-1
</code>

Las variables pueden ser eliminadas con la función **del()**
<code python> del(var) # var es eliminada</code>

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.

==== Conversión de tipos ====
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()**
===== Funciones básicas de lectura/escritura de datos =====
Estas funciones son **input()** y **print()**.

==== 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.

<code python>
print("¡Hola mundo!")
edad = 30
print ('Tengo '+ str(edad) + " años")
</code>

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.

==== input() ====
Se utiliza para introducir texto (cadenas de caracteres o //strings//).
<code python>
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
</code>

===== Control de flujo =====
==== Operadores ====
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.

==== Sentencia if() ====
Declaración de if():

<code python>
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")
</code>

==== Sentencia while() ====
Declaración de while():

<code python>
A=0
B=10
while(A!=B):
    A+=1
    print(A)
</code>

Si fuese necesario, se pueden usar las sentencias:
  * **break** Sale del bucle while
  * **continue** Pasa a la primera línea del interior del bucle while


==== Sentencia for() ====
Declaración de for():

<code python>
#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
</code>

También pueeden usarse las sentencias **break** y **continue**.

==== Finalización de programa ====
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()**.

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

===== Funciones =====
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.

<code python>
def elDoble(numero):
    return numero*2
</code>

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

<code python>
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' 
</code>

Como se explicó en el [[python: basico#Manejo y ámbito de variables|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.

===== Manejo de excepciones =====
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.

<code python>
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.
</code>
===== Tipos de datos secuenciales =====
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.
==== Listas ====
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.

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

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

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

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.


=== Trabajar con listas ===
== Slicing ==
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).

== Concatenación y replicación ==
Se pueden usar los operadores **+** y ***** para concatenar y replicar los elementos, respectivamente.

== Funciones con listas ==
  * **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

== Recorrer listas ==
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.
<code python>
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
</code>

Un bucle for también puede devolver 2 valores: índice de elementos y su contenido usando la función **enumerate()**, en lugar de range()
<code python>
for index,item in enumerate(lista)
</code>

== Métodos de las listas ==
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.

== Copia de listas - Referencias ==
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!

<code python>
spam=[0, 1, 2, 3, 4, 5]
cheese = spam
cheese[1] = 'Hello'
print(spam)          # [0,'Hello', 2, 3, 4, 5]
</code>

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**. 

<code python>
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
</code>


==== Tuplas ====
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.

=== Conversión de tupla-lista ===
Para convertir el tipo de dato:
  * Convertir tupla en lista: **list()**
  * Convertir lista en tupla: **tuple()**


==== Diccionarios ====
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 **:**.
<code python>
myCat={'size':'fat', 'color':'grey', 'age':5}
print myCat['size']  # 'fat'
</code>

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.


=== Métodos de diccionarios ===
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:

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

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):

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

También es posible anidar diccionarios:

<code python>
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
</code>
==== Strings ====
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 desde Python 3.6 con **//f-strings//**:

<code python>
name = 'Al'
age =4000
f'Hello, my name is {name}, and I am {years+1}'
</code>

=== Métodos útiles de string ===
== Convertir a mayúsculas/minúsculas ==
  * **upper()** Pasar a mayúsculas.
  * **lower()** Pasar a minúsculas.

== Métodos isx() ==
  * **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.

== Inicio/final de cadena ==
  * **startswith(**...**)** True si empieza con la cadena pasada como argumento.
  * **endswith(**...**)** True si finaliza con la cadena pasada como argumento.

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

== División de strings ==
  * **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.

<code python>
before, sep, after = 'Hello World!'.partition(' ')
# before = 'Hello'
# sep = ' '
# after = 'World!'
</code>

== Justificar texto ==
  * **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.

== Quitar espacios en blanco ==
  * **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.

== Código UNICODE ==
  * **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.
===== Expresiones Regulares y patrones =====
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

=== Claves de caracteres para crear expresiones regulares ===
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.


=== Símbolos para expresiones regulares ===
  * **?** //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.

=== Métodos para trabajar con expresiones regulares ===
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:
  - A partir del patrón especificado anteriormente:\\ patron.sub(string_que_sustituirá, string_donde buscará_coincidencias_para sustituir):<code python>
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" 
</code>
  - 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:<code python>
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'
</code>
===== Validación de datos de entrada =====
Se usa la biblioteca pyinputplus, que no viene con python, por lo que es necesario instalarla.\\

<code python>
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.
</code>

=== Métodos de validación de datos ===
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.

=== Intentos ===
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.