了解Python 二

Python是什么？

Python是面向对象，高级语言，解释，动态和多用途编程语言。Python易于学习，而且功能强大，功能多样的脚本语言使其对应用程序开发具有吸引力。
Python的语法和动态类型具有其解释性质，使其成为许多领域的脚本编写和快速应用程序开发的理想语言。

Python支持多种编程模式，包括面向对象编程，命令式和函数式编程或过程式编程。

Python几乎无所不能，一些常用的开发领域，如Web编程。这就是为什么它被称为多用途，因为它可以用于网络，企业，3D CAD等软件和系统开发。

在Python中，不需要使用数据类型来声明变量，因为它是动态类型的，所以可以写一个如 a=10 来声明一个变量a中的值是一个整数类型。

Python使开发和调试快速，因为在python开发中没有包含编译步骤，并且编辑 <-> 测试 <-> 调试循环使用代码开发效率非常高。

Python是一种高级，解释，交互和面向对象的脚本语言。 Python被设计为高度可读性。 它使用英语关键字，而其他语言使用标点符号。它的语法结构比其他语言少。

• Python是解释型语言 Python代码在解释器中运行时处理，执行前不需要编译程序。 这与PERL和PHP类似。
• Python是交动的 在Python提示符下面直接和解释器进行交互来编写程序。
• Python是面向对象的 Python支持面向对象的风格或编程技术，将代码封装在对象内。
• Python是一门初学者的语言 Python是初学者程序员的伟大语言，并支持从简单的文本处理到WWW浏览器到游戏的各种应用程序的开发。

Python可以开发哪些程序？

Python作为一个整体可以用于任何软件开发领域。下面来看看Python可以应用在哪些领域的开发。如下所列 -

1.基于控制台的应用程序

Python可用于开发基于控制台的应用程序。 例如：IPython。

2.基于音频或视频的应用程序

Python在多媒体部分开发，证明是非常方便的。 一些成功的应用是：TimPlayer，cplay等。

3.3D CAD应用程序

Fandango是一个真正使用Python编写的应用程序，提供CAD的全部功能。

4.Web应用程序

Python也可以用于开发基于Web的应用程序。 一些重要的开发案例是：PythonWikiEngines，Pocoo，PythonBlogSoftware等，如国内的成功应用案例有：豆瓣，知乎等。

5.企业级应用

Python可用于创建可在企业或组织中使用的应用程序。一些实时应用程序是：OpenErp，Tryton，Picalo等。

6.图像应用

使用Python可以开发图像应用程序。 开发的应用有：VPython，Gogh，imgSeek等

Python安装和环境配置

Python 3适用于Windows，Mac OS和大多数Linux操作系统。即使Python 2目前可用于许多其他操作系统，有部分系统Python 3还没有提供支持或者支持了但被它们在系统上删除了，只保留旧的Python 2版本。

在本教程中，我们重点讲解如何在 Windows 10 和 Ubuntu 系统上安装 Python 3 的最新版本(当前新版本：Python 3.6.1)。

在Windows 10上安装Python 3

最新版本的Python 3(Python 3.5.1)的二进制文件可从Python官方网站的下载页面： http://www.python.org/downloads/windows/ 下载，可以使用以下不同的安装选项 -

这里选择： 下载Windows x86-64 executable installer 下载。下载完成后，双击 python-3.6.1-amd64.exe 可执行文件。

第一步：双击 python-3.6.1-amd64.exe 可执行文件，如下所示 -

第二步：选择“Cusomize installation“，如下所示 -

第三步：选择“Next>“，这里选择安装在 D:\Program Files\Python36，如下所示 -

第四步：开始安装 “Install“ ，如下 -

第五步：安装完成后选择关闭(Close)，如下所示 -

测试安装结果

由于我们在安装的第一步中，已经选择了“Add Python 3.6 to PATH”了，所以这里不需要单独去设置环境变量了。如果没有选择此项，则应该需要将Python 3.6添加到环境变量。
假设您已经按照上面的步骤来安装完成，现在打开命令提示符，并在其中输入 python，然后回车 -

