Python-Objekte, Namen und Bindungen

PythonErweitert - Objekt, Name und Bindung

stehen im Vordergrund

Sofern nicht anders angegeben, handelt es sich bei den folgenden um Basiert auf Python3

1. Alles ist ein Objekt

Python Philosophie:

Alles in Python ist ein Objekt

1.1 Daten Modell – Objekte, Werte und Typen

Objekte sind Python Abstraktionen von Daten. PythonAlle Daten im Programm werden durch Objekte oder Beziehungen zwischen Objekten dargestellt. (In gewisser Weise ist der Code in Python, um dem „Speichercomputer“-Modell von Neumann zu entsprechen, auch ein Objekt.) Jedes Objekt in

Python hat eine Identität, einen Wert und einen Typ. Nachdem ein Objekt erstellt wurde, ändert sich seine Identität nie; Sie können sich die Identität als die Adresse des Objekts im Speicher vorstellen. Der is-Operator vergleicht die Identitäten zweier Objekte; die id()-Funktion gibt eine Ganzzahl zurück, die die Identität des Objekts darstellt.

CPython-Implementierungsdetails: In der Implementierung des CPython-Interpreters gibt die id(x)-Funktion die Speicheradresse zurück, in der x gespeichert ist.

Der Typ von Das Objekt bestimmt das Objekt. Die unterstützten Operationen (z. B. hat das Objekt eine Länge?) bestimmen auch die möglichen Werte für Objekte dieses Typs. type()Die Funktion gibt den Typ des Objekts zurück (dieser Typ selbst ist auch ein Objekt). Wie seine Identität ist auch der Typ eines Objekts unveränderlich ^[1].

