Python 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.

Criar classe

Use a declaração de classe para criar uma nova classe, depois da aula, e o nome da classe termina com dois pontos, os seguintes exemplos:

class ClassName:
   '类的帮助信息'   #类文档字符串
   class_suite  #类体

classe ajuda pode ser visto por ClassName .__ doc__.

class_suite composto por membros da classe, método, atributos de dados.

Exemplos

O que se segue é um exemplo simples classe Python:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Employee:
   '所有员工的基类'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

• empCount variável é uma variável de classe, o seu valor será compartilhado entre todas as instâncias desta classe. Você pode usar o acesso Employee.empCount dentro da classe ou classe de fora.
• O método primeiro método __init __ () é um método método especial, construtor ou inicialização da classe é chamado ao criar uma instância desta classe irá chamar o método

Criar uma instância de um objeto

Para criar uma instância de uma classe, você pode usar o nome da classe, e aceito método parâmetros __init__.

"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)

Propriedades de acesso

Você pode usar o ponto (.) Propriedade para acessar o objeto. Acessando uma variável de classe com o nome da classe da seguinte forma:

emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

Exemplo completo:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Employee:
   '所有员工的基类'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

"创建 Employee 类的第一个对象"
emp1 = Employee("Zara", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print "Total Employee %d" % Employee.empCount

Executar o código acima dos resultados de saída são as seguintes:

Name :  Zara ,Salary:  2000
Name :  Manni ,Salary:  5000
Total Employee 2

Você pode adicionar, excluir, modificar as propriedades da classe da seguinte forma:

emp1.age = 7  # 添加一个 'age' 属性
emp1.age = 8  # 修改 'age' 属性
del emp1.age  # 删除 'age' 属性

Você também pode acessar as propriedades utilizar as seguintes funções:

• getattr (obj, nome [, padrão]): Acesso de objetos de propriedade.
• hasattr (obj, nome): Verifique se existe um atributo.
• setattr (obj, nome, valor): definir uma propriedade. Se a propriedade não existir, crie uma nova propriedade.
• delattr (obj, nome): excluir atributos.

hasattr(emp1, 'age')    # 如果存在 'age' 属性返回 True。
getattr(emp1, 'age')    # 返回 'age' 属性的值
setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8
delattr(empl, 'age')    # 删除属性 'age'

Python atributo de classe embutido

• __dict__: atributos da classe (incluindo um dicionário, o atributo de dados composição de classe)
• __doc__: classe string documento
• __name__: nome da classe
• __module__: módulo onde a definição de classe (o nome completo é ". __main __ className ', se a classe está localizada em uma MyMod módulo importado, então className .__ module__ igual MyMod)
• __bases__: Todas as classes de elemento pai (que compreendem uma classe pai que consiste em todas as linhas)

Python chama o built-in exemplos de atributos de classe são as seguintes:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Employee:
   '所有员工的基类'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

print "Employee.__doc__:", Employee.__doc__
print "Employee.__name__:", Employee.__name__
print "Employee.__module__:", Employee.__module__
print "Employee.__bases__:", Employee.__bases__
print "Employee.__dict__:", Employee.__dict__

Executar o código acima dos resultados de saída são as seguintes:

Employee.__doc__: 所有员工的基类
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: ()
Employee.__dict__: {'__module__': '__main__', 'displayCount': <function displayCount at 0x10a939c80>, 'empCount': 0, 'displayEmployee': <function displayEmployee at 0x10a93caa0>, '__doc__': '\xe6\x89\x80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xe7\xb1\xbb', '__init__': <function __init__ at 0x10a939578>}

objeto python é destruído (coleta de lixo)

Como a linguagem Java, Python usa contagem de referência esta técnica simples para rastrear objetos na memória.

Um variáveis ​​de controlo interno, chamado de contador de referência.

Quando um objeto é criado, ele cria uma contagem de referência, quando o objeto não é mais necessária, ou seja, uma referência para a contagem de objeto se torna 0, é lixo coletado. Mas a recuperação não é "imediatamente" pelo intérprete no momento apropriado, os objetos de lixo ocupam espaço de memória de recuperação.

a = 40      # 创建对象  <40>
b = a       # 增加引用， <40> 的计数
c = [b]     # 增加引用.  <40> 的计数

del a       # 减少引用 <40> 的计数
b = 100     # 减少引用 <40> 的计数
c[0] = -1   # 减少引用 <40> 的计数

mecanismo de coleta de lixo não só para a contagem de referência do objeto é 0, o mesmo também pode lidar com o caso de referências circulares. Ele refere-se a uma referência circular, dois objectos referem-se uns aos outros, mas não há outras referências variáveis ​​eles. Neste caso, apenas a contagem de referência não é suficiente. coletor de lixo do Python é realmente uma referência a um contador de ciclos eo coletor de lixo. Como um coletor de lixo complementar contagem de referência vai pagar a atenção para o montante total atribuído grandes objetos (e não contando as que foram destruídas por referência). Neste caso, o intérprete fará uma pausa, tentando limpar todo o ciclo não referenciado.

Exemplos

Destructor __del__, __ del__ é chamado quando o objeto é destruído, quando o objeto não está mais sendo usado, __ método del__ para executar:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Point:
   def __init__( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print class_name, "销毁"

pt1 = Point()
pt2 = pt1
pt3 = pt1
print id(pt1), id(pt2), id(pt3) # 打印对象的id
del pt1
del pt2
del pt3

Exemplos dos resultados acima são como se segue:

3083401324 3083401324 3083401324
Point 销毁

Nota: Normalmente, você precisa definir uma classe em um arquivo separado,

A herança de classe

Um dos principais benefícios da programação orientada a objeto é trazido para reutilizar a reutilização de código para conseguir uma delas é através do mecanismo de herança. Herdado relacionamento tipo e subtipo completamente compreensível entre as classes em.

Ressalva: Inheritance Syntax class nome da classe derivada (o nome da classe base): // ... escrever o nome de classe base entre parênteses, quando a classe base é a definição de classe, entre tuplas especificados.

Em sucessão python de algumas das características:

• 1: No seguinte configuração (__init __ () método) classe Cheng Zhongji não será invocado automaticamente, requer especializada chamou pessoalmente no construtor da sua classe derivada.
• 2: Quando você chamar o método da classe base, você precisa adicionar o nome da classe prefixo da classe base, e a necessidade de trazer variáveis ​​auto parâmetros. Não precisa trazer auto parâmetro é diferente da chamada de função normal na classe
• 3: Python sempre o primeiro a encontrar o tipo correspondente de abordagem, se não puder encontrar o método correspondente em uma classe derivada, ele começou a procurar um por um para a classe base. (Primeira chamadas de método para encontrar nesta classe, só para encontrar para encontrar a classe base).

Se a coluna mais de uma classe na tupla herança, então ele é chamado de "herança múltipla".

sintaxe:

Declaração da classe derivada, semelhante à sua classe pai, então herdar a lista de classe base com o nome da classe, como segue:

class SubClassName (ParentClass1[, ParentClass2, ...]):
   'Optional class documentation string'
   class_suite

exemplo:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

class Parent:        # 定义父类
   parentAttr = 100
   def __init__(self):
      print "调用父类构造函数"

   def parentMethod(self):
      print '调用父类方法'

   def setAttr(self, attr):
      Parent.parentAttr = attr

   def getAttr(self):
      print "父类属性 :", Parent.parentAttr

class Child(Parent): # 定义子类
   def __init__(self):
      print "调用子类构造方法"

   def childMethod(self):
      print '调用子类方法 child method'

c = Child()          # 实例化子类
c.childMethod()      # 调用子类的方法
c.parentMethod()     # 调用父类方法
c.setAttr(200)       # 再次调用父类的方法
c.getAttr()          # 再次调用父类的方法

O código acima é executado da seguinte forma:

调用子类构造方法
调用子类方法 child method
调用父类方法
父类属性 : 200

Você pode herdar várias classes

class A:        # 定义类 A
.....

class B:         # 定义类 B
.....

class C(A, B):   # 继承类 A 和 B
.....

Você pode usar issubclass () ou método isinstance () para detectar.

• issubclass () - função booleana para determinar se uma classe é uma subclasse de outra classe ou sintaxe classe descendente: issubclass (sub, sup)
• isinstance (obj, Classe) função booleana se obj é uma instância de uma classe de objeto ou instância objeto de classe da classe é uma subclasse retorna verdadeiro.

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:

exemplo:

#!/usr/bin/python
# -*- coding: UTF-8 -*-

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

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

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

Executar o código acima dos resultados de saída são as seguintes:

调用子类方法

métodos Fundação sobrecarregado

A tabela seguinte lista algumas das características comuns que você pode substituir em sua classe:

sobrecarga de operadores

Python também suporta a sobrecarga de operador, os exemplos são os seguintes:

#!/usr/bin/python

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)

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. Chama private_methods self .__ dentro da classe

Exemplos

#!/usr/bin/python
# -*- coding: UTF-8 -*-

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  # 报错，实例不能访问私有变量

Python, alterando o nome para incluir o nome da classe:

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

Python não é permitido acesso de classe instanciado dados privados, mas você pode usar atributos de acesso object._className__attrName, o seguinte código irá substituir a última linha de código acima do código:

.........................
print counter._JustCounter__secretCount

Executar o código acima, os resultados da execução são as seguintes:

1
2
2
2