O melhor tutorial Python3 orientada a objeto em 2024. Neste tutorial você pode aprender Visão Geral da Tecnologia Orientada a Objetos,definição de classe,objeto de classe,métodos de classe,herdar,Herança múltipla,substitui o método,atributos de classe e métodos,
Python foi concebido desde o início é uma linguagem orientada a objetos, e como tal, criar uma classe e objetos em Python é muito fácil. Esta seção iremos detalhar a programação orientada a objeto em Python.
Se você não tiver sido exposto ao orientada a objeto linguagem de programação, então você pode precisar primeiro entender algumas das características básicas de linguagens orientadas a objetos, formada na mente dentro de um conceito básico de orientada a objeto, que ajuda você a aprender mais facilmente o Python programação orientada a objetos.
Em seguida, vamos dar uma compreensão simples de menos de algumas características básicas orientada a objetos.
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.
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.
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: pt. def __init__(self, realpart, imagpart): pt. self.r = realpart pt. self.i = imagpart pt. >>> x = Complex(3.0, -4.5) >>> x.r, x.i (3.0, -4.5)
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 岁。
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):
#!/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 年级
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
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 é:
调用子类方法
__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.
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
__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.
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.w3write.com') x.who() # 正常输出 x.foo() # 正常输出 x.__foo() # 报错
Os resultados dos exemplos acima:
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)