Trabajo Práctico Nro 1

Programación en Python
ESTRUCTURA SECUENCIAL

Pregunta 1: ¿Cuál es el valor final de a, b y c? (atención a los tipos de número decimal y entero)

a = 5 * 11
b = a / 2.
c, a = b * 2, b + 1
Pregunta 2: Identica tres tipos de datos de Python y explica brevemente en qué se diferencian. Explica la
diferencia entre el tipo lista y el tipo tupla.

Pregunta 3: ¿Cuál es el resultado de la operación lógica 'manzana'> 'casa'? Explica por qué. Nota:
Consultad en estándar Unicode para la codificación de caracteres.

Ejercicio 1: Copia el siguiente código en un editor de texo. Guárdelo como "holamundo.py" y ejecútelo con
Python

print ('hola')
print ('adios')

Ejercicio 2: Copia, guarda y ejecuta el siguiente código: variables.py

a = 10
B = 5
resultado = 0
print('el valor de la variable a es: ')
print(a)
print('el valor de la variable B es: ')
print(B)
resultado = a + B
print('El resultado es ', resultado)

Ejercicio 3: Cambia el código anterior por el siguiente y ejecútalo:

a = 8
B = 10
resultado = 0
print('el valor de la variable a es: ' + str(a))
print('el valor de la variable b es: ' + str(B))
resultado = a + B
print('El resultado es ' + str(resultado))

Ejercicio 4: ejecutar y entender el siguiente programa: :

numero1 = int(input('Dime un numero del 1 al 10 '))
numero2 = int(input('Dime otro numero del 1 al 10 '))
calcula = numero1 * numero2
cadenaCalcula = str (calcula)
print('El resultado es ')
print (cadenaCalcula)

Ejercicio 5: Realizar un programa donde el usuario introduce una cantidad de euros y el ordenador contesta
con su valor en dólares.1 Euro = 0,97 u$s

Ejercicio 6: Realizar un programa donde el usuario introduce la temperatura en ºC Celsius y el ordenador

contesta con °F Farengheit (averiguar la relación entre °C y °F)

Ejercicio 7: Copia, guarda y ejecuta el siguiente código: variables2.py. OJO! , los espacios son importantes
(4 espacios de sangria hacia la derecha)

def f_variables():
a = 8
B = 10
resultado = 0
print('el valor de la variable a es: ' + str(a))
print('el valor de la variable b es: ' + str(B))
resultado = a + B
print('El resultado es ' + str(resultado))
f_variables()

Ejercicio 8: DEBUG, depurar paso a paso el siguiente programa :

numero1 = int(input('Dime un numero del 1 al 10 '))

numero2 = int(input('Dime otro numero del 1 al 10 '))
if numero1 > numero2:
resultado = 'el segundo'
else:
resultado = 'el primero'
print ('El mayor es ' +str(resultado))

Ejercicio 9: Realice un programa para obtener el área de un triángulo conociendo la base y la altura.
a∗b
Aplicar la fórmula: Á𝑟𝑒𝑎 =
2
Ejercicio 10: Una empresa importadora desea determinar cuántos dólares puede adquirir con equis
cantidad de dinero. Realice un programa para tal fin.

Ejercicio 11: Una empresa que contrata personal requiere determinar la edad de las personas que solicitan
trabajo, pero cuando se les realiza la entrevista sólo se les pregunta el año en que nacieron. Realice el
programa para solucionar este problema.

Ejercicio 12: Un estacionamiento requiere determinar el cobro que debe aplicar a las personas que lo
utilizan. Considere que el cobro es con base en las horas que lo disponen y que las fracciones de hora se
toman como completas y realice un programa que permita determinar el cobro.
Ejercicio 13: Pinturas “La brocha gorda” requiere determinar cuánto cobrar por trabajos de pintura.
Considere que se cobra por m2 y realice un programa que le permita ir generando presupuestos para cada
cliente.

Ejercicio 14: Copia el siguiente programa en el entorno de desarrollo y guárdalo con el nombre
ejercicio14.py:

print('Pruebas de formatos de impresión')

