8. Con respecto a los atributos, la siguiente declaración es correcta ().
A. Los miembros de datos también se denominan atributos y se dividen en atributos públicos y atributos privados.
B. Para no destruir la encapsulación de la clase, puede usar el decorador @property para acceder a propiedades privadas y verificar las propiedades.
C. @property decorator es una propiedad especial, que es responsable de llamar un método a una propiedad.
D. Setter Este decorador permite la asignación a propiedades (funciones) decoradas con @property, pero el decorador setter debe estar detrás de la propiedad y los nombres de las dos propiedades decoradas (funciones) deben ser las mismas.
9. Juicio: a los miembros privados no se puede acceder directamente desde fuera de la clase, y generalmente se accede y se opera dentro de la clase. De manera especial, "nombre de objeto._ nombre de clase __xxx" también puede acceder a miembros privados en programas externos, pero esto destruirá la encapsulación de la clase y no se recomienda.
Respuesta: sí
10. Diseñe una calculadora simple para el pago mensual de la hipoteca de los compradores de viviendas, y calcule el interés total y el monto de reembolso mensual de acuerdo con la siguiente fórmula:
Interés total = monto del préstamo * tasa de interés
Monto de reembolso mensual = (monto del préstamo + interés total) /
período de préstamo Los diferentes períodos de préstamo tienen diferentes tasas de interés. Aquí, solo hay tres tipos de años y tasas de interés como se muestra en la siguiente tabla.
Tasa de interés
anual 3 años (36 meses) 6.03%
5 años (60 meses) 6.12%
20 años (240 meses) 4.39%
class LoanCaculator():
def __init__(self, loan, time):
self.loan = loan
if time == "1":
self.time = 3
elif time == "2":
self.time = 5
elif time == "3":
self.time = 20
def get_total_interests(self):
return self.loan * self.get_interests_rate()
def get_interests_rate(self):
if self.time == 3:
return 0.0603
elif self.time == 5:
return 0.0612
elif self.time == 20:
return 0.0639
def get_monthly_payment(self):
return (self.loan + self.get_total_interests())/ (self.time * 12)
loan = int(input("请输入贷款金额："))
time = input("请选择贷款年限：1.3年（36个月） 2.5年（60个月） 3.20年（240个月）")
loan_caculate = LoanCaculator(loan, time)
print("月供为: %f" % loan_caculate.get_monthly_payment())
Resultado de la operación:
Ingrese el monto del préstamo: 10000
Seleccione el período del préstamo: 1.3 años (36 meses) 2.5 años (60 meses)
3.20 años (240 meses) Oferta de marzo : 44.329167
11. Diseñe las clases Bird y fish, ambas heredadas de la clase Animal, implemente su método print_info (), información de salida.
class Animal():
def __init__(self,age):
self.age = age
def print_info(self):
print("我今年%d岁了！" % (self.age))
class Bird(Animal):
def __init__(self, color):
super().__init__(4)
self.color = color
def print_info(self):
print("我是一只%s的鸟" % (self.color))
super().print_info()
class Fish(Animal):
def __init__(self, weight):
super().__init__(2)
self.weight = weight
def print_info(self):
print("我是一只%d斤重的鱼" % (self.weight))
super().print_info()
bird = Bird("红色")
bird.print_info()
fish =Fish(5)
fish.print_info()
Resultado:
¡soy un pájaro rojo,
tengo 4 años este año!
Soy un pez con un peso de 5 kg. ¡
Tengo 2 años este año!
12. Utilice el polimorfismo para crear mediante programación una clase de teléfono Teléfonos y definir el método de llamada call (). Cree dos subclases: Apple phone class iPhone y Android phone class APhone, y anule la llamada al método en sus respectivas clases. Cree una persona humana y defina el método para llamar usando un teléfono use_phone_call ()
class Phone():
def call(self):
print("使用功能机打电话")
class IPhone(Phone):
def call(self):
print("使用苹果手机打电话")
class APhone(Phone):
def call(self):
print("使用安卓手机打电话")
class Person():
def use_phone_call(self, phone):
phone.call()
person = Person()
person.use_phone_call(Phone())
person.use_phone_call(IPhone())
person.use_phone_call(APhone())
Resultado de la operación:
usar un teléfono con función para hacer una llamada
usando un teléfono móvil de Apple para hacer una llamada
usando un teléfono móvil con Android
3 juego PUBG
(1) Defina las variables del jugador: nombre, sangre (salud), arma (arma) métodos: armas de equipo, ataque (2) defina la clase de arma variables de arma: tipo_arma (tipo de arma), letal (letal) (3) Atacar al enemigo crea jugadores y objetos enemigos e inicializa los atributos. Después de crear el objeto arma, el objeto jugador está equipado con armas. El jugador llama al método de ataque para atacar. La
respuesta correcta:
class Player():
def __init__(self, name):
self.name = name
self.blood = 100
self.weapon = None
print("创建名为%s的玩家对象" % (self.name))
def armed(self, weapon):
self.weapon = weapon
print("%s装备了杀伤力为%d点的%s" % (self.name, weapon.lethal, weapon.weapon_type))
def attack(self,target):
target.blood -= self.weapon.lethal
print("%s使用%s攻击%s,造成%d点伤害" % (self.name, self.weapon.weapon_type, target.name, self.weapon.lethal ))
print("%s还剩%d点血" % (target.name, target.blood))
class Weapon():
def __init__(self, weapon_type, lethal):
self.lethal = lethal
self.weapon_type = weapon_type
player = Player("大漠雄鹰")
enemy = Player("大反派")
player.armed(Weapon("平底锅", 5))
player.attack(enemy)
player.attack(enemy)
player.attack(enemy)
4 Definir una clase de estudiante (Estudiante)
, Requisitos: (1) Inicializar miembro de datos miembro de datos ( Sno, Sname, Sage); (2) Definir miembro de datos (Sno, Sname, Sage) a través del decorador de atributos;
(3) Definir método especial __str (self), el El método devuelve: Tal cadena "Mi nombre es Zhang San, el número de estudiante es 1101, la edad es 33, es un estudiante", donde Zhang San, 1101, 33, de acuerdo con la entrada del usuario para mostrar. ";
(4) la definición de una clase graduada por herencia (Gra_student), y aumentar los miembros de datos de la investigación ( investigación,)
(5) en la clase Gra_student, definir métodos especiales __str (Ser), el método devuelve: Mi nombre es Cuatro, La identificación del estudiante es 1102, la edad es 35, es un estudiante graduado, la dirección de investigación es una red compleja;
(6) llame a la clase del estudiante s = Estudiante ('zs', '1101', 23) y el método especial __str __ ( auto), modifique la edad del estudiante a 33, llame a __str __ (self) nuevamente; (7) llame a la clase de posgrado ga = Gra_student ('李四', '1102', 35, 'red compleja'), llame a __str __ (self) La
respuesta correcta:
class Student(object):
def __init__(self, Sname, Sno, Sage):
self.Sno = Sno
self.Sname = Sname
self.Sage = Sage
@property
def Sno(self):
return self._Sno
@Sno.setter
def Sno(self, sno):
self._Sno = sno
@property
def Sname(self):
return self._Sname
@Sname.setter
def Sname(self, sname):
self._Sname = sname
@property
def Sage(self):
return self._Sage
@Sage.setter
def Sage(self, sage):
self._Sage = sage
def __str__(self):
return '我叫%s,学号是%s,年龄为%s,是一名学生' % (str(self.Sname), str(self.Sno), str(self.Sage))
def run(self):
return '我叫%s,学号是%s,年龄为%s,是一名学生' % (str(self.Sname), str(self.Sno), str(self.Sage))
class Gra_student(Student):
def __init__(self, Sno, Sname, Sage, Skey):
super().__init__(Sno, Sname, Sage)
self.Skey = Skey
def __str__(self):
return '我叫%s,学号是%s,年龄为%s,是一名研究生' % (str(self.Sname), str(self.Sno), str(self.Sage))
5 Defina una clase de vector tridimensional y defina los métodos especiales correspondientes para implementar operaciones de suma y resta entre dos objetos de este tipo (requiere soporte para operadores +, -) e implementar operaciones de multiplicación y división de objetos de este tipo y escalares (requiere soporte Operadores *, /), y el cálculo de la longitud del vector (requiere el uso de atributos).
La respuesta correcta:
class Vector3:
#构造方法，初始化，定义向量坐标
def __init__(self, x, y, z):
self.__x = x
self.__y = y
self.__z = z
#与两一个向量相加，对应分量相加，返回新向量
def __add__(self, anotherPoint):
x = self.__x + anotherPoint.__x
y = self.__y + anotherPoint.__y
z = self.__z + anotherPoint.__z
return Vector3(x, y, z)
#减去另一个向量，对应分量相减，返回新向量
def __sub__(self, anotherPoint):
x = self.__x - anotherPoint.__x
y = self.__y - anotherPoint.__y
z = self.__z - anotherPoint.__z
return Vector3(x, y, z)
#向量与一个数字相乘，各分量乘以同一个数字，返回新向量
def __mul__(self, n):
x, y, z = self.__x*n, self.__y*n, self.__z*n
return Vector3(x, y, z)
#向量除以一个数字，各分量除以同一个数字，返回新向量
def __truediv__(self, n):
x, y, z = self.__x/n, self.__y/n, self.__z/n
return Vector3(x, y, z)
#查看向量长度，所有分量平方和的平方根
@property
def length(self):
return (self.__x**2 + self.__y**2 + self.__z**2)**0.5
def __str__(self):
return 'Vector3({},{},{})'.format(self.__x,self.__y,self.__z)
#用法演示
v1 = Vector3(3, 4, 5)
v2 = Vector3(5, 6, 7)
print(v1+v2)
print(v1-v2)
print(v1*3)
print(v2/2)
print(v1.length)
