====== Python ======
  * [[script:python:xtra|Documentación extra]]
  * [[script:python:docs|Documentos externos (artículos, tutoriales...)]]

===== Básico =====


==== Range ====
  * Para hacer un for del 0 al 10 podremos hacer: 
<code python>for i in range(0,10)</code>
  * 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)
<code python>
	range(0,10,3)
	[0, 3, 6, 9]
</code>
  * Al partir cadenas y estas cosillas relacionadas con el range, lo que se hace es llamar a un range interno:
<code python>
	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
</code>
  * 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:
<code python>
    for i in xrange(0,10):
        print i
</code>
==== Condicionales y bucles ====
  * Los and, ors...: and, or, not, ==, !=, <, >...
  * El 'else if' en python es 'elif'
  * Existe el break y el while:
<code python>
b = False
i = 0
while not b:
    print "hello"
    if (i >= 4):
        break
    i = i + 1
</code>
  * Un foreach sería: ''for <var temp> in <agrupacion elementos>:''



===== Orientado a objetos =====
==== Clases ====

  * Para tener constructores con argumentos estos han de tener un valor por defecto, sino no furrulará:
<code python>
	class cPrueba:
		def __init__(self, parA = 'Hola'):
	....
</code>
  * O esto o dentro del constructor asignamos el parámetro en algún sitio:
<code python>
	class cPrueba:
		def __init__ (self, parA):
			MyPar = parA
</code>
  * La herencia se hace indicando la clase base entre parentesis:
<code python>
	class cPrueba2 (cPrueba):
		...
</code>
  * <del>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.</del> MENTIRA!!, has de llamarlos tú: <nowiki>nombreBase.__init__(self))</nowiki>
  * Para acceder a la clase base de una derivada desde esta, no tenemos que hacer más que <NombreClaseBase>.<NombreMetodo>


=== Notas de clases ===
  * 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 ''<nowiki>__cmp__</nowiki>'', 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: ''<nowiki>__repr__</nowiki>'', 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:
<code python>
	def __setattr__(self, name, value):
	def __getattr__(self, name):
	def __delattr__(self, name):
</code>



===== Funciones del lenguaje =====



==== Función type ====
Mediante esta función enviandole una variable, se nos indicará el tipo del cual es dicha variable:
<code python>
    a = "afdsah"
    print type(a)		# type: str
</code>
Para comparar tipos deberemos importar el módulo types y comparar...
<code python>
    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
</code>
También lo podemos hacer con objetos clases pero con el atributo ''<nowiki>__class__</nowiki>''
<code python>
class Field:
    pass
f = Field ()
print f.__class__ == Field  # True
</code>







===== Python avanzado =====
==== Valores booleanos ====
  * 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:
<code python>
    i = 5
    b = 7
    print i and b		# 7
    print b and i		# 5
    print i or b		# 5
    print b or i		# 7
</code>
  * O por ejemplo, algo así:
<code python>
	if a:
		print a
	else:
		print b
</code>
Podría sustituirse por:
<code python>
	print a or b
</code>



==== Variables globales ====
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>''
<code python>
    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()
</code>
Esto imprimiría:
<code>
(show_global) nombre: Manzana
(set_global) nombre: Naranja
(show_global) nombre: Naranja
</code>
Pero:
<code python>
    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()
</code>
Imprimiría:
<code>
(show_global) nombre: Manzana
(set_global) nombre: Naranja
(show_global) nombre: Manzana
</code>
==== Namespaces ====
  * En python un namespace se refiere al lugar donde están disponibles variables y objetos, mediante la variable <nowiki>__name__</nowiki> podemos saber en qué namespace nos encontramos, si es el que se ejecuta será llamado ''<nowiki>__main__</nowiki>''.
  * 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
=== Notas ===
**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:
<code python>
if __name__ == "__main__":
	< código inicial >
</code>






==== Módulo por defecto ====
El módulo ''<nowiki>__builtin__</nowiki>'' 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:
<code python> 
	import __builtin__
	__builtin__.<xxxx>
</code>

==== Otros módulos ====
  * Existen módulos para controlar funciones del sistema operativo como: **sys** y **os**. Mira en la sección de [[script:python:docs#documentacion|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.







===== Notas =====
  * En cualquier momento puedes poner: ''<nowiki><>.__doc__</nowiki>'' y accederás a la documentación de ese método\propiedad: <code python>print string.split.__doc__</code>
  * Parece ser que ''None'' equivale a ''NULL''.
  * Python es tan flexible que podemos crear una función dentro de otra y llamarla:
<code python>
    def Func (a):
        def func (a):
            return a * 3
        return func(a)
    print Func("Aa")
</code>
  * 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:
<code python>print sys.stdin.readline()</code>
  * 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).
  * 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.
<code python>
	sys.stdout = PrintRedirect('tmp.log')
</code>
  * ''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 copiar un objeto lo que debemos hacer es usar el método copy del módulo copy:
<code python>
	import copy
	...
	p2 = copy.copy(p1)
</code>
  * 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:
<code python>obj.__class__</code>
  * 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 ([[fw:ironpython:ironpython|IronPython]]).