到此，在 Windows 10 系统上安装 Python 3.6 已经完成了。

在Ubuntu上安装Python 3

首先来看看当 Ubuntu 系统上安装的是什么版本的 Python，在终端上输入 python，如下所示 -

yiibai@ubuntu:~$ python -version
The program 'python' can be found in the following packages:
 * python-minimal
 * python3
Try: sudo apt install <selected package>
yiibai@ubuntu:~$

在上面显示结果中，还没有安装 Python 。

第一种情况：
如果使用的是Ubuntu 14.04或16.04，则可以使用J Fernyhough的PPA： http://launchpad.net/~jonathonf/+archive/ubuntu/python-3.6 来安装Python 3.6：

sudo add-apt-repository ppa:jonathonf/python-3.6
sudo apt-get update
sudo apt-get install python3.6

第二种情况：
如果使用的是Ubuntu 16.10或17.04，则Python 3.6位于Universe存储库中，直接升级 apt-get，然后再安装即可 -

sudo apt-get update
sudo apt-get install python3.6

现在，查看 Ubuntu 的当前版本 -

yiibai@ubuntu:~$ sudo lsb_release -a
[sudo] password for yiibai:
No LSB modules are available.
Distributor ID: Ubuntu
Description:    Ubuntu 16.04.1 LTS
Release:        16.04
Codename:       xenial
yiibai@ubuntu:~$

提示：Ubuntu无法找到add-apt-repository问题的解决方法,执行安装命令：apt-get install python-software-properties，除此之外还要安装 apt-get install software-properties-common，然后就能用add-apt-repository了。

根据上面显示的系统信息，系统版本是：Ubuntu 16.04.1 LTS，所以属于第一种情况安装 Python 3.6，所以完整的安装步骤如下 -

sudo apt-get install python-software-properties
sudo apt-get install software-properties-common
sudo add-apt-repository ppa:jonathonf/python-3.6
sudo apt-get update
sudo apt-get install python3.6

注意，上面命令执行可能会出现中断或错误的情况，可尝试多执行几次。

当上面命令成功执行完成后，默认情况下，它也会安装了一个 Python 2.7，在命令行提示符下输入：python，那么它使用的是 Python 2.7，如果要使用 Python 3.6，那么可以直接输入：python3.6，验证安装结果如下所示 -

从源代码编译安装 Python 3.6
或者，如果您有时间和精力，也可以尝试从源代码编译来安装 Python 3.6 。源代码下载地址：http://www.python.org/ftp/python/3.6.1/

首先，需要使用以下命令安装一些构建依赖项。

sudo apt install build-essential checkinstall

sudo apt install libreadline-gplv2-dev libncursesw5-dev libssl-dev libsqlite3-dev tk-dev libgdbm-dev libc6-dev libbz2-dev

然后，从python.org下载Python 3.6源代码。

wget http://www.python.org/ftp/python/3.6.0/Python-3.6.0.tar.xz

接下来，解压缩tarball。

tar xvf Python-3.6.0.tar.xz

现在cd进入源目录，配置构建环境并进行安装。

cd Python-3.6.0/

./configure

sudo make altinstall

使altinstall命令跳过创建符号链接，所以/usr/bin/python仍然指向旧版本的Python，保证Ubuntu系统将不会中断。

完成完成后，可以通过键入以下命令来使用Python 3.6：

$ python3.6

以下是所有可用命令行选项的列表 -

编号	选项	说明
1	-d	提供调试输出
2	-O	生成优化的字节码(结果为.pyo文件)
3	-S	启动时不要运行导入站点来寻找Python路径
4	-v	详细输出(import语句的详细跟踪)
5	-X	禁用基于类的内置异常(仅使用字符串); 从版本1.6开始已经过时了
6	-c cmd	运行Python脚本作为cmd字符串发送
7	file	从给定运行的Python脚本文件