Die Werte einiger Objekte können geändert werden. Objekte, deren Werte sich ändern können, werden auch als veränderlich bezeichnet. Objekte, deren Werte konstant sind, werden auch als unveränderlich bezeichnet . (Wenn ein unveränderliches Containerobjekt einen Verweis auf ein veränderliches Objekt enthält und sich der Wert des veränderlichen Objekts ändert, wird auch der Wert des unveränderlichen Containerobjekts geändert; das unveränderliche Containerobjekt gilt jedoch weiterhin als unveränderlich, da die Sammlung Die im Objekt enthaltenen Werte sind tatsächlich unveränderlich. Daher ist Unveränderlichkeit nicht unbedingt gleichbedeutend mit unveränderlichen Werten Andere Objekte können als Adressen betrachtet werden. Auch wenn sich der Inhalt der Adresse ändert, ist das unveränderliche Containerobjekt immer noch ein unveränderliches Objekt Beispielsweise sind Zahlen, Zeichenfolgen und Tupel unveränderlich, Wörterbücher und Listen jedoch veränderlich. Objekte werden niemals explizit zerstört; sie werden im Garbage Collection gesammelt, wenn sie nicht erreichbar sind (Anmerkung: Das Objekt hat keine Referenz). Eine Interpreter-Implementierung ermöglicht es, die Garbage Collection zu verzögern oder ganz zu ignorieren – je nachdem, wie die Garbage Collection implementiert ist, solange keine erreichbaren Objekte gesammelt werden.

Die Interpreter-Implementierung verwendet den Referenzzählmodus, um die Erkennung von SchleifenCPython Link-Müll zu verzögern. Diese Methode kann die meisten nicht erreichbaren Objekte recyceln Es gibt keine Garantie dafür, dass der Müll, auf den sich der Zyklus bezieht, recycelt wird. Weitere Informationen zur Steuerung der zyklischen Speicherbereinigung finden Sie in der Dokumentation des -Moduls. Andere Interpreter-Implementierungen unterscheiden sich von , und gc-Implementierungen können sich in Zukunft ändern. Daher kann man sich nicht darauf verlassen, dass der Garbage Collector nicht erreichbare Objekte zurückgewinnt (daher sollten Dateiobjekte immer explizit geschlossen werden). CPythonCPythonEs ist zu beachten, dass die Verwendung der

-Tracking-Funktion des Tools dazu führen kann, dass Objekte, die recycelt werden sollten, am Leben bleiben. Die Verwendung der try-Anweisung zum Abfangen von Ausnahmen kann möglich sein Behalten Sie außerdem das Überleben des Objekts bei. ...exceptEinige Objekte verweisen auf externe Ressourcen wie Dateien oder Fenster. Es versteht sich von selbst, dass die Ressource nach der Müllsammlung, die die Ressource enthält, auch freigegeben wird. Da es jedoch keinen Mechanismus gibt, der garantiert, dass die Müllsammlung definitiv erfolgt, bieten diese ressourcenhaltenden Objekte auch eine Möglichkeit, externe Objekte explizit freizugeben Ressourcen, normalerweise mit der

close()<a href="//m.sbmmt.com/wiki/207.html" target="_blank">endgültige<code>tryly-Anweisung und ... Anweisungen erleichtern die Freigabe von Ressourcen. <a href="//m.sbmmt.com/wiki/207.html" target="_blank">final</a>ly

Einige Objekte enthalten Verweise auf andere Objekte. Diese Objekte werden Container genannt. Tupel, Listen und Wörterbücher sind allesamt Container. Teil des referenzierten Containerwerts. Wenn wir über den Wert eines Containers sprechen, beziehen wir uns meistens auf die Menge der Objektwerte, die der Container enthält, und nicht auf die Menge der Identitäten der Objekte. wir implizieren die Identität der darin enthaltenen Objekte. Wenn also ein unveränderliches Objekt (z. B. ein Tupel) einen Verweis auf ein veränderliches Objekt enthält, ändert sich bei einer Änderung des veränderlichen Objekts auch sein Wert.

Typen beeinflussen das meiste Verhalten eines Objekts. In einigen Fällen wird sogar die Bedeutung der Identität des Objekts beeinflusst: Bei unveränderlichen Typen kann die Berechnung eines neuen Werts tatsächlich einen Verweis auf ein vorhandenes Objekt mit demselben Wert und Typ zurückgeben, während dies bei veränderlichen Objekten unmöglich ist. Nachdem beispielsweise die Anweisung a = 1; b = 1 ausgeführt wurde, können sich a und b abhängig von der Interpreterimplementierung auf dasselbe Objekt mit demselben Wert beziehen oder auch nicht. Aber nachdem die Anweisung c = []; d = [] ausgeführt wurde, ist garantiert, dass c und d auf unterschiedliche und eindeutige neu erstellte leere Listen verweisen. (Beachten Sie, dass c = d = [] c und d dasselbe Objekt zuweist)

Hinweis: Das Obige wurde aus „The Python Language References“ übersetzt #Daten Modell# Objekts, Werte, Typen》Version 3.6.1.

1.2 Objektzusammenfassung

Das offizielle Dokument hat das Python Objekt im Detail beschrieben. Hier ist eine Zusammenfassung.

Drei Eigenschaften von Objekten:

• Identität
  Identifiziert das Objekt eindeutig; CPython Der Interpreter ist als Objekt implementiert Speicheradresse.
  Operation: id(), integrierte Funktion id() gibt eine Ganzzahl zurück, die das Objekt identifiziert; is vergleicht die Identitäten zweier Objekte.
  Beispiel:

  >>> id(1)
  1470514832
  >>> 1 is 1
  True

  Nach dem Login kopieren

• Typ
  bestimmt die vom Objekt unterstützten Operationen, mögliche Werte;
  Operation: type(), integrierte Funktion gibt den Typ des Objekts zurück
  Beispiel:

  >>> type('a')
  <class></class>

  Nach dem Login kopieren

• Wert
  Daten, veränderlich/unveränderlich
  Operation: Der ==-Operator wird verwendet, um zu vergleichen, ob die Werte zweier Objekte gleich sind. Andere -Vergleichsoperatoren vergleichen die Größe von Objekten.
  Beispiel:

  >>> 'python'
  'python'
  >>> 1 == 2
  False

  Nach dem Login kopieren

Veränderlich und unveränderlich : Es wird allgemein angenommen, dass Objekte mit unveränderlichen Werten unveränderliche Objekte und Objekte mit variablen Werten sind Es handelt sich um ein veränderliches Objekt. Beachten Sie jedoch, dass das unveränderliche Sammlungsobjekt veränderbare Objektreferenzmitglieder enthält. Objekte in

Python:

# -*- coding: utf-8 -*-# filename: hello.py'a test module'author = 'Richard Cheng'import sysclass Person(object):    ''' Person class'''

    def init(self, name, age):        self.name = name        self.age = agedef tset():    print(sys.path)
    p = Person('Richard', 20)    print(p.name, ':', p.age)def main():
    tset()if name == 'main':
    main()

Dieser AbsatzPython Der Code enthält viele Objekte, darunter das hello-Modulobjekt, das erstellte Person-Klassenobjekt, verschiedene Funktionen wie test, main-Funktionsobjekte, Zahlen, Zeichenfolgen und sogar der Code selbst ist ebenfalls ein Objekt.

2. Der Name ist „Variable“

Streng genommen gibt es ein Wort für „Variable“ in Python Variablen werden besser als Namen bezeichnet.

Die folgende Übersetzung stammt aus Code Like a Pythonista: Idiomatisches Python # Python hat „Namen“

2.1 Andere Sprachen haben Variablen

In anderen Sprachen wird ein Wert zugewiesen zu einer Variablen ist wie Der Wert wird in das „Feld“ gelegt.
int a = 1;

Das Feld a hat jetzt eine Ganzzahl 1.

Ersetzen Sie den Inhalt der Box, indem Sie derselben Variablen einen Wert zuweisen:
a =2;

Jetzt enthält die Box a einen Ganzzahl2

Weisen Sie eine Variable einer anderen zu, kopieren Sie den Wert der Variablen und fügen Sie ihn in das neue Feld ein:
int b = a;

b ist das zweite Feld, das eine Kopie der Ganzzahl 2 enthält. Box a hat eine separate Kopie.

2.2 Python hat Namen In

Python ist ein Name oder Bezeichner so, als würde man eine Bezeichnung an ein Objekt binden.
a = 1

这里，整数对象1有一个叫做a的标签。

如果重新给a分配值，只是简单的将标签移动到另一个对象：
a = 2

现在名字a贴到了整数对象2上面。原来的整数对象1不再拥有标签a，或许它还存在，但是不能通过标签a访问它了(当对象没有任何引用时，会被回收。)

如果将一个名字分配给另一名字，只是将另一个名字标签捆绑到存在的对象上：
b = a

名字b只是绑定到与a引用的相同对象上的第二个标签而已。

虽然在Python中普遍使用“变量”(因为“变量”是普遍术语)，真正的意思是名字或者标识符。Python中的变量是值得标签，不是装值得盒子。

2.3 指针？引用？名字？

C/C++中有指针，Java中有引用，Python中的名字在一定程度上等同于指针和引用。

2.1节中其他语言的例子，也只是针对于它们的基本类型而言的，若是指针或者引用，表现也跟Python的名字一样。这也在一定程度上说明了Python将面向对象贯彻得更加彻底。

2.4 名字支持的操作

可以对一个变量做什么？声明变量，使用变量，修改变量的值。名字作为Python中的一个重要概念，可以对它做的操作有：

• 定义；名字需要先定义才能使用，与变量需要先声明一样。

• 绑定：名字的单独存在没有意义，必须将它绑定到一个对象上。

• Python-Objekte, Namen und Bindungen：名字可以重新引用另一个对象，这个操作就是Python-Objekte, Namen und Bindungen。

• 引用：为什么要定义名字，目的是使用它。

3、绑定的艺术

名字以及对象，它们之间必然会发生些什么。

3.1 变量的声明

其他如C/C++和Java的高级语言，变量在使用前需要声明，或者说定义。以下在Java中声明变量：

public static void main(String[] args) {        int i = 0; // 先声明，后使用
        System.out.println(i); // 使用变量i}

这样，在可以访问到变量i所在作用域的地方，既可以使用i了。还有其他声明变量的方法么？好像没有了。

3.2 名字的定义

Python中有多种定义名字的途径，如函数定义，函数名就是引用函数对象的名字；类定义，类名就是指向类对象的名字，模块定义，模块名就是引用模块对象的名字；当然，最直观的还是赋值语句。

赋值语句

官方对赋值语句做了这样的说明(地址)：

Assignment statements are used to (re)bind names to values and to modify attributes or items of mutable objects.

即：

赋值语句被用来将名字绑定或者Python-Objekte, Namen und Bindungen给值，也用来修改可变对象的属性或项

那么，我们关心的，就是赋值语句将名字和值(对象)绑定起来了。

看一个简单的赋值语句：

a = 9

Python在处理这条语句时:

1. 首先在内存中创建一个对象，表示整数9:

1. 然后创建名字a，并把它指向上述对象：

上述过程就是通过赋值语句的名字对象绑定了。名字首次和对象绑定后，这个名字就定义在当前命名空间了，以后，在能访问到这个命名空间的作用域中可以引用该名字了。

3.3 引用不可变对象

定义完名字之后，就可以使用名字了，名字的使用称为“引用名字”。当名字指向可变对象和不可变对象时，使用名字会有不同的表现。

a = 9       #1a = a + 1   #2

语句1执行完后，名字a指向表示整数9的对象：

由于整数是不可变对象，所以在语句2处引用名字a，试图将表示整数9的对象 + 1，但该对象的值是无法改变的。因此就将该对象表示的整数值9加1，以整数10新建一个整数对象：

接下来，将名字a Python-Objekte, Namen und Bindungen 到新建对象上，并移除名字对原对象的引用：

使用id()函数，可以看到名字a指向的对象地址确实发生了改变：

>>> a = 9>>> id(a)1470514960>>> a = a + 1>>> id(a)1470514976

3.4 引用可变对象

3.4.1 示例1：改变可变对象的值

可变对象可以改变其值，并且不会造成地址的改变：

>>> list1 = [1]>>> id(list1)42695136>>> list1.append(2)>>> id(list1)42695136>>> list1
[1, 2]>>>

执行语句list1 = [1]，创建一个list对象，并且其值集中添加1，将名字list1指向该对象：

执行语句list1.append(2)，由于list是可变对象，可以直接在其值集中添加2：

值得改变并没有造成list1引用的对象地址的改变。

3.4.2 示例2：可变对象Python-Objekte, Namen und Bindungen

再来看一个比较“奇怪”的例子：

values = [1, 2, 3]
values[1] = valuesprint(values)

一眼望去，期待的结果应该是

[1, [1, 2, 3], 3]

但实际上结果是：

[1, [...], 3]

我们知道list中的元素可以是各种类型的，list类型是可以的：

3.4.3 示例3：Python-Objekte, Namen und Bindungen可变对象

观察以下代码段：

>>> list1 = [1]>>> id(list1)42695136>>> list1 = [1, 2]>>> id(list1)42717432

两次输出的名字list1引用对象的地址不一样，这是因为第二次语句list 1 = [1, 2] 对名字做了Python-Objekte, Namen und Bindungen：

3.5 共享对象

当两个或两个以上的名字引用同一个对象时，我们称这些名字共享对象。共享的对象可变性不同时，表现会出现差异。

3.5.1 共享不可变对象

函数attempt_change_immutable将参数i的值修改为2

def attempt_change_immutable(i):
    i = 2i = 1print(i)
attempt_change_immutable(i)print(i)

Output:

11

如果你对输出不感到意外，说明不是新手了 ^_^。

1. 首先，函数的参数i与全局名字i不是在同一命名空间中，所以它们之间不相互影响。

2. 调用函数时，将两个名字i都指向了同一个整数对象。

3. 函数中修改i的值为2, 因为整数对象不可变，所以新建值为2的整数对象，并把函数中的名字i绑定到对象上。

4. 全局名字i的绑定关系并没有被改变。

值得注意的是，这部分内容与命名空间和作用域有关系，另外有文章介绍它们，可以参考。

3.5.2 Python-Objekte, Namen und Bindungen

函数attempt_change_mutable为列表增加字符串。

def attempt_change_mutable(list_param):
    list_param.append('test')

list1 = [1]print(list1)
attempt_change_mutable(list1)print(list1)

output:

[1]
[1, 'test']

可以看到函数成功改变了列表list1的值。传递参数时，名字list_param引用了与名字list1相同的对象，这个对象是可变的，在函数中成功修改了对象的值。

首先，名字list_param与名字list1指向对象：

然后，通过名字list_param修改了对象的值：

最后，这个修改对名字list1可见。

3.6 绑定何时发生

总的来说，触发名字对象绑定的行为有以下一些：

• 赋值操作；a = 1

• 函数定义；

  def test():
      pass

  Nach dem Login kopieren

  将名字test绑定到函数对象

• 类定义：

  class Test(object):
      pass

  Nach dem Login kopieren

  将名字Test绑定到类对象

• 函数传参；

  def test(i):
      pass
  test(1)

  Nach dem Login kopieren

  将名字i绑定到整数对象1

• import语句：

  import sys

  Nach dem Login kopieren

  将名字sys绑定到指定模块对象。

• <a href="//m.sbmmt.com/wiki/125.html" target="_blank">for</a>循环

  for i in range(10):
      pass

  Nach dem Login kopieren

  每次循环都会绑定/Python-Objekte, Namen und Bindungen名字i

• as操作符

  with open('dir', 'r') as f:
      pass
  
  try:
      pass
  except NameError as ne:
      pass

  Nach dem Login kopieren

  with open语句，异常捕获语句中的as都会发生名字的绑定

  4、其他说明

  待续。。。

  参考

  1. The Python Language References#Data model# Objects, values, types

  2. Python的名字绑定

  3. Python一切皆对象

  4. Code Like a Pythonista: Idiomatic Python

  5. python基础（5）：深入理解 python 中的赋值、引用、拷贝、作用域

  脚注

  [1] 在特定的控制条件下，改变对象的类型是可能的。但不是一种明智的做法，如果处理不当的话，会发生一些奇怪的行为。

  Das obige ist der detaillierte Inhalt vonPython-Objekte, Namen und Bindungen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!