Python3 orientada a objeto

Visão Geral da Tecnologia Orientada a Objetos

• Class (classe): utilizada para descrever a recolha tem as mesmas propriedades e métodos de objectos. Ele define um conjunto de propriedades e métodos comuns para cada objeto. Objetos são instâncias de classes.
• variáveis de classe: variáveis de classe é comum em todo o objeto instanciado. variáveis ​​de classe definido e fora da função na classe no. variáveis ​​de classe não sejam normalmente utilizadas como variáveis ​​de instância.
• membros de dados: variáveis de classe ou variáveis de instância para as classes de processamento de dados associados e objetos de instância.
• Substituições: Se você não pode satisfazer as necessidades de uma subclasse herda o método da classe pai, ele pode ser reescrita, um processo chamado de método de sobreposição (override), também conhecido como o método de substituição.
• Exemplos de variáveis: variáveis definidas no método, apenas o papel da classe da instância atual.
• Herança: Essa é uma classe derivada (classe derivada) herda as (classe base) Campos e métodos de classe base. Herança também permite que um objeto de classe derivada como um objeto de deleite classe base. Por exemplo, existe uma tal concepção: um tipo de objecto que é derivado de uma classe de animal cão, o que é um análogo "é uma (é-a)" relação (Fig exemplo, é um animal do cão).
• Instanciar: criar uma instância de uma classe, a classe de objeto específico.
• Métodos: As funções definidas classe.
• Objeto: estrutura de dados exemplo, através da definição de classe. Os objetos de dados incluem dois membros (variáveis ​​de classe e instância) e métodos.

E outras linguagens de programação, Python em um mínimo de nova sintaxe e semântica da situação para se juntar ao mecanismo da classe.

classes Python em programação orientada a objeto fornece todas as funções básicas: o mecanismo de herança de classe permite que várias classes de base, a classe base em classes derivadas podem substituir quaisquer métodos, você pode chamar o método da classe base com o mesmo nome.

Os objetos podem conter qualquer número e tipo de dados.

definição de classe

Sintaxe é como se segue:

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

Após a classe é instanciado, você pode usar suas propriedades, de fato, depois de criar uma classe, você pode acessar suas propriedades através do nome da classe.

objeto de classe

objetos de Classe suportam dois tipos de operações: referências a atributos e instanciação.

Atributo referências usar Python para todos atributo faz referência asintaxe padrão: obj.name.

Depois que o objeto classe foi criado atributo de classe namespace todos os nomes são nomes válidos. Assim, se a definição de classe ficou assim:

#!/usr/bin/python3

class MyClass:
    """一个简单的类实例"""
    i = 12345
    def f(self):
        return 'hello world'

# 实例化类
x = MyClass()

# 访问类的属性和方法
print("MyClass 类的属性 i 为：", x.i)
print("MyClass 类的方法 f 输出为：", x.f())

Instanciar a classe:

# 实例化类
x = MyClass()
# 访问类的属性和方法

Acima cria uma nova instância da classe e atribui o objeto resultante a variável local x, x objeto vazio.

A saída do programa acima é:

MyClass 类的属性 i 为： 12345
MyClass 类的方法 f 输出为： hello world

Muitas classes gostaria de criar objetos em um estado inicial conhecido. Portanto, uma classe pode definir uma __ chamado __init () método especial (construtor), como este:

def __init__(self):
    self.data = []

Classe define __init __ () método, então o operador de classe instanciação chamará automaticamente método __init __ (). Assim, neste exemplo, pode ser a criação de uma nova instância:

x = MyClass()

Claro que, o método __init __ () pode ter argumentos, parâmetros __init __ () é passada para o operador de classe instanciação. Por exemplo:

>>> class Complex:
...     def __init__(self, realpart, imagpart):
...         self.r = realpart
...         self.i = imagpart
...
>>> x = Complex(3.0, -4.5)
>>> x.r, x.i
(3.0, -4.5)

métodos de classe

No interior terrestre, palavra-chave uso def pode ser definida como um método de classe, diferentes definições e funções gerais, métodos de classe deve incluir o auto parâmetro, e que o primeiro parâmetro:

#!/usr/bin/python3

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

# 实例化类
p = people('w3big',10,30)
p.speak()

A saída do programa acima é:

w3big 说: 我 10 岁。

