Grundlegende Syntax von objektorientierten Klassen und Klassen in Python

Als ich herausfand, dass ich objektorientierte Programmierung in Python schreiben wollte, war ich zögerlich und unruhig. Ich habe überlegt: Wie soll ich dieses Loch erklimmen? Da es in Python viele objektorientierte Inhalte gibt, ist es am besten, den vorherigen Inhalt mit objektorientiertem Denken erneut zu erlernen, wenn Sie ihn gründlich erklären möchten. Diese Grube ist so groß, dass wir nach langem Zögern einfach den wichtigen Inhalt aufgreifen können. Der unzureichende Inhalt kann nur von allen ergänzt werden.

Als allgemeine Aussage verwende ich die Version Python2.7 und es kann Unterschiede zwischen den Versionen geben.

Okay, bevor wir beginnen, denken wir über eine Frage nach und schauen uns den Code an:

Warum erstelle ich nur einen Wert und weise ihn zu? es zu einem? Verwenden Sie eine Methode, die ich noch nicht geschrieben habe?

Einige Freunde sagen vielleicht: Da a derzeit ein String-Objekt ist, können Sie natürlich String-Methoden verwenden. Diese Methoden werden im Voraus von Python geschrieben.

Okay, ändern wir die Frage: Warum weiß Python, dass es sich um ein String-Objekt handelt?

Bevor wir ausführlich auf dieses Thema eingehen, erinnern wir uns an einen Satz: Alles in Python ist ein Objekt, und Objekte werden von Klassen erstellt.

Was ist also ein Kurs? Ich gebe Ihnen hier ein Beispiel.

Eines Tages ging ich auf der Straße und sah plötzlich einen Feind vor mir. Zu diesem Zeitpunkt wollte ich ihn schlagen, aber die Kräfte interagierten miteinander und meine Faust würde weh tun, wenn ich ihn schlagen würde. Hey, zu diesem Zeitpunkt habe ich einen Stein am Straßenrand gefunden. Unabhängig davon, was der Polizist dachte, war dies eine gute Wahl. Dann hob ich den Stein auf und führte einige Taten an meinem Feind aus, die ein guter Junge nicht nachahmen kann. Dann verbarg ich meine Verdienste und meinen Ruhm, machte Schluss und ging nach Hause.

Warum wissen wir in diesem Prozess, dass es sich bei dem Ding um einen Stein handelt?

Weil es wie Stein aussieht!

Warum wissen wir, dass Steine ​​Menschen treffen können?

Weil der Stein hart ist!

Warum wissen wir, dass Steine ​​hart sind?

Weil... nun ja... mein Vater es mir erzählt hat, als ich klein war.

An diesem Punkt können wir eine Schlussfolgerung ziehen: Wir wissen, was ein Ding ist und welche Funktionen es hat, weil wir bereits eine Vorstellung von diesem Ding im Kopf haben. Dieses Konzept ist möglicherweise von Ältesten bekannt oder kann nach verschiedenen Experimenten von einem selbst zusammengefasst werden. Ähnlich wie unser Verständnis von „Schwarzen Löchern“ stammen sie aus verschiedenen Studien von Wissenschaftlern.

So implementieren Sie das Beispiel, jemanden mit einem Stein zu schlagen, im Code:

class Stone(object):　　# 我创建一个叫Stone的类

  def attack(self):
    print '把头伸过来，我给你加个buff'

a = Stone()  # 我用类创建了一个对象，也称为类的实例化
a.attack()   # 我使用这个对象的方法

Großartig, das haben wir gebraucht.

Wenn wir andere Objekte erstellen:

Offensichtlich tut Python das nicht Für uns ist keine Angriffsmethode vorbereitet, daher können wir sie nicht nutzen.

Die sogenannte Klasse ist nur eine abstrakte Definition, während Instanzen konkrete Objekte sind. Der Unterschied zwischen ihnen ist wie der Stein in meinem Kopf und der Stein in meiner Hand, nur letzterer ist echt. Reden Sie mit mir hier natürlich nicht über Idealismus oder ähnliches.

Angesichts dessen sollte die Beziehung zwischen Klassen und Objekten klarer sein. Einige Schüler fragen sich vielleicht: Alle Klassen in Python werden von uns im Voraus geschrieben. Gibt es eine Möglichkeit, Python automatisch Klassen generieren zu lassen und diese Klassen dann zu bestimmten Zeiten zu verwenden? Herzlichen Glückwunsch, Klassenkamerad, Sie haben möglicherweise die Schwelle der künstlichen Intelligenz erreicht. Wenn sie realisiert werden könnte, wäre sie dann nicht ähnlich wie unsere menschliche Lernfähigkeit? Nun ja, das ist nur eine Idee von mir. Ich weiß noch nicht, wie man echte künstliche Intelligenz realisiert sei eine lebenslange Verfolgung.

Nachdem wir darüber gesprochen haben, was Klassen und Instanziierung sind, werfen wir einen Blick auf die grundlegende Syntax von Klassen.

Zuallererst ist class, wie def zum Definieren von Funktionen, das Schlüsselwort zum Definieren einer Klasse.

