| impresión() |
Mostrar el resultado de un comando |
x = "Hola mundo"
imprimir (x)
salida: Hola mundo |
| aporte() |
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)
producción: |
| 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")
producción:
Esta es una linea
Esta es una segunda linea |
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") |
| demá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")
demá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)
producción:
1
4
6
8 |
| rotura |
Terminar el flujo de un bucle con una condición determinada |
a = [1, 4, -10, 6, 8]
para b en a:
si b> = 6:
rotura
imprimir (b)
producción:
1
4
-10 |
| aprobar |
Ignore un conjunto de instrucciones previas |
para b en a:
aprobar |
intentar, excepto
|
Pruebe un bloque de código, de lo contrario, genere una excepción definida |
intentar:
imprimir (a)
excepto:
print ("¡Se produjo un error!")
salida: ¡Ocurrió un error! |
| finalmente |
Ejecute un código final cuando fallan los bloques try y except |
intentar:
imprimir (a)
excepto:
imprimir (d)
finalmente:
print ("No puedes imprimir una variable indefinida")
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:
plantear 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")
demá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 |
| Ninguno |
Declarar un valor nulo |
x = Ninguno |
| < |
Compruebe si un valor es menor que otro |
5<10
salida: Verdadero |
| > |
Comprueba 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 |
| "== |
Compruebe 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 ()
producción:
'Hola Mundo' |
| string.lower () |
Convierte todas las cadenas a minúsculas |
a = "Hola mundo"
una baja()
salida: 'hola mundo' |
| string.upper () |
Convierte todas las cadenas a mayúsculas |
a = "Hola mundo"
a.upper ()
salida: 'HOLA MUNDO' |
| string.startswith () |
Compruebe si una cadena comienza con un carácter en particular |
a = "Hola mundo"
comienza con ('a')
salida: Falso |
| string.endswith () |
Compruebe 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!"
demás:
volver "está vacío!" |
| x% y |
Encuentra el resto (módulo) de una división |
9%4
salida: 1 |
| x // y |
Encuentra 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 |
Elevar 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)
producción:
3 [1, 2] |
| por |
Recorre los elementos de una variable |
a = [1, 3, 5]
para b en a:
imprimir (b, "x", "2", "=", b * 2)
producción:
1 x 2 = 2
3 x 2 = 6
5 x 2 = 10 |
| tiempo |
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
producción:
2 es menor que 4
3 es menor que 4
4 es menor que 4 |
| distancia() |
Crea un rango de números enteros positivos entre xey |
x = rango (4)
imprimir (x)
rango (0, 4)
para b en x:
imprimir (b)
producción:
0
1
2
3 |
| 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 tuppletupples 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)
producción:
[1, 2, 3, 4, 6, 2] |
| 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 () |
Saque el valor de una clave y elimínelo 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)
imprimir (a)
salida: {1: 2, 4: 8} |
| list.pop () |
Saque un índice determinado de una lista y elimínelo de una lista |
a = [1, 3, 2, 4, 1, 6, 6, 4]
pop (-2)
salida: 6
imprimir (a)
salida: [1, 3, 2, 4, 1, 6, 4] |
| claro() |
Vaciar los elementos de una lista o un diccionario. |
x = [1, 3, 5]
x.clear ()
imprimir (x)
producción: [] |
| retirar() |
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} |
| retirar() |
Eliminar el primer valor coincidente de un elemento de una lista sin importar 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 trucos 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 |
| mkvirtualenv nombre |
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 open (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() |