命令行脚本

通过在应用程序中调用解释器，可以在命令行中执行Python脚本，如以下示例所示。

$python  script.py          # Unix/Linux

or 

python% script.py           # Unix/Linux

or 

C:>python script.py         # Windows/DOS

注意 - 确保文件权限模式允许执行。

集成开发环境

如果您的系统上支持Python的GUI应用程序，也可以从图形用户界面(GUI)环境运行Python。

Unix - IDLE是第一个用于Python的Unix IDE。

Windows - PythonWin是Python的第一个Windows图形用户界面，是具有GUI的IDE。

Macintosh - Macintosh版本的Python以及IDLE IDE可从主网站获取，可作为MacBinary或BinHex’d文件下载。

如果您无法正确设置环境，则可以通过向系统管理员寻求帮助。确保Python环境设置正确，以正常工作。

注 - 后续章节中给出的所有示例都是使用Windows 7和Ubuntu Linux上提供的Python 3.6.1版本来执行。

---

---

---

Python面向对象（类和对象）

自从存在以来，Python一直是面向对象的语言。 因此，创建和使用类和对象是非常容易的。 本章将学习如何使用Python面向对象编程。

如果您以前没有面向对象(OO)编程的经验，可能需要查阅介绍面向对象(OO)编程课程或至少学习一些有关教程，以便掌握基本概念。

下面是面向对象编程(OOP)的一个小介绍，以帮助您快速入门学习 -

OOP术语概述

• 类 -
  用于定义表示用户定义对象的一组属性的原型。属性是通过点符号访问的数据成员(类变量和实例变量)和方法。

• 类变量
  由类的所有实例共享的变量。 类变量在类中定义，但在类的任何方法之外。 类变量不像实例变量那样频繁使用。

• 数据成员 -
  保存与类及其对象相关联的数据的类变量或实例变量。

• 函数重载 -
  将多个行为分配给特定函数。 执行的操作因涉及的对象或参数的类型而异。

• 实例变量 -
  在方法中定义并仅属于类的当前实例的变量。

• 继承 -
  将类的特征传递给从其派生的其他类。

• 实例 -
  某个类的单个对象。 例如，对象obj属于Circle类，它是Circle类的实例。

• 实例化 -
  创建类的实例。

• 方法 -
  在类定义中定义的一种特殊类型的函数。

• 对象 -
  由其类定义的数据结构的唯一实例。对象包括数据成员(类变量和实例变量)和方法。

• 运算符重载 -
  将多个函数分配给特定的运算符。

1.创建类

class语句创建一个新的类定义。 类的名称紧跟在class关键字之后，在类的名称之后紧跟冒号，如下 -

class ClassName:
   'Optional class documentation string'
   class_suite

• 该类有一个文档字符串，可以通过ClassName.doc访问。
• class_suite由定义类成员，数据属性和函数的所有组件语句组成。

示例

以下是一个简单的Python类的例子 -

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)

• 变量empCount是一个类变量，其值在此类中的所有实例之间共享。 这可以从类或类之外的Employee.empCount访问。
• 第一个方法init ()是一种特殊的方法，当创建此类的新实例时，该方法称为Python构造函数或初始化方法。

声明其他类方法，如正常函数，但每个方法的第一个参数是self。 Python将self参数添加到列表中; 调用方法时不需要包含它。

2.创建实例对象

要创建类的实例，可以使用类名调用该类，并传递其init方法接受的任何参数。

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

3.访问属性

可以使用带有对象的点(.)运算符来访问对象的属性。 类变量将使用类名访问如下 -

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

现在把所有的概念放在一起 -

#!/usr/bin/python3

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("Maxsu", 2000)
#This would create second object of Employee class"
emp2 = Employee("Kobe", 5000)
emp1.displayEmployee()
emp2.displayEmployee()
print ("Total Employee %d" % Employee.empCount)

当执行上述代码时，会产生以下结果 -

