Introduccin a Python

Clase 4
Introduccin a la computacin
Patricia Borensztejn

The Zen of Python

Beautiful is better than ugly.

Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.

Modos de Ejecucin: Modo interactivo

Los lenguajes interpretados permiten este modo de
ejecucin donde le vamos dando rdenes al
interprete y obtenemos una respuesta inmediata a
cada una de esas rdenes.
C:\Users\Patricia>python
Python 2.7.1 (r271:86832, Nov 27 2010, 18:30:46) [MSC v.1500 32 bit (Intel)] on
win32
Type "help", "copyright", "credits" or "license" for more information.
>>> print "hola, patricia"
hola, patricia

Modos de ejecucin: Interactivo

El problema es que si yo quiero repetir muchas
veces la orden, la tengo que volver a escribir.
Asi es que, en lugar de rdenes, podemos definir
funciones dentro del modo interactivo y luego
invocarlas. As:
>>> def hola():
... print "hola, patricia"
...
>>> hola()
hola, patricia
>>> hola()
hola, patricia
>>> hola()
hola, patricia
>>>

Modo de ejecucin: usando mdulos

Un mdulo es un archivo almacenado en disco con
extensin .py.
En windows, lo ejecutamos as:
C:\Users\Patricia\programas_python>python euler1.py
233168
euler1.py
def euler1():
result = 0
for i in range(1,1000):
if i % 3 == 0 or i % 5 == 0 :
result = result + i
print result
euler1()

El archivo contiene la
definicin y la invocacin

Modo de ejecucin: usando mdulos

Tambin podemos invocar funciones que
estn dentro de los mdulos asi:

euler12.py

>>> import euler12

>>> euler12.euler1()
233168
>>>

def euler1():
result = 0
for i in range(1,1000):
if i % 3 == 0 or i % 5 == 0 :
result = result + i
print result

El archivo contiene la
definicin de euler1. La
invocacin se hace desde el
intrprete.

Mas sobre interpretacin

Cuando utilizamos la clusula import por primera vez:
>>> import euler12
>>> euler12.euler1()
233168
>>>

Lo que sucede es que el archivo .py se precompila a un

formato intermedio (no es cdigo mquina) llamado
bytecode. Este archivo tiene extensin .pyc (python
compilado!!!) o .pyo (python optimizado)
Esto hace que las siguientes veces que invocamos las
funciones precompiladas, se interpretan mas rpido.
Por ello, podemos decir que Python es semi-interpretado o
semi-compilado

Bytecode
El cdigo fuente (source code) se compila a
bytecode, que es la representacin interna de un
programa python en el intrprete.
El cdigo en bytecode se guarda en los archivos
.pyc y .pyo para que la segunda vez que se
ejecute ese archivo sea mas rpido porque no
hay que traducir a bytecode.
Este lenguaje intermedio se dice que ejecuta en
una mquina virtual que ejecuta el cdigo
mquina correspondiente a cada bytecode.

Otra curiosidad
El interprete de python es un programa.
Saben en que lenguaje est escrito ese
programa? .
Si, adivinaron. En C.
Hay otras alternativas, incluso que el
interprete est escrito en Python, pero el que
nosotros usamos est escrito en C.

Modulo dis: desensamblador

>>> import dis
>>> dis.dis(hola)
>>> import euler1
233168
>>> dis.dis(euler1)
Disassembly of euler1:
2
0 LOAD_CONST
3 STORE_FAST
3

1 (0)
0 (result)

6 SETUP_LOOP
68 (to 77)
9 LOAD_GLOBAL
0 (range)
12 LOAD_CONST
2 (1)
15 LOAD_CONST
3 (1000)
18 CALL_FUNCTION
2
21 GET_ITER
>> 22 FOR_ITER
51 (to 76)
25 STORE_FAST
1 (i)
28 LOAD_FAST
1 (i)
31 LOAD_CONST
4 (3)
34 BINARY_MODULO
35 LOAD_CONST
1 (0)
38 COMPARE_OP
2 (==)
41 POP_JUMP_IF_TRUE
60

>>>

44 LOAD_FAST
1 (i)
47 LOAD_CONST
5 (5)
50 BINARY_MODULO
51 LOAD_CONST
1 (0)
54 COMPARE_OP
2 (==)
57 POP_JUMP_IF_FALSE
22
>> 60 LOAD_FAST
0 (result)
63 LOAD_FAST
1 (i)
66 BINARY_ADD
67 STORE_FAST
0 (result)
70 JUMP_ABSOLUTE
22
73 JUMP_ABSOLUTE
22
>> 76 POP_BLOCK
>> 77 LOAD_FAST
80 PRINT_ITEM
81 PRINT_NEWLINE
82 LOAD_CONST
85 RETURN_VALUE

0 (result)

0 (None)

Formato de Python
A diferencia de C, Python tiene una manera muy
definida de escribirse
En C, el inicio y el fin de los bloques de cdigo est
marcados por { }. En Python, hay que tabular
El smbolo : indica continuacin de sentencia en el
rengln siguiente
def euler1():
result = 0
for i in range(1,1000):
if i % 3 == 0 or i % 5 == 0 :
result = result + i
print result

def euler1():
result = 0
for i in range(1,1000):
if i % 3 == 0 or i % 5 == 0 :
result = result + i
print result

Formatos, para comparar.

C es un lenguaje de formato libre, de nosotros
depende que los programas sean legibles.
Python nos obliga a hacer legibles nuestros
programas
int main()
{int suma,i;suma=0;for(i=3;i<1000;i++){if((i%3==0)||(i%5==0)) suma=suma+i; }
printf("El resultado es %d\n",suma);return 0;}

