python函数多态,多态Python

python面向对象的三大特征的用法和函数的用法一样吗

python面向对象的三大特征的用法和函数的用法一样。面向对象的三大特性是指封装、继承和多态。面向对象编程是一种编程方式，此编程方式的落地需要使用类和对象来实现，所以，面向对象编程其实就是对类和对象的使用。类就是一个模板，模板里可以包含多个函数，函数里实现一些功能对象则是根据模板创建的实例，通过实例对象可以执行类中的函数。

在巴林右旗等地区，都构建了全面的区域性战略布局，加强发展的系统性、市场前瞻性、产品创新能力，以专注、极致的服务理念，为客户提供网站设计、做网站 网站设计制作按需求定制开发,公司网站建设,企业网站建设,品牌网站建设,成都全网营销,外贸网站制作,巴林右旗网站建设费用合理。

python的三大特征

第一点：封装

隐藏对象的属性和实现细节，仅对外提供公共访问方式，在Python中用双下线开头的方式将属性设置成私有的。

拥有三个好处：将变化隔离，便于使用，提高复用性，提高安全性。

第二点：继承

继承是一种创建新类的方式，在Python中，新建的类可以继承一个或多个父类，父类又被称为基类或超类，新建的类称为派生类或子类。即一个派生类继承基类的字段和方法，继承也允许把一个派生类的对象作为一个基类对象对待。

第三点：多态

一种事物的多种体现形式，函数的重写其实就是多态的一种体现。Python中，多态指是父类的引用指向子类的对象。

实现多态的步骤：

1. 定义新的子类;

2. 重写对应的父类方法;

3. 使用子类的方法直接处理，不调用父类的方法;

多态的好处：

1. 增加了程序的灵活性;

2. 增加了程序的可扩展性。

java 多态与python多态

不一样。java的class只能继承一个parent，需要interface或者需要parent是abstract class；python的class可以继承多个parent，所以不需要interface，另外，因为python是dynamically typed，所以即使完全不继承parent，也可以做到多态。

Python类的继承与多态详细介绍

类(Class): 用来描述具有相同的属性和方法的对象的集合。

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

类有一个名为 __init__() 的特殊方法（构造方法），该方法在类实例化时会自动调用

self:self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。

类调用 Car.weight

实例化 car01=Car(5)

实例对象调用 car01.weght

我们在构造类时，Python3默认我们继承了object这个基类，我个人理解object就是个空的类，可以不用管为何要在括号中写上object，这是Python3的特性，在python2中如果你没有写object的话不会默认继承了object这个基类。

同样的我们自己希望继承的父类只需要把objetc改为我们自己定义的类名即可。子类中可以拥有父类中所有的公有属性和方法，但是可以通过在变量名前加下划线使其变为私有，这样子类就不可以访问父类中的成员了。

以下三个公交车类的父类均为客车类，我们可以写一个funcs方法使得每次调用funcs方法时，传入不同的对象以执行不同的func方法，具体实现如下：

主函数 ：

可以看到，我将小 汽车 实例化为带有重量为5t的一个具体对象，将客车实例化为带有重量为20t的一个具体对象，将三个公交车实例化为带有重量为15t的一个具体对象.

如上图所示，我每次在调用funcs方法时都传入了一个实例化对象，funcs根据不同的对象执行相应的内部方法。

python 函数参数的类型

1. 不同类型的参数简述

#这里先说明python函数调用得语法为：

复制代码

代码如下:

func(positional_args,

keyword_args,

*tuple_grp_nonkw_args,

**dict_grp_kw_args)

#为了方便说明,之后用以下函数进行举例

def test(a,b,c,d,e):

print a,b,c,d,e

举个例子来说明这4种调用方式得区别：

复制代码

代码如下:

#

#positional_args方式

test(1,2,3,4,5)

1 2 3 4 5

#这种调用方式的函数处理等价于

a,b,c,d,e = 1,2,3,4,5

print a,b,c,d,e

#

#keyword_args方式

test(a=1,b=3,c=4,d=2,e=1)

1 3 4 2 1

#这种处理方式得函数处理等价于

a=1

b=3

c=4

d=2

e=1

print a,b,c,d,e

#

#*tuple_grp_nonkw_args方式

x = 1,2,3,4,5

test(*x)

1 2 3 4

5

#这种方式函数处理等价于

复制代码

代码如下:

a,b,c,d,e = x

print

a,b,c,d,e

#特别说明:x也可以为dict类型,x为dick类型时将键传递给函数

y

{'a': 1,

'c': 6, 'b': 2, 'e': 1, 'd': 1}

test(*y)

a c b e d

#

#**dict_grp_kw_args方式

y

{'a': 1, 'c': 6, 'b': 2, 'e': 1, 'd': 1}

test(**y)

1 2 6

1 1

#这种函数处理方式等价于

a = y['a']

b = y['b']

... #c,d,e不再赘述

print

a,b,c,d,e

2.

不同类型参数混用需要注意的一些细节

接下来说明不同参数类型混用的情况,要理解不同参数混用得语法需要理解以下几方面内容.