Name :  Maxsu ,Salary:  2000
Name :  Kobe ,Salary:  5000
Total Employee 2

可以随时添加，删除或修改类和对象的属性 -

emp1.salary = 7000  # Add an 'salary' attribute.
emp1.name = 'xyz'  # Modify 'age' attribute.
del emp1.salary  # Delete 'age' attribute.

如果不是使用普通语句访问属性，可以使用以下函数 -

• getattr(obj，name [，default]) - 访问对象的属性。
• hasattr(obj，name) - 检查属性是否存在。
• setattr(obj，name，value) - 设置一个属性。如果属性不存在，那么它将被创建。
• delattr(obj，name) - 删除一个属性。

下面是一此使用示例 -

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

3.内置类属性

每个Python类保持以下内置属性，并且可以像任何其他属性一样使用点运算符访问它们 -

• dict - 包含该类的命名空间的字典。
• doc - 类文档字符串或无，如果未定义。
• name - 类名。
• module - 定义类的模块名称。此属性在交互模式下的值为“main”。
• bases - 一个包含基类的空元组，按照它们在基类列表中出现的顺序。

对于上述类，尝试访问所有这些属性 -

#!/usr/bin/python3

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)

emp1 = Employee("Maxsu", 2000)
emp2 = Employee("Bryant", 5000)
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__ )

当执行上述代码时，会产生以下结果 -

Employee.__doc__: Common base class for all employees
Employee.__name__: Employee
Employee.__module__: __main__
Employee.__bases__: (<class 'object'>,)
Employee.__dict__: {
   'displayCount': <function Employee.displayCount at 0x0160D2B8>, 
   '__module__': '__main__', '__doc__': 'Common base class for all employees', 
   'empCount': 2, '__init__': 
   <function Employee.__init__ at 0x0124F810>, 'displayEmployee': 
   <function Employee.displayEmployee at 0x0160D300>,
   '__weakref__': 
   <attribute '__weakref__' of 'Employee' objects>, '__dict__': 
   <attribute '__dict__' of 'Employee' objects>
}

4.销毁对象(垃圾收集)

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

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

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

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

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

通常情况下，垃圾回收器会销毁孤立的实例并回收其空间。 但是，类可以实现调用析构函数的特殊方法del()，该方法在实例即将被销毁时被调用。 此方法可能用于清理实例使用的任何非内存资源。

示例

这个del()析构函数打印要被销毁的实例的类名 -

#!/usr/bin/python3

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
print (id(pt1), id(pt2), id(pt3));   # prints the ids of the obejcts
del pt1
del pt2
del pt3

当执行上述代码时，会产生以下结果 -

3083401324 3083401324 3083401324
Point destroyed

注意 - 理想情况下，应该在单独的文件中定义类，然后使用import语句将其导入主程序文件。

在上面的例子中，假定Point类的定义包含在point.py中，并且其中没有其他可执行代码。

#!/usr/bin/python3
import point
p1 = point.Point()

5.类继承

使用类继承不用从头开始构建代码，可以通过在新类名后面的括号中列出父类来从一个预先存在的类派生它来创建一个类。

子类继承其父类的属性，可以像子类中一样定义和使用它们。子类也可以从父类代替代数据成员和方法。

语法

派生类被声明为很像它们的父类; 然而，继承的基类的列表在类名之后给出 -

class SubClassName (ParentClass1[, ParentClass2, ...]):
   'Optional class documentation string'
   class_suite

示例

#!/usr/bin/python3

class Parent:        # define parent class
   parentAttr = 100
   def __init__(self):
      print ("Calling parent constructor")

   def parentMethod(self):
      print ('Calling parent method')

   def setAttr(self, attr):
      Parent.parentAttr = attr

   def getAttr(self):
      print ("Parent attribute :", Parent.parentAttr)

class Child(Parent): # define child class
   def __init__(self):
      print ("Calling child constructor")

   def childMethod(self):
      print ('Calling child method')

