• Documentación extra
• Documentos externos (artículos, tutoriales...)

• Escribir por pantalla: print “Hola”
• Declarar variable: iNum = 4
• Comentarios: #
• Comentarios de más de una línea: “”“ … ”“”
• Pedir por consola: var = raw_input(“Opcion: ”)
• Pedir por consola un integer: var = input(“Opcion: ”)
• Booleanos: True\False …uso… b = True
• Para redondear un float (el segundo parámetro son los dígitos): round(3.232, 1)
• Dar a varias variables varios valores en una sola línea: a, b, c = 1, 2, 3
• Intercambiar el valor de dos variables: a, b = b, a
• var1 'is' var2 devuelve True si la referencia de var1 es la misma que la de var2
• Saber el carácter de un código ASCII: chr(57)
• Saber el código ASCII de un carácter: ord('9')
• Métodos que devuelven el mínimo y el máximo de dos numeros: min y max
• Importar un módulo: import <nombre de módulo>
• Importar varios módulos: import <mod1>, <mod2>…

• Para hacer un for del 0 al 10 podremos hacer:

for i in range(0,10)

• El range(0,10) devuelve los números del 0 al 9 sin incluir el 10.
• Lo que hace al llamar a la función range es devolver una lista con los números del 0 al 10, sin inculir el último.
• Pero el mismo efecto haría si haces: range(10). Sólo con un parámetro.
• Podemos llamar a range con 3 valores, el tercero son los pasos que por defecto es +1, pero si quisiesemos contar en negativo deberíamos hacer: range(0,-10,-1)

	range(0,10,3)
	[0, 3, 6, 9]

• Al partir cadenas y estas cosillas relacionadas con el range, lo que se hace es llamar a un range interno:

	cadena[:]		# toda la cadena
	cadena[:-1]		# toda la cadena menos el último carácter
	cadena[3:]		# toda la cadena a partir del 3er carácter
	cadena[::-1]		# cadena invertida

• Al hacer un range lo que se hace es crear una lista, si esta lista va a ser larga ocuparía espacio en memoria, para usarla temporalmete, como por ejemplo en un for usaremos la funcion xrange:

    for i in xrange(0,10):
        print i

• Los and, ors…: and, or, not, ==, !=, <, >…
• El 'else if' en python es 'elif'
• Existe el break y el while:

b = False
i = 0
while not b:
    print "hello"
    if (i >= 4):
        break
    i = i + 1

• Un foreach sería: for <var temp> in <agrupacion elementos>:

• Definimos la función como: def <nombre> (<parámetros>)

	def suma (a, b):
	    return a + b
	print suma(2,3)
	# 5

• También podemos dar valores por defecto a los parámetros

	def suma (a = 2, b = 4):
	    return a + b

Y llamarla de formas distintas:

	print suma()		# 6
	print suma(4)		# 8
	print suma(b=1)		# 3

• Podemos indicar, en una función, que tendrá un número indefinido de parámetros:

	def testArgLists_1(*args):
	    print args[0]
	    print len(args)
	    print 'args:', args

Que llamandola así: testArgLists_1('aaa', 'bbb'), nos mostrará…

aaa
2
args: ('aaa', 'bbb')

• También podemos usar un diccionario de argumentos:

	def testArgLists_1(**kwargs):
	    print 'kwargs:', args

Que llamandola así:

testArgLists_1(arg1='ccc', arg2='ddd')

Mostraría:

kwargs: {'arg1': 'ccc', 'arg2': 'ddd'}

Ahora podemos tratar kwargs como si fuese un diccionario, es más, lo es!

• Podemos guardar funciones en en variables, por ejemplo imaginemos una función “Hacer()”

	a = Hacer	# Vuelca Hacer sobre a
	a()		# Llama a Hacer

• El valor de una variable que se usa dentro de una función, es tomado del entorno donde se llama a la función:

	def DobleX ():
		return x * 2
	...
	x = 3
	print DobleX() 	# 6

Si no queremos que esto ocurra deberíamos declarar x dentro de la función.

• Definimos una clase como: class <nombre>:
• Siempre, a cada método de la clase, debemos pasar como primer argumento la palabra 'self', que corresponde a sí mismo, algo así como el this de otros lenguajes.
• Las propiedades de la clase son definidas mediante el self dentro de la clase. Esto es, si definimos algo así: self.prop = 4, luego podremos hacer <objeto>.prop, pero si no lo hemos definido esto nos dará error. Es cuando la definimos cuando se crea.
• El método constructor por defecto en una clase sería:

	def __init__ (self)

• Para crear un objeto haríamos: <nombre> = <clase>()
• Ejemplo de definición de una clase:

    class cPrueba:
        def __init__ (self):
            print "constructor"
        def method (self):
            print "metodo"
        def params (self, num):
            print num