print('--------------------------------\n')
# Inicializamos las variables
dato1 = 333
dato2 = 205.5
dato3 = 'hola'
# Pruebas
print(f'Entero en bases 10, 2 y 16 : {dato1} {dato1:b} {dato1:x}')
print(f'Entero alineado derecha (6 pos rell 0) : {dato1:06}')
print(f'Real sin formato : {dato2}')
print(f'Real con dos decimales : {dato2:.2f}')
print(f'Real alineado derecha (12 pos 0 decim) : {dato2:12.0f}')
print(f'Real alineado derecha (12 pos 2 decim) : {dato2:12.2f}')
print(f'Real con formato exponencial : {dato2:e}')
print(f'Cadena alin. izquierda (20 pos rell =) : {dato3:=<20}')
print(f'Cadena centrada (20 pos rell _) : {dato3:_^20}')
print(f'Cadena alin. derecha (20 pos rell .) : {dato3:.>20}')

Ejercicio 15: ¿Qué valor se almacena en las variables x e y al ejecutar cada una de estas sentencias?

a) y = 2

b) y = 1 / 2

c) y = 13 // 4

d) y = 13 % 4

e) x = 2 ** 4

f) x=x+y-3

Ejercicio 16: ¿Cuál es la diferencia más destacable entre un compilador y un intérprete? Nombra tres
lenguajes de programación compilados y tres más interpretados. Buscar la información por Internet y
realizar la comparativa.

Ejercicio 17: Si estás en clase, vas a jugar con los compañeros. Forma un grupo de dos a cuatro personas
y toma el código de un ejercicio ejercicio17.py. Mientras una persona no mira, el resto añade un error al
programa. La persona que no miraba debe encontrar dicho error. Si lo encuentra a simple vista suma dos
puntos, o si lo encuentra ejecutando el programa en el intérprete suma un punto, pero si no lo encuentra
será la persona que puso el error la que sume un punto.

Ejercicio 18: Observa el siguiente programa en Python que implementa el cálculo del área y el perímetro de
un círculo, dado un radio r, según las fórmulas área = π * r 2 y perímetro = 2 * π * r

PI = 3.1416
# Pedimos el radio
r = float( input('Introduce radio del círculo: ') )
# Calculamos el área y perímetro
a = PI * r * r
p = 2 * PI * r
# Damos los resultados
print('Área =', a)
print('Perímetro =', p)
a) ¿Qué variables son de entrada, qué variables son de salida, y cuáles auxiliares?
b) ¿Se pueden declarar constantes en Python, como por ejemplo PI?
c) ¿Por qué ponemos un conversor de tipo (“float”) delante de la entrada de datos (“input”)?
d) ¿Qué pasaría si no?

Ejercicio 19: Crea un programa llamado ejercicio19.py, que pida tres notas y calcule la media.

Ejercicio 20: Crea un programa llamado ejercicio20.py, que pida dos puntos del espacio bidimensional y
calcule el punto medio según la fórmula:

Sean los puntos a= (ax , ay) y b =(bx , by ) entonces m(a,b) =( (ax+bx)/2, (ay+by)/2)

Ejercicio 21:Se desea calcular la distancia recorrida (m) por un móvil que tiene velocidad constante (m/s)
durante un tiempo t (s), considerar que es un MRU (Movimiento Rectilíneo Uniforme).

# -*- coding: utf-8 -*-

# Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Ejercicio21: CALCULAR DISTANCIA.")
print("-------------------------------------------------------")
# Entradas print("Ingrese la velocidad y el tiempo de la unidad móvil")
# convirtiendo entrada a Entero
V = float( input("Velocidad: ") )
T = int( input("Tiempo: ") )
# Proceso
D = V*T
#Salida
print(D)
Ejercicio 22: Se necesita obtener el promedio simple de un estudiante a partir de sus tres notas parciales
N1, N2 y N3.

# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Ejercicio22: PROMEDIO DE 3 NOTAS.")
print("-------------------------------------------------------")
#Entradas
print("Ingrese las 3 notas del alumno N1 , N2, N3")
N1 = int( input("N1: "))
N2 = int( input("N2: "))
N3 = int( input("N3: "))
#Proceso
P = int( (N1+N2+N3)/3 )
#Salida
print("\nSalida: ")
print(P)
Ejercicio 23: Se necesita elaborar un algoritmo que solicite el número de respuestas correctas, incorrectas
y en blanco, correspondientes a postulantes, y muestre su puntaje final considerando que por cada
respuesta correcta tendrá 3 puntos, respuestas incorrectas tendrá -1 y respuestas en blanco tendrá 0.

# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Ejercicio23: PUNTAJE FINAL.")
print("-------------------------------------------------------")
#Entradas
print("Ingrese número de respuestas correctas: ")
RC = int( input())
print("Ingrese número de respuestas incorrectas: ")
RI = int( input())
print("Ingrese número de respuestas en blanco: ")
RB = int( input())
#Proceso
PCR = RC*3
PRI = RI*-1
PRB = RB*0
PF = PCR + PRI + PRB
#Salida
print("El puntaje total es:", PF)
Ejercicio 24: Elaborar un algoritmo que permita ingresar el número de partidos ganados, perdidos y
empatados, por ABC club en el torneo apertura, se debe de mostrar su puntaje total, teniendo en cuenta que
por cada partido ganado obtendrá 3 puntos, empatado 1 punto y perdido 0 puntos.

# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Ejercicio24: PUNTAJE TOTAL DE PARTIDOS.")
print("-------------------------------------------------------")
#Entradas
print("Ingrese número de partidos ganados")
PG = int( input())
print("Ingrese número de partidos empatados")
PE = int( input())
print("Ingrese número de partidos perdidos")
PP = int( input())
#Proceso
PPG = PG*3
PPE = PE*1
PPP = PP*0
PF = PPG + PPE + PPP
#Salida print("\nSALIDA: ")
print("-------------------------------------------------------")
print("Puntaje Final: ", PF)
Ejercicio 25:Elaborar un algoritmo que permita calcular el número de micro discos 3 .5 necesarios para
hacer una copia de seguridad, de la información almacenada en un disco cuya capacidad se conoce. Hay
que considerar que el disco duro está lleno de información, además expresado en gigabyte. Un micro disco
tiene 1.44 megabyte y un gigabyte es igual a 1,024 megabyte.

# -*- coding: utf-8 -*-

import math
#librería necesaria para usar funciones Matemáticas
#en este caso math.ceil(), que redondea un numero al Entero superior
#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Ejercicio25: NÚMERO DE MICRO DISCOS 3.5 NECESARIOS")
print("-------------------------------------------------------")
#Entradas
print("Ingrese GB: ")
GB = float( input())
#Proceso
MG = GB*1024
MD = MG/1.44
#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print(MD)
#En caso de Decimal Aproximar al siguiente entero
#Ya que la parte decimal debe ser almacenada en otro DISCO 3.5
print("Numero de Discos necesarios: ", math.ceil(MD))
Ejercicio 26: Se tiene los puntos A y B en el cuadrante positivo del plano cartesiano, elabore el algoritmo
que permita obtener la distancia entre A y B.

# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Ejercicio26: DISTANCIA ENTRE 2 PUNTOS A y B, en 2D.")
print("-------------------------------------------------------")
#Entradas
print("Ingrese coordenadas del Punto A: ")
AX = float(input("Ax: "))
AY = float(input("Ay: "))
print("Ingrese coordenadas del Punto B: ")
BX = float(input("Bx: "))
BY = float(input("By: "))
#Proceso
D = ( (AX-BX)**2 + (AY-BY)**2 )**0.5
#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("Resultado:", D)
Ejercicio 27: Elaborar un algoritmo que solicite 2 números y muestre el promedio de ambos.

# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Ejercicio27: PROMEDIO DE DOS NÚMEROS.")
print("-------------------------------------------------------")
#Entradas
print("Ingrese notas: ")
N1 = int( input("N1: "))
N2 = int( input("N2: "))
#Proceso
S = N1 + N2
P = S/2
#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("Promedio:", P)
Ejercicio 28: Construya un programa tal que, dado como datos la base y la altura de un rectángulo, calcule
el perímetro y la superficie de este.

# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Ejercicio28: CALCULAR PERÍMETRO Y SUPERFICIE DEL RECTÁNGULO")
print("-------------------------------------------------------")
#Entradas
print("Ingrese Base y Alto: ")
BASE = float( input("Base: "))
ALTO = float( input("Alto: "))
#Proceso
SUP = BASE*ALTO PER = 2*(BASE + ALTO)
#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("Superficie:", SUP)
print("Perímetro:", PER)
Ejercicio 29: Construya un programa que resuelva un problema que tiene una gasolinera. Los
dispensadores de esta registran lo que “surten” en galones, pero el precio de la gasolina está fijado en litros.
El programa debe calcular e imprimir lo que hay que cobrarle al cliente.

# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Ejercicio29: GASOLINERA.")
print("-------------------------------------------------------")
#Constantes
LITXG = 3.785
PRECIOXL = 4.50
#Entradas
consu = float( input("Ingresar consumo: "))
#Proceso
total = consu*LITXG*PRECIOXL
#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("Total:", total)

Ejercicio 30: Construya un programa tal que, dado como datos el radio y la altura de un cilindro, calcule e
imprima el área y su volumen.

# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("Ejercicio30: CALCULAR ÁREA Y VOLUMEN DEL CILINDRO.")
print("-------------------------------------------------------")
#Constantes
PI = 3.1416
#Entradas
print("Ingrese Radio y Alto: ")
radio = float( input("Radio: "))
alto = float ( input("Alto: "))
#Proceso
vol = PI * radio**2 * alto
are = 2*PI*radio*(radio + alto)
#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("Volumen:", vol) print("área:", are)
Ejercicio 31: Dado el radio de un círculo, calcule el volumen de la esfera correspondiente.

# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("ejercicio31: CALCULAR VOLUMEN DE LA ESFERA.")
print("-------------------------------------------------------")
#Constantes
PI = 3.1416
#Entradas
r = float( input("Ingrese Radio: "))
#Proceso
v = 4/3 * PI * r**3
#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("El volumen de la esfera es:", v)
Ejercicio 32: Calcular el perímetro de un triángulo equilátero, teniendo como dato de entrada la altura de
este triángulo.

# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("ejercicio32: PERÍMETRO TRIANGULO EQUILÁTERO.")
print("-------------------------------------------------------")
#Entradas
print("Ingrese altura del triángulo: ")
h = float( input())
#Proceso
p = 3*(2*h)/3**0.5
#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("El perímetro del triángulo será:", p)
Ejercicio 33:Si tengo una cantidad de soles, dar su equivalente en dólares y después en euros. Se sabe
que 1 dólar =3.25 soles y 1 euro=3.83 soles.

# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("ejercicio33: CAMBIOS DE SOLES a EUROS y DÓLARES")
print("-------------------------------------------------------")
#Constantes
EU = 3.84
DO = 2.28
#Entradas
print("Ingrese la cantidad de soles:")
s = float( input())
#Proceso
d = s/DO
e = s/EU
#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("En", s, "soles hay ", e, "euros")
print("En", s, "soles hay ", d, "dólares")
Ejercicio 34:Dado el tiempo en segundos y la distancia en metros de un móvil, ingresados por teclado,
calcule la velocidad correspondiente.

# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("ejercicio34: CALCULAR LA VELOCIDAD DE UN MÓVIL.")
print("-------------------------------------------------------")
#Entradas
print("Ingrese el tiempo en segundos:")
t = float( input())
print("Ingrese la distancia en metros:")
d = float( input())
#Proceso
v = d/t
#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("La velocidad es:", v, "m/s")
Ejercicio 35: Calcular el monto a pagar por un artículo si se tiene como datos de entrada la cantidad de
docenas que compra y el costo por unidad de este artículo.

# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("ejercicio35: CALCULAR MONTO A PAGAR.")
print("-------------------------------------------------------")
#Entradas
print("Ingrese costo unitario del artículo:")
c = float( input())
print("Ingrese el número de docenas:")
d = int( input())
#Proceso
p = d*12 * c
#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("El precio del artículo es:", p)
Ejercicio 36: Realice un diagrama de flujo que convierta millas a kilómetros. Se sabe que una milla equivale
a 1.609344 kilómetros.

# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("ejercicio36: Millas a Kilómetros.")
print("-------------------------------------------------------")
#Constantes
MI = 1.609344
#Entradas
print("Ingrese número de millas:")
m = float( input())
#Proceso
k = m*MI
#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print(m, "millas tiene", k, "kilómetros")
Ejercicio 37:Si se conoce la longitud de dos de los lados de un triángulo (b y c) y el ángulo entre ellos (alfa),
expresado en grados sexagesimales, la longitud del tercer lado (a) se calcula por la fórmula:

a2 = b2 + c2 – 2bc*cos(alfa)

# -*- coding: utf-8 -*-

