Primeiro, a primeira compreensão da categoria
Uma classe é uma coleção de objetos com as mesmas propriedades e métodos.
Vejamos primeiro o seguinte exemplo:
>>> 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 os exemplos acima, faça algumas explicações de nome:
(1) Classe: um grupo de coisas semelhantes, correspondendo à classe acima (palavra-chave), Foo é o nome da classe
(2), objeto: as coisas na coleção, por Classe geração, correspondendo ao f
(3) acima, atributo: uma certa característica do objeto, correspondendo ao nome acima, idade, dinheiro
(4), método: uma certa capacidade dinâmica do objeto, correspondendo ao getname acima () , getmoney ()
Do exposto, podemos ver que a classe define uma classe Foo. Existem três métodos abaixo dela. Entre eles, init () é o método de construção, que será executado automaticamente quando o objeto é gerado, e getname e getmoney são métodos comuns que são chamados pelo objeto.
A classe Foo tem três valores de atributo (nome, idade, dinheiro), entre os quais nome e idade são valores de atributo comuns e __money é um valor de atributo privado. O valor de atributo comum pode ser chamado pelo objeto para obter o valor específico , embora o valor do atributo privado só possa ser Chamado na classe, o objeto não pode ser chamado, se você precisar obter o conteúdo do valor do atributo privado, pode definir um método como o acima para obter o atributo privado por meio do método de chamada de objeto .
Dois, o campo da classe
Os campos da classe incluem campos estáticos e campos comuns. Dentre eles, os campos estáticos são armazenados em classes e podem ser acessados por meio de objetos e classes, enquanto os campos comuns são armazenados em objetos e só podem ser acessados por meio de objetos.
O seguinte exemplo:
>>> 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'
>>>No exemplo acima, NAME é um campo estático e city é um campo normal. O campo estático NAME pode ser chamado por meio do objeto f e da classe Foo (como acima), enquanto o campo normal só pode ser chamado por meio do objeto f.
Três, o método da classe
Os métodos de classe são divididos em:
(1), métodos ordinários
(2), métodos estáticos
(3), os
cenários de aplicação dos métodos de classe são os seguintes:
(1) Se você precisar salvar alguns valores no objeto, chamando o método precisa chamar o valor no objeto, use o método Ordinário;
(2) Se o valor no objeto não for necessário, use o método estático;
(3) Se o nome da classe atual for necessário no método, use o método da classe ;
>>> 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'>
>>>Uma classe Foo é definida acima, que tem o método comum bar (), o método estático staticmethod (), staticmethod2 () e o método de classe class_method (), onde @staticmethod indica que o método é estático e @classmethod indica o método É um método de classe. Eles podem ser todos chamados por objeto e nome de classe. Entre eles, se você usar um nome de classe para chamar um método comum, você precisa passar o nome do objeto, chamar o método estático sem passar parâmetros e chamar o método de classe sem passar parâmetros .