PDF de programación - Docs Python 101

Docs Python 101

Introduction
Python
Django

Table of Contents

0
1
2

2

Docs Python 101

Introduction

3

Docs Python 101

Python

Python es un lenguaje de programación interpretado cuya filosofía hace hincapié en una
sintaxis que favorezca un código legible.

Es fuertemente tipado porque no se permiten violaciones de los tipos de datos, es decir, una
variable de un tipo concreto, no se puede usar como si fuera de otro tipo distinto a menos
que se haga una conversión explícita.

Es dinámicamente tipado pues una misma variable puede tomar valores de distinto tipo en
distintos momentos.

Palabras reservadas

import from as
print
if elif else
for while break continue
pass
try exec finally raise assert
class def return
and or not in is
lambda del with exec global yield

Comentarios

Todo lo que sigue al signo # hasta el final de la línea, es un comentario.

# esto es un comentario

Declaracion e inicialización de Variables

Las variables no tienen tipo, así que no hay que declararlas. Aparecen cuando se les asigna
un valor y este puede ser cambiado en cualquier momento. La asignación se realiza
mediante el operador = . Para comprobar la igualdad se utiliza el operador == . Se puede
asignar varias variables a la vez:

Python

4

Docs Python 101

z = 0
x,y = 1,2

Tipos de datos fundamentales

Enteros

foo = 23
# enteros largos, con una `L` al final
bar = 23L
#octal, anteponiendo un `0`
027 == 23
#hexadecimal, anteponiendo `0x`
0×17 == 23

Reales

baz = 2.0

# para representar fracciones de alta precisión, se utiliza un módulo incluido
# en la bilioteca estándard

Cadenas

foo = 'usando comillas simples puedo tener "dobles" dentro'
bar = "usando comillas dobles puedo tener 'simples' dentro"
baz = 'me gusta complicarme la vida para usar una \' comilla dentro'
qux = "me gusta complicarme la vida para usar una \" comilla doble dentro"
quux = '\t comienzo con un tabulador'
corge = '\n comienzo con un cambio de línea'
grault = u'utilizo codificación Unicode pues me antedece una `u`'
garply = r'\n no comienzo con cambio de línea pues me antecede una `r`'
waldo = '''puedo estar en varias líneas si se usan tres comillas, simples o
dobles'''

Booleanos

Python

5

Docs Python 101

foo = True
bar = False

# en contexto booleano
baz = 0 # soy `False`
qux = 1 # si soy distinto de `0` soy True
quux = '' # soy `False`
corge = 'si no soy una cadena vacía, soy `True`'

Listas

Una lista es un conjunto ordenado de elementos encerrados entre corchetes, tienen como
primer índice 0 de izquierda a derecha y -1 en sentido contrario.

foo = ['a', 'b', 'mpilgrim', 'z', 'example']
foo[0] == 'a'
foo[1] == 'b'
foo[-1] == 'example'
foo[-2] == 'z'

len(foo) == 5

'mpilgrim' in foo == True

Se puede obtener una porción de la lista muy facilmente, en inglés se denomina slicing .

foo[1:3] == ['b', 'mpilgrim']
foo[1:-1] == ['b', 'mpilgrim', 'z']
foo[0:3] == foo[:3]
foo == foo[:] # contienen los mismo elementos, pero `foo[:]` es una copia

Adicionalmente a los índices inicio y fin, se puede especificar uno más que es el paso . Si
el paso es negativo, el orden de los índices se invierte.

foo[0:3:2] == ['a', 'mpilgrim']
foo[4:0:-2] == ['example', 'mpilgrim']
foo[::-1] == ['example', 'z', 'mpilgrim', 'b', 'a'] # nueva copia con orden invertido

Modificación de las listas

Python

6

Docs Python 101

foo.append(1) == None
foo == ['a', 'b', 'mpilgrim', 'z', 'example', 1]

foo.count('a') == 1

foo.extend([2,3]) == None
foo == ['a', 'b', 'mpilgrim', 'z', 'example', 1, 2, 3]

foo.reverse() == None
foo == [3, 2, 1, 'example', 'z', 'mpilgrim', 'b', 'a']

foo.remove('example') == None
foo = [3, 2, 1, 'z', 'mpilgrim', 'b', 'a']

foo.pop(0) == 3
foo == [2, 1, 'z', 'mpilgrim', 'b', 'a']
foo.pop() == 'a'

foo.append([8,9]) == None
foo == [2, 1, 'z', 'mpilgrim', 'b', [8, 9]]

Tuplas

Las tuplas son listas inmutables, no pueden ser cambiadas una vez creadas. Son más
rápidas que las listas. Pueden ser claves de diccionarios.

foo = ('a', 'b', 'mpilgrim', 'z', 'example')
bar = list(foo)
bar = ['a', 'b', 'mpilgrim', 'z', 'example']
baz = tuple(bar)
foo == baz

qux = (1,) # la coma al final es imprescindible para definir una tupa de 1 elemento

Diccionarios

Definen relaciones uno a uno entre claves y valores.

Python

7

Docs Python 101

foo = {'server':'localhost', 'database':'master'}

# puede construirse también con `dict` pero el anterior es más rápido
foo == dict(server='localhost', database='master')

foo.keys() == ['database', 'server']
foo.values() = ['master', 'localhost']
foo.items() = [('database', 'master'), ('server', 'localhost')]