#Librerias
import math
#Necearia para fórmulas matemáticas
#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("ejercicio37: CALCULAR EL TERCER LADO DEL TRIANGULO")
print("-------------------------------------------------------")
#Constantes
PI = 3.1416
#Entradas
print("Ingrese lados del triángulo:")
b = float( input("Lado b: "))
c = float( input("Lado c: "))
print("Ingrese el ángulo en grados sexagesimales:")
alfa = float( input())
#Proceso
#fórmula para calcular lado 'a' con alfa transformado
a = ( b**2 + c**2 - 2*b*c * math.cos( alfa*PI/180 ) )**0.50
#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("El lado a es:", a)
Ejercicio 38: Dado la velocidad de 2 cuerpos que se dirigen uno al encuentro de otro determinar el tiempo
de encuentro si la distancia que los separa inicialmente es “D”.

# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("ejercicio38: TIEMPO DE ENCUENTRO.")
print("-------------------------------------------------------")
#Entradas
print("Ingrese las velocidades:")
va = float( input("Va: "))
vb = float( input("Vb: "))
print("Ingrese la distancia que los separa:")
D = float( input())
#Proceso
te = D/(va+vb)
#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("Los cuerpos se encontraran en:", te, "segundos")
Ejercicio 39: Dado un ángulo en Radianes conviértalo a grados Sexagesimales y luego a Centesimales.

# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("ejercicio39: RADIANES a SEXAGESIMALES y CENTESIMALES")
print("-------------------------------------------------------")
#Constantes
PI = 3.1416
#Entradas
print("Ingrese ángulo en radianes:")
x = float( input())
#Proceso
sex = x*180/PI
cen = x*200/PI
#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("En sexagesimales es:", sex)
print("En centesimales es:", cen)
Ejercicio 40: Determine la distancia entre dos puntos en el espacio. (x1,y1, z1) y (x2, y2, z2)

# -*- coding: utf-8 -*-

#Decoración: Nombre del Algoritmo
print("-------------------------------------------------------")
print("ejercicio40: DISTANCIA DE DOS PUNTOS en 3D.")
print("-------------------------------------------------------")
#Entradas
print("Ingrese valores del punto A(x1, y1 y z1): ")
x1 = float( input("x1: "))
y1 = float( input("y1: "))
z1 = float( input("z1: "))
print("Ingrese valores del punto B(x2, y2 y z2): ")
x2 = float( input("x2: "))
y2 = float( input("y2: "))
z2 = float( input("z2: "))
#Proceso
dis = ( (z2-z1)**2 + (y2-y1)**2 + (x2-x1)**2 )**0.5
#Salida
print("\nSALIDA: ")
print("-------------------------------------------------------")
print("La distancia es:", dis)
Ejercicio 41: Escribir un programa que seleccione la cadena “analista” a partir de la cadena: “Ana es buena
analista de datos.”. Mostrar el resultado por pantalla.

# Respuesta
frase = "Ana es buena analista de datos."
palabra = frase[12:21]
print(palabra)

Ejercicio 42: Qué expresión en Python necesitamos para conseguir el string “nohtyPythonython” utilizando
sólo la palabra “Python”?

Como podemos ver, para construir la cadena de texto necesitamos dos bloques diferenciados:

• la sub-cadena _ “nothyP” _ que corresponde a la palabra Python en orden inverso

• la sub-cadena _ “ython” _ repetida 2 veces

Podemos crear estos bloques de forma separada y al final concatenarlos para obtener el resultado final.

# Respuesta
# Primero definimos nuestra cadena base
python = "Python"
# Accedemos a los caracteres de Python en orden inverso
bloque1 = python[::-1]
# Accedemos a los 5 caracteres finales y los repetimos 2 veces
bloque2 = 2* python[1:]
# Finalmente, concatenar los bloques anteriores
resultado = bloque1 + bloque2
print (resultado)

Ejercicio 43: Escribe un programa que asigne dos valores enteros cualquiera (elije un número entero
aleatorio) a dos variables con nombre a y b. Utiliza las variables de obtenidas anteriormente para evaluar la
siguiente expresión matemática:

