Um conceito chave da Programação Orientada a Objetos (OOP) é encapsular dados e operações sobre dados para formar um todo interdependente e indivisível , ou seja, Objeto. Após abstrair os objetos do mesmo tipo, as características comuns são obtidas para formar a classe Class.
A lista de tipos de dados embutidos, dicionários, tuplas, etc. são todas classes. Para aprender Python, você deve estar familiarizado com as classes. A partir de conceitos relacionados, vamos classificar as classes.
1 Propriedades e métodos
Classe é reunir os dados e os métodos de operação nos dados.Os dados nada mais são do que variáveis e os métodos de operação nos dados nada mais são do que funções. Esses dois são chamados coletivamente de membros de classe, enquanto as funções são chamadas de métodos de membro e as variáveis são chamadas de propriedades de membro .
2 atributos de instância e atributos de classe
Os atributos dos membros são divididos em atributos de instância e atributos de classe,
- Os atributos de instância geralmente se referem àqueles definidos no construtor __init__ e devem ser prefixados com self ao defini-lo e usá-lo
- Os atributos de classe são variáveis definidas fora de todos os métodos da classe. Os
atributos de instância são determinados pela instância. Diferentes instâncias podem ser diferentes atributos de instância; enquanto os atributos de classe são globais e os atributos de classe de cada instância são os mesmos; (instância atributos O relacionamento com os atributos de classe é como o relacionamento entre variáveis locais e variáveis globais)
class Car:
price = 10000 # 这是类属性， 定义在所有方法之外
def __init__(self, c):
self.color = c # 这是实例属性
Como os atributos de classe são globais, eles podem ser acessados por meio de classe, atributos e atributos de instância, enquanto os atributos de instância só podem ser acessados por meio de atributos de instância.
car1 = Car('red') #创建一个对象， 也叫做类的实例化 ，从人类 到具体的 “张三”
Car.price #类.属性访问
>>>10000
car1.price #实例.属性访问
>>>10000
Car.color
>>>AttributeError: type object 'Car' has no attribute 'color' # 实例属性不可以通过 类.属性 访问
car1.color
>>>'red'
isinstance(car1, Car) # 查看一个对象是否为某个类的实例
>>> True
Depois que a definição da classe for concluída, o python pode adicionar ou modificar membros dinamicamente, como segue
Car.company = "Volkswagen" # 增加成员属性
Car.price = 11111 # 修改成员属性
def setSpeed(self, s):
self.speed = s
import types
Car.setSpeed = types.MethodType(setSpeed, car1) # 增加成员方法
A diferença entre um método e uma função é que um método geralmente se refere a uma função relacionada a uma instância. Ao chamar um método, a própria instância será passada como o primeiro parâmetro. Portanto, ao adicionar um método membro, você deve chamar tipos .MethodType () para converter a função em um método. Em seguida, pode ser adicionado à classe.
Atributos
Atributos e métodos são variáveis, e o outro é uma função. Quando chamado, há um parêntese. O método também pode ser atribuído. Pode ser chamado sem parênteses
class Car:
price = 10000
def __init__(self, c):
self.color = c
def showcolor1(self):
return self.color
@property # 属性装饰器
def showcolor2(self):
return self.color
car = Car('red')
car.price # 访问属性
>>>10000
car.showcolor1() # 调用方法
>>>'red'
car.showcolor2 # 方法属性化
>>>'red'
métodos e atributos de visualização de dir (class_name) na classe, descrições de métodos de visualização de ajuda (class.method)
dir(car)
['__class__',
'__delattr__',
'__dict__',
'__dir__',
'__doc__',
'__eq__',
'__format__',
'__ge__',
'__getattribute__',
'__gt__',
'__hash__',
'__init__',
'__init_subclass__',
'__le__',
'__lt__',
'__module__',
'__ne__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__setattr__',
'__sizeof__',
'__str__',
'__subclasshook__',
'__weakref__',
'color',
'price',
'showcolor1',
'showcolor2']
3 membros públicos e privados
Para a confidencialidade dos dados, algumas variáveis precisam ser definidas como atributos privados, de modo que os métodos não possam ser acessados diretamente de fora da classe, ou seja, membros privados, o oposto são membros públicos.
- __x, aqueles que começam com sublinhados duplos em python são membros privados
- _x, um único sublinhado no início é um membro protegido, não pode ser importado usando import, apenas dentro da classe ou subclasses podem ser usadas
- x , aqueles com sublinhados em ambos os lados são membros especiais.
class Car:
__price = 10000
def __init__(self, c):
self.color = c
car = Car('red')
Car.__price
AttributeError: type object 'Car' has no attribute '__price'
car.__price
AttributeError: type object 'Car' has no attribute '__price' # 不管是实例还是类都不能访问私有成员
Mas, para teste e depuração de programas, o python fornece uma maneira de acessar membros privados fora da classe, "atributos instance._class__private"
car = Car('red')
car._Car__price
>>>10000 # 可以访问
4 Métodos públicos, métodos privados, métodos estáticos, métodos de classe
Os métodos públicos e privados pertencem a instâncias (o primeiro parâmetro é self), cada instância tem seus próprios métodos públicos e privados, mas os métodos privados não podem ser chamados diretamente por meio da instância. Os métodos privados só podem ser chamados internamente (ou chamados por meio de um método especial forma de python).
class Car:
def __init__(self, c):
self.color = c
def __show(self): # 私有方法
print(self.color)
def setColor(self, newcolor): # 公有方法
self.color = newcolor
self.__show()
car1 = Car('red')
car1.__show()
>>>AttributeError: 'Car' object has no attribute '__show'
car1.setColor("bule")
>>>bule
Você pode ver que para o método privado __show (), ele fica oculto para você quando é chamado de fora, para mentir para você, mas o método público setColor () dentro da classe pode ser chamado por meio de self .__ show ().
Os métodos estáticos e os métodos de classe podem ser chamados pelo nome da classe e pelo nome da instância, mas não podem acessar diretamente os membros da instância, apenas os membros da classe.Todos são métodos gerais.
class Car:
price = 10000
def __init__(self, c):
self.color = c # 这是实例属性
@classmethod #类方法修饰器
def showprice(cls):
print(cls.price)
@staticmethod # 静态方法修饰器
def sayhello():
print('hello')
car1 = Car('red')
car1.showprice()
car1.sayhello()
>>>10000
>>>hello
Observação: os métodos de classe e os métodos estáticos não dependem da instância e não podem chamar membros da instância
Sobrecarga do operador
Por que a adição da classe int e a adição da lista têm o mesmo sinal “+”, mas o método de operação é diferente, essa é a sobrecarga do operador, para o mesmo operador, o método de cálculo definido para diferentes classes.
Por exemplo, para a classe Carro, defina dois carros "+" como a soma de seus preços e sobrecarga __add__
class Car:
def __init__(self, color, money):
self.color = color
self.money = money
def __add__(self, anothercar):
if isinstance(anothercar, Car):
return self.money + anothercar.money
else : print('this is nor a car ')
car1 = Car("red", 10000)
car2 = Car("bule",10000)
car1 + car2
>>>20000
herdar
Herança é projetada para reutilização.Quando uma nova classe é necessária, se a nova classe é uma subclasse de uma classe projetada, então é um método inteligente e eficiente para chamar diretamente a classe projetada, que são chamadas de subclasses e subclasses. Pai. Esse comportamento é herança.
Por exemplo, agora precisamos de uma classe Volkswagen que pode herdar as funções da classe Carro.
class Volkswagen(Car):
def setmodel(self, m):
self.model = m
car3 = Volkswagen( 'yellow', 100)
car3.color
>>>'yellow'
car3.money
>>>100 # 继承了负类的成员
car3.setmodel('迈腾')
>>>car3.model
'迈腾'
Para ver as subcategorias de uma classe, você pode usar issubclass (filho, pai). Ou class .__ bases__ para ver a categoria pai.
issubclass(Volkswagen, Car)
True
Volkswagen.__bases__
(__main__.Car,)
Referência de conteúdo:
programação python, Dong Fuguo, Tsinghua University Press
Participando do tutorial de pássaros Python orientado a objetos