• Ejemplo de llamadas:

    c = cPrueba ()	# constructor
    c.method()		# metodo
    c.params(33)		# 33

• Para tener constructores con argumentos estos han de tener un valor por defecto, sino no furrulará:

	class cPrueba:
		def __init__(self, parA = 'Hola'):
	....

• O esto o dentro del constructor asignamos el parámetro en algún sitio:

	class cPrueba:
		def __init__ (self, parA):
			MyPar = parA

• La herencia se hace indicando la clase base entre parentesis:

	class cPrueba2 (cPrueba):
		...

• El orden de llamada a los constructores en las clases que participan en la herencia es el de siempre: primero el de la base y luego el de las heredadas. MENTIRA!!, has de llamarlos tú: nombreBase.__init__(self))
• Para acceder a la clase base de una derivada desde esta, no tenemos que hacer más que <NombreClaseBase>.<NombreMetodo>
• Un método curioso, que haría como el .toString() de Java, sería el __str__. Si en una clase definimos este método, cuando dicha clase se use como string devolverá lo que retorne dicho método:

	class cClase:
		...
		def __str__ (self):
			return "hola"
	...
	obj = cClase()
	print obj		# hola

• Otro método es el de la documentación (__doc__), para redefinir este no tenemos que reescribir nada, únicamente debemos, después del nombre de clase, insertar un string, este será su documentación:

    class cHi:
        "Clase de prueba"
        nombre = ""
 
    x = cHi()
    x.nombre = "Pepe"
    print x.nombre		# Pepe
    print x.__doc__		# Clase de prueba

• Si metes una propiedad dentro de una clase, le das un valor, creas objetos y luego la cambias. Esa propiedad será cambiada para todos los objetos.
• Para poder comparar objetos de un mismo tipo debes definir el método __cmp__, que reciba los parámetros self y otro elemento. Si es mayor debe devolver un int >0, si es menor <0, si son iguales los dos objetos debe devolver un 0.
• Otro método especial es el: __repr__, que se usa para mostrar una representación en string del objeto (p.ej. cuando no se use en un print y sólo se ponga su nombre).
• Existen las siguientes funciones que son llamadas cuando se acceden a los elementos de la clase:

	def __setattr__(self, name, value):
	def __getattr__(self, name):
	def __delattr__(self, name):

Por defecto no podemos operar con dos objetos (sumarlos, restarlos…). Pero si queremos hacerlo únicamente debemos definir ciertas funciones especiales:

__add__		Suma
__sub__		Resta
__mul__		Multiplicación con otro elemento del mismo tipo
__rmul__	Si el operando de la derecha es un tipo primitivo
__div__		División
__neg__		Negación, poniendo signo - delante.

También existen el __radd__, el __rdiv__…)

	def __add__(self, otro):
		return Punto(self.x + otro.x, self.y + otro.y)

La sentencia del es usada para eliminar de memoria una variable o un elemento de una lista:

    hi = ["hola", "adios", "buenos dias"]
    del hi[1]
    print hi	# ["hola", "buenos dias"]
    del hi
    print hi	# nos daría error "hi" ya no existe

Mediante esta función enviandole una variable, se nos indicará el tipo del cual es dicha variable:

    a = "afdsah"
    print type(a)		# type: str

Para comparar tipos deberemos importar el módulo types y comparar…

    import types
    a = "askfdj"
    print type(a) == types.ModuleType	# Falso, no es un módulo
    print type(a) == types.StringType	# Verdadero, a es un string
    print type(types) == types.ModuleType	# Verdadero, types es modulo

También lo podemos hacer con objetos clases pero con el atributo __class__

class Field:
    pass
f = Field ()
print f.__class__ == Field  # True

__mod__		A%B
__pow__		A**B
__and__		A&B
__or__		A|B
__xor__		A^B
__eq__		A==B
__ne__		A!=B
__gt__		A>B
__lt__		A<B
__ge__		A>=B
__le__		A<=B
__lshift__	A<<B
__rshift__	A>>B
__contains__	A in B, A not in B
__pos__		+A
__inv__		~A
__abs__		abs(A)
__len__		len(A)
__getitem__	A[i]		def __getitem__(self, index):
__setitem__	A[i] = v
__delitem__	del A[i]
__getslice__	A[s:e]
__setslice__	A[s:e] = v
__delslice__	del A[s:e]

Una función lambda es una función sencilla de una sola línea. Estas funciones son virtuales y no tienen un nombre con el que llamarlas. Se crean, se ejecutan y desaparecen, pero puedes guardarlas en una variable y llamarlas desde ella.

