Ingrese una cadena que represente el nombre de la forma geométrica y luego ingrese los datos de esta forma en una línea. Seleccione la fórmula apropiada para calcular el área (tabla) y el volumen de la forma geométrica en función de la cadena que representa el nombre. es una figura bidimensional, solo calcule el área, si es una figura tridimensional, calcule su área de superficie y volumen, y mantenga estrictamente el resultado con 2 decimales.
El programa de plantilla proporciona los códigos para rectángulos y cuboides. Consulte estos códigos para completar los procedimientos de cálculo para las cinco formas de círculos, esferas, cilindros, conos y prismas triangulares regulares.
(Puede copiar el código en la plantilla localmente, comentar las funciones que deben complementarse con código o agregar una declaración de paso en el cuerpo de la función antes de ejecutarla. Una vez completada la depuración, cópiela y péguela en el cuadro de código)
Ejemplo 1
输入：
长方形
4 8
输出：
长方形的面积为32.00
Ejemplo 2
输入：
长方体
4 8 9
输出：
长方体的表面积为280.00, 体积为288.00
Ejemplo 3
输入：
圆形
88
输出：
圆形的面积为24328.49
Ejemplo 4
输入：
球
88
输出：
球的表面积为97313.97, 体积为2854543.24
Ejemplo 5
输入：
圆柱体
88 88
输出：
圆柱体的表面积为97313.97, 体积为2140907.43
Ejemplo 6
输入：
圆锥
88 88
输出：
圆锥的表面积为58734.18, 体积为713635.81
Ejemplo 7
输入：
正三棱柱
88 88
输出：
正三棱柱的表面积为29938.50, 体积为295086.03 import math
def type_judge(geom_type):
"""接收一个字符串为参数，根据参数判断几何体类型
若输入为二维图形，计算其面积
若输入为三维图形，计算其面积与体积
根据类型调用不同的函数进行运算。
"""
if geom_type == '长方形':
length, width = map(float, input().split()) # 空格分隔的输入切分为列表并映射为浮点数
return square(length, width) # 调用函数计算长方形面积
elif geom_type == '长方体':
length, width, height = map(float, input().split()) # 空格分隔的输入切分为列表并映射为浮点数
return cube(length, width, height) # 调用函数计算长方体表面积与体积
elif geom_type == '圆形':
radius = float(input()) # 输入转为浮点数
return circle(radius) # 调用函数计算圆面积
elif geom_type == '球':
radius = float(input()) # 输入转为浮点数
return sphere(radius) # 调用函数计算球表面积与体积
elif geom_type == '圆柱体':
radius, height = map(float, input().split()) # 空格分隔的输入切分为列表并映射为浮点数
return cylinder(radius, height) # 调用函数计算圆柱体表面积与体积
elif geom_type == '圆锥':
radius, height = map(float, input().split()) # 空格分隔的输入切分为列表并映射为浮点数
return cone(radius, height) # 调用函数计算圆锥表面积与体积
elif geom_type == '正三棱柱':
side, height = map(float, input().split())
return tri_prism(side, height)
else:
return f'未找到{geom_type}计算方法'
def square(length, width):
"""计算长方形的面积"""
area_of_square = length * width
return f'长方形的面积为{area_of_square:.2f}'
def cube(length, width, height):
"""计算长方体的表面积和体积"""
area_of_cube = length * width * 2 + width * height * 2 + length * height * 2
volume_of_cube = length * width * height
return f'长方体的表面积为{area_of_cube:.2f}, 体积为{volume_of_cube:.2f}'
def circle(radius):
"""接收圆的半径，返回圆形的面积，圆周率用math.pi"""
area_of_circle = math.pi * math.pow(radius, 2)
return f'圆形的面积为{area_of_circle:.2f}'
def sphere(radius):
"""接收球的半径，返回球的表面积和体积，圆周率用math.pi"""
area_of_sphere = 4*math.pi*math.pow(radius, 2)
volume_of_sphere = math.pi*math.pow(radius, 3)*4/3
return f'球的表面积为{area_of_sphere:.2f}, 体积为{volume_of_sphere:.2f}'
def cylinder(radius, height):
"""接收圆柱体的底面半径和高，返回圆柱体的表面积和体积，圆周率用math.pi"""
area_of_cylinder = 2*math.pi*radius*(radius+height)
volume_of_cylinder = math.pi*radius*radius*height
return f'圆柱体的表面积为{area_of_cylinder:.2f}, 体积为{volume_of_cylinder:.2f}'
def cone(radius, height):
"""接收圆锥的底面半径和高，返回圆锥的表面积和体积，圆周率用math.pi"""
area_of_cone = math.pi*radius * \
(radius+math.sqrt(math.pow(radius, 2)+math.pow(height, 2)))
volume_of_cone = math.pi*math.pow(radius, 2)*height/3
return f'圆锥的表面积为{area_of_cone:.2f}, 体积为{volume_of_cone:.2f}'
# 参考前面的方法自定义一个函数计算正三棱柱的表面积与体积，
# 函数名为tri_prism()
# 函数接受底边长和高两个参数side, height
def tri_prism(side, height):
"""接收正三棱柱的底边长和高，返回正三棱柱的表面积和体积"""
area_of_tri_prism = math.sqrt(3)*math.pow(side, 2)/2+3*side*height
volume_of_tri_prism = math.sqrt(3)*math.pow(side, 2)*height/4
return f'正三棱柱的表面积为{area_of_tri_prism:.2f}, 体积为{volume_of_tri_prism:.2f}'
if __name__ == '__main__':
type_of_geometry = input() # 接收用户输入的字符串
geometry = type_judge(type_of_geometry) # 调用判断图形类型的函数
print(geometry) # 输出函数运行结果
Este código es una calculadora de geometría simple. Se calcula recibiendo el tipo de geometría ingresado por el usuario y luego llamando a diferentes funciones según los diferentes tipos.
Primero, se define una función type_judge(), que se utiliza para seleccionar la función correspondiente para el cálculo según el tipo de geometría. Entre ellos, para rectángulos y círculos cuya entrada son gráficos bidimensionales, llame a las funciones cuadrado() y círculo() para calcular sus áreas; para cuboides, esferas, cilindros, conos y prismas triangulares regulares cuya entrada son gráficos tridimensionales, llame a cube() Las funciones, esfera(), cilindro(), cono() y tri_prism() calculan su área de superficie y volumen.
A continuación se definen las funciones de cálculo para cada geometría, incluyendo:
- cuadrado(): Calcula el área de un rectángulo
- cubo(): Calcula el área de superficie y el volumen de un cuboide
- circulo(): Calcula el área de un círculo
- esfera(): Calcula el área de superficie y el volumen de la esfera
- cilindro(): Calcula el área de superficie y el volumen de un cilindro
- cono(): Calcula el área de superficie y el volumen de un cono
- tri_prism(): Calcula el área de superficie y el volumen de un prisma triangular regular
Cada función acepta algunos parámetros, realiza los cálculos correspondientes y devuelve una cadena que contiene los resultados del cálculo y tiene una precisión de dos decimales.
Finalmente, en el programa principal, primero se recibe el tipo de geometría ingresado por el usuario, luego se llama a la función type_judge() para realizar los cálculos y se imprimen los resultados del cálculo.
map() es una función de orden superior incorporada en Python que se utiliza para aplicar cada elemento en un objeto iterable a la función especificada y devolver un iterador compuesto por los resultados. Su formato de sintaxis básica es el siguiente:
map(function, iterable, ...)
Entre ellos, la función es una función e iterable es un objeto iterable. Se pueden pasar varios objetos iterables, lo que indica que es necesario pasar varios parámetros a la función. La función map() pasará cada elemento del iterable a la función para su procesamiento por turno y devolverá un iterador compuesto por los resultados del procesamiento.
Por ejemplo, para elevar al cuadrado cada elemento de una lista, puedes utilizar el siguiente código:
lst = [1, 2, 3, 4, 5]
result = map(lambda x: x ** 2, lst)
print(list(result)) # 输出 [1, 4, 9, 16, 25]
Aquí se usa una expresión lambda para definir una función cuadrada simple, y luego cada elemento de la primera lista se pasa a la función para el cálculo, y el resultado se forma en un iterador y finalmente se convierte en lista y salida.
La función map() se puede aplicar fácilmente a muchos escenarios, como el procesamiento por lotes de datos, funciones de mapeo, etc.
A = mapa(flotante, entrada().split())
Este código divide la cadena obtenida por la entrada del usuario en espacios, luego usa la función map() para convertir cada cadena dividida en un tipo de número de punto flotante y devuelve un iterador compuesto por números de punto flotante. Finalmente, asigne este iterador a la variable A.
En concreto, el proceso de ejecución de este código es el siguiente:
- La función input() recibe la entrada del usuario y devuelve un valor de cadena.
- El método split() divide la cadena según espacios y devuelve una lista que consta de las cadenas divididas.
- La función map() convierte cada elemento de la lista utilizando la función float() y devuelve un iterador que consta de los números de coma flotante convertidos.
- Asigne este iterador a la variable A.