def euler1():
result = 0
for i in range(1,1000):
if i % 3 == 0 or i % 5 == 0 :
result = result + i
print result

Variables y Tipos de Datos

No hay que declarar las variables ni su tipo.
Sin embargo, antes de usar una variables es necesario inicializarla
Al inicializar una variable que no exista, Python deduce su tipo y
guarda espacio en memoria para almacenar su valor.
int main()
{
int suma,i;
suma=0;
for(i=3;i<1000;i++)
{
if((i%3==0)||(i%5==0)) suma=suma+i;
}
printf("El resultado es %d\n",suma);
return 0;
}

def euler1():
result = 0
for i in range(1,1000):
if i % 3 == 0 or i % 5 == 0 :
result = result + i
print "El resultado es "
print result

Tipos Bsicos en Python

Nmeros:
3 (entero)
15.57 (de coma
flotante)
7 + 5j (complejos)

Cadenas de texto:
Hola Mundo

Valores booleanos:
True (cierto) y
False (falso).

>>> a=3
>>> type(a)
<type 'int'>
>>> b="hola"
>>> type (b)
<type 'str'>
>>>c=True
>>>type(c)
<type bool'>

Tipos Bsicos:Enteros
Hay dos tipos de enteros:
int: corresponde al long de C y se representa al
menos con 32 bits, aunque podra ser an mas
grande (64 bits) dependiendo de la plataforma.
(en C sucede lo mismo)
Long: El tipo long de Python permite almacenar
nmeros de cualquier precisin, estando limitados
solo por la memoria disponible en la mquina.

Por defecto, Python utiliza int

Reales o Punto Flotante

Los nmeros reales se representan
utilizando el tipo float, que se implementa
como el double de C, es decir con 64 bits,
dando una precisin y un rango de:
2,2250738585072020 x 10-308 hasta
1,797693134862315710308
La representacin de los nmeros reales
est normalizada, (IEEE 754). Se representa
mediante una mantisa y un exponente.
La cantidad de bits dedicados a codificar el
exponente determinan el rango de la
representacin , y los dedicados a codificar
la mantisa, la precisin de la
representacin
Ojo: no poner comas! Eso significa otra
cosa en Python!!

>>> a=2.3
>>> type (a)
<type 'float>
>>> a=0.1e-3
>>> print a
0.0001
>>>

>>> 2,3
(2, 3)
>>> print 2,3
23
>>> print 1,000,000
100
>>>

Complejos
Python es uno de los pocos lenguajes que
soportan el tipo de datos numrico: complex
Se almacena en memoria como dos floats,
uno para la parte real y otro para la parte
imaginaria.
>>> c=2.1+3.4j
>>> type (c)
<type 'complex'>
>>>

Bases
Podemos escribir los nmeros en Python en
cualquiera de estas bases : decimal,
hexadecimal, binaria, octal.
>>> a=0x234
>>> print a
564
>>> a=0b10101010
>>> print a
170

Operaciones

El resultado de operar con nmeros de

distinto tipo es del tipo mas complejo

Orden de evaluacin
Escribimos: 3+4-5*4+5*2
Esto es equivalente a escribir: 3+4-(5*4)+(5*2)
Y no a esto: (3+4-5)*(4+5)*2

Asociatividad:
2**3**2= 2**(3**2)=29

Asociatividad:
2*4/6= (2/4)*6

Tipo Booleano
Solo tiene dos valores: True y False
Es el tipo de salida de las expresiones de
condicin:

Operadores booleanos

Asignaciones en Python
Asignacin Simple
<var> = <expr>
miVar = oldValue * foo + skip

Asignacin Simultnea
<var1>, <var2>, ... = <expr1>, <expr2>, ...
a,b = b,a

Assigning Input
input(<prompt>)
myVar = input("Enter a number: ")
x,y = input("Enter the coordinates (x,y): ")

Ejemplo con asignacin mltiple:

Fibonacci
# fibonacci.py
# This program computes the nth Fibonacci number
def fibo():
n = input("Enter value of n ")
cur,prev = 1,1
for i in range(n-2):
cur,prev = prev+cur,cur
print "The nth Fibonacci number is", cur
fibo()

asignaciones mltiples

Trabajando con enteros positivos:

Euler 2
Each new term in the Fibonacci sequence is generated by adding
the previous two terms. By starting with 1 and 2, the first 10
terms will be:
1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...
By considering the terms in the Fibonacci sequence whose values
do not exceed four million, find the sum of the even-valued
terms.

Trabajando con enteros positivos:

Euler 3
The prime factors of 13195 are 5, 7, 13 and 29.

What is the largest prime factor of the number 600851475143 ?

A modo de ayuda:
Fibonacci en los dos lenguajes
//fibonacci.c
//This program computes the nth Fibonacci
//number
#include <stdio.h>
int fibo()
{
int i, term, cur=1,prev=1;
int n;
printf("Enter value of n :");
scanf("%d", &n);
for(i=0;i<n-2;i++)
{
term=prev+cur;
prev=cur;
cur=term;
}
printf("El resultado es %d\n",cur);
return 0;
}
int main()
{
return (fibo());
}

# fibonacci.py
# This program computes the nth Fibonacci
number

def fibo():
n = input("Enter value of n ")
cur,prev = 1,1
for i in range(n-2):
cur,prev = prev+cur,cur
print "The nth Fibonacci number is", cur
fibo()