#!/usr/bin/env python

1. # No declaramos variables, ponemos nombres a objetos
2. coches = 100
3. capacidad_coche = 4.0
4. conductores = 30
5. pasajeros = 90
6. coches_no_conducidos = coches - conductores
7. coches_conducidos = conductores
8. capacidad_real = coches_conducidos * capacidad_coche
9. media_pasajeros_coche = pasajeros / coches_conducidos
10.  
11. print "Hay", coches, "coches disponibles."
12. print "Tenemos sólo ", conductores, "conductores disponibles."
13. print "Habrá", coches_no_conducidos, "coches vacíos hoy."
14. print "Podemos transportar", capacidad_real, "personas hoy."
15. print "Tenemos", pasajeros, "pasajeros para transportar."
16. print "Tenemos que poner una media de", media_pasajeros_coche, "por coche hoy."

>>> num = '2.3'
>>> float(num)
2.3
>>> int('2')
2
>>> long('2')
2L

# viejo estilo 
>>> "%s %s" %('hello', 'world')
'hello world'
 
# Nuevo estilo. PEP 3101
>>> "{0} {1}".format('hello', 'world')
'hello world'

1. nombre = raw_input('Introduzca su nombre: ')
2. edad = raw_input('Introduzca la edad: ')
3. edad = int(edad)

1. edad = int(raw_input('Introduce tu edad: '))
2. if edad < 18:
3.     print 'Menor de edad'
4. else:
5.     print 'Mayor de edad'

animals = ["cat", "dog", "bird"]
for index in range(len(animals)):
    print index, animals[index]

for animal in animals:
    print animal
# o si hace falta enumerar
for n, animal in enumerate(animals):
    print n, animal

1. for x in range(10):
2.     print 'Hola'

1. while temperatura > 24:
2.     ventilador_encendido

1. def al_cubo(num):
2.     return num ** 3

def eleva(num, exp=2):
    return num ** exp

def ficha_empleado(nombre, nif, edad):
    ...
ficha_empleado(nombre='Manuel', nif='123454P', edad=35)

>>> def test_argumentos_variables(farg, *args):
	print 'arg. formal', farg
	for arg in args:
		print 'otro arg.', arg
 
>>> test_argumentos_variables('hola', 1, 'dos', 3)
arg. formal hola
otro arg. 1
otro arg. dos
otro arg. 3

>>> def test_argumentos_variables(farg, **kwargs):
	print 'arg. formal', farg
	for k in kwargs:
	    print 'otro arg con clave: %s: %s' % (k, kwargs[k])
 
 
>>> test_argumentos_variables('hola', buenos="dias", temperatura=28)
arg. formal hola
otro arg con clave: temperatura: 28
otro arg con clave: buenos: dias

def test_var_args_call(arg1, arg2, arg3):
    print "arg1:", arg1
    print "arg2:", arg2
    print "arg3:", arg3
args = ("two", 3)
 
test_var_args_call(1, *args)
'''
Resultado:
 
arg1: 1
arg2: two
arg3: 3
'''

def test_var_args_call(arg1, arg2, arg3):
    print "arg1:", arg1
    print "arg2:", arg2
    print "arg3:", arg3
kwargs = {"arg3": 3, "arg2": "two"}
 
test_var_args_call(1, **kwargs)
'''
Resultado:
 
arg1: 1
arg2: two
arg3: 3
'''

1. notas = [8, 7, 4.5, 6]
2. notas.append(9)
3. media = sum(notas)/len(notas)
4. print media # 6.9

>>> letras = {}
>>> for l in 'supercalifragilisticoespialidoso':
...     letras[l] = letras.get('l', 0) + 1
... 
>>> letras
{'a': 3, 'c': 3, 'e': 3, 'd': 4, 'g': 2, 'f': 2, 'i': 4, 'l': 3, 'o': 4, 'p': 3, 's': 4, 'r': 2, 'u': 1, 't': 3}
>>> letras.keys()
>>> letras.values()
>>> letras.items()

# viejo estilo
fin = open("foo.txt")
for linea in fin:
    # manipular linea
fin.close()
 
# mejor
with open('foo.txt') as fin:
    for linea in fin:
        # manipular linea

try:
    f = open("file.txt")
except IOError, e:
    # tratar excepción

try:
    # código con riesgo
except Exception, e:
    # captura excepción
else:
    # si no ha saltado ninguna excepción
finally:
    # ejecuta al final

import math
from math import sin
import longname as ln
 
math.sqrt(9)
sin(30)
ln(2)

print (123).__class__
print zip.__class__
print list.__class__
import os ; print os.__class__

class Estudiante(object):
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad
maria = Estudiante('María', 19)
print maria.nombre

class Estudiante(object):
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad
    def saluda(self):
        return 'Hola, me llamo %s' % self.nombre
 
maria = Estudiante('María', 19)
print maria.saluda()

maria.edad += 1

class Base (object):
    def method(self):
	print "base.method()"
 
class Deriv (Base):
    def method ( self ):
        print "deriv.method()"
     def other (self):
        print "deriv.other()" # método añadido

class Persona(object):
    def __init__(self, nombre):
        self.nombre = nombre
 
class Estudiante(Persona):
    def __init__(self, nombre, curso):
        super(Estudiante, self).__init__(nombre)
        self.curso = curso

  __init__(self, ...)
  __new__(cls, args)
  __del__(self)
  __str__(self)
  __cmp__(self, otro)
  __len__(self)
  __getitem__(self, key)
  __setitem__(self, key, valor)
  ...

class Estudiante(object):
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad
    def saluda(self):
        return 'Hola, me llamo %s' % self.nombre
    def __str__(self):
        return self.nombre
    def __repr__(self):
        return self.nombre
    def __cmp__(self, per):
        '''p es otro objeto de tipo persona'''
        return cmp(self.nombre, per.nombre)
 
if __name__ == '__main__':
    maria = Estudiante('María', 19)
    luis = Estudiante('Luis', 21)
    ana = Estudiante('Ana', 23)
    estudiantes = [maria, luis, ana]
    print sorted(estudiantes)

class Objeto(object):
   contador = 0   # contador es un atributo estático
   def __init__(self, valor):
      self.valor = valor
      Objeto.contador += 1
   @staticmethod
   def total():
      return Objeto.contador
 
uno = Objeto('Primero')
dos = Objeto('Segundo')
tres = Objeto('Tercero')
 
print 'Hemos creado', Objeto.total(), 'objetos.'
print 'Soy el objeto', dos.valor, 'de', dos.total(), 'objetos.'

class Objeto(object):
    @classmethod
    def metodo_de_clase(cls):
        print "Invocado desde la clase %s " % cls
class ObjetoHijo(Objeto):
    pass

>>> Objeto.metodo_de_clase()
Invocado desde la clase <class '__main__.Objeto'> 
>>> ObjetoHijo.metodo_de_clase()
Invocado desde la clase <class '__main__.ObjetoHijo'> 
>>> o = Objeto()
>>> o.metodo_de_clase()
Invocado desde la clase <class '__main__.Objeto'> 
>>> h = ObjetoHijo()
>>> h.metodo_de_clase()
Invocado desde la clase <class '__main__.ObjetoHijo'>