herdar

Python também suporta herança de classe, se um idioma não suporta herança, a classe tem pouco significado. Definição da classe derivada da seguinte forma:

class DerivedClassName(BaseClassName1):
    <statement-1>
    .
    .
    .
    <statement-N>

Note que a ordem da classe base em parênteses, se a classe de base tem o mesmo nome de método, mas sem especificar subclasses, pitão da esquerda para a direita método de busca que não é encontrado em sub-classe, da esquerda para a direita para encontrar classe base contém métodos.

BaseClassName (exemplo nome da classe base) deve ser definido em um escopo de classe derivada. Além das aulas, você pode usar a expressão, a classe base é definida em outro módulo, que é muito útil para:

class DerivedClassName(modname.BaseClassName):

Exemplos

#!/usr/bin/python3

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))



s = student('ken',10,60,3)
s.speak()

A saída do programa acima é:

ken 说: 我 10 岁了，我在读 3 年级

Herança múltipla

Python suporta uma forma limitada de herança múltipla. definição múltipla classe de herança é o seguinte:

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

Note-se que a ordem na classe pai parênteses, se a classe pai tem o mesmo nome do método, mas sem especificar subclasses, pitão da esquerda para a direita método de pesquisa que não é encontrado na sub-classe, da esquerda para a direita para encontrar classe pai contém métodos.

#!/usr/bin/python3

#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))

#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)

test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

A saída do programa acima é:

我叫 Tim，我是一个演说家，我演讲的主题是 Python

substitui o método

Se a função que são o método da classe pai não pode atender às suas necessidades, você pode reescrever o seu método de classe pai em uma subclasse, os exemplos são os seguintes:

#!/usr/bin/python3

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')

class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')

c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法

A saída do programa acima é:

调用子类方法

atributos de classe e métodos

classe de propriedade privada

__private_attrs: começando dois sublinhados afirmando que a propriedade é privada e não pode ser usado ou acessado diretamente na classe externamente. Self .__ private_attrs quando usado dentro de um método de classe.

métodos de classe

No interior terrestre, palavra-chave uso def pode ser definida como um método de classe com a definição geral das diferentes funções, os métodos de classe deve incluir o auto parâmetro, e que o primeiro parâmetro

métodos privados de classe

__private_method: os dois primeiros sublinhado, o método é declarado como métodos particulares na classe não pode chamar externamente. slef chamada classe interna .__ private_methods.

Exemplos

exemplo, a propriedade privada da classe da seguinte forma:

#!/usr/bin/python3

class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量

    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)

counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
print (counter.__secretCount)  # 报错，实例不能访问私有变量

A saída do programa acima é:

1
2
2
Traceback (most recent call last):
  File "test.py", line 16, in <module>
    print (counter.__secretCount)  # 报错，实例不能访问私有变量
AttributeError: 'JustCounter' object has no attribute '__secretCount'

instância método particular da classe da seguinte forma:

#!/usr/bin/python3

class Site:
	def __init__(self, name, url):
		self.name = name       # public
		self.__url = url   # private

	def who(self):
		print('name  : ', self.name)
		print('url : ', self.__url)

	def __foo(self):          # 私有方法
		print('这是私有方法')

	def foo(self):            # 公共方法
		print('这是公共方法')
		self.__foo()

x = Site('本教程', 'www.w3big.com')
x.who()        # 正常输出
x.foo()        # 正常输出
x.__foo()      # 报错

Os resultados dos exemplos acima:

métodos proprietários da classe:

• __init__: construtor é chamado quando um objeto é gerado
• __del__: destructor, os objetos de libertação
• __repr__: impressão, conversão
• __setitem__: de acordo com a atribuição de índices
• __getitem__: Obtém o valor no índice
• __len__: get comprimento
• __cmp__: operação de comparação
• __call__: chamada de função
• __add__: adicionar operação
• __sub__: subtração
• __mul__: Multiplicação
• __div__: operação de divisão
• __mod__: operador de resto
• __pow__: parte chamada

sobrecarga de operadores

Python também suporta a sobrecarga de operador, o que pode ser sobrecarregado classe métodos proprietários, os exemplos são os seguintes:

#!/usr/bin/python3

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)

Os resultados da execução de código acima são os seguintes:

Vector(7,8)