Python 简明教程

Python - Classes and Objects

Python 是一种 object-oriented programming language ，这意味着它基于 OOP 概念的原则。在 Python 程序中使用的实体是某个类的一个对象。例如，数字、字符串、列表、字典以及程序的其他类似实体是相应内置类的对象。

Python is an object-oriented programming language, which means that it is based on principle of OOP concept. The entities used within a Python program is an object of one or another class. For instance, numbers, strings, lists, dictionaries, and other similar entities of a program are objects of the corresponding built-in class.

在 Python 中，名为 Object 的类是所有类的基础类或父类，既包括内置类也包括用户自定义类。

In Python, a class named Object is the base or parent class for all the classes, built-in as well as user defined.

What is a Class in Python?

在 Python 中，类是一种用户定义的实体（数据类型），它定义了对象可以包含的数据类型和它可以执行的操作。它用作创建对象的模板。例如，如果我们想要在 Python 程序中为智能手机定义一个类，我们可以使用数据类型（如 RAM、ROM、屏幕大小）和操作（如呼叫和消息）。

In Python, a class is a user defined entity (data types) that defines the type of data an object can contain and the actions it can perform. It is used as a template for creating objects. For instance, if we want to define a class for Smartphone in a Python program, we can use the type of data like RAM, ROM, screen-size and actions like call and message.

Creating Classes in Python

class 关键字用于在 Python 中创建新类。类的名称紧跟关键字 class，后跟一个冒号，如下所示 −

The class keyword is used to create a new class in Python. The name of the class immediately follows the keyword class followed by a colon as shown below −

class ClassName:
   'Optional class documentation string'
   class_suite

  1. The class has a documentation string, which can be accessed via ClassName.doc.

  2. The class_suite consists of all the component statements defining class members, data attributes and functions.

Example

以下是简单 Python 类的示例 −

Following is the example of a simple Python class −

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1

   def displayCount(self):
     print "Total Employee %d" % Employee.empCount

   def displayEmployee(self):
      print "Name : ", self.name,  ", Salary: ", self.salary

  1. The variable empCount is a class variable whose value is shared among all instances of a this class. This can be accessed as Employee.empCount from inside the class or outside the class.

  2. The first method init() is a special method, which is called class constructor or initialization method that Python calls when you create a new instance of this class.

  3. You declare other class methods like normal functions with the exception that the first argument to each method is self. Python adds the self argument to the list for you; you do not need to include it when you call the methods.

What is an Object?

对象被称为给定 Python 类的实例。每个对象都有自己的属性和方法，这些属性和方法由其类定义。

An object is refered to as an instance of a given Python class. Each object has its own attributes and methods, which are defined by its class.

当创建一个类时，它只描述了对象的结构。当从类实例化对象时分配内存。

When a class is created, it only describes the structure of obejcts. The memory is allocated when an object is instantiated from a class.

class object

在上图中，Vehicle 是类名，Car、Bus 和 SUV 是它的对象。

In the above figure, Vehicle is the class name and Car, Bus and SUV are its objects.

Creating Objects of Classes in Python

可以使用类名和传入其 ` init ` 方法接受的任何参数来创建类的实例。

To create instances of a class, you call the class using class name and pass in whatever arguments its init method accepts.

# This would create first object of Employee class
emp1 = Employee("Zara", 2000)
# This would create second object of Employee class
emp2 = Employee("Manni", 5000)

Accessing Attributes of Objects in Python

可以使用带有 object 的点运算符访问该对象的属性。类变量可以使用类名进行访问，方法如下：

You access the object’s attributes using the dot operator with object. Class variable would be accessed using class name as follows −

emp1.displayEmployee()
emp2.displayEmployee()
print ("Total Employee %d" % Employee.empCount)

现在，将所有概念组合在一起：

Now, putting all the concepts together −

class Employee:
   "Common base class for all employees"
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1

   def displayCount(self):
     print ("Total Employee %d" % Employee.empCount)

   def displayEmployee(self):
      print ("Name : ", self.name,  ", Salary: ", self.salary)

