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,
Comentarios de: Tema 2: Introducción a Python (0)
No hay comentarios