foo['database'] == 'master'
foo['value'] # KeyError Exception

foo.has_key('database') == True
foo.get('database') == 'master'
foo.get('value') == None
foo.get('value', 'default') == 'default'

'database' in foo == True
'value' in foo == False
'localhost' in foo.values() == True

Las claves tienen que ser objetos inmutables, e.j. no pueden ser listas, pero si tuplas. Son
estructuras donde el acceso es muy rápido, O(1). Sin embargo cuando son muy grandes y
se necesita recorrerlos, es recomendable utilizar las variantes de los métodos que
devuelven iteradores: foo.iterkeys foo.itervalues y foo.iteritems .

Las claves se ordenan según su hash , en la práctica significa que no se puede asumir una
relación de orden según el valor ni el orden en que entraron.

Operadores aritméticos

Python

8

Docs Python 101

# Se puede omitir la parte entera del número si es `0`
0.2 == .2

# suma
1 + 2 == 3
1.0 + 2 == 3.0

# resta
1 - 2 == -1
1 - .3 == 0.7

# multiplicación
55 * 2 == 110

# potencia
4 ** 3 == 64

# resto de la división
6 % 2 == 0

# división
5 / 2 == 2
5.0 / 2 == 2.5

# división_entera
5 // 2 == 2
5 // 2.0 == 2.0

Operadores booleanos

# `and`
2 and 1 == 1
1 and 2 == 2

# `or`
2 or 1 == 2

# `not`
not 1 == False
not '' == True

Sentencias de control de flujo (condicionales)

Permiten al programador especificar que la siguiente sentencia a ser ejecutada puede ser
otra diferente que la siguiente en secuencia.

Python

9

Docs Python 101

if z == 0:
x,y = y,x
elif z < 0:
x += 1
else:
y -= 1

Los bloques elif y else pueden omitirse.

Sentencias de control de flujo (iterativas)

El uso de la sentencia while no es muy común.

while True:
if some_condition:
break
do_something()

flag = True
while flag:
if some_condition:
flag = False
do_something()

Es mucho más común encontrar la iteración utilizando la sentencia for .

foo = ['a', 'b', 'e']
for s in foo:
do_something_with(s)

bar = {'server':'localhost', 'database':'master'}
for k, v in bar.items():
do_something_with(k,v)

for k, v in bar.iteritems():
do_something_with(k,v)

baz = {
"title": (3,33),
"artist": (33,63),
}
for key, (start,end) in baz.items():
do_something_with(k,start,end)

Declaración de funciones

Python

10

Docs Python 101

Para declarar una función se utiliza la palabra reservada def , seguidamente el nombre de
la función, luego entre paréntisis los parámetros y por último :

def a_function_name(param1):
return param1 + 1

print a_function_name(1)

Si no se utiliza return para expresamente retornar un valor, la función retorna None .

Si no deseamos que la función haga nada, podemo usar pass para rellenar el cuerpo de la
función. En general pass se utiliza para rellenar cualquier bloque.

def no_op(param):
pass

callback = a_function_name
if some_condition:
callback = no_op

Las funciones puede definir parámetros opcionales, los cuales no son necesario pasarlos
pues poseen un valor por omisión. Luego de un parámetro opcional, todos los demás tienen
que serlo.

def power(number, exponent=2):
return number ** exponent

power(4,3) == 64
power(number=2, exponent=3) == 8
power(exponent=3, number=2) == 8
power(4) == 16

Cuando en la invocación de una función, se utiliza el nombre del parámetro, se dice que fue
pasado por nombre y cuando no, fue pasado por posición . Este mecanismo es muy
potente pues permite definir muy facilmente funciones que aceptan cualquier combinación
de parámetros. Los que fueron pasados por valos se capturan utilizando * y los pasados
por nombres con el ** .

Python

11

Docs Python 101

def foo(*args, **kwargs):
for arg in args: # args its a `list`
do_something_with(arg)
for k,v in kwargs.items(): # kwargs its a `dict`
do_another_thing_with(k,v)

foo(1,2,3)
foo(named_param=1,another_named_param=2)
foo(1,2,3,named_param=1,another_named_param=2)
foo(named_param=1,another_named_param=2,1,2,3) # SyntaxError: non-keyword arg
# after keyword arg

Definición de clases y creación de objetos

Una clase comienza por la palabra reservada class , seguida por el nombre y entre
paréntisis el nombre de la clase ancestra si es que heredara de alguna otra.

class ClassA:
pass

class ClassB(ClassA):
pass

class ClassC(object):
pass

No es común implementar el constructor de la clase, sino el inicializador, en el momento
que el se ejecuta, ya el objeto está creado y se posee una referencia válida al mismo.

En la declaración de todos los métodos de instancia, hay al menos uno, que es
precisamente la referencia al objeto y en la invocación al método, se omite. Por convención
este parámetro se llama self .

class ClassC(object):
def __init__(self):
self.attr = 0
def increment(self):
self.attr += 1
return self.attr

c = ClassC()
print c.increment()

Python

12

Docs Python 101

La sobrecarga de métodos en muy natural y elegante, debido a la utilización de parámetros
opcionales. Este ejemplo no es muy ilustrativo, pero sería natural implementar cierta lógica
tanto en el __init__ como en increment para diferenciar casos en dependencia del valor
del parámetro.

class ClassD(object):
def __init__(self, initial=0):
self.attr = initial
def in