Curso de Python : Clase 1

Temas:

  • Visión de Python
  • Python como lenguaje de Scripting
  • Instalación de Python
  • El shell interactivo
  • Sintaxis Básica
  • Strings
  • Debugging

Un poco de Historia

  • Python fue creado a finales de los años 80 por un programador holandés llamado Guido van Rossum, quien sigue siendo aún hoy el líder del desarrollo del lenguaje.

  • El nombre del lenguaje proviene de los humoristas británicos Monty Python.

"I chose Python as a working title for the project, being in a slightly irreverent mood (and a big fan of Monty Python's Flying Circus)."

Filosofía : Zen de Python

In [1]:
import this

The Zen of Python, by Tim Peters

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.
Namespaces are one honking great idea -- let's do more of those!

Principales caracteristicas del Lenguaje

  • Propósito general
  • Alto nivel
  • Multiparadigma
  • Multiplataforma
  • Tipado dinámico
  • Fuertemente tipado
  • Interpretado

Python 2.x vs Python 3.x

  • La versión 2.0, lanzada en 2000, fue un paso muy importante para el lenguaje ya que era mucho más madura, incluyendo un recolector de basura. La versión 2.2, lanzada en diciembre de 2001, fue también un hito importante ya que mejoró la orientación a objetos. La última versión de esta línea es la 2.7 que fue lanzada en noviembre de 2010 y aún está vigente.
  • En diciembre de 2008 se lanzó la rama 3.0, cuya versión actual es la 3.6, de diciembre de 2016. Python 3 fue diseñado para corregir algunos defectos de diseño en el lenguaje, y muchos de los cambios introducidos son incompatibles con las versiones anteriores.
  • Por esta razón, las ramas 2.x y 3.x coexisten con distintos grados de adopción.

Implementaciones

  • CPython
  • Jython
  • IronPython
  • PyPy

Fuente: https://wiki.python.org/moin/PythonImplementations

Instalación Python - Path

Ingresar y descargar en https://www.python.org/

En Windows debemos agregar el Path de Python para poder ejecutarlo en otras carpetas, seteando la variable de entorno

C:\>set PATH=%PATH%;C:\Python27 C:\>set PYTHONPATH=%PYTHONPATH%;C:\Python27

Propiedades del sistema->Configuraciones avanzadas->Variables de entorno:

  • Crear PYTHONPATH: "C:\Python27"
  • Agregar en PATH: "C:\Python27"

Python Shell

Correr scripts

  • Extensión: .py

Cuando ejecutamos el comando python en la terminal

$ python
Python 2.7.13 (v2.7.13:a06454b1afa1, Dec 17 2016, 12:39:47) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for
more information.
>>>

El intérprete nos muersta los símbolos >>> llamados prompt y nos indica que está listo para que escribamos a continuación una sentencia que será evaluada.

Python permite utilizar las operaciones +, -, *, ! y ** (suma, resta, multiplicación, división y potenciación). La sintaxis es la convencional (valores intercalados con operaciones), y se puede usar paréntesis para modificar el orden de asociación natural de las operaciones (potenciación, producto/división, suma/resta).

>>> 2+3
5
>>> 5*7
35
>>> 2+3*7
23
>>> (2+3)*7
35
>>> 10/4
2
>>> 5**2
25
>>>max(1,6,2,3,6)
>>>6

Funciones

  • Las funciones son fragmentos de código asociado a un nombre
  • Realizan una serie de tareas y devuelven un valor
  • Se definen con la palabra clave def
  • Luego se encuentra el nombre de la función
  • Y entre paréntesis los argumentos separados por comas
  • La identación es OBLIGATORIA

Ejemplo:

def hola_mundo():
    return "Hola mundo!"

Keywords

Son palarbas reservadas por Python. No podemos usarlas para nombres de variables, funciones ni ningún otro identificador.

In [3]:
import keyword
print keyword.kwlist

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

Primer Script : Hola mundo!

Creamos el archivo miModulo.py y escribimos:

In [5]:
#!/usr/bin/env python