# This would create first object of Employee class
emp1 = Employee("Zara", 2000)
# This would create second object of Employee class
emp2 = Employee("Manni", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print ("Total Employee %d" % Employee.empCount)

执行上述代码后，将生成以下结果 −

When the above code is executed, it produces the following result −

Name :  Zara , Salary:  2000
Name :  Manni , Salary:  5000
Total Employee 2

可以随时添加、移除或修改类的属性和对象：

You can add, remove, or modify attributes of classes and objects at any time −

# Add an 'age' attribute
emp1.age = 7
# Modify 'age' attribute
emp1.age = 8
# Delete 'age' attribute
del emp1.age

除了使用常规语句来访问属性，还可以使用以下函数：

Instead of using the normal statements to access attributes, you can also use the following functions −

  1. getattr(obj, name[, default]) − to access the attribute of object.

  2. hasattr(obj,name) − to check if an attribute exists or not.

  3. setattr(obj,name,value) − to set an attribute. If attribute does not exist, then it would be created.

  4. delattr(obj, name) − to delete an attribute.

# Returns true if 'age' attribute exists
hasattr(emp1, 'age')
# Returns value of 'age' attribute
getattr(emp1, 'age')
# Set attribute 'age' at 8
setattr(emp1, 'age', 8)
# Delete attribute 'age'
delattr(empl, 'age')

Built-In Class Attributes in Python

Python 类遵循下列内置属性，可以使用点运算符访问这些属性，就像访问任何其他属性一样：

Every Python class keeps following built-in attributes and they can be accessed using dot operator like any other attribute −

SNo.

Attributes & Description

1

*dict*Dictionary containing the class’s namespace.

2

*doc*Class documentation string or none, if undefined.

3

*name*Class name

4

*module*Module name in which the class is defined. This attribute is "main" in interactive mode.

5

*bases*A possibly empty tuple containing the base classes, in the order of their occurrence in the base class list.

Example

对于上述 Employee 类，我们尝试访问其属性：

For the above Employee class, let us try to access its attributes −

class Employee:
   'Common base class for all employees'
   empCount = 0

   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1

   def displayCount(self):
     print ("Total Employee %d" % Employee.empCount)

   def displayEmployee(self):
      print ("Name : ", self.name,  ", Salary: ", self.salary)

print ("Employee.__doc__:", Employee.__doc__)
print ("Employee.__name__:", Employee.__name__)
print ("Employee.__module__:", Employee.__module__)
print ("Employee.__bases__:", Employee.__bases__)
print ("Employee.__dict__:", Employee.__dict__)

执行上述代码后，将生成以下结果 −

When the above code is executed, it produces the following result −

Employee.__doc__: Common base class for all employees
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: ()
Employee.__dict__: {'__module__': '__main__', 'displayCount':
<function displayCount at 0xb7c84994>, 'empCount': 2,
'displayEmployee': <function displayEmployee at 0xb7c8441c>,
'__doc__': 'Common base class for all employees',
'__init__': <function __init__ at 0xb7c846bc>}

Built-in Class of Python datatypes

如前所述，Python 遵循面向对象编程范式。字符串、列表和数据类型等实体属于一个或另一个内置类。

As mentioned earlier, Python follows object-oriented programming paradigm. Entities like strings, lists and data types belongs to one or another built-in class.

如果我们想要查看哪种数据类型属于哪个内置类，可以使用 Python 的 type() 函数。此函数接受数据类型并返回其对应的类。

If we want to see which data type belongs to which built-in class, we can use the Python type() function. This function accepts a data type and returns its corresponding class.

Example

以下示例演示如何检查给定数据类型的内置类。

The below example demonstrates how to check built-in class of a given data type.

num = 20
print (type(num))
num1 = 55.50
print (type(num1))
s = "TutorialsPoint"
print (type(s))
dct = {'a':1,'b':2,'c':3}
print (type(dct))
def SayHello():
   print ("Hello World")
   return
print (type(SayHello))

执行此代码后，它将显示 Python 数据类型对应的类：

When you execute this code, it will display the corresponding classes of Python data types −

<class 'int'>
<class 'float'>
<class 'str'>
<class 'dict'>
<class 'function'>

Garbage Collection(Destroying Objects) in Python

Python 自动删除不需要的对象（内置类型或类实例）以释放内存空间。Python 定期回收不再使用内存块的过程称为垃圾收集。

Python deletes unwanted objects (built-in types or class instances) automatically to free the memory space. The process by which Python periodically reclaims blocks of memory that no longer are in use is termed Garbage Collection.

Python 的垃圾回收器在程序执行期间运行，并在对象的引用计数达到零时触发。对象的引用计数会随着指向它的别名的数量而改变。

Python’s garbage collector runs during program execution and is triggered when an object’s reference count reaches zero. An object’s reference count changes as the number of aliases that point to it changes.

当对象被分配新名称或放置在容器（列表、元组或字典）中时，该对象的引用计数会增加。当对象被 del 删除、其引用被重新分配或其引用超出范围时，对象的引用计数会减少。当对象的引用计数为零时，Python 会自动收集它。

An object’s reference count increases when it is assigned a new name or placed in a container (list, tuple, or dictionary). The object’s reference count decreases when it’s deleted with del, its reference is reassigned, or its reference goes out of scope. When an object’s reference count reaches zero, Python collects it automatically.

# Create object 40
a = 40
# Increase ref. count  of 40
b = a
# Increase ref. count  of 40
c = [b]

# Decrease ref. count  of 40
del a
# Decrease ref. count  of 40
b = 100
# Decrease ref. count  of 40
c[0] = -1

当垃圾回收器销毁未使用的实例并回收其空间时，您通常不会注意到。但是，一个类可以实现一个特殊方法 del （），称为析构函数，该析构函数在即将销毁该实例时被调用。此方法可用于清理实例使用的任何非内存资源。

You normally will not notice when the garbage collector destroys an unused instance and reclaims its space. But a class can implement the special method del(), called a destructor, that is invoked when the instance is about to be destroyed. This method might be used to clean up any non memory resources used by an instance.

Example

当 del 的析构函数打印即将被销毁的实例的类名称，如下面的代码块所示 −

The del() destructor prints the class name of an instance that is about to be destroyed as shown in the below code block −

class Point:
   def __init__( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print (class_name, "destroyed")

pt1 = Point()
pt2 = pt1
pt3 = pt1
# prints the ids of the obejcts
print (id(pt1), id(pt2), id(pt3))
del pt1
del pt2
del pt3

执行时，上述代码将产生以下结果 −

On executing, the above code will produces following result −

135007479444176 135007479444176 135007479444176
Point destroyed

Data Hiding in Python

对象的属性在类定义的外部可能可见，也可能不可见。你需要以双下划线前缀为属性命名，那么这些属性就不能直接被外部人员看到。

An object’s attributes may or may not be visible outside the class definition. You need to name attributes with a double underscore prefix, and those attributes then are not be directly visible to outsiders.

Example

class JustCounter:
   __secretCount = 0

   def count(self):
      self.__secretCount += 1
      print self.__secretCount

counter = JustCounter()
counter.count()
counter.count()
print counter.__secretCount

执行上述代码后，将生成以下结果 −

When the above code is executed, it produces the following result −

1
2
ERROR!
Traceback (most recent call last):
  File <main.py>", line 11, in <module>
AttributeError: 'JustCounter' object has no attribute '__secretCount'

Python 通过在内部更改名称来包括类名称来保护这些成员。你可以将此类属性访问为 object._className__attrName。如果你将最后一行替换为以下内容，那么它就会对你起作用 −

Python protects those members by internally changing the name to include the class name. You can access such attributes as object._className__attrName. If you would replace your last line as following, then it works for you −

print(counter._JustCounter__secretCount)

执行上述代码后，将生成以下结果 −

When the above code is executed, it produces the following result −

1
2
2