紧接着的是类名，这个可以自定义，同样的，不能和python的内置关键字冲突。另外，建议避开python的内建类型，例如 str、int之类的名字。规范的命名应该遵从“驼峰命名法”，例如： MyClass 这里的命名，每个单词的首字母大写。

然后是一个括号，里面的参数是用于继承的，一般继承于 object，表示一个新式类。另外，你可能见过没有括号的写法，这是经典类的写法。

示例：

class NewClass(object):
  pass

class OldClass:
  pass

New = NewClass()  # 创建一个新式类的实例
Old = OldClass()  # 创建一个经典类的实例

这就是类的基本语法，当然这样还是不够的，但是在更深入之前，我想先讲一个新旧式类的差别。

在这里，我们先打印一下两个变量的类型：

print type(New)
print type(Old)

可以看下两者的输出是不同的。

在早于python2.2的版本时，只有经典类这一种写法，当时，类和类型没有合并。

类是类对象，实例是实例对象，这两个对象之间没有任何关系。

这句话是什么意思？看代码：

print type(OldClass)
print type(Old)

我们可以看见其输出很含糊，经典类属于类对象，无论是哪个类，都统一为“类”类型，实例属于实例类型，却不知道其是由哪个类创建的，所以的实例都统一为“实例”类型。也就是说当时的类型用 classobj 和 instance 代表了所以的类和实例，无论你是哪个类，又或是哪个类创建的实例。

这样的信息实在太少，而类和类型之间非常混乱。为了解决这种情况，在 python2.2 中引入了新式类，并进行了类和类型的同统一。

print type(NewClass)
print type(New)

类的类型是 type？type 返回的对象还能像类一样创新新对象？

总结的来说：在新式类中，所以的类对象都是 type 的实例。而不同的类对象有能创建出其对应的实例。

class NewClass(object):
  def __init__(self, val):
    self.val = val

New = NewClass(123)  
b = type(New)(321) # 对实例来说type返回的是类对象，我又可以用类对象来和创建新的实例
print b.val

构造器方法

一般可以理解类中的函数就是方法，而方法分为：实例方法，只有实例化后才能调用的，其第一个参数一般为 self，代表实例本身；类方法，其第一个参数为 cls，代表类本身；还有静态方法，就是个普通函数，没有要求参数。

1. __init__(self [,arg1,....]):

当类被调用进行实例化的时候，python会自动调用类里面的构造函数（如果有的话），在构造函数中，可以进行各种初始化的操作，最常见的就是上面的进行实例的属性的创建。

python 在示例化的时候，会检查其实行了 __init__ 方法了没有，如果没有则不对实例进行任何操作，然后返回对象。如果实行了这个方法，则自动调用这个方法，并自动将 self 传进行，也就是说我们在实例化进行传参的时候，将不用理会 self，直接传给后面的参数。

讲到属性，就必须要提一下什么是属性。属性这个对象其实更像一个变量，大多数对象都可以有属性（不包括python的内置类型），例如函数。

def Test():
  pass

Test.a = 123
print Test.a

因为函数也是一个对象。

属性在类中，就是一个变量，例如：

class NewClass(object):
  a = 123

print NewClass.a

当然，因为 python 的特性，我们可以在运作中为某个对象添加属性，而不用一开始就在类中写定。

注意，这个方法应该返回 None，也就是说我们一般不用 return 任何对象，让它默认返回就行了。

2. __new__(cls [,arg1,....]):

这也是一个构造器方法，它是一个类方法，一般在对 python 的不可变数据类型进行继承扩展的时候用的比较多。

某处拿来的代码示例：

class RoundFloat(float):
  def __new__(cls, val):
    return super(RoundFloat, cls).__new__(cls, round(val, 2))

a = RoundFloat(3.14159)
print a

解构器方法

__del__(self [,arg1,....])

这个方法将会在对象所以的引用被清除后才执行，例如：

class Test(object):

  def __del__(self):
    print '我被干掉了，兄弟们为我报仇！'

a = Test() # 创建了一个对象
b = a  # b又引用了a
c = b  # c又引用了b，现在 a 所指向的对象有3次引用，相当有三条命
del a  # 干掉一条命
del b  # 又干掉
del c  # 听说你有3条命？全部干掉！

注意，这里只输出了一次，也就是说到了最后才删除完毕。这里要注意一下几点：

1.调用 del 并不意味着完成删除某个对象，只是减少引用。

2.如果你有一个循环引用或其它的原因，让一个实例的引用逗留不去，该对象的__del__()可能永远不会被执行。

3.__del__()未捕获的异常会被忽略掉（因为一些在__del__()用到的变量或许已经被删除了）。 不要在__del__()中干与实例没任何关系的事情。

4.一般情况下并不用实现这个方法，因为这样有一定的风险。

5.如果你定义了__del__，并且实例是某个循环的一部分，垃圾回收器将不会终止这个循环— —你需要自已显式调用 del。

6.如果继承了父类，且父类中也有解构器，要记得调用。否则可能会有某些在父类中的清理方法没有调用到，出现以下无法预料的错误。

以上这篇浅谈Grundlegende Syntax von objektorientierten Klassen und Klassen in Python就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持PHP中文网。

更多Grundlegende Syntax von objektorientierten Klassen und Klassen in Python相关文章请关注PHP中文网！