c = Child()          # instance of child
c.childMethod()      # child calls its method
c.parentMethod()     # calls parent's method
c.setAttr(200)       # again call parent's method
c.getAttr()          # again call parent's method

当执行上述代码时，会产生以下结果 -

Calling child constructor
Calling child method
Calling parent method
Parent attribute : 200

以类似的方式，可以从多个父类来构建一个新的类，如下所示：

class A:        # define your class A
.....

class B:         # define your calss B
.....

class C(A, B):   # subclass of A and B
.....

可以使用issubclass()或isinstance()函数来检查两个类和实例之间的关系。

• issubclass(sub，sup)布尔函数如果给定的子类sub确实是超类sup的子类返回True。
• isinstance(obj，Class)布尔函数如果obj是类Class的一个实例，或者是类的一个子类的实例则返回True。

重载方法

可以随时重载父类的方法。 重载父方法的一个原因是：您可能希望在子类中使用特殊或不同的方法功能。

示例

#!/usr/bin/python3

class Parent:        # define parent class
   def myMethod(self):
      print ('Calling parent method')

class Child(Parent): # define child class
   def myMethod(self):
      print ('Calling child method')

c = Child()          # instance of child
c.myMethod()         # child calls overridden method

当执行上述代码时，会产生以下结果 -

Calling child method

基本重载方法

下表列出了可以在自己的类中覆盖的一些通用方法 -

编号	方法	描述	调用示例
1	init ( self [,args…] )	构造函数(带任意可选参数)	obj = className(args)
2	del( self )	析构函数，删除一个对象	del obj
3	repr( self )	可评估求值的字符串表示	repr(obj)
4	str( self )	可打印的字符串表示	str(obj)
5	cmp ( self, x )	对象比较	cmp(obj, x)

6.重载运算符

假设已经创建了一个Vector类来表示二维向量。当使用加号(+)运算符执行运算时，它们会发生什么？ 很可能Python理解不了你想要做什么。

但是，可以在类中定义add方法来执行向量加法，然后将按照期望行为那样执行加法运算 -

示例

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

当执行上述代码时，会产生以下结果 -

Vector(7,8)

7.数据隐藏

对象的属性在类定义之外可能或不可见。需要使用双下划线前缀命名属性，然后这些属性将不会直接对外部可见。

示例

#!/usr/bin/python3

class JustCounter:
   __secretCount = 0

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

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

当执行上述代码时，会产生以下结果 -

1
2
Traceback (most recent call last):
   File "test.py", line 12, in <module>
      print counter.__secretCount
AttributeError: JustCounter instance has no attribute '__secretCount'

Python通过内部更改名称来包含类名称来保护这些成员。 可以访问object._className__attrName等属性。如果将最后一行替换为以下，那么它适用于 -

.........................
print (counter._JustCounter__secretCount)

当执行上述代码时，会产生以下结果 -

1
2
2

Python构造函数

构造函数是一种特殊类型的方法(函数)，它在类的实例化对象时被调用。 构造函数通常用于初始化(赋值)给实例变量。 构造函数还验证有足够的资源来使对象执行任何启动任务。

创建一个构造函数

构造函数是以双下划线()开头的类函数。构造函数的名称是__init()。

创建对象时，如果需要，构造函数可以接受参数。当创建没有构造函数的类时，Python会自动创建一个不执行任何操作的默认构造函数。

每个类必须有一个构造函数，即使它只依赖于默认构造函数。

举一个例子：

创建一个名为ComplexNumber的类，它有两个函数init()函数来初始化变量，并且有一个getData()方法用来显示数字。

看这个例子：

#!/usr/bin/python3
#coding=utf-8

class ComplexNumber:

    def __init__(self, r = 0, i = 0):
        """"初始化方法"""
        self.real = r 
        self.imag = i 

    def getData(self):
        print("{0}+{1}j".format(self.real, self.imag))

