CUESTIONARIO CAPITULO 7: OBJETOS Y CLASES

7.1 Describa la relación entre un objeto y su definición de clase.

Una clase es una plantilla o un plano de un objeto. Puedes definir muchos objetos usando
esa clase
La clase define las propiedades y comportamientos o acciones de sus objetos. Las
propiedades son variables o sus campos de datos con nombre y los comportamientos o
acciones son métodos a los que se puede llamar usando objetos. Los objetos también se
llaman instancias de la clase.
7.2 ¿Cómo se define una clase?
Podemos definir una clase por palabra clave "clase" y luego darle un nombre y luego
definir su inicializador o constructor, que es un método especial que construye el objeto
una vez que lo creó. El método de inicialización siempre tiene el nombre "_ _init_ _" y
debe comenzar y terminar con dos guiones bajos. el _ _init_ _ (self) debe tomar al menos
un parámetro que se llama "self". Luego tienes que definir las variables de datos de clase
(propiedades) y métodos (acciones).
7.3 ¿Cómo se crea un objeto?
Los objetos se pueden definir de dos maneras:
Primero, la forma explícita común. define una variable para mantener ese objeto (que en
realidad es una variable que contiene una referencia a ese objeto). por ejemplo: c = círculo
(4) c es una variable que almacena una referencia a un objeto Círculo. y ese objeto se
inicializa con 4.
La segunda forma es definir un objeto de forma anónima:
objeto anónimo es un objeto definido sin declarar una variable para contener una
referencia a él
Ejemplo:
impresión (Círculo (4))
7.4 ¿Cuál es el nombre del método de inicialización?
El método de inicialización puede definirse como _ _init_ _ y debe tomar al menos un
parámetro "self" parámetro
Ejemplo:
def _ _init_ _ (self):
alguna operación puede definir las variables de datos y darles un valor predeterminado
dentro del método initailizer
def _ _init_ _ (self, name = "norhan"):
self.name = name
Por lo tanto, ahora el método de inicialización define dos parámetros: uno mismo
(obligatorio y obligatorio de definir) y nombre de la variable de datos.
(self.name = name) significa que este nombre de objeto es el nombre que da cuando
definió el objeto
aquí si definió su objeto sin dar un nombre, el método de inicialización le dará el valor
predeterminado norhan
7.5 El primer parámetro en el método de inicialización se denomina self por convención.
¿Cuál es el papel de self?
Una vez que haya creado una clase, puede definir muchos objetos a partir de ella.
Entonces, ¿cómo Python realiza un seguimiento de estos objetos en la memoria?
usando la palabra clave "self".
Ejemplo:
rectángulo de clase:
def _ _init_ _ (self, width = 4, height = 3):
self.width = ancho
self.height = altura

================================================== ===============
Esta es una clase que define un rectángulo con el ancho predeterminado = 4 y la altura = 3
Permite definir objetos:
r1 = Rectángulo ()
r2 = Rectángulo (6,7)
r3 = Rectángulo (10,4)
================================================== ===============
auto será reemplazado por nombres de objetos
================================================== ===============
la implementación de r1 será

def _ _init_ _ (r1, ancho = 4, ancho = 3):

r1.width = 4
r2.width = 3
================================================== ==============
implementación de r2
def _ _init_ _ (r2, ancho = 6, altura = 7)
r2.width = 6
r2.height = 7
7.6 ¿Cuál es la sintaxis para construir un objeto? ¿Qué hace Python al construir un objeto?

7.7 ¿Cuáles son las diferencias entre un inicializador y un método?

Los inicializadores se llaman de forma predeterminada cuando se crea una instancia de un
objeto de una clase, mientras que la función principal invoca el método de una clase
siempre que sea necesario.
7.8 ¿Para qué es el operador de acceso a componente de objeto?
Los miembros del objeto son campos de datos y métodos. Para acceder a los campos de
datos de un objeto e invocar los métodos de un objeto, debe asignar el objeto a una
variable utilizando la siguiente sintaxis: objectRefVar = ClassName (argumentos). Luego,
puede acceder a los miembros del objeto mediante el operador de acceso miembro
(también denominado operador de punto) (.). Puede usar los campos
objectRefVarName.data o objectRefVarName.method
7.9 ¿Qué problema surge al ejecutar el siguiente programa? ¿Cómo lo arreglas?

class A:
def __init__(self, i):
 self.i = i

def main():
a = A()
print(a.i)

main() # Llamada a la función principal

7.10 ¿Qué está mal en los siguientes programas?

1 class A:
2 # Construye un objeto de la clase
3 def A(self):
4 radius = 3

1 class A:
2 # Construye un objeto de la clase
3 def __init__(self):
4 radius = 3
5
6 def setRadius(radius):
7 self.radius = radius

7.11 Muestra la salida del siguiente programa:

class Count:
def __init__(self, count = 0):
self.count = count
def main():
c = Count()
times = 0
for i in range(100):
increment(c, times)
print("count is", c.count)
print("times is", times)

def increment(c, times):

c.count += 1
times += 1

main() # Llamada a la función principal

7.12 Muestra la salida del siguiente programa:

class Count:
def __init__(self, count = 0):
self.count = count
def main():
c = Count()
n = 1
m(c, n)

print("count is", c.count)

print("n is", n)

def m(c, n):

c = Count(5)
n = 3

main() # Llamada a la función principal

7.13 ¿Qué problema surge al ejecutar el siguiente programa? ¿Cómo lo arreglas?

class A:
def __init__(self, i):
self.__i = i

def main():
a = A(5)
print(a.__i)

main() # Llamada a la función principal

7.14 ¿Es correcto el siguiente código? Si es así, ¿qué visualiza en pantalla?

1 def main():
2 a = A()
3 a.print()
4
5 class A:
6 def __init__(self, newS = "Bienvenido"):
7 self.__s = newS
8
9 def print(self):
10 print(self.__s)
11
12 main() # Llamada a la función principal

7.15 ¿Es correcto el siguiente código? Si no, arregla el error.

class A:
def __init__(self, on):
self.__on = not on
def main():
a = A(False)
print(a.on)
main() # Llamada a la función principal

respuesta:
La variable miembro de la clase se declara privada. Cambie su tipo a público para que
pueda llamarse desde la función principal.
7.16 ¿Cuáles son los beneficios de la ocultación de datos? ¿Cómo se hace en Python?
El principal beneficio de la ocultación de datos es evitar modificaciones directas de los
campos de datos por parte del cliente. Esto se puede hacer definiendo campos de datos
privados. En Python, los campos de datos privados se definen con dos guiones bajos.
7.17 ¿Cómo se define un método privado?
Definimos los campos de datos privados colocando dos guiones bajos antes de la variable.
7.18 Describa las diferencias entre paradigmas de procedimiento y orientados a objetos.