(a2 +b 2)
2
# Elegimos dos números enteros al azar
a = 6
b = 5
# Calculamos los cuadrados de las variables anteriores utilizando el operador **
cuadrado_a = a ** 2
cuadrado_b = b ** 2
# Calculamos la suma de los cuadrados
suma_cuadrados = cuadrado_a + cuadrado_b
# Finalmente, calculamos el cuadrado de la suma
resultado = suma_cuadrados ** 2
print(resultado)
# También podemos escribir esta misma expresión en una sóla línea
resultado = (a**2 + b**2)**2
print(resultado)
Ejercicio 44: Escribir un programa que calcule el volumen de una pirámide cuadrangular con una base de
4x5 metros de longitud y anchura respectivamente, y con una altura de 7,5 m. Recuerda que la fórmula para
1
calcular el volumen es: V = ⋅l⋅w⋅h
3
donde l y w son la longitud y la anchura de la base, y h es la altura.

# Respuesta
# Asignamos los valores del radio y la altura
base_long = 4
base_anchura = 5
altura = 7.5
# A continuación calculamos el volumen utilizando la siguiente fórmula:
volumen = 1/3 * base_long * base_anchura* altura
print('El volumen de la pirámide es de ', volumen, 'metros cúbicos.')
Ejercicio 45: Escribe un programa que defina una lista con el nombre de todos los meses del año. Haz que
muestre los meses que corresponden a otoño.

# Definimos la lista con los meses del año

meses = ["Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "Julio","Agosto", "Septiembre", "Octubre",
"Noviembre", "Diciembre"]
# Los meses correspondientes a otoño son los meses 9, 10 y 11
print (meses[8:11])
Fijaros que en Python el primer elemento de una lista o array lo encontraremos en la posición 0. Por lo
tanto, si queremos acceder al noveno elemento de la lista utilizaremos el índice 8, es decir, escribiremos
meses [8].

Por otra parte, cuando especificamos un rango, 8: 11, el elemento final no se incluye en el resultado final. Es
decir, meses [08:11] devolverá los elementos correspondientes a las posiciones 8, 9 y 10.

Ejercicio 46: Escribe un programa que a partir de la lista de números dada muestre por pantalla una
cadena de caracteres con todos los números, separados entre sí por un guion, y duplicando el primero y el
último elemento de la lista.

Así, por ejemplo, para la lista [‘1’, ‘2’, ‘3’] , el programa debería mostrar la cadena: ‘1-1-2-3-3’.

# Definimos la lista de números de entrada

numeros = ['6', '3', '45', '23', '2', '3', '17', '80']
# Respuesta
numeros = [numeros[0]] + numeros + [numeros[-1]]
print('-'.join(numeros))

Ejercicio 47: Ordena la siguiente lista de cadenas de caracteres:

1. Invirtiendo el orden original

2. En orden alfabético inverso

Nota: Puedes consultar la documentación oficial de la función [ sorted ()]

(https://docs.python.org/3/library/functions.html#sorted) para ver qué parámetros puedes utilizar para
resolver la segunda parte de la actividad.

st_chars = ["Benjamin Sisko", "Kira Nerys", "Odo", "Quark", "Jadzia Dax"]

# Hemos visto el uso de los dos puntos (":") para acceder a múltiples elementos
#de una lista.
# Python trata la expresión de la siguiente manera:
# - Si no hay ningún índice antes del primer ":" asume que debe comenzar por el
# principio de la lista.
# - Si no hay ningún índice tras el primer ":" asume que debe posicionarse al
final de la lista.
# - El último número nos indica los incrementos en el índice que se deben hacer
a medida que recorremos la lista.
# (En este caso siempre "sumamos" -1 al índice y por lo tanto, obtenemos -1, -2,
-3, etc.)
print(st_chars[::-1])

Para el siguiente ejercicio, buscamos la documentación de la función sorted () y vemos que esta nos sirve
para ordenar cualquier secuencia (lista, tupla) y devuelverá una lista con los elementos de manera
ordenada, sin modificar la secuencia original. El parámetro reverse predeterminado se establece como falso,
pero si lo establecemos como True, entonces el Iterable ordenaría en orden inverso (descendente):

print(sorted(st_chars, reverse=True))

Ejercicio 48: A partir de la siguiente lista, proporciona expresiones que retornen:

A_list = [42, 7.5, "Answer to the Ultimate Question", "Dave", 7.5]

1. El número de veces que aparece el elemento 7.5 en la lista.

2. La posición de la primera aparición del valor 7.5.
3. La misma lista sin el último elemento.

