La hoja de trucos de Python RegEx para programadores en ciernes
El uso de Python para resolver varios problemas tecnológicos y su fácil curva de aprendizaje lo ha convertido en uno de los lenguajes de programación modernos más populares. A pesar de ser rápido de aprender, sus expresiones regulares pueden ser complicadas, especialmente para los recién llegados.
Aunque Python tiene muchas bibliotecas, es aconsejable que conozca sus sintaxis habituales. Incluso si eres un experto en eso, existe la posibilidad de que de vez en cuando necesites buscar algunos comandos de Python para refrescar tu memoria.
Por esa razón, hemos preparado esta hoja de referencia de expresiones regulares de Python para ayudarlo a comprender mejor sus sintaxis.
DESCARGA GRATUITA: Esta hoja de trucos está disponible como PDF descargable de nuestro socio de distribución, TradePub. Deberá completar un breve formulario para acceder a él solo por primera vez. Descargue la hoja de referencia de Python RegEx para programadores en ciernes .
La hoja de trucos de Python RegEx para programadores en ciernes
| Expresión | Acción | Ejemplos |
|---|---|---|
| impresión() | Mostrar el resultado de un comando | x = "Hola mundo" imprimir (x) salida: Hola mundo |
| entrada() | Recopilar aportaciones de los usuarios | print (input ("¿cuál es tu nombre?")) salida: cual es tu nombre? |
| tipo() | Encuentra el tipo de variable | x = "Expresiones regulares" tipo (x) salida: |
| len () | Encuentra la cantidad de elementos en una variable | len ([1, 2, 3]) salida: 3 |
| Escapar de un carácter que cambia la intención de una línea de código | print ("Quiero que añadas " "") salida: quiero que agregue "" | |
| norte | Romper un carácter de cadena para comenzar en la siguiente línea | print ("Esta es una línea n Esta es una segunda línea") salida: |
| def nombre_función (parámetro): comandos | Iniciar una función con un parámetro opcional | def tuNombre (x): imprimir (x + 1) |
| lambda | Llamar a una función anónima | add_3_to = lambda y: y + 3 imprimir (add_3_to (4)) salida: 7 |
| regreso | Devuelve un resultado de una función | def tuNombre (x): devolver x + 1 |
| clase | Crea un objeto Python | clase myClass: def myFunc (x): |
| def __init__ | Inicializar los atributos de una clase | clase myClass: def __init __ (yo, atributos …) |
| "__init__.py | Guarde un archivo que contenga un módulo para que se lea correctamente en otro archivo de Python | Cambiar el nombre de un archivo que contiene un módulo como: "__init__.py |
| En t() | Convertir una variable en un número entero | int (1.234) salida: 1 |
| str () | Convertir una variable en una cadena | str (1.234) salida: '1.234' |
| flotador() | Convertir una variable en flotante | flotador (23) salida: 23.0 |
| dictar (Contador ()) | Convierta una lista o una tupla en un diccionario después de ordenar con un contador incorporado de Python | desde el contador de importación de colecciones dict (Contador ([1,1,2,1,2,3,3,4])) salida: {1: 3, 2: 2, 3: 2, 4: 1} |
| redondo() | Redondea el resultado de una operación al número entero más cercano | redonda (23.445) salida: 23 |
| round (operación o número, lugares decimales) | Redondea el resultado de una operación a un número específico de decimales | redonda (23,4568, 2) salida: 23,46 |
| Si: | Iniciar una declaración condicional | si 2 <3: print ("Dos es más pequeño") |
| elif: | Hacer una contradeclaración cuando la declaración if es falsa | si 2 <3: print ("Dos es más pequeño") elif 2 == 3: imprimir ("Continuar") |
| más: | Haga una contradeclaración final si otras condiciones son falsas | si 2 <3: print ("Dos es más pequeño") elif 2 == 3: imprimir ("Continuar") más: print ("Tres es mayor") |
| Seguir | Ignore una condición y ejecute el resto del ciclo | a = [1, 4, -10, 6, 8] para b en a: si b <= 0: Seguir imprimir (b) salida: |
| romper | Terminar el flujo de un bucle con una condición determinada | a = [1, 4, -10, 6, 8] para b en a: si b> = 6: romper imprimir (b) salida: |
| pasar | Ignore un conjunto de instrucciones previas | para b en a: pasar |
| intentar, excepto | Pruebe un bloque de código, de lo contrario, genere una excepción definida | tratar: imprimir (a) excepto: salida: ¡Ocurrió un error! |
| finalmente | Ejecute un código final cuando fallan los bloques try y except | tratar: imprimir (a) excepto: salida: no se puede imprimir una variable indefinida |
| elevar Excepción () | Genera una excepción que detiene el comando cuando la ejecución no es posible | a = 7 + 2 si a <10: aumentar la excepción ("¡Oh! No obtuviste una puntuación de 10") |
| importar x | Importar un módulo o biblioteca completo | importar matemáticas |
| desde x importar y | Importar una biblioteca x desde un archivo o una clase y | desde el modo de importación scipy.stats |
| como | Personaliza una expresión con tu nombre preferido | importar pandas como pd |
| en | Verifique si un valor está presente en una variable | x = [1, 4, 6, 7] si 5 en x: print ("Hay un cinco") más: print ("No hay cinco") salida: no hay cinco |
| es | Compruebe si dos variables se refieren a un solo elemento | x = [1, 4, 6, 7] x = b imprimir (x es b) Cierto |
| Ninguna | Declarar un valor nulo | x = Ninguno |
| < | Compruebe si un valor es menor que otro | 5 <10 salida: Verdadero |
| > | Compruebe si un valor es más que otro | 5> 10 salida: Falso |
| <= | Comprueba si un valor es menor o igual a otro | 2 * 2 <= 3 salida: Falso |
| > = | Comprueba si un valor es mayor o igual a otro | 2 * 2> = 3 salida: Verdadero |
| "== | Comprueba si un valor es exactamente igual al otro | 3 == 4 resultado: falso |
| ! = | Comprobar que un valor no es igual al otro | 3! = 4 salida: Verdadero |
| importar re | Importar las expresiones regulares integradas de Python | importar re re.findall ("cadenas", variable) |
| a | b | Compruebe si alguno de los dos elementos está presente en una cadena | importar re someText = "Hola expresión regular" a = re.findall ("regular | Hola", someText) imprimir (a) salida: ['Hola', 'regular'] |
| cadena $ | Compruebe si una variable termina con un conjunto de cadenas | importar re someText = "Hola expresión regular" a = re.findall ("expresión $", someText) salida: ['expresión'] |
| ^ cadena | Compruebe si una variable comienza con un conjunto de cadenas | importar re someText = "Hola expresión regular" a = re.findall ("^ Hola", someText) imprimir (a) salida: ['Hola'] |
| string.index () | Verifique la posición del índice de un carácter de cadena | a = "Hola mundo" a.index ('H') salida: 0 |
| string.capitalize () | Poner en mayúscula el primer carácter de un conjunto de cadenas | a = "Hola mundo" a.capitalizar () salida: 'Hola mundo' |
| string.swapcase () | Imprime la primera letra de cada palabra en minúsculas y las demás en mayúsculas | a = "Hola mundo" a.swapcase () salida: |
| string.lower () | Convierte todas las cadenas a minúsculas | a = "Hola mundo" una baja() salida: 'hola mundo' |
| string.upper () | Convertir todas las cadenas a mayúsculas | a = "Hola mundo" a.upper () salida: 'HOLA MUNDO' |
| string.startswith () | Verifique si una cadena comienza con un carácter en particular | a = "Hola mundo" comienza con ('a') salida: Falso |
| string.endswith () | Verifique si una cadena termina con un carácter en particular | a = "Hola mundo" termina con ('d') salida: Verdadero |
| string.split () | Separe cada palabra en una lista | a = "Hola mundo" Una parte() salida: ['Hola', 'mundo'] |
| cadenas {} '. formato () | Mostrar una salida como cadena | a = 3 + 4 print ("La respuesta es {}". formato (a)) salida: la respuesta es 7 |
| no es ninguno | Comprueba si el valor de una variable no está vacío | def checknull (a): si a no es Ninguno: volver "está lleno!" más: volver "está vacío!" |
| x% y | Encuentra el resto (módulo) de una división | 9% 4 salida: 1 |
| x // y | Halla el cociente de una división | 9 // 4 salida: 2 |
| "= | Asignar un valor a una variable | a = {1: 5, 3: 4} |
| "+ | Suma elementos juntos | ["un dos"] + ["un uno"] salida: ['a dos', 'a uno'] 1 + 3 salida = 4 |
| "- | Encuentra la diferencia entre un conjunto de números | 3-4 salida = -1 |
| "* | Halla el producto de un conjunto de números | 3 * 4 salida: 12 |
| a + = x | Agregue x a la variable a sin asignar su valor a una nueva variable | a = 2 a + = 3 salida: 5 |
| a- = x | Subsract x de la variable a sin asignarla a una nueva variable | a = 3 a- = 2 salida: 1 |
| a * = x | Encuentre el producto de la variable ayx sin asignar el resultado a una nueva variable | a = [1, 3, 4] a * = 2 salida: [1, 3, 4, 1, 3, 4] |
| x ** y | Eleva la base x a potencia y | 2 ** 3 salida: 8 |
| pow (x, y) | Eleva x a la potencia de y | pow (2, 3) salida: 8 |
| abs (x) | Convertir un número entero negativo a su valor absoluto | abs (-5) salida: 5 |
| x ** (1 / enésimo) | Encuentra la raíz n-ésima de un número | 8 ** (1/3) salida: 2 |
| a = b = c = d = x | Asignar el mismo valor a múltiples variables | a = b = c = d = "Hola mundo" |
| x, y = y, x | Intercambiar variables | x = [1, 2] y = 3 x, y = y, x imprimir (x, y) salida: |
| para | Recorre los elementos de una variable | a = [1, 3, 5] para b en a: imprimir (b, "x", "2", "=", b * 2) salida: |
| mientras | Siga recorriendo una variable, en la medida en que una condición particular permanezca verdadera | a = 4 b = 2 mientras b <= a: print (b, "es menor que", a) b + = 1 salida: |
| rango() | Crea un rango de números enteros positivos entre xey | x = rango (4) imprimir (x) rango (0, 4) para b en x: imprimir (b) salida: |
| suma() | Iterar a través de los elementos de una lista | imprimir (suma ([1, 2, 3])) salida: 6 |
| suma (lista, inicio) | Devuelve la suma de una lista con un elemento agregado | imprimir (suma ([1, 2, 3], 3)) salida: 9 |
| [] | Haz una lista de elementos | x = ['a', 3, 5, 'h', [1, 3, 3], {'d': 3}] |
| () | Crea un tupple — los tupples son inmutables | x = (1, 2, 'g', 5) |
| {} | Crea un diccionario | a = {'x': 6, 'y': 8} |
| x [a: b] | Cortar una lista | x = [1, 3, 5, 6] x [0: 2] salida: [1, 3] |
| x [clave] | Obtener el valor de una clave en el diccionario x | a = {'x': 6, 'y': 8} imprimir (a ['x']) salida: 6 |
| x.append () | Agregar una lista de valores a una lista vacía | x = [1] x.append ([1,2,3]) imprimir (x) salida: [1, [1,2,3]] |
| x.extend () | Agregue una lista de valores para continuar una lista existente sin crear necesariamente una lista anidada | x = [1,2] x.extend ([3,4,6,2]) imprimir (x) salida: |
| del (x [a: b]) | Eliminar un elemento por completo de una lista en un índice específico | x = [1,2,3,5] del (x [0: 2]) imprimir (x) salida: [2,3,5] |
| del (x [clave]) | Eliminar una clave y un valor completamente de un diccionario en un índice específico | y = {1: 3, 2: 5, 4: 6, 8: 2} del (y [1], y [8]) imprimir (y) salida = {2: 5, 4: 6} |
| dict.pop () | Extraer el valor de una clave y eliminarlo de un diccionario en un índice específico | a = {1: 3, 2: 4, 5: 6} pop (1) salida: 3 |
| dict.popitem () | Saque el último elemento de un diccionario y elimínelo | a = {1: 2, 4: 8, 3: 5} a.popitem () salida: (3, 5) |
| list.pop () | Sacar un índice determinado de una lista y eliminarlo de una lista | a = [1, 3, 2, 4, 1, 6, 6, 4] pop (-2) salida: 6 |
| claro() | Vaciar los elementos de una lista o diccionario | x = [1, 3, 5] x.clear () imprimir (x) salida: [] |
| eliminar() | Eliminar un elemento de una lista | x = [1, 5, 6, 7] x.remove (1) salida: [5, 6, 7] |
| insertar() | Insertar elementos en una lista | x = [3, 5, 6] x.insertar (1, 4) imprimir (x) salida: [1, 4, 3, 5, 6] |
| ordenar (reverso = condición) | Invertir la dirección de los elementos en una lista | x = [1, 3, 5, 6] x.sort (reverso = verdadero) imprimir (x) salida: [6, 5, 3, 1] |
| actualizar() | Actualice un diccionario cambiando su primer elemento y agregando cualquier otro elemento al final | x = {1: 3, 5: 6} x.update ({1: 4, 8: 7, 4: 4}) imprimir (x) salida: {1: 4, 5: 6, 8: 7, 4: 4} |
| llaves() | Mostrar todas las claves en un diccionario | a = {1: 2, 4: 8} a.keys () salida: dict_keys ([1, 4]) |
| valores() | Mostrar todos los valores en un diccionario | a = {1: 2, 4: 8} a.values () salida: dict_values ([2, 8]) |
| artículos() | Mostrar las claves y los valores en un diccionario. | a = {1: 2, 4: 8} a.items () salida: dict_items ([(1, 2), (4, 8)]) |
| obtener la clave) | Obtener el valor de un elemento en un diccionario por su clave | a = {1: 2, 4: 8, 3: 5} obtener (1) salida: 2 |
| setdefault (clave) | Devuelve el valor original de un elemento a un diccionario | a.setdefault (2) |
| f = {** a, ** b} | Fusionar dos diccionarios | a = {'x': 6, 'y': 8} b = {'c': 5, 'd': 3} f = {** a, ** y} imprimir (f) salida: {'x': 6, 'y': 8, 'c': 5, 'd': 3} |
| eliminar() | Eliminar el primer valor coincidente de un elemento de una lista sin tener en cuenta su índice | a = [1, 3, 2, 4, 4, 1, 6, 6, 4] a.remove (4) imprimir (a) salida: [1, 3, 2, 4, 1, 6, 6, 4] |
| vista de memoria (x) | Acceder a los búferes internos de un objeto | a = vista de memoria (objeto) |
| bytes () | Convertir un protocolo de búfer de memoria en bytes | bytes (a [0: 2]) |
| bytearray () | Devuelve una matriz de bytes | bytearray (objeto) |
| # | Escriba una sola línea de comentario o evite que se ejecute una línea de código | # Hoja de referencia de Python regex |
| "" "" "" | Escribe un comentario de varias líneas | "" "La hoja de referencia de Python regex es buena para principiantes Es igualmente un gran repaso para los expertos "" " |
| Línea de comando | ||
| paquete de instalación pip | Instalar una biblioteca en línea | pip instalar pandas |
| nombre virtualenv | Utilice virtaulenv para crear un entorno virtual | virtualenv myproject |
| nombre mkvirtualenv | Utilice el contenedor de entorno virtual para crear un entorno virtual | mkvirtualenv myproject |
| python file.py | Ejecute los comandos en un archivo de Python | "python my_file.py |
| congelación de pepitas | Enumere todos los paquetes instalados en un entorno virtual | congelación de pepitas |
| congelación de pip> algunos archivos | Copie todas las bibliotecas instaladas en un solo archivo | pip freeze> requirements.txt |
| dónde | Encuentra la ruta de instalación de Python | donde python |
| –versión | Verifique la versión de un paquete | Python –versión |
| .exe | Ejecutar un shell de Python | python.exe |
| con abierto (archivo, 'w') | Escribir en un archivo existente y sobrescribir su contenido existente | con open ('regex.txt', 'w') como wf: wf.write ("¡Hola mundo!") |
| con abierto (archivo, 'r') | Abrir un archivo como de solo lectura | con open ('regex.txt', 'r') como rf: imprimir (rf.read () |
| con open (archivo, 'a') | Escribir en un archivo sin sobrescribir su contenido existente | con open ('regex.txt', 'a') como af: af.write (" n¡Hola, sí!") |
| file.close | Cerrar un archivo si no está en uso | af = abierto ('regex.txt') af.close |
| salida | Salir del shell de Python | salida() |
Sea creativo al usar Python
Aprender las expresiones regulares de Python es un gran paso para convertirse en un mejor programador de Python, pero esa es solo una de las pocas cosas que debe hacer.
Sin embargo, jugar con sus sintaxis y ser creativo con ellas pule tu habilidad de codificación. Entonces, más allá de aprender las sintaxis, úselas en proyectos de la vida real y se convertirá en un mejor programador de Python.