Python3 obiektowe

Obiektowe Przegląd technologii

• (Klasa) stosowane do opisu kolekcji mają takie same właściwości i metody obiektów. To definiuje zestaw właściwości i metod wspólnych dla każdego obiektu. Obiekty są instancjami klas.
• Zmienne Klasa: zmienne klasy jest powszechne na całym instancja obiektu. Zmienne klasy zdefiniowane i na zewnątrz funkcji w klasie w. Zmienne klasy nie zwykle używane jako zmienne instancji.
• Członkowie danych: zmienne klasy lub zmiennych instancji dla klas związanych z przetwarzaniem danych i instancji obiektów.
• Zastępuje: Jeśli nie można zaspokoić potrzeby podklasa dziedziczy metody klasy nadrzędnej, to może być zapisane, a proces zwany metodą nakładki (override), znany również jako metoda nadrzędnego.
• Przykłady zmiennych: zmienne zdefiniowane w metodzie, tylko rola klasy bieżącej instancji.
• Dziedziczenie: To jest klasa pochodna (klasa pochodna) dziedziczy klasa podstawowa (klasy bazowej) pól i metod. Dziedziczenie umożliwia także pochodnej klasy jako obiekt klasy bazowej obiektu leczeniu. Na przykład, taka konstrukcja: typ obiektu, który pochodzi z klasy psów zwierzęcia, które jest analogiem "oznacza (is-a)" związek (przykład fig, jest pies zwierząt).
• Wystąpienia: utworzyć instancję klasy, konkretnej klasy obiektów.
• Metody: Funkcje klasy zdefiniowane.
• Object: Dane struktury przykład poprzez definicji klasy. Obiekty danych obejmują dwa elementy (class i wystąpień zmiennych) i metod.

I innych języków programowania, Python przynajmniej nowej składni i semantyki sytuacji przystąpić do mechanizmu klasy.

Klasy Python w programowaniu obiektowym zapewnia wszystkie podstawowe funkcje: mechanizm klasy dziedziczenie pozwala wielu klas bazowych, klasa bazowa w klasach pochodnych może zastąpić wszelkie metody, można wywołać metodę klasy bazowej o tej samej nazwie.

Przedmioty mogą zawierać dowolną liczbę i typ danych.

definicja klasy

Składnia jest następująca:

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

Po klasy jest tworzony, można wykorzystać jego właściwości, w rzeczywistości, po utworzeniu klasy, można uzyskać dostęp do jego właściwości poprzez nazwę klasy.

obiekt Class

obiekty klasy obsługują dwa rodzaje operacji: Referencje atrybutów i instancji.

Atrybut odniesienia używać Pythona dla wszystkich atrybutu odwołuje się do standardowejskładni: obj.name.

Gdy obiekt klasy został stworzony atrybut namespace klasy wszystkie nazwy są prawidłowe nazwy. Tak więc, jeśli definicja klasy wyglądał następująco:

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

Instancję klasy:

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

Przede tworzy nową instancję klasy i przypisuje ten obiekt do lokalnej zmiennej x, x pusty obiekt.

Powyższy program jest wyjście:

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

Wiele klas lubią tworzyć obiekty w znanego stanu początkowego. Dlatego klasa może określić nazwie __init __ () specjalna metoda (konstruktor), na przykład:

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

Klasa definiuje metody __init __ (), a następnie operator klasy instancji automatycznie wywoła metodę __init __ (). Tak więc w tym przykładzie, może być, aby utworzyć nową instancję:

x = MyClass()

Oczywiście metoda __init __ () może mieć argumenty, parametry __init __ () jest przekazywana do operatora klasy konkretyzacji. Na przykład:

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

metody klas

We wnętrzu naziemnej, używanie słów kluczowych def może być zdefiniowana jako metoda klasy, różnych definicji i najważniejszych funkcji, metody klasy musi zawierać parametr siebie, a jako pierwszy parametr:

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

Powyższy program jest wyjście:

w3big 说: 我 10 岁。

dziedziczyć

Python obsługuje także klasy dziedziczenie, jeśli język nie obsługuje dziedziczenie, klasy ma niewielki sens. Definicja klasy pochodnej, co następuje:

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

Zauważ, że kolejność w klasie bazowej w nawiasach, jeśli klasa bazowa ma taką samą nazwę metody, ale bez określania podklasy, Python od lewej do prawej metody wyszukiwania, która nie znajduje się w sub-klasy, od lewej do prawej, aby wybrać Klasa bazowa zawiera metody.

BaseClassName (przykład nazwa klasy bazowej) musi być zdefiniowana w klasie pochodnej zakresu. Oprócz zajęć, można użyć wyrażenia, klasa bazowa jest określona w innym module, który jest bardzo przydatny dla:

class DerivedClassName(modname.BaseClassName):

Przykłady

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

Powyższy program jest wyjście:

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

Wielokrotne dziedziczenie

Python obsługuje ograniczoną formę wielokrotnego dziedziczenia. Definicja Wielokrotne dziedziczenie klasy wygląda następująco:

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

Zauważ, że kolejność w nawiasach klasy nadrzędnej, jeśli klasa dominująca mają taką samą nazwę metody, ale bez określania podklasy, Python od lewej do prawej metody wyszukiwania, która nie znajduje się w sub-klasy, od lewej do prawej, aby wybrać klasa dominująca zawiera metody.

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

Powyższy program jest wyjście:

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

metoda nadpisania

Jeśli funkcja jesteś metoda klasy rodzic nie może zaspokoić swoich potrzeb, można przepisać swoją macierzystą metody klasy w podklasie, przykłady przedstawiają się następująco:

#!/usr/bin/python3

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

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

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

Powyższy program jest wyjście:

调用子类方法

atrybuty i metody klasy

Prywatna klasa własności

__private_attrs: zaczynając dwa podkreślenia stwierdzające, że nieruchomość jest prywatny i nie mogą być używane lub dostępne bezpośrednio w klasie zewnętrznie. Self .__ private_attrs kiedy jest stosowany w metodzie klasy.

metody klas

We wnętrzu naziemnej kluczowe zastosowanie def może być zdefiniowana jako metoda z klasy ogólnej definicji różnych funkcji, metody klasie musi zawierać siebie parametru, jak i pierwszy parametr

Metody prywatnych klasy

__private_method: pierwsze dwa podkreślenia, metoda jest zadeklarowana jako metody prywatne w klasie nie może dzwonić na zewnątrz. Wewnętrzne SLEF wywołanie klasy .__ private_methods.

Przykłady

Prywatna własność instancja klasy, co następuje:

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

Powyższy program jest wyjście:

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'

Metoda prywatna instancja klasy, co następuje:

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

Wyniki z powyższych przykładów:

Własne metody klasy:

• __init__: konstruktor jest wywoływana, gdy obiekt jest generowany
• __del__: destructor, obiekty uwalnianiu
• __repr__: drukowanie, konwersja
• __setitem__: zgodnie z przypisaniem indeksu
• __getitem__: Pobiera wartość indeksu
• __len__: uzyskać długość
• __cmp__: operacja porównania
• __call__: wywołanie funkcji
• __add__: dodawanie operacji
• __sub__: odejmowanie
• __mul__: mnożenie
• __div__: Operacja podziału
• __mod__: Operator pozostała
• __pow__: abonent

operator Przeciążenie

Python obsługuje także przeciążanie operatorów, co mogę być przeciążone klasy metody praw własności, przykłady przedstawiają się następująco:

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

Wyniki wykonania, powyższy kod są następujące:

Vector(7,8)