Python3 Object-Oriented

Object-Oriented Panoramica della tecnologia

• Class (Class): usato per descrivere la collezione hanno le stesse proprietà e metodi degli oggetti. Si definisce un insieme di proprietà e metodi comuni a ogni oggetto. Gli oggetti sono istanze di classi.
• variabili di classe: variabili di classe è comune in tutto l'oggetto istanziato. variabili classe definita e all'esterno della funzione nella classe. variabili di classe normalmente non utilizzati come variabili di istanza.
• i membri dati: variabili di classe o variabili di istanza per le classi di elaborazione dati associati e oggetti istanza.
• Sostituzioni: Se non è possibile soddisfare le esigenze di una sottoclasse eredita dalla metodo della classe genitore, può essere riscritta, un processo chiamato metodo di sovrapposizione (override), noto anche come il metodo prevalente.
• Esempi di variabili: variabili definite nel metodo, solo il ruolo della classe dell'istanza corrente.
• Ereditarietà: Questa è una classe derivata (classe derivata) eredita la classe di base () campi ei metodi della classe base. L'ereditarietà consente inoltre un oggetto di classe derivata come un oggetto di piacere classe base. Ad esempio, vi è un tale progetto: un tipo di oggetto che è derivata da una classe Animal Dog, che è un analogo "è un (è-a)" relazione (Fig esempio, è un animale Dog).
• Un'istanza: creare un'istanza di una classe, la classe di oggetto specifico.
• Metodi: Le funzioni di classe definite.
• Oggetto: dati di istanza struttura attraverso la definizione della classe. oggetti dati includono due membri (variabili di classe e di istanza) e metodi.

E altri linguaggi di programmazione, Python ad un minimo di nuova sintassi e la semantica della situazione di aderire al meccanismo della classe.

classi Python in programmazione orientata agli oggetti fornisce tutte le funzioni di base: il meccanismo di ereditarietà di classe consente a più classi base, la classe di base nelle classi derivate possono sovrascrivere i metodi, è possibile chiamare il metodo della classe base con lo stesso nome.

Gli oggetti possono contenere qualsiasi numero e tipo di dati.

definizione di classe

La sintassi è la seguente:

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

Dopo che la classe viene creata un'istanza, è possibile utilizzare le sue proprietà, infatti, dopo aver creato una classe, è possibile accedere alle sue proprietà tramite il nome della classe.

oggetto Class

Gli oggetti classe supportano due tipi di operazioni: riferimenti ad attributo e istanziazione.

Attributi referenze utilizzano Python per tutti attributo fa riferimento allasintassi standard: obj.name.

Dopo l'oggetto di classe è stato creato attributo class namespace tutti i nomi sono nomi validi. Quindi, se la definizione di classe si presentava così:

#!/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())

Un'istanza della classe:

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

Sopra crea una nuova istanza della classe e assegna tale oggetto alla variabile x locale, x oggetto vuoto.

L'output del programma di cui sopra è:

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

Molte classi piace creare oggetti in uno stato iniziale noto. Perciò una classe può definire un __ chiamato __init () metodo speciale (costruttore), in questo modo:

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

metodo di classe definisce __init __ (), allora l'operatore di classe di un'istanza chiamerà automaticamente il metodo __init __ (). Quindi, in questo esempio, può essere quello di creare una nuova istanza:

x = MyClass()

Naturalmente, il metodo __init __ () può avere argomenti, parametri __init __ () viene passato per l'operatore di classe di un'istanza. Ad esempio:

>>> 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)

I metodi di classe

Nell'interno terrestre, uso def parola chiave può essere definito come un metodo di classe, definizioni diverse e funzioni generali, metodi di classe devono includere il parametro sé, e come primo parametro:

#!/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()

L'output del programma di cui sopra è:

w3big 说: 我 10 岁。

ereditare

Python supporta anche ereditarietà di classe, se una lingua non supporta l'ereditarietà, la classe ha poco significato. Definizione della classe derivata come segue:

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

Si noti che l'ordine della classe base tra parentesi, se la classe base ha lo stesso nome del metodo, ma senza specificare sottoclassi, pitone da sinistra a destra metodo di ricerca che non si trova nella sottoclasse, da sinistra a destra per trovare classe di base contiene i metodi.

NomeClasseBase (ad esempio nome della classe base) deve essere definito in un ambito classe derivata. Oltre ai corsi, è possibile utilizzare l'espressione, la classe base è definita in un altro modulo, che è molto utile per:

class DerivedClassName(modname.BaseClassName):

Esempi

#!/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()

L'output del programma di cui sopra è:

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

L'ereditarietà multipla

Python supporta una forma limitata di ereditarietà multipla. Definizione multipla della classe eredità appare come segue:

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

Si noti che l'ordine in classe genitore parentesi, se la classe genitore hanno lo stesso nome del metodo, ma senza specificare sottoclassi, pitone da sinistra a destra metodo di ricerca che non si trova nella sottoclasse, da sinistra a destra per trovare classe genitore contiene metodi.

#!/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()   #方法名同，默认调用的是在括号中排前地父类的方法

L'output del programma di cui sopra è:

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

override del metodo

Se la funzione sei il metodo della classe genitore non può soddisfare le vostre esigenze, è possibile riscrivere il metodo di classe genitore in una sottoclasse, esempi sono i seguenti:

#!/usr/bin/python3

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

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

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

L'output del programma di cui sopra è:

调用子类方法

attributi e metodi di classe

Classe Proprietà privata

__private_attrs: a cominciare due sottolineature affermando che la proprietà è privata e non può essere utilizzato o accedere direttamente nella classe esternamente. Self .__ private_attrs quando utilizzato all'interno di un metodo di classe.

I metodi di classe

Nell'interno terrestre, uso def parola chiave può essere definito come un metodo di classe con la definizione generale delle diverse funzioni, metodi di classe devono includere il parametro sé, e come primo parametro

metodi privati ​​della classe

__private_method: i primi due di sottolineatura, il metodo è dichiarato come metodi privati della classe non possono chiamare dall'esterno. slef chiamata classe interna .__ private_methods.

Esempi

esempio privata proprietà della classe come segue:

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

L'output del programma di cui sopra è:

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'

metodo di istanza private della classe come segue:

#!/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()      # 报错

I risultati degli esempi di cui sopra:

metodi proprietari della classe:

• __init__: costruttore viene chiamato quando viene generato un oggetto
• __del__: destructor, gli oggetti di rilascio
• __repr__: la stampa, la conversione
• __setitem__: secondo l'assegnazione degli indici
• __getitem__: Ottiene il valore dell'indice
• __len__: ottenere la lunghezza
• __cmp__: operazione di confronto
• __call__: chiamata di funzione
• __add__: aggiungi operazione
• __sub__: sottrazione
• __mul__: moltiplicazione
• __div__: operazione di divisione
• __mod__: Operatore resto
• __pow__: parte chiamata

L'overloading degli operatori

Python supporta anche sovraccarico operatore, cosa posso essere sovraccaricato metodi proprietari di classe, gli esempi sono i seguenti:

#!/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)

I risultati di esecuzione sopra codici sono i seguenti:

Vector(7,8)