def hola_mundo():
    print "Hola mundo!"
    
hola_mundo()

Hola mundo!

Se puede correr de dos maneras:

  • Correr "Python shell" y luego desde el intérprete el siguiente código
import miModulo
miModulo.hola_mundo()
  • O bien desde la consola
python miModulo.py

¿Y si no queremos saludar al Mundo?

In [6]:
def hola(alguien):
    print "Hola " + alguien + "!"
    
hola("Mati")

Hola Mati!

¿Cómo sabemos que hace una función?

Aunque el nombre debe ser claro como para darnos una idea de lo que hace una función, aveces no alcanza. Por lo que es recomendable siempre docuemntar las funciónes. Tanto como para ayudarlo al otro que la lee o a el nosotros del futuro.

  • La documentación de una función se coloca luego del encabezado de la función, en un párrafo encerrado entre """
In [7]:
def hola(persona1, persona2):
     
    """ Imprime por pantalla un saludo, dirigido a las personas que se indican por parámetro."""

    print("Hola " + persona1 + " y " + persona2)
    
hola("Miguel", "Mati")

Hola Miguel y Mati

Cuando una función definida está correctamente documentada, es posible acceder a su documentación mediante la función help provista por Python

In [8]:
help(hola)

Help on function hola in module __main__:

hola(persona1, persona2)
    Imprime por pantalla un saludo, dirigido a las personas que se indican por parámetro.

Devolviendo resultados

Luego de realizar dichas tareas necesitamos que las funciones devuelvan el resultado a quién llamó la función

  • Las funciones devuelven datos con la sentencia return.
  • Una función que no devuelve nada, devuelve None (es el Null de Python)
In [9]:
x = hola_mundo()
print x

Hola mundo!
None

Tipos Básicos

Se dividen en:

  • Números: Pueden ser enteros (ejemplo, 3), flotantes (ejemplo, 3.14) o complejos (ejemplo, 1 + 2i).
  • Strings (Cadenas de Texto): "Hola mundo!"
  • Valores booleanos: True o False

Podemos comprobar el tipo con la función type() de Python

In [10]:
n_entero = 5 #Esto es un entero (int)
type(n_entero)
Out[10]:
int
In [11]:
n_flotante = 3.14 #Esto es un numero de coma flotante (float)
type(n_flotante)
Out[11]:
float
In [12]:
n_complejo = 1 + 2j #Esto es un numero complejo
type(n_complejo)
Out[12]:
complex
In [13]:
cadena = "Miguel" #Esto es una cadena
type(cadena)
Out[13]:
str

Números

  • int

    • Es un long de C
    • El rango depende de la plataforma

  • float

    • Es un double de C
    • Sigue el estándar IEEE 754.
Operador Descripción Ejemplo
+ suma r = 3 + 2 # r es 5
- resta r = 4 - 7 # r es -3
- negación r = -7 # r es -7
* producto r = 2 * 6 # r es 12
** exponenciación r = 2 ** 6 # r es 64
/ división (Python 3) r = 3 / 2 # r es 1.5
/ división entera (Python 2) r = 3 / 2 # r es 1
// división entera r = 3.5 // 2 # r es 1.0
% modulo r = 7 % 2 # r es 1

Cadenas

Por ahora sólo diremos que las cadenas no son más que texto encerrado entre comillas simples (‘cadena’) o dobles (“cadena”).

cadena1 = "cadena"
cadena2 = 'cadena'

Booleanos

Operador Descripción Ejemplo
and ¿se cumple a y b? r = True and False # r es False
or ¿se cumple a o b? r = True or False # r es True
not No a r = not True # r es False
Expresión Significado
a == b a es igual a b
a != b a es distinto de b 
a<b a es menor que b
a <= b a es menor o igual que b 
a>b a es mayor que b
a >= b a es mayor o igual que b

Condicionales (if...elif...else)

if <condición_1>:
    <hacer algo_1 si se da la condición_1>
elif <condición_2>:
    <hacer algo_2 si se da la condición_2>
...
elif <condición_n>:
    <hacer algo_n si se da la condición_n>
else:
    <hacer otra cosa si no dan las anteriores>
In [14]:
def positivo_o_no(x):
    if x > 0:
        print("Numero positivo")
    elif x == 0:
        print("Igual a 0")
    else:
        print("Numero negativo")

positivo_o_no(10)
positivo_o_no(-10)
positivo_o_no(0)

Numero positivo
Numero negativo
Igual a 0

Ejercicio 1.1

  • Dado un año indicar si es bisiesto.
  • Nota: un año es bisiesto si es un número divisible por 4 y no por 100, o si es divisible por 400.

Solución 1.1

In [15]:
def es_bisiesto(anio):
        """ Devuelve True si el año es bisiesto, False en caso contrario. """
        if (anio % 4 == 0 and anio % 100 != 0) or (anio % 400 == 0):
                return True
        return False
In [16]:
def es_bisiesto(anio):
        """ Devuelve True si el año es bisiesto, False en caso contrario. """
        return (anio % 4 == 0 and anio % 100 != 0) or (anio % 400 == 0)
In [17]:
def es_bisiesto(anio):
        """ Devuelve True si el año es bisiesto, False en caso contrario. """
        return (not anio % 4 and anio % 100) or (not anio % 400)

Interacción con el usuario

Ya vimos que la función print nos permite mostrar información al usuario del programa. En algunos casos también necesitaremos que el usuario ingrese datos al programa.

La necesitaremos, por ejemplo, si queremos escribir en Python un programa que pida al usuario que escriba su nombre, y luego lo salude. Para esto usaremos la funcion raw_input

In [18]:
#hola.py

def hola(nombre):
    return "Hola " + nombre + "!"

def saludar():
    nombre = raw_input("Por favor ingrese su nombre: ")
    saludo = hola(nombre)
    print(saludo)

saludar()

Por favor ingrese su nombre: Miguel
Hola Miguel!

Ciclo definido

for <variable> in <secuencia de valores>:
    <cuerpo>

Por ejemplo: Supongamos que queremos calcular la suma de los primeros 5 números cuadrados.

In [19]:
def imprimir_cuadrados1():
    suma = 0
    suma = suma + 1*1
    suma = suma + 2*2
    suma = suma + 3*3
    suma = suma + 4*4
    suma = suma + 5*5
    return suma

imprimir_cuadrados1()
Out[19]:
55
In [22]:
def imprimir(n):
    acum = 0
    for x in range(n + 1):
        acum += x*x
    return acum

imprimir(5)
Out[22]:
55

Ejercicio 1.2

  • Dado un número n, decir si ese número es primo.

Solución 1.2

In [23]:
def es_primo(n):
        """ Dado un número n, devuelve True si es primo, False si no"""
        for i in range(2,n):
                if n % i == 0:
                    return False
        return True
    
es_primo(83)
Out[23]:
True

Ejercicio 1.3

  • Escribir un programa que reciba un número n por parámetro e imprima los primeros n números triangulares, junto con su índice. Los números triangulares se obtienen mediante la suma de los números naturales desde 1 hasta n.

Solución 1.3

In [24]:
def triangulares(n):
        for i in range(1, n + 1):
                acum = 0
                for j in range(1, i + 1): 
                        acum += j
                print(i, " - ", acum)
                
triangulares(5)

(1, ' - ', 1)
(2, ' - ', 3)
(3, ' - ', 6)
(4, ' - ', 10)
(5, ' - ', 15)

Ciclo indefinido

while <condición>:
    <hacer algo>
  • Cuenta con:
    • break
    • continue
In [26]:
#Correrlo en terminal texto_while.py

texto = raw_input("Ingrese un texto(hasta 140 caracteres):")
while len(texto) > 140 :
    texto = raw_input("Ingrese un texto(hasta 140 caracteres):")

Ingrese un texto(hasta 140 caracteres):texto

Ejercicio 1.4

  • Escribir un programa que reciba una a una las notas del usuario, preguntando a cada paso si desea ingresar más notas (-1 para salir). Finalmente debe imprimir el promedio correspondiente.

Solución 1.4

In [27]:
#ej14.py

def promedio():
        acumulador = 0
        cantidadNotas = 0
        nota = int(raw_input("Ingrese una nota (-1 para salir):"))
        while nota != -1:
                acumulador += nota
                cantidadNotas += 1
                nota = int(raw_input("Ingrese una nota (-1 para salir):"))
        return float(acumulador) / cantidadNotas

promedio()

Ingrese una nota (-1 para salir):2
Ingrese una nota (-1 para salir):3
Ingrese una nota (-1 para salir):-1
Out[27]:
2.5

Ejercicio 1.5

Utilizando la función randrange del módulo random, escribir un programa que obtenga un número aleatorio secreto, y luego permita al usuario ingresar números y le indique sin son menores o mayores que el número a adivinar, hasta que el usuario ingrese el número correcto.

randrange(1,10) Devuelve un numero entre [1,10)

In [28]:
import random #Importa el modulo, si queremos ejecutar una funcion -> modulo.funcion()
from random import randrange #Importa solo la función randrange del modulo random
from random import * #Importa todas las funciones definidas en el modulo random

help(randrange)
randrange(1,40) 

Help on method randrange in module random:

randrange(self, start, stop=None, step=1, _int=<type 'int'>, _maxwidth=9007199254740992L) method of random.Random instance
    Choose a random item from range(start, stop[, step]).
    
    This fixes the problem with randint() which includes the
    endpoint; in Python this is usually not what you want.
Out[28]:
13

Solución 1.5

In [29]:
# ej15.py
import random

def adivinador():
        n = random.randrange(10)
        ingresado = int(raw_input("Ingrese un número:"))
        while ingresado != n:
                if ingresado < n:
                        ingresado = int(raw_input("El número ingresado es menor. " +
                                               "Ingrese un número:"))
                else:
                        ingresado = int(raw_input("El número ingresado es mayor. " +
                                             "Ingrese un número:"))    
        print "Correcto! El numero es ", n
        
adivinador()

Ingrese un número:2
Correcto! El numero es  2

Parámetros

In [ ]:
#parametros1.py

import sys
for arg in sys.argv:
    print arg

Ejercicio 1.6

  • Ejercicio de años bisiesto con parámetros

Solución 1.6

In [ ]:
#ej1.6.py
import sys

def es_bisiesto(anio):
    """ Devuelve True si el anio es bisiesto, False en caso contrario. """
    return (anio % 4 == 0 and anio % 100 != 0) or (anio % 400 == 0)
    
print(es_bisiesto(int(sys.argv[1])))

Ejercicios extra

  • Escribir una función que reciba dos números como parámetros, y devuelva cuántos múltiplos del primero hay, que sean menores que el segundo. Implementarla utilizando un ciclo for, y uno while
  • Escribir una función que reciba un número natural e imprima todos los números primos que hay hasta ese número.
  • Escribir una función que devuelva la suma de todos los divisores de un número n, sin incluirlo.
  • Usando la función anterior, escribir una función que imprima los primeros m números tales que la suma de sus divisores sea igual a sí mismo (es decir los primeros m números perfectos).

Cadenas

Son texto encerrado entre comillas dobles (“ “) o simples (‘ ‘)

  • Los caracteres especiales se “escapean” con \
  • Anteponiendo u -> Unicode: unicode = u”äóè”
  • r -> raw (No escapea): raw = r”\n”
  • Comillas triples: """ """
In [32]:
triple = """primera línea
              esto se vera en otra línea"""

print triple

primera línea
              esto se vera en otra línea

Operaciones con cadenas

In [33]:
"Un divertido " + "programa " + "de " + "radio"
Out[33]:
'Un divertido programa de radio'
In [34]:
3 * "programas "
Out[34]:
'programas programas programas '
In [35]:
len("programas ")
Out[35]:
10
In [36]:
palabra = "curso python"
for letra in palabra:
    print letra

c
u
r
s
o
 
p
y
t
h
o
n
In [37]:
a = "Verónica"
print a
print a[1]
print a[-2]

Verónica
e
c

Las cadenas son inmutables!

In [38]:
a[1] = 'o'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-38-a1f251c3625e> in <module>()
----> 1 a[1] = 'o'

TypeError: 'str' object does not support item assignment

Ejercicio 1.7

  • Escribir un ciclo que permita mostrar los caracteres de una cadena del final al principio.

Solución 1.7

In [40]:
def alverre(cadena):
    for i in range(len(cadena) - 1, -1, -1):
        print(cadena[i])
        
alverre("hola")

a
l
o
h
In [41]:
def alverre2(cadena):
    for i in range(1, len(cadena) + 1):
        print(cadena[-i])
        
alverre2("chau")

u
a
h
c

Segmentos (slices)

In [44]:
a = "Veronica"
print a[0:2]
print a[-4:-2]
print a[0:80]
print a[:3]
print a[3:]
print a[::2]

a = a[::-1]
print a

Ve
ni
Veronica
Ver
onica
Vrnc
acinoreV

Ejercicio 1.8

Escribir funciones que dada una cadena y un caracter, inserte el caracter entre cada letra de la cadena. Ej: ’separar’ y ’,’ debería devolver ’s,e,p,a,r,a,r’

Solución 1.8

In [48]:
def separar(cadena, separador):
        resultado = ""
        for letra in cadena:
                resultado += letra + separador
        return resultado[:-1]
    
separar("hola",",")
Out[48]:
'h,o,l,a'
In [49]:
def separar(cadena, separador):
        resultado = cadena[0]
        for i in range(1,len(cadena)):
                resultado += separador + cadena[i]
        return resultado
separar("como",",")
Out[49]:
'c,o,m,o'
In [50]:
def separar(cadena, separador):
    return separador.join(cadena)

separar("andas",",")
Out[50]:
'a,n,d,a,s'

Ejercicio 1.9

  • Escribir una función que dado una cadena, indique si se trata de un palíndromo Ej: “neuquen”

Solución 1.9

In [51]:
def es_palindromo(cadena):
        for i in range(len(cadena) / 2 + 1):
                if cadena[i] != cadena[-(i + 1)]:
                    return False
        return True
In [52]:
def es_palindromo(cadena):
        return cadena == cadena[::-1]

Debugging

  • pdb módulo para debugging
  • Ejecutar un script: py -m pdb script.py
  • No hacen falta “breakpoints”
  • Insertar un breakpoint en modo interactivo:
    • break numero_de_linea
    • break nombre_funcion
  • Insertar un breakpoint por código: pdb.set_trace()
  • where (w): imprime el stack trace actual
  • list (l): muestra el código fuente en ejecución
  • step (s): (step into) ejecuta la línea siguiente, entrando en la función
  • next (n): (step over) ejecuta la línea siguiente hasta que se devuelve el control a la función actual
  • continue (c): continúa la ejecución hasta el siguiente breakpoint
  • print (p expresión): imprime la expresión
  • whatis expresión: Imprime el tipo de la expresión
  • quit (q): para salir

Ejemplo: debugging de promedio

Chequear:

  • Si ingreso -1 de una, explota
  • Si le doy s en el input, me pasea por funciones del sistema. Salir con return
  • Insertar un breakpoint con set_trace
  • Insertar un breakpoint con break promedio

Próxima clase

  • Tipos de datos nativos:
    • Listas y tuplas
    • Diccionarios
  • Iteraciones
  • Mutabilidad e inmutabilidad

Referencias

  • Documentación Python 2.7

      https://docs.python.org/2/

  • Zen de python

      http://legacy.python.org/dev/peps/pep-0020/

  • Wikipedia

      https://en.wikipedia.org/wiki/Python

  • Apuntes Teóricos - Algoritmos y Programación I - Cátedra Wachenchauzer - FIUBA

      http://algoritmos7540-rw.tk/