Show Menu
Cheatography

Python3 para principiantes Cheat Sheet by

Operadores Matema­ticos

+ | - | * | %
Suma | resta | multip­lic­acion | resto (modulo)
a / b
Division float(a/b)
a // b
Devision entera int(a/b)
a ** b
Exponente a^b
Además de int y float, soporta otros tipos de números, como Decimal y Fraction. y numeros complejos usando el sufijo `j` o `J`

Giladas especiales

``
[modo intera­ctivo] última expresión impresa es asignada a la variable _
pass
No hace nada, se usa para rellenar algo obliga­torio en futura implem­ent­acion
del a[0]
del a
Elimina el item a[0]
Elimina a

Cadena de caracteres

'cadena'
"cadena"
Cadenas con comiilas simplles o dobles
""" ... cadena multilinea ... "­"­"
Comillas triples para multilinea.
Fin de línea son incluídos
automá­tic­amente, es posible
prevenir esto agregando
una \ al final de la línea.
r"sin \n caracteres especi­ale­s"
r, para raw, cadenas crudas
str_a + str_a
Concat­enacion
2*str_a
Repeticion
str[a:b]
rebanada desde el indice a (incluido) hasta b sin incluir
str[:b]
rebanada parcial hasta b (b excluido)
str[b:]
rebanada parcial desde b (b incluido)
str = 'cadadena negativa'
hola[:-5]
hola[-5:]

'cadadena neg'
'ativa'
texto = ('cadenas en '
'difrentes lineas.')
Multilinea
Las cadenas son inmutables
Las cadenas de texto se pueden indexar (subín­dices), el primer carácter de la cadena tiene el índice 0. No hay un tipo de dato para los caract­eres; un carácter es simple­mente una cadena de longitud uno.

Loops

while condicion:
    ...sentencias...
else:
    ...sentencias...
else opcional, se ejecuta luego
de terminado el bucle
for element in iterable:
    ...sentencias...
else:
    ...sentencias...
else opcional, se ejecuta luego
de terminado el bucle
break
corta el bucle
continue
salta a la siguiente iteracion
El continue y el brack funcionan como en c.
Si el break se ejecuta no se ejecuta el else.
Si necesitás modificar la secuencia sobre la que estás iterando mientras estás adentro del ciclo primero hace una copia.
for p in palabr­as[:]: # hace una copia

Conjuntos

canasta = {'manz­ana', 'naranja', 'manzana', 'pera', 'naranja', 'banana'}
{'pera', 'manzana', 'banana', 'naranja'}
'naranja' in canasta
True
'yerba' in canasta
False
a = set('a­bra­cad­abra')
{a', 'r', 'b', 'c', 'd'}
a - b
Elementos en a pero no en b
a & b
Elementos en a y b
a ^ b
Elementos en a y b pero no en ambos
Tambien soporta a + b, a | b
Es una colección no ordenada y sin elementos repetidos.
Incluyen verifi­cación de perten­encia, elimin­ación de entradas duplic­adas. Soportan operac­iones matemá­ticas como la unión, inters­ección, difere­ncia, y diferencia simétrica.
Las llaves o la función set() pueden usarse para crear conjuntos.
Soportada la compre­nsión de conjuntos.

Diccio­nario

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'jack': 4098, 'guido': 4127}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'jack': 4098, 'irv': 4127, 'guido': 4127}
>>> list(tel.keys())
['irv', 'guido', 'jack']
>>> sorted(tel.keys())
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False

El constructor dict() crea un diccionario directamente desde secuencias de pares clave-valor:
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}
Las tuplas pueden usarse como claves si solamente contienen cadenas, números o tuplas; si una tupla contiene cualquier objeto mutable directa o indire­cta­mente, no puede usarse como clave. No podés usar listas como claves

Formateo de datos

str()
repres­ent­aciones legibles por humanos
repr()
repres­ent­aciones que pueden ser leídas por el el intérprete
repr(x).rjust([n])
str.ljust([n])
str.center([n])
Ajusta
str.z­fill()
Rellena cadena de numeros con 0
str.f­orm­at()
Las llaves y caracteres son reempl­azadas
print­('{1} y {0}'.f­orm­at(­'ca­rne', 'huevo­s'))
Un número en las llaves se refiere a la posición del objeto pasado en el métod
print­('Esta {comida} es {adjet­ivo­}.'.fo­rmat( comida­='c­arne', adjeti­vo=­'es­pan­tos­a'))
Argumentos nombrados en el método, serán referidos usando el nombre del argumento.

Modulos & packeage

import fibo
Importa fibo.py.
No mezcla el espacio de nombres.
fibo.n­om­bre­Met­odo­(args)
llamada a metodo
from fibo import fib, fib2
importa fib y fib2
mezcla el espacio de nombres
__name__
Nombre del modulo
from fibo import *
Importa todaslo que no tengan prefijo _ )
if __name__ == "__main__":
    ...sentencias...
Se ejecuta solo como script y no como import
dir([­no­mbr­eMo­dul­o])
Lista las defini­ciones de un modulo
from paquete import submod­ulo­_es­pec­ifico
n se recomienda a menos que el módulo que estás importando necesite usar submódulos con el mismo nombre desde otros paquetes.
Si en __init­__.py define una lista __all__, se toma como la lista de los nombres de módulos que deberían ser importados cuando se hace from package import *.
Un módulo puede contener declar­aciones ejecut­ables y defini­ciones de funciones. Las declar­aciones son para inicia­lizar el módulo.
Los archivos __init­__.py se necesitan para hacer que Python trate los direct­orios como que contienen paquete
from .. import nombr­emod
Importa relativo

Errores y excepc­iones

class B(Exception):
  pass
class C(B):
  pass
class D(C):
  pass
for cls in [B, C, D]:
  try:
    raise cls()
  except D:
    print("D")
  except C:
    print("C")
  except B as instanciaExepcion:
    print("B")
  else:
    pass
  finally:
    pass
Imprimirá B, C, D, en ese orden.Si las clausulas de except estuvieran invertidas (con except B primero), habría impreso B, B, B.
Una clase en una clausula except es compatible con una excepción si la misma esta en la misma clase o una clase base de la misma
Una clausula except listando una clase derivada no es compatible con una clase base
El último except puede omitir nombrar qué excepción captura, para servir como comodín
Tienen un bloque else opcion­al,­cuando está debe seguir a los except. Se ejecutasi el bloque try no genera una excepción.
Tienen un bloque fin­ally opcion­al,­cuando está se ejecuta siempre a la salida sin importar si se lanzo la excepcion

Ambitos

def prueba_ambitos():
    def hacer_local():
        algo = "algo local"
    def hacer_nonlocal():
        nonlocal algo
        algo = "algo no local"
    def hacer_global():
        global algo
        algo = "algo global"
    algo = "algo de prueba"
    hacer_local()
    print("Luego de la asignación local:", algo)
    hacer_nonlocal()
    print("Luego de la asignación no local:", algo)
    hacer_global()
    print("Luego de la asignación global:", algo)

prueba_ambitos()
print("In global scope:", algo)
Luego de la asignación local: algo de prueba
Luego de la asignación no local: algo no local
Luego de la asignación global: algo no local
En el ámbito global: algo global

Variables

No existen variables privadas de instancia
Por convención un nombre prefijado con un guión bajo debería tratarse como una parte no pública de la API
Cualquier identi­ficador con 2 guiones bajos __algo es textua­lmente reempl­azado por
_nombredeclase__algo
). Se modifica el nombre del identi­ficador sin importar su posición sintác­tica, siempre y cuando ocurra dentro de la definición de una clase.
La modifi­cación de nombres es útil para dejar que las subclases sobree­scriban los métodos sin romper las llamadas a los métodos desde la misma clase.
class Mapeo:
  def __init­__(­self, iterable):
    
self.lista_de_items = []
    self.__actualizar(iterable)
  def actual­iza­r(self, iterable):
    for item in iterable:
      self.lista_de_items.append(item)
  __actualizar = actualizar # copia privada del actual­izar() original class SubClaseMapeo(Mapeo):
  def actual­iza­r(self, keys, values):
      # provee una nueva signatura para actualizar()
      
# pero no rompe __init__()
      
for item in zip(keys, values):
      self.lista_de_items.append(item)

Iteradores / Genera­dores

la sentencia for llama a iter() en el objeto conten­edor. La función devuelve un objeto iterador que define el método __next__() que accede elementos en el contenedor de a uno por vez. Cuando no hay más elementos, __next__() levanta una excepción StopIt­eration que le avisa al bucle del for que hay que terminar.
Para implem­entar un iterador un método __iter__() que devuelva un objeto con un método __next­__(). Si la clase define __next­__(), entonces alcanza con que __iter__() devuelva self:
Se escriben como funciones regulares pero usan la sentencia yield cuando quieren devolver datos. Cada vez que se llama next() sobre él, el generador continúa desde donde dejó (y recuerda todos los valores de datos y cual sentencia fue ejecutada última).
Expres­iones genera­doras: Algunos genera­dores simples pueden ser codifi­cados concis­amente como expres­iones usando una sintaxis similar a las listas por compre­nsión pero con paréntesis en vez de corchetes. Estas expres­iones se utilizan en situac­iones donde el generador es usado inmedi­ata­mente por una función que lo contiene. Las expres­iones genera­doras son más compactas pero menos versátiles que defini­ciones completas de genera­dores, y tienden a utilizar menos memoria que las listas por compre­nsión equiva­lentes.
 

Interprete

python -c comando [arg]
ejecuta las sentencias en comando
python -c "­pri­nt(­2+2­)"
python -m module [arg]
ejecuta el código de module como si se hubiese ingresado su nombre completo en la línea de comandos
# -*- coding: encoding -*-
Espeficica codifi­cacion diferente a UTF8
# -- coding: cp-1252 --
python -i scrip­t.py
Ejecuta el script y entra en modo intera­ctivo

Listas

list.a­ppend (x)
Agrega un ítem al final de la lista
Equivale a a[len(a):] = [x].
list.e­xtend (itera­ble)
Extiende la lista agregá­ndole todos los ítems del iterable. Equivale a a[len(a):] = iterable.
list.i­nsert (i, x)
Inserta un ítem en una posición dada.
list.r­emove (x)
Quita el primer ítem de la lista cuyo valor sea x.
Es un error si no existe tal ítem.
list.pop ([, i])
Quita el ítem en la posición dada y lo devuelve.
Si no se especifica un índice, a.pop() quita y devuelve el último ítem de la lista.
list.c­lear ()
Quita todos los elementos de la lista.
Equiva­lente a del a[:]
list.i­ndex (x[, start[, end]])
Devuelve un índice basado en cero
del primer ítem cuyo valor sea x.
Excepción ValueError si no existe tal ítem
list.c­ount (x)
Devuelve el número de veces que x aparece en la lista.
list.sort (key=None, revers­e=F­alse)
Ordena los ítems de la lista in situ
list.r­everse ()
Invierte los elementos de la lista in situ.
list.copy ()
evuelve una copia superf­icial de la lista. Equiva­lente a a[:]
Tipo de datos mutables.
Pueden ser indexadas y rebanadas.
Pueden contener diferentes tipos (mala practica)
Las rebanada devuelve una copia superf­icial de la lista
Inefic­iente para tratar como FIFO, usar 'from collec­tions import deque'

Funciones comunes

range(end)
range(start,end)
range(start,end,step)
el objeto devuelto por range() se comporta
como si fuera una lista, pero no lo es.
Es un objeto que devuelve los ítems sucesivos
de la secuencia deseada cuando iterás sobre
él, pero realmente no construye la lista,
enume­rat­e(­ite­rab­le)
Agrega un contador al iterable y devuelve un enumerate
rever­sed­(i­ter­able)
Invierte el orden in place
sort(­it­era­ble)
Ordena

Sobre funciones

La palabra reservada def se usa para definir funciones. Debe seguirle el nombre de la función y la lista de parámetros
La primer sentencia del cuerpo de la función puede ser opcion­almente una cadena de texto literal; esta es la cadena de texto de docume­ntación de la función, o docstring.
La ejecución de una función introduce una nueva tabla de símbolos usada para las variables locales de la función (tabla de símbolos loca)
La referencia a variable mira las tablas en orden:
1) Tabla de simbolos local.
2)Tabla de simbolos local de la funcion externa
3) Tabla de simbolos global
4) Nombres predef­inidos

Cadenas de texto de docume­ntación

La primer línea debe ser siempre un resumen corto y conciso del propósito del objeto. No se debe mencionar explíc­ita­mente el nombre o tipo del objeto.
Esta línea debe empezar con una letra mayúscula y terminar con un punto.
Si hay más líneas en la cadena de texto de docume­nta­ción, la segunda línea debe estar en blanco, separando visual­mente
el resumen del resto de la descri­pción. Las líneas siguientes deben ser uno o más párrafos descri­biendo las conven­ciones
para llamar al objeto, efectos secund­arios, etc

Argumento de funciones

def ventadequeso(tipo, *argumentos, **palabrasclaves):
    print("-- ¿Tiene", tipo, "?")
    print("-- Lo siento, nos quedamos sin", tipo)
    for arg in argumentos:
        print(arg)
    print("-" * 40)
    for c in palabrasclaves:
        print(c, ":", palabrasclaves[c])

ventadequeso("Limburger",
    "Es muy liquido, sr.",
    "Realmente es muy muy liquido, sr.",
    cliente="Juan Garau",
    vendedor="Miguel Paez",

-- ¿Tiene Limburger ? -- Lo siento, nos quedamos sin Limburger Es muy liquido, sr. Realmente es muy muy liquido, sr.
---------------------------------------- cliente : Juan Garau vendedor : Miguel Paez puesto : Venta de Queso Argentino
    puesto="Venta de Queso Argentino"

# Otro ejemplo
>>> def loro(tension, estado='rostizado', accion='explotar'):
... print("-- Este loro no va a", accion, end=' ')
... print("si le aplicás", tension, "voltios.", end=' ')
... print("Está", estado, "!")

>>> d = {"tension": "cinco mil", "estado": "demacrado",
... "accion": "VOLAR"}
>>> loro(**d)
-- Este loro no va a VOLAR si le aplicás cinco mil voltios. Está demacrado !
Cuando un parámetro formal de la forma **nombre está presente al final, recibe un diccio­nario conten­iendo todos los argumentos nombrados excepto aquellos corres­pon­dientes a un parámetro formal.
Puede ser combinado con un parámetro formal de la forma *nombre que recibe una tupla conten­iendo los argumentos posici­onales además de la lista de parámetros formales. (nombre debe ocurrir antes de *nombre).

Lista de compre­nsión

[(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
# Es equivalente a:
combs = []
for x in [1,2,3]:
    for y in [3,1,4]:
        if x != y:
            combs.append((x, y))
# Printeo
combs
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
Una lista de compre­nsión consiste de corchetes rodeando una expresión seguida de la declar­ación for y luego cero o más declar­aciones for o if. El resultado será una nueva lista que sale de evaluar la expresión en el contexto de los for o if que le siguen.

Iteracion

caballeros = {'gall­ahad': 'el puro', 'robin': 'el valiente'}
for k, v in caballeros.items():
        print(k, v)
Obtener al mismo tiempo
la clave y su valor
for i, v in enumer­ate­(['ta', 'te', 'ti']):
        pint(i,v)
Obtener al mismo tiempo
indice y valor
preguntas = ['nombre', 'objet­ivo', 'color favorito']
respuestas = ['lanc­elot', 'el santo grial', 'azul']
        print(­'Cual es tu {0}? {1}.'.f­or­mat(p, r))

Sobre condic­iones

Las condic­iones usadas en las instru­cciones while e if pueden contener cualquier operador, no sólo compar­aci­ones.
Los operadores de compar­ación in y not in verifican si un valor está (o no está) en una secuencia.
Los operadores is e is not comparan si dos objetos son realmente el mismo objeto; esto es signif­icativo sólo para objetos mutables como las listas.
Todos los operadores de compar­ación tienen la misma prioridad, la cual es menor que la de todos los operadores numericos
Las compar­aciones pueden encade­narse. Por ejemplo, a < b == c verifica si a es menor que b y además si b es igual a c.
Las compar­aciones pueden combinarse mediante los operadores booleanos and y or, y el resultado de una compar­ación puede negarse con not. Estos tienen priori­dades menores que los operadores de compar­ación; entre ellos not tiene la mayor prioridad y or la menor, o sea que A and not B or C equivale a (A and (not B)) or C.
Operadores booleanos and y or son los llamados operadores cortoc­irc­uito: sus argumentos se evalúan de izquierda a derecha, y la evaluación se detiene en el momento en que se determina su resultado.
Cuando se usa como un valor general y no como un booleano, el valor devuelto de un operador cortoc­ircuito es el último argumento evaluado
non_nulo = cadena1 or cadena2 or cadena3
non_nulo
'Trond­heim'

Tuplas y secuencias

Una tupla consiste de un número de valores separados por comas
t = 12345, 54321, 'hola!'
# t[0]
12345
t (12345, 54321, 'hola!')
Las tuplas son inmuta­bles, perosí se puede crear tuplas que contengan objetos mutables, como las listas.
x, y, z = t desemp­aqueta la tupla

Manejo de archivos

open('archivo', 'modo')
devuelve un objeto archivo
r/w(overwrite)/a
with open('archivo') as f:
  datos_leidos = f.read()
El archivo es cerrado luego de que el bloque termina, incluso si se generó una excepción.
f.read()
f.read(nbytes)
lee todo el archivo o n bytes
f.rea­dli­ne()
Lee una linea (deja \n si existe)
for linea in f:
  print(linea, end='')
Para leer líneas de un archivo, podés iterar sobre el objeto archivo. Esto es eficiente en memoria y rápido
list(f)
f.read­lin­es()
Lee todas las lineas, devuelve una lista
f.wri­te(­str)
escribe en el archivo
f.tell()
devuelve un entero que indica la posición actual en el archivo repres­entada como número de bytes desde el comienzo del archivo en modo binario y un número opaco en modo texto.
f.see­k(d­esp­laz­ami­ento, desde_­donde)
cambiar la posición del objeto archivo.La posición es calculada agregando el despla­zam­iento a un punto de refere­ncia; el punto de referencia se selecciona del argumento desde_­donde. Un valor desde_­donde de 0 mide desde el comienzo del archivo, 1 usa la posición actual del archivo, y 2 usa el fin del archivo como punto de refere­ncia. desde_­donde puede omitirse, el default es 0
Si se agrega b al modo el archivo se abre en modo binario.
Se debería usar este modo para todos los archivos que no contengan texto ya que cuando se lee en modo texto, por defecto se convierten los fines de lineas que son especí­ficos a las plataf­ormas (\n en Unix, \r\n en Windows) a solamente \n ropiendo si es binario el archivo

Clases

Soporta herencia multiple
(dinamico) Se crean en tiempo de ejecución, y pueden modifi­carse luego de la creación.
Los miembros de la clase son publicos (En termin­ologia de c++)
Todas las funciones miembro son virtuales.
No hay atajos para hacer referencia a los miembros del objeto desde sus métodos: la función método se declara con un primer argumento explícito que representa al objeto, el cual se provee implíc­ita­mente por la llamada
Como en Smalltalk, las clases mismas son objetos
Los tipos de datos integrados pueden usarse como clases base para que el usuario los extienda.
Hay sobrecarga de operadores

objetos clases, metodos e instancias

una definición de clase, se crea un nuevo espacio de nombres, el cual se usa como ámbito local. y Cuando una definición de clase se finaliza normal­mente se crea un objeto clase.
soportan dos tipos de operac­iones: hacer referencia a atributos e instan­cia­ción.
__doc__ también es un atributo válido, que devuelve la docume­ntación asociada a la clase
x = MiClase(), crea una nueva instancia de la clase
Los miembros pueden ser de existencia dinamica, la clase es mutable
x.f() es exacta­mente equiva­lente a MiClas­e.f(x)
Los atributos de datos tienen prefer­encia sobre los métodos con el mismo nombre;
El ámbito global asociado a un método es el módulo que contiene su defini­ción. (Una clase nunca se usa como un ámbito global.)
Todo valor es un objeto, y por lo tanto tiene una clase (también llamado su tipo). Ésta se almacena como objeto.__­cla­ss__.
`def __init­__(­self):
 ­ ­sel­f.datos = []`
Cuando se instancia se llama al metodo init de la clase.
usar verbos para los métodos y sustan­tivos para los atributos.

Herencia

class ClaseD­eri­vad­a(C­las­eBa­se):
Las refere­ncias a métodos se resuelven de la siguiente manera:
*se busca el atributo de clase corres­pon­die­nte­,de­sce­ndiendo por la cadena de clases base si es necesario, y la referencia al método es válida si se entrega un objeto función.
un método de la clase base que llame a otro método definido en la misma clase base puede terminar llamando a un método de la clase derivada que lo haya redefi­nido. por que todas los metodos son virtuales
Hay una manera simple de llamar al método de la clase base direct­amente: simple­mente llamás a ClaseB­ase.me­tod­o(self, argume­ntos)
                   
 

Comments

No comments yet. Add yours below!

Add a Comment

Your Comment

Please enter your name.

    Please enter your email address

      Please enter your Comment.

          Related Cheat Sheets

            Python 3 Cheat Sheet by Finxter