首先要明白,函数调用使用参数类型必须严格按照顺序,不能随意调换顺序,否则会报错. 如 (a=1,2,3,4,5)会引发错误,;

(*x,2,3)也会被当成非法.

其次,函数对不同方式处理的顺序也是按照上述的类型顺序.因为#keyword_args方式和**dict_grp_kw_args方式对参数一一指定,所以无所谓顺序.所以只需要考虑顺序赋值(positional_args)和列表赋值(*tuple_grp_nonkw_args)的顺序.因此,可以简单理解为只有#positional_args方式,#*tuple_grp_nonkw_args方式有逻辑先后顺序的.

最后,参数是不允许多次赋值的.

举个例子说明,顺序赋值(positional_args)和列表赋值(*tuple_grp_nonkw_args)的逻辑先后关系:

复制代码

代码如下:

#只有在顺序赋值,列表赋值在结果上存在罗辑先后关系

#正确的例子1

x =

{3,4,5}

test(1,2,*x)

1 2 3 4 5

#正确的例子2

test(1,e=2,*x)

1 3 4 5 2

#错误的例子

test(1,b=2,*x)

Traceback (most recent call

last):

File "stdin", line 1, in module

TypeError: test()

got multiple values for keyword argument 'b'

#正确的例子1,处理等价于

a,b = 1,2 #顺序参数

c,d,e = x #列表参数

print a,b,c,d,e

#正确的例子2,处理等价于

a = 1 #顺序参数

e = 2 #关键字参数

b,c,d = x #列表参数

#错误的例子,处理等价于

a = 1 #顺序参数

b = 2 #关键字参数

b,c,d = x

#列表参数

#这里由于b多次赋值导致异常,可见只有顺序参数和列表参数存在罗辑先后关系

函数声明区别

理解了函数调用中不同类型参数得区别之后,再来理解函数声明中不同参数得区别就简单很多了.

1. 函数声明中的参数类型说明

函数声明只有3种类型, arg, *arg , **arg 他们得作用和函数调用刚好相反.

调用时*tuple_grp_nonkw_args将列表转换为顺序参数,而声明中的*arg的作用是将顺序赋值(positional_args)转换为列表.

调用时**dict_grp_kw_args将字典转换为关键字参数,而声明中**arg则反过来将关键字参数(keyword_args)转换为字典.

特别提醒：*arg

和 **arg可以为空值.

以下举例说明上述规则:

复制代码

代码如下:

#arg, *arg和**arg作用举例

def

test2(a,*b,**c):

print a,b,c

#

#*arg 和

**arg可以不传递参数

test2(1)

1 () {}

#arg必须传递参数

test2()

Traceback (most recent call last):

File "stdin", line 1,

in module

TypeError: test2() takes at least 1 argument (0 given)

#

#*arg将顺positional_args转换为列表

test2(1,2,[1,2],{'a':1,'b':2})

1 (2, [1, 2], {'a': 1, 'b': 2})

{}

#该处理等价于

a = 1 #arg参数处理

b = 2,[1,2],{'a':1,'b':2} #*arg参数处理

c =

dict() #**arg参数处理

print a,b,c

#

#**arg将keyword_args转换为字典

test2(1,2,3,d={1:2,3:4}, c=12, b=1)

1 (2, 3) {'c': 12, 'b': 1, 'd': {1: 2, 3:

4}}

#该处理等价于

a = 1 #arg参数处理

b= 2,3 #*arg参数处理

#**arg参数处理

c =

dict()

c['d'] = {1:2, 3:4}

c['c'] = 12

c['b'] = 1

print

a,b,c

2. 处理顺序问题

函数总是先处理arg类型参数,再处理*arg和**arg类型的参数.

因为*arg和**arg针对的调用参数类型不同,所以不需要考虑他们得顺序.

复制代码

代码如下:

def test2(a,*b,**c):

print

a,b,c

test2(1, b=[1,2,3], c={1:2, 3:4},a=1)

Traceback (most

recent call last):

File "stdin", line 1, in

module

TypeError: test2() got multiple values for keyword argument

'a'

#这里会报错得原因是,总是先处理arg类型得参数

#该函数调用等价于

#处理arg类型参数:

a = 1

a = 1

#多次赋值,导致异常

#处理其他类型参数

...

print a,b,c

def foo(x,y):

... def bar():

... print

x,y

... return bar

...

#查看func_closure的引用信息

a =

[1,2]

b = foo(a,0)

b.func_closure[0].cell_contents

[1, 2]

b.func_closure[1].cell_contents

b()

[1, 2] 0

#可变对象仍然能被修改

a.append(3)

b.func_closure[0].cell_contents

[1, 2, 3]

b()

[1, 2, 3] 0

什么是python多态

让具有不同功能的函数可以使用相同的函数名，这样就可以用一个函数名调用不同内容(功能)的函数。

Python中多态的特点

1、只关心对象的实例方法是否同名，不关心对象所属的类型；

2、对象所属的类之间，继承关系可有可无；

3、多态的好处可以增加代码的外部调用灵活度，让代码更加通用，兼容性比较强；

4、多态是调用方法的技巧，不会影响到类的内部设计。