SALIDAS:

v = “otro texto”
n=10
print(“Un texto”,v,”y un número”,n)

c= “Un texto {} y un número {}”.format(v,n)

c

print©

Segunda manera:
##Para cambiar el orden fácilmente
Print(“Un texto {1} y u número {0}”.format(v,n)

##Referenciando el orden
Print(“Un texto {texto} y un número {número}”.format(numero=n,texto=v))

##Alinear 30 espacios una palabra en particular

print(“{:>30}”.format(“palabra”)) #Alineamiento a la derecha
palabra
print(“{:30}”.format(“palabra”)) #Alineamiento a la izquierda
palabra

print(“{:^30}”.format(“palabra”)) #Alineamiento al centro en 30 caracteres

palabra
print(“{:.5}”.format(“palabra”)) #Truncamiento a 5 caracteres
palab

print(“{:>30.3}”.format(“palabra”)) #Alineamiento a la derecha en 30 caracteres con truncamiento

pal
Formateo de números enteros:

print(“{:4d}”.format(10))
print(“{:4d}”.format(100))
print(“{:4d}”.format(1000))

#Ahora rellenados con ceros

print(“{:04d}”.format(10))
print(“{:04d}”.format(100))
print(“{:04d}”.format(1000))

#Formateo de números flotantes, rellenados con espacios

print(“{}”.format(3.1415926))

print(“{:7.3f}”.format(153.21))
print(“{:7.3f}”.format(3.1415926))

print(“{:07.3f}”.format(153.21))
print(“{:07.3f}”.format(3.1415926))

Ejercicio con import sys y sys.argv

import sys
if len(sys.argv) == 3:
filas = int(sys.argv[1])
columnas = int(sys.argv[2])
if filas<1 or filas >9 or columnas <1 or columnas>9:
print(“Error-Filas o columnas incorrectas”)
print(“Ejemplo: tabla.py [1-9] [1-9]”)
else:
for f in range(filas):
pront (“”)
for c in range(columnas):
print(“ * ”,end=’’)

else:
print(“Error-Argumentos incorrectos”)
print(“Ejemplo: tabla.py [1-9] [1-9]”)

Salida: 25 asteriscos en una sola fila

Salida2: 5 asteriscos en 5 filas distintas

Generador de tablas, de m filas y n columnas respectivamente.

###EJEMPLO DE DESCOMPOSICIÓN EN UNIDADES, DECENAS, CENTENAS,

MILES AND SO ON

import sys

if len(sys.argv) == 2:
numero = int(sys.argv[1])
if numero<0 or numero>9999:
print(“Error – Número es incorrecto”)
print(“Ejemplo: descomposicion.py [0-9999]”)
else:
#Aquí va la lógica
cadena = str(numero)
longitud = len(cadena)
for i in range(longitud):
print(“{:04d}”.format(int(cadena[longitud-1-i])*10**i))
else:
print(“Error-Argumentos incorrectos”)
print(“Ejemplo: descomposicion.py [0-9999]”)

####END

##Se ingresa el número 3647

0007
0040
0600
3000

FUNCIONES
Ejemplos:

#Imprimir un saludo

def saludar():
print(“Hola! Este print se llama desde la función saludar()”)
saludar()

Hola! Este print se llama desde la función saludar ()

#Tabla del 5

def dibujar_tabla_del_5():
for i in range(10):
print(“5 *”,i,”=”,i*5)
dibujar_tabla_del_5()

Variables con el mismo nombre pueden coexistir en distintas partes del código

#Retorno de Valores

def test():
return “Una cadena retornada”
#Esto no se ejecutara nunca
print(“Otro print”)
test()

#Pero

print(test())
c=test()
print©

#Otro ejemplo

def test():
return [1,2,3,4,5]
print(test())

Salida: [1,2,3,4,5]

print(test()[-1]) #Encadenando como si fuera una lista – último elemento

print(test()[1:4]) #Slicing

Salida: [2,3,4]

l= test()
l[-1]
Salida : 5

#Otro ejemplo:

def test():
return “Una cadena” ,20, [1,2,3]

test()
Salida: una tupla de la forma

(‘Una cadena’,20,[1,2,3])
c,n,k = test()

Enviando Valores:

Ejemplo:

def suma(a,b):
return a+b

r = suma(2,5)
r
Salida: 7

Argumentos y Parámetros

EQUIVALENTES

def resta(a,b):
return a-b

resta(1,2)

resta(b=2,a=1)

def resta(a=None,b=None):
if a == None or b == None:
print(“Error, debes enviar dos números a la función”)
return
return a-b
resta(1,5)

ARGUMENTOS POR VALOR Y POR REFERENCIA

#Paso por valor (Argumentos a una función)

def doblar_valor(numero):
numero*=2
n=10
doblar_valor(n)
n
Out: 10

AHORA

Colecciones, listas, conjuntos

def doblar_valores(numeros):
for i,n in enumerate(numeros):
numeros [i]*=2
ns = [10,50,100]

doblar_valores(ns)
ns

Out: [20,100,200]

#Paso por referencia: los cambios se ven reflejados en el exterior.

PUNTEROS en python es un artificio

def doblar_valores(numeros):
for i,n in enumerate(numeros):
numeros[i]*=2
ns = [10,50,100]
doblar_valores(ns[:])
ns

Out: [10,50,100]

ARGUMENTOS INDETERMINADOS

def indeterminados_posicion(*args):
print(args)

indeterminados_posicion(5,”Hola”,[1,2,3,4,5])

#Parámetro args de argumentos

def indeterminados_nombre(**kwargs):
print(kwargs)
indeterminados_nombre(n=5,c=”Hola”,l=[1,2,3,4,5])
Out: {‘n’:5,’c’:’Hola’,’l’:[1,2,3,4,5]}
#Variación
def indeterminados_nombre(**kwargs):
for kwarg in kwargs:
print(kwarg,” “, kwargs[kwarg])
indeterminados:nombre(n=5,c=”Hola”,l=[1,2,3,4,5])

Out:

n 5
c Hola
l [1,2,3,4,5]

args y kargs a la vez

def super_funcion(*args,**kwargs):
t=0
for arg in args:
t+=arg
print(“Sumatorio indeterminado es”,t)
for kwarg in kwargs:
print(kwarg,” “,kwargs[kwarg])
super_funcion(10,50,-1,1.56,10,20,300,nombre=”Hector”,edad=27)

Out:
Sumatorio indeterminado es 390.56
nombre Hector
edad 27

FUNCIONES RECURSIVAS

HARD

#FACTORIAL DE UN NÚMERO

def factorial(num):
print(“Valor inicial ->”,num)
if num>1:
num=num*factorial(num-1)
print(“valor final ->”,num)
return num
factorial(5)

FUNCIONES INTEGRADAS
Convertir caracteres a enteros o flotantes
n=int(”10”)
n

f= float(“10.5”)
f

#Decimal a cadena
c=”Un texto y un número” + str(10)+” “+str(3.14)

bin(10) ‘0b1010’
hex(10) ‘0xa’

int(‘0b1010’,2)
int(‘0xa’,16)

round(5.5)  6
round(5.4)  4

eval(‘2+5’)  7

n=10
eval(‘n*10-5’)

EJERCICIO

numeros = [-12,84,13,20,-33,101,9]

#Completa el ejercicio aquí

def separar(lista):
lista.sort()
pares=[]
impares=[]
for n in lista:
if n%2 == 0;
pares.append(n)
else:
impares.append(n)
return pares, impares
pares,impares=separar(numeros)
print(pares)
print(impares)

MANEJO DE EXCEPCIONES
APRENDIENDO DEL ERROR
EJEMPLO BLOQUE TRY-EXCEPT

while (True):

try:
n=float(input(“Introduce un número: “))
m=4
print(“{}/{}={}”.format(n,m,n/m))

except:
print(“Ha ocurrido un error, introduce bien el número”)
else:
print(“Todo ha funcionado correctamente”)
break #Importante romper la iteración si todo ha salido bien
finally:
print(“Fin de la iteración”)

MÚLTIPLES EXCEPCIONES

#Identificador del error

try:
n=input(“Introduce un número: “)
5/n
except Exception as e:
print(type(e).__name__)
#Muestra el tipo de error sin que se deje de ejecutar el código
#Tiene que ver con las clases y con las herencias
#Excepción TypeError

#Ejemplo 2 Múltiples

try:
n=input(“Introduce un número: “)
5/n
except TypeError:
print(“No se puede dividir el número por una cadena”)
except ValueError:
print(“Debes introducir una cadena que sea un número”)
except ZeroDivisionError:
print(“No se puede dividir un número entre cero. Prueba otro número”)
except Exception as e:
print(type(e).__name__)

INVOCACIONES DE EXCEPCIONES
def mi_funcion(algo=None):
if algo is None
print(“Error! No se permite un valor nulo”)

mi_funcion()
Out: EL MENSAJE

def mi_funcion(algo=None):
try:
if algo is None
raise ValueError(“Error! No se permite un valor nulo”)
except ValueError:
print(“Error! No se permite un valor nulo (desde la excepción)”)

mi_funcion()

ALGO COMPLEJO

elementos = [1,5,-2]

#Completa el ejercicio aquí

def agregar_una_vez(lista,el):
try:
if el in lista:
raise ValueError
else:
lista.append(el)
except ValueError:
print(“Error: Imposible añadir elementos duplicados => {}”.format(el))
agregar_una_vez(elementos,10)
agregar_una_vez(elementos,-2)
agregar_una_vez(elementos,”Hola”)
print(elementos)

OUT:
Error: Imposible añadir elementos duplicados => -2
[1,5,-2,10,’Hola’]

CLASES Y OBJETOS

POO: Paradigma de solución de problemas que identifica entidades de la realidad y las

traslada a clases y objetos.
Programación Estructurada vs POO

COMPARACIÓN

##CLASES Y OBJETOS

EJEMPLO

#La clase es como un molde para crear objetos

#Primera letra en mayúscula

class Galleta:
pass

una_galleta=Galleta()
otra_galleta=Galleta()

#Un objeto es una instancia de clase

type(una_galleta)
OUT: __main__.Galleta

type(10)

type(3.14)

ATRIBUTOS Y MÉTODOS DE CLASE

class Galleta:
pass

una_galleta=Galleta()

una_galleta.sabor= “Salado”

una_galleta.color = “Marrón”

print (“El sabor de galleta es “, una_galleta.sabor)

___________

class Galleta:
chocolate = False
g = Galleta()
g.chocolate
OUT: False
#Ahora

g.chocolate = True
g.chocolate

OUT: True

class Galleta():
chocolate = False
def __init__(self):
print(“Se acaba de crear una galleta.”)
g = Galleta ()

OUT: Se acaba de crear una galleta

#Atributos y métodos de clase

class Galleta():
chocolate = False

def __init__(self, sabor=None, forma=None):

self.sabor= sabor
self.forma= forma
if sabor is not None and forma is not None
print(“Se acaba de crear una galleta {} y {}”.format(sabor,forma))

def chocolatear(self):
self.chocolate = True

def tiene_chocolate(self):
if (self.chocolate):
print(“Soy una galletsa chocolateada :-D”
else:
print(“Soy una galleta sin chocolate ”)

Entonces:

g = Galleta(“salada”,”cuadrada”)
OUT: Se acaba de crear una galleta salada y cuadrada

MÉTODOS ESPECIALES

__init__ al iniciar una instancia, se le denomina método constructor

class Pelicula:
 #Constructor de clase
def __init__(self,titulo,duracion,lanzamiento):
self.titulo = titulo
self.duracion = duracion
self.lanzamiento = lanzamiento
print(“Se ha creado la película”,self.titulo)
p = Pelicula(“El Padrino”, 175,1972)

OUT:

Se ha creado la película El Padrino

#Referencia a una instancia con un código de memoria

class Pelicula:
#Constructor de clase
def __init__(self,titulo,duracion,lanzamiento):
self.titulo = titulo
self.duracion = duracion
self.lanzamiento = lanzamiento
print(“Se ha creado la película”,self.titulo)

#Destructor de clase
def __del__(self):
print(“Se está borrando la película”, self.titulo)

#Redefinimos el método string

def __str__(self):
return “{} lanzada en {} con una duración de {}
minutos”.format(self.titulo,self.lanzamiento,self.duracion)
#Redefinimos el método length
def __len__(self):
return self.duracion
p= Pelicula(“El Padrino”,175,1972)

OUT: Se ha creado la película El Padrino

str(p)
OUT: ‘El Padrino lanzada en 1972 con una duración de 175 minutos’

len(p)
OUT: 175

OBJETOS DENTRO DE OBJETOS

ENCAPSULACIÓN
Funcionalidad para impedir el acceso interno a métodos. Python no ofrece pero se
puede simular.

class Ejemplo:
__atributo_privado = “Soy un atributo inalcanzable desde fuera”

def __metodo_privado(self):
print(“Soy un método inalcanzable desde fuera”)

e = Ejemplo()

e.__atributo_privado
e.__metodo_privado

###

class Ejemplo:
__atributo_privado = “Soy un atributo inalcanzable desde fuera”

def __metodo_privado(self):
print(“Soy un método inalcanzable desde fuera”)
def __ atributo_publico(self):
return self.__atributo_privado
def __metodo_publico(self):
return self.__metodo_privado

HERENCIA

Capacidad de una clase de heredad atributos y métodos de otra, además de agregar

nuevos o modificar los heredados

SUPERCLASE – SUBCLASE

POLIMORFISMO,HERENCIA MÚLTIPLE

POLIMORFIA

Propiedad de la herencia en que objetos de distintas subclases pueden responder una

misma acción.

Todas ls clases son a su vez subclases de la superclase Object.

class Producto:
def __init__(self,referencia,tipo,nombre,pvp,descripción,productor=None,
distribuido=None, isbn=None,autor =None):
self.referencia
 self.tipo
self nombre
self.pvp = pvp

HERENCIA: COCHES Y VEHÍCULOS (VOLVER A REVISAR EN EL FUTURO)

Métodos de las colecciones

CADENAS

“Hola Mundo”.upper()
OUT: ‘HOLA MUNDO’

“Hola Mundo”.lower()
“hola mundo”.capitalize()

“hola mundo”.title()
‘Hola Mundo’

“Hola mundo”.count(‘o’)
“Hola mundo”.count(‘z’)
“Hola mundo”.count(‘mundo’)
“Hola mundo”.find(‘mundo’)
5
#Desde donde empieza el 5

“Hola mundo mundo mundo”.rfin(‘mundo’)

##La última aparición – reverse find

c=”100”
c.isdigit()
True

c2 = “ABC10034po
c2.isalnum()
True

Un dash y se vuelve falso

c2.isalpha()
False

“Hola mundo”.isalpha()
OUT: False
#Pregunta si todo esta en el alfabeto

“Hola mundo”.islower()
False

“Hola mundo”.isupper()
False

“Hola Mundo”.istitle()
True

“ “.isspace()
True
#Pregunta si todos son espacios

“Hola mundo”.startswith(“Hola”)
True

“Hola mundo”.endswith(‘o’)
True

#Métodos avanzados

“Hola mundo mundo”.split()[0]

[‘Hola,’mundo’,’mundo’]

“Hola,mundo,mundo,otra,palabra”.split(‘,’)
#De esta manera separa a partir de la coma

“,”.join(“Hola mundo”)
“H,o,l,a, ,m,u,n,d,o’

“ “.join(“Hola”)
‘H o l a’

“ Hola mundo “.strip()

OUT: ‘Hola mundo’

“------Hola mundo------“.strip(‘-‘)
‘Hola mundo’

“Hola mundo mundo mundo mundo mundo”.replace(‘ mundo’,’ ‘,3)

‘Hola mundo mundo’

## ‘ mundo’ Espacio para eliminar espacios juntos

LISTAS
lista.append(6)
lista.clear()

l1=[1,2,3]
l2=[4,5,6]

l1.extend(l2)
l1
OUT:[1,2,3,4,5,6]

[“Hola”,”mundo”,”mundo”].count(“Hola”)
[“Hola”,”mundo”,”mundo”].index(“mundo”)
OUT: 1

l[10,20,30,40,50]
l.pop()
OUT: 50

print(l)
OUT: [10,20,30,40]

l.pop(0)
OUT:10

print(l)
OUT: [20,30,40]

l.remove(30)
print(l)
OUT: [20,40]

l= [20,30,30,30,40]

l.remove(30)
print(l)
[20,30,30,40]

l.reverse()
[40,30,30,20]

lista = list(“Hola mundo”)

lista

lista.reverse()
lista
cadena = “”.join(lista)
#Cadena a una lista

‘odnum aloH’

#Ordenar los elementos

lista.sort() ##Ordenar los elementos de una lista, de menor a mayor

lista.sort(reverse=True) ## Ordenado de mayor a menor

CONJUNTOS

c= set()
c.add(1)
c.add(2)
c.add(3)
c
OUT: {1,2,3}
c.discard(1)
OUT: {2,3}

Copiar conjuntos

c2 = c.copy()
c2.discard(4)

c2 ##Sin el 4
c ##Continua con el 4

c2.clear()
c2
set()
Conjunto vacío

c1 = {1,2,3}
c2 = {3,4,5}
c3 = {-1,99}
c4 = {1,2,3,4,5}

c1.isdisjoint(c1,c3) #DISJUNTO
OUT: True

c1.issubset(c4) ##SUBCONJUNTO
OUT: True

c4.issuperset(c1) ##CONTENEDOR
OUT: True
UNION

c1.union(c2)

c1.update(c2)
c1

c1.difference(c2)
c1.difference_update(c2)

c1.intersection(c2)

c1.symmetric_difference(c2)

DICCIONARIOS

colores = {“amarillo”:”yellow”,”azul”:”blue”,”verde”:”green”}

colores.get(‘negro’,’no se encuentra’)

‘amarillo’ in colores
True

colores.keys()
dict_keys([‘amarillo’,’azul’,’verde’])

dict_values([‘yellow’,’blue’,’green’])

dict_items

for c in colores:
print(colores[c])

for c,v in colores.items():

print(c,v)

colores.pop(“amarillo”, “no se ha encontrado”)

OUT: ‘yellow’

colores.clear{}

colores
OUT: {}
FORMAS DE ORGANIZAR EL CÓDIGO, DISTRIBUIR, DOCUMENTAR, INTERFACES
GRÁFICAS, FICHEROS, BASE DE DATOS