if __name__ == '__main__':
    c = ComplexNumber(5, 6)
    c.getData()

执行上面代码，得到以下结果 -

5+6j

可以为对象创建一个新属性，并在定义值时进行读取。但是不能为已创建的对象创建属性。

看这个例子：

#!/usr/bin/python3
#coding=utf-8

class ComplexNumber:

    def __init__(self, r = 0, i = 0):
        """"初始化方法"""
        self.real = r 
        self.imag = i 

    def getData(self):
        print("{0}+{1}j".format(self.real, self.imag))

if __name__ == '__main__':
    c = ComplexNumber(5, 6)
    c.getData()

    c2 = ComplexNumber(10, 20)
    # 试着赋值给一个未定义的属性
    c2.attr = 120
    print("c2 = > ", c2.attr)

    print("c.attr => ", c.attr)

执行上面代码，得到以下结果 -

5+6j
c2 = >  120
Traceback (most recent call last):
  File "D:\test.py", line 23, in <module>
    print("c.attr => ", c.attr)
AttributeError: 'ComplexNumber' object has no attribute 'attr'

Python继承

什么是继承？

继承用于指定一个类将从其父类获取其大部分或全部功能。 它是面向对象编程的一个特征。 这是一个非常强大的功能，方便用户对现有类进行几个或多个修改来创建一个新的类。新类称为子类或派生类，从其继承属性的主类称为基类或父类。

子类或派生类继承父类的功能，向其添加新功能。 它有助于代码的可重用性。

下图表示：

语法-1

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

语法-2

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

参数说明

必须在包含派生类定义的范围中定义名称BaseClassName。还可以使用其他任意表达式代替基类名称。 当在另一个模块中定义基类时要指定模块的名称。

Python继承示例

我们来看一个简单的python继承示例，在这个示例中使用两个类：Animal和Dog。Animal是父类或基类，Dog是Animal的子类。

在这里，在Animal类中定义了eat()方法，Dog类中定义了bark()方法。 在这个例子中，我们创建Dog类的实例，并且仅通过子类的实例调用eat()和bark()方法。 由于父属性和行为自动继承到子对象，所以通过子实例也可以调用父类和子类的方法。

class Animal:   
    def eat(self):  
      print 'Eating...'  
class Dog(Animal):     
   def bark(self):  
      print 'Barking...'  

d=Dog()  
d.eat()  
d.bark()

执行上面代码，得到以下结果 -

Eating...  
Barking...

Python多重继承

在本文中，您将了解Python中的多重继承以及如何在程序中使用它。还将了解多级继承和方法解析顺序。

与C++一样，一个类可以从Python中的多个基类派生出来。这被称为多重继承。

在多重继承中，所有基类的特征都被继承到派生类中。多重继承的语法类似于单继承。

Python多重继承示例

class Base1:
    pass

class Base2:
    pass

class MultiDerived(Base1, Base2):
    pass

这里，MultiDerived派生自Base1和Base2类。

MultiDerived类从Base1和Base2继承。

Python中的多层继承

另一方面，我们也可以继承一个派生类的形式。这被称为多级继承。 它可以在Python中有任何的深度(层级)。在多级继承中，基类和派生类的特性被继承到新的派生类中。
下面给出了具有相应可视化的示例。

class Base:
    pass

class Derived1(Base):
    pass

class Derived2(Derived1):
    pass

这里，Derived1派生自Base，Derived2派生自Derived1。

Python中的方法解析顺序

Python中的每个类都派生自类:object。它是Python中最基础的类型。

所以在技术上，所有其他类，无论是内置还是用户定义，都是派生类，所有对象都是对象类的实例。

# Output: True
print(issubclass(list,object))

# Output: True
print(isinstance(5.5,object))

# Output: True
print(isinstance("Hello",object))

在多继承方案中，在当前类中首先搜索任何指定的属性。如果没有找到，搜索继续进入父类，深度优先，再到左右的方式，而不需要搜索相同的类两次。