• Sintaxis: lambda <parametro1, parametro2…> : <línea de código devuelta>

>>> a = lambda x,y : x*y
>>> a(3,4)
12

También podemos llamar a una función lambda sin almacenarla en una variable:

>>> (lambda x: x*2)(3)
6

• Todos los valores pueden usarse como valores booleaos, valores vacíos como [], 0 o None corresponden a False. Si, en cambio, la variable contiene algún valor, su valor booleano será True.
• Si nosotros evaluamos un and o un or, lo que ocurre al pedir:
  • i and b → Si i es verdadero devolverá b, si no devolverá i.
  • i or b → Si i es verdadero devolverá i, si no devolverá b.
    

Ejemplo:

    i = 5
    b = 7
    print i and b		# 7
    print b and i		# 5
    print i or b		# 5
    print b or i		# 7

• O por ejemplo, algo así:

	if a:
		print a
	else:
		print b

Podría sustituirse por:

	print a or b

• Podemos capturar excepciones mediante los bloques try:\except:

    try:
        print a
    except:
        print "a"

• Aunque también podemos capturar excepciones concretas, por ejemplo, la anterior sería una NameError:

    try:
        print a
    except NameError, e:
        print e

• Nosotros podemos lanzar las excepciones que queramos, para ello usaremos el raise: raise NameError
• O podemos hacer nuestras excepciones personalizadas, para ello deben de heredar de la clase RuntimeError:

    class MyError(RuntimeError):
        def __init__(self, msg):
            self.Msg = msg
        def getMsg(self):
            return self.Msg
    try:
        raise MyError('mi mensaje de error')
    except MyError, obj:
        print 'Msg:', obj.getMsg()

Desde una función podemos acceder a una variable global, fuera de dicha función, pero no escribirla. Para ello, poder escribirla, debemos acceder a esa variable desde la función habiendo indicado antes que es la global, así: global <variable>

    NAME = "Manzana"
    def show_global():
        name = NAME
        print '(show_global) nombre: %s' % name
    def set_global():
        global NAME
        NAME = 'Naranja'
        name = NAME
        print '(set_global) nombre: %s' % name
    show_global()
    set_global()
    show_global()

Esto imprimiría:

(show_global) nombre: Manzana
(set_global) nombre: Naranja
(show_global) nombre: Naranja

Pero:

    NAME = "Manzana"
    def show_global():
        name = NAME
        print '(show_global) nombre: %s' % name
    def set_global():
        NAME = 'Naranja'
        name = NAME
        print '(set_global) nombre: %s' % name
    show_global()
    set_global()
    show_global()

Imprimiría:

(show_global) nombre: Manzana
(set_global) nombre: Naranja
(show_global) nombre: Manzana

• En python un namespace se refiere al lugar donde están disponibles variables y objetos, mediante la variable __name__ podemos saber en qué namespace nos encontramos, si es el que se ejecuta será llamado __main__.
• Para comprobar los elementos de un namespace hacemos:
  • dir(math) ← Muestra los elementos del módulo math
  • dir() ← Muestra los elementos del módulo actual

Método main, un archivo de código .py puede ser llamado como módulo o como ejecutable, para controlar si la forma de llamada ha sido por como ejecutable:

if __name__ == "__main__":
	< código inicial >

• Para leer un fichero únicamente tenemos que declarar una variable que reciba el valor que retorna el método open (varString), donde varString es el string correspondiente al fichero.
• Recuerda que cuando hayamos acabado con el fichero, debemos cerrarlo con el método close.
• El siguiente ejemplo lee y muestra todas las líneas de un fichero (c:\prueba.txt) que luego cierra:

    var = open ("c:\\prueba.txt")
    for file in var.readlines():
        print file,
    var.close()

• Fíjate en la coma de “print file,”, hace que no se muestren con retorno de carro después de cada línea, por qué???? Porque la coma se pone para que no haga el salto de línea tras escribir dicha línea

	print "Hola", 
	print " caracola"
	# Hola caracola

• Para escribir debemos llamar a open pasandole, a parte del nombre del fichero, el string “w”, escribiremos mediante el método write.
• El siguiente código copia un archivo (prueba.txt) e otro (prueba2.txt):

    var = open ("c:\\prueba.txt")
    var2 = open ("c:\\prueba2.txt", "w")
    for file in var.readlines():
        var2.write(file)
    var.close()
    var2.close()

• Para añadir datos al final de un fichero existente usaríamos como segundo parámetro, en vez de 'r' o 'w' la letra 'a'.

• Puedes leer un fichero entero mediante el comando: file.read()
• Puedes leer una serie de carácteres con: file.read(varInt), cuando usas este método una especie de cursor se queda donde acabó de leer.

