PDF de programación - Tema 2: Introducción a Python

latex te

Tema 2: Introducción a Python

Carmen Graciani Díaz
José Luis Ruiz Reina

Departamento de Ciencias de la Computación e Inteligencia Artificial

Universidad de Sevilla

Inteligencia Artificial, 2018-19

Introducción a PYTHON

• Creado a principios de los 90 por Guido van Rossum
• El nombre procede del programa de la BBC “Monty

Python’s Flying Circus”

• Todas las distribuciones son de código abierto
• Es un “poderoso” lenguaje de programación “fácil” de

aprender

• Cuenta con una amplia biblioteca estándar
• Web oficial de Python: http://www.python.org
• Lenguaje interpretado de alto nivel que puede extenderse

con C o C++

• Programación orientada a objetos
• Programación imperativa
• Programación funcional

Trabajar con PYTHON

• Modo interactivo

• Arrancar un intérprete: python3
• Escribir una expresión en el intérprete
• Evaluar la expresión

• Creación de guiones

• Escribir el código en un fichero.py
• Añadir al inicio #!/usr/bin/python3
• Darle permiso de ejecución

Interacción

• Intérprete
$ python3
Python 3.6.5 |Anaconda, Inc.| (default, Apr 29 2018, 16:14:56)
[GCC 7.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print(’¡Hola! y ¡Adiós!’)
¡Hola! y ¡Adiós!
>>> exit()
$

Entornos de programación

• Entorno de programación:

• Editar programas
• Interactuar con el intérprete
• Desarrollo de proyectos
• Depuración

• Algunos de los más conocidos:

• Idle
• Spyder
• IPython+Jupyter
• Pydev
• PyCharm
• Emacs+Python-mode

Guiones

• Guión (script):

#!/usr/bin/python3
# Escribe por pantalla el mensaje: ¡Hola! y ¡Adiós!
print(’¡Hola! y ¡Adiós!’)

• Ejecución:

$ ./ejemplo.py
¡Hola! y ¡Adiós!
$

• Comentarios en Python: # y triples comillas

Tipos de datos numéricos

• Números (son inmutables)

>>> 2+2
4
>>> (50-5*6)/4
5.0
>>> a = (1+2j)/(1+1j)
>>> a.real
1.5
>>> ancho = 20
>>> alto = 5*9
>>> area = ancho * alto
>>> area
900
>>> area *= 2
>>> area
1800

• Mutable vs inmutable. Asignaciones aumentadas
• Las variables en Python siempre son referencias a objetos

Booleanos

• Dos datos booleanos: True y False
• Operadores lógicos and, or, not y comparación con ==

>>> 2 == 2
True
>>> 2 == 3
False
>>> True and 2 == 3
False
>>> False or 2 == 2
True
>>> not False
True
>>> True == 1
True
>>> False == 0
True

Cadenas

• Secuencia de caracteres, entre comillas simples o dobles

(inmutables)

• Algunas operaciones con cadenas:

>>> c1="Buenas"
>>> c2=" tardes"
>>> frase = c1+c2
>>> frase
’Buenas tardes’
>>> frase[3:8]
’nas t’
>>> frase[3:8:2]
’nst’
>>> frase[-1]
’s’
>>> frase[3:8:-1]
’’
>>> frase[3:8]
’nas t’
>>> frase[8:3:-1]
’at sa’
>>> frase[::-1]
’sedrat saneuB’
>>> frase * 4
’Buenas tardesBuenas tardesBuenas tardesBuenas tardes’

Cadenas

• Algunos métodos sobre cadenas

>>> cad="En un lugar de La Mancha"
>>> cad.index("Mancha")
18
>>> cad.index("plancha")
Traceback (most recent call last):

File "<stdin>", line 1, in <module>

ValueError: substring not found
>>> cad.find("Mancha")
18
>>> cad.find("plancha")
-1
>>> cad.upper()
’EN UN LUGAR DE LA MANCHA’
>>> cad.count("u")
2

Cadenas

• Más operaciones con cadenas:

>>> " ".join(["Rojo", "blanco", "negro"])
’Rojo blanco negro’
>>> " y ".join(["Rojo", "blanco", "negro"])
’Rojo y blanco y negro’
>>> "Rojo blanco negro".split(" ")
[’Rojo’, ’blanco’, ’negro’]
>>> "Rojo y blanco y negro".split(" ")
[’Rojo’, ’y’, ’blanco’, ’y’, ’negro’]
>>> "Rojo y blanco y negro".split(" y ")
[’Rojo’, ’blanco’, ’negro’]

Cadenas

• Escritura por pantalla (print y format)

>>> print("Inteligencia","Artificial")
Inteligencia Artificial
>>> c="{0} por {1} es {2}"
>>> x,y,u,z = 2,3,4,5
>>> print(c.format(x,y,x*y))
2 por 3 es 6
>>> print(c.format(u,z,u*z))
4 por 5 es 20

Tuplas

• Secuencias ordenadas de elementos, separados por

comas y usualmente entre paréntesis
>>> 1,2,3,4
(1, 2, 3, 4)
>>> ()
()
>>> 1,
(1,)
>>> a=2
>>> b=3
>>> (a,b,a+b,a-b,a*b,a/b)
(2, 3, 5, -1, 6, 0.6666666666666666)

Tuplas

• Se le pueden aplicar operaciones similares a las de

cadenas
>>> a=("Uno","Dos","Tres","Cuatro")
>>> a[2]
’Tres’
>>> a[1:3]
(’Dos’, ’Tres’)
>>> a[::]
(’Uno’, ’Dos’, ’Tres’, ’Cuatro’)
>>> a[::-1]
(’Cuatro’, ’Tres’, ’Dos’, ’Uno’)
>>> a+a[2::-1]
(’Uno’,’Dos’,’Tres’,’Cuatro’,’Tres’,’Dos’,’Uno’)
>>> "Dos" in a
True

Tuplas

• Inmutables:

>>> a=("Madrid","Paris","Roma","Berlin","Londres")
>>> b=a
>>> b
(’Madrid’, ’Paris’, ’Roma’, ’Berlin’, ’Londres’)
>>> a[3]="Atenas"
Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: ’tuple’ object does not support assignment
>>> a+="Atenas",
>>> a
(’Madrid’,’Paris’,’Roma’,’Berlin’,’Londres’,’Atenas’)
>>> b
(’Madrid’, ’Paris’, ’Roma’, ’Berlin’, ’Londres’)

Tuplas

• Tuplas en lado izquierdo de asignaciones:

>>> a,b,c=(1,2,3)
>>> a
1
>>> b
2
>>> c
3
>>> a,b=b,a # ¡¡intercambio en una sola instrucción!!
>>> a
2
>>> b
1

• Desempaquetado
>>> a,*b =(1,2,3,4)
>>> a
1
>>> b
[2, 3, 4]
>>> *a,b = [1,2,3,4]
>>> a
[1, 2, 3]
>>> b
4

Listas

• Secuencias ordenadas de elementos, separados por

comas y entre corchetes
>>> ["a","b","c","d"]
[’a’, ’b’, ’c’, ’d’]
>>> [2]
[2]
>>> []
[]

• Operaciones similares a las de tuplas y cadenas
>>> bocadillo = [’pan’, ’jamon’, ’pan’]
>>> 2*bocadillo[:2] + [’huevo’] + [bocadillo[-1]]
[’pan’, ’jamon’, ’pan’, ’jamon’, ’huevo’, ’pan’]
>>> triple = 2*bocadillo + ["tomate",’pan’]
>>> triple
[’pan’, ’jamon’, ’pan’, ’pan’, ’jamon’, ’pan’,

’tomate’, ’pan’]

>>> "tomate" in triple
True
>>> len(triple)
8

Listas

• Las listas son mutables:

>>> l=["hola","adios","hasta pronto"]
>>> m=l
>>> m
[’hola’,’adios’,’hasta pronto’]
>>> l[2]="see you"
>>> l
[’hola’,’adios’,’see you’]
>>> m
[’hola’,’adios’,’see you’]
>>> p=[l,m]
>>> p
[[’hola’,’adios’,’see you’],[’hola’,’adios’,’see you’]]
>>> m[0]="hello"
>>> p
[[’hello’,’adios’,’see you’], [’hello’,’adios’,’see you’]]
>>> p[0][1:2]=[]
>>> p
[[’hello’, ’see you’], [’hello’, ’see you’]]
>>> l
[’hello’, ’see you’]
>>> m
[’hello’, ’see you’]

Listas

• Algunos métodos sobre listas

>>> r=["a",1,"b",2,"c","3"]
>>> r.append("d")
>>> r
[’a’, 1, ’b’, 2, ’c’, ’3’, ’d’]
>>> r.extend([4,"e"])
>>> r
[’a’, 1, ’b’, 2, ’c’, ’3’, ’d’, 4, ’e’]
>>> r.pop()
’e’
>>> r
[’a’, 1, ’b’, 2, ’c’, ’3’, ’d’, 4]
>>> r.pop(0)
’a’
>>> r
[1, ’b’, 2, ’c’, ’3’, ’d’, 4]
>>> r.insert(3,"x")
>>> r
[1, ’b’, 2, ’x’, ’c’, ’3’, ’d’, 4]

Definiciones por comprensión

• Las listas se pueden definir sin necesidad de explicitar sus

elementos
>>> [a for a in range(6)]
[0, 1, 2, 3, 4, 5]
>>> [a for a in range(6) if a % 2==0]
[0, 2, 4]
>>> [a*a for a in range(6) if a % 2==0]
[0, 4, 16]
>>> [(x,y) for x in [1,2,3] for y in ["a","b","c"]]
[(1, ’a’),(1, ’b’),(1, ’c’),(2, ’a’),(2, ’b’),(2, ’c’),

(3, ’a’),(3, ’b’),(3, ’c’)]
>>> (a*a for a in range(6) if a % 2==0)
<generator object <genexpr> at 0x7fbb85aa8a00>

• Aplicable también a otros tipos datos de colección:

>>> tuple(a*a for a in range(6) if a % 2==0)
(0, 4, 16)
>>> tuple(a%3 for a in range(9))
(0, 1, 2, 0, 1, 2, 0, 1, 2)
>>> {a%3 for a in range(9)} #tipo conjunto,lo vemos a continuación
{0, 1, 2}

Conjuntos

• Colecciones de datos, sin orden y sin duplicados,
representados entre llaves y separados por comas

• Los elementos de los conjuntos deben ser hashables
• En particular todos los tipos de datos inmutables son

hashables

• Los conjuntos son mutables
• Ejemplos:

>>> cesta = {"peras", "manzanas", "peras", "manzanas"}
>>> cesta
{’peras’, ’manzanas’}
>>> "melocotones" in cesta
False
>>> a = {x for x in "abracadabra" if x not in "abc"}
>>> a
{’r’, ’d’}

Conjuntos

• Algunos métodos sobre conjuntos

>>> s={1,3,5,7,9}
>>> s.add(10)
>>> s
{1, 3, 5, 7, 9, 10}
>>> s.add(10)
>>> s
{1, 3, 5, 7, 9, 10}
>>> s | {1,2,4}
{1, 2, 3, 4, 5, 7, 9, 10}
>>> s
{1, 3, 5, 7, 9, 10}
>>> s & {4,7,15}
{7}
>>> s
{1, 3, 5, 7, 9, 10}
>>> s <= {1,3,5,7,9,10,11,12}
True
>>> s |= {2,4}
>>> s
{1, 2, 3, 4, 5, 7, 9, 10}

Diccionarios

• Colección no ordenada de pares clave:valor (es un tipo de

dato mutable)
>>> tel = {"juan": 4098, "ana": 4139}
>>> tel["ana"]
4139
>>> "ana" in tel
True
>>> tel["pedro"]=4118
>>> tel
{’juan’: 4098, ’pedro’: 4118, ’ana’: 4139}
>>> tel.keys()
dict_keys([’juan’, ’pedro’, ’ana’])
>>> del tel[’ana’]
>>> [(n,t) for (n,t) in tel.items()]
[(’juan’, 4098), (’pedro’, 4118)]
>>> tel["olga"]
Traceback (most recent call last):

File "<stdin>", line 1, in <module>

KeyError: ’olga’
>>> None == tel.get("olga")
True

Estructuras de control (instrucción if)

• Programa signo.py:

x = int(input(’Escribe un entero: ’))

if x < 0:

print(’Negativo:’, x)

elif x == 0:

print(’Cero’)

else:

print(’{0} es positivo:’.format(x))

• El papel de la indentación en Python
• Ejecución:

Escribe un entero:34
34 es positivo

Estructuras de control (instrucción for)

• Programa media.py:

l, suma, n = [1,5,8,12,3,7], 0, 0
for e in l:

suma += e
n +=1

print(suma/n)

• Programa primos.py:

primos = []
for n in range(1, 20, 2):
for x in range(2, n):

if n % x == 0:

primos.append(n)

else:

• Salida:

9 es 3 * 3
15 es 3 * 5

print(n, ’es’, x, ’*’, n//x)
break

• Variable primos: [1, 3, 5, 7, 11, 13, 17, 19]

Estructuras de control (instrucción while)

• Programa fibonacci.py:

a, b = 0, 1
while b < 10:

print(b,end=’,’)
a,b = b,a+b

• Programa busca-indice.py

ind =0
busco = "premio"
lst = ["nada","pierdo","premio","sigue"]
while ind < len(lst):

if lst[ind] == busco:

break
ind += 1

else: ind = -1

• Las instrucciones pass, continue, break y return

Algunos patrones de iteración

>>> notas = {’Juan Gómez’: ’notable’, ’Pedro Pérez’: ’aprobado’}
>>> for k, v in notas.items(): print(k, v)
Pedro Pérez aprobado
Juan Gómez notable

print(i, col)

>>> for i, col in enumerate([’rojo’, ’azul’, ’amarillo’]):
...
0 rojo
1 azul
2 amarillo

>>> preguntas = [’nombre’, ’apellido’, ’color favorito’]
>>> respuestas = [’Juan’, ’Pérez’, ’rojo’]
>>> for p, r in zip(preguntas, respuestas):
...
Mi nombre es Juan.
Mi apellido es Pérez.
Mi color favorito es rojo.

print(’Mi {0} es {1}.’.format(p, r))

>>> for i in reversed(range(1, 10, 2)): print(i,