Para hacer la actividad, necesitaréis investigar algunas operaciones adicionales que podemos realizar sobre
listas. Para ello podéis consultar la documentación oficial de Python sobre listas (intro y más sobre listas).

a_list = [42, 7.5, "Answer to the Ultimate Question", "Dave", 7.5]

# El método count () cuenta cuántas veces aparece un valor en una lista y lo
devuelve.
print (a_list.count (7.5))
# Utilizaremos el método index (), éste encuentra el valor dado en una lista y
devuelve la posición del elemento.
# Si el mismo valor aparece más de una vez, el método index() devuelve la
posición de su primera aparición.
print (a_list.index (7.5))
# Indicamos que queremos excluir el último elemento indexado de la lista usando
el operador
print (a_list [: - 1])

Ejercicio 49: ¿Qué expresión en Python necesitamos para conseguir la string Learning Python utilizando
sólo las variables str1 y str2 definidas?

str1 = "I love Python, it's great!"

str2 = "Learning"

Como podemos ver, para construir la cadena de texto necesitamos aislar la sub-cadena “Python”, que
encontramos en la tercera palabra de la cadena str1 y corresponde con los caracteres 7 a 13 de la cadena.
Podremos crear esta nueva cadena de forma separada y luego concatenarla con la cadena str2 utilizando el
operador +:

# Accedemos a los caracteres que nos interesan de la cadena str1, incluyendo el

espacio previo a la palabra 'Python'
subcadena = str1 [6:13]
# Finalmente, concatenamos la nueva cadena (subcadena 'Python') y la
concatenamos con str2
resultat = str2 + subcadena
# Mostramos el resultado
print (resultat)
# También podemos añadir el espacio en blanco entre palabras al unilas, cuidado
con no añadir dos espacios en blanco:
subcadena = str1 [7:13]
resultado = str2 + ' ' + subcadena
print (resultado)

Ejercicio 50: El codigo que se presenta a continuación no funciona, corrige el error y explica por qué
sucede.

name = "Alex"
age = 20
print("Hello, my name is %d and I'm %d years old!" % (name, age))

# Respuesta
name = "Alex"
age = 20
print("Hello, my name is %s and I'm %d years old!" % (name, age))

Respuesta

Para poder utilizar esta funcionalidad, debe haber una concordancia entre el tipo de la variable que
queremos sustituir y la expresión utilizada. Es decir, si queremos sustituir un string, debemos utilizar la
expresión %s que indica que el elemento que queremos referenciar es también un string.

Si utilizamos %d y el contenido es string, Python devolverá un mensaje de error, ya que hay una
discrepancia en cuanto al tipo de variable.

Ejercicio 51:En este ejercicio utilizaremos la frase: “La paciencia es la madre de la ciencia.”

a) Extrae las palabras paciencia y ciencia de la cadena de strings definida anteriormente.

b) Crea la palabra ciencia a partir de paciencia, y la palabra paciencia a partir de ciencia.
c) Separa la frase en las diferentes palabras que la forman (e.g. “La”, “paciencia,” es ”, etc). ¿Cuál es
el separador que debemos usar?
d) Vuelve a unir los elementos de la frase mediante “-” (e.g. “La-paciencia-es …”).
# Respuesta
# Creamos la frase del enunciado
frase = "La paciencia es la madre de la ciencia"
# a)
# Seleccionamos los elementos necesarios para obtener las palabras paciencia y
ciencia
palabra1 = frase[3:13]
palabra2 = frase[-7:]
# Mostramos el resultado por pantalla
print("La primera palabra es:",palabra1)
print("La segunda palabra es:",palabra2)

# b)
# Creamos la palabra ciencia a partir de paciencia
palabra3 = palabra1[2:]
# Creamos la palabra ciencia a partir de paciencia
palabra4 = 'pa'+ palabra2
# Mostramos el resultado por pantalla
print("La tercera palabra es:",palabra3)
print("La quarta palabra es:",palabra4)

# c)
# Separamos las palabras utilizando el separador " "
frase_mod = frase.split(' ')
# Mostramos el resultado por pantalla
print("La frase separada por sus elementos es:",frase_mod)

# d)
# Especificamos el separador
s = "-"
# Utilizamos la función join para unir los elementos de la lista
frase_joined = s.join(frase_mod)
# Mostramos el resultado por pantalla
print("La frase con el nuevo separador es:",frase_joined)