En los módulos os y os.path encontrarás métodos (sus nombres indican lo que hacen) como:

• os.path.
  • isfile
  • isdir
• os.
  • listdir

Y para copiar y mover ficheros:

• shutil.
  • copyfile
  • move
  • copytree

b = a if a != 3 else 0

Es como poner:

	if a != 3:
		b = a
	else:
		b = 0

El módulo __builtin__ es el módulo que se carga inicialmente y por defecto en python. Aún así, si queremos hacer referencia, en concreto a ese haremos:

	import __builtin__
	__builtin__.<xxxx>

• Existen módulos para controlar funciones del sistema operativo como: sys y os. Mira en la sección de documentación.
• El módulo gc es el recolector de basura, puedes activarlo y desactivarlo
• El módulo pickle nos permite guardar variables de tipos de datos “especiales” de python en ficheros.

• Los bloques de código son diferenciados por tabulaciones.
• Es case sensitive.
• Si programamos un script con linux la primera línea ha de ser: #!/usr/bin/python
• En cualquier momento puedes poner: <>.__doc__ y accederás a la documentación de ese método\propiedad:

  print string.split.__doc__

• Todos los métodos sirven para todos los objetos, ej:

	for i in range (0, len(lista)):
	    print "Elemento " + str(i) + ": " + str(lista[i])

• Parece ser que None equivale a NULL.
• Podemos hacer: dir(<paquete>), esto nos devolverá una lista de strings con los métodos contenidos en ese paquete.
• Cuando hagamos un print “algo”, si ponemos una coma al final no hará el salto de línea.
• Python es tan flexible que podemos crear una función dentro de otra y llamarla:

    def Func (a):
        def func (a):
            return a * 3
        return func(a)
    print Func("Aa")

• Para realizar lo que sería una creación temporal de un objeto para llamar a un método es tan sencillo como:

    >>> class A:
        def Func(self):
            print "ahfs"
 
    >>> A().Func()
    ahfs

• Podemos trabajar con números complejos, para ello usamos la 'j' detrás del número: 3j … o … 2 + 4j
• Para recoger los carácteres pulsados del teclado puedes hacerlo como si desde un fichero se tratase, usa el objeto 'stdin' dentro del módulo 'sys' de la siguiente forma:

print sys.stdin.readline()

• Existe una función sumatorio, a la cual le pasas una lista y la suma: sum(range(0,10))
• La función mktmp() del módulo tempfile devuelve una cadena con la dirección de un nombre de fichero que podría usarse como fichero temporal (que no tenga el nombre de otro).
• Puedes escribir strings de más de una línea usando “”“ en vez de “. P.Ej:

	print """ Hola Caracola!!
		Qué haces aquí...
		tan sola????"""

• Podemos hacer que el print, en vez de imprimir por pantalla lo haga por otro canal, para ello, en el módulo sys hay una propiedad que es stdout, por ahí es por donde escribirá el print. Para escribir el print usa un método write pasandole a este un string.
• Si creas una clase con un método write, asignas un objeto de esta a sys.stdout al hacer print se llamará a ese método.

	sys.stdout = PrintRedirect('tmp.log')

• PrintRedirect es una clase que guarda el string pasado por el constructor internamente. Cuando se llama a print también se llama al método write de PrintRedirect (def write(self, msg): …) que escribe en el fichero que se llama como el string.
• Para omitir los \n, \t… en python debemos colocar una 'r' antes del string:

str = r"c:\windows\nvidia"

• Podemos ver el id de un objeto/variable haciendo: id(objeto)
• Para copiar un objeto lo que debemos hacer es usar el método copy del módulo copy:

	import copy
	...
	p2 = copy.copy(p1)

• Recuerda que puedes usar la clausula 'import' dentro de una función (así no la dejas como global si sólo vas a usar unas pocas funciones del módulo).
• Podemos ver las propiedades de una clase haciendo: vars(nombreClase)
• Puedes acceder al nombre de la clase de un objeto haciendo:

obj.__class__

• Puedes dividir una línea de código en varias colocando \ al final:

	>>> print \
		"manolo"
	manolo

• En Windows puedes tener varias versiones de Python instaladas, solo que únicamente una podrá hacer un Register Extensions, es decir, ser la oficial del sistema.
• A Python también se le llama CPython, es la implementación por defecto del lenguaje y está escrita en C, además de este existen otros dos desarrollos importantes, el de Java (Jython) y el de .NET (IronPython).
• Si en windows quieres ejecutar un script en Python sin que se muestre la consola únicamente has de hacerlo ejecutandolo desde pythonw.exe en vez de desde el python.exe. O cambiando su extensión de .py a .pyw.