Primero, la primera comprensión de la categoría
Una clase es una colección de objetos con las mismas propiedades y métodos.
Veamos primero el siguiente ejemplo:
>>> class Foo:
... def __init__(self, name, age):
... self.name = name
... self.age = age
... self.__money = 100
... def get_name(self):
... return self.name
... def get_money(self):
... return self.__money
...
>>> f = Foo("joker",18)
>>> print(f.get_name)
<bound method Foo.get_name of <__main__.Foo object at 0x000001F4B8339438>>
>>> print(f.get_name())
joker
>>> print(f.get_money())
100
>>> print(f.name)
joker
>>> print(f.age)
18
>>> print(f.__money)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Foo' object has no attribute '__money'
>>>Combinando los ejemplos anteriores, haga algunas explicaciones de nombres:
(1) Clase: un grupo de cosas similares, correspondientes a la clase anterior (palabra clave), Foo es el nombre de la clase
(2), objeto: las cosas en la colección, por Clase generación, correspondiente a la anterior f
(3), atributo: cierta característica del objeto, correspondiente al nombre anterior, edad, dinero
(4), método: cierta capacidad dinámica del objeto, correspondiente al getname anterior () , getmoney ()
De lo anterior, podemos ver que la clase define una clase Foo. Hay tres métodos debajo de ella. Entre ellos, init () es el método de construcción, que se ejecutará automáticamente cuando se genere el objeto, y getname y getmoney son métodos ordinarios a los que llama el objeto.
La clase Foo tiene tres valores de atributo (nombre, edad, dinero), entre los cuales el nombre y la edad son valores de atributo ordinarios, y __money es un valor de atributo privado. El objeto puede llamar al valor de atributo ordinario para obtener el valor específico , mientras que el valor del atributo privado solo se puede llamar en la clase, el objeto no se puede llamar, si necesita obtener el contenido del valor del atributo privado, puede definir un método como el anterior para obtener el atributo privado a través del método de llamada al objeto .
Dos, el campo de la clase
Los campos de la clase incluyen campos estáticos y campos ordinarios. Entre ellos, los campos estáticos se almacenan en clases y se puede acceder a ellos a través de objetos y clases, mientras que los campos ordinarios se almacenan en objetos y solo se puede acceder a ellos a través de objetos.
El siguiente ejemplo:
>>> class Foo:
... NAME = "中国"
... def __init__(self, city):
... self.city = city
...
>>> f = Foo("上海")
>>> print(f.NAME)
中国
>>> print(Foo.NAME)
中国
>>> print(f.city)
上海
>>> print(Foo.city)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: type object 'Foo' has no attribute 'city'
>>>En el ejemplo anterior, NAME es un campo estático y city es un campo normal. El campo estático NAME se puede llamar a través del objeto f y la clase Foo (como arriba), mientras que el campo normal solo se puede llamar a través del objeto f.
Tres, el método de la clase.
Los métodos de clase se dividen en:
(1), métodos ordinarios
(2), métodos estáticos
(3), los
escenarios de aplicación de los métodos de clase son los siguientes:
(1) Si necesita guardar algunos valores en el objeto, llame al el método necesita llamar al valor en el objeto, use el método Ordinary;
(2) Si el valor en el objeto no es necesario, use el método estático;
(3) Si el nombre de clase actual es necesario en el método, use el método de clase ;
>>> class Foo:
... def bar(self):
... print("bar")
... @staticmethod
... def static_method():
... print("static method")
... @staticmethod
... def static_method2(a,b):
... print(a,b)
... @classmethod
... def class_method(cls):
... print("class method",cls)
...
>>> f = Foo()
>>> f.bar()
bar
>>> Foo.bar(f)
bar
>>> f.static_method()
static method
>>> Foo.static_method()
static method
>>> Foo.static_method(1,2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: static_method() takes 0 positional arguments but 2 were given
>>> Foo.static_method2(1,2)
1 2
>>> Foo.class_method()
class method <class '__main__.Foo'>
>>>Una clase Foo se define arriba, que tiene un método ordinario bar (), método estático staticmethod (), staticmethod2 () y método de clase class_method (), donde @staticmethod indica que el método es un método estático, y @classmethod indica el método Es un método de clase. Todos se pueden llamar por objeto y nombre de clase. Entre ellos, si usa un nombre de clase para llamar a un método común, debe pasar el nombre del objeto, llamar al método estático sin pasar parámetros y llamar al método de clase sin pasar parámetros .