Curso Introducción a la

programación con Python3

Presentación
José Domingo Muñoz Rodríguez
www.josedomingo.org
@Pledin_JD
Curso Introducción a la
programación con Python3

Introducción a la
programación
Resolución de problemas
● Un programador es una persona que resuelve
problemas, y para llegar a ser un programador
eficaz se necesita aprender a resolver problemas
de un modo riguroso y sistemático:
● Análisis
● Diseño
● Codificación
● Ejecución y validación del programa
Análisis del problema
 Diseño de algoritmos
● Un algoritmo es un conjunto de
acciones que especifican la
secuencia de operaciones realizar,
en orden, para resolver un
problema.

● Debe ser preciso

● Debe estar definido
● Debe ser finito
 Diseño de algoritmos

● Un diagrama de flujo es una de

las técnicas de representación
gráfica de algoritmos más
antiguas.
● El pseudocódigo, nos permite
una aproximación del algoritmo
al lenguaje natural y por tanto
una redacción rápida del mismo.
Curso Introducción a la
programación con Python3

Introducción a
python3
Características de Python
Python es un lenguaje:

● Interpetrado
● Alto nivel
● Multiparadigma, ya que soporta orientación
a objetos, programación imperativa y
programación funcional.
● Multiplataforma
● Libre
¿Por qué elegir python?

● Porque es fácil de aprender

● Sintaxis muy limpia y sencilla
● Hay que escribir menos
● Obtienes resultados muy rápido
● Puedes programar con distintos paradigmas:
● Puedes programas distintos tipos de aplicaciones:
● Muchos usan Python (Google, Nokia, IBM). Es
demandado.
● Gran cantidad de módulos, muchísimas funcionalidades.
● Una gran comunidad que apoya el proyecto.
● Viene preinstalado en la mayoría de sistemas
 ¿Por qué elegir python?
Índice TIOBE

http://www.tiobe.com/tiobe-index/
Instalación de python3
● Instalación en linux debian/Ubuntu
○ En Debian 9 Stretch, la versión es la 3.5.3
○ En Ubuntu 18.04 Bionic, la versión es la 3.6.3
● Instalación en Windows
○ Descargar instalador (paquete MSI)
● Instalación en Mac
 ¿IDE o
Escribir y ejecutar programas python3 editor de
texto?
Uso del interprete

A partir de un fichero con el código fuente

$ python3 programa.py
 Mi primer programa en python3
Proceso mayor_edad
Definir edad como entero;
Escribir "Dime tu edad:";
Leer edad;
Si edad>=18 Entonces
Escribir "Eres mayor de edad";
FinSi
Escribir "Programa terminado";
FinProceso

# Programa que pida la edad

# y diga si es mayor de edad.
edad=int(input("Dime tu
edad:"))
if edad>=18:
print("Eres mayor de edad")
print("Programa Terminado")
Curso Introducción a la
programación con Python3

Tipos de datos
básicos
Literales, variables y expresiones
● Literales enteros: 3, 12, -23 Variables:
● Literales reales: 12.3, 45.6
● Literales cadenas: >>> var = 5
'hola que tal!' >>> var
"Muy bien"
'''Podemos \n 5
ir al cine'''

Expresiones

a + 7
(a ** 2) + b
Operadores
● Operadores aritméticos: +, -, *, /, //, %, **.
● Operadores de cadenas: +, *
● Operadores de asignación: =
● Operadores de comparación: ==, !=, >=, >, <=, <
● Operadores lógicos: and, or, not
● Operadores de pertenencia: in, not in
 Precedencia de operadores
1. Los paréntesis rompen la precedencia.
2. La potencia (**)
3. Operadores unarios (+ -)
4. Multiplicar, dividir, módulo y división entera (* % // )
5. Suma y resta (+ -)
6. Operador binario AND (&)
7. Operadores binario OR y XOR (^ |)
8. Operadores de comparación (<= < > >=)
9. Operadores de igualdad (<> == !=)
10. Operadores de asignación (=)
11. Operadores de pertenencia (in, in not)
12. Operadores lógicos (not, or, and)
Tipos de datos
★ Tipos númericos >>> type(5)
<class 'int'>
○ Tipo entero (int)
>>> type(5.5)
○ Tipo real (float) <class 'float'>
★ Tipos booleanos (bool) >>> type([1,2])
<class 'list'>
★ Tipo de datos secuencia >>> type(int)
○ Tipo lista (list) <class 'type'>
○ Tipo tuplas (tuple)
★ Tipo de datos cadenas de caracteres
○ Tipo cadena (str)
★ Tipo de datos mapas o diccionario (dict)
 Tipos de datos numéricos
>>> entero = 7 +: Suma dos números
>>> type(entero) -: Resta dos números
<class 'int'> *: Multiplica dos números
>>> real = 7.2 /: Divide dos números, el resultado es float.
>>> type (real) //: División entera
<class 'float' %: Módulo o resto de la división
**: Potencia
>>> a=int(7.2) +, -: Operadores unarios positivo y negativo
>>> a >>> abs(-7)
7
>>> a=int("345")
7
>>> a >>> divmod(7,2)
345 (3, 1)
>>> import math
>>> b=float(1) >>> hex(255)
>>> b >>> math.sqrt(9)
'0xff'
1.0 3.0
>>> pow(2,3)
>>> =float("1.234")
>>> b
8
1.234 >>>
>>> a=int("123.3") round(7.567,1)
7.6
 Tipo de datos booleanos
True, False ¿Qué valores se consideran falsos?

● False
● Cualquier número 0. (0, 0.0)
● Cualquier secuencia vacía ([], (), '')
● Cualquier diccionario vacío ({})

Operadores Lógicos Operadores de Comparación

x or y == != >= > <= <
x and y
not x
 Trabajando con variables
Una variables es un identificador que referencia a un valor. No
hay que declarar la variable antes de usarla, el tipo de la variable
será el mismo que el del valor al que hace referencia. Por lo
tanto su tipo puede cambiar en cualquier momento.

>>> a = 5
>>> a = 5
>>> a
>>> a
5
5
>>> a = 8
>>> del a
>>> a
>>> a
8
Traceback (most recent call
>>> a = a + 1
last):
>>> a+=1
File "<stdin>", line 1, in
>>> 10
<module>
NameError: name 'a' is not
definedOtros operadores de asignación: +=, -=, *=, /=, %=, **=, //= .
 input
Entrada y salida estándar
>>> nombre=input("Nombre:")
Nombre:jose
print >>> nombre
'jose'
>>> print(1,2,3) >>> edad=int(input("Edad:"))
1 2 3 Edad:23
>>> edad
>>> print("Hola son las",6,"de la tarde")
Hola son las 6 de la tarde 23

>>> print("Hola son las "+str(6)+" de la tarde")

Hola son las 6 de la tarde

>>> print("%d %f %s" % (2.5,2.5,2.5))

2 2.500000 2.5

>>> print("El producto %s cantidad=%d precio=%.2f"%("cesta",23,13.456))

El producto cesta cantidad=23 precio=13.46
 Introducción a las cadenas de caracteres
>>> cad1 = "Hola" +: Concatenación
>>> cad2 = '¿Qué tal?' >>> "hola " + "que tal"
>>> cad3 = '''Hola, 'hola que tal'
que tal?''' *: Repetición
>>> "abc" * 3
'abcabcabc'
Indexación
"a">"A" >>> cadena = "josé"
True >>> cadena[0]
'j'
"informatica">"informacion >>> cadena[3]
"
True
'é'
Longitud
"abcde">"abcdef" >>> cadena = "josé"
False >>> len(cadena)
4
 Pasando de pseudocódigo a python3
Definir nombre Como Cadena;
Escribir "Dime tu nombre:";
Leer nombre;

# nombre = input("Dime tu nombre:")

Definir numero Como Entero;

Escribir "Dime un número entero:";
Leer numero;

numero = int(input("Dime un número entero:"))

Definir numero Como Real;

Escribir "Dime un número real:";
Leer numero;

numero = float(input("Dime un número real:"))

 Pasando de pseudocódigo a python3
Escribir "Hola ",nombre;

print("Hola",nombre)

Escribir Sin Saltar var," ";

print(var," ",end="")

numero <- 7;

numero = 7

trunc(7/2)

7 // 2
 Pasando de pseudocódigo a python3
raiz(9)

import math
math.sqrt(9)
subcadena(cadena,0,0)

cadena[0]

cadena3 <- concatenar(cadena1,cadena2)

cadena3 = cadena1 + cadena2

cadena <- Mayusculas(cadena)

cadena = cadena.upper()
Curso Introducción a la
programación con Python3

Estructuras de
control
Estructura de control: Alternativas
Alternativa simple

edad = int(input("Dime tu
edad:"))
if edad>=18:
print("Eres mayor de edad")
print("Programa terminado") Alternativa doble

edad = int(input("Dime tu
edad:"))
if edad>=18:
print("Eres mayor de edad")
else:
print("Eres menor de edad")
print("Programa terminado")
Estructura de control: Alternativas
Alternativa múliple (pseudocódigo)

Proceso notas
Alternativa múltiple en python3
Definir nota como entero;
Escribir "Dime tu nota:"; nota = int(input("Dime tu nota:"))
Leer nota; if nota >=1 and nota <= 4:
Segun nota Hacer print("Suspenso")
1,2,3,4: Escribir "Suspenso";
elif nota == 5:
5: Escribir "Suficiente";
print("Suficiente")
6,7: Escribir "Bien";
8: Escribir "Notable";
elif nota == 6 or nota == 7:
9,10: Escribir "Sobresaliente"; print("Bien")
De Otro Modo: elif nota == 8:
Escribir "Nota incorrecta"; print("Notable")
FinSegun elif nota ==9 or nota == 10:
Escribir "Programa terminado"; print("Sobresaliente")
FinProceso else:
print("Nota incorrecta")
print("Programa terminado")
Estructura de control repetitivas: while
while

secreto = "asdasd"
Instrucciones: break
clave = input("Dime la clave:")
while clave != secreto: secreto = "asdasd"
print("Clave incorrecta!!!") clave = input("Dime la clave:")
clave = input("Dime la clave:") while clave != secreto:
print("Bienvenido!!!")
print("Clave incorrecta!!!")
print("Programa terminado")
otra = input("¿Quieres introducir otra clave (S/N)?:")
if otra.upper()=="N":
Instrucciones: continue break;
cont = 0 clave = input("Dime la clave:")
while cont<10: if clave == secreto:
cont = cont + 1 print("Bienvenido!!!")
if cont % 2 != 0: print("Programa terminado")
continue
print(cont)
 ¿Y la estructura “Repetir” de pseudocódigo?
Proceso login
Definir secreto, clave como cadena;
secreto <- "asdasd";
Repetir
Escribir "Dime la clave:";
Leer clave;
Si clave<>secreto Entonces
Escribir "Clave incorrecta!!!";
FinSi
Hasta Que clave=secreto
Escribir "Bienvenido!!!";
Escribir "Programa terminado";
FinProceso secreto = "asdasd"
while True:
clave = input("Dime la clave:")
if clave != secreto:
print("Clave incorrecta!!!")
if clave == secreto:
break;
print("Bienvenido!!!")
print("Programa terminado")
 Estructura de control repetitivas: for
Proceso Contar
Definir var como Entero;
Para var<-1 Hasta 10 Hacer
Escribir Sin Saltar var," ";
FinPara
FinProceso
for var in range(1,11):
print(var," ",end="")
Proceso ContarDescesdente
Definir var como Entero;
Para var<-10 Hasta 1 Con Paso -1 Hacer
Escribir Sin Saltar var," ";
FinPara
FinProceso
for var in range(10,0,-1):
print(var," ",end="")
Proceso ContarPares
Definir var como Entero;
Para var<-2 Hasta 10 Con Paso 2 Hacer
Escribir Sin Saltar var," ";
FinPara
FinProceso
for var in range(2,11,2):
print(var," ",end="")
 Usos específico de variables: contadores
cont = 0; El contador se inicializa a un valor inicial
for var in range(1,6):
num = int(input("Dime un número:"))
if num % 2 == 0:
El contador se incrementa
cont = cont + 1 Un contador también se puede decrementar
print("Has introducido ",cont," números pares.")

Un contador es una variable entera que la utilizamos para contar cuando ocurre un
suceso.
 ¿A qué valor

Usos específico de variables: acumuladores inicializamos

si vamos a
acumular
productos?

suma = 0; El acumulador se inicializa a un valor inicial

for var in range(1,6):
num = int(input("Dime un número:"))
if num % 2 == 0: El acumulador se acumula
Podemos acumular también productos
suma = suma + num
print("La suma de los números pares es ",suma)

Un acumulador es una variable numérica que permite ir acumulando

operaciones. Me permite ir haciendo operaciones parciales.
 Usos específico de variables: indicadores
indicador = False; Se inicializa a un valor lógico:
for var in range(1,6): No ha sucedido!!!!
num = int(input("Dime un número:"))
if num % 2 == 0:
indicador = True Cuando ocurre el suceso cambiamos su valor
if indicador:
print("Has introducido algún número par") Al final debemos
else: comprobar si el suceso
print("No has introducido algún número par") ha ocurrido

Un indicador es una variable lógica, que usamos para recordar o indicar algún
suceso.
Curso Introducción a la
programación con Python3

Tipos de datos
secuencias
 Tipo de datos cadenas de caracteres
>>> cad1 = "Hola" +: Concatenación
>>> cad2 = '¿Qué tal?' *: Repetición
>>> cad3 = '''Hola, Indexación
que tal?''' Longitud
Recorrido
>>> cadena = "informática"
>>> for caracter in cadena:
... print(caracter,end="")
Slice ...
>>> cadena[2:5] informática
'for' Operadores de pertenencia
>>> cadena[2:7:2] >>> "a" in cadena
'frá'
>>> cadena[:5]
True
'infor' >>> "b" in cadena
>>> cadena[5:] False
'mática' >>> "a" not in cadena
>>> cadena[-1:-3] False >>> cad = str(7.8)
'' >>> type(cad)
>>> cadena[::-1] <class 'str'>
'acitámrofni' >>> print(cad)
7.8
 Las cadenas de caracteres son inmutables
No podemos cambiar los caracteres de una cadena de la siguiente forma:
>>> cadena = "informática"
>>> cadena[2]="g"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

Esto implica que al usar un método la cadena original no cambia,

el método devuelve otra cadena modificada. Veamos un ejemplo:
>>> cadena = "informática"
>>> cadena.upper()
'INFORMÁTICA'
>>> cadena
'informática'

Si queremos cambiar la cadena debemos modificar su valor con el operador de

asignación:
>>> cadena = cadena.upper()
>>> cadena
'INFORMÁTICA'
 Métodos principales de cadenas
>>> cad = "hola, como estás?"
>>> print(cad.capitalize())
Hola, como estás?

>>> cad = "Hola Mundo"

>>> print(cad.lower()) >>> cad = "bienvenido a mi aplicación"
hola mundo
>>> cad.count("a")
>>> cad = "hola mundo" 3
>>> print(cad.upper())
HOLA MUNDO >>> cad.count("a",16)
2
>>> cad = "Hola Mundo" >>> cad.count("a",10,16)
>>> print(cad.swapcase())
1
hOLA mUNDO

>>> cad = "hola mundo" >>> cad.find("mi")

>>> print(cad.title()) 13
Hola Mundo >>> cad.find("hola")
-1
 Métodos principales de cadenas
>>> cad.startswith("b")
True
>>> buscar = "nombre apellido"
>>> cad.startswith("m")
>>> reemplazar_por = "Juan Pérez"
False replace(buscar, reemplazar_por))
>>> print ("Estimado Sr. nombre apellido:".
>>> cad.startswith("m",13) Estimado Sr. Juan Pérez:
True
>>> cad.endswith("ción") >>> cadena = " www.eugeniabahit.com "
True >>> print(cadena.strip())
>>> cad.endswith("ción",0,10) www.eugeniabahit.com
False >>> cadena="00000000123000000000"
>>> cad.endswith("nido",0,10) >>> print(cadena.strip("0"))
True 123

Otras funciones de validación:

isdigit(), islower(), >>> hora = "12:23:12"
isupper(), isspace(), >>> print(hora.split(":"))
istitle(),... ['12', '23', '12']

>>> texto = "Linea 1\nLinea 2\nLinea 3"

>>> print(texto.splitlines())
['Linea 1', 'Linea 2', 'Linea 3']
 >>> lista1 = []
>>> lista2 = ["a",1,True]

Tipo de datos secuencia: listas

lista = [1,2,3,4,5,6] Concatenación (+)
>>> lista + [7,8,9]
Recorrido [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> for num in lista:
... print(num,end="")
123456
Repeteción (*)
>>> lista * 2
>>> lista2 = ["a","b","c","d","e"]
[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]
>>> for num,letra in zip(lista,lista2):
... print(num,letra)
1 a Indexación
2 b >>> lista[3]
... 4

Operadores de pertenencia >>> lista1[12]

>>> 2 in lista ...
True IndexError: list index out of range
>>> 8 not in lista
True >>> lista[-1]
6
Tipo de datos secuencia: listas
>>> lista1 = [20,40,10,40,50]
Slice >>> len(lista1)
>>> lista[2:4] 5
[3, 4]
>>> lista[1:4:2] >>> max(lista1)
[2, 4] 50
>>> lista[:5]
[1, 2, 3, 4, 5] >>> min(lista1)
>>> lista[5:] 10
[6, 1, 2, 3, 4, 5, 6]
>>> lista[::-1] >>> sum(lista1)
[6, 5, 4, 3, 2, 1, 6, 5, 4, 3, 2, 1] 150

>>> sorted(lista1)
Listas multidimensionales [10, 20, 30, 40, 50]
>>> tabla = [[1,2,3],[4,5,6],[7,8,9]]
>>> tabla[1][1]
>>> sorted(lista1,reverse=True)
5
[50, 40, 30, 20, 10]
>>> for fila in tabla:
... for elem in fila:
... print(elem,end="")
... print()
 Las listas son mutables
Los elementos de las listas se pueden modificar:
>>> lista1 = [1,2,3]
>>> lista1[2]=4
>>> lista1 ¿Cómo se copian las listas?
[1, 2, 4] Para copiar una lista en otra no podemos utilizar el operador de asignación:
>>> del lista1[2] >>> lista1 = [1,2,3]
>>> lista1 >>> lista2 = lista1
[1, 2] >>> lista1[1] = 10
>>> lista2
[1, 10, 3]
Los métodos de las listas
modifican el contenido de la lista: El operador de asignación no crea una nueva lista, sino que nombra con dos
>>> lista1.append(3) nombres distintos a la misma lista, por lo tanto la forma más fácil de copiar
>>> lista1 una lista en otra es:
[1, 2, 3] >>> lista1 = [1,2,3]
>>> lista2=lista1[:]
>>> lista1[1] = 10
>>> lista2
[1, 2, 3]
 Métodos principales de listas
>>> lista = [1,2,3]
>>> lista.append(4)
>>> lista
[1, 2, 3, 4]

>>> lista2 = [5,6] >>> lista. pop()

>>> lista.extend(lista2)
>>> lista
6
[1, 2, 3, 4, 5, 6] >>> lista
[1, 100, 2, 3, 4, 5]
>>> lista.insert(1,100)
>>> lista >>> lista. pop(1)
[1, 100, 2, 3, 4, 5, 6] 100
>>> lista
[1, 2, 3, 4, 5]

>>> lista. remove(3)

>>> lista
[1, 2, 4, 5]
 Métodos principales de listas
>>> lista.reverse()
>>> lista
[5, 4, 2, 1]
>>> lista. count(5)
>>> lista.sort() 1
>>> lista
[1, 2, 4, 5] >>> lista. append(5)
>>> lista
>>> lista.sort(reverse=True)
>>> lista [5, 4, 2, 1, 5]
[5, 4, 2, 1]
>>> lista. index(5)
>>> lista=["hola","que","tal","Hola","Que","Tal"] 0
>>> lista.sort()
>>> lista
['Hola', 'Que', 'Tal', 'hola', 'que', 'tal'] >>> lista. index(5,1)
4

>>> lista. index(5,1,4)

Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 5 is not in list
Tipo de datos secuencia: tuplas
Las tuplas son inmutables
>>> tupla1 = () >>> tupla = (1,2,3)
>>> tupla2 = ("a",1,True) >>> tupla[1]=5
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

● Recorrido Métodos de búsqueda: count, index

>>> tupla = (1,2,3,4,1,2,3)
● Operadores de pertenencia
>>> tupla.count(1)
● Concatenación (+) 2
● Repeteción (*)
● Indexación >>> tupla.index(2)
● Slice 1
>>> tupla.index(2,2)
Entre las funciones definidas podemos 5
usar: len, max, min, sum,
sorted.
Curso Introducción a la
programación con Python3

Tipos de datos
mapas
Tipo de datos mapas: diccionarios
>>> dicccionario = {'one': 1, 'two': 2, 'three': 3}

>>> dict1 = {}
>>> dict1["one"]=1
>>> dict1["two"]=2
>>> dict1["three"]=3

Longitud Eliminación
>>> len(a) >>> del(a["one"])
3 >>> a
{'three': 3, 'two': 2}
Indexación
>>> a["one"] Operadores de pertenencia
1 >>> "two" in a
>>> a["one"]+=1 True
>>> a
{'three': 3, 'one': 2, 'two': 2}
 Los diccionarios son mutables
Los elementos de los diccionarios se pueden modificar:
>>> a = {'one': 1, 'two': 2, 'three': 3}
>>> a["one"]=2
>>> del(a["three"])
>>> a
{'one': 2, 'two': 2}
¿Cómo se copian los diccionarios?
Para copiar un diccionario en otra no podemos utilizar el operador de
asignación:
>>> a = {'one': 1, 'two': 2, 'three': 3}
>>> b = a
>>> del(a["one"])
>>> b
{'three': 3, 'two': 2}

En este caso para copiar diccionarios vamos a usar el método copy():

>>> a = dict(one=1, two=2, three=3)
>>> b = a.copy()
>>> a["one"]=1000
>>> b
{'three': 3, 'one': 1, 'two': 2}
 Métodos principales de diccionarios
>>> dict1 = {'one': 1, 'two': 2, 'three': 3}
>>> dict1.clear()
>>> dict1
{}

>>> dict1 = {'one': 1, 'two': 2, 'three': 3}

>>> dict2 = dict1.copy()

>>> dict1 = {'one': 1, 'two': 2, 'three': 3}

>>> dict2 = {'four':4,'five':5}
>>> dict1.update(dict2)
>>> dict1
{'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5}
 Métodos principales de diccionarios
>>> dict1 = {'one': 1, 'two': 2, 'three': 3}
>>> dict1.get("one")
1
>>> dict1.get("four")
>>> dict1.get("four","no existe") >>> for clave in dict1.keys():
'no existe' ... print(clave)
one
>>> dict1.pop("one") two
1 three
>>> dict1
{'two': 2, 'three': 3} >>> for valor in dict1.values():
>>> dict1.pop("four") ... print(valor)
Traceback (most recent call last): 1
File "<stdin>", line 1, in <module> 2
KeyError: 'four' 3
>>> dict1.pop("four","no existe")
'no existe' >>> for clave,valor in dict1.items():
... print(clave,"->",valor)
one -> 1
two -> 2
three -> 3
Curso Introducción a la
programación con Python3

Excepciones
 Excepciones

>>> while True print('Hello world')

File "<stdin>", line 1
while True print('Hello world')
^
SyntaxError: invalid syntax

>>> 4/0
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

>>> a+4
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'a' is not defined

>>> "2"+2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Can't convert 'int' object to str implicitly
 Manejando excepciones

>>> while True:

... try:
... x = int(input("Introduce un número:"))
... break
... except ValueError:
... print ("Debes introducir un número")

>>> try:
... print (10/int(cad))
... except ValueError:
... print("No se puede convertir a entero")
... except ZeroDivisionError:
... print("No se puede dividir por cero")
... except:
... print("Otro error")
 Manejando excepciones

>>> try:
... print (10/int(cad))
... except ValueError:
... print("No se puede convertir a entero")
... except ZeroDivisionError:
... print("No se puede dividir por cero")
... else:
... print("Otro error")

>>> try:
... result = x / y
... except ZeroDivisionError:
... print("División por cero!")
... else:
... print("El resultado es", result)
... finally:
... print("Terminamos el programa")
Curso Introducción a la
programación con Python3

Introducción a los
módulos
 Introducción a los módulos
Módulo: Cada uno de los ficheros .py que nosotros creamos se llama módulo. Los elementos creados
en un módulo (funciones, clases, ...) se pueden importar para ser utilizados en otro módulo. El
nombre que vamos a utilizar para importar un módulo es el nombre del fichero.

Importación de módulos Módulos matématicos

>>> import math ● math
>>> math.sqrt(9) >>> math.sqrt(9)
3.0 ● functions
>>> from math import
sqrt ● random
>>> sqrt(9) >>> random.randint(1,10)
3.0
Módulos de hora y fecha Módulos del sistemas

● time ● os
>>> time.sleep(1) >>> os.system(“clear”)

● datetime
Curso Introducción a la
programación con Python3

Programación
estructurada
 Programación estructurada
Con la programación modular y estructura, un problema complejo debe ser dividido en varios
subproblemas más simples, y estos a su vez en otros subproblemas más simples. Esto debe hacerse hasta
obtener subproblemas lo suficientemente simples como para poder ser resueltos fácilmente con algún
algoritmo (divide y vencerás). Además el uso de subrutinas nos proporciona la reutilización del código y no
tener repetido instrucciones que realizan la misma tarea.

>>> def factorial(n):

... """Calcula el factorial de un
número"""
... resultado = 1
... for i in range(1,n+1): >>>
... resultado*=i factorial(5)
... return resultado 120

Para llamar a una función se debe utilizar su nombre y entre paréntesis los parámetros
reales que se mandan. La llamada a una función se puede considerar una expresión
cuyo valor y tipo es el retornado por la función.
 Ámbito de variables
Variables locales: se declaran dentro de una función y no se pueden utilizar fuera
de esa función

>>> def operar(a,b): Variables globales: son visibles en todo el módulo.

... suma = a + b
... resta = a - b >>> PI = 3.1415
... print(suma,resta) >>> def area(radio):
... ... return PI*radio**2
>>> operar(4,5) ...
9 -1 >>> area(2)
>>> resta 12.566
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'resta' is not defined
 Parámetros formales y reales
def CalcularMaximo(num1,num2):
if num1 > num2: Parámetros formales: Son las
return num1 variables que recibe la función, se
else: crean al definir la función.
return num2

numero1 = int(input("Dime el número1:"))

numero2 = int(input("Dime el número2:"))
num_maximo = CalcularMaximo(numero1,numero2)
Parámetros reales: Son la expresiones print("El máximo es ",num_maximo;)
que se utilizan en la llamada de la
función, sus valores se “copiarán” en los
parámetros formales.
 Paso de parámetro por valor o por referencia
En Python el paso de parámetros es siempre por referencia. El lenguaje no trabaja con el concepto de
variables sino objetos y referencias.

Si se pasa un valor de un objeto inmutable, su valor no se podrá

cambiar dentro de la función.
>>> def f(a):
... a=5
>>> a=1 Sin embargo si pasamos un objeto de un tipo mutable, si
>>> f(a) podremos cambiar su valor:
>>> a
1 >>> def f(lista):
... lista.append(5)
...
>>> l = [1,2] Devolución de información
>>> f(l) Una función en python puede devolver
>>> l información utilizando la instrucción return. La
[1, 2, 5] instrucción return puede devolver cualquier tipo
de resultados, por lo tanto es fácil devolver
múltiples datos guardados en una lista, tupla
Aunque podemos cambiar el parámetro real cuando los objetos pasados
o diccionario.
son de tipo mutables, no es recomendable hacerlo en Python.
 LLamadas a una función
Cuando se llama a una función se tienen que indicar los parámetros reales que se van a pasar. La llamada a
una función se puede considerar una expresión cuyo valor y tipo es el retornado por la función. Si la
función no tiene una instrucción return el tipo de la llamada será None.

Una función recursiva es aquella que al ejecutarse hace

>>> def cuadrado(n):
llamadas a ella misma. Por lo tanto tenemos que tener "un caso
... return n*n base" que hace terminar el bucle de llamadas. Veamos un
ejemplo:
>>> a=cuadrado(2)
>>> cuadrado(3)+1 def factorial(num):
10 if num==0 or num==1:
>>> cuadrado(cuadrado(4)) return 1
256 else:
>>> type(cuadrado(2)) return num * factorial(num-1)
<class 'int'>
Curso Introducción a la
programación con Python3

Programación
orientada a objetos
 Introducción a la Programación orientada a Objetos
import math Llamamos clase a la representación abstracta de un concepto.
class punto(): Las clases se componentes de atributos y métodos.
""" Representación de un punto en el
plano, los atributos son x e y Los atributos definen las características propias del objeto y
que representan los valores de las modifican su estado.
coordenadas cartesianas."""

def __init__(self,x=0,y=0): Los métodos son bloques de código (o funciones) de una clase
self.x=x que se utilizan para definir el comportamiento de los objetos.
self.y=y

def mostrar(self): El constructor __init__, que nos permite inicializar los

return str(self.x)+":"+str(self.y) atributos de objetos. Este método se llama cada vez que se
crea una nueva instancia de la clase (objeto).
def distancia(self, otro):
""" Devuelve la distancia entre ambos puntos. """
dx = self.x - otro.x
dy = self.y - otro.y Todos los métodos de cualquier clase, recibe como primer
return math.sqrt((dx*dx + dy*dy)) parámetro a la instancia sobre la que está trabajando. (self).
 Introducción a la Programación orientada a Objetos

>>> punto1=punto()
>>> punto2=punto(4,5)
>>> print(punto1.distancia(punto2))
6.4031242374328485
Para crear un objeto, utilizamos el nombre de la clase enviando
como parámetro los valores que va a recibir el constructor.
>>> punto2.x
4
>>> punto2.x = 7
>>> punto2.x
Podemos acceder y modificar los atributos de objeto.
7
 Encapsulamiento
La característica de no acceder o modificar los valores de los atributos
directamente y utilizar métodos para ello lo llamamos encapsulamiento.

>>> class Alumno():

... def __init__(self,nombre=""):
... self.nombre=nombre Las variables que
>>>
... punto2.x
self.__secreto="asdasd" comienzan por un doble
4
... guión bajo __ la podemos
>>> punto2.x = 7
a1=Alumno("jose") considerar como
punto2.x
>>> a1.__secreto atributos privados.
7
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Alumno' object has no
attribute '__secreto'
 Encapsulamiento
● En Python, las propiedades (getters) nos permiten implementar la
funcionalidad exponiendo estos métodos como atributos.
● Los métodos setters son métodos que nos permiten modificar los
atributos a través de un método.

class circulo():
def __init__(self,radio): >>> c1=circulo(3)
self.radio=radio >>> c1.radio
Estoy dando el radio
@property 3
def radio(self):
>>> c1.radio=4
print("Estoy dando el radio")
return self.__radio >>> c1.radio=-1
Radio debe ser positivo
@radio.setter >>> c1.radio
def radio(self,radio): 0
if radio>=0:
self.__radio = radio
else:
raise ValueError("Radio positivo")
self.__radio=0
 La clase punto3d hereda de la clase punto todos sus propiedades y sus métodos. En la
clase hija hemos añadido la propiedad y el setter para el nuevo atributo z, y hemos
Herencia modificado el constructor (sobreescritura) el método mostrar y el método distancia.

class punto3d(punto):
>>> p3d=punto3d(1,2,3)
def __init__(self,x=0,y=0,z=0):
super().__init__(x,y) >>> p3d.x
self.z=z 1
@property >>> p3d.z
def z(self): 3
print("Doy z") >>> p3d.mostrar()
return self.__z
1:2:3
@z.setter >>> p3d.y = 3
def z(self,z):
print("Cambio z")
self.__z=z

def mostrar(self): La función super() me proporciona

return super().mostrar()+":"+str(self.__z) una referencia a la clase base. Nos
def distancia(self,otro): permite acceder a los métodos de la
dx = self.__x - otro.__x
dy = self.__y - otro.__y
clase madre.
dz = self.__z - otro.__z
return (dx*dx + dy*dy + dz*dz)**0.5
Delegación
Llamamos delegación a la situación en la que una clase contiene (como
atributos) una o más instancias de otra clase, a las que delegará parte de sus
funcionalidades.
class circulo():
def __init__(self,centro,radio):
self.centro=centro
self.radio=radio

def mostrar(self):
return "Centro:{0}-Radio:{1}".format(self.centro.mostrar(),self.radio)

>>> c1=circulo(punto(2,3),5)
>>> print(c1.mostrar())
Centro:2:3-Radio:5